From 2d2533772ecb6aefeb5d5083a036f82a2491069d Mon Sep 17 00:00:00 2001 From: samier barguil Date: Mon, 23 Oct 2023 15:38:11 +0200 Subject: [PATCH] update based on previous PR --- Yang/ietf-isis@2022-10-19.yang | 4455 +++++++++++++++++ Yang/ietf-l3-isis-topology.yang | 201 + Yang/ietf-l3-unicast-topology@2018-02-26.yang | 359 ++ Yang/ietf-network-topology@2018-02-26.yang | 294 ++ Yang/ietf-network@2018-02-26.yang | 192 + draft-ogondio-opsawg-isis-topology.md | 19 +- 6 files changed, 5503 insertions(+), 17 deletions(-) create mode 100644 Yang/ietf-isis@2022-10-19.yang create mode 100644 Yang/ietf-l3-isis-topology.yang create mode 100644 Yang/ietf-l3-unicast-topology@2018-02-26.yang create mode 100644 Yang/ietf-network-topology@2018-02-26.yang create mode 100644 Yang/ietf-network@2018-02-26.yang diff --git a/Yang/ietf-isis@2022-10-19.yang b/Yang/ietf-isis@2022-10-19.yang new file mode 100644 index 0000000..cbbfc08 --- /dev/null +++ b/Yang/ietf-isis@2022-10-19.yang @@ -0,0 +1,4455 @@ +module ietf-isis { + yang-version 1.1; + namespace "urn:ietf:params:xml:ns:yang:ietf-isis"; + prefix isis; + + import ietf-routing { + prefix rt; + reference + "RFC 8349: A YANG Data Model for Routing Management + (NMDA Version)"; + } + import ietf-inet-types { + prefix inet; + reference + "RFC 6991: Common YANG Data Types"; + } + import ietf-yang-types { + prefix yang; + reference + "RFC 6991: Common YANG Data Types"; + } + import ietf-interfaces { + prefix if; + reference + "RFC 8343: A YANG Data Model for Interface Management"; + } + import ietf-key-chain { + prefix key-chain; + reference + "RFC 8177: YANG Data Model for Key Chains"; + } + import ietf-routing-types { + prefix rt-types; + reference + "RFC 8294: Common YANG Data Types for the Routing Area"; + } + import iana-routing-types { + prefix iana-rt-types; + reference + "RFC 8294: Common YANG Data Types for the Routing Area"; + } + import ietf-bfd-types { + prefix bfd-types; + reference + "RFC 9314: YANG Data Model for Bidirectional Forwarding + Detection (BFD)"; + } + + organization + "IETF LSR Working Group"; + contact + "WG Web: + WG List: + + Editor: Stephane Litkowski + + + Author: Derek Yeung + + + Author: Acee Lindem + + + Author: Jeffrey Zhang + + + Author: Ladislav Lhotka + "; + description + "This YANG module defines the generic configuration and + operational states for the IS-IS protocol common to all + vendor implementations. It is intended that the module + will be extended by vendors to define vendor-specific + IS-IS configuration parameters and policies - + for example, route maps or route policies. + + This YANG data model conforms to the Network Management + Datastore Architecture (NMDA) as described in RFC 8342. + + The key words 'MUST', 'MUST NOT', 'REQUIRED', 'SHALL', 'SHALL + NOT', 'SHOULD', 'SHOULD NOT', 'RECOMMENDED', 'NOT RECOMMENDED', + 'MAY', and 'OPTIONAL' in this document are to be interpreted as + described in BCP 14 (RFC 2119) (RFC 8174) when, and only when, + they appear in all capitals, as shown here. + + Copyright (c) 2022 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 Revised BSD License set + forth in Section 4.c of the IETF Trust's Legal Provisions + Relating to IETF Documents + (https://trustee.ietf.org/license-info). + + This version of this YANG module is part of RFC 9130; see the + RFC itself for full legal notices."; + reference + "RFC 8342: Network Management Datastore Architecture (NMDA)"; + + revision 2022-10-19 { + description + "Initial revision."; + reference + "RFC 9130: YANG Data Model for the IS-IS Protocol"; + } + + /* Identities */ + + identity isis { + base rt:routing-protocol; + description + "Identity for the IS-IS routing protocol."; + } + + identity lsp-log-reason { + description + "Base identity for a Link State PDU (LSP) + change log reason."; + } + + identity refresh { + base lsp-log-reason; + description + "Identity used when the LSP log reason is that an LSP + refresh was received."; + } + + identity content-change { + base lsp-log-reason; + description + "Identity used when the LSP log reason is + a change in the contents of the LSP."; + } + + identity frr-protection-method { + description + "Base identity for a Fast Reroute protection method."; + } + + identity frr-protection-method-lfa { + base frr-protection-method; + description + "Loop-Free Alternate as defined in RFC 5286."; + reference + "RFC 5286: Basic Specification for IP Fast Reroute: + Loop-Free Alternates"; + } + + identity frr-protection-method-rlfa { + base frr-protection-method; + description + "Remote Loop-Free Alternate as defined in RFC 7490."; + reference + "RFC 7490: Remote Loop-Free Alternate (LFA) + Fast Reroute (FRR)"; + } + + identity frr-protection-method-rsvpte { + base frr-protection-method; + description + "RSVP-TE as defined in RFC 4090."; + reference + "RFC 4090: Fast Reroute Extensions to RSVP-TE for + LSP Tunnels"; + } + + identity frr-protection-available-type { + description + "Base identity for Fast Reroute protection types + provided by an alternate path."; + } + + identity frr-protection-available-node-type { + base frr-protection-available-type; + description + "Node protection is provided by the alternate."; + } + + identity frr-protection-available-link-type { + base frr-protection-available-type; + description + "Link protection is provided by the alternate."; + } + + identity frr-protection-available-srlg-type { + base frr-protection-available-type; + description + "Shared Risk Link Group (SRLG) protection is provided by + the alternate."; + } + + identity frr-protection-available-downstream-type { + base frr-protection-available-type; + description + "The alternate is downstream of the node in the path."; + } + + identity frr-protection-available-other-type { + base frr-protection-available-type; + description + "The level of protection is unknown."; + } + + identity frr-alternate-type { + description + "Base identity for the IP Fast Reroute alternate type."; + } + + identity frr-alternate-type-equal-cost { + base frr-alternate-type; + description + "ECMP-based alternate."; + } + + identity frr-alternate-type-lfa { + base frr-alternate-type; + description + "LFA-based alternate."; + } + + identity frr-alternate-type-remote-lfa { + base frr-alternate-type; + description + "Remote-LFA-based alternate."; + } + + identity frr-alternate-type-tunnel { + base frr-alternate-type; + description + "Tunnel-based alternate (such as RSVP-TE or GRE)."; + } + + identity frr-alternate-mrt { + base frr-alternate-type; + description + "MRT-based alternate."; + } + + identity frr-alternate-tilfa { + base frr-alternate-type; + description + "TI-LFA-based alternate."; + } + + identity frr-alternate-other { + base frr-alternate-type; + description + "Other type of alternate."; + } + + identity unidirectional-link-delay-subtlv-flag { + description + "Base identity for the flag corresponding to the + Unidirectional Link Delay sub-TLV as defined in RFC 8570."; + reference + "RFC 8570: IS-IS Traffic Engineering (TE) Metric Extensions"; + } + + identity unidirectional-link-delay-subtlv-a-flag { + base unidirectional-link-delay-subtlv-flag; + description + "The 'A' bit field represents the Anomalous (A) bit. + The A bit is set when the measured value of + this parameter exceeds its configured + maximum threshold. + The A bit is cleared when the measured value + falls below its configured reuse threshold. + If the A bit is clear, + the value represents steady-state link performance."; + } + + identity min-max-unidirectional-link-delay-subtlv-flag { + description + "Base identity for the flag corresponding to the Min/Max + Unidirectional Link Delay sub-TLV as defined in RFC 8570."; + reference + "RFC 8570: IS-IS Traffic Engineering (TE) Metric Extensions"; + } + + identity min-max-unidirectional-link-delay-subtlv-a-flag { + base min-max-unidirectional-link-delay-subtlv-flag; + description + "The 'A' bit field represents the Anomalous (A) bit. + The A bit is set when the measured value of + this parameter exceeds its configured + maximum threshold. + The A bit is cleared when the measured value + falls below its configured reuse threshold. + If the A bit is clear, + the value represents steady-state link performance."; + } + + identity unidirectional-link-loss-subtlv-flag { + description + "Base identity for the flag corresponding to the + Unidirectional Link Loss sub-TLV as defined in RFC 8570."; + reference + "RFC 8570: IS-IS Traffic Engineering (TE) Metric Extensions"; + } + + identity unidirectional-link-loss-subtlv-a-flag { + base unidirectional-link-loss-subtlv-flag; + description + "The 'A' bit field represents the Anomalous (A) bit. + The A bit is set when the measured value of + this parameter exceeds its configured + maximum threshold. + The A bit is cleared when the measured value + falls below its configured reuse threshold. + If the A bit is clear, + the value represents steady-state link performance."; + } + + identity tlv229-flag { + description + "Base identity for the flag corresponding to TLV 229 + (M-Topologies) as defined in RFC 5120."; + reference + "RFC 5120: M-ISIS: Multi Topology (MT) Routing in + Intermediate System to Intermediate Systems (IS-ISs)"; + } + + identity tlv229-overload-flag { + base tlv229-flag; + description + "If set, the originator is overloaded + and must be avoided in the path calculation."; + } + + identity tlv229-attached-flag { + base tlv229-flag; + description + "If set, the originator is attached to + another area using the referred metric."; + } + + identity router-capability-flag { + description + "Base identity for the flag corresponding to the + Router Capability TLV as defined in RFC 7981."; + reference + "RFC 7981: IS-IS Extensions for Advertising Router + Information"; + } + + identity router-capability-flooding-flag { + base router-capability-flag; + description + "Quote from RFC 7981: + 'If the S bit is set(1), the IS-IS Router CAPABILITY TLV + MUST be flooded across the entire routing domain. If the + S bit is not set(0), the TLV MUST NOT be leaked between + levels. This bit MUST NOT be altered during the TLV + leaking.'"; + } + + identity router-capability-down-flag { + base router-capability-flag; + description + "Quote from RFC 7981: + 'When the IS-IS Router CAPABILITY TLV is leaked from + Level 2 (L2) to Level 1 (L1), the D bit MUST be set. + Otherwise, this bit MUST be clear. IS-IS Router + CAPABILITY TLVs with the D bit set MUST NOT be leaked from + Level 1 to Level 2. This is to prevent TLV looping.'"; + } + + identity lsp-flag { + description + "Base identity for LSP attributes as defined in ISO 10589."; + reference + "ISO 10589: Intermediate System to Intermediate System + intra-domain routeing information exchange protocol + for use in conjunction with the protocol for providing + the connectionless-mode network service (ISO 8473)"; + } + + identity lsp-partitioned-flag { + base lsp-flag; + description + "Originator partition repair supported."; + } + + identity lsp-attached-error-metric-flag { + base lsp-flag; + description + "Set when the originator is attached to + another area using the error metric."; + } + + identity lsp-attached-delay-metric-flag { + base lsp-flag; + description + "Set when the originator is attached to + another area using the delay metric."; + } + + identity lsp-attached-expense-metric-flag { + base lsp-flag; + description + "Set when the originator is attached to + another area using the expense metric."; + } + + identity lsp-attached-default-metric-flag { + base lsp-flag; + description + "Set when the originator is attached to + another area using the default metric."; + } + + identity lsp-overload-flag { + base lsp-flag; + description + "If set, the originator is overloaded + and must be avoided in the path calculation."; + } + + identity lsp-l1-system-flag { + base lsp-flag; + description + "Set when the Intermediate System has an L1 type."; + } + + identity lsp-l2-system-flag { + base lsp-flag; + description + "Set when the Intermediate System has an L2 type."; + } + + /* Feature definitions */ + + feature osi-interface { + description + "Support of OSI-specific parameters on an interface."; + } + + feature poi-tlv { + description + "Support of the Purge Originator Identification (POI) TLV."; + reference + "RFC 6232: Purge Originator Identification TLV for IS-IS"; + } + + feature ietf-spf-delay { + description + "Support for the IETF SPF delay algorithm."; + reference + "RFC 8405: Shortest Path First (SPF) Back-Off Delay Algorithm + for Link-State IGPs"; + } + + feature bfd { + description + "Support for detection of IS-IS neighbor reachability + via BFD."; + reference + "RFC 5880: Bidirectional Forwarding Detection (BFD) + RFC 5881: Bidirectional Forwarding Detection (BFD) + for IPv4 and IPv6 (Single Hop)"; + } + + feature key-chain { + description + "Support of key chains for authentication."; + reference + "RFC 8177: YANG Data Model for Key Chains"; + } + + feature node-flag { + description + "Support for node flags for IS-IS prefixes."; + reference + "RFC 7794: IS-IS Prefix Attributes for Extended IPv4 and IPv6 + Reachability"; + } + + feature node-tag { + description + "Support for node administrative tags for IS-IS + routing instances."; + reference + "RFC 7917: Advertising Node Administrative Tags in IS-IS"; + } + + feature ldp-igp-sync { + description + "Support for LDP IGP synchronization."; + reference + "RFC 5443: LDP IGP Synchronization"; + } + + feature fast-reroute { + description + "Support for IP Fast Reroute (IP FRR)."; + } + + feature nsr { + description + "Support for Non-Stop-Routing (NSR). The IS-IS NSR feature + allows a router with redundant control-plane capability + (e.g., dual Route Processor (RP) cards) to maintain its + state and adjacencies during planned and unplanned + IS-IS instance restarts. It differs from graceful restart + or Non-Stop Forwarding (NSF) in that no protocol signaling + or assistance from adjacent IS-IS neighbors is required to + recover control-plane state."; + } + + feature lfa { + description + "Support for Loop-Free Alternates (LFAs)."; + reference + "RFC 5286: Basic Specification for IP Fast Reroute: + Loop-Free Alternates"; + } + + feature remote-lfa { + description + "Support for remote LFAs (R-LFAs)."; + reference + "RFC 7490: Remote Loop-Free Alternate (LFA) + Fast Reroute (FRR)"; + } + + feature overload-max-metric { + description + "Support of overload by setting all links to the maximum + link metric. In IS-IS, the overload bit is usually used to + signal that a node cannot be used as a transit node. The + 'overload-max-metric' feature provides similar behavior, + also setting all the link metrics to MAX_METRIC."; + } + + feature prefix-tag { + description + "Support for 32-bit prefix tags."; + reference + "RFC 5130: A Policy Control Mechanism in IS-IS Using + Administrative Tags"; + } + + feature prefix-tag64 { + description + "Support for 64-bit prefix tags."; + reference + "RFC 5130: A Policy Control Mechanism in IS-IS Using + Administrative Tags"; + } + + feature auto-cost { + description + "Support for an IS-IS interface metric computation + according to a reference bandwidth."; + } + + feature te-rid { + description + "Traffic Engineering router ID."; + reference + "RFC 5305: IS-IS Extensions for Traffic Engineering + RFC 6119: IPv6 Traffic Engineering in IS-IS"; + } + + feature max-ecmp { + description + "Sets the maximum number of ECMP paths."; + } + + feature multi-topology { + description + "Support for Multi-Topology (MT) Routing."; + reference + "RFC 5120: M-ISIS: Multi Topology (MT) Routing in + Intermediate System to Intermediate Systems (IS-ISs)"; + } + + feature nlpid-control { + description + "Support for the advertisement of a Network Layer + Protocol Identifier within an IS-IS configuration."; + } + + feature graceful-restart { + description + "Support for IS-IS graceful restart."; + reference + "RFC 8706: Restart Signaling for IS-IS"; + } + + feature lsp-refresh { + description + "Configuration of the LSP refresh interval."; + } + + feature maximum-area-addresses { + description + "Support for 'maximum-area-addresses' configuration."; + } + + feature admin-control { + description + "Administrative control of the protocol state."; + } + + /* Type definitions */ + + typedef circuit-id { + type uint8; + description + "This type defines the circuit ID + associated with an interface."; + } + + typedef extended-circuit-id { + type uint32; + description + "This type defines the extended circuit ID + associated with an interface."; + } + + typedef interface-type { + type enumeration { + enum broadcast { + description + "Broadcast interface type."; + } + enum point-to-point { + description + "Point-to-point interface type."; + } + } + description + "This type defines the type of adjacency + to be established for the interface. + 'interface-type' determines the type + of Hello message that is used."; + } + + typedef level { + type enumeration { + enum level-1 { + description + "This enum indicates L1-only capability."; + } + enum level-2 { + description + "This enum indicates L2-only capability."; + } + enum level-all { + description + "This enum indicates capability for both levels."; + } + } + default "level-all"; + description + "This type defines the IS-IS level of an object."; + } + + typedef adj-state-type { + type enumeration { + enum up { + description + "This state indicates that the adjacency is established."; + } + enum down { + description + "This state indicates that the adjacency is + NOT established."; + } + enum init { + description + "This state indicates that the adjacency is being + established."; + } + enum failed { + description + "This state indicates that the adjacency has failed."; + } + } + description + "This type defines the states of an adjacency."; + } + + typedef if-state-type { + type enumeration { + enum up { + description + "'up' state."; + } + enum down { + description + "'down' state."; + } + } + description + "This type defines the state of an interface."; + } + + typedef level-number { + type uint8 { + range "1 .. 2"; + } + description + "This type defines the current IS-IS level."; + } + + typedef lsp-id { + type string { + pattern '[0-9A-Fa-f]{4}\.[0-9A-Fa-f]{4}\.[0-9A-Fa-f]' + + '{4}\.[0-9][0-9]-[0-9][0-9]'; + } + description + "This type defines the IS-IS LSP ID format using a + pattern. An example LSP ID is '0143.0438.AEF0.02-01'."; + } + + typedef area-address { + type string { + pattern '[0-9A-Fa-f]{2}(\.[0-9A-Fa-f]{4}){0,6}'; + } + description + "This type defines the area address format."; + } + + typedef snpa { + type string { + length "0 .. 20"; + } + description + "This type defines the Subnetwork Point of Attachment (SNPA) + format. The SNPA should be encoded according to the rules + specified for the particular type of subnetwork being used. + As an example, for an Ethernet subnetwork, the SNPA is + encoded as a Media Access Control (MAC) address, such as + '00aa.bbcc.ddee'."; + } + + typedef system-id { + type string { + pattern '[0-9A-Fa-f]{4}\.[0-9A-Fa-f]{4}\.[0-9A-Fa-f]{4}'; + } + description + "This type defines the IS-IS system ID by using a pattern. + An example system ID is '0143.0438.AEF0'."; + } + + typedef extended-system-id { + type string { + pattern '[0-9A-Fa-f]{4}\.[0-9A-Fa-f]{4}\.[0-9A-Fa-f]{4}\.' + + '[0-9][0-9]'; + } + description + "This type defines the IS-IS system ID using a pattern. + 'extended-system-id' contains the pseudonode number + in addition to the system ID. + An example extended system ID is '0143.0438.AEF0.00'."; + } + + typedef wide-metric { + type uint32 { + range "0 .. 16777215"; + } + description + "This type defines the wide-style format of an IS-IS metric."; + } + + typedef std-metric { + type uint8 { + range "0 .. 63"; + } + description + "This type defines the old-style format of the IS-IS metric."; + } + + typedef mesh-group-state { + type enumeration { + enum mesh-inactive { + description + "The interface is not part of a mesh group."; + } + enum mesh-set { + description + "The interface is part of a mesh group."; + } + enum mesh-blocked { + description + "LSPs must not be flooded over this interface."; + } + } + description + "This type describes the mesh group state of an interface."; + } + + /* Grouping for notifications */ + + grouping notification-instance-hdr { + description + "Instance-specific IS-IS notification data grouping."; + leaf routing-protocol-name { + type leafref { + path "/rt:routing/rt:control-plane-protocols/" + + "rt:control-plane-protocol/rt:name"; + } + description + "Name of the IS-IS instance."; + } + leaf isis-level { + type level; + description + "IS-IS level of the instance."; + } + } + + grouping notification-interface-hdr { + description + "Interface-specific IS-IS notification data grouping."; + leaf interface-name { + type if:interface-ref; + description + "IS-IS interface name."; + } + leaf interface-level { + type level; + description + "IS-IS level of the interface."; + } + leaf extended-circuit-id { + type extended-circuit-id; + description + "Extended circuit ID of the interface."; + } + } + + /* Groupings for IP Fast Reroute */ + + grouping instance-fast-reroute-config { + description + "This group defines the global configuration of IP + Fast Reroute (FRR)."; + container fast-reroute { + if-feature "fast-reroute"; + description + "This container may be augmented with global + parameters for IP FRR."; + container lfa { + if-feature "lfa"; + description + "This container may be augmented with + global parameters for Loop-Free Alternates (LFAs). + The creation of this container has no effect on + LFA activation."; + } + } + } + + grouping interface-lfa-config { + leaf candidate-enabled { + type boolean; + default "true"; + description + "Enables the interface to be used as a backup."; + } + leaf enabled { + type boolean; + default "false"; + description + "Activates the LFA. Per-prefix LFA computation is assumed."; + } + container remote-lfa { + if-feature "remote-lfa"; + leaf enabled { + type boolean; + default "false"; + description + "Activates the remote LFA (R-LFA)."; + } + description + "Remote LFA configuration."; + } + description + "Grouping for LFA interface configuration."; + } + + grouping interface-fast-reroute-config { + description + "This group defines the interface configuration of IP FRR."; + container fast-reroute { + if-feature "fast-reroute"; + container lfa { + if-feature "lfa"; + uses interface-lfa-config; + container level-1 { + uses interface-lfa-config; + description + "LFA level-1 configuration."; + } + container level-2 { + uses interface-lfa-config; + description + "LFA level-2 configuration."; + } + description + "LFA configuration."; + } + description + "Interface IP FRR configuration."; + } + } + + grouping instance-fast-reroute-state { + description + "IP FRR state data grouping."; + container protected-routes { + config false; + list address-family-stats { + key "address-family prefix alternate"; + leaf address-family { + type iana-rt-types:address-family; + description + "Address family."; + } + leaf prefix { + type inet:ip-prefix; + description + "Protected prefix."; + } + leaf alternate { + type inet:ip-address; + description + "Alternate next hop for the prefix."; + } + leaf alternate-type { + type identityref { + base frr-alternate-type; + } + description + "Type of alternate."; + } + leaf best { + type boolean; + description + "Set when the alternate is the preferred alternate; + clear otherwise."; + } + leaf non-best-reason { + type string { + length "1..255"; + } + description + "Information field that explains why the alternate + is not the best alternate. The length should be + limited to 255 Unicode characters. The expected format + is a single line of text."; + } + container protection-available { + leaf-list protection-types { + type identityref { + base frr-protection-available-type; + } + description + "This list contains a set of protection + types defined as identities. + An identity must be added for each type of + protection provided by the alternate. + As an example, if an alternate provides + SRLG, node, and link protection, three + identities must be added in this list: + one for SRLG protection, one for node + protection, and one for link protection."; + } + description + "Protection types provided by the alternate."; + } + leaf alternate-metric-1 { + type uint32; + description + "Metric from the Point of Local Repair (PLR) to the + destination through the alternate path."; + } + leaf alternate-metric-2 { + type uint32; + description + "Metric from the PLR to the alternate node."; + } + leaf alternate-metric-3 { + type uint32; + description + "Metric from the alternate node to the destination."; + } + description + "Per-address-family protected prefix statistics."; + } + description + "List of prefixes that are protected."; + } + container unprotected-routes { + config false; + list prefixes { + key "address-family prefix"; + leaf address-family { + type iana-rt-types:address-family; + description + "Address family."; + } + leaf prefix { + type inet:ip-prefix; + description + "Unprotected prefix."; + } + description + "Per-address-family unprotected prefix statistics."; + } + description + "List of prefixes that are not protected."; + } + list protection-statistics { + key "frr-protection-method"; + config false; + leaf frr-protection-method { + type identityref { + base frr-protection-method; + } + description + "Protection method used."; + } + list address-family-stats { + key "address-family"; + leaf address-family { + type iana-rt-types:address-family; + description + "Address family."; + } + leaf total-routes { + type yang:gauge32; + description + "Total prefixes."; + } + leaf unprotected-routes { + type yang:gauge32; + description + "Total prefixes that are not protected."; + } + leaf protected-routes { + type yang:gauge32; + description + "Total prefixes that are protected."; + } + leaf link-protected-routes { + type yang:gauge32; + description + "Total prefixes that are link protected."; + } + leaf node-protected-routes { + type yang:gauge32; + description + "Total prefixes that are node protected."; + } + description + "Per-address-family protected prefix statistics."; + } + description + "Global protection statistics."; + } + } + + /* Routing table and local Routing Information Base (RIB) + groupings */ + + grouping local-rib { + description + "Local RIB: RIB for routes computed by the local IS-IS + routing instance."; + container local-rib { + config false; + description + "Local RIB."; + list route { + key "prefix"; + description + "Routes."; + leaf prefix { + type inet:ip-prefix; + description + "Destination prefix."; + } + container next-hops { + description + "Next hops for the route."; + list next-hop { + key "next-hop"; + description + "List of next hops for the route."; + leaf outgoing-interface { + type if:interface-ref; + description + "Name of the outgoing interface."; + } + leaf next-hop { + type inet:ip-address; + description + "Next-hop address."; + } + } + } + leaf metric { + type uint32; + description + "Metric for this route."; + } + leaf level { + type level-number; + description + "Level number for this route."; + } + leaf route-tag { + type uint32; + description + "Route tag for this route."; + } + } + } + } + + grouping route-content { + description + "IS-IS protocol-specific route properties grouping."; + leaf metric { + type uint32; + description + "IS-IS metric of a route."; + } + leaf-list tag { + type uint64; + description + "List of tags associated with the route. This list + provides a consolidated view of both 32-bit and 64-bit + tags (RFC 5130) available for the prefix."; + reference + "RFC 5130: A Policy Control Mechanism in IS-IS Using + Administrative Tags"; + } + leaf route-type { + type enumeration { + enum l2-intra-area { + description + "Level-2 internal route. As per RFC 5302, + the prefix is directly connected to the + advertising router. It cannot be + distinguished from an L1->L2 inter-area + route."; + reference + "RFC 5302: Domain-Wide Prefix Distribution with + Two-Level IS-IS"; + } + enum l1-intra-area { + description + "Level-1 internal route. As per RFC 5302, + the prefix is directly connected to the + advertising router."; + } + enum l2-external { + description + "Level-2 external route. As per RFC 5302, + such a route is learned from other IGPs. + It cannot be distinguished from an L1->L2 + inter-area external route."; + } + enum l1-external { + description + "Level-1 external route. As per RFC 5302, + such a route is learned from other IGPs."; + } + enum l1-inter-area { + description + "These prefixes are learned via L2 routing."; + } + enum l1-inter-area-external { + description + "These prefixes are learned via L2 routing + towards a level-2 external route."; + } + } + description + "IS-IS route type."; + } + } + + /* Grouping definitions for configuration and operational states */ + + grouping adjacency-state { + container adjacencies { + config false; + list adjacency { + leaf neighbor-sys-type { + type level; + description + "Level capability of the neighboring system."; + } + leaf neighbor-sysid { + type system-id; + description + "The system ID of the neighbor."; + } + leaf neighbor-extended-circuit-id { + type extended-circuit-id; + description + "The circuit ID of the neighbor."; + } + leaf neighbor-snpa { + type snpa; + description + "The SNPA of the neighbor."; + } + leaf usage { + type level; + description + "Defines the level(s) activated for the adjacency. + On a point-to-point link, this might be level 1 and + level 2, but on a LAN, the usage will be level 1 + between neighbors at level 1 or level 2 between + neighbors at level 2."; + } + leaf hold-timer { + type rt-types:timer-value-seconds16; + units "seconds"; + description + "The holding time (in seconds) for this adjacency. + This value is based on received Hello PDUs and the + elapsed time since receipt."; + } + leaf neighbor-priority { + type uint8 { + range "0 .. 127"; + } + description + "Priority of the neighboring IS for becoming the + Designated Intermediate System (DIS)."; + } + leaf lastuptime { + type yang:timestamp; + description + "When the adjacency most recently entered the + 'up' state, measured in hundredths of a + second since the last reinitialization of + the network management subsystem. + The value is 0 if the adjacency has never + been in the 'up' state."; + } + leaf state { + type adj-state-type; + description + "This leaf describes the state of the interface."; + } + description + "List of operational adjacencies."; + } + description + "This container lists the adjacencies of + the local node."; + } + description + "Adjacency state."; + } + + grouping admin-control { + leaf enabled { + if-feature "admin-control"; + type boolean; + default "true"; + description + "Enables or disables the protocol."; + } + description + "Grouping for administrative control."; + } + + grouping ietf-spf-delay { + leaf initial-delay { + type rt-types:timer-value-milliseconds; + units "msec"; + default "50"; + description + "Delay used while in the QUIET state (milliseconds)."; + } + leaf short-delay { + type rt-types:timer-value-milliseconds; + units "msec"; + default "200"; + description + "Delay used while in the SHORT_WAIT state (milliseconds)."; + } + leaf long-delay { + type rt-types:timer-value-milliseconds; + units "msec"; + default "5000"; + description + "Delay used while in the LONG_WAIT state (milliseconds)."; + } + leaf hold-down { + type rt-types:timer-value-milliseconds; + units "msec"; + default "10000"; + description + "This timer value defines the period without any changes + for the IGP to be considered stable (in milliseconds)."; + } + leaf time-to-learn { + type rt-types:timer-value-milliseconds; + units "msec"; + default "500"; + description + "Duration used to learn all the IGP events + related to a single network event (milliseconds)."; + } + leaf current-state { + type enumeration { + enum quiet { + description + "QUIET state."; + } + enum short-wait { + description + "SHORT_WAIT state."; + } + enum long-wait { + description + "LONG_WAIT state."; + } + } + config false; + description + "Current SPF Back-Off algorithm state."; + } + leaf remaining-time-to-learn { + type rt-types:timer-value-milliseconds; + units "msec"; + config false; + description + "Remaining time until the time-to-learn timer fires."; + } + leaf remaining-hold-down { + type rt-types:timer-value-milliseconds; + units "msec"; + config false; + description + "Remaining time until the hold-down timer fires."; + } + leaf last-event-received { + type yang:timestamp; + config false; + description + "Time of the last IGP event received."; + } + leaf next-spf-time { + type yang:timestamp; + config false; + description + "Time when the next SPF has been scheduled."; + } + leaf last-spf-time { + type yang:timestamp; + config false; + description + "Time of the last SPF computation."; + } + description + "Grouping for IETF SPF delay configuration and state."; + reference + "RFC 8405: Shortest Path First (SPF) Back-Off Delay Algorithm + for Link-State IGPs"; + } + + grouping node-tag-config { + description + "IS-IS node tag configuration state."; + container node-tags { + if-feature "node-tag"; + list node-tag { + key "tag"; + leaf tag { + type uint32; + description + "Node tag value."; + } + description + "List of tags."; + } + description + "Container for node administrative tags."; + } + } + + grouping authentication-global-cfg { + choice authentication-type { + case key-chain { + if-feature "key-chain"; + leaf key-chain { + type key-chain:key-chain-ref; + description + "Reference to a key chain."; + } + } + case password { + leaf key { + type string; + description + "This leaf specifies the authentication key. The + length of the key may be dependent on the + cryptographic algorithm."; + } + leaf crypto-algorithm { + type identityref { + base key-chain:crypto-algorithm; + } + description + "Cryptographic algorithm associated with a key."; + } + } + description + "Choice of authentication."; + } + description + "Grouping for global authentication configuration."; + } + + grouping metric-type-global-cfg { + leaf value { + type enumeration { + enum wide-only { + description + "Advertises the new metric style only (RFC 5305)."; + reference + "RFC 5305: IS-IS Extensions for Traffic Engineering"; + } + enum old-only { + description + "Advertises the old metric style only (RFC 1195)."; + reference + "RFC 1195: Use of OSI IS-IS for routing in TCP/IP and + dual environments"; + } + enum both { + description + "Advertises both metric styles."; + } + } + description + "Type of metric to be generated: + + - 'wide-only' means that only a new metric style + is generated. + - 'old-only' means that only an old metric style + is generated. + - 'both' means that both are advertised. + + This leaf only affects IPv4 metrics."; + } + description + "Grouping for global metric style configuration."; + } + + grouping metric-type-global-cfg-with-default { + leaf value { + type enumeration { + enum wide-only { + description + "Advertises the new metric style only (RFC 5305)."; + reference + "RFC 5305: IS-IS Extensions for Traffic Engineering"; + } + enum old-only { + description + "Advertises the old metric style only (RFC 1195)."; + reference + "RFC 1195: Use of OSI IS-IS for routing in TCP/IP and + dual environments"; + } + enum both { + description + "Advertises both metric styles."; + } + } + default "wide-only"; + description + "Type of metric to be generated: + + - 'wide-only' means that only a new metric style + is generated. + - 'old-only' means that only an old metric style + is generated. + - 'both' means that both are advertised. + + This leaf only affects IPv4 metrics."; + } + description + "Grouping for global metric style configuration."; + } + + grouping default-metric-global-cfg { + leaf value { + type wide-metric; + description + "Value of the metric."; + } + description + "Global default metric configuration grouping."; + } + + grouping default-metric-global-cfg-with-default { + leaf value { + type wide-metric; + default "10"; + description + "Value of the metric."; + } + description + "Global default metric configuration grouping."; + } + + grouping overload-global-cfg { + leaf status { + type boolean; + default "false"; + description + "This leaf specifies the overload status."; + } + description + "Grouping for overload bit configuration."; + } + + grouping overload-max-metric-global-cfg { + leaf timeout { + type rt-types:timer-value-seconds16; + units "seconds"; + description + "Timeout (in seconds) of the overload condition."; + } + description + "Overload maximum metric configuration grouping."; + } + + grouping route-preference-global-cfg { + choice granularity { + case detail { + leaf internal { + type uint8; + description + "Protocol preference for internal routes."; + } + leaf external { + type uint8; + description + "Protocol preference for external routes."; + } + } + case coarse { + leaf default { + type uint8; + description + "Protocol preference for all IS-IS routes."; + } + } + description + "Choice for implementation of route preference."; + } + description + "Global route preference grouping."; + } + + grouping hello-authentication-cfg { + choice authentication-type { + case key-chain { + if-feature "key-chain"; + leaf key-chain { + type key-chain:key-chain-ref; + description + "Reference to a key chain."; + } + } + case password { + leaf key { + type string; + description + "Authentication key specification. The length of the + key may be dependent on the cryptographic algorithm."; + } + leaf crypto-algorithm { + type identityref { + base key-chain:crypto-algorithm; + } + description + "Cryptographic algorithm associated with a key."; + } + } + description + "Choice of authentication."; + } + description + "Grouping for Hello authentication."; + } + + grouping hello-interval-cfg { + leaf value { + type rt-types:timer-value-seconds16; + units "seconds"; + description + "Interval (in seconds) between successive Hello + messages."; + } + description + "Interval between Hello messages."; + } + + grouping hello-interval-cfg-with-default { + leaf value { + type rt-types:timer-value-seconds16; + units "seconds"; + default "10"; + description + "Interval (in seconds) between successive Hello + messages."; + } + description + "Interval between Hello messages."; + } + + grouping hello-multiplier-cfg { + leaf value { + type uint16; + description + "Number of missed Hello messages prior to + declaring the adjacency down."; + } + description + "Grouping for the number of missed Hello messages prior to + declaring the adjacency down."; + } + + grouping hello-multiplier-cfg-with-default { + leaf value { + type uint16; + default "3"; + description + "Number of missed Hello messages prior to + declaring the adjacency down."; + } + description + "Grouping for the number of missed Hello messages prior to + declaring the adjacency down."; + } + + grouping priority-cfg { + leaf value { + type uint8 { + range "0 .. 127"; + } + description + "Priority of the interface for DIS election."; + } + description + "Interface DIS election priority grouping."; + } + + grouping priority-cfg-with-default { + leaf value { + type uint8 { + range "0 .. 127"; + } + default "64"; + description + "Priority of the interface for DIS election."; + } + description + "Interface DIS election priority grouping."; + } + + grouping metric-cfg { + leaf value { + type wide-metric; + description + "Metric value."; + } + description + "Interface metric grouping."; + } + + grouping metric-cfg-with-default { + leaf value { + type wide-metric; + default "10"; + description + "Metric value."; + } + description + "Interface metric grouping."; + } + + grouping metric-parameters { + container metric-type { + uses metric-type-global-cfg-with-default; + container level-1 { + uses metric-type-global-cfg; + description + "Configuration specific to level 1."; + } + container level-2 { + uses metric-type-global-cfg; + description + "Configuration specific to level 2."; + } + description + "Metric style global configuration."; + } + container default-metric { + uses default-metric-global-cfg-with-default; + container level-1 { + uses default-metric-global-cfg; + description + "Configuration specific to level 1."; + } + container level-2 { + uses default-metric-global-cfg; + description + "Configuration specific to level 2."; + } + description + "Default metric global configuration."; + } + container auto-cost { + if-feature "auto-cost"; + description + "Interface auto-cost configuration state."; + leaf enabled { + type boolean; + description + "Enables or disables interface auto-cost."; + } + leaf reference-bandwidth { + when "../enabled = 'true'" { + description + "Only when auto-cost is enabled."; + } + type uint32 { + range "1..4294967"; + } + units "Mbits"; + description + "Configures the reference bandwidth used to automatically + determine the interface cost (Mbits). The cost is the + reference bandwidth divided by the interface speed, + with 1 being the minimum cost."; + } + } + description + "Grouping for global metric parameters."; + } + + grouping high-availability-parameters { + container graceful-restart { + if-feature "graceful-restart"; + leaf enabled { + type boolean; + default "false"; + description + "Enables graceful restart."; + } + leaf restart-interval { + type rt-types:timer-value-seconds16; + units "seconds"; + description + "Interval (in seconds) to attempt graceful restart prior + to failure."; + } + leaf helper-enabled { + type boolean; + default "true"; + description + "Enables a local IS-IS router as a graceful restart + helper."; + } + description + "Configuration of graceful restart."; + } + container nsr { + if-feature "nsr"; + description + "Non-Stop Routing (NSR) configuration."; + leaf enabled { + type boolean; + default "false"; + description + "Enables or disables NSR."; + } + } + description + "Grouping for high-availability parameters."; + } + + grouping authentication-parameters { + container authentication { + uses authentication-global-cfg; + container level-1 { + uses authentication-global-cfg; + description + "Configuration specific to level 1."; + } + container level-2 { + uses authentication-global-cfg; + description + "Configuration specific to level 2."; + } + description + "Authentication global configuration for + both LSPs and Sequence Number PDUs (SNPs)."; + } + description + "Grouping for authentication parameters."; + } + + grouping address-family-parameters { + container address-families { + if-feature "nlpid-control"; + list address-family-list { + key "address-family"; + leaf address-family { + type iana-rt-types:address-family; + description + "Address family."; + } + leaf enabled { + type boolean; + description + "Activates the address family."; + } + description + "List of address families and whether or not they + are activated."; + } + description + "Address family configuration."; + } + description + "Grouping for address family parameters."; + } + + grouping mpls-parameters { + container mpls { + container te-rid { + if-feature "te-rid"; + description + "Stable IS-IS router IP address used for Traffic + Engineering."; + leaf ipv4-router-id { + type inet:ipv4-address; + description + "Router ID value that would be used in TLV 134."; + } + leaf ipv6-router-id { + type inet:ipv6-address; + description + "Router ID value that would be used in TLV 140."; + } + } + container ldp { + container igp-sync { + if-feature "ldp-igp-sync"; + description + "This container may be augmented with global + parameters for LDP IGP synchronization."; + } + description + "LDP configuration."; + } + description + "MPLS configuration."; + } + description + "Grouping for MPLS global parameters."; + } + + grouping lsp-parameters { + leaf lsp-mtu { + type uint16; + units "bytes"; + default "1492"; + description + "Maximum size of an LSP PDU in bytes."; + } + leaf lsp-lifetime { + type uint16 { + range "1..65535"; + } + units "seconds"; + description + "Lifetime of the router's LSPs in seconds."; + } + leaf lsp-refresh { + if-feature "lsp-refresh"; + type rt-types:timer-value-seconds16; + units "seconds"; + description + "Refresh interval of the router's LSPs in seconds."; + } + leaf poi-tlv { + if-feature "poi-tlv"; + type boolean; + default "false"; + description + "Enables the advertisement of the IS-IS Purge Originator + Identification TLV."; + } + description + "Grouping for LSP global parameters."; + } + + grouping spf-parameters { + container spf-control { + leaf paths { + if-feature "max-ecmp"; + type uint16 { + range "1..65535"; + } + description + "Maximum number of Equal-Cost Multi-Path (ECMP) paths."; + } + container ietf-spf-delay { + if-feature "ietf-spf-delay"; + uses ietf-spf-delay; + description + "IETF SPF delay algorithm configuration."; + } + description + "SPF calculation control."; + } + description + "Grouping for SPF global parameters."; + } + + grouping instance-config { + description + "IS-IS global configuration grouping."; + uses admin-control; + leaf level-type { + type level; + default "level-all"; + description + "Level of an IS-IS node. Can be 'level-1', 'level-2', or + 'level-all'."; + } + leaf system-id { + type system-id; + description + "System ID of the node."; + } + leaf maximum-area-addresses { + if-feature "maximum-area-addresses"; + type uint8; + default "3"; + description + "Maximum areas supported."; + } + leaf-list area-address { + type area-address; + description + "List of areas supported by the protocol instance."; + } + uses lsp-parameters; + uses high-availability-parameters; + uses node-tag-config; + uses metric-parameters; + uses authentication-parameters; + uses address-family-parameters; + uses mpls-parameters; + uses spf-parameters; + uses instance-fast-reroute-config; + container preference { + uses route-preference-global-cfg; + description + "Router preference configuration for IS-IS + protocol instance route installation."; + } + container overload { + uses overload-global-cfg; + description + "Router protocol instance overload state configuration."; + } + container overload-max-metric { + if-feature "overload-max-metric"; + uses overload-max-metric-global-cfg; + description + "Router protocol instance overload maximum + metric advertisement configuration."; + } + } + + grouping instance-state { + description + "IS-IS instance operational state."; + uses spf-log; + uses lsp-log; + uses hostname-db; + uses lsdb; + uses local-rib; + uses system-counters; + uses instance-fast-reroute-state; + leaf discontinuity-time { + type yang:date-and-time; + description + "The time of the most recent occasion at which any one + or more of this IS-IS instance's counters suffered a + discontinuity. If no such discontinuities have occurred + since the IS-IS instance was last reinitialized, then + this node contains the time the IS-IS instance was + reinitialized, which normally occurs when it was + created."; + } + } + + grouping multi-topology-config { + description + "Per-topology configuration."; + container default-metric { + uses default-metric-global-cfg; + container level-1 { + uses default-metric-global-cfg; + description + "Configuration specific to level 1."; + } + container level-2 { + uses default-metric-global-cfg; + description + "Configuration specific to level 2."; + } + description + "Default metric per-topology configuration."; + } + uses node-tag-config; + } + + grouping interface-config { + description + "Interface configuration grouping."; + uses admin-control; + leaf level-type { + type level; + default "level-all"; + description + "IS-IS level of the interface."; + } + leaf lsp-pacing-interval { + type rt-types:timer-value-milliseconds; + units "milliseconds"; + default "33"; + description + "Interval (in milliseconds) between LSP transmissions."; + } + leaf lsp-retransmit-interval { + type rt-types:timer-value-seconds16; + units "seconds"; + description + "Interval (in seconds) between LSP retransmissions."; + } + leaf passive { + type boolean; + default "false"; + description + "Indicates whether the interface is in passive mode (IS-IS + is not running, but the network is advertised)."; + } + leaf csnp-interval { + type rt-types:timer-value-seconds16; + units "seconds"; + default "10"; + description + "Interval (in seconds) between Complete Sequence Number + Packet (CSNP) messages."; + } + container hello-padding { + leaf enabled { + type boolean; + default "true"; + description + "IS-IS Hello padding activation. Enabled by default."; + } + description + "IS-IS Hello padding configuration."; + } + leaf mesh-group-enabled { + type mesh-group-state; + description + "IS-IS interface mesh group state."; + } + leaf mesh-group { + when "../mesh-group-enabled = 'mesh-set'" { + description + "Only valid when 'mesh-group-enabled' equals 'mesh-set'."; + } + type uint8; + description + "IS-IS interface mesh group ID."; + } + leaf interface-type { + type interface-type; + default "broadcast"; + description + "Type of adjacency to be established for the interface. + This dictates the type of Hello messages that are used."; + } + leaf-list tag { + if-feature "prefix-tag"; + type uint32; + description + "List of tags associated with the interface."; + } + leaf-list tag64 { + if-feature "prefix-tag64"; + type uint64; + description + "List of 64-bit tags associated with the interface."; + } + leaf node-flag { + if-feature "node-flag"; + type boolean; + default "false"; + description + "Sets the prefix as a node representative prefix."; + } + container hello-authentication { + uses hello-authentication-cfg; + container level-1 { + uses hello-authentication-cfg; + description + "Configuration specific to level 1."; + } + container level-2 { + uses hello-authentication-cfg; + description + "Configuration specific to level 2."; + } + description + "Authentication type to be used in Hello messages."; + } + container hello-interval { + uses hello-interval-cfg-with-default; + container level-1 { + uses hello-interval-cfg; + description + "Configuration specific to level 1."; + } + container level-2 { + uses hello-interval-cfg; + description + "Configuration specific to level 2."; + } + description + "Interval between Hello messages."; + } + container hello-multiplier { + uses hello-multiplier-cfg-with-default; + container level-1 { + uses hello-multiplier-cfg; + description + "Configuration specific to level 1."; + } + container level-2 { + uses hello-multiplier-cfg; + description + "Configuration specific to level 2."; + } + description + "Hello multiplier configuration."; + } + container priority { + must '../interface-type = "broadcast"' { + error-message "Priority only applies to broadcast " + + "interfaces."; + description + "Checks for a broadcast interface."; + } + uses priority-cfg-with-default; + container level-1 { + uses priority-cfg; + description + "Configuration specific to level 1."; + } + container level-2 { + uses priority-cfg; + description + "Configuration specific to level 2."; + } + description + "Priority for DIS election."; + } + container metric { + uses metric-cfg-with-default; + container level-1 { + uses metric-cfg; + description + "Configuration specific to level 1."; + } + container level-2 { + uses metric-cfg; + description + "Configuration specific to level 2."; + } + description + "Metric configuration."; + } + container bfd { + if-feature "bfd"; + description + "BFD interface configuration."; + uses bfd-types:client-cfg-parms; + reference + "RFC 5880: Bidirectional Forwarding Detection (BFD) + RFC 5881: Bidirectional Forwarding Detection + (BFD) for IPv4 and IPv6 (Single Hop) + RFC 9314: YANG Data Model for Bidirectional Forwarding + Detection (BFD)"; + } + container address-families { + if-feature "nlpid-control"; + list address-family-list { + key "address-family"; + leaf address-family { + type iana-rt-types:address-family; + description + "Address family."; + } + description + "List of address families."; + } + description + "Interface address families."; + } + container mpls { + container ldp { + leaf igp-sync { + if-feature "ldp-igp-sync"; + type boolean; + default "false"; + description + "Enables IGP/LDP synchronization."; + } + description + "Configuration related to LDP."; + } + description + "MPLS configuration for IS-IS interfaces."; + } + uses interface-fast-reroute-config; + } + + grouping multi-topology-interface-config { + description + "IS-IS interface topology configuration."; + container metric { + uses metric-cfg; + container level-1 { + uses metric-cfg; + description + "Configuration specific to level 1."; + } + container level-2 { + uses metric-cfg; + description + "Configuration specific to level 2."; + } + description + "Metric IS-IS interface configuration."; + } + } + + grouping interface-state { + description + "IS-IS interface operational state."; + uses adjacency-state; + uses event-counters; + uses packet-counters; + leaf discontinuity-time { + type yang:date-and-time; + description + "The time of the most recent occasion at which any one + or more of this IS-IS interface's counters suffered a + discontinuity. If no such discontinuities have occurred + since the IS-IS interface was last reinitialized, then + this node contains the time the IS-IS interface was + reinitialized, which normally occurs when it was + created."; + } + } + + /* Grouping for the hostname database */ + + grouping hostname-db { + container hostnames { + config false; + list hostname { + key "system-id"; + leaf system-id { + type system-id; + description + "System ID associated with the hostname."; + } + leaf hostname { + type string { + length "1..255"; + } + description + "Hostname associated with the system ID + as defined in RFC 5301."; + reference + "RFC 5301: Dynamic Hostname Exchange Mechanism + for IS-IS"; + } + description + "List of system ID / hostname associations."; + } + description + "Hostname-to-system-ID mapping database."; + } + description + "Grouping for hostname-to-system-ID mapping database."; + } + + /* Groupings for counters */ + + grouping system-counters { + container system-counters { + config false; + list level { + key "level"; + leaf level { + type level-number; + description + "IS-IS level."; + } + leaf corrupted-lsps { + type uint32; + 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'."; + } + leaf authentication-type-fails { + type uint32; + description + "Number of authentication type mismatches."; + } + leaf authentication-fails { + type uint32; + description + "Number of authentication key failures."; + } + leaf database-overload { + type uint32; + description + "Number of times the database has become + overloaded."; + } + leaf own-lsp-purge { + type uint32; + description + "Number of times a zero-aged copy of the system's + own LSP is received from some other IS-IS node."; + } + leaf manual-address-drop-from-area { + type uint32; + description + "Number of times a manual address + has been dropped from the area."; + } + leaf max-sequence { + type uint32; + description + "Number of times the system has attempted + to exceed the maximum sequence number."; + } + leaf sequence-number-skipped { + type uint32; + description + "Number of times a sequence number skip has + occurred."; + } + leaf id-len-mismatch { + type uint32; + description + "Number of times a PDU is received with a + different value for the ID field length + than that of the receiving system."; + } + leaf partition-changes { + type uint32; + description + "Number of partition changes detected."; + } + leaf lsp-errors { + type uint32; + description + "Number of LSPs received with errors."; + } + leaf spf-runs { + type uint32; + description + "Number of times SPF was run at this level."; + } + description + "List of supported levels."; + } + description + "List of counters for the IS-IS protocol instance."; + } + description + "Grouping for IS-IS system counters."; + } + + grouping event-counters { + container event-counters { + config false; + leaf adjacency-changes { + type uint32; + description + "The number of times an adjacency state change has + occurred on this interface."; + } + leaf adjacency-number { + type uint32; + description + "The number of adjacencies on this interface."; + } + leaf init-fails { + type uint32; + description + "The number of times initialization of this interface has + failed. This counts events such as Point-to-Point + Protocol (PPP) Network Control Protocol (NCP) failures. + Failures to form an adjacency are counted by + 'adjacency-rejects'."; + } + leaf adjacency-rejects { + type uint32; + description + "The number of times an adjacency has been + rejected on this interface."; + } + leaf id-len-mismatch { + type uint32; + description + "The number of times an IS-IS PDU with an ID + field length different from that for this + system has been received on this interface."; + } + leaf max-area-addresses-mismatch { + type uint32; + description + "The number of times an IS-IS PDU has been + received on this interface with the + max area address field differing from that of + this system."; + } + leaf authentication-type-fails { + type uint32; + description + "Number of authentication type mismatches."; + } + leaf authentication-fails { + type uint32; + description + "Number of authentication key failures."; + } + leaf lan-dis-changes { + type uint32; + description + "The number of times the DIS has changed on this + interface at this level. If the interface type is + 'point-to-point', the count is zero."; + } + description + "IS-IS interface event counters."; + } + description + "Grouping for IS-IS interface event counters."; + } + + grouping packet-counters { + container packet-counters { + config false; + list level { + key "level"; + leaf level { + type level-number; + description + "IS-IS level."; + } + container iih { + leaf in { + type uint32; + description + "Received IS-IS Hello (IIH) PDUs."; + } + leaf out { + type uint32; + description + "Sent IIH PDUs."; + } + description + "Number of IIH PDUs received/sent."; + } + container ish { + leaf in { + type uint32; + description + "Received Intermediate System Hello (ISH) PDUs."; + } + leaf out { + type uint32; + description + "Sent ISH PDUs."; + } + description + "ISH PDUs received/sent."; + } + container esh { + leaf in { + type uint32; + description + "Received End System Hello (ESH) PDUs."; + } + leaf out { + type uint32; + description + "Sent ESH PDUs."; + } + description + "Number of ESH PDUs received/sent."; + } + container lsp { + leaf in { + type uint32; + description + "Received Link State PDU (LSP) PDUs."; + } + leaf out { + type uint32; + description + "Sent LSP PDUs."; + } + description + "Number of LSP PDUs received/sent."; + } + container psnp { + leaf in { + type uint32; + description + "Received Partial Sequence Number PDU (PSNP) PDUs."; + } + leaf out { + type uint32; + description + "Sent PSNP PDUs."; + } + description + "Number of PSNP PDUs received/sent."; + } + container csnp { + leaf in { + type uint32; + description + "Received Complete Sequence Number PDU (CSNP) PDUs."; + } + leaf out { + type uint32; + description + "Sent CSNP PDUs."; + } + description + "Number of CSNP PDUs received/sent."; + } + container unknown { + leaf in { + type uint32; + description + "Received unknown PDUs."; + } + description + "Number of unknown PDUs received."; + } + description + "List of packet counters for supported levels."; + } + description + "Packet counters per IS-IS level."; + } + description + "Grouping for packet counters per IS-IS level."; + } + + /* Groupings for various log buffers */ + + grouping spf-log { + container spf-log { + config false; + list event { + key "id"; + leaf id { + type yang:counter32; + description + "Event identifier. A purely internal value. + The most recent events are expected to have a bigger + ID number."; + } + leaf spf-type { + type enumeration { + enum full { + description + "Full SPF computation."; + } + enum route-only { + description + "SPF computation of route reachability + only."; + } + } + description + "Type of SPF computation performed."; + } + leaf level { + type level-number; + description + "IS-IS level number for the SPF computation."; + } + leaf schedule-timestamp { + type yang:timestamp; + description + "Timestamp of when the SPF computation was + scheduled."; + } + leaf start-timestamp { + type yang:timestamp; + description + "Timestamp of when the SPF computation started."; + } + leaf end-timestamp { + type yang:timestamp; + description + "Timestamp of when the SPF computation ended."; + } + list trigger-lsp { + key "lsp"; + leaf lsp { + type lsp-id; + description + "LSP ID of the LSP that triggered the SPF + computation."; + } + leaf sequence { + type uint32; + description + "Sequence number of the LSP that triggered the SPF + computation."; + } + description + "This list includes the LSPs that triggered the + SPF computation."; + } + description + "List of computation events. Implemented as a + wrapping buffer."; + } + description + "This container lists the SPF computation events."; + } + description + "Grouping for SPF log events."; + } + + grouping lsp-log { + container lsp-log { + config false; + list event { + key "id"; + leaf id { + type yang:counter32; + description + "Event identifier. A purely internal value. + The most recent events are expected to have a bigger + ID number."; + } + leaf level { + type level-number; + description + "IS-IS level number for the LSP."; + } + container lsp { + leaf lsp { + type lsp-id; + description + "LSP ID of the LSP."; + } + leaf sequence { + type uint32; + description + "Sequence number of the LSP."; + } + description + "LSP identification container for either the received + LSP or the locally generated LSP."; + } + leaf received-timestamp { + type yang:timestamp; + description + "This is the timestamp when the LSP was received. + In the case of a local LSP update, the timestamp refers + to the LSP origination time."; + } + leaf reason { + type identityref { + base lsp-log-reason; + } + description + "Type of LSP change."; + } + description + "List of LSP events. Implemented as a wrapping buffer."; + } + description + "This container lists the LSP log. + Local LSP modifications are also included in the list."; + } + description + "Grouping for the LSP log."; + } + + /* Groupings for the Link State Database (LSDB) descriptions */ + /* Unknown TLV and sub-TLV descriptions */ + + grouping tlv { + description + "Type-Length-Value (TLV)."; + leaf type { + type uint16; + description + "TLV type."; + } + leaf length { + type uint16; + description + "TLV length (octets)."; + } + leaf value { + type yang:hex-string; + description + "TLV value."; + } + } + + grouping unknown-tlvs { + description + "Unknown TLVs grouping. Used for unknown TLVs or + unknown sub-TLVs."; + container unknown-tlvs { + description + "All unknown TLVs."; + list unknown-tlv { + description + "Unknown TLV."; + uses tlv; + } + } + } + + /* TLVs and sub-TLVs for prefixes */ + + grouping prefix-reachability-attributes { + description + "Grouping for extended reachability attributes of an + IPv4 or IPv6 prefix."; + leaf external-prefix-flag { + type boolean; + description + "External prefix flag."; + } + leaf readvertisement-flag { + type boolean; + description + "Re-advertisement flag."; + } + leaf node-flag { + type boolean; + description + "Node flag."; + } + } + + grouping prefix-ipv4-source-router-id { + description + "Grouping for the IPv4 source router ID of a prefix + advertisement."; + leaf ipv4-source-router-id { + type inet:ipv4-address; + description + "IPv4 source router ID address."; + } + } + + grouping prefix-ipv6-source-router-id { + description + "Grouping for the IPv6 source router ID of a prefix + advertisement."; + leaf ipv6-source-router-id { + type inet:ipv6-address; + description + "IPv6 source router ID address."; + } + } + + grouping prefix-attributes-extension { + description + "Prefix extended attributes as defined in RFC 7794."; + reference + "RFC 7794: IS-IS Prefix Attributes for Extended IPv4 and IPv6 + Reachability"; + uses prefix-reachability-attributes; + uses prefix-ipv4-source-router-id; + uses prefix-ipv6-source-router-id; + } + + grouping prefix-ipv4-std { + description + "Grouping for attributes of an IPv4 standard prefix + as defined in RFC 1195."; + reference + "RFC 1195: Use of OSI IS-IS for routing in TCP/IP and + dual environments"; + leaf ip-prefix { + type inet:ipv4-address; + description + "IPv4 prefix address."; + } + leaf prefix-len { + type uint8; + description + "IPv4 prefix length (in bits)."; + } + leaf i-e { + type boolean; + description + "Internal or external (I/E) metric bit value. + Set to 'false' to indicate an internal metric."; + } + container default-metric { + leaf metric { + type std-metric; + description + "Default IS-IS metric for the IPv4 prefix."; + } + description + "IS-IS default metric container."; + } + container delay-metric { + leaf metric { + type std-metric; + description + "IS-IS delay metric for the IPv4 prefix."; + } + leaf supported { + type boolean; + default "false"; + description + "Indicates whether the IS-IS delay metric is supported."; + } + description + "IS-IS delay metric container."; + } + container expense-metric { + leaf metric { + type std-metric; + description + "IS-IS expense metric for the IPv4 prefix."; + } + leaf supported { + type boolean; + default "false"; + description + "Indicates whether the IS-IS expense metric is supported."; + } + description + "IS-IS expense metric container."; + } + container error-metric { + leaf metric { + type std-metric; + description + "This leaf describes the IS-IS error metric value."; + } + leaf supported { + type boolean; + default "false"; + description + "Indicates whether the IS-IS error metric is supported."; + } + description + "IS-IS error metric container."; + } + } + + grouping prefix-ipv4-extended { + description + "Grouping for attributes of an IPv4 extended prefix + as defined in RFC 5305."; + reference + "RFC 5305: IS-IS Extensions for Traffic Engineering"; + leaf up-down { + type boolean; + description + "Value of the up/down bit. + Set to 'true' when the prefix has been advertised down + the hierarchy."; + } + leaf ip-prefix { + type inet:ipv4-address; + description + "IPv4 prefix address."; + } + leaf prefix-len { + type uint8; + description + "IPv4 prefix length (in bits)."; + } + leaf metric { + type wide-metric; + description + "IS-IS wide metric value."; + } + leaf-list tag { + type uint32; + description + "List of 32-bit tags associated with the IPv4 prefix."; + } + leaf-list tag64 { + type uint64; + description + "List of 64-bit tags associated with the IPv4 prefix."; + } + uses prefix-attributes-extension; + } + + grouping prefix-ipv6-extended { + description + "Grouping for attributes of an IPv6 prefix + as defined in RFC 5308."; + reference + "RFC 5308: Routing IPv6 with IS-IS"; + leaf up-down { + type boolean; + description + "Value of the up/down bit. + Set to 'true' when the prefix has been advertised down + the hierarchy."; + } + leaf ip-prefix { + type inet:ipv6-address; + description + "IPv6 prefix address."; + } + leaf prefix-len { + type uint8; + description + "IPv6 prefix length (in bits)."; + } + leaf metric { + type wide-metric; + description + "IS-IS wide metric value."; + } + leaf-list tag { + type uint32; + description + "List of 32-bit tags associated with the IPv6 prefix."; + } + leaf-list tag64 { + type uint64; + description + "List of 64-bit tags associated with the IPv6 prefix."; + } + uses prefix-attributes-extension; + } + + /* TLVs and sub-TLVs for neighbors */ + + grouping neighbor-link-attributes { + description + "Grouping for link attributes as defined + in RFC 5029."; + reference + "RFC 5029: Definition of an IS-IS Link Attribute Sub-TLV"; + leaf link-attributes-flags { + type uint16; + description + "Flags for the link attributes."; + } + } + + grouping neighbor-gmpls-extensions { + description + "Grouping for GMPLS attributes of a neighbor as defined + in RFC 5307."; + reference + "RFC 5307: IS-IS Extensions in Support of Generalized + Multi-Protocol Label Switching (GMPLS)"; + leaf link-local-id { + type uint32; + description + "Local identifier of the link."; + } + leaf remote-local-id { + type uint32; + description + "Remote identifier of the link."; + } + leaf protection-capability { + type uint8; + description + "Describes the protection capabilities + of the link. This is the value of the + first octet of the sub-TLV type 20 value."; + } + container interface-switching-capability { + description + "Interface switching capabilities of the link."; + leaf switching-capability { + type uint8; + description + "Switching capability of the link."; + } + leaf encoding { + type uint8; + description + "Type of encoding of the LSP being used."; + } + container max-lsp-bandwidths { + description + "Per-priority maximum LSP bandwidths."; + list max-lsp-bandwidth { + leaf priority { + type uint8 { + range "0 .. 7"; + } + description + "Priority from 0 to 7."; + } + leaf bandwidth { + type rt-types:bandwidth-ieee-float32; + description + "Maximum LSP bandwidth."; + } + description + "List of maximum LSP bandwidths for different + priorities."; + } + } + container tdm-specific { + when '../switching-capability = 100'; + description + "Switching-capability-specific information applicable + when the switching type is Time-Division Multiplexing + (TDM)."; + leaf minimum-lsp-bandwidth { + type rt-types:bandwidth-ieee-float32; + description + "Minimum LSP bandwidth."; + } + leaf indication { + type uint8; + description + "Indicates whether the interface supports Standard + or Arbitrary SONET/SDH (Synchronous Optical Network / + Synchronous Digital Hierarchy)."; + } + } + container psc-specific { + when "../switching-capability >= 1 and + ../switching-capability <= 4"; + description + "Switching-capability-specific information applicable + when the switching type is PSC1, PSC2, PSC3, or PSC4 + ('PSC' stands for 'Packet Switching Capability')."; + leaf minimum-lsp-bandwidth { + type rt-types:bandwidth-ieee-float32; + description + "Minimum LSP bandwidth."; + } + leaf mtu { + type uint16; + units "bytes"; + description + "Interface MTU."; + } + } + } + } + + grouping neighbor-extended-te-extensions { + description + "Grouping for TE attributes of a neighbor as defined + in RFC 8570."; + reference + "RFC 8570: IS-IS Traffic Engineering (TE) Metric Extensions"; + container unidirectional-link-delay { + description + "Container for the average delay + from the local neighbor to the remote neighbor."; + container flags { + leaf-list unidirectional-link-delay-subtlv-flags { + type identityref { + base unidirectional-link-delay-subtlv-flag; + } + description + "This list contains identities for the bits that + are set."; + } + description + "Unidirectional Link Delay sub-TLV flags."; + } + leaf value { + type uint32; + units "usec"; + description + "Delay value expressed in microseconds."; + } + } + container min-max-unidirectional-link-delay { + description + "Container for the minimum and maximum delay + from the local neighbor to the remote neighbor."; + container flags { + leaf-list min-max-unidirectional-link-delay-subtlv-flags { + type identityref { + base min-max-unidirectional-link-delay-subtlv-flag; + } + description + "This list contains identities for the bits that + are set."; + } + description + "Min/Max Unidirectional Link Delay sub-TLV flags."; + } + leaf min-value { + type uint32; + units "usec"; + description + "Minimum delay value expressed in microseconds."; + } + leaf max-value { + type uint32; + units "usec"; + description + "Maximum delay value expressed in microseconds."; + } + } + container unidirectional-link-delay-variation { + description + "Container for the average delay variation + from the local neighbor to the remote neighbor."; + leaf value { + type uint32; + units "usec"; + description + "Delay variation value expressed in microseconds."; + } + } + container unidirectional-link-loss { + description + "Container for packet loss from the local neighbor to the + remote neighbor."; + container flags { + leaf-list unidirectional-link-loss-subtlv-flags { + type identityref { + base unidirectional-link-loss-subtlv-flag; + } + description + "This list contains identities for the bits that + are set."; + } + description + "Unidirectional Link Loss sub-TLV flags."; + } + leaf value { + type uint32; + units "percent"; + description + "Link packet loss expressed as a percentage of + the total traffic sent over a configurable interval."; + } + } + container unidirectional-link-residual-bandwidth { + description + "Container for the residual bandwidth + from the local neighbor to the remote neighbor."; + leaf value { + type rt-types:bandwidth-ieee-float32; + units "Bps"; + description + "Residual bandwidth."; + } + } + container unidirectional-link-available-bandwidth { + description + "Container for the available bandwidth + from the local neighbor to the remote neighbor."; + leaf value { + type rt-types:bandwidth-ieee-float32; + units "Bps"; + description + "Available bandwidth."; + } + } + container unidirectional-link-utilized-bandwidth { + description + "Container for the utilized bandwidth + from the local neighbor to the remote neighbor."; + leaf value { + type rt-types:bandwidth-ieee-float32; + units "Bps"; + description + "Utilized bandwidth."; + } + } + } + + grouping neighbor-te-extensions { + description + "Grouping for TE attributes of a neighbor as defined + in RFC 5305."; + reference + "RFC 5305: IS-IS Extensions for Traffic Engineering"; + leaf admin-group { + type uint32; + description + "Administrative Group / Resource Class/Color."; + } + container local-if-ipv4-addrs { + description + "All local interface IPv4 addresses."; + leaf-list local-if-ipv4-addr { + type inet:ipv4-address; + description + "List of local interface IPv4 addresses."; + } + } + container remote-if-ipv4-addrs { + description + "All remote interface IPv4 addresses."; + leaf-list remote-if-ipv4-addr { + type inet:ipv4-address; + description + "List of remote interface IPv4 addresses."; + } + } + leaf te-metric { + type uint32; + description + "TE metric."; + } + leaf max-bandwidth { + type rt-types:bandwidth-ieee-float32; + description + "Maximum bandwidth."; + } + leaf max-reservable-bandwidth { + type rt-types:bandwidth-ieee-float32; + description + "Maximum reservable bandwidth."; + } + container unreserved-bandwidths { + description + "All unreserved bandwidths."; + list unreserved-bandwidth { + leaf priority { + type uint8 { + range "0 .. 7"; + } + description + "Priority from 0 to 7."; + } + leaf unreserved-bandwidth { + type rt-types:bandwidth-ieee-float32; + description + "Unreserved bandwidth."; + } + description + "List of unreserved bandwidths for different + priorities."; + } + } + } + + grouping neighbor-extended { + description + "Grouping for attributes of an IS-IS extended neighbor."; + leaf neighbor-id { + type extended-system-id; + description + "System ID of the extended neighbor."; + } + container instances { + description + "List of all adjacencies between the local + system and the neighbor system ID."; + list instance { + key "id"; + leaf id { + type uint32; + description + "Unique identifier of an instance of a + particular neighbor."; + } + leaf metric { + type wide-metric; + description + "IS-IS wide metric for the extended neighbor."; + } + uses neighbor-gmpls-extensions; + uses neighbor-te-extensions; + uses neighbor-extended-te-extensions; + uses neighbor-link-attributes; + uses unknown-tlvs; + description + "Instance of a particular adjacency."; + } + } + } + + grouping neighbor { + description + "IS-IS standard neighbor grouping."; + leaf neighbor-id { + type extended-system-id; + description + "IS-IS neighbor system ID."; + } + container instances { + description + "List of all adjacencies between the local + system and the neighbor system ID."; + list instance { + key "id"; + leaf id { + type uint32; + description + "Unique identifier of an instance of a + particular neighbor."; + } + leaf i-e { + type boolean; + description + "Internal or external (I/E) metric bit value. + Set to 'false' to indicate an internal metric."; + } + container default-metric { + leaf metric { + type std-metric; + description + "IS-IS default metric value."; + } + description + "IS-IS default metric container."; + } + container delay-metric { + leaf metric { + type std-metric; + description + "IS-IS delay metric value."; + } + leaf supported { + type boolean; + default "false"; + description + "IS-IS delay metric supported."; + } + description + "IS-IS delay metric container."; + } + container expense-metric { + leaf metric { + type std-metric; + description + "IS-IS expense metric value."; + } + leaf supported { + type boolean; + default "false"; + description + "IS-IS expense metric supported."; + } + description + "IS-IS expense metric container."; + } + container error-metric { + leaf metric { + type std-metric; + description + "IS-IS error metric value."; + } + leaf supported { + type boolean; + default "false"; + description + "IS-IS error metric supported."; + } + description + "IS-IS error metric container."; + } + description + "Instance of a particular adjacency as defined in + ISO 10589."; + reference + "ISO 10589: Intermediate System to Intermediate System + intra-domain routeing information exchange protocol + for use in conjunction with the protocol for providing + the connectionless-mode network service (ISO 8473)"; + } + } + } + + /* Top-level TLVs */ + + grouping tlv132-ipv4-addresses { + leaf-list ipv4-addresses { + type inet:ipv4-address; + description + "List of IPv4 addresses of the IS-IS node. The IS-IS + reference is TLV 132."; + } + description + "Grouping for TLV 132."; + } + + grouping tlv232-ipv6-addresses { + leaf-list ipv6-addresses { + type inet:ipv6-address; + description + "List of IPv6 addresses of the IS-IS node. The IS-IS + reference is TLV 232."; + } + description + "Grouping for TLV 232."; + } + + grouping tlv134-ipv4-te-rid { + leaf ipv4-te-routerid { + type inet:ipv4-address; + description + "IPv4 Traffic Engineering router ID of the IS-IS node. + The IS-IS reference is TLV 134."; + } + description + "Grouping for TLV 134."; + } + + grouping tlv140-ipv6-te-rid { + leaf ipv6-te-routerid { + type inet:ipv6-address; + description + "IPv6 Traffic Engineering router ID of the IS-IS node. + The IS-IS reference is TLV 140."; + } + description + "Grouping for TLV 140."; + } + + grouping tlv129-protocols { + leaf-list protocol-supported { + type uint8; + description + "List of supported protocols of the IS-IS node. + The IS-IS reference is TLV 129."; + } + description + "Grouping for TLV 129."; + } + + grouping tlv137-hostname { + leaf dynamic-hostname { + type string; + description + "Hostname of the IS-IS node. The IS-IS reference + is TLV 137."; + } + description + "Grouping for TLV 137."; + } + + grouping tlv10-authentication { + container authentication { + leaf authentication-type { + type identityref { + base key-chain:crypto-algorithm; + } + description + "Authentication type to be used with an IS-IS node."; + } + leaf authentication-key { + type string; + description + "Authentication key to be used. For security reasons, + the authentication key MUST NOT be presented in + a cleartext format in response to any request + (e.g., via get or get-config)."; + } + description + "IS-IS node authentication information container. The + IS-IS reference is TLV 10."; + } + description + "Grouping for TLV 10."; + } + + grouping tlv229-mt { + container mt-entries { + list topology { + description + "List of topologies supported."; + leaf mt-id { + type uint16 { + range "0 .. 4095"; + } + description + "Multi-Topology (MT) identifier of the topology."; + } + container attributes { + leaf-list flags { + type identityref { + base tlv229-flag; + } + description + "This list contains identities for the bits that + are set."; + } + description + "TLV 229 flags."; + } + } + description + "IS-IS node topology information container. The + IS-IS reference is TLV 229."; + } + description + "Grouping for TLV 229."; + } + + grouping tlv242-router-capabilities { + container router-capabilities { + list router-capability { + container flags { + leaf-list router-capability-flags { + type identityref { + base router-capability-flag; + } + description + "This list contains identities for the bits that + are set."; + } + description + "Router Capability flags."; + } + container node-tags { + if-feature "node-tag"; + list node-tag { + leaf tag { + type uint32; + description + "Node tag value."; + } + description + "List of tags."; + } + description + "Container for node administrative tags."; + } + uses unknown-tlvs; + description + "IS-IS node capabilities. This list element may + be extended with detailed information. The IS-IS + reference is TLV 242."; + } + description + "List of Router Capability TLVs."; + } + description + "Grouping for TLV 242."; + } + + grouping tlv138-srlg { + description + "Grouping for TLV 138."; + container links-srlgs { + list links { + leaf neighbor-id { + type extended-system-id; + description + "System ID of the extended neighbor."; + } + leaf flags { + type uint8; + description + "Flags associated with the link."; + } + leaf link-local-id { + type union { + type inet:ip-address; + type uint32; + } + description + "Local identifier of the link. + It could be an IPv4 address or a local identifier."; + } + leaf link-remote-id { + type union { + type inet:ip-address; + type uint32; + } + description + "Remote identifier of the link. + It could be an IPv4 address or a remotely learned + identifier."; + } + container srlgs { + description + "List of SRLGs."; + leaf-list srlg { + type uint32; + description + "SRLG value of the link."; + } + } + description + "SRLG attribute of a link."; + } + description + "List of links with SRLGs."; + } + } + + /* Grouping for LSDB descriptions */ + + grouping lsp-entry { + description + "IS-IS LSP database entry grouping."; + leaf decoded-completed { + type boolean; + description + "The IS-IS LSP body has been fully decoded."; + } + leaf raw-data { + type yang:hex-string; + description + "The hexadecimal representation of the complete LSP + as received or originated, in network byte order."; + } + leaf lsp-id { + type lsp-id; + description + "LSP ID of the LSP."; + } + leaf checksum { + type uint16; + description + "LSP checksum."; + } + leaf remaining-lifetime { + type uint16; + units "seconds"; + description + "Remaining lifetime (in seconds) until LSP expiration."; + } + leaf sequence { + type uint32; + description + "This leaf describes the sequence number of the LSP."; + } + container attributes { + leaf-list lsp-flags { + type identityref { + base lsp-flag; + } + description + "This list contains identities for the bits that + are set."; + } + description + "LSP attributes."; + } + uses tlv132-ipv4-addresses; + uses tlv232-ipv6-addresses; + uses tlv134-ipv4-te-rid; + uses tlv140-ipv6-te-rid; + uses tlv129-protocols; + uses tlv137-hostname; + uses tlv10-authentication; + uses tlv229-mt; + uses tlv242-router-capabilities; + uses tlv138-srlg; + uses unknown-tlvs; + container is-neighbor { + list neighbor { + key "neighbor-id"; + uses neighbor; + description + "List of neighbors."; + } + description + "Standard IS neighbors container. The IS-IS reference is + TLV 2."; + } + container extended-is-neighbor { + list neighbor { + key "neighbor-id"; + uses neighbor-extended; + description + "List of extended IS neighbors."; + } + description + "Standard IS extended neighbors container. The IS-IS + reference is TLV 22."; + } + container ipv4-internal-reachability { + list prefixes { + uses prefix-ipv4-std; + description + "List of prefixes."; + } + description + "IPv4 internal reachability information container. + The IS-IS reference is TLV 128."; + } + container ipv4-external-reachability { + list prefixes { + uses prefix-ipv4-std; + description + "List of prefixes."; + } + description + "IPv4 external reachability information container. The + IS-IS reference is TLV 130."; + } + container extended-ipv4-reachability { + list prefixes { + uses prefix-ipv4-extended; + uses unknown-tlvs; + description + "List of prefixes."; + } + description + "IPv4 extended reachability information container. The + IS-IS reference is TLV 135."; + } + container mt-is-neighbor { + list neighbor { + leaf mt-id { + type uint16 { + range "0 .. 4095"; + } + description + "Multi-Topology (MT) identifier."; + } + uses neighbor-extended; + description + "List of neighbors."; + } + description + "IS-IS MT neighbor container. The IS-IS reference is + TLV 223."; + } + container mt-extended-ipv4-reachability { + list prefixes { + leaf mt-id { + type uint16 { + range "0 .. 4095"; + } + description + "MT identifier."; + } + uses prefix-ipv4-extended; + uses unknown-tlvs; + description + "List of extended prefixes."; + } + description + "IPv4 MT extended reachability information container. + The IS-IS reference is TLV 235."; + reference + "RFC 5120: M-ISIS: Multi Topology (MT) Routing in + Intermediate System to Intermediate Systems (IS-ISs)"; + } + container mt-ipv6-reachability { + list prefixes { + leaf mt-id { + type uint16 { + range "0 .. 4095"; + } + description + "MT identifier."; + } + uses prefix-ipv6-extended; + uses unknown-tlvs; + description + "List of IPv6 extended prefixes."; + } + description + "IPv6 MT extended reachability information container. + The IS-IS reference is TLV 237."; + reference + "RFC 5120: M-ISIS: Multi Topology (MT) Routing in + Intermediate System to Intermediate Systems (IS-ISs)"; + } + container ipv6-reachability { + list prefixes { + uses prefix-ipv6-extended; + uses unknown-tlvs; + description + "List of IPv6 prefixes."; + } + description + "IPv6 reachability information container. The IS-IS + reference is TLV 236."; + } + } + + grouping lsdb { + description + "Link State Database (LSDB) grouping."; + container database { + config false; + list levels { + key "level"; + leaf level { + type level-number; + description + "LSDB level number (1 or 2)."; + } + list lsp { + key "lsp-id"; + uses lsp-entry; + description + "List of LSPs in the LSDB."; + } + description + "List of LSPs for the LSDB-level container."; + } + description + "IS-IS LSDB container."; + } + } + + /* Augmentations */ + + augment "/rt:routing/" + + "rt:ribs/rt:rib/rt:routes/rt:route" { + when "derived-from-or-self(rt:source-protocol, 'isis:isis')" { + description + "IS-IS-specific route attributes."; + } + uses route-content; + description + "This augments the route object in the Routing Information + Base (RIB) with IS-IS-specific attributes."; + } + + augment "/if:interfaces/if:interface" { + leaf clns-mtu { + if-feature "osi-interface"; + type uint16; + description + "Connectionless-mode Network Service (CLNS) MTU of the + interface."; + } + description + "ISO-specific interface parameters."; + } + + augment "/rt:routing/rt:control-plane-protocols/" + + "rt:control-plane-protocol" { + when "derived-from-or-self(rt:type, 'isis:isis')" { + description + "This augmentation is only valid when the routing protocol + instance type is 'isis'."; + } + description + "This augments a routing protocol instance with IS-IS-specific + parameters."; + container isis { + must 'count(area-address) > 0' { + error-message "At least one area address must be " + + "configured."; + description + "Enforces the configuration of at least one area."; + } + uses instance-config; + uses instance-state; + container topologies { + if-feature "multi-topology"; + list topology { + key "name"; + leaf enabled { + type boolean; + description + "Enables the topology configuration."; + } + leaf name { + type leafref { + path "../../../../../../rt:ribs/rt:rib/rt:name"; + } + description + "RIB corresponding to the topology."; + } + uses multi-topology-config; + description + "List of topologies."; + } + description + "MT container."; + } + container interfaces { + list interface { + key "name"; + leaf name { + type if:interface-ref; + description + "Reference to the interface within + the routing instance."; + } + uses interface-config; + uses interface-state; + container topologies { + if-feature "multi-topology"; + list topology { + key "name"; + leaf name { + type leafref { + path "../../../../../../../../" + + "rt:ribs/rt:rib/rt:name"; + } + description + "RIB corresponding to the topology."; + } + uses multi-topology-interface-config; + description + "List of interface topologies."; + } + description + "MT container."; + } + description + "List of IS-IS interfaces."; + } + description + "Configuration container specific to IS-IS interfaces."; + } + description + "IS-IS configuration/state top-level container."; + } + } + + /* RPC methods */ + + rpc clear-adjacency { + description + "This RPC request clears a particular set of IS-IS + adjacencies. If the operation fails for an internal + reason, then the 'error-tag' and 'error-app-tag' should be + set indicating the reason for the failure."; + reference + "RFC 6241: Network Configuration Protocol (NETCONF)"; + input { + leaf routing-protocol-instance-name { + type leafref { + path "/rt:routing/rt:control-plane-protocols/" + + "rt:control-plane-protocol/rt:name"; + } + mandatory true; + description + "Name of the IS-IS protocol instance whose IS-IS + adjacency is being cleared. + + If the corresponding IS-IS instance doesn't exist, + then the operation will fail with an 'error-tag' of + 'data-missing' and an 'error-app-tag' of + 'routing-protocol-instance-not-found'."; + } + leaf level { + type level; + description + "IS-IS level of the adjacency to be cleared. If the + IS-IS level is 'level-all', level-1 and level-2 + adjacencies would both be cleared. + + If the value provided is different from the value + authorized in the enum type, then the operation + SHALL fail with an 'error-tag' of 'data-missing' and + an 'error-app-tag' of 'bad-isis-level'."; + } + leaf interface { + type if:interface-ref; + description + "IS-IS interface name. + + If the corresponding IS-IS interface doesn't exist, + then the operation SHALL fail with an 'error-tag' of + 'data-missing' and an 'error-app-tag' of + 'isis-interface-not-found'."; + } + } + } + + rpc clear-database { + description + "This RPC request clears a particular IS-IS database. + Additionally, all neighbor adjacencies will be forced to + the DOWN state and self-originated LSPs will be + reoriginated. If the operation fails for an IS-IS + internal reason, then the 'error-tag' and 'error-app-tag' + should be set indicating the reason for the failure."; + input { + leaf routing-protocol-instance-name { + type leafref { + path "/rt:routing/rt:control-plane-protocols/" + + "rt:control-plane-protocol/rt:name"; + } + mandatory true; + description + "Name of the IS-IS protocol instance whose IS-IS + database or databases are being cleared. + + If the corresponding IS-IS instance doesn't exist, + then the operation will fail with an 'error-tag' of + 'data-missing' and an 'error-app-tag' of + 'routing-protocol-instance-not-found'."; + } + leaf level { + type level; + description + "IS-IS level of the adjacency to be cleared. If the + IS-IS level is 'level-all', the databases for both + level 1 and level 2 would be cleared. + + If the value provided is different from the value + authorized in the enum type, then the operation + SHALL fail with an 'error-tag' of 'data-missing' and + an 'error-app-tag' of 'bad-isis-level'."; + } + } + } + + /* Notifications */ + + notification database-overload { + uses notification-instance-hdr; + leaf overload { + type enumeration { + enum off { + description + "Indicates that the IS-IS instance has left the + overload state."; + } + enum on { + description + "Indicates that the IS-IS instance has entered the + overload state."; + } + } + description + "New overload state of the IS-IS instance."; + } + description + "This notification is sent when an IS-IS instance + overload state changes."; + } + + notification lsp-too-large { + uses notification-instance-hdr; + uses notification-interface-hdr; + leaf pdu-size { + type uint32; + description + "Size of the LSP PDU."; + } + leaf lsp-id { + type lsp-id; + description + "LSP ID."; + } + description + "This notification is sent when an attempt to propagate + an LSP that is larger than the dataLinkBlockSize (ISO 10589) + for the circuit occurs. The generation of the notification + must be throttled with at least 5 seconds between successive + notifications."; + reference + "ISO 10589: Intermediate System to Intermediate System + intra-domain routeing information exchange protocol + for use in conjunction with the protocol for providing + the connectionless-mode network service (ISO 8473)"; + } + + notification if-state-change { + uses notification-instance-hdr; + uses notification-interface-hdr; + leaf state { + type if-state-type; + description + "Interface state."; + } + description + "This notification is sent when an interface + state change is detected."; + } + + notification corrupted-lsp-detected { + uses notification-instance-hdr; + leaf lsp-id { + type lsp-id; + description + "LSP ID."; + } + description + "This notification is sent when an LSP that was stored in + memory has become corrupted."; + } + + notification attempt-to-exceed-max-sequence { + uses notification-instance-hdr; + leaf lsp-id { + type lsp-id; + description + "LSP ID."; + } + description + "This notification is sent when the system + wraps the 32-bit sequence counter of an LSP."; + } + + notification id-len-mismatch { + uses notification-instance-hdr; + uses notification-interface-hdr; + leaf pdu-field-len { + type uint8; + description + "Value for the system ID length in the received PDU."; + } + leaf raw-pdu { + type binary; + description + "Received raw PDU."; + } + description + "This notification is sent when a PDU with a different value + for the system ID length is received. The generation of the + notification must be throttled with at least 5 seconds + between successive notifications."; + } + + notification max-area-addresses-mismatch { + uses notification-instance-hdr; + uses notification-interface-hdr; + leaf max-area-addresses { + type uint8; + description + "Received number of supported areas."; + } + leaf raw-pdu { + type binary; + description + "Received raw PDU."; + } + description + "This notification is sent when a PDU with a different value + for the Maximum Area Addresses has been received. The + generation of the notification must be throttled with + at least 5 seconds between successive notifications."; + } + + notification own-lsp-purge { + uses notification-instance-hdr; + uses notification-interface-hdr; + leaf lsp-id { + type lsp-id; + description + "LSP ID."; + } + description + "This notification is sent when the system receives + a PDU with its own system ID and zero age."; + } + + notification sequence-number-skipped { + uses notification-instance-hdr; + uses notification-interface-hdr; + leaf lsp-id { + type lsp-id; + description + "LSP ID."; + } + description + "This notification is sent when the system receives a + PDU with its own system ID and different contents. The + system has to originate the LSP with a higher sequence + number."; + } + + notification authentication-type-failure { + uses notification-instance-hdr; + uses notification-interface-hdr; + leaf raw-pdu { + type binary; + description + "Received raw PDU."; + } + description + "This notification is sent when the system receives a + PDU with the wrong authentication type field. + The generation of the notification must be throttled + with at least 5 seconds between successive notifications."; + } + + notification authentication-failure { + uses notification-instance-hdr; + uses notification-interface-hdr; + leaf raw-pdu { + type binary; + description + "Received raw PDU."; + } + description + "This notification is sent when the system receives + a PDU on which authentication fails. The generation of the + notification must be throttled with at least 5 seconds + between successive notifications."; + } + + notification version-skew { + uses notification-instance-hdr; + uses notification-interface-hdr; + leaf protocol-version { + type uint8; + description + "Protocol version received in the PDU."; + } + leaf raw-pdu { + type binary; + description + "Received raw PDU."; + } + description + "This notification is sent when the system receives a + PDU with a different protocol version number. + The generation of the notification must be throttled + with at least 5 seconds between successive notifications."; + } + + notification area-mismatch { + uses notification-instance-hdr; + uses notification-interface-hdr; + leaf raw-pdu { + type binary; + description + "Received raw PDU."; + } + description + "This notification is sent when the system receives a + Hello PDU from an IS that does not share any area + address. The generation of the notification must be + throttled with at least 5 seconds between successive + notifications."; + } + + notification rejected-adjacency { + uses notification-instance-hdr; + uses notification-interface-hdr; + leaf raw-pdu { + type binary; + description + "Received raw PDU."; + } + leaf reason { + type string { + length "0..255"; + } + description + "The system may provide a reason to reject the + adjacency. If the reason is not available, + the reason string will not be returned. + The expected format is a single line of text."; + } + description + "This notification is sent when the system receives a + Hello PDU from an IS but does not establish an adjacency + for some reason. The generation of the notification + must be throttled with at least 5 seconds between + successive notifications."; + } + + notification protocols-supported-mismatch { + uses notification-instance-hdr; + uses notification-interface-hdr; + leaf raw-pdu { + type binary; + description + "Received raw PDU."; + } + leaf-list protocols { + type uint8; + description + "List of protocols supported by the remote system."; + } + description + "This notification is sent when the system receives a + non-pseudonode LSP that has no matching protocols + supported. The generation of the notification must be + throttled with at least 5 seconds between successive + notifications."; + } + + notification lsp-error-detected { + uses notification-instance-hdr; + uses notification-interface-hdr; + leaf lsp-id { + type lsp-id; + description + "LSP ID."; + } + leaf raw-pdu { + type binary; + description + "Received raw PDU."; + } + leaf error-offset { + type uint32; + description + "If the problem is a malformed TLV, the error offset + points to the start of the TLV. If the problem is with + the LSP header, the error offset points to the errant + byte."; + } + leaf tlv-type { + type uint8; + description + "If the problem is a malformed TLV, the TLV type is set + to the type value of the suspicious TLV. Otherwise, + this leaf is not present."; + } + description + "This notification is sent when the system receives an + LSP with a parse error. The generation of the notification + must be throttled with at least 5 seconds between + successive notifications."; + } + + notification adjacency-state-change { + uses notification-instance-hdr; + uses notification-interface-hdr; + leaf neighbor { + type string { + length "1..255"; + } + description + "Name of the neighbor. It corresponds to the hostname + associated with the system ID of the neighbor in the + mapping database (RFC 5301). If the name of the neighbor + is not available, it is not returned."; + reference + "RFC 5301: Dynamic Hostname Exchange Mechanism for IS-IS"; + } + leaf neighbor-system-id { + type system-id; + description + "Neighbor system ID."; + } + leaf state { + type adj-state-type; + description + "New state of the IS-IS adjacency."; + } + leaf reason { + type string { + length "1..255"; + } + description + "If the adjacency is going to the 'down' state, this leaf + provides a reason for the adjacency going down. The reason + is provided as text. If the adjacency is going to the 'up' + state, no reason is provided. The expected format is a + single line of text."; + } + description + "This notification is sent when an IS-IS adjacency + moves to the 'up' state or the 'down' state."; + } + + notification lsp-received { + uses notification-instance-hdr; + uses notification-interface-hdr; + leaf lsp-id { + type lsp-id; + description + "LSP ID."; + } + leaf sequence { + type uint32; + description + "Sequence number of the received LSP."; + } + leaf received-timestamp { + type yang:timestamp; + description + "Timestamp when the LSP was received."; + } + leaf neighbor-system-id { + type system-id; + description + "Neighbor system ID of the LSP sender."; + } + description + "This notification is sent when an LSP is received. + The generation of the notification must be throttled with + at least 5 seconds between successive notifications."; + } + + notification lsp-generation { + uses notification-instance-hdr; + leaf lsp-id { + type lsp-id; + description + "LSP ID."; + } + leaf sequence { + type uint32; + description + "Sequence number of the received LSP."; + } + leaf send-timestamp { + type yang:timestamp; + description + "Timestamp when the LSP was regenerated."; + } + description + "This notification is sent when an LSP is regenerated. + The generation of the notification must be throttled with + at least 5 seconds between successive notifications."; + } +} diff --git a/Yang/ietf-l3-isis-topology.yang b/Yang/ietf-l3-isis-topology.yang new file mode 100644 index 0000000..d43319a --- /dev/null +++ b/Yang/ietf-l3-isis-topology.yang @@ -0,0 +1,201 @@ +module ietf-l3-isis-topology { + yang-version 1.1; + namespace + "urn:ietf:params:xml:ns:yang:ietf-l3-isis-topology"; + prefix "isisnt"; + + import ietf-network { + prefix "nw"; + reference + "RFC 8345: A YANG Data Model for Network Topologies"; + } + + import ietf-network-topology { + prefix "nt"; + reference + "RFC 8345: A YANG Data Model for Network Topologies"; + } + + import ietf-l3-unicast-topology { + prefix "l3t"; + reference + "RFC 8346: A YANG Data Model for Layer 3 Topologies"; + } + + import ietf-isis { + prefix "ietf-isis"; + reference + "RFC 9130: YANG Data Model for the IS-IS Protocols"; + } + + import ietf-inet-types { + prefix "inet"; + reference + "RFC 6991: Common YANG Data Types"; + } + + organization + "IETF OPSA (Operations and Management Area) Working Group"; + contact + "WG Web: + WG List: + + Editor: Oscar Gonzalez de Dios + + Editor: Samier Barguil + + Editor: Victor Lopez + "; + description + "This module defines a model for Layer 3 ISIS + topologies. + + Copyright (c) 2022 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 Revised BSD License set + forth in Section 4.c of the IETF Trust's Legal Provisions + Relating to IETF Documents + (https://trustee.ietf.org/license-info). + + This version of this YANG module is part of RFC XXXX + (https://www.rfc-editor.org/info/rfcXXXX); see the RFC itself + for full legal notices."; + + revision 2022-09-21 { + description + "Initial version"; + reference + "RFC XXXX: A YANG Data Model for Intermediate System to + Intermediate System (ISIS) Topology"; + } + + grouping isis-topology-type { + description "Identifies the topology type to be ISIS."; + container isis-topology { + presence "indicates ISIS topology"; + description + "The presence of the container node indicates ISIS + topology"; + } + } + + grouping isis-node-attributes { + description "isis node scope attributes"; + container isis-timer-attributes { + description + "Contains node timer attributes"; + uses ietf-isis:lsp-parameters; + } + container isis-status { + description + "Contains the ISIS status attributes"; + leaf level { + type ietf-isis:level; + description + "Level of an IS-IS node - can be level-1, + level-2 or level-all."; + } + + leaf-list area-address { + type ietf-isis:area-address; + description + "List of areas supported by the protocol instance."; + } + + leaf system-id { + type ietf-isis:system-id; + description + "System-id of the node."; + } + + leaf-list neighbors { + type inet:ip-address; + config false; + description + "Topology flags"; + } + } + } + + grouping isis-termination-point-attributes { + description "ISIS termination point scope attributes"; + container isis-termination-point-attributes { + description + "Indicates the termination point from the + which the ISIS is configured. A termination + point can be a physical port, an interface, etc."; + + leaf interface-type { + type ietf-isis:interface-type; + description + "Type of adjacency to be established for the interface. This + dictates the type of hello messages that are used."; + } + + leaf level { + type ietf-isis:level; + description + "Level of an IS-IS node - can be level-1, + level-2 or level-all."; + } + + leaf metric { + type uint32 { + range "0 .. 16777215"; + } + description + "This type defines wide style format of IS-IS metric."; + } + + leaf is-passive{ + type boolean; + description + "Indicates whether the interface is in passive mode (IS-IS + not running but network is advertised)."; + } + } + } + + augment "/nw:networks/nw:network/nw:network-types" { + description + "Introduces new network type for L3 Unicast topology"; + uses isis-topology-type; + } + + augment "/nw:networks/nw:network/nw:node/l3t:l3-node-attributes" { + when "/nw:networks/nw:network/nw:network-types/isisnt:isis-topology" { + description + "Augmentation parameters apply only for networks with + isis topology"; + } + description + "isis node-level attributes "; + uses isis-node-attributes; + } + + augment "/nw:networks/nw:network/nt:link/l3t:l3-link-attributes" { + when "/nw:networks/nw:network/nw:network-types/isisnt:isis-topology" { + description + "Augmentation parameters apply only for networks with + ISIS topology"; + } + description + "Augments topology link configuration"; + uses isis-termination-point-attributes; + } + + augment "/nw:networks/nw:network/nw:node/nt:termination-point/l3t:l3-termination-point-attributes" { + when "/nw:networks/nw:network/nw:network-types/isisnt:isis-topology" { + description + "Augmentation parameters apply only for networks with + ISIS topology"; + } + description + "Augments topology termination point configuration"; + uses isis-termination-point-attributes; + } +} + diff --git a/Yang/ietf-l3-unicast-topology@2018-02-26.yang b/Yang/ietf-l3-unicast-topology@2018-02-26.yang new file mode 100644 index 0000000..39fcebd --- /dev/null +++ b/Yang/ietf-l3-unicast-topology@2018-02-26.yang @@ -0,0 +1,359 @@ +module ietf-l3-unicast-topology { + yang-version 1.1; + namespace + "urn:ietf:params:xml:ns:yang:ietf-l3-unicast-topology"; + prefix "l3t"; + import ietf-network { + prefix "nw"; + } + import ietf-network-topology { + prefix "nt"; + } + import ietf-inet-types { + prefix "inet"; + } + import ietf-routing-types { + prefix "rt-types"; + } + organization + "IETF I2RS (Interface to the Routing System) Working Group"; + contact + "WG Web: + WG List: + Editor: Alexander Clemm + + Editor: Jan Medved + + Editor: Robert Varga + + Editor: Xufeng Liu + + Editor: Nitin Bahadur + + Editor: Hariharan Ananthakrishnan + "; + description + "This module defines a model for Layer 3 Unicast + topologies. + + Copyright (c) 2018 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 + (https://trustee.ietf.org/license-info). + + This version of this YANG module is part of + RFC 8346; see the RFC itself for full legal notices."; + revision "2018-02-26" { + description + "Initial revision."; + reference + "RFC 8346: A YANG Data Model for Layer 3 Topologies"; + } + + identity flag-identity { + description "Base type for flags"; + } + + typedef l3-event-type { + type enumeration { + enum "add" { + description + "A Layer 3 node, link, prefix, or termination point has + been added"; + } + enum "remove" { + description + "A Layer 3 node, link, prefix, or termination point has + been removed"; + } + enum "update" { + description + "A Layer 3 node, link, prefix, or termination point has + been updated"; + } + } + description "Layer 3 event type for notifications"; + } + + typedef prefix-flag-type { + type identityref { + base "flag-identity"; + } + description "Prefix flag attributes"; + } + + typedef node-flag-type { + type identityref { + base "flag-identity"; + } + description "Node flag attributes"; + } + + typedef link-flag-type { + type identityref { + base "flag-identity"; + } + description "Link flag attributes"; + } + + typedef l3-flag-type { + type identityref { + base "flag-identity"; + } + description "L3 flag attributes"; + } + + grouping l3-prefix-attributes { + description + "L3 prefix attributes"; + leaf prefix { + type inet:ip-prefix; + description + "IP prefix value"; + } + leaf metric { + type uint32; + description + "Prefix metric"; + } + leaf-list flag { + type prefix-flag-type; + description + "Prefix flags"; + } + } + grouping l3-unicast-topology-type { + description "Identifies the topology type to be L3 Unicast."; + container l3-unicast-topology { + presence "indicates L3 Unicast topology"; + description + "The presence of the container node indicates L3 Unicast + topology"; + } + } + grouping l3-topology-attributes { + description "Topology scope attributes"; + container l3-topology-attributes { + description "Contains topology attributes"; + leaf name { + type string; + description + "Name of the topology"; + } + leaf-list flag { + type l3-flag-type; + description + "Topology flags"; + } + } + } + grouping l3-node-attributes { + description "L3 node scope attributes"; + container l3-node-attributes { + description + "Contains node attributes"; + leaf name { + type inet:domain-name; + description + "Node name"; + } + leaf-list flag { + type node-flag-type; + description + "Node flags"; + } + leaf-list router-id { + type rt-types:router-id; + description + "Router-id for the node"; + } + list prefix { + key "prefix"; + description + "A list of prefixes along with their attributes"; + uses l3-prefix-attributes; + } + } + } + grouping l3-link-attributes { + description + "L3 link scope attributes"; + container l3-link-attributes { + description + "Contains link attributes"; + leaf name { + type string; + description + "Link Name"; + } + leaf-list flag { + type link-flag-type; + description + "Link flags"; + } + leaf metric1 { + type uint64; + description + "Link Metric 1"; + } + leaf metric2 { + type uint64; + description + "Link Metric 2"; + } + } + } + grouping l3-termination-point-attributes { + description "L3 termination point scope attributes"; + container l3-termination-point-attributes { + description + "Contains termination point attributes"; + choice termination-point-type { + description + "Indicates the termination point type"; + case ip { + leaf-list ip-address { + type inet:ip-address; + description + "IPv4 or IPv6 address."; + } + } + case unnumbered { + leaf unnumbered-id { + type uint32; + description + "Unnumbered interface identifier. + The identifier will correspond to the ifIndex value + of the interface, i.e., the ifIndex value of the + ifEntry that represents the interface in + implementations where the Interfaces Group MIB + (RFC 2863) is supported."; + reference + "RFC 2863: The Interfaces Group MIB"; + } + } + case interface-name { + leaf interface-name { + type string; + description + "Name of the interface. The name can (but does not + have to) correspond to an interface reference of a + containing node's interface, i.e., the path name of a + corresponding interface data node on the containing + node reminiscent of data type interface-ref defined + in RFC 8343. It should be noted that data type + interface-ref of RFC 8343 cannot be used directly, + + as this data type is used to reference an interface + in a datastore of a single node in the network, not + to uniquely reference interfaces across a network."; + reference + "RFC 8343: A YANG Data Model for Interface Management"; + } + } + } + } + } + augment "/nw:networks/nw:network/nw:network-types" { + description + "Introduces new network type for L3 Unicast topology"; + uses l3-unicast-topology-type; + } + augment "/nw:networks/nw:network" { + when "nw:network-types/l3t:l3-unicast-topology" { + description + "Augmentation parameters apply only for networks with + L3 Unicast topology"; + } + description + "L3 Unicast for the network as a whole"; + uses l3-topology-attributes; + } + augment "/nw:networks/nw:network/nw:node" { + when "../nw:network-types/l3t:l3-unicast-topology" { + description + "Augmentation parameters apply only for networks with + L3 Unicast topology"; + } + description + "L3 Unicast node-level attributes "; + uses l3-node-attributes; + } + augment "/nw:networks/nw:network/nt:link" { + when "../nw:network-types/l3t:l3-unicast-topology" { + description + "Augmentation parameters apply only for networks with + L3 Unicast topology"; + } + description + "Augments topology link attributes"; + uses l3-link-attributes; + } + augment "/nw:networks/nw:network/nw:node/" + +"nt:termination-point" { + when "../../nw:network-types/l3t:l3-unicast-topology" { + description + "Augmentation parameters apply only for networks with + L3 Unicast topology"; + } + description "Augments topology termination point configuration"; + uses l3-termination-point-attributes; + } + notification l3-node-event { + description + "Notification event for L3 node"; + leaf l3-event-type { + type l3-event-type; + description + "Event type"; + } + uses nw:node-ref; + uses l3-unicast-topology-type; + uses l3-node-attributes; + } + notification l3-link-event { + description + "Notification event for L3 link"; + leaf l3-event-type { + type l3-event-type; + description + "Event type"; + } + uses nt:link-ref; + uses l3-unicast-topology-type; + uses l3-link-attributes; + } + notification l3-prefix-event { + description + "Notification event for L3 prefix"; + leaf l3-event-type { + type l3-event-type; + description + "Event type"; + } + uses nw:node-ref; + uses l3-unicast-topology-type; + container prefix { + description + "Contains L3 prefix attributes"; + uses l3-prefix-attributes; + } + } + notification termination-point-event { + description + "Notification event for L3 termination point"; + leaf l3-event-type { + type l3-event-type; + description + "Event type"; + } + uses nt:tp-ref; + uses l3-unicast-topology-type; + uses l3-termination-point-attributes; + } +} diff --git a/Yang/ietf-network-topology@2018-02-26.yang b/Yang/ietf-network-topology@2018-02-26.yang new file mode 100644 index 0000000..1ec944d --- /dev/null +++ b/Yang/ietf-network-topology@2018-02-26.yang @@ -0,0 +1,294 @@ +module ietf-network-topology { + yang-version 1.1; + namespace "urn:ietf:params:xml:ns:yang:ietf-network-topology"; + prefix nt; + + import ietf-inet-types { + prefix inet; + reference + "RFC 6991: Common YANG Data Types"; + } + import ietf-network { + prefix nw; + reference + "RFC 8345: A YANG Data Model for Network Topologies"; + } + + organization + "IETF I2RS (Interface to the Routing System) Working Group"; + + contact + "WG Web: + WG List: + + Editor: Alexander Clemm + + + Editor: Jan Medved + + + Editor: Robert Varga + + + Editor: Nitin Bahadur + + + Editor: Hariharan Ananthakrishnan + + + Editor: Xufeng Liu + "; + + description + "This module defines a common base model for a network topology, + augmenting the base network data model with links to connect + nodes, as well as termination points to terminate links + on nodes. + + Copyright (c) 2018 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 + (https://trustee.ietf.org/license-info). + + This version of this YANG module is part of RFC 8345; + see the RFC itself for full legal notices."; + + revision 2018-02-26 { + description + "Initial revision."; + reference + "RFC 8345: A YANG Data Model for Network Topologies"; + } + + typedef link-id { + type inet:uri; + description + "An identifier for a link in a topology. The precise + structure of the link-id will be up to the implementation. + The identifier SHOULD be chosen such that the same link in a + real network topology will always be identified through the + same identifier, even if the data model is instantiated in + separate datastores. An implementation MAY choose to capture + semantics in the identifier -- for example, to indicate the + type of link and/or the type of topology of which the link is + a part."; + } + + typedef tp-id { + type inet:uri; + description + "An identifier for termination points on a node. The precise + structure of the tp-id will be up to the implementation. + The identifier SHOULD be chosen such that the same termination + point in a real network topology will always be identified + through the same identifier, even if the data model is + instantiated in separate datastores. An implementation MAY + choose to capture semantics in the identifier -- for example, + to indicate the type of termination point and/or the type of + node that contains the termination point."; + } + + grouping link-ref { + description + "This grouping can be used to reference a link in a specific + network. Although it is not used in this module, it is + defined here for the convenience of augmenting modules."; + leaf link-ref { + type leafref { + path "/nw:networks/nw:network[nw:network-id=current()/../"+ + "network-ref]/nt:link/nt:link-id"; + require-instance false; + } + description + "A type for an absolute reference to a link instance. + (This type should not be used for relative references. + In such a case, a relative path should be used instead.)"; + } + uses nw:network-ref; + } + + grouping tp-ref { + description + "This grouping can be used to reference a termination point + in a specific node. Although it is not used in this module, + it is defined here for the convenience of augmenting + modules."; + leaf tp-ref { + type leafref { + path "/nw:networks/nw:network[nw:network-id=current()/../"+ + "network-ref]/nw:node[nw:node-id=current()/../"+ + "node-ref]/nt:termination-point/nt:tp-id"; + require-instance false; + } + description + "A type for an absolute reference to a termination point. + (This type should not be used for relative references. + In such a case, a relative path should be used instead.)"; + } + uses nw:node-ref; + } + + augment "/nw:networks/nw:network" { + description + "Add links to the network data model."; + list link { + key "link-id"; + description + "A network link connects a local (source) node and + a remote (destination) node via a set of the respective + node's termination points. It is possible to have several + links between the same source and destination nodes. + Likewise, a link could potentially be re-homed between + termination points. Therefore, in order to ensure that we + would always know to distinguish between links, every link + is identified by a dedicated link identifier. Note that a + link models a point-to-point link, not a multipoint link."; + leaf link-id { + type link-id; + description + "The identifier of a link in the topology. + A link is specific to a topology to which it belongs."; + } + container source { + description + "This container holds the logical source of a particular + link."; + leaf source-node { + type leafref { + path "../../../nw:node/nw:node-id"; + require-instance false; + } + description + "Source node identifier. Must be in the same topology."; + } + leaf source-tp { + type leafref { + path "../../../nw:node[nw:node-id=current()/../"+ + "source-node]/termination-point/tp-id"; + require-instance false; + } + description + "This termination point is located within the source node + and terminates the link."; + } + } + + container destination { + description + "This container holds the logical destination of a + particular link."; + leaf dest-node { + type leafref { + path "../../../nw:node/nw:node-id"; + require-instance false; + } + description + "Destination node identifier. Must be in the same + network."; + } + leaf dest-tp { + type leafref { + path "../../../nw:node[nw:node-id=current()/../"+ + "dest-node]/termination-point/tp-id"; + require-instance false; + } + description + "This termination point is located within the + destination node and terminates the link."; + } + } + list supporting-link { + key "network-ref link-ref"; + description + "Identifies the link or links on which this link depends."; + leaf network-ref { + type leafref { + path "../../../nw:supporting-network/nw:network-ref"; + require-instance false; + } + description + "This leaf identifies in which underlay topology + the supporting link is present."; + } + + leaf link-ref { + type leafref { + path "/nw:networks/nw:network[nw:network-id=current()/"+ + "../network-ref]/link/link-id"; + require-instance false; + } + description + "This leaf identifies a link that is a part + of this link's underlay. Reference loops in which + a link identifies itself as its underlay, either + directly or transitively, are not allowed."; + } + } + } + } + augment "/nw:networks/nw:network/nw:node" { + description + "Augments termination points that terminate links. + Termination points can ultimately be mapped to interfaces."; + list termination-point { + key "tp-id"; + description + "A termination point can terminate a link. + Depending on the type of topology, a termination point + could, for example, refer to a port or an interface."; + leaf tp-id { + type tp-id; + description + "Termination point identifier."; + } + list supporting-termination-point { + key "network-ref node-ref tp-ref"; + description + "This list identifies any termination points on which a + given termination point depends or onto which it maps. + Those termination points will themselves be contained + in a supporting node. This dependency information can be + inferred from the dependencies between links. Therefore, + this item is not separately configurable. Hence, no + corresponding constraint needs to be articulated. + The corresponding information is simply provided by the + implementing system."; + + leaf network-ref { + type leafref { + path "../../../nw:supporting-node/nw:network-ref"; + require-instance false; + } + description + "This leaf identifies in which topology the + supporting termination point is present."; + } + leaf node-ref { + type leafref { + path "../../../nw:supporting-node/nw:node-ref"; + require-instance false; + } + description + "This leaf identifies in which node the supporting + termination point is present."; + } + leaf tp-ref { + type leafref { + path "/nw:networks/nw:network[nw:network-id=current()/"+ + "../network-ref]/nw:node[nw:node-id=current()/../"+ + "node-ref]/termination-point/tp-id"; + require-instance false; + } + description + "Reference to the underlay node (the underlay node must + be in a different topology)."; + } + } + } + } +} diff --git a/Yang/ietf-network@2018-02-26.yang b/Yang/ietf-network@2018-02-26.yang new file mode 100644 index 0000000..6a03d7e --- /dev/null +++ b/Yang/ietf-network@2018-02-26.yang @@ -0,0 +1,192 @@ +module ietf-network { + yang-version 1.1; + namespace "urn:ietf:params:xml:ns:yang:ietf-network"; + prefix nw; + + import ietf-inet-types { + prefix inet; + reference + "RFC 6991: Common YANG Data Types"; + } + + organization + "IETF I2RS (Interface to the Routing System) Working Group"; + + contact + "WG Web: + WG List: + + Editor: Alexander Clemm + + + Editor: Jan Medved + + + Editor: Robert Varga + + + Editor: Nitin Bahadur + + + Editor: Hariharan Ananthakrishnan + + + Editor: Xufeng Liu + "; + description + "This module defines a common base data model for a collection + of nodes in a network. Node definitions are further used + in network topologies and inventories. + + Copyright (c) 2018 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 + (https://trustee.ietf.org/license-info). + + This version of this YANG module is part of RFC 8345; + see the RFC itself for full legal notices."; + + revision 2018-02-26 { + description + "Initial revision."; + reference + "RFC 8345: A YANG Data Model for Network Topologies"; + } + + typedef node-id { + type inet:uri; + description + "Identifier for a node. The precise structure of the node-id + will be up to the implementation. For example, some + implementations MAY pick a URI that includes the network-id + as part of the path. The identifier SHOULD be chosen + such that the same node in a real network topology will + always be identified through the same identifier, even if + the data model is instantiated in separate datastores. An + implementation MAY choose to capture semantics in the + identifier -- for example, to indicate the type of node."; + } + + typedef network-id { + type inet:uri; + description + "Identifier for a network. The precise structure of the + network-id will be up to the implementation. The identifier + SHOULD be chosen such that the same network will always be + identified through the same identifier, even if the data model + is instantiated in separate datastores. An implementation MAY + choose to capture semantics in the identifier -- for example, + to indicate the type of network."; + } + + grouping network-ref { + description + "Contains the information necessary to reference a network -- + for example, an underlay network."; + leaf network-ref { + type leafref { + path "/nw:networks/nw:network/nw:network-id"; + require-instance false; + } + description + "Used to reference a network -- for example, an underlay + network."; + } + } + + grouping node-ref { + description + "Contains the information necessary to reference a node."; + leaf node-ref { + type leafref { + path "/nw:networks/nw:network[nw:network-id=current()/../"+ + "network-ref]/nw:node/nw:node-id"; + require-instance false; + } + description + "Used to reference a node. + Nodes are identified relative to the network that + contains them."; + } + uses network-ref; + } + + container networks { + description + "Serves as a top-level container for a list of networks."; + list network { + key "network-id"; + description + "Describes a network. + A network typically contains an inventory of nodes, + topological information (augmented through the + network-topology data model), and layering information."; + leaf network-id { + type network-id; + description + "Identifies a network."; + } + container network-types { + description + "Serves as an augmentation target. + The network type is indicated through corresponding + presence containers augmented into this container."; + } + list supporting-network { + key "network-ref"; + description + "An underlay network, used to represent layered network + topologies."; + leaf network-ref { + type leafref { + path "/nw:networks/nw:network/nw:network-id"; + require-instance false; + } + description + "References the underlay network."; + } + } + + list node { + key "node-id"; + description + "The inventory of nodes of this network."; + leaf node-id { + type node-id; + description + "Uniquely identifies a node within the containing + network."; + } + list supporting-node { + key "network-ref node-ref"; + description + "Represents another node that is in an underlay network + and that supports this node. Used to represent layering + structure."; + leaf network-ref { + type leafref { + path "../../../nw:supporting-network/nw:network-ref"; + require-instance false; + } + description + "References the underlay network of which the + underlay node is a part."; + } + leaf node-ref { + type leafref { + path "/nw:networks/nw:network/nw:node/nw:node-id"; + require-instance false; + } + description + "References the underlay node itself."; + } + } + } + } + } +} diff --git a/draft-ogondio-opsawg-isis-topology.md b/draft-ogondio-opsawg-isis-topology.md index 28302c7..c6d0171 100644 --- a/draft-ogondio-opsawg-isis-topology.md +++ b/draft-ogondio-opsawg-isis-topology.md @@ -244,7 +244,7 @@ module ietf-l3-isis-topology { Editor: Samier Barguil Editor: Victor Lopez - "; + ; Editor: Benoit Claise "; description @@ -288,22 +288,7 @@ module ietf-l3-isis-topology { container isis-timer-attributes { description "Contains node timer attributes"; - leaf lsp-lifetime { - type uint16 { - range "1..65535"; - } - units "seconds"; - description - "Lifetime of the router's LSPs in seconds."; - } - leaf lsp-refresh-interval { - type uint16 { - range "1..65535"; - } - units "seconds"; - description - "Refresh interval of the router's LSPs in seconds."; - } + uses ietf-isis:lsp-parameters; } container isis-status { description