[email protected]

 module ietf-interfaces-test {

    yang-version 1;

    namespace
      "urn:ietf:interfaces:test";

    prefix test;

    import ietf-yang-types {
      prefix yang;
      revision-date 2013-07-15;
    }
    import ietf-inet-types {
      prefix inet;
      revision-date 2013-07-15;
    }

    revision "2017-09-08" {

    }


    typedef interface-ref {
      type leafref {
        path "/test:interfaces/test:interface/test:name";
      }
      description
        "This type is used by data models that need to reference
       configured interfaces.";
    }

    typedef interface-state-ref {
      type leafref {
        path "/test:interfaces-state/test:interface/test:name";
      }
      description
        "This type is used by data models that need to reference
       the operationally present interfaces.";
    }
    
    typedef ip-address-origin {
      type enumeration {
        enum other {
          description
            "None of the following.";
        }
        enum static {
          description
            "Indicates that the address has been statically
             configured - for example, using NETCONF or a Command Line
             Interface.";
        }
        enum dhcp {
          description
            "Indicates an address that has been assigned to this
             system by a DHCP server.";
        }
        enum link-layer {
          description
            "Indicates an address created by IPv6 stateless
             autoconfiguration that embeds a link-layer address in its
             interface identifier.";
        }
        enum random {
          description
            "Indicates an address chosen by the system at

             random, e.g., an IPv4 address within 169.254/16, an
             RFC 4941 temporary address, or an RFC 7217 semantically
             opaque address.";
          reference
            "RFC 4941: Privacy Extensions for Stateless Address
                       Autoconfiguration in IPv6
             RFC 7217: A Method for Generating Semantically Opaque
                       Interface Identifiers with IPv6 Stateless
                       Address Autoconfiguration (SLAAC)";
        }
      }
      description
        "The origin of an address.";
    }
    
    typedef neighbor-origin {
      type enumeration {
        enum other {
          description
            "None of the following.";
        }
        enum static {
          description
            "Indicates that the mapping has been statically
             configured - for example, using NETCONF or a Command Line
             Interface.";
        }
        enum dynamic {
          description
            "Indicates that the mapping has been dynamically resolved
             using, e.g., IPv4 ARP or the IPv6 Neighbor Discovery
             protocol.";
        }
      }
      description
        "The origin of a neighbor entry.";
    }

    identity interface-type {
      description
        "Base identity from which specific interface types are
       derived.";
    }

    feature arbitrary-names {
      description
        "This feature indicates that the device allows user-controlled
       interfaces to be named arbitrarily.";
    }

    feature pre-provisioning {
      description
        "This feature indicates that the device supports
       pre-provisioning of interface configuration, i.e., it is
       possible to configure an interface whose physical interface
       hardware is not present on the device.";
    }

    feature if-mib {
      description
        "This feature indicates that the device implements
       the IF-MIB.";
      reference
        "RFC 2863: The Interfaces Group MIB";

    }

    grouping interfaces-state {
      description
        "Data nodes for the operational state of interfaces.";
      list interface {
        key "name";
        ordered-by user;
        description
          "The list of interfaces on the device.

         System-controlled interfaces created by the system are
         always present in this list, whether they are configured or
         not.";
        leaf name {
          type string;
          description
            "The name of the interface.

           A server implementation MAY map this leaf to the ifName
           MIB object.  Such an implementation needs to use some
           mechanism to handle the differences in size and characters
           allowed between this leaf and ifName.  The definition of
           such a mechanism is outside the scope of this document.";
          reference
            "RFC 2863: The Interfaces Group MIB - ifName";

        }

        leaf type {
          type identityref {
            base interface-type;
          }
          mandatory true;
          description
            "The type of the interface.";
          reference
            "RFC 2863: The Interfaces Group MIB - ifType";

        }

        leaf admin-status {
          if-feature if-mib;
          type enumeration {
            enum "up" {
              value 1;
              description
                "Ready to pass packets.";
            }
            enum "down" {
              value 2;
              description
                "Not ready to pass packets and not in some test mode.";
            }
            enum "testing" {
              value 3;
              description
                "In some test mode.";
            }
          }
          mandatory true;
          description
            "The desired state of the interface.

           This leaf has the same read semantics as ifAdminStatus.";
          reference
            "RFC 2863: The Interfaces Group MIB - ifAdminStatus";

        }

        leaf oper-status {
          type enumeration {
            enum "up" {
              value 1;
              description
                "Ready to pass packets.";
            }
            enum "down" {
              value 2;
              description
                "The interface does not pass any packets.";
            }
            enum "testing" {
              value 3;
              description
                "In some test mode.  No operational packets can
               be passed.";
            }
            enum "unknown" {
              value 4;
              description
                "Status cannot be determined for some reason.";
            }
            enum "dormant" {
              value 5;
              description
                "Waiting for some external event.";
            }
            enum "not-present" {
              value 6;
              description
                "Some component (typically hardware) is missing.";
            }
            enum "lower-layer-down" {
              value 7;
              description
                "Down due to state of lower-layer interface(s).";
            }
          }
          mandatory true;
          description
            "The current operational state of the interface.

           This leaf has the same semantics as ifOperStatus.";
          reference
            "RFC 2863: The Interfaces Group MIB - ifOperStatus";

        }

        leaf last-change {
          type yang:date-and-time;
          description
            "The time the interface entered its current operational
           state.  If the current state was entered prior to the
           last re-initialization of the local network management
           subsystem, then this node is not present.";
          reference
            "RFC 2863: The Interfaces Group MIB - ifLastChange";

        }

        leaf if-index {
          if-feature if-mib;
          type int32 {
            range "1..2147483647";
          }
          mandatory true;
          description
            "The ifIndex value for the ifEntry represented by this
           interface.";
          reference
            "RFC 2863: The Interfaces Group MIB - ifIndex";

        }

        leaf phys-address {
          type yang:phys-address;
          description
            "The interface's address at its protocol sub-layer.  For
           example, for an 802.x interface, this object normally
           contains a Media Access Control (MAC) address.  The
           interface's media-specific modules must define the bit


           and byte ordering and the format of the value of this
           object.  For interfaces that do not have such an address
           (e.g., a serial line), this node is not present.";
          reference
            "RFC 2863: The Interfaces Group MIB - ifPhysAddress";

        }

        leaf-list higher-layer-if {
          type interface-state-ref;
          description
            "A list of references to interfaces layered on top of this
           interface.";
          reference
            "RFC 2863: The Interfaces Group MIB - ifStackTable";

        }

        leaf-list lower-layer-if {
          type interface-state-ref;
          description
            "A list of references to interfaces layered underneath this
           interface.";
          reference
            "RFC 2863: The Interfaces Group MIB - ifStackTable";

        }

        leaf speed {
          type yang:gauge64;
          units "bits/second";
          description
            "An estimate of the interface's current bandwidth in bits
             per second.  For interfaces that do not vary in
             bandwidth or for those where no accurate estimation can
             be made, this node should contain the nominal bandwidth.
             For interfaces that have no concept of bandwidth, this
             node is not present.";
          reference
            "RFC 2863: The Interfaces Group MIB -
                  ifSpeed, ifHighSpeed";

        }

        container ipv4 {
          presence "Present if IPv4 is enabled on this interface";
          description
            "Interface-specific parameters for the IPv4 address family.";

          leaf forwarding {
            type boolean;
            description
              "Indicates whether IPv4 packet forwarding is enabled or
               disabled on this interface.";
          }
          
          leaf mtu {
            type uint16 {
              range "68..max";
            }
            units octets;
            description
              "The size, in octets, of the largest IPv4 packet that the
               interface will send and receive.";
            reference
              "RFC 791: Internet Protocol";
          }
          
          list address {
            key "ip";
            ordered-by user;
            description
              "The list of IPv4 addresses on the interface.";

            leaf ip {
              type inet:ipv4-address-no-zone;
              description
                "The IPv4 address on the interface.";
            }
            
            choice subnet {
              description
                "The subnet can be specified as a prefix-length, or,
                 if the server supports non-contiguous netmasks, as
                 a netmask.";
              leaf prefix-length {
                type uint8 {
                  range "0..32";
                }
                description
                  "The length of the subnet prefix.";
              }
              
              leaf netmask {
                if-feature ipv4-non-contiguous-netmasks;
                type yang:dotted-quad;
                description
                  "The subnet specified as a netmask.";
              }
            }

            leaf origin {
              type ip-address-origin;
              description
                "The origin of this address.";
            }
          }
          
          list neighbor {
            key "ip";
            ordered-by user;
            description
              "A list of mappings from IPv4 addresses to
               link-layer addresses.

               This list represents the ARP Cache.";
            reference
              "RFC 826: An Ethernet Address Resolution Protocol";

            leaf ip {
              type inet:ipv4-address-no-zone;
              description
                "The IPv4 address of the neighbor node.";
            }
            
            leaf link-layer-address {
              type yang:phys-address;
              description
                "The link-layer address of the neighbor node.";
            }
            
            leaf origin {
              type neighbor-origin;
              description
                "The origin of this neighbor entry.";
            }
          }
        } //container ipv4
        
        container ipv6 {
          presence "Present if IPv6 is enabled on this interface";
          description
            "Parameters for the IPv6 address family.";

          leaf forwarding {
            type boolean;
            default false;
            description
              "Indicates whether IPv6 packet forwarding is enabled or
               disabled on this interface.";
            reference
              "RFC 4861: Neighbor Discovery for IP version 6 (IPv6)
                         Section 6.2.1, IsRouter";
          }
          leaf mtu {
            type uint32 {
              range "1280..max";
            }
            units octets;
            description
              "The size, in octets, of the largest IPv6 packet that the
               interface will send and receive.";
            reference
              "RFC 2460: Internet Protocol, Version 6 (IPv6) Specification
                         Section 5";
          }
          
          list address {
            key "ip";
            ordered-by user;
            description
              "The list of IPv6 addresses on the interface.";

            leaf ip {
              type inet:ipv6-address-no-zone;
              description
                "The IPv6 address on the interface.";
            }
            
            leaf prefix-length {
              type uint8 {
                range "0..128";
              }
              mandatory true;
              description
                "The length of the subnet prefix.";
            }
            
            leaf origin {
              type ip-address-origin;
              description
                "The origin of this address.";
            }

            leaf status {
              type enumeration {
                enum preferred {
                  description
                    "This is a valid address that can appear as the
                     destination or source address of a packet.";
                }
                enum deprecated {
                  description
                    "This is a valid but deprecated address that should
                     no longer be used as a source address in new
                     communications, but packets addressed to such an
                     address are processed as expected.";
                }
                enum invalid {
                  description
                    "This isn't a valid address, and it shouldn't appear
                     as the destination or source address of a packet.";
                }
                enum inaccessible {
                  description
                    "The address is not accessible because the interface
                     to which this address is assigned is not
                     operational.";
                }
                enum unknown {
                  description
                    "The status cannot be determined for some reason.";
                }
                enum tentative {
                  description
                    "The uniqueness of the address on the link is being
                     verified.  Addresses in this state should not be
                     used for general communication and should only be
                     used to determine the uniqueness of the address.";
                }
                enum duplicate {
                  description
                    "The address has been determined to be non-unique on
                     the link and so must not be used.";
                }
                enum optimistic {
                  description
                    "The address is available for use, subject to
                     restrictions, while its uniqueness on a link is
                     being verified.";
                }
              }
              description
                "The status of an address.  Most of the states correspond
                 to states from the IPv6 Stateless Address
                 Autoconfiguration protocol.";
              reference
                "RFC 4293: Management Information Base for the
                           Internet Protocol (IP)
                           - IpAddressStatusTC
                 RFC 4862: IPv6 Stateless Address Autoconfiguration";
            }
          }
          
          list neighbor {
            key "ip";
            ordered-by user;
            description
              "A list of mappings from IPv6 addresses to
               link-layer addresses.

               This list represents the Neighbor Cache.";
            reference
              "RFC 4861: Neighbor Discovery for IP version 6 (IPv6)";

            leaf ip {
              type inet:ipv6-address-no-zone;
              description
                "The IPv6 address of the neighbor node.";
            }
            leaf link-layer-address {
              type yang:phys-address;
              description
                "The link-layer address of the neighbor node.";
            }
            leaf origin {
              type neighbor-origin;
              description
                "The origin of this neighbor entry.";
            }
            leaf is-router {
              type empty;
              description
                "Indicates that the neighbor node acts as a router.";
            }

            leaf state {
              type enumeration {
                enum incomplete {
                  description
                    "Address resolution is in progress, and the link-layer
                     address of the neighbor has not yet been
                     determined.";
                }
                enum reachable {
                  description
                    "Roughly speaking, the neighbor is known to have been
                     reachable recently (within tens of seconds ago).";
                }
                enum stale {
                  description
                    "The neighbor is no longer known to be reachable, but
                     until traffic is sent to the neighbor no attempt
                     should be made to verify its reachability.";
                }
                enum delay {
                  description
                    "The neighbor is no longer known to be reachable, and
                     traffic has recently been sent to the neighbor.
                     Rather than probe the neighbor immediately, however,
                     delay sending probes for a short while in order to
                     give upper-layer protocols a chance to provide
                     reachability confirmation.";
                }
                enum probe {
                  description
                    "The neighbor is no longer known to be reachable, and
                     unicast Neighbor Solicitation probes are being sent
                     to verify reachability.";
                }
              }
              description
                "The Neighbor Unreachability Detection state of this
                 entry.";
              reference
                "RFC 4861: Neighbor Discovery for IP version 6 (IPv6)
                           Section 7.3.2";
            }
          }
        } // container ipv6
      }  // list interface          
    }  // grouping interfaces-state
    
    grouping node-identifier {
        leaf node-id {
            type string;
       }
    }

    grouping p4-device {

       //leaf node-id {
       // type string;
       //}
       uses node-identifier;

       leaf grpc-server-ip {
         type inet:ipv4-address;
       }

       leaf grpc-server-port {
         type inet:port-number;
       }

       leaf device-id {
         type uint64;
       }
    }
    
    container node-interfaces-state {
       list node {
         key "node-id";
         ordered-by user;

         uses p4-device;

         uses interfaces-state;       
       } // list node
    } // container node-interfaces-state  
  }  // module ietf-interfaces-test