Rename modfied ietf-routing models

Change-Id: I6ea55212dcf3cc6e4015269b501ffd7828096459
Signed-off-by: Marek Gradzki <mgradzki@cisco.com>

1 files changed, 1030 insertions, 0 deletions

diff --git a/routing/routing-api/src/main/yang/hc2vpp-ietf-routing@2014-05-24.yang b/routing/routing-api/src/main/yang/hc2vpp-ietf-routing@2014-05-24.yang
new file mode 100644
index 000000000..118225cfd
--- /dev/null
+++ b/routing/routing-api/src/main/yang/hc2vpp-ietf-routing@2014-05-24.yang
@@ -0,0 +1,1030 @@
+module hc2vpp-ietf-routing {
+
+  namespace "urn:ietf:params:xml:ns:yang:ietf-routing";
+
+  prefix "rt";
+
+  import ietf-yang-types {
+    prefix "yang";
+  }
+
+  import ietf-interfaces {
+    prefix "if";
+  }
+
+  organization
+    "IETF NETMOD (NETCONF Data Modeling Language) Working Group";
+
+  contact
+    "WG Web:   <http://tools.ietf.org/wg/netmod/>
+     WG List:  <mailto:netmod@ietf.org>
+
+     WG Chair: Thomas Nadeau
+               <mailto:tnadeau@lucidvision.com>
+
+     WG Chair: Juergen Schoenwaelder
+               <mailto:j.schoenwaelder@jacobs-university.de>
+
+     Editor:   Ladislav Lhotka
+               <mailto:lhotka@nic.cz>";
+
+  description
+    "This YANG module defines essential components for the management
+     of a routing subsystem.
+
+     Copyright (c) 2014 IETF Trust and the persons identified as
+     authors of the code. All rights reserved.
+
+     Redistribution and use in source and binary forms, with or
+     without modification, is permitted pursuant to, and subject to
+     the license terms contained in, the Simplified BSD License set
+     forth in Section 4.c of the IETF Trust's Legal Provisions
+     Relating to IETF Documents
+     (http://trustee.ietf.org/license-info).
+
+     This version of this YANG module is part of RFC XXXX; see the
+     RFC itself for full legal notices.";
+
+  revision 2014-05-24 {
+    description
+      "Initial revision.";
+    reference
+      "RFC XXXX: A YANG Data Model for Routing Management";
+  }
+
+  /* Features */
+
+  feature multiple-ribs {
+    description
+      "This feature indicates that the device supports multiple RIBS
+       per address family, and the framework for passing routes
+       between RIBs.
+
+       Devices that do not support this feature MUST provide exactly
+       one system-controlled RIB per supported address family. These
+       RIBs then appear as entries of the list
+       /routing-state/ribs/rib.";
+  }
+
+  feature multipath-routes {
+    description
+      "This feature indicates that the device supports multipath
+       routes that have a list of next-hops.";
+  }
+
+  /* Identities */
+
+  identity address-family {
+    description
+      "Base identity from which identities describing address
+       families are derived.";
+  }
+
+  identity ipv4 {
+    base address-family;
+    description
+      "This identity represents IPv4 address family.";
+  }
+
+  identity ipv6 {
+    base address-family;
+    description
+      "This identity represents IPv6 address family.";
+  }
+
+  identity routing-instance-type {
+    description
+      "Base identity from which identities describing routing
+       instance types are derived.
+
+       It is primarily intended for discriminating among different
+       types of logical routers or router virtualization.";
+  }
+
+  identity standard-routing-instance {
+    base routing-instance-type;
+    description
+      "This identity represents a default routing instance.";
+  }
+
+  identity routing-protocol {
+    description
+      "Base identity from which routing protocol identities are
+       derived.";
+  }
+
+  identity direct {
+    base routing-protocol;
+    description
+      "Routing pseudo-protocol which provides routes to directly
+       connected networks.";
+  }
+
+  identity static {
+    base routing-protocol;
+    description
+      "Static routing pseudo-protocol.";
+  }
+
+  identity route-filter {
+    description
+      "Base identity from which all route filters are derived.";
+  }
+
+  identity deny-all-route-filter {
+    base route-filter;
+    description
+      "Route filter that blocks all routes.";
+  }
+
+  identity allow-all-route-filter {
+    base route-filter;
+    description
+      "Route filter that permits all routes.";
+  }
+
+  /* Type Definitions */
+
+  typedef routing-instance-ref {
+    type leafref {
+      path "/rt:routing/rt:routing-instance/rt:name";
+    }
+    description
+      "This type is used for leafs that reference a routing instance
+       configuration.";
+  }
+
+  typedef routing-instance-state-ref {
+    type leafref {
+      path "/rt:routing-state/rt:routing-instance/rt:name";
+    }
+    description
+      "This type is used for leafs that reference state data of a
+       routing instance.";
+  }
+
+  typedef rib-ref {
+    type leafref {
+      path "/rt:routing/rt:ribs/rt:rib/rt:name";
+    }
+    description
+      "This type is used for leafs that reference a RIB
+       configuration.";
+  }
+
+  typedef rib-state-ref {
+    type leafref {
+      path "/rt:routing-state/rt:ribs/rt:rib/rt:name";
+    }
+    description
+      "This type is used for leafs that reference a RIB in state
+       data.";
+  }
+
+  typedef route-filter-ref {
+    type leafref {
+      path "/rt:routing/rt:route-filters/rt:route-filter/rt:name";
+    }
+    description
+      "This type is used for leafs that reference a route filter
+       configuration.";
+  }
+
+  typedef route-filter-state-ref {
+    type leafref {
+      path "/rt:routing-state/rt:route-filters/rt:route-filter/"
+         + "rt:name";
+    }
+    description
+      "This type is used for leafs that reference a route filter in
+       state data.";
+  }
+
+  /* Groupings */
+
+  grouping address-family-grouping {
+    description
+      "This grouping provides a leaf identifying an address
+       family.";
+    leaf address-family {
+      type identityref {
+        base address-family;
+      }
+      mandatory "true";
+      description
+        "Address family.";
+    }
+  }
+
+  grouping state-entry-id {
+    description
+      "This grouping defines a unique identifier for entries in
+       several operational state lists.";
+    leaf id {
+      type uint64;
+      description
+        "Unique numerical identifier of a list entry in operational
+         state. It may be used by protocols or tools that inspect
+         and/or manipulate operational state data and prefer
+         fixed-size integers as list entry handles.
+
+         These identifiers are always ephemeral, i.e., they may
+         change after a reboot.";
+    }
+  }
+
+  grouping router-id {
+    description
+      "This grouping provides the definition of router ID.";
+    leaf router-id {
+      type yang:dotted-quad;
+      description
+        "Router ID - 32-bit number in the form of a dotted quad. Some
+         protocols use this parameter for identifying a router to its
+         neighbors.";
+    }
+  }
+
+  grouping outgoing-interface {
+    description
+      "This grouping defines the outgoing interface for use in
+       next-hops.";
+    leaf outgoing-interface {
+      type leafref {
+        path "/rt:routing-state/rt:routing-instance/rt:interfaces/"
+           + "rt:interface/rt:name";
+      }
+      description
+        "Name of the outgoing interface.";
+    }
+  }
+
+  // WARNING - renamed due to yang sources generation problem(having same name for grouping and it's leaf ends up in error against Java Language Specification)
+  grouping special-next-hop-grouping {
+    description
+      "This grouping provides the leaf for specifying special
+       next-hop options.";
+    leaf special-next-hop {
+      type enumeration {
+        enum blackhole {
+          description
+            "Silently discard the packet.";
+        }
+        enum unreachable {
+          description
+            "Discard the packet and notify the sender with an error
+             message indicating that the destination host is
+             unreachable.";
+        }
+        enum prohibit {
+          description
+            "Discard the packet and notify the sender with an error
+             message indicating that the communication is
+             administratively prohibited.";
+        }
+        enum receive {
+          description
+            "The packet will be received by the local network
+             device.";
+        }
+      }
+      description
+        "Special next-hop options.";
+    }
+  }
+
+  grouping next-hop-classifiers {
+    description
+      "This grouping provides two next-hop classifiers.";
+    leaf priority {
+      type enumeration {
+        enum primary {
+          value "1";
+          description
+            "Primary next-hop.";
+        }
+        enum backup {
+          value "2";
+          description
+            "Backup next-hop.";
+        }
+      }
+      description
+        "Simple priority for distinguishing between primary and
+         backup next-hops.
+
+         Backup next-hops are used if and only if no primary
+         next-hops are reachable.";
+    }
+    leaf weight {
+      type uint8;
+      must ". = 0 or not(../../next-hop/weight = 0)" {
+        error-message "Illegal combination of zero and non-zero "
+                    + "next-hop weights.";
+        description
+          "Next-hop weights must be either all zero (equal
+           load-balancing) or all non-zero.";
+      }
+      description
+        "This parameter specifies the weight of the next-hop for load
+         balancing. The number specifies the relative fraction of the
+         traffic that will use the corresponding next-hop.
+
+         A value of 0 represents equal load-balancing.
+
+         If both primary and backup next-hops are present, then the
+         weights for each priority level are used separately.";
+    }
+  }
+
+  grouping next-hop-content {
+    description
+      "Generic parameters of next-hops in routes.";
+    choice next-hop-options {
+      mandatory "true";
+      description
+        "Options for expressing the next-hop in routes.";
+      case special-next-hop {
+        uses special-next-hop-grouping;
+      }
+      case simple-next-hop {
+        uses outgoing-interface;
+      }
+      case next-hop-list {
+        if-feature multipath-routes;
+        container next-hop-list {
+          description
+            "Container for multiple next-hops.";
+          list next-hop {
+            key "id";
+            description
+              "An entry of a next-hop list.";
+            uses state-entry-id;
+            uses outgoing-interface;
+            uses next-hop-classifiers;
+          }
+        }
+      }
+    }
+  }
+
+  grouping route-metadata {
+    description
+      "Route metadata.";
+    leaf source-protocol {
+      type identityref {
+        base routing-protocol;
+      }
+      mandatory "true";
+      description
+        "Type of the routing protocol from which the route
+         originated.";
+    }
+    leaf last-updated {
+      type yang:date-and-time;
+      description
+        "Time stamp of the last modification of the route. If the
+         route was never modified, it is the time when the route was
+         inserted into the RIB.";
+    }
+  }
+
+  /* Operational state data */
+
+  container routing-state {
+    config "false";
+    description
+      "Operational state of the routing subsystem.";
+    list routing-instance {
+      key "name";
+      unique "id";
+      description
+        "Each list entry is a container for operational state data of
+         a routing instance.
+
+         An implementation MAY create one or more system-controlled
+         instances, other user-controlled instances MAY be created by
+         configuration.";
+      leaf name {
+        type string;
+        description
+          "The name of the routing instance.
+
+           For system-controlled instances the name is persistent,
+           i.e., it SHOULD NOT change across reboots.";
+      }
+      uses state-entry-id {
+        refine "id" {
+          mandatory "true";
+        }
+      }
+      leaf type {
+        type identityref {
+          base routing-instance-type;
+        }
+        description
+          "The routing instance type, primarily intended for
+           discriminating among different types of logical routers,
+           route virtualization, master-slave arrangements etc.,
+           while keeping all routing instances in the same flat
+           list.";
+      }
+      uses router-id {
+        description
+          "Global router ID.
+
+           An implementation may choose a value if none is
+           configured.
+
+           Routing protocols that use router ID MAY override this
+           global parameter.";
+      }
+      container default-ribs {
+        description
+          "Default RIBs used by the routing instance.";
+        list default-rib {
+          key "address-family";
+          description
+            "Each list entry specifies the default RIB for one
+             address family.
+
+             The default RIB is operationally connected to all
+             routing protocols for which a connected RIB has not been
+             explicitly configured.
+
+             The 'direct' pseudo-protocol is always connected to the
+             default RIBs.";
+          uses address-family-grouping;
+          leaf rib-name {
+            type rib-state-ref;
+            mandatory "true";
+            description
+              "Name of an existing RIB to be used as the default RIB
+               for the given routing instance and address family.";
+          }
+        }
+      }
+      container interfaces {
+        description
+          "Network layer interfaces belonging to the routing
+           instance.";
+        list interface {
+          key "name";
+          description
+            "List of network layer interfaces assigned to the routing
+             instance.";
+          leaf name {
+            type if:interface-state-ref;
+            description
+              "A reference to the name of a configured network layer
+               interface.";
+          }
+        }
+      }
+      container routing-protocols {
+        description
+          "Container for the list of routing protocol instances.";
+        list routing-protocol {
+          key "name";
+          description
+            "Operational state of a routing protocol instance.
+
+             An implementation MUST provide exactly one
+             system-controlled instance of the type 'direct'. Other
+             instances MAY be created by configuration.";
+          leaf name {
+            type string;
+            description
+              "The name of the routing protocol instance.
+
+               For system-controlled instances this name is
+               persistent, i.e., it SHOULD NOT change across
+               reboots.";
+          }
+          leaf type {
+            type identityref {
+              base routing-protocol;
+            }
+            mandatory "true";
+            description
+              "Type of the routing protocol.";
+          }
+          container connected-ribs {
+            description
+              "Container for connected RIBs.";
+            list connected-rib {
+              key "rib-name";
+              description
+                "List of RIBs to which the routing protocol instance
+                 is connected (at most one RIB per address
+                 family).";
+              leaf rib-name {
+                type rib-state-ref;
+                description
+                  "Name of an existing RIB.";
+              }
+              leaf import-filter {
+                type route-filter-state-ref;
+                description
+                  "Reference to a route filter that is used for
+                   filtering routes passed from this routing protocol
+                   instance to the RIB specified by the 'rib-name'
+                   sibling node.
+
+                   If this leaf is not present, the behavior is
+                   protocol-specific, but typically it means that all
+                   routes are accepted.";
+              }
+              leaf export-filter {
+                type route-filter-state-ref;
+                description
+                  "Reference to a route filter that is used for
+                   filtering routes passed from the RIB specified by
+                   the 'rib-name' sibling node to this routing
+                   protocol instance.
+
+                   If this leaf is not present, the behavior is
+                   protocol-specific - typically it means that all
+                   routes are accepted.
+
+                   The 'direct' and 'static' pseudo-protocols accept
+                   no routes from any RIB.";
+              }
+            }
+          }
+
+          //NOTE -added to allow operational state for static-routes
+          container static-routes {
+            when "../type='rt:static'" {
+            description
+              "This container is only valid for the 'static'
+               routing protocol.";
+            }
+            description
+            "Configuration of the 'static' pseudo-protocol.
+
+             Address family specific modules augment this node with
+             their lists of routes.";
+          }
+        }
+      }
+    }
+    container ribs {
+      description
+        "Container for RIBs.";
+      list rib {
+        key "name";
+        unique "id";
+        description
+          "Each entry represents a RIB identified by the 'name' key.
+           All routes in a RIB MUST belong to the same address
+           family.
+
+           The server MUST provide a system-controlled default RIB
+           for each address family, and MAY provide other
+           system-controlled RIBs. Additional RIBs MAY be created in
+           the configuration.";
+        leaf name {
+          type string;
+          description
+            "The name of the RIB.";
+        }
+        uses state-entry-id {
+          refine "id" {
+            mandatory "true";
+          }
+        }
+        uses address-family-grouping;
+        container routes {
+          description
+            "Current contents of the RIB.";
+          list route {
+            key "id";
+            description
+              "A RIB route entry. This data node MUST be augmented
+               with information specific for routes of each address
+               family.";
+            uses state-entry-id;
+            uses next-hop-content;
+            uses route-metadata;
+          }
+        }
+        container recipient-ribs {
+          if-feature multiple-ribs;
+          description
+            "Container for recipient RIBs.";
+          list recipient-rib {
+            key "rib-name";
+            description
+              "List of RIBs that receive routes from this RIB.";
+            leaf rib-name {
+              type rib-state-ref;
+              description
+                "The name of the recipient RIB.";
+            }
+            leaf filter {
+              type route-filter-state-ref;
+              description
+                "A route filter which is applied to the routes passed
+                 to the recipient RIB.";
+            }
+          }
+        }
+      }
+    }
+    container route-filters {
+      description
+        "Container for route filters.";
+      list route-filter {
+        key "name";
+        description
+          "Route filters are used for filtering and/or manipulating
+           routes that are passed between a routing protocol and a
+           RIB and vice versa, or between two RIBs.
+
+           It is expected that other modules augment this list with
+           contents specific for a particular route filter type.";
+        leaf name {
+          type string;
+          description
+            "The name of the route filter.";
+        }
+        leaf type {
+          type identityref {
+            base route-filter;
+          }
+          mandatory "true";
+          description
+            "Type of the route-filter - an identity derived from the
+             'route-filter' base identity.";
+        }
+      }
+    }
+  }
+
+  /* Configuration Data */
+
+  container routing {
+    description
+      "Configuration parameters for the routing subsystem.";
+    list routing-instance {
+      key "name";
+      description
+        "Configuration of a routing instance.";
+      leaf name {
+        type string;
+        description
+          "The name of the routing instance.
+
+           For system-controlled entries, the value of this leaf must
+           be the same as the name of the corresponding entry in
+           state data.
+
+           For user-controlled entries, an arbitrary name can be
+           used.";
+      }
+      leaf type {
+        type identityref {
+          base routing-instance-type;
+        }
+        default "rt:standard-routing-instance";
+        description
+          "The type of the routing instance.";
+      }
+      leaf enabled {
+        type boolean;
+        default "true";
+        description
+          "Enable/disable the routing instance.
+
+           If this parameter is false, the parent routing instance is
+           disabled and does not appear in operational state data,
+           despite any other configuration that might be present.";
+      }
+      uses router-id {
+        description
+          "Configuration of the global router ID.";
+      }
+      leaf description {
+        type string;
+        description
+          "Textual description of the routing instance.";
+      }
+      container default-ribs {
+        if-feature multiple-ribs;
+        description
+          "Configuration of the default RIBs used by the routing
+           instance.
+
+           The default RIB for an addressed family if by default
+           connected to all routing protocol instances supporting
+           that address family, and always receives direct routes.";
+        list default-rib {
+          must "address-family=/routing/ribs/rib[name=current()/"
+             + "rib-name]/address-family" {
+            error-message "Address family mismatch.";
+            description
+              "The entry's address family MUST match that of the
+               referenced RIB.";
+          }
+          key "address-family";
+          description
+            "Each list entry configures the default RIB for one
+             address family.";
+          uses address-family-grouping;
+          leaf rib-name {
+            type string;
+            mandatory "true";
+            description
+              "Name of an existing RIB to be used as the default RIB
+               for the given routing instance and address family.";
+          }
+        }
+      }
+      container interfaces {
+        description
+          "Configuration of the routing instance's interfaces.";
+        list interface {
+          key "name";
+          description
+            "List of network layer interfaces assigned to the routing
+             instance.";
+          leaf name {
+            type if:interface-ref;
+            description
+              "A reference to the name of a configured network layer
+               interface.";
+          }
+        }
+      }
+      container routing-protocols {
+        description
+          "Configuration of routing protocol instances.";
+        list routing-protocol {
+          key "name";
+          description
+            "Each entry contains configuration of a routing protocol
+             instance.";
+          leaf name {
+            type string;
+            description
+              "An arbitrary name of the routing protocol instance.";
+          }
+          leaf description {
+            type string;
+            description
+              "Textual description of the routing protocol
+               instance.";
+          }
+          leaf enabled {
+            type boolean;
+            default "true";
+            description
+              "Enable/disable the routing protocol instance.
+
+               If this parameter is false, the parent routing
+               protocol instance is disabled and does not appear in
+               operational state data, despite any other
+               configuration that might be present.";
+          }
+          leaf type {
+            type identityref {
+              base routing-protocol;
+            }
+            mandatory "true";
+            description
+              "Type of the routing protocol - an identity derived
+               from the 'routing-protocol' base identity.";
+          }
+          container connected-ribs {
+            description
+              "Configuration of connected RIBs.";
+            list connected-rib {
+              must "not(/routing/ribs/rib[name=current()/"
+                 + "preceding-sibling::connected-rib/"
+                 + "rib-name and address-family=/routing/ribs/"
+                 + "rib[name=current()/rib-name]/address-family])" {
+                error-message
+                  "Duplicate address family for connected RIBs.";
+                description
+                  "For each address family, there MUST NOT be more
+                   than one connected RIB.";
+              }
+              key "rib-name";
+              description
+                "List of RIBs to which the routing protocol instance
+                 is connected (at most one RIB per address family).
+
+                 If no connected RIB is configured for an address
+                 family, the routing protocol is connected to the
+                 default RIB for that address family.";
+              leaf rib-name {
+                type rib-ref;
+                must "../../../type != 'rt:direct' or "
+                   + "../../../../../default-ribs/ "
+                   + "default-rib/rib-name=." {
+                  error-message "The 'direct' protocol can be "
+                              + "connected only to a default RIB.";
+                  description
+                    "For the 'direct' pseudo-protocol, the connected
+                     RIB must always be a default RIB.";
+                }
+                description
+                  "Name of an existing RIB.";
+              }
+              leaf import-filter {
+                type route-filter-ref;
+                description
+                  "Configuration of import filter.";
+              }
+              leaf export-filter {
+                type route-filter-ref;
+                description
+                  "Configuration of export filter.";
+              }
+            }
+          }
+          container static-routes {
+            when "../type='rt:static'" {
+              description
+                "This container is only valid for the 'static'
+                 routing protocol.";
+            }
+            description
+              "Configuration of the 'static' pseudo-protocol.
+
+               Address family specific modules augment this node with
+               their lists of routes.";
+          }
+        }
+      }
+    }
+    container ribs {
+      description
+        "Configured RIBs.";
+      list rib {
+        key "name";
+        description
+          "Each entry represents a configured RIB identified by the
+           'name' key.
+
+           Entries having the same key as a system-controlled entry
+           of the list /routing-state/ribs/rib are used for
+           configuring parameters of that entry. Other entries define
+           additional user-controlled RIBs.";
+        leaf name {
+          type string;
+          description
+            "The name of the RIB.
+
+             For system-controlled entries, the value of this leaf
+             must be the same as the name of the corresponding entry
+             in state data.
+
+             For user-controlled entries, an arbitrary name can be
+             used.";
+        }
+        uses address-family-grouping;
+        leaf description {
+          type string;
+          description
+            "Textual description of the RIB.";
+        }
+        container recipient-ribs {
+          if-feature multiple-ribs;
+          description
+            "Configuration of recipient RIBs.";
+          list recipient-rib {
+            must "rib-name != ../../name" {
+              error-message
+                "Source and recipient RIBs are identical.";
+              description
+                "A RIB MUST NOT appear among its recipient RIBs.";
+            }
+            must "/routing/ribs/rib[name=current()/rib-name]/"
+               + "address-family=../../address-family" {
+              error-message "Address family mismatch.";
+              description
+                "Address family of the recipient RIB MUST match that
+                 of the source RIB.";
+            }
+            key "rib-name";
+            description
+              "Each entry configures a recipient RIB.";
+            leaf rib-name {
+              type rib-ref;
+              description
+                "The name of the recipient RIB.";
+            }
+            leaf filter {
+              type route-filter-ref;
+              description
+                "A route filter which is applied to the routes passed
+                 to the recipient RIB.";
+            }
+          }
+        }
+      }
+    }
+    container route-filters {
+      description
+        "Configuration of route filters.";
+      list route-filter {
+        key "name";
+        description
+          "Each entry configures a named route filter.";
+        leaf name {
+          type string;
+          description
+            "The name of the route filter.";
+        }
+        leaf description {
+          type string;
+          description
+            "Textual description of the route filter.";
+        }
+        leaf type {
+          type identityref {
+            base route-filter;
+          }
+          mandatory "true";
+          description
+            "Type of the route filter..";
+        }
+      }
+    }
+  }
+
+  /* RPC methods */
+
+  rpc active-route {
+    description
+      "Return the active route that a routing-instance uses for
+       sending packets to a destination address.";
+    input {
+      leaf routing-instance-name {
+        type routing-instance-state-ref;
+        mandatory "true";
+        description
+          "Name of the routing instance whose forwarding information
+           base is being queried.
+
+           If the routing instance with name equal to the value of
+           this parameter doesn't exist, then this operation SHALL
+           fail with error-tag 'data-missing' and error-app-tag
+           'routing-instance-not-found'.";
+      }
+      container destination-address {
+        description
+          "Network layer destination address.
+
+           Address family specific modules MUST augment this
+           container with a leaf named 'address'.";
+        uses address-family-grouping;
+      }
+    }
+    output {
+      container route {
+        description
+          "The active route for the specified destination.
+
+           If the routing instance has no active route for the
+           destination address, no output is returned - the server
+           SHALL send an <rpc-reply> containing a single element
+           <ok>.
+
+           Address family specific modules MUST augment this list
+           with appropriate route contents.";
+        uses address-family-grouping;
+        uses next-hop-content;
+        uses route-metadata;
+      }
+    }
+  }
+
+  rpc route-count {
+    description
+      "Return the current number of routes in a RIB.";
+    input {
+      leaf rib-name {
+        type rib-state-ref;
+        mandatory "true";
+        description
+          "Name of the RIB.
+
+           If the RIB with name equal to the value of this parameter
+           doesn't exist, then this operation SHALL fail with
+           error-tag 'data-missing' and error-app-tag
+           'rib-not-found'.";
+      }
+    }
+    output {
+      leaf number-of-routes {
+        type uint64;
+        mandatory "true";
+        description
+          "Number of routes in the RIB.";
+      }
+    }
+  }
+}
\ No newline at end of file