| module openconfig-isis { |
| |
| yang-version "1"; |
| |
| // namespace |
| namespace "http://openconfig.net/yang/openconfig-isis"; |
| |
| prefix "oc-isis"; |
| |
| // import some basic types |
| import ietf-inet-types { prefix "inet"; } |
| import ietf-yang-types { prefix "yang"; } |
| import openconfig-types { prefix "oc-types"; } |
| import openconfig-isis-types { prefix "oc-isis-types"; } |
| import openconfig-routing-policy { prefix "oc-rpol"; } |
| import openconfig-extensions { prefix "oc-ext"; } |
| import openconfig-interfaces { prefix "oc-if"; } |
| import openconfig-segment-routing { prefix "oc-sr"; } |
| // TODO(robjs): Import authentication and keychain following merge of these |
| // modules. |
| //import openconfig-authentication-types { prefix "oc-auth-types"; } |
| //import openconfig-keychain { prefix "oc-keychain"; } |
| |
| // Include submodules: |
| // IS-IS LSP is the LSDB for IS-IS. |
| include openconfig-isis-lsp; |
| // IS-IS RT is routing-related features for IS-IS |
| include openconfig-isis-routing; |
| |
| // meta |
| organization |
| "OpenConfig working group"; |
| |
| contact |
| "OpenConfig working group |
| www.openconfig.net "; |
| |
| description |
| "This module describes a YANG model for ISIS protocol configuration. |
| It is a limited subset of all of the configuration parameters |
| available in the variety of vendor implementations, hence it is |
| expected that it would be augmented with vendor - specific configuration |
| data as needed. Additional modules or submodules to handle other |
| aspects of ISIS configuration, including policy, routing, types, |
| LSDB and additional address families are also expected. This model |
| supports the following ISIS configuration level hierarchy: |
| |
| ISIS |
| +-> { global ISIS configuration} |
| +-> levels +-> { level config} |
| +-> { system-level-counters } |
| +-> { level link-state-database} |
| +-> interface +-> { interface config } |
| +-> { circuit-counters } |
| +-> { levels config } |
| +-> { level adjacencies }"; |
| |
| oc-ext:openconfig-version "0.3.2"; |
| |
| revision "2017-07-26" { |
| description |
| "Update LSDB and fix bugs."; |
| reference "0.3.2"; |
| } |
| |
| revision "2017-05-15" { |
| description |
| "Refactor LSDB."; |
| reference "0.3.0"; |
| } |
| |
| revision "2017-01-13" { |
| description |
| "Remove top-level /isis container"; |
| reference "0.2.1"; |
| } |
| |
| revision "2016-12-15" { |
| description |
| "Add segment routing to IS-IS module"; |
| reference "0.2.0"; |
| } |
| |
| revision "2016-10-18" { |
| description |
| "Initial revision of IS-IS models."; |
| reference "0.1.0"; |
| } |
| |
| // extension statements |
| |
| // feature statements |
| |
| // identity statements |
| |
| // typedef statements |
| |
| // grouping statements |
| |
| grouping isis-global-config { |
| description |
| "This grouping defines lobal configuration options for ISIS router."; |
| |
| // multi-instance |
| leaf instance { |
| type string; |
| default 0; |
| description |
| "ISIS Instance."; |
| } |
| |
| leaf-list net { |
| type oc-isis-types:net; |
| description |
| "ISIS network entity title (NET). The first 8 bits are usually |
| 49 (private AFI), next 16 bits represent area, next 48 bits represent |
| system id and final 8 bits are set to 0."; |
| reference |
| "International Organization for Standardization, Information |
| technology - Open Systems Interconnection-Network service |
| Definition - ISO/ IEC 8348:2002."; |
| } |
| |
| leaf maximum-area-addresses { |
| type uint8; |
| default 3; |
| description |
| "Maximum areas supported."; |
| } |
| |
| leaf level-capability { |
| type oc-isis-types:level-type; |
| default "LEVEL_1_2"; |
| description |
| "ISIS level capability(level-1, level-2,vlevel-1-2)."; |
| } |
| |
| leaf max-ecmp-paths { |
| type uint8; |
| description |
| "ISIS max-paths count."; |
| } |
| |
| leaf poi-tlv { |
| type boolean; |
| default false; |
| description |
| "ISIS purge TLV. When set to true, a TLV is added to purges to record |
| the system ID of the IS generating the purge."; |
| reference "RFC6232: Purge Originator Identification TLV for IS-IS. TLV 13."; |
| } |
| |
| leaf iid-tlv { |
| type boolean; |
| default false; |
| description |
| "ISIS Instance Identifier TLV. When set to trues, the IID-TLV identifies |
| the unique instance as well as the topology/topologies to which the |
| PDU applies."; |
| reference "RFC6822: IS-IS Multi-Instance. TLV 7"; |
| } |
| |
| leaf fast-flooding { |
| type boolean; |
| default true; |
| description |
| "When set to true, IS will always flood the LSP that triggered an SPF |
| before the router actually runs the SPF computation."; |
| } |
| } |
| |
| grouping admin-config { |
| description |
| "Re-usable grouping to enable or disable a particular IS-IS feature."; |
| |
| leaf enabled { |
| type boolean; |
| default false; |
| description |
| "When set to true, the functionality within which this leaf is |
| defined is enabled, when set to false it is explicitly disabled."; |
| } |
| } |
| |
| grouping isis-bfd-config { |
| description |
| "This grouping defines Bidirectionl-Forwarding-Detection |
| configuration."; |
| |
| //There is also BFD state under adjacency |
| leaf bfd-tlv { |
| type boolean; |
| description |
| "When set to true, BFD TLV is used. This enables support for the IS-IS |
| BFD TLV options, which specify that a BFD session must be established |
| before an IS-IS adjacency can transition to the established state. |
| This option should be enabled on all IS-IS neighbors on a shared |
| interface."; |
| reference "RFC6213. TLV 148"; |
| } |
| reference "RFC5880: Bidirectional Forwarding Detection (BFD)."; |
| } |
| |
| grouping isis-authentication-check-config { |
| description |
| "This grouping defines ISIS authentication check."; |
| |
| leaf authentication-check { |
| type boolean; |
| default true; |
| description |
| "When set to true, reject all ISIS protocol PDUs that either have a mismatch |
| in authentication-type or authentication-key."; |
| } |
| } |
| |
| grouping isis-metric-style-config { |
| description |
| "This grouping defines ISIS metric style."; |
| |
| leaf metric-style { |
| type oc-isis-types:metric-style; |
| description |
| "ISIS metric style types(narrow, wide)."; |
| } |
| } |
| |
| grouping authentication-key-config { |
| description |
| "This grouping defines authentication key configuration."; |
| |
| leaf auth-password { |
| type oc-types:routing-password; |
| description |
| "Authentication key string."; |
| } |
| } |
| |
| grouping keychain-base-group { |
| description |
| "This grouping defines keychain configuration."; |
| |
| container keychain { |
| description |
| "This container defines keychain parameters."; |
| |
| // TODO(robjs): Import keychain parameters following merge of the auth |
| // models. |
| //uses oc-keychain:keychain-common-base; |
| //uses oc-keychain:tolerance-base; |
| //uses oc-keychain:keychain-key-base; |
| } |
| } |
| |
| grouping isis-authentication-config { |
| description |
| "This grouping defines ISIS authentication configuration."; |
| |
| // TODO(robjs): Add authentication following merge of auth modules. |
| //leaf auth-type { |
| // type oc-auth-types:auth-type; |
| // description |
| // "ISIS authentication type (key, key-chain)."; |
| //} |
| |
| leaf csnp-authentication { |
| type boolean; |
| default false; |
| description |
| "Enable or disable for IS-IS CSNPs."; |
| } |
| |
| leaf psnp-authentication { |
| type boolean; |
| default false; |
| description |
| "Enable or disable authentication for IS-IS PSNPs."; |
| } |
| |
| leaf lsp-authentication { |
| type boolean; |
| default false; |
| description |
| "Enable or disable authentication for IS-IS LSPs."; |
| } |
| } |
| |
| grouping isis-authentication-group { |
| description |
| "This grouping defines ISIS authentication."; |
| |
| container config { |
| description |
| "This container defines ISIS authentication configuration."; |
| |
| uses isis-authentication-config; |
| } |
| |
| container state { |
| config false; |
| description |
| "This container defines ISIS authentication state."; |
| |
| uses isis-authentication-config; |
| } |
| |
| container key { |
| description |
| "This container defines ISIS authentication key"; |
| container config { |
| description |
| "This container defines ISIS authentication key configuration."; |
| |
| uses authentication-key-group-config { |
| when "../auth-type = KEY"; |
| } |
| } |
| |
| container state { |
| config false; |
| description |
| "This container defines ISIS authentication key state."; |
| |
| uses authentication-key-group-config { |
| when "../auth-type = KEY"; |
| } |
| } |
| } |
| |
| uses keychain-base-group { |
| when "../auth-type = KEY_CHAIN"; |
| } |
| } |
| |
| grouping isis-hello-authentication-config { |
| description |
| "Configuration options for IS-IS hello authentication."; |
| |
| leaf hello-authentication { |
| type boolean; |
| default false; |
| description |
| "Enabled or disable ISIS Hello authentication."; |
| } |
| |
| // TODO(robjs): Add hello-auth-type following merge of auth models. |
| //leaf hello-auth-type { |
| // type oc-auth-types:auth-type; |
| // description |
| // "ISIS authentication type (key, key-chain)."; |
| //} |
| } |
| |
| grouping isis-hello-authentication-group { |
| description |
| "This grouping defines ISIS hello-authentication."; |
| |
| container config { |
| description |
| "This container defines ISIS authentication configuration."; |
| |
| uses isis-hello-authentication-config; |
| } |
| |
| container state { |
| config false; |
| description |
| "This container defines ISIS authentication state."; |
| |
| uses isis-hello-authentication-config; |
| } |
| |
| container key { |
| description |
| "This container defines ISIS authentication key"; |
| |
| container config { |
| description |
| "This container defines ISIS authentication key configuration."; |
| |
| uses authentication-key-group-config { |
| when "../auth-type = KEY"; |
| } |
| } |
| |
| container state { |
| config false; |
| description |
| "This container defines ISIS authentication key state."; |
| |
| uses authentication-key-group-config { |
| when "../auth-type = KEY"; |
| } |
| } |
| } |
| |
| uses keychain-base-group { |
| when "../auth-type = KEY_CHAIN"; |
| } |
| } |
| |
| grouping isis-ldp-igp-config { |
| description |
| "This grouping defines ISIS/LDP Synchronization configuration."; |
| |
| leaf enabled { |
| type boolean; |
| default true; |
| description |
| "When set to true, rely on IGP/LDP synchronization. IGP cost for |
| link is maintained at max until LDP adjacencies are established "; |
| reference "RFC5443: LDP IGP Synchronization."; |
| } |
| |
| leaf post-session-up-delay { |
| type uint16; |
| units seconds; |
| description |
| "Specifies a delay, expressed in units of seconds, |
| between the LDP session to the IGP neighbor being established, and |
| it being considered synchronized by the IGP."; |
| } |
| } |
| |
| grouping isis-te-config { |
| description |
| "This grouping defines ISIS Traffic Engineering configuration."; |
| |
| leaf ipv4-router-id { |
| type inet:ipv4-address-no-zone; |
| description |
| "IPv4 MPLS Traffic Engineering Router-ID."; |
| } |
| |
| leaf ipv6-router-id { |
| type inet:ipv6-address-no-zone; |
| description |
| "IPv6 MPLS Traffic Engineering Router-ID."; |
| } |
| } |
| |
| grouping isis-reference-bandwidth-config { |
| description |
| "This grouping defines ISIS Reference Bandwidth Configuration."; |
| |
| leaf reference-bandwidth { |
| type uint32; |
| description |
| "ISIS Reference Bandwidth value"; |
| } |
| } |
| |
| grouping isis-overload-bit-set-config { |
| description |
| "This grouping defines ISIS Overload Bit."; |
| |
| leaf set-bit { |
| type boolean; |
| default false; |
| description |
| "When set to true, IS-IS overload bit is set."; |
| } |
| |
| leaf set-bit-on-boot { |
| type boolean; |
| default false; |
| description |
| "When set to true, the IS-IS overload bit is set on system boot."; |
| } |
| |
| leaf advertise-high-metric { |
| type boolean; |
| default false; |
| description |
| "When set to true, the local IS advertises links with the highest |
| available metric regardless of their configured metric. The metric |
| value is based on the metric style - if wide metrics are utilised |
| the metric is advertised as 16777214, otherwise they are advertised |
| with a value of 63."; |
| } |
| } |
| |
| grouping isis-overload-bit-reset-config { |
| description |
| "This grouping defines ISIS Overload Bit Reset Triggers"; |
| |
| leaf reset-trigger { |
| type identityref { |
| base oc-isis-types:OVERLOAD_RESET_TRIGGER_TYPE; |
| } |
| description |
| "In the case that the system sets the overload bit on start, the |
| system should reset the bit (i.e., clear the overload bit) upon |
| the specified trigger."; |
| } |
| |
| leaf delay { |
| type uint16; |
| units seconds; |
| description |
| "If a reset trigger is specified, the system should delay resetting |
| the overload bit for the specified number of seconds after the |
| trigger occurs."; |
| } |
| } |
| |
| grouping isis-attached-bit-config { |
| description |
| "This grouping defines ISIS Attached Bit"; |
| |
| leaf ignore-bit { |
| type boolean; |
| default false; |
| description |
| "When set to true, if the attached bit is set on an incoming Level 1 |
| IS-IS, the local system ignores it. In this case the local system |
| does not set a default route to the L1L2 router advertising the PDU |
| with the attached bit set."; |
| } |
| |
| leaf suppress-bit { |
| type boolean; |
| default false; |
| description |
| "When set to true, if the local IS acts as a L1L2 router, then the |
| attached bit is not advertised in locally generated PDUs."; |
| } |
| } |
| |
| grouping overload-bit-group { |
| description |
| "This grouping defines ISIS Overload Bit."; |
| |
| container config { |
| description |
| "This container defines ISIS Overload Bit configuration."; |
| |
| uses isis-overload-bit-set-config; |
| } |
| |
| container state { |
| config false; |
| description |
| "This container defines state for ISIS Overload Bit."; |
| |
| uses isis-overload-bit-set-config; |
| } |
| |
| container reset-triggers { |
| description |
| "This container defines state for ISIS Overload Bit reset triggers"; |
| |
| list reset-trigger { |
| key "reset-trigger"; |
| |
| description |
| "This list describes ISIS Overload reset trigger reasons."; |
| |
| leaf reset-trigger { |
| type leafref { |
| path "../config/reset-trigger"; |
| } |
| description |
| "Reference to the reset trigger reason"; |
| } |
| |
| container config { |
| description |
| "This container defines ISIS Overload Bit reset trigger |
| configuration."; |
| |
| uses isis-overload-bit-reset-config; |
| } |
| |
| container state { |
| config false; |
| description |
| "This container defines state for ISIS Overload Bit reset |
| triggers."; |
| |
| uses isis-overload-bit-reset-config; |
| } |
| } |
| } |
| } |
| |
| |
| grouping isis-base-level-config { |
| description |
| "This grouping defines ISIS Level configuration."; |
| |
| leaf level-number { |
| type oc-isis-types:level-number; |
| description |
| "ISIS level number (level-1, level-2)."; |
| } |
| } |
| |
| grouping isis-interface-level-config { |
| description |
| "This grouping defines ISIS Interface Level configuration."; |
| |
| leaf level-number { |
| type oc-isis-types:level-number; |
| description |
| "ISIS level number(level-1, level-2)."; |
| } |
| |
| leaf passive { |
| type boolean; |
| default false; |
| description |
| "ISIS passive interface admin enable/disable function."; |
| } |
| |
| leaf priority { |
| type uint8 { |
| range "0 .. 127"; |
| } |
| description |
| "ISIS neighbor priority(LAN hello PDU only)."; |
| } |
| } |
| |
| grouping isis-hello-timers-config { |
| description |
| "This grouping defines ISIS hello timers configuration."; |
| |
| leaf hello-interval { |
| type uint32; |
| description |
| "ISIS hello-interval value."; |
| } |
| |
| leaf hello-multiplier { |
| type uint8; |
| description |
| "ISIS hello-multiplier value."; |
| } |
| } |
| |
| grouping isis-interface-config { |
| description |
| "This grouping defines ISIS interface configuration."; |
| |
| leaf interface-id { |
| type oc-if:interface-id; |
| description |
| "Interface for which ISIS configuration is to be applied."; |
| } |
| |
| leaf passive { |
| type boolean; |
| default false; |
| description |
| "When set to true, the referenced interface is a passive interface |
| such that it is not eligible to establish adjacencies with other |
| systems, but is advertised into the IS-IS topology."; |
| } |
| |
| leaf hello-padding { |
| type oc-isis-types:hello-padding-type; |
| description |
| "This leaf controls padding type for IS-IS Hello PDUs."; |
| } |
| |
| leaf circuit-type { |
| type oc-isis-types:circuit-type; |
| description |
| "ISIS circuit type (p2p, broadcast)."; |
| } |
| } |
| |
| grouping isis-adaptive-timers-state { |
| description |
| "This grouping defines ISIS adaptive timers state"; |
| |
| leaf adaptive-timer { |
| type oc-isis-types:adaptive-timer-type; |
| description |
| "ISIS adaptive timer types (linear, exponential)."; |
| } |
| } |
| |
| grouping isis-lsp-generation-timers-config { |
| description |
| "This grouping defines ISIS LSP Generation timers configuration"; |
| |
| leaf lsp-max-wait-interval { |
| type uint64; |
| units milliseconds; |
| description |
| "Time interval in milliseconds that specifies max interval between |
| two consecutive occurrences of an LSP being generated."; |
| } |
| |
| leaf lsp-first-wait-interval { |
| type uint64; |
| units milliseconds; |
| description |
| "Time interval in milliseconds that specifies the first LSP generation |
| delay."; |
| } |
| |
| leaf lsp-second-wait-interval { |
| type uint64; |
| units milliseconds; |
| description |
| "Time interval in milliseconds that specifies the millisecond LSP |
| generation delay."; |
| } |
| } |
| |
| grouping isis-lsp-timers-config { |
| description |
| "This grouping defines ISIS LSP timers configuration"; |
| |
| leaf lsp-lifetime-interval { |
| type uint16; |
| units seconds; |
| default 1200; |
| description |
| "Time interval in seconds that specifies how long an LSP remains in |
| LSDB without being refreshed."; |
| } |
| |
| leaf lsp-refresh-interval { |
| type uint16; |
| units seconds; |
| description |
| "Time interval in seconds that specifies how often route topology |
| that a device originates is transmitted in LSPs."; |
| } |
| } |
| |
| grouping isis-spf-timers-config { |
| description |
| "This grouping defines ISIS SPF timers configuration."; |
| |
| leaf spf-hold-interval { |
| type uint64; |
| units milliseconds; |
| default 5000; |
| description |
| "SPF Hold Down time interval in milliseconds."; |
| } |
| |
| leaf spf-first-interval { |
| type uint64; |
| units milliseconds; |
| description |
| "Time interval in milliseconds between the |
| detection of topology change and when the SPF algorithm runs."; |
| } |
| leaf spf-second-interval { |
| type uint64; |
| units milliseconds; |
| description |
| "Time interval in milliseconds between the first and second |
| SPF calculation."; |
| } |
| } |
| |
| grouping isis-interface-timers-config { |
| description |
| "This grouping defines ISIS interface timers configuration."; |
| |
| leaf csnp-interval { |
| type uint16; |
| units seconds; |
| description |
| "The interval, specified in seconds, at which periodic CSNP packets |
| should be transmitted by the local IS."; |
| } |
| |
| leaf lsp-pacing-interval { |
| type uint64; |
| units milliseconds; |
| description |
| "The interval interval in milliseconds between the |
| detection of topology change and when the SPF algorithm runs."; |
| } |
| } |
| |
| grouping isis-transport-config { |
| description |
| "This grouping defines configuration parameters relating to the |
| transport protocol used by the ISIS."; |
| |
| leaf lsp-mtu-size { |
| type uint16; |
| description |
| "The maximum size in bytes of an IS-IS Link state PDU."; |
| } |
| } |
| |
| grouping isis-graceful-restart-config { |
| description |
| "This grouping defines ISIS graceful restart configuration."; |
| |
| leaf helper-only { |
| type boolean; |
| description |
| "Enable or disable the IS-IS graceful restart helper function. When |
| this leaf is set, the local system does not utilise the IS-IS |
| graceful restart procedures during its own restart, but supports |
| retaining forwarding information during a remote speaker's restart."; |
| } |
| reference "RFC 5306: Restart Signaling for IS-IS."; |
| } |
| |
| // configuration context containers |
| grouping inter-level-propagation-policies-structural { |
| description |
| "Propagate prefixes between IS-IS levels."; |
| |
| container inter-level-propagation-policies { |
| description |
| "Policies to propagate prefixes between IS-IS levels."; |
| |
| container level1-to-level2 { |
| description |
| "Policies relating to prefixes to be propagated from |
| Level 1 to Level 2."; |
| |
| container config { |
| description |
| "Configuration parameters relating to the propagation |
| of prefixes from IS-IS Level 1 to Level 2."; |
| |
| uses inter-level-propagation-policy-config; |
| } |
| |
| container state { |
| config false; |
| description |
| "Operational state parameters relating to the |
| propagation of prefixes from IS-IS Level 1 to Level 2."; |
| |
| uses inter-level-propagation-policy-config; |
| } |
| |
| } |
| |
| container level2-to-level1 { |
| description |
| "Policies relating to prefixes to be propagated from |
| Level2 to Level 1."; |
| |
| container config { |
| description |
| "Configuration parameters relating to the propagation |
| of prefixes from IS-IS Level 2 to Level 1."; |
| |
| uses inter-level-propagation-policy-config; |
| } |
| |
| container state { |
| config false; |
| description |
| "Operational state parameters relating to the propagation |
| of prefixes from IS-IS Level 2 to Level 1."; |
| |
| uses inter-level-propagation-policy-config; |
| } |
| } |
| } |
| } |
| |
| grouping inter-level-propagation-policy-config { |
| description |
| "Policy governing the propagation of prefixes between levels."; |
| |
| uses oc-rpol:apply-policy-import-config; |
| } |
| |
| grouping authentication-key-group-config { |
| description |
| "This grouping defines ISIS authentication key configuration."; |
| |
| uses authentication-key-config; |
| |
| // TODO(robjs): Add crypto-algorithm after merge of authentication modules. |
| //leaf crypto-algorithm { |
| // type identityref { |
| // base oc-auth-types:CRYPTO_TYPE; |
| // } |
| // description |
| // "Authentication key cryptographic algorithm to be used for key encryption."; |
| //} |
| } |
| |
| grouping isis-global-base { |
| description |
| "This grouping describes ISIS Global router."; |
| |
| container config { |
| description |
| "This container defines ISIS global configuration router."; |
| |
| uses isis-authentication-check-config; |
| uses isis-global-config; |
| } |
| |
| container state { |
| config false; |
| description |
| "This container defines state for ISIS global router."; |
| |
| uses isis-authentication-check-config; |
| uses isis-global-config; |
| } |
| |
| container lsp-bit { |
| description |
| "This container defines ISIS LSP Operational Bits."; |
| |
| container overload-bit { |
| description |
| "This container defines Overload Bit configuration."; |
| uses overload-bit-group; |
| } |
| |
| container attached-bit { |
| description |
| "This container defines Attached Bit."; |
| |
| container config { |
| description |
| "This container defines Attached Bit configuration."; |
| |
| uses isis-attached-bit-config; |
| } |
| |
| container state { |
| config false; |
| description |
| "This container defines state for Link State PDU Bit."; |
| |
| uses isis-attached-bit-config; |
| } |
| } |
| } |
| |
| container reference-bandwidth { |
| description |
| "This container defines ISIS Reference Bandwidth."; |
| |
| container config { |
| description |
| "This container defines Reference Bandwidth configuration"; |
| uses isis-reference-bandwidth-config; |
| } |
| |
| container state { |
| config false; |
| description |
| "This container defines state for Reference Bandwidth."; |
| |
| uses isis-reference-bandwidth-config; |
| } |
| } |
| |
| container nsr { |
| description |
| "This container defines ISIS Non-Stop Routing."; |
| |
| container config { |
| description |
| "This container defines Non-Stop-Routing configuration."; |
| |
| uses admin-config; |
| } |
| |
| container state { |
| config false; |
| description |
| "This container defines state for Non-Stop-Routing"; |
| |
| uses admin-config; |
| } |
| } |
| |
| container graceful-restart { |
| description |
| "This container defines ISIS Graceful Restart."; |
| |
| container config { |
| description |
| "This container defines ISIS graceful-restart configuration."; |
| |
| uses admin-config; |
| uses isis-graceful-restart-config; |
| } |
| |
| container state { |
| config false; |
| description |
| "This container defines state information for ISIS graceful-restart."; |
| |
| uses admin-config; |
| uses isis-graceful-restart-config; |
| } |
| } |
| |
| container timers { |
| description |
| "This container defines ISIS timers."; |
| |
| container config { |
| description |
| "This container defines ISIS global timers configuration."; |
| |
| uses isis-lsp-timers-config; |
| } |
| |
| container state { |
| config false; |
| description |
| "This container defines state information for ISIS global timers."; |
| |
| uses isis-lsp-timers-config; |
| } |
| |
| container spf { |
| description |
| "This container defines ISIS SPF timer settings."; |
| |
| container config { |
| description |
| "This container defines ISIS SPF timers configuration."; |
| |
| uses isis-spf-timers-config; |
| } |
| |
| container state { |
| config false; |
| description |
| "This container defines state information for ISIS SPF timers."; |
| |
| uses isis-spf-timers-config; |
| uses isis-adaptive-timers-state; |
| } |
| } |
| |
| container lsp-generation { |
| description |
| "This container defines ISIS LSP Generation."; |
| |
| container config { |
| description |
| "This container defines ISIS LSP Generation timers |
| configuration."; |
| |
| uses isis-lsp-generation-timers-config; |
| } |
| |
| container state { |
| config false; |
| description |
| "This container defines state information for ISIS LSP Generation |
| timers."; |
| |
| uses isis-lsp-generation-timers-config; |
| uses isis-adaptive-timers-state; |
| } |
| } |
| } |
| |
| container transport { |
| description |
| "This container defines ISIS transport."; |
| |
| container config { |
| description |
| "This container defines ISIS transport related configuration."; |
| |
| uses isis-transport-config; |
| } |
| |
| container state { |
| config false; |
| description |
| "This container defines state information for ISIS transport |
| parameters."; |
| |
| uses isis-transport-config; |
| } |
| } |
| |
| container mpls { |
| description |
| "Configuration and operational state relating to MPLS-related |
| features in IS-IS"; |
| |
| container igp-ldp-sync { |
| description |
| "Configuration and operational state relating to synchronisation |
| between the LDP and IS-IS"; |
| |
| container config { |
| description |
| "This container defines ISIS/IGP configuration."; |
| |
| uses isis-ldp-igp-config; |
| } |
| |
| container state { |
| config false; |
| description |
| "This container defines state information for ISIS/LDP Sync."; |
| |
| uses isis-ldp-igp-config; |
| } |
| } |
| } |
| |
| container igp-shortcuts { |
| description |
| "This container defines IGP shortcuts configuration and state |
| information."; |
| |
| uses isis-shortcuts-afi-list; |
| } |
| |
| container afi-safi { |
| description |
| "This container defines address-family specific configuration |
| and state information."; |
| |
| uses isis-afi-safi-list; |
| } |
| |
| uses oc-sr:sr-igp-top; |
| } |
| |
| grouping isis-route-preference-config { |
| description |
| "This grouping defines ISIS route preference configuration"; |
| |
| leaf external-route-preference { |
| type uint8 { |
| range "1..max"; |
| } |
| description |
| "Administrative Distance(preference) for external ISIS routes."; |
| } |
| |
| leaf internal-route-preference { |
| type uint8 { |
| range "1..max"; |
| } |
| description |
| "Administrative Distance(preference) for internal ISIS routes."; |
| } |
| } |
| |
| grouping isis-interfaces { |
| description |
| "This grouping defines ISIS interfaces configured on local system."; |
| |
| list interface { |
| key "interface-id"; |
| |
| description |
| "This list contains ISIS interfaces."; |
| |
| leaf interface-id { |
| type leafref { |
| path "../config/interface-id"; |
| } |
| description |
| "Reference to interface-id"; |
| } |
| |
| uses isis-interface-group; |
| uses oc-if:interface-ref; |
| } |
| } |
| |
| grouping isis-interface-group { |
| description |
| "This grouping defines ISIS interfaces configured on local system."; |
| |
| container config { |
| description |
| "This container defines ISIS interface configuration."; |
| |
| uses admin-config; |
| uses isis-interface-config; |
| } |
| |
| container state { |
| config false; |
| description |
| "This container defines state information for ISIS interfaces."; |
| |
| uses admin-config; |
| uses isis-interface-config; |
| } |
| |
| container circuit-counters { |
| description |
| "This container defines state information for ISIS circuit counters."; |
| |
| uses circuit-counters-structural; |
| } |
| |
| container authentication { |
| description |
| "This container defines ISIS authentication."; |
| |
| uses isis-hello-authentication-group; |
| } |
| |
| container afi-safi { |
| description |
| "This container defines address-family specific configuration |
| and state information."; |
| |
| uses isis-if-global-afi-safi-list; |
| } |
| |
| container levels { |
| description |
| "This container defines ISIS level specific configuration and |
| state information."; |
| |
| uses isis-interface-levels; |
| } |
| |
| container timers { |
| description |
| "This container describes ISIS interface timers configuration"; |
| |
| container config { |
| description |
| "Configuration parameters relating to interface |
| timers for IS-IS"; |
| |
| uses isis-interface-timers-config; |
| } |
| |
| container state { |
| config false; |
| description |
| "This container defines state information for ISIS interface timers."; |
| |
| uses isis-interface-timers-config; |
| } |
| } |
| |
| container bfd { |
| //TODO(bogdanov): Integrate BFD model/module |
| description |
| "This container defines BFD."; |
| |
| container config { |
| description |
| "This container defines BFD configuration parameters."; |
| |
| uses isis-bfd-config; |
| } |
| |
| container state { |
| config false; |
| description |
| "This container defines BFD state information."; |
| |
| uses isis-bfd-config; |
| } |
| } |
| } |
| |
| grouping isis-levels { |
| description |
| "This grouping defines global ISIS Levels."; |
| |
| list level { |
| key "level-number"; |
| |
| description |
| "Configuration and operational state parameters related to a |
| particular level within the IS-IS protocol instance"; |
| |
| leaf level-number { |
| type leafref { |
| path "../config/level-number"; |
| } |
| description |
| "Reference to ISIS level-number."; |
| } |
| |
| uses isis-level-group; |
| } |
| } |
| |
| grouping isis-interface-levels { |
| description |
| "This grouping defines ISIS interface Levels."; |
| |
| list level { |
| key "level-number"; |
| description |
| "Configuration and operational state parameters related to a |
| particular level on an IS-IS enabled interface."; |
| |
| leaf level-number { |
| type leafref { |
| path "../config/level-number"; |
| } |
| description |
| "Reference to ISIS level-number."; |
| } |
| |
| uses isis-interface-level-group; |
| } |
| } |
| |
| grouping isis-level-group { |
| description |
| "This grouping defines ISIS level configuration and state |
| information."; |
| |
| container config { |
| description |
| "This container defines ISIS level based configuration."; |
| |
| uses admin-config; |
| uses isis-base-level-config; |
| uses isis-metric-style-config; |
| uses isis-authentication-check-config; |
| } |
| |
| container state { |
| config false; |
| description |
| "This container defines ISIS level state information."; |
| |
| uses admin-config; |
| uses isis-base-level-config; |
| uses isis-metric-style-config; |
| uses isis-authentication-check-config; |
| } |
| |
| container system-level-counters { |
| description |
| "This container defines ISIS system level counters."; |
| |
| uses system-level-counters-structural; |
| } |
| |
| container link-state-database { |
| config false; |
| description |
| "This container defines ISIS LSDB."; |
| |
| list lsp { |
| key "lsp-id"; |
| description |
| "This list describes LSPs in the LSDB."; |
| uses lsp-state; |
| } |
| } |
| |
| container traffic-engineering { |
| description |
| "This container defines ISIS TE."; |
| |
| container config { |
| description |
| "This container defines ISIS TE configuration."; |
| |
| uses admin-config; |
| uses isis-te-config; |
| } |
| |
| container state { |
| config false; |
| description |
| "This container defines ISIS TE state information."; |
| |
| uses admin-config; |
| uses isis-te-config; |
| } |
| } |
| |
| container route-preference { |
| description |
| "This container defines Administrative Distance (or preference) |
| assigned to ISIS routes (level1 internal, level2 internal, level1 |
| external, level2 external)."; |
| |
| container config { |
| description |
| "This container defines route preference configuration."; |
| uses isis-route-preference-config; |
| } |
| |
| container state { |
| config false; |
| description |
| "This container defines ISIS route preference state information."; |
| uses isis-route-preference-config; |
| } |
| } |
| |
| container authentication { |
| description |
| "This container defines ISIS authentication."; |
| uses isis-authentication-group; |
| } |
| |
| } |
| |
| grouping isis-interface-level-group { |
| description |
| "This grouping defines ISIS interface level."; |
| |
| container config { |
| description |
| "This container defines interface ISIS level configuration."; |
| |
| uses isis-interface-level-config; |
| uses admin-config; |
| } |
| |
| container state { |
| config false; |
| description |
| "This container defines interface ISIS level state information."; |
| |
| uses isis-interface-level-config; |
| uses admin-config; |
| } |
| |
| container packet-counters { |
| description |
| "This container defines ISIS interface packet counters."; |
| |
| uses packet-counters-structural; |
| } |
| |
| container adjacencies { |
| config false; |
| description |
| "This container defines ISIS adjacencies."; |
| |
| list adjacency { |
| key "system-id"; |
| |
| description |
| "List of the local system's IS-IS adjacencies."; |
| |
| leaf system-id { |
| type leafref { |
| path "../state/system-id"; |
| } |
| description |
| "Reference to the IS neighbor."; |
| } |
| |
| container state { |
| description |
| "Operational state relating to the IS-IS adjacency with the |
| remote system"; |
| |
| uses adjacency-state; |
| } |
| } |
| } |
| |
| container timers { |
| description |
| "This container defines ISIS timers."; |
| |
| container config { |
| description |
| "This container defines ISIS interface hello-timers configuration."; |
| |
| uses isis-hello-timers-config; |
| } |
| |
| container state { |
| config false; |
| description |
| "This container defines ISIS interface hello-timers state."; |
| |
| uses isis-hello-timers-config; |
| } |
| } |
| |
| container afi-safi { |
| description |
| "This container defines address-family specific configuration |
| and state information."; |
| |
| uses isis-if-afi-safi-list; |
| } |
| |
| container hello-authentication { |
| description |
| "This container defines ISIS authentication."; |
| |
| uses isis-hello-authentication-group; |
| } |
| } |
| |
| |
| grouping isis-top { |
| description |
| "This grouping define top-level ISIS model data."; |
| |
| container isis { |
| description |
| "This container defines top-level ISIS configuration and state |
| information."; |
| |
| container global { |
| description |
| "This container defines global ISIS configuration and state |
| information."; |
| |
| uses isis-global-base; |
| uses inter-level-propagation-policies-structural; |
| } |
| |
| container levels { |
| description |
| "This container defines ISIS level configuration and state |
| information."; |
| uses isis-levels; |
| } |
| |
| container interfaces { |
| description |
| "This container defines global ISIS interface configuration and |
| state information."; |
| uses isis-interfaces; |
| } |
| } |
| } |
| |
| grouping adjacency-state { |
| description |
| "This grouping defines ISIS adjacency."; |
| |
| leaf system-id { |
| type oc-isis-types:system-id; |
| description |
| "ISIS neighbor system-id."; |
| } |
| |
| leaf neighbor-ipv4-address { |
| type inet:ipv4-address-no-zone; |
| description |
| "ISIS Neighbor IPv4 address."; |
| } |
| |
| leaf neighbor-ipv6-address { |
| type inet:ipv6-address-no-zone; |
| description |
| "ISIS Neighbor IPv6 address."; |
| } |
| |
| leaf neighbor-snpa { |
| type oc-isis-types:snpa; |
| description |
| "ISIS neighbor SNPA."; |
| } |
| |
| leaf local-extended-circuit-id { |
| type oc-isis-types:extended-circuit-id; |
| description |
| "Local extended circuit ID."; |
| } |
| leaf neighbor-extended-circuit-id { |
| type oc-isis-types:extended-circuit-id; |
| description |
| "ISIS neighbor extended circuit ID."; |
| } |
| |
| leaf priority { |
| type uint8 { |
| range "0..127"; |
| } |
| description |
| "Priority of the neighboring IS(LAN Hello only)."; |
| } |
| |
| leaf dis-system-id { |
| type oc-isis-types:system-id; |
| description |
| "DIS System ID(LAN hello only)."; |
| } |
| |
| leaf neighbor-circuit-type { |
| type oc-isis-types:level-type; |
| description |
| "Received ISIS circuit type (level-1, level-2, level-1-2)."; |
| } |
| |
| leaf adjacency-type { |
| type oc-isis-types:level-type; |
| description |
| "Formed ISIS adjacency type(level-1, level-2, level-1-2)."; |
| } |
| |
| leaf adjacency-state { |
| type oc-isis-types:isis-interface-adj-state; |
| description |
| "P2P 3-way ISIS adjacency state(up, down, init, failed)."; |
| reference "RFC4303. TLV 240."; |
| } |
| |
| leaf remaining-hold-time { |
| type uint16; |
| units seconds; |
| description |
| "Holding time in seconds for adjacency. This value is based on received |
| hello PDUs and the elapsed time since receipt."; |
| } |
| |
| leaf up-time { |
| type yang:timestamp; |
| description |
| "Adjacency up time."; |
| } |
| |
| leaf multi-topology { |
| type boolean; |
| description |
| "When set to true, ISIS multi-topology is supported."; |
| reference "RFC5129. TLV 229."; |
| } |
| |
| leaf-list topology { |
| type identityref { |
| base oc-isis-types:AFI_SAFI_TYPE; |
| } |
| description |
| "ISIS topology type support(ipv4-unicast, ipv6-unicast, |
| ipv4-multicast, ipv6-multicast)."; |
| } |
| |
| leaf restart-support { |
| type boolean; |
| description |
| "When set to true, Graceful-restart signaling is supported."; |
| } |
| |
| leaf restart-suppress { |
| type boolean; |
| description |
| "When set to true, adjacency is not advertised. The SA bit is used by a |
| starting router to request that its neighbor suppress advertisement of |
| the adjacency to the starting router in the neighbor's LSPs."; |
| } |
| |
| leaf restart-status { |
| type boolean; |
| description |
| "When set to true, neighbor is being helped. The RR bit is used by a |
| (re)starting router to signal to its neighbors that a (re)start is in |
| progress."; |
| } |
| |
| leaf-list area-address { |
| type oc-isis-types:area-address; |
| description |
| "List of ISIS area-address(es)."; |
| } |
| |
| leaf-list nlpid { |
| type enumeration { |
| enum IPV4 { |
| description |
| "IPv4 Address family."; |
| } |
| enum IPV6 { |
| description |
| "IPv6 Address family."; |
| } |
| } |
| description |
| "Supported Protocol. IPv4 is defined as (0xcc) |
| and IPv6 - (0x8e). ISIS reference is TLV 129."; |
| } |
| |
| // TODO(bogdanov): update when BFD model is integrated. |
| //leaf ipv4-bfd-status { |
| //type oc-isis-types:bfd-state; |
| //description |
| // "IPv4 BFD session status."; |
| //} |
| //leaf ipv6-bfd-status { |
| //type oc-isis-types:bfd-state; |
| //description |
| // "IPv4 BFD session status. "; |
| //} |
| |
| } |
| |
| grouping packet-counters-generic-state { |
| description |
| "Operational state parameters relating to LSP packet counters."; |
| |
| leaf received { |
| type yang:counter32; |
| description |
| "The number of the specified type of PDU received on the interface."; |
| } |
| leaf processed { |
| type yang:counter32; |
| description |
| "The number of the specified type of PDU received on the interface |
| that have been processed by the local system."; |
| } |
| leaf dropped { |
| type yang:counter32; |
| description |
| "The number of the specified type of PDU received on the interface |
| that have been dropped."; |
| } |
| |
| leaf sent { |
| type yang:counter32; |
| description |
| "The number of the specified type of PDU that have been sent by the |
| local system on the interface."; |
| } |
| |
| leaf retransmit { |
| type yang:counter32; |
| description |
| "The number of the specified type of PDU that that have been |
| retransmitted by the local system on the interface."; |
| } |
| } |
| |
| grouping packet-counters-structural { |
| description |
| "This grouping defines ISIS packet counter state."; |
| |
| container lsp { |
| description |
| "This container defines LSP packet counters."; |
| |
| container state { |
| config false; |
| description |
| "This container defines LSP PDU counters."; |
| |
| uses packet-counters-generic-state; |
| } |
| } |
| |
| container iih { |
| description |
| "This container defines IIH packet counters."; |
| |
| container state { |
| config false; |
| description |
| "Operational counters relating to IIH PDUs"; |
| |
| uses packet-counters-generic-state; |
| } |
| } |
| |
| container ish { |
| description |
| "This container defines ISH packet counters."; |
| |
| container state { |
| config false; |
| description |
| "Operational state relating to ISH PDUs."; |
| |
| uses packet-counters-generic-state; |
| } |
| } |
| |
| container esh { |
| description |
| "This container defines ESH packet counters."; |
| container state { |
| config false; |
| description |
| "Operational state relating to ESH PDUs"; |
| |
| uses packet-counters-generic-state; |
| } |
| } |
| |
| container psnp { |
| description |
| "This container defines PSNP packet counters."; |
| |
| container state { |
| config false; |
| description |
| "Packet counters relating to PSNPs."; |
| |
| uses packet-counters-generic-state; |
| } |
| } |
| |
| container csnp { |
| description |
| "Operational state parameters relating to CSNPs."; |
| |
| container state { |
| config false; |
| description |
| "Packet counters relating to CSNPs."; |
| |
| uses packet-counters-generic-state; |
| } |
| } |
| |
| container unknown { |
| description |
| "Operational state parameters relating to IS-IS PDUs that are not |
| otherwise classified - referred to as Unknown PDUs."; |
| |
| container state { |
| config false; |
| description |
| "Packet counters relating to unknown PDUs."; |
| |
| uses packet-counters-generic-state; |
| } |
| } |
| } |
| |
| grouping system-level-counters-state { |
| description |
| "IS-IS counters that are relevant to the system IS-IS context."; |
| |
| leaf corrupted-lsps { |
| type yang:counter32; |
| description |
| "Number of corrupted in-memory LSPs detected. LSPs received from the |
| wire with a bad checksum are silently dropped and not counted. LSPs |
| received from the wire with parse errors are counted by lsp-errors. MIB |
| Entry: SysCorrLSPs."; |
| } |
| |
| leaf database-overloads { |
| type yang:counter32; |
| description |
| "Number of times the database has become |
| overloaded. |
| MIB entry: SysLSPL(Level)DbaseOloads."; |
| } |
| |
| leaf manual-address-drop-from-areas { |
| type yang:counter32; |
| description |
| "Number of times a manual address has been dropped from area. |
| MIB Entry: SysManAddrDropFromAreas."; |
| } |
| |
| leaf exceed-max-seq-nums { |
| type yang:counter32; |
| description |
| "The number of times the system has attempted to exceed the maximum |
| sequence number. MIB Entry: SysAttmptToExMaxSeqNums."; |
| } |
| leaf seq-num-skips { |
| type yang:counter32; |
| description |
| "Number of times a sequence number skip has occurred. MIB Entry: |
| SysSeqNumSkips."; |
| } |
| |
| leaf own-lsp-purges { |
| type yang:counter32; |
| description |
| "Number of times a zero-aged copy of the system's |
| own LSP is received from some other node. |
| MIB Entry: isisSysOwnLSPPurges."; |
| } |
| |
| leaf id-len-mismatch { |
| type yang:counter32; |
| description |
| "Number of times a PDU is received with a different value for ID field |
| length from that of the receiving system. MIB Entry: |
| isisSysIDFieldLenMismatches."; |
| } |
| |
| leaf part-changes { |
| type yang:counter32; |
| description |
| "The number of partition changes detected. MIB Entry: SysPartChanges."; |
| } |
| |
| leaf max-area-address-mismatches { |
| type yang:counter32; |
| description |
| "Number of times a PDU is received with a different value for |
| MaximumAreaAddresses from that of the receiving system. MIB Entry: |
| SysMaxAreaAddrMismatches."; |
| } |
| |
| leaf auth-fails { |
| type yang:counter32; |
| description |
| "The number of authentication key failures. |
| MIB Entry: SysAuthFails."; |
| } |
| |
| leaf spf-runs { |
| type yang:counter32; |
| description |
| "The number of times SPF was ran at this level."; |
| } |
| |
| leaf auth-type-fails { |
| type yang:counter32; |
| description |
| "The number of authentication type mismatches."; |
| } |
| |
| leaf lsp-errors { |
| type yang:counter32; |
| description |
| "The number of received LSPs with errors."; |
| } |
| } |
| |
| grouping system-level-counters-structural { |
| description |
| "This grouping defines system level counters."; |
| |
| container state { |
| config false; |
| description |
| "The container defines a list of system counters for the IS."; |
| |
| uses system-level-counters-state; |
| } |
| } |
| |
| grouping circuit-counters-state { |
| description |
| "Operational state parameters relating to counters specific to one |
| interface or circuit."; |
| |
| leaf adj-changes { |
| type yang:counter32; |
| description |
| "Number of times an adjacency state change has occurred on this circuit. |
| MIB Entry: CircAdjChanges."; |
| } |
| |
| leaf init-fails { |
| type yang:counter32; |
| description |
| "Number of times initialization of this circuit has failed. This counts |
| events such as PPP NCP failures. MIB Entry: CircInitFails."; |
| } |
| |
| leaf rejected-adj { |
| type yang:counter32; |
| description |
| "Number of times an adjacency has been rejected on this circuit. MIB |
| Entry: CircRejAdjs."; |
| } |
| |
| leaf id-field-len-mismatches { |
| type yang:counter32; |
| description |
| "Number of times an IS-IS control PDU with an ID field length different |
| from that for this system has been received. |
| MIB Entry: CircIDFieldLenMismatches."; |
| } |
| |
| leaf max-area-address-mismatches { |
| type yang:counter32; |
| description |
| "Number of times an IS-IS control PDU with a max area address field |
| different from that for this system has been received. MIB Entry: |
| CircMaxAreaAddrMismatches."; |
| } |
| |
| leaf auth-type-fails { |
| type yang:counter32; |
| description |
| "Number of times an IS-IS control PDU with an auth type field different |
| from that for this system has been received. MIB Entry: |
| CircAuthTypeFails."; |
| } |
| |
| leaf auth-fails { |
| type yang:counter32; |
| description |
| "Number of times an IS-IS control PDU with the correct auth type has |
| failed to pass authentication validation. MIB Entry: CircAuthFails."; |
| } |
| |
| leaf lan-dis-changes { |
| type yang:counter32; |
| description |
| "Number of times the Designated IS has changed on this circuit at this |
| level. If the circuit is point to point, this count is zero. MIB Entry: |
| CircLANDesISChanges."; |
| } |
| |
| leaf adj-number { |
| type uint32; |
| description |
| "Number of adjacencies on this circuit. |
| MIB Entry: CircNumAdj."; |
| } |
| } |
| |
| grouping circuit-counters-structural { |
| description |
| "This grouping defines circuit counters."; |
| |
| container state { |
| config false; |
| description |
| "The container defines a list of counters for IS circuit."; |
| |
| uses circuit-counters-state; |
| } |
| } |
| } |