Package org.opendaylight.yang.gen.v1.http.openconfig.net.yang.network.instance.rev151018

Interface OpenconfigNetworkInstanceData

All Superinterfaces:
org.opendaylight.yangtools.yang.binding.BindingContract<org.opendaylight.yangtools.yang.binding.DataContainer>, org.opendaylight.yangtools.yang.binding.BindingObject, org.opendaylight.yangtools.yang.binding.DataContainer, org.opendaylight.yangtools.yang.binding.DataObject, org.opendaylight.yangtools.yang.binding.DataRoot, NetworkInstanceTop
@Generated("mdsal-binding-generator") public interface OpenconfigNetworkInstanceData extends org.opendaylight.yangtools.yang.binding.DataRoot, NetworkInstanceTop
An OpenConfig description of a network-instance. This may be a Layer 3 forwarding construct such as a virtual routing and forwarding (VRF) instance, a Layer 2 instance such as a virtual switch instance (VSI). Mixed Layer 2 and Layer 3 instances are also supported.

This class represents the following YANG schema fragment defined in module openconfig-network-instance 

 module openconfig-network-instance {
   yang-version 1;
   namespace "http://openconfig.net/yang/network-instance";
   prefix netinst;
   import ietf-yang-types {
     prefix yang;
   }
   import ietf-inet-types {
     prefix inet;
   }
   import openconfig-network-instance-types {
     prefix nit;
   }
   import openconfig-policy-types {
     prefix pt;
   }
   import openconfig-routing-policy {
     prefix rpol;
   }
   import openconfig-local-routing {
     prefix lroute;
   }
   import openconfig-interfaces {
     prefix ocif;
   }
   import openconfig-extensions {
     prefix ocext;
   }
   ocext:openconfig-version 0.1.0;
   revision 2015-10-18 {
   }
   grouping network-instance-top {
     container network-instances {
       list network-instance {
         key name;
         leaf name {
           type leafref {
             path ../config/name;
           }
         }
         container config {
           uses network-instance-config;
           uses network-instance-l3vrf-config {
             when "../type = 'L3VRF'" {
             }
           }
         }
         container state {
           config false;
           uses network-instance-config;
           uses network-instance-l3vrf-config {
             when "../type = 'L3VRF'" {
             }
           }
           uses network-instance-state;
         }
         container inter-instance-policies {
           uses rpol:apply-policy-group;
         }
         container table-connections {
           list table-connection {
             key "src-table dst-table";
             leaf src-table {
               type leafref {
                 path ../config/src-table;
               }
             }
             leaf dst-table {
               type leafref {
                 path ../config/dst-table;
               }
             }
             container config {
               uses inter-table-policies-config;
             }
             container state {
               config false;
               uses inter-table-policies-config;
             }
             uses rpol:apply-policy-group;
           }
         }
         container tables {
           list table {
             key table-name;
             leaf table-name {
               type leafref {
                 path ../config/table-name;
               }
             }
             container config {
               uses table-config;
             }
             container state {
               config false;
               uses table-config;
             }
           }
         }
         container interfaces {
           container config {
             uses instance-interfaces-config;
           }
           container state {
             config false;
             uses instance-interfaces-config;
             uses instance-interfaces-state;
           }
         }
         container connection-points {
           list connection-point {
             key connection-point-id;
             leaf connection-point-id {
               type leafref {
                 path ../config/connection-point-id;
               }
             }
             container config {
               uses instance-connection-point-config;
             }
             container state {
               config false;
               uses instance-connection-point-config;
               uses instance-connection-point-state;
             }
             container endpoints {
               when "../config/type = 'L2P2P' or ../config/type = 'L2VSI'" {
               }
               list endpoint {
                 key endpoint-id;
                 leaf endpoint-id {
                   type leafref {
                     path ../config/endpoint-id;
                   }
                 }
                 container config {
                   uses instance-endpoint-config;
                 }
                 container state {
                   config false;
                   uses instance-endpoint-config;
                   uses instance-endpoint-state;
                 }
               }
             }
           }
         }
         container protocols {
           list protocol {
             key "identifier name";
             leaf identifier {
               type leafref {
                 path ../config/identifier;
               }
             }
             leaf name {
               type leafref {
                 path ../config/name;
               }
             }
             container config {
               uses protocols-config;
             }
             container state {
               config false;
               uses protocols-config;
               uses protocols-state;
             }
             container static {
               when "../config/identifier = 'STATIC'" {
               }
               uses lroute:local-static-top;
             }
             container aggregate {
               when "../config/identifier = 'LOCAL-AGGREGATE'" {
               }
               uses lroute:local-aggregate-top;
             }
           }
         }
       }
     }
   }
   grouping instance-endpoint-config {
     leaf endpoint-id {
       type string;
     }
     uses instance-endpoint-local-remote;
     leaf precedence {
       type uint16;
     }
   }
   grouping instance-endpoint-local-remote {
     choice local-remote {
       case local {
         leaf interface {
           type leafref {
             path /network-instances/network-instance/interfaces/config/interface;
           }
         }
       }
       case remote {
         leaf neighbor {
           type inet:ip-address;
         }
         leaf virtual-circuit-identifier {
           type uint32;
         }
       }
     }
   }
   grouping instance-endpoint-state {
     leaf active {
       type boolean;
     }
   }
   grouping instance-connection-point-config {
     leaf connection-point-id {
       type string;
     }
   }
   grouping instance-connection-point-state {
   }
   grouping table-config {
     leaf table-name {
       type string;
     }
   }
   grouping table-state {
   }
   grouping inter-table-policies-config {
     leaf src-table {
       type string;
     }
     leaf dst-table {
       type string;
     }
   }
   grouping network-instance-config {
     leaf name {
       type string;
     }
     leaf type {
       type identityref {
         base network-instance-type;
       }
     }
     leaf enabled {
       type boolean;
     }
     leaf description {
       type string;
     }
     leaf router-id {
       type yang:dotted-quad;
     }
     leaf route-distinguisher {
       type nit:route-distinguisher;
     }
   }
   grouping network-instance-state {
   }
   grouping network-instance-l3vrf-config {
   }
   grouping protocols-config {
     leaf identifier {
       type identityref {
         base install-protocol-type;
       }
     }
     leaf name {
       type string;
     }
     leaf enabled {
       type boolean;
     }
     leaf target-table {
       type string;
     }
   }
   grouping protocols-state {
   }
   grouping instance-interfaces-config {
     leaf-list interface {
       type leafref {
         path /ocif:interfaces/ocif:interface/ocif:name;
       }
     }
   }
   grouping instance-interfaces-state {
   }
   uses network-instance-top;
 }