diff options
Diffstat (limited to 'src/plugins/yang/openconfig/openconfig-local-routing@2017-05-15.yang')
| -rw-r--r-- | src/plugins/yang/openconfig/openconfig-local-routing@2017-05-15.yang | 408 |
1 files changed, 408 insertions, 0 deletions
diff --git a/src/plugins/yang/openconfig/openconfig-local-routing@2017-05-15.yang b/src/plugins/yang/openconfig/openconfig-local-routing@2017-05-15.yang new file mode 100644 index 0000000..5184fe7 --- /dev/null +++ b/src/plugins/yang/openconfig/openconfig-local-routing@2017-05-15.yang @@ -0,0 +1,408 @@ +module openconfig-local-routing { + + yang-version "1"; + + // namespace + namespace "http://openconfig.net/yang/local-routing"; + + prefix "oc-loc-rt"; + + // import some basic types + import openconfig-inet-types { prefix inet; } + import openconfig-policy-types { prefix oc-pt; } + import openconfig-extensions { prefix oc-ext; } + import openconfig-interfaces { prefix oc-if; } + + // meta + organization "OpenConfig working group"; + + contact + "OpenConfig working group + www.openconfig.net"; + + description + "This module describes configuration and operational state data + for routes that are locally generated, i.e., not created by + dynamic routing protocols. These include static routes, locally + created aggregate routes for reducing the number of constituent + routes that must be advertised, summary routes for IGPs, etc. + + This model expresses locally generated routes as generically as + possible, avoiding configuration of protocol-specific attributes + at the time of route creation. This is primarily to avoid + assumptions about how underlying router implementations handle + route attributes in various routing table data structures they + maintain. Hence, the definition of locally generated routes + essentially creates 'bare' routes that do not have any protocol- + specific attributes. + + When protocol-specific attributes must be attached to a route + (e.g., communities on a locally defined route meant to be + advertised via BGP), the attributes should be attached via a + protocol-specific policy after importing the route into the + protocol for distribution (again via routing policy)."; + + oc-ext:openconfig-version "1.0.1"; + + revision "2017-05-15" { + description + "Update to resolve style guide non-compliance."; + reference "1.0.1"; + } + + revision "2016-05-11" { + description + "OpenConfig public release"; + reference "1.0.0"; + } + + + // identity statements + + identity LOCAL_DEFINED_NEXT_HOP { + description + "A base identity type of local defined next-hops"; + } + + identity DROP { + base LOCAL_DEFINED_NEXT_HOP; + description + "Discard traffic for the corresponding destination"; + } + + identity LOCAL_LINK { + base LOCAL_DEFINED_NEXT_HOP; + description + "Treat traffic towards addresses within the specified + next-hop prefix as though they are connected to a local + link. When the LOCAL_LINK next-hop type is specified, + an interface must also be specified such that + the local system can determine which link to trigger + link-layer address discovery against"; + } + + // typedef statements + + typedef local-defined-next-hop { + type identityref { + base LOCAL_DEFINED_NEXT_HOP; + } + description + "Pre-defined next-hop designation for locally generated + routes"; + } + + // grouping statements + + grouping local-generic-settings { + description + "Generic options that can be set on local routes When + they are defined"; + + leaf set-tag { + type oc-pt:tag-type; + description + "Set a generic tag value on the route. This tag can be + used for filtering routes that are distributed to other + routing protocols."; + } + } + + grouping local-static-config { + description + "Configuration data for static routes."; + + leaf prefix { + type inet:ip-prefix; + description + "Destination prefix for the static route, either IPv4 or + IPv6."; + } + + uses local-generic-settings; + } + + grouping local-static-state { + description + "Operational state data for static routes"; + } + + + grouping local-static-nexthop-config { + description + "Configuration parameters related to each next-hop entry + specified for a static route"; + + leaf index { + type string; + description + "An user-specified identifier utilised to uniquely reference + the next-hop entry in the next-hop list. The value of this + index has no semantic meaning other than for referencing + the entry."; + } + + leaf next-hop { + type union { + type inet:ip-address; + type local-defined-next-hop; + } + description + "The next-hop that is to be used for the static route + - this may be specified as an IP address, an interface + or a pre-defined next-hop type - for instance, DROP or + LOCAL_LINK. When this leaf is not set, and the interface-ref + value is specified for the next-hop, then the system should + treat the prefix as though it is directly connected to the + interface."; + } + + leaf metric { + type uint32; + description + "A metric which is utilised to specify the preference of + the next-hop entry when it is injected into the RIB. The + lower the metric, the more preferable the prefix is. When + this value is not specified the metric is inherited from + the default metric utilised for static routes within the + network instance that the static routes are being + instantiated. When multiple next-hops are specified for a + static route, the metric is utilised to determine which of + the next-hops is to be installed in the RIB. When multiple + next-hops have the same metric (be it specified, or simply + the default) then these next-hops should all be installed + in the RIB"; + } + + leaf recurse { + type boolean; + default false; + description + "Determines whether the next-hop should be allowed to + be looked up recursively - i.e., via a RIB entry which has + been installed by a routing protocol, or another static route + - rather than needing to be connected directly to an + interface of the local system within the current network + instance. When the interface reference specified within the + next-hop entry is set (i.e., is not null) then forwarding is + restricted to being via the interface specified - and + recursion is hence disabled."; + } + } + + grouping local-static-nexthop-state { + description + "Operational state parameters relating to a next-hop entry + for a static route"; + } + + + grouping local-static-top { + description + "Top-level grouping for the list of static route definitions"; + + container static-routes { + description + "Enclosing container for the list of static routes"; + + list static { + key "prefix"; + description + "List of locally configured static routes"; + + leaf prefix { + type leafref { + path "../config/prefix"; + } + description + "Reference to the destination prefix list key."; + } + + container config { + description + "Configuration data for static routes"; + + uses local-static-config; + } + + container state { + + config false; + + description + "Operational state data for static routes"; + + uses local-static-config; + uses local-static-state; + } + + container next-hops { + description + "Configuration and state parameters relating to the + next-hops that are to be utilised for the static + route being specified"; + + list next-hop { + key "index"; + + description + "A list of next-hops to be utilised for the static + route being specified."; + + leaf index { + type leafref { + path "../config/index"; + } + description + "A reference to the index of the current next-hop. + The index is intended to be a user-specified value + which can be used to reference the next-hop in + question, without any other semantics being + assigned to it."; + } + + container config { + description + "Configuration parameters relating to the next-hop + entry"; + + uses local-static-nexthop-config; + } + + container state { + config false; + description + "Operational state parameters relating to the + next-hop entry"; + + uses local-static-nexthop-config; + uses local-static-nexthop-state; + } + + uses oc-if:interface-ref; + } + } + } + } + } + + grouping local-aggregate-config { + description + "Configuration data for aggregate routes"; + + leaf prefix { + type inet:ip-prefix; + description + "Aggregate prefix to be advertised"; + } + + leaf discard { + type boolean; + default false; + description + "When true, install the aggregate route with a discard + next-hop -- traffic destined to the aggregate will be + discarded with no ICMP message generated. When false, + traffic destined to an aggregate address when no + constituent routes are present will generate an ICMP + unreachable message."; + } + + uses local-generic-settings; + + } + + grouping local-aggregate-state { + description + "Operational state data for local aggregate advertisement + definitions"; + } + + grouping local-aggregate-top { + description + "Top-level grouping for local aggregates"; + + container local-aggregates { + description + "Enclosing container for locally-defined aggregate + routes"; + + list aggregate { + key "prefix"; + description + "List of aggregates"; + + leaf prefix { + type leafref { + path "../config/prefix"; + } + description + "Reference to the configured prefix for this aggregate"; + } + + container config { + description + "Configuration data for aggregate advertisements"; + + uses local-aggregate-config; + } + + container state { + + config false; + + description + "Operational state data for aggregate + advertisements"; + + uses local-aggregate-config; + uses local-aggregate-state; + } + } + } + } + + grouping local-routes-config { + description + "Configuration data for locally defined routes"; + } + + grouping local-routes-state { + description + "Operational state data for locally defined routes"; + } + + grouping local-routes-top { + description + "Top-level grouping for local routes"; + + container local-routes { + description + "Top-level container for local routes"; + + container config { + description + "Configuration data for locally defined routes"; + + uses local-routes-config; + } + + container state { + + config false; + + description + "Operational state data for locally defined routes"; + + uses local-routes-config; + uses local-routes-state; + } + + uses local-static-top; + uses local-aggregate-top; + } + } + + uses local-routes-top; + +} |