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

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

This class represents the following YANG schema fragment defined in module odl-l3vpn

 module odl-l3vpn {
   namespace urn:opendaylight:netvirt:l3vpn;
   prefix odl-l3vpn;
   import yang-ext {
     prefix ext;
     revision-date 2013-07-09;
   }
   import l3vpn {
     prefix l3vpn;
     revision-date 2014-08-15;
   }
   import ietf-yang-types {
     prefix yang;
     revision-date 2013-07-15;
   }
   import odl-interface {
     prefix odlif;
     revision-date 2016-04-06;
   }
   import neutronvpn {
     prefix nvpn;
     revision-date 2015-06-02;
   }
   import l3vpn-instances-interfaces {
     prefix nvpn-l3vpn;
     revision-date 2020-02-04;
   }
   revision 2013-09-11 {
   }
   grouping vpn-route-list {
     leaf-list route-entry-id {
       type uint32;
     }
   }
   container prefix-to-interface {
     config false;
     list vpn-ids {
       key vpn-id;
       leaf vpn-id {
         type uint32;
       }
       list prefixes {
         key ip_address;
         leaf ip_address {
           type string;
         }
         leaf dpnId {
           type uint64;
         }
         leaf vpn-interface-name {
           type string;
         }
         uses nvpn:network-attributes;
         leaf prefix-cue {
           type enumeration {
             enum none {
               value 0;
             }
             enum nat {
               value 1;
             }
             enum phys-net-func {
               value 2;
             }
             enum subnet-route {
               value 3;
             }
           }
           default none;
         }
       }
     }
   }
   container vpn-to-extraroutes {
     config false;
     list vpn {
       key vpn-name;
       leaf vpn-name {
         type string;
       }
       list extra-routes {
         key vrf-id;
         leaf vrf-id {
           type string;
         }
         list routes {
           key prefix;
           leaf prefix {
             type string;
           }
           leaf-list nexthop-ip-list {
             type string;
           }
         }
       }
     }
   }
   container vpn-instance-to-vpn-id {
     list vpn-instance {
       key vpn-instance-name;
       leaf vpn-instance-name {
         type string;
       }
       leaf vpn-id {
         type uint32;
       }
       leaf vrf-id {
         type string;
       }
     }
   }
   container vpn-id-to-vpn-instance {
     list vpn-ids {
       key vpn-id;
       leaf vpn-id {
         type uint32;
       }
       leaf vpn-instance-name {
         type string;
       }
       leaf vrf-id {
         type string;
       }
       leaf external-vpn {
         type boolean;
       }
     }
   }
   container evpn-rd-to-networks {
     list evpn-rd-to-network {
       key rd;
       leaf rd {
         type string;
       }
       leaf network-id {
         type string;
       }
     }
   }
   container vpn-interface-op-data {
     config false;
     list vpn-interface-op-data-entry {
       key "name vpn-instance-name";
       leaf name {
         type string;
       }
       leaf vpn-instance-name {
         type string {
           length 1..40;
         }
       }
       leaf dpn-id {
         type uint64;
       }
       leaf router-interface {
         type boolean;
       }
       leaf gateway-mac-address {
         type string;
       }
       leaf gateway-ip-address {
         type string;
       }
       leaf lport-tag {
         type uint32;
       }
       leaf vpn-interface-state {
         type enumeration {
           enum active {
             value 0;
           }
           enum inactive {
             value 1;
           }
         }
         default active;
       }
     }
   }
   augment /odl-l3vpn:vpn-interface-op-data/odl-l3vpn:vpn-interface-op-data-entry {
     ext:augment-identifier adjacencies-op;
     uses nvpn-l3vpn:adjacency-list;
   }
   container vpn-instance-op-data {
     config false;
     list vpn-instance-op-data-entry {
       key vrf-id;
       leaf vpn-id {
         type uint32;
       }
       leaf vrf-id {
         type string;
       }
       leaf vpn-instance-name {
         type string;
       }
       leaf vpn-interface-count {
         type uint32;
       }
       uses vpn-route-list;
       list vpn-to-dpn-list {
         key dpnId;
         leaf dpnId {
           type uint64;
         }
         list vpn-interfaces {
           key interface-name;
           leaf interface-name {
             type string;
           }
         }
         list ip-addresses {
           key ip-address;
           leaf ip-address {
             type string;
           }
           leaf ip-address-source {
             type enumeration {
               enum ExternalFixedIP;
               enum FloatingIP;
             }
           }
         }
         leaf dpn-state {
           type enumeration {
             enum active {
               value 0;
             }
             enum inactive {
               value 1;
             }
           }
           default active;
         }
       }
       leaf ipv4-configured {
         type boolean;
         default false;
       }
       leaf ipv6-configured {
         type boolean;
         default false;
       }
       leaf bgpvpn-type {
         type enumeration {
           enum BGPVPNInternet {
             value 0;
           }
           enum BGPVPNExternal {
             value 1;
           }
           enum VPN {
             value 2;
           }
         }
       }
       leaf type {
         type enumeration {
           enum l3 {
             value 0;
           }
           enum l2 {
             value 1;
           }
         }
         default l3;
       }
       leaf l3vni {
         type uint32;
       }
       container vpnTargets {
         list vpnTarget {
           key vrfRTValue;
           leaf vrfRTValue {
             type string {
               length 3..21;
             }
           }
           leaf vrfRTType {
             type enumeration {
               enum export_extcommunity {
                 value 0;
               }
               enum import_extcommunity {
                 value 1;
               }
               enum both {
                 value 2;
               }
             }
           }
         }
       }
       leaf vpn-state {
         type enumeration {
           enum created {
             value 0;
           }
           enum pending_delete {
             value 3;
           }
         }
         default created;
       }
       leaf-list rd {
         type string;
       }
     }
   }
   typedef task-state {
     type enumeration {
       enum idle {
         value 0;
       }
       enum pending_advertise {
         value 1;
       }
       enum pending_withdraw {
         value 2;
       }
       enum advertised {
         value 3;
       }
       enum withdrawn {
         value 4;
       }
     }
   }
   container subnet-op-data {
     config false;
     list subnet-op-data-entry {
       key subnet-id;
       leaf subnet-id {
         type yang:uuid;
       }
       leaf nh-dpnId {
         type uint64;
       }
       leaf vpn-name {
         type string;
       }
       leaf vrf-id {
         type string;
       }
       leaf subnet-cidr {
         type string;
       }
       leaf route-adv-state {
         type task-state;
       }
       leaf last-adv-state {
         type task-state;
       }
       leaf elan-tag {
         type uint32;
       }
       list subnet-to-dpn {
         key dpnId;
         leaf dpnId {
           type uint64;
         }
         list vpn-interfaces {
           key interface-name;
           leaf interface-name {
             type string;
           }
         }
       }
       leaf label {
         type uint32;
       }
       leaf l3vni {
         type uint32;
       }
       uses nvpn:network-attributes;
     }
   }
   container port-op-data {
     config false;
     list port-op-data-entry {
       key port-id;
       leaf port-id {
         type string;
       }
       leaf-list subnet-ids {
         type yang:uuid;
       }
       leaf dpnId {
         type uint64;
       }
     }
   }
   grouping dpn-in-vpn-event {
     leaf dpn-id {
       type uint64;
     }
     leaf vpn-name {
       type string;
     }
     leaf rd {
       type string;
     }
   }
   notification add-dpn-event {
     container add-event-data {
       uses dpn-in-vpn-event;
     }
   }
   notification remove-dpn-event {
     container remove-event-data {
       uses dpn-in-vpn-event;
     }
   }
   notification add-interface-to-dpn-on-vpn-event {
     container add-interface-event-data {
       uses dpn-in-vpn-event;
       leaf interface-name {
         type string;
       }
       leaf vpn-id {
         type uint32;
       }
     }
   }
   notification remove-interface-from-dpn-on-vpn-event {
     container remove-interface-event-data {
       uses dpn-in-vpn-event;
       leaf interface-name {
         type string;
       }
       leaf vpn-id {
         type uint32;
       }
     }
   }
   container conf-transport-type-l3vpn {
     leaf transport-type {
       type identityref {
         base tunnel-type-base;
       }
     }
   }
   container neutron-router-dpns {
     config false;
     list router-dpn-list {
       key router-id;
       leaf router-id {
         type string;
       }
       list dpn-vpninterfaces-list {
         key dpn-id;
         leaf dpn-id {
           type uint64;
         }
         list router-interfaces {
           key interface;
           leaf interface {
             type string;
           }
         }
       }
     }
   }
   container dpn-routers {
     config false;
     list dpn-routers-list {
       key dpn-id;
       leaf dpn-id {
         type uint64;
       }
       list routers-list {
         key router;
         leaf router {
           type string;
         }
       }
     }
   }
   container router-interfaces {
     list router-interface {
       key interface-name;
       leaf interface-name {
         type string;
       }
       leaf router-name {
         type string;
       }
     }
   }
   container learnt-vpn-vip-to-port-data {
     config false;
     list learnt-vpn-vip-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 creation-time {
         type string;
       }
     }
   }
   container evpn-config {
     leaf multi-homing-mode {
       type enumeration {
         enum none;
         enum all-active;
         enum single-active;
       }
       default none;
     }
     leaf irb-mode {
       type enumeration {
         enum symmetric;
         enum asymmetric;
       }
       default symmetric;
     }
   }
   container l3vpn-lb-nexthops {
     config false;
     list nexthops {
       key nexthop-key;
       leaf nexthop-key {
         type string;
       }
       leaf group-id {
         type string;
       }
       leaf-list target-device-id {
         type string;
       }
     }
   }
   container l3vpn-dc-gws {
     config false;
     list dc-gateway {
       key ip-address;
       leaf ip-address {
         type string;
       }
     }
   }
   typedef learnt-vpn-vip-to-port-event-action {
     type enumeration {
       enum add {
         value 0;
       }
       enum delete {
         value 1;
       }
     }
   }
   container learnt-vpn-vip-to-port-event-data {
     config false;
     list learnt-vpn-vip-to-port-event {
       key learnt-vpn-vip-event-id;
       leaf vpn-name {
         type string;
       }
       leaf src-fixedip {
         type string;
       }
       leaf dest-fixedip {
         type string;
       }
       leaf port-name {
         type string;
       }
       leaf mac-address {
         type string;
       }
       leaf event-action {
         type learnt-vpn-vip-to-port-event-action;
       }
       leaf learnt-vpn-vip-event-id {
         type string;
       }
     }
   }
   container subnets-associated-to-route-targets {
     config false;
     list route-target {
       key "rt rt-type";
       leaf rt {
         type string;
       }
       leaf rt-type {
         type enumeration {
           enum iRT {
             value 0;
           }
           enum eRT {
             value 1;
           }
         }
       }
       list associated-subnet {
         key cidr;
         leaf cidr {
           type string;
         }
         list associated-vpn {
           key name;
           leaf name {
             type string;
           }
         }
       }
     }
   }
 }

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method	Description
`@Nullable ConfTransportTypeL3vpn`	`getConfTransportTypeL3vpn()`
`@Nullable DpnRouters`	`getDpnRouters()`
`@Nullable EvpnConfig`	`getEvpnConfig()`
`@Nullable EvpnRdToNetworks`	`getEvpnRdToNetworks()`	Holds the networks to which given evpn is attached
`@Nullable L3vpnDcGws`	`getL3vpnDcGws()`
`@Nullable L3vpnLbNexthops`	`getL3vpnLbNexthops()`
`@Nullable LearntVpnVipToPortData`	`getLearntVpnVipToPortData()`
`@Nullable LearntVpnVipToPortEventData`	`getLearntVpnVipToPortEventData()`
`@Nullable NeutronRouterDpns`	`getNeutronRouterDpns()`
`@Nullable PortOpData`	`getPortOpData()`
`@Nullable PrefixToInterface`	`getPrefixToInterface()`
`@Nullable RouterInterfaces`	`getRouterInterfaces()`
`@Nullable SubnetOpData`	`getSubnetOpData()`
`@Nullable SubnetsAssociatedToRouteTargets`	`getSubnetsAssociatedToRouteTargets()`
`@Nullable VpnIdToVpnInstance`	`getVpnIdToVpnInstance()`
`@Nullable VpnInstanceOpData`	`getVpnInstanceOpData()`
`@Nullable VpnInstanceToVpnId`	`getVpnInstanceToVpnId()`
`@Nullable VpnInterfaceOpData`	`getVpnInterfaceOpData()`
`@Nullable VpnToExtraroutes`	`getVpnToExtraroutes()`

- Method Detail
  - getPrefixToInterface
```
@Nullable PrefixToInterface getPrefixToInterface()
```
    Returns:
    
    org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.PrefixToInterface prefixToInterface, or null if not present
  - getVpnToExtraroutes
```
@Nullable VpnToExtraroutes getVpnToExtraroutes()
```
    Returns:
    
    org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnToExtraroutes vpnToExtraroutes, or null if not present
  - getVpnInstanceToVpnId
```
@Nullable VpnInstanceToVpnId getVpnInstanceToVpnId()
```
    Returns:
    
    org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnInstanceToVpnId vpnInstanceToVpnId, or null if not present
  - getVpnIdToVpnInstance
```
@Nullable VpnIdToVpnInstance getVpnIdToVpnInstance()
```
    Returns:
    
    org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnIdToVpnInstance vpnIdToVpnInstance, or null if not present
  - getEvpnRdToNetworks
```
@Nullable EvpnRdToNetworks getEvpnRdToNetworks()
```
    Holds the networks to which given evpn is attached
    
    Returns:
    
    org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.EvpnRdToNetworks evpnRdToNetworks, or null if not present
  - getVpnInterfaceOpData
```
@Nullable VpnInterfaceOpData getVpnInterfaceOpData()
```
    Returns:
    
    org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnInterfaceOpData vpnInterfaceOpData, or null if not present
  - getVpnInstanceOpData
```
@Nullable VpnInstanceOpData getVpnInstanceOpData()
```
    Returns:
    
    org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnInstanceOpData vpnInstanceOpData, or null if not present
  - getSubnetOpData
```
@Nullable SubnetOpData getSubnetOpData()
```
    Returns:
    
    org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.SubnetOpData subnetOpData, or null if not present
  - getPortOpData
```
@Nullable PortOpData getPortOpData()
```
    Returns:
    
    org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.PortOpData portOpData, or null if not present
  - getConfTransportTypeL3vpn
```
@Nullable ConfTransportTypeL3vpn getConfTransportTypeL3vpn()
```
    Returns:
    
    org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.ConfTransportTypeL3vpn confTransportTypeL3vpn, or null if not present
  - getNeutronRouterDpns
```
@Nullable NeutronRouterDpns getNeutronRouterDpns()
```
    Returns:
    
    org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.NeutronRouterDpns neutronRouterDpns, or null if not present
  - getDpnRouters
```
@Nullable DpnRouters getDpnRouters()
```
    Returns:
    
    org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.DpnRouters dpnRouters, or null if not present
  - getRouterInterfaces
```
@Nullable RouterInterfaces getRouterInterfaces()
```
    Returns:
    
    org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.RouterInterfaces routerInterfaces, or null if not present
  - getLearntVpnVipToPortData
```
@Nullable LearntVpnVipToPortData getLearntVpnVipToPortData()
```
    Returns:
    
    org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.LearntVpnVipToPortData learntVpnVipToPortData, or null if not present
  - getEvpnConfig
```
@Nullable EvpnConfig getEvpnConfig()
```
    Returns:
    
    org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.EvpnConfig evpnConfig, or null if not present
  - getL3vpnLbNexthops
```
@Nullable L3vpnLbNexthops getL3vpnLbNexthops()
```
    Returns:
    
    org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.L3vpnLbNexthops l3vpnLbNexthops, or null if not present
  - getL3vpnDcGws
```
@Nullable L3vpnDcGws getL3vpnDcGws()
```
    Returns:
    
    org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.L3vpnDcGws l3vpnDcGws, or null if not present
  - getLearntVpnVipToPortEventData
```
@Nullable LearntVpnVipToPortEventData getLearntVpnVipToPortEventData()
```
    Returns:
    
    org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.LearntVpnVipToPortEventData learntVpnVipToPortEventData, or null if not present
  - getSubnetsAssociatedToRouteTargets
```
@Nullable SubnetsAssociatedToRouteTargets getSubnetsAssociatedToRouteTargets()
```
    Returns:
    
    org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.SubnetsAssociatedToRouteTargets subnetsAssociatedToRouteTargets, or null if not present

Interface OdlL3vpnData

Method Summary

Method Detail

getPrefixToInterface

getVpnToExtraroutes

getVpnInstanceToVpnId

getVpnIdToVpnInstance

getEvpnRdToNetworks

getVpnInterfaceOpData

getVpnInstanceOpData

getSubnetOpData

getPortOpData

getConfTransportTypeL3vpn

getNeutronRouterDpns

getDpnRouters

getRouterInterfaces

getLearntVpnVipToPortData

getEvpnConfig

getL3vpnLbNexthops

getL3vpnDcGws

getLearntVpnVipToPortEventData

getSubnetsAssociatedToRouteTargets