module openconfig-network-instance {

    yang-version 1;

    namespace
      "http://openconfig.net/yang/network-instance";

    prefix oc-netinst;

    import ietf-yang-types {
      prefix yang;
    }
    import ietf-inet-types {
      prefix inet;
    }
    import openconfig-network-instance-types {
      prefix oc-ni-types;
    }
    import openconfig-policy-types {
      prefix oc-pol-types;
    }
    import openconfig-routing-policy {
      prefix oc-rpol;
    }
    import openconfig-local-routing {
      prefix oc-loc-rt;
    }
    import openconfig-interfaces {
      prefix oc-if;
    }
    import openconfig-extensions {
      prefix oc-ext;
    }
    import openconfig-network-instance-l3 {
      prefix oc-ni-l3;
    }
    import openconfig-types {
      prefix oc-types;
    }
    import openconfig-bgp {
      prefix oc-bgp;
    }
    import openconfig-mpls {
      prefix oc-mpls;
    }
    import openconfig-vlan {
      prefix oc-vlan;
    }
    import openconfig-segment-routing {
      prefix oc-sr;
    }
    import openconfig-isis {
      prefix oc-isis;
    }
    import openconfig-aft {
      prefix oc-aft;
    }

    include openconfig-network-instance-l2;

    organization "OpenConfig working group";

    contact
      "OpenConfig working group
www.openconfig.net";

    description
      "An OpenConfig description of a network-instance. This may be
a Layer 3 forwarding construct such as a virtual routing and
forwarding (VRF) instance, or a Layer 2 instance such as a
virtual switch instance (VSI). Mixed Layer 2 and Layer 3
instances are also supported.";

    revision "2017-01-13" {
      description
        "Add AFT to the network instance";
      reference
        "0.6.0";

    }

    revision "2016-12-15" {
      description
        "Add segment routing to network instance";
      reference
        "0.5.0";

    }

    revision "2016-11-10" {
      description
        "Add IS-IS to OpenConfig network instance";
      reference
        "0.4.1";

    }

    revision "2016-10-12" {
      description "Update table connections";
      reference
        "0.4.0";

    }

    revision "2016-09-28" {
      description
        "Change L2 instance to submodule; add MAC table";
      reference
        "0.3.0";

    }

    revision "2016-08-11" {
      description
        "Resolve repeated container names in routing protocols";
      reference
        "0.2.3";

    }

    revision "2016-07-08" {
      description
        "Updated with refactored routing protocol models";
      reference
        "0.2.1";

    }

    revision "2016-03-29" {
      description "Initial revision";
      reference
        "0.2.0";

    }

    revision "2015-10-18" {
      description "Initial revision";
      reference
        "0.1.0";

    }

    oc-ext:openconfig-version "0.6.0";

    typedef network-instance-ref {
      type leafref {
        path "/network-instances/network-instance/config/name";
      }
      description
        "A re-usable type that can be referenced within other
modules that references a network instance.";
    }

    grouping network-instance-top {
      description
        "Top-level grouping containing a list of network instances.";
      container network-instances {
        description
          "The L2, L3, or L2+L3 forwarding instances that are
configured on the local system";
        list network-instance {
          key "name";
          description
            "Network instances configured on the local system";
          leaf name {
            type leafref {
              path "../config/name";
            }
            description
              "A unique name identifying the network instance";
          }

          uses l2ni-instance {
            when
              "config/type = 'L2VSI' or config/type = 'L2P2P' or config/type = 'L2L3' or config/type = 'DEFAULT_INSTANCE'" {
              description
                "Layer 2 configuration parameters included when
a network instance is a Layer 2 instance or a
combined L2L3 instance";
            }
          }

          container config {
            description
              "Configuration parameters relating to a network
instance";
            uses network-instance-config;

            uses network-instance-type-dependent-config;
          }  // container config

          container state {
            config false;
            description
              "Operational state parameters relating to a network
instance";
            uses network-instance-config;

            uses network-instance-type-dependent-config;

            uses network-instance-state;
          }  // container state

          container encapsulation {
            when
              "../config/type != 'DEFAULT_INSTANCE'" {
              description
                "Only allow the encapsulation of the instance to be
set when the instance is not the default instance";
            }
            description
              "Configuration parameters relating to the encapsulation
used for the network instance";
            container config {
              description
                "Configuration parameters relating to the encapsulation
of the network instance";
              uses encapsulation-config;

              uses l2ni-encapsulation-config {
                when
                  "../../oc-netinst:config/oc-netinst:type = 'L2VSI' or ../../oc-netinst:config/oc-netinst:type = 'L2P2P'
  or ../../oc-netinst:config/oc-netinst:type = 'L2L3'" {
                  description
                    "Only allow L2 encapsulations to be set
when the instance is of a type that supports
L2";
                }
              }
            }  // container config

            container state {
              config false;
              description
                "State parameters relating to the encapsulation of
the network instance";
              uses encapsulation-config;

              uses l2ni-encapsulation-config {
                when
                  "../../oc-netinst:config/oc-netinst:type = 'L2VSI' or ../../oc-netinst:config/oc-netinst:type = 'L2P2P'
 or ../../oc-netinst:config/oc-netinst:type = 'L2L3'" {
                  description
                    "Only allow L2 encapsulations to be set
when the instance is of a type that supports
L2";
                }
              }
            }  // container state
          }  // container encapsulation

          container inter-instance-policies {
            description
              "Policies dictating how RIB or FIB entries are imported
to and exported from this instance";
            uses oc-rpol:apply-policy-group;
          }  // container inter-instance-policies

          container table-connections {
            description
              "Policies dictating how RIB or FIB entries are propagated
between tables";
            list table-connection {
              key "src-protocol dst-protocol address-family";
              description
                "A list of connections between pairs of routing or
forwarding tables, the leaking of entries between
which is specified by the import policy.

A connection connecting a source table to a destination
table implies that routes that match the policy specified
for the connection are available for the destination
protocol to advertise, or match within its policies.";
              leaf src-protocol {
                type leafref {
                  path
                    "../config/src-protocol";
                }
                description
                  "The name of the protocol associated with the table
which should be utilised as the source of forwarding
or routing information";
              }

              leaf dst-protocol {
                type leafref {
                  path
                    "../config/dst-protocol";
                }
                description
                  "The table to which routing entries should be
exported";
              }

              leaf address-family {
                type leafref {
                  path
                    "../config/address-family";
                }
                description
                  "The address family associated with the connection";
              }

              container config {
                description
                  "Configuration parameters relating to the connection
between tables";
                uses inter-table-policies-config;
              }  // container config

              container state {
                config false;
                description
                  "State parameters relating to the connection between
tables";
                uses inter-table-policies-config;
              }  // container state
            }  // list table-connection
          }  // container table-connections

          container interfaces {
            description
              "The interfaces that are associated with this network
instance";
            list interface {
              key "id";
              unique "config/interface config/subinterface";
              description
                "An interface associated with the network instance";
              leaf id {
                type leafref {
                  path "../config/id";
                }
                description
                  "A reference to an identifier for this interface which
acts as a key for this list";
              }

              container config {
                description
                  "Configuration parameters relating to the associated
interface";
                uses instance-interfaces-config;
              }  // container config

              container state {
                config false;
                description
                  "Operational state parameters relating to the
associated interface";
                uses instance-interfaces-config;

                uses instance-interfaces-state;
              }  // container state
            }  // list interface
          }  // container interfaces

          container tables {
            description
              "The routing tables that are managed by this network
instance";
            list table {
              key "protocol address-family";
              description
                "A network instance manages one or more forwarding or
routing tables. These may reflect a Layer 2 forwarding
information base, a Layer 3 routing table, or an MPLS
LFIB.

The table populated by a protocol within an instance is
identified by the protocol identifier (e.g., BGP, IS-IS)
and the address family (e.g., IPv4, IPv6) supported by
that protocol. Multiple instances of the same protocol
populate a single table -- such that
a single IS-IS or OSPF IPv4 table exists per network
instance.

An implementation is expected to create entries within
this list when the relevant protocol context is enabled.
i.e., when a BGP instance is created with IPv4 and IPv6
address families enabled, the protocol=BGP,
address-family=IPv4 table is created by the system.";
              leaf protocol {
                type leafref {
                  path "../config/protocol";
                }
                description
                  "A reference to the protocol that populates
the table";
              }

              leaf address-family {
                type leafref {
                  path
                    "../config/address-family";
                }
                description
                  "A reference to the address-family that the
table represents";
              }

              container config {
                description
                  "Configuration parameters relating to the
table";
                uses table-config;
              }  // container config

              container state {
                config false;
                description
                  "State parameters related to the table";
                uses table-config;
              }  // container state
            }  // list table
          }  // container tables

          container connection-points {
            description
              "The set of connection points within a forwarding
instance";
            list connection-point {
              key "connection-point-id";
              description
                "A connection point within a Layer 2 network instance.
Each connection-point consists of a set of interfaces
only one of which is active at any one time. Other than
the specification of whether an interface is local
(i.e., exists within this network-instance), or remote,
all configuration and state parameters are common";
              leaf connection-point-id {
                type leafref {
                  path
                    "../config/connection-point-id";
                }
                description
                  "A locally significant reference for the
connection-point";
              }

              container config {
                description
                  "Configuration parameters relating to a Layer 2
network instance connection point";
                uses instance-connection-point-config;
              }  // container config

              container state {
                config false;
                description
                  "Operational state parameters relating to a Layer 2
network instance connection point";
                uses instance-connection-point-config;

                uses instance-connection-point-state;
              }  // container state

              container endpoints {
                when
                  "../../../config/type = 'oc-ni-types:L2P2P' or ../../../config/type = 'oc-ni-types:L2VSI'" {
                  description
                    "Configuration parameters to associate interfaces
into a common group for use in Layer 2 network
instances";
                }
                description
                  "The set of endpoints which are grouped within the
connection point";
                list endpoint {
                  key "endpoint-id";
                  description
                    "A list of the endpoints (interfaces or remote
connection points that can be used for this
connection point). The active endpoint is selected
based on the precedence that it is configured
with";
                  leaf endpoint-id {
                    type leafref {
                      path
                        "../config/endpoint-id";
                    }
                    description
                      "A pointer to the configured identifier for the
endpoint";
                  }

                  container config {
                    description
                      "Configuration parameters relating to the
endpoint";
                    uses instance-endpoint-config;
                  }  // container config

                  container state {
                    config false;
                    description
                      "Operational state parameters relating to the
endpoint";
                    uses instance-endpoint-config;

                    uses instance-endpoint-state;
                  }  // container state

                  container local {
                    when
                      "../config/type = 'LOCAL'" {
                      description
                        "Only include the local configuration when
the endpoint is specified to be local to
the network element";
                    }
                    description
                      "Configuration and operational state parameters
relating to a local interface";
                    container config {
                      description
                        "Configuration parameters relating to a local
endpoint";
                      uses instance-endpoint-local-config;
                    }  // container config

                    container state {
                      config false;
                      description
                        "Operational state parameters relating to a
local endpoint";
                      uses instance-endpoint-local-config;
                    }  // container state
                  }  // container local

                  container remote {
                    when
                      "../config/type = 'REMOTE'" {
                      description
                        "Only include the remote configuration when
the endpoint is specified to be remote to
the network element";
                    }
                    description
                      "Configuration and operational state parameters
relating to a remote interface";
                    container config {
                      description
                        "Configuration parameters relating to a remote
endpoint";
                      uses instance-endpoint-remote-config;
                    }  // container config

                    container state {
                      config false;
                      description
                        "Operational state parameters relating to
a remote endpoint";
                      uses instance-endpoint-remote-config;
                    }  // container state
                  }  // container remote
                }  // list endpoint
              }  // container endpoints
            }  // list connection-point
          }  // container connection-points

          uses oc-mpls:mpls-top {
            when "config/type = 'DEFAULT'" {
              description
                "MPLS configuration is only valid within the default
network instance.";
            }
          }

          uses oc-sr:sr-top {
            when "config/type = 'DEFAULT'" {
              description
                "Segment routing configuration is only valid with the default
network instance.";
            }
          }

          uses oc-vlan:vlan-top;

          uses oc-aft:aft-top;

          container protocols {
            description
              "The routing protocols that are enabled for this
network-instance.";
            list protocol {
              key "identifier name";
              description
                "A process (instance) of a routing protocol. Some
systems may not support more than one instance of
a particular routing protocol";
              leaf identifier {
                type leafref {
                  path
                    "../config/identifier";
                }
                description
                  "The protocol name for the routing or forwarding
protocol to be instantiated";
              }

              leaf name {
                type leafref {
                  path "../config/name";
                }
                description
                  "An operator-assigned identifier for the routing
or forwarding protocol. For some processes this
leaf may be system defined.";
              }

              container config {
                description
                  "Configuration parameters relating to the routing
protocol instance";
                uses protocols-config;
              }  // container config

              container state {
                config false;
                description
                  "State parameters relating to the routing protocol
instance";
                uses protocols-config;

                uses protocols-state;
              }  // container state

              uses oc-loc-rt:local-static-top {
                when
                  "config/identifier = 'oc-pol-types:STATIC'" {
                  description
                    "Include static route parameters only when the
protocol is set to static";
                }
                description
                  "Configuration and state parameters relating to
static routes";
              }

              uses oc-loc-rt:local-aggregate-top {
                when
                  "config/identifier = 'oc-pol-types:LOCAL-AGGREGATE'" {
                  description
                    "Include aggregate route parameters only when the
protocol is set to aggregate";
                }
                description
                  "Configuration and state parameters relating to
locally generated aggregate routes";
              }

              uses oc-bgp:bgp-top {
                when
                  "config/identifier = 'oc-pol-types:BGP'" {
                  description
                    "Include BGP parameters only when the protocol
is of type BGP";
                }
                description
                  "Configuration and state parameters relating to
Border Gateway Protocol (BGP)";
              }

              uses oc-isis:isis-top {
                when
                  "config/identifier = 'ISIS'" {
                  description
                    "Include IS-IS configuration when the protocol is of type
IS-IS";
                }
                description
                  "Configuration and state parameters relating to Intermediate
System to Intermediate System (IS-IS).";
              }
            }  // list protocol
          }  // container protocols
        }  // list network-instance
      }  // container network-instances
    }  // grouping network-instance-top

    grouping network-instance-type-dependent-config {
      description
        "Type dependent network instance configuration";
      uses oc-ni-l3:l3ni-instance-common-config {
        when
          "../config/type = 'oc-ni-types:L3VRF' or ../config/type = 'oc-ni-types:L2L3'" {
          description
            "Layer 3 VRF configuration parameters included when a
network instance is a L3VRF or combined L2L3 instance";
        }
      }

      uses l2ni-instance-common-config {
        when
          "../config/type = 'oc-ni-types:L2VSI' or ../config/type = 'oc-ni-types:L2P2P' or ../config/type = 'oc-ni-types:L2L3'" {
          description
            "Layer 2 configuration parameters included when
a network instance is a Layer 2 instance or a
combined L2L3 instance";
        }
      }
    }  // grouping network-instance-type-dependent-config

    grouping instance-endpoint-config {
      description
        "Configuration data relating to an forwarding-instance
endpoint";
      leaf endpoint-id {
        type string;
        description
          "An identifier for the endpoint";
      }

      leaf precedence {
        type uint16;
        description
          "The precedence of the endpoint - the lowest precendence
viable endpoint will be utilised as the active endpoint
within a connection";
      }

      leaf type {
        type identityref {
          base oc-ni-types:ENDPOINT_TYPE;
        }
        description
          "The type of endpoint that is referred to by the current
endpoint";
      }
    }  // grouping instance-endpoint-config

    grouping instance-endpoint-local-config {
      description
        "Configuration parameters relating to an endpoint that is local
to the current system";
      uses oc-if:interface-ref-common;
    }  // grouping instance-endpoint-local-config

    grouping instance-endpoint-remote-config {
      description
        "Configuration parameters relating to an endpoint that is
remote from the local system";
      leaf remote-system {
        type inet:ip-address;
        description
          "The IP address of the device which hosts the
remote end-point";
      }

      leaf virtual-circuit-identifier {
        type uint32;
        description
          "The virtual-circuit identifier that identifies the
connection at the remote end-point";
      }
    }  // grouping instance-endpoint-remote-config

    grouping instance-endpoint-state {
      description
        "Operational state data relating to a forwarding-instance
endpoint";
      leaf active {
        type boolean;
        description
          "When the backup endpoint is active, the value of this
parameter is set to true";
      }
    }  // grouping instance-endpoint-state

    grouping instance-connection-point-config {
      description
        "Configuration data relating to a forwarding-instance
connection point";
      leaf connection-point-id {
        type string;
        description
          "An identifier for a connection point";
      }
    }  // grouping instance-connection-point-config

    grouping instance-connection-point-state {
      description
        "Operational state data relating to a forwarding-instance
connection point";
    }  // grouping instance-connection-point-state

    grouping table-config {
      description
        "Config parameters relating to an L2/L2.5/L3 table that exists
within a network instance";
      leaf protocol {
        type leafref {
          path
            "../../../../protocols/protocol/config/identifier";
        }
        description
          "Reference to the protocol that the table is associated with.";
      }

      leaf address-family {
        type identityref {
          base oc-types:ADDRESS_FAMILY;
        }
        description
          "The address family (IPv4, IPv6) of the table's entries";
      }
    }  // grouping table-config

    grouping instance-interfaces-config {
      description
        "Configuration parameters related to an interface associated
with the network instance";
      leaf id {
        type string;
        description
          "A unique identifier for this interface - this is expressed
as a free-text string";
      }

      uses oc-if:interface-ref-common;

      leaf-list associated-address-families {
        type identityref {
          base oc-types:ADDRESS_FAMILY;
        }
        description
          "The address families on the subinterface which are to be
associated with this network instance. When this leaf-list
is empty and the network instance requires Layer 3 information
the address families for which the network instance is
enabled should be imported. If the value of this leaf-list
is specified then the association MUST only be made for
those address families that are included in the list.";
      }
    }  // grouping instance-interfaces-config

    grouping instance-interfaces-state {
      description
        "Operational state parameters relating to an interface
associated with this network instance";
    }  // grouping instance-interfaces-state

    grouping inter-table-policies-config {
      description
        "Configuration entries that relate to how RIB or FIB entries
are propagated between tables within the same network
instance";
      leaf src-protocol {
        type leafref {
          path
            "../../../../tables/table/config/protocol";
        }
        description
          "The source protocol for the table connection";
      }

      leaf address-family {
        type leafref {
          path
            "../../../../tables/table[protocol=current()/../src-protocol]/config/address-family";
        }
        description
          "The address family associated with the connection. This
must be defined for the source protocol. The target
address family is implicitly defined by the address family
specified for the source protocol.";
      }

      leaf dst-protocol {
        type leafref {
          path
            "../../../../tables/table/config/protocol";
        }
        description
          "The destination protocol for the table connection";
      }

      uses oc-rpol:apply-policy-import-config;
    }  // grouping inter-table-policies-config

    grouping network-instance-config {
      description
        "Configuration parameters relating to a top-level network
instance";
      leaf name {
        type string;
        description
          "An operator-assigned unique name for the forwarding
instance";
      }

      leaf type {
        type identityref {
          base oc-ni-types:NETWORK_INSTANCE_TYPE;
        }
        description
          "The type of network instance. The value of this leaf
indicates the type of forwarding entries that should be
supported by this network instance";
      }

      leaf enabled {
        type boolean;
        description
          "Whether the network instance should be configured to be
active on the network element";
      }

      leaf description {
        type string;
        description
          "A free-form string to be used by the network operator to
describe the function of this network instance";
      }

      leaf router-id {
        type yang:dotted-quad;
        description
          "A identifier for the local network instance - typically
used within associated routing protocols or signalling
routing information in another network instance";
      }

      leaf route-distinguisher {
        type oc-ni-types:route-distinguisher;
        description
          "The route distinguisher that should be used for the local
VRF or VSI instance when it is signalled via BGP.";
      }
    }  // grouping network-instance-config

    grouping network-instance-state {
      description
        "Operational state parameters relating to a network instance";
    }  // grouping network-instance-state

    grouping protocols-config {
      description
        "Configuration parameters relating to a generic protocol
instance within a network instance";
      leaf identifier {
        type identityref {
          base oc-pol-types:INSTALL_PROTOCOL_TYPE;
        }
        description
          "The protocol identifier for the instance";
      }

      leaf name {
        type string;
        description
          "A unique name for the protocol instance";
      }

      leaf enabled {
        type boolean;
        description
          "A boolean value indicating whether the local protocol
instance is enabled.";
      }

      leaf default-metric {
        type uint32;
        description
          "The default metric within the RIB for entries that are
installed by this protocol instance. This value may
be overridden by protocol specific configuration options.
The lower the metric specified the more preferable the RIB
entry is to be selected for use within the network instance.
Where multiple entries have the same metric value then these
equal cost paths should be treated according to the specified
ECMP path selection behaviour for the instance";
      }
    }  // grouping protocols-config

    grouping protocols-state {
      description
        "Operational state parameters relating to a protocol instance";
    }  // grouping protocols-state

    grouping instance-interface-association-config {
      description
        "Grouping containing leaves that are to be augmented into an
interface or subinterface to include mapping to a network
instance";
      leaf network-instance {
        type leafref {
          path
            "/network-instances/network-instance/name";
        }
        description
          "The network instance that this interface is associated
with";
      }
    }  // grouping instance-interface-association-config

    grouping encapsulation-config {
      description
        "Type agnostic configuration parameters relating to the
encapsulation of the network instance";
      leaf encapsulation-type {
        type identityref {
          base oc-ni-types:ENCAPSULATION;
        }
        description
          "The on-the-wire encapsulation that should be used when
sending traffic from this network instance";
      }

      leaf label-allocation-mode {
        type identityref {
          base oc-ni-types:LABEL_ALLOCATION_MODE;
        }
        description
          "The label allocation mode to be used for L3 entries
in the network instance";
      }
    }  // grouping encapsulation-config

    uses network-instance-top;
  }  // module openconfig-network-instance