diff options
Diffstat (limited to 'routing/routing-api/src/main/yang/ietf-routing.yang')
-rw-r--r-- | routing/routing-api/src/main/yang/ietf-routing.yang | 1030 |
1 files changed, 1030 insertions, 0 deletions
diff --git a/routing/routing-api/src/main/yang/ietf-routing.yang b/routing/routing-api/src/main/yang/ietf-routing.yang new file mode 100644 index 000000000..6902cd0bf --- /dev/null +++ b/routing/routing-api/src/main/yang/ietf-routing.yang @@ -0,0 +1,1030 @@ +module 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 |