Interface NeutronvpnData

  • All Superinterfaces:
    org.opendaylight.yangtools.yang.binding.DataRoot

    public interface NeutronvpnData
    extends org.opendaylight.yangtools.yang.binding.DataRoot

    This class represents the following YANG schema fragment defined in module neutronvpn

     module neutronvpn {
       namespace urn:opendaylight:netvirt:neutronvpn;
       prefix neutronvpn;
       import ietf-yang-types {
         prefix yang;
         revision-date 2013-07-15;
       }
       revision 2015-06-02 {
       }
       container subnetmaps {
         list subnetmap {
           key id;
           leaf id {
             type yang:uuid;
           }
           leaf subnet-ip {
             type string;
           }
           uses network-attributes;
           leaf tenant-id {
             type yang:uuid;
           }
           leaf router-id {
             type yang:uuid;
           }
           leaf router-interface-port-id {
             type yang:uuid;
           }
           leaf router-intf-mac-address {
             type string;
           }
           leaf router-interface-fixed-ip {
             type string;
           }
           leaf vpn-id {
             type yang:uuid;
           }
           leaf internet-vpn-id {
             type yang:uuid;
           }
           leaf-list port-list {
             type yang:uuid;
           }
           leaf-list direct-port-list {
             type yang:uuid;
           }
         }
       }
       container networkMaps {
         list networkMap {
           key network-id;
           leaf network-id {
             type yang:uuid;
           }
           leaf-list subnet-id-list {
             type yang:uuid;
           }
         }
       }
       grouping vpn-instance {
         leaf id {
           type yang:uuid;
         }
         leaf name {
           type string;
         }
         leaf tenant-id {
           type yang:uuid;
         }
         leaf-list route-distinguisher {
           type string;
         }
         leaf-list import-RT {
           type string;
         }
         leaf-list export-RT {
           type string;
         }
         list router-ids {
           key router-id;
           leaf router-id {
             type yang:uuid;
           }
         }
         leaf-list network-ids {
           type yang:uuid;
         }
         leaf l3vni {
           type uint32;
         }
       }
       grouping network-attributes {
         leaf network-id {
           type yang:uuid;
         }
         leaf network-type {
           type enumeration {
             enum FLAT;
             enum VLAN;
             enum VXLAN;
             enum GRE;
           }
         }
         leaf segmentation-id {
           type uint32;
         }
         leaf external {
           type boolean;
           default false;
         }
       }
       container vpnMaps {
         list vpnMap {
           key vpn-id;
           leaf vpn-id {
             type yang:uuid;
           }
           leaf name {
             type string;
           }
           leaf tenant-id {
             type yang:uuid;
           }
           list router-ids {
             key router-id;
             leaf router-id {
               type yang:uuid;
             }
           }
           leaf-list network_ids {
             type yang:uuid;
           }
         }
       }
       container neutron-vpn-portip-port-data {
         list vpn-portip-to-port {
           key "vpn-name port-fixedip";
           leaf vpn-name {
             type string;
           }
           leaf port-fixedip {
             type string;
           }
           leaf port-name {
             type string;
           }
           leaf mac-address {
             type string;
           }
           leaf subnet-ip {
             type boolean;
           }
           leaf learnt-ip {
             type boolean;
             default false;
           }
         }
       }
       container neutron-vpn-port-id-subport-data {
         list port-id-to-subport {
           key port-id;
           leaf port-id {
             type yang:uuid;
           }
           leaf vlan-id {
             type uint32;
           }
           leaf trunk-port-id {
             type yang:uuid;
           }
         }
       }
       container router-interfaces-map {
         list router-interfaces {
           key router-id;
           leaf router-id {
             type yang:uuid;
           }
           list interfaces {
             key interface-id;
             leaf interface-id {
               type string;
             }
           }
         }
       }
       container dhcp-config {
         list configs {
           key "lease-duration default-domain";
           leaf lease-duration {
             type int32;
           }
           leaf default-domain {
             type string;
           }
         }
       }
       rpc createL3VPN {
         input input {
           list l3vpn {
             uses vpn-instance;
           }
         }
         output output {
           leaf-list response {
             type string;
           }
         }
       }
       rpc createEVPN {
         input input {
           list evpn {
             uses evpn-instance;
           }
         }
         output output {
           leaf-list response {
             type string;
           }
         }
       }
       grouping evpn-instance {
         leaf id {
           type yang:uuid;
         }
         leaf name {
           type string;
         }
         leaf tenant-id {
           type yang:uuid;
         }
         leaf-list route-distinguisher {
           type string;
         }
         leaf-list import-RT {
           type string;
         }
         leaf-list export-RT {
           type string;
         }
       }
       rpc associateRouter {
         input input {
           leaf vpn-id {
             type yang:uuid;
           }
           list router-ids {
             key router-id;
             min-elements 1;
             leaf router-id {
               type yang:uuid;
             }
           }
         }
       }
       rpc dissociateRouter {
         input input {
           leaf vpn-id {
             type yang:uuid;
           }
           list router-ids {
             key router-id;
             min-elements 1;
             leaf router-id {
               type yang:uuid;
             }
           }
         }
       }
       rpc associateNetworks {
         input input {
           leaf vpn-id {
             type yang:uuid;
           }
           leaf-list network-id {
             type yang:uuid;
           }
         }
         output output {
           leaf response {
             type string;
           }
         }
       }
       rpc dissociateNetworks {
         input input {
           leaf vpn-id {
             type yang:uuid;
           }
           leaf-list network-id {
             type yang:uuid;
           }
         }
         output output {
           leaf response {
             type string;
           }
         }
       }
       rpc getEVPN {
         input input {
           leaf id {
             type yang:uuid;
           }
         }
         output output {
           list evpn-instances {
             uses evpn-instance;
           }
         }
       }
       rpc deleteEVPN {
         input input {
           leaf-list id {
             type yang:uuid;
           }
         }
         output output {
           leaf-list response {
             type string;
           }
         }
       }
       rpc deleteL3VPN {
         input input {
           leaf-list id {
             type yang:uuid;
           }
         }
         output output {
           leaf-list response {
             type string;
           }
         }
       }
       rpc getL3VPN {
         input input {
           leaf id {
             type yang:uuid;
           }
         }
         output output {
           list l3vpn-instances {
             uses vpn-instance;
           }
         }
       }
       rpc get-fixedIPs-for-neutron-port {
         input input {
           leaf port-id {
             type yang:uuid;
           }
         }
         output output {
           leaf-list fixedIPs {
             type string;
           }
         }
       }
     }
     
    • Method Detail

      • getSubnetmaps

        @Nullable Subnetmaps getSubnetmaps()
        Returns:
        org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.Subnetmaps subnetmaps, or null if not present
      • getNetworkMaps

        @Nullable NetworkMaps getNetworkMaps()
        Returns:
        org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NetworkMaps networkMaps, or null if not present
      • getVpnMaps

        @Nullable VpnMaps getVpnMaps()
        Returns:
        org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.VpnMaps vpnMaps, or null if not present
      • getNeutronVpnPortipPortData

        @Nullable NeutronVpnPortipPortData getNeutronVpnPortipPortData()
        Returns:
        org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NeutronVpnPortipPortData neutronVpnPortipPortData, or null if not present
      • getNeutronVpnPortIdSubportData

        @Nullable NeutronVpnPortIdSubportData getNeutronVpnPortIdSubportData()
        Returns:
        org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NeutronVpnPortIdSubportData neutronVpnPortIdSubportData, or null if not present
      • getRouterInterfacesMap

        @Nullable RouterInterfacesMap getRouterInterfacesMap()
        Returns:
        org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.RouterInterfacesMap routerInterfacesMap, or null if not present
      • getDhcpConfig

        @Nullable DhcpConfig getDhcpConfig()
        Returns:
        org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.DhcpConfig dhcpConfig, or null if not present