diff options
Diffstat (limited to 'yang/frr-isisd.yang')
| -rw-r--r-- | yang/frr-isisd.yang | 2517 |
1 files changed, 2517 insertions, 0 deletions
diff --git a/yang/frr-isisd.yang b/yang/frr-isisd.yang new file mode 100644 index 0000000..5d7c739 --- /dev/null +++ b/yang/frr-isisd.yang @@ -0,0 +1,2517 @@ +// SPDX-License-Identifier: BSD-2-Clause +module frr-isisd { + yang-version 1.1; + namespace "http://frrouting.org/yang/isisd"; + prefix frr-isisd; + + import ietf-yang-types { + prefix yang; + } + + import ietf-inet-types { + prefix inet; + } + + import frr-interface { + prefix frr-interface; + } + + import frr-vrf { + prefix frr-vrf; + } + + import frr-route-map { + prefix frr-route-map; + } + + import frr-route-types { + prefix frr-route-types; + } + + organization + "FRRouting"; + contact + "FRR Users List: <mailto:frog@lists.frrouting.org> FRR Development + List: <mailto:dev@lists.frrouting.org>"; + description + "This module defines a model for managing FRR isisd daemon. + + Copyright 2020 FRRouting + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."; + + revision 2021-02-15 { + description + "Group SRGB and SRLB in a container so that they can be displayed + and configured together"; + } + revision 2020-04-06 { + description + "Group LSP timers in a container so that they can be displayed and + configured together"; + } + revision 2019-12-17 { + description + "Changed default area is-type to level-1-2"; + } + revision 2019-09-09 { + description + "Changed interface references to use + frr-interface:interface-ref typedef"; + } + revision 2018-07-26 { + description + "Initial revision."; + reference + "ISO/IEC 10589:2002."; + } + + typedef level { + type enumeration { + enum "level-1" { + value 1; + description + "This enum indicates L1-only capability."; + } + enum "level-2" { + value 2; + description + "This enum indicates L2-only capability."; + } + enum "level-1-2" { + value 3; + description + "This enum indicates capability for both levels."; + } + } + description + "This type defines IS-IS level of an object."; + } + + typedef extended-circuit-id { + type uint32; + description + "This type defines the extended circuit ID + associated with an interface."; + } + + typedef hello-padding-type { + type enumeration { + enum "always" { + value 0; + description + "Add padding to all hello packets."; + } + enum "disabled" { + value 1; + description + "Do not add any padding to hello packets."; + } + enum "during-adjacency-formation" { + value 2; + description + "Add padding to hello packets during adjacency formation only."; + } + } + } + + typedef network-type { + type enumeration { + enum "unknown" { + value 0; + description + "Unknown network type. Only valid as a state."; + } + enum "broadcast" { + value 1; + description + "Broadcast circuit network-type."; + } + enum "point-to-point" { + value 2; + description + "Point-to-point circuit network-type."; + } + enum "loopback" { + value 3; + description + "Loopback circuit network-type. Only valid as a state."; + } + } + } + + 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 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 MAC address like + '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 IS-IS system-id using a pattern, + An example system-id is 0143.0438.AeF0"; + } + + typedef net-address { + type string { + pattern "[a-fA-F0-9]{2}(\\.[a-fA-F0-9]{4}){3,9}\\.[a-fA-F0-9]{2}"; + } + description + "This type defines an OSI NET address using a pattern, + An example net-address is 49.0123.6452.1972.00"; + } + + typedef if-state-type { + type enumeration { + enum "up" { + value 0; + description + "Up state."; + } + enum "down" { + value 1; + description + "Down state"; + } + } + description + "This type defines the state of an interface"; + } + + typedef adj-state-type { + type enumeration { + enum "up" { + value 0; + description + "State indicates the adjacency is established."; + } + enum "down" { + value 1; + description + "State indicates the adjacency is NOT established."; + } + enum "init" { + value 2; + description + "State indicates the adjacency is establishing."; + } + enum "failed" { + value 3; + description + "State indicates the adjacency is failed."; + } + } + description + "This type defines states of an adjacency"; + } + + typedef metric-style-type { + type enumeration { + enum "narrow" { + value 0; + description + "This enum describes narrow metric style"; + reference + "RFC1195"; + } + enum "wide" { + value 1; + description + "This enum describes wide metric style"; + reference + "RFC5305"; + } + enum "transition" { + value 2; + description + "This enum describes transition metric style"; + } + } + } + + typedef access-list-ref { + type string; + } + + typedef prefix-list-ref { + type string; + } + + grouping redistribute-attributes { + description + "Common optional attributes of any redistribute entry."; + leaf route-map { + type frr-route-map:route-map-ref; + description + "Applies the conditions of the specified route-map to routes that + are redistributed into this routing instance."; + } + + leaf metric { + type uint32 { + range "0..16777215"; + } + default "0"; + description + "Metric used for the redistributed route. If 0, + the default-metric attribute is used instead."; + } + } + + grouping redistribute-default { + description + "Redistribution of default route within a level."; + leaf always { + type boolean; + default "false"; + description + "Always advertise default route."; + } + + uses redistribute-attributes; + } + + grouping isis-password { + description + "Authentication attributes or an IS-IS area or domain."; + leaf password { + type string { + length "1..254"; + } + mandatory true; + description + "Actual password."; + } + + leaf password-type { + type enumeration { + enum "clear" { + value 1; + description + "Clear-text password type."; + } + enum "md5" { + value 54; + description + "MD5 password type."; + } + } + mandatory true; + description + "Type of password used."; + } + } + + grouping isis-area-password { + uses isis-password; + + leaf authenticate-snp { + type enumeration { + enum "none" { + value 0; + description + "No SNP authentication."; + } + enum "send-only" { + value 1; + description + "Send authenticated PDUs but do not check on receiving."; + } + enum "validate" { + value 3; + description + "Send authenticated PDUs and check on receiving."; + } + } + default "none"; + description + "SNP PDUs authentication."; + } + } + + grouping global-config-lfa { + container lfa { + description + "LFA configuration."; + + leaf load-sharing { + type boolean; + default "true"; + description + "Load share prefixes across multiple backups."; + } + leaf priority-limit { + type enumeration { + enum "critical" { + value 0; + description + "Compute for critical priority prefixes only."; + } + enum "high" { + value 1; + description + "Compute for critical & high priority prefixes."; + } + enum "medium" { + value 2; + description + "Compute for critical, high & medium priority prefixes."; + } + } + description + "Limit backup computation up to the prefix priority."; + } + list tiebreaker { + key "index"; + unique "type"; + description + "Configure tiebreaker for multiple backups."; + leaf index { + type uint8 { + range "1..255"; + } + description + "Preference order among tiebreakers."; + } + leaf type { + type enumeration { + enum "downstream" { + value 0; + description + "Prefer backup path via downstream node."; + } + enum "lowest-backup-metric" { + value 1; + description + "Prefer backup path with lowest total metric."; + } + enum "node-protecting" { + value 2; + description + "Prefer node protecting backup path."; + } + } + mandatory true; + description + "Tiebreaker type."; + } + } + } + } + + grouping global-config-remote-lfa { + container remote-lfa { + description + "Remote LFA configuration."; + + leaf prefix-list { + type prefix-list-ref; + description + "Filter PQ node router ID based on prefix list."; + } + } + } + + grouping interface-config-lfa { + container lfa { + description + "LFA configuration."; + leaf enable { + type boolean; + default false; + description + "Enables LFA computation."; + } + leaf-list exclude-interface { + type frr-interface:interface-ref; + description + "Exclude an interface from computation."; + } + } + } + + grouping interface-config-remote-lfa { + container remote-lfa { + description + "Remote LFA configuration."; + + leaf enable { + type boolean; + default false; + description + "Enables remote LFA computation using LDP tunnels."; + must ". = 'false' or ../../lfa/enable = 'true'" { + error-message + "Remote LFA depends on classic LFA being configured in the interface."; + } + + } + leaf maximum-metric { + type uint32 { + range "1..16777215"; + } + description + "Limit remote LFA node selection within the metric."; + } + } + } + + grouping interface-config-ti-lfa { + container ti-lfa { + description + "TI-LFA configuration."; + leaf enable { + must ". = 'false' or ../../lfa/enable = 'false'" { + error-message + "Can't enable both classic LFA and TI-LFA in the same interface."; + } + type boolean; + default false; + description + "Enables TI-LFA computation."; + } + leaf node-protection { + type boolean; + must ". = 'false' or ../enable = 'true'"; + default false; + description + "Node protection is provided by the alternate."; + } + leaf link-fallback { + type boolean; + must ". = 'false' or ../enable = 'true'"; + default false; + description + "Fallback to link protection."; + } + } + } + + grouping interface-config { + description + "Interface configuration grouping"; + leaf area-tag { + type string; + mandatory true; + description + "Area-tag associated to this circuit."; + } + + leaf ipv4-routing { + type boolean; + default "false"; + description + "Routing IS-IS IPv4 traffic over this circuit."; + } + + leaf ipv6-routing { + type boolean; + default "false"; + description + "Routing IS-IS IPv6 traffic over this circuit."; + } + + leaf circuit-type { + type level; + default "level-1-2"; + description + "IS-type of this circuit."; + } + + container bfd-monitoring { + leaf enabled { + type boolean; + default "false"; + description + "Monitor IS-IS peers on this circuit."; + } + leaf profile { + type string; + description + "Let BFD use a pre-configured profile."; + } + } + + container csnp-interval { + description + "Complete Sequence Number PDU (CSNP) generation interval."; + leaf level-1 { + type uint16 { + range "1..600"; + } + units "seconds"; + default "10"; + description + "CNSP interval for level-1"; + } + + leaf level-2 { + type uint16 { + range "1..600"; + } + units "seconds"; + default "10"; + description + "CNSP interval for level-2"; + } + } + + container psnp-interval { + description + "Partial Sequence Number PDU (PSNP) generation interval."; + leaf level-1 { + type uint16 { + range "1..120"; + } + units "seconds"; + default "2"; + description + "PNSP interval for level-1"; + } + + leaf level-2 { + type uint16 { + range "1..120"; + } + units "seconds"; + default "2"; + description + "PCNSP interval for level-2"; + } + } + + container hello { + description + "Parameters related to IS-IS hello PDUs."; + leaf padding { + type hello-padding-type; + default "always"; + description + "Type of padding for IS-IS hello packets."; + } + + container interval { + description + "Interval between consecutive hello messages."; + leaf level-1 { + type uint32 { + range "1..600"; + } + units "seconds"; + default "3"; + description + "Holding time for level-1; interval will depend on multiplier."; + } + + leaf level-2 { + type uint32 { + range "1..600"; + } + units "seconds"; + default "3"; + description + "Holding time for level-2; interval will depend on multiplier."; + } + } + + container multiplier { + description + "Multiplier for the hello messages holding time."; + leaf level-1 { + type uint16 { + range "2..100"; + } + default "10"; + description + "Multiplier for the hello holding time."; + } + + leaf level-2 { + type uint16 { + range "2..100"; + } + default "10"; + description + "Multiplier for the hello holding time."; + } + } + } + + container metric { + description + "Default metric for this IS-IS circuit."; + leaf level-1 { + type uint32 { + range "0..16777215"; + } + must ". < 64 or /frr-isisd:isis/instance[area-tag = current()/../../area-tag]/metric-style = 'wide'"; + default "10"; + description + "Default level-1 metric for this IS-IS circuit."; + } + + leaf level-2 { + type uint32 { + range "0..16777215"; + } + must ". < 64 or /frr-isisd:isis/instance[area-tag = current()/../../area-tag]/metric-style = 'wide'"; + default "10"; + description + "Default level-2 metric for this IS-IS circuit."; + } + } + + container priority { + description + "Priority for Designated Router election."; + leaf level-1 { + type uint8 { + range "0..127"; + } + default "64"; + description + "Level-1 priority for this IS-IS circuit."; + } + + leaf level-2 { + type uint8 { + range "0..127"; + } + default "64"; + description + "Level-2 priority for this IS-IS circuit."; + } + } + + leaf network-type { + type network-type; + must "(. = \"point-to-point\") or (. = \"broadcast\")"; + default "broadcast"; + description + "Explicitly configured type of IS-IS circuit (broadcast or point-to-point)."; + } + + leaf passive { + type boolean; + default "false"; + description + "Interface is in passive mode."; + } + + container password { + presence "Present if a password is set for this IS interface."; + uses isis-password; + } + + leaf disable-three-way-handshake { + type boolean; + default "false"; + description + "Disables three-way handshake when creating new adjacencies."; + } + + container multi-topology { + description + "IS-IS topologies configured on this circuit."; + leaf standard { + type boolean; + default "true"; + description + "Standard (IPV4 unicast) topology."; + } + + leaf ipv4-multicast { + type boolean; + default "true"; + description + "IPv4 multicast topology."; + } + + leaf ipv4-management { + type boolean; + default "true"; + description + "IPv4 management topology."; + } + + leaf ipv6-unicast { + type boolean; + default "true"; + description + "IPv6 unicast topology."; + } + + leaf ipv6-multicast { + type boolean; + default "true"; + description + "IPv6 multicast topology."; + } + + leaf ipv6-management { + type boolean; + default "true"; + description + "IPv6 management topology."; + } + + leaf ipv6-dstsrc { + type boolean; + default "true"; + description + "IPv6 destination-source topology."; + } + } + + container mpls { + description + "Configuration of MPLS parameters"; + leaf ldp-sync { + type boolean; + default "true"; + description + "Enable MPLS LDP-Sync functionality on this circuit."; + } + leaf holddown { + type uint16 { + range "0..10000"; + } + units "seconds"; + description + "Time to wait for LDP-Sync to occur before restoring interface metric."; + } + } + + container fast-reroute { + description + "Interface IP Fast-reroute configuration."; + container level-1 { + description + "Level-1 IP Fast-reroute configuration."; + uses interface-config-lfa; + uses interface-config-remote-lfa; + uses interface-config-ti-lfa; + } + container level-2 { + description + "Level-2 IP Fast-reroute configuration."; + uses interface-config-lfa; + uses interface-config-remote-lfa; + uses interface-config-ti-lfa; + } + } + } + + grouping adjacency-state { + description + "Adjacency state"; + container adjacencies { + config false; + description + "This container lists the adjacencies of + the local node."; + list adjacency { + description + "List of operational adjacencies."; + leaf neighbor-sys-type { + type level; + description + "Level capability of 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 + "Circuit ID of the neighbor"; + } + + leaf neighbor-snpa { + type snpa; + description + "SNPA of the neighbor"; + } + + leaf hold-timer { + type uint16; + 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 DIS."; + } + + leaf state { + type adj-state-type; + description + "This leaf describes the state of the interface."; + } + + uses adjacency-sids; + uses lan-adjacency-sids; + } + } + } + + grouping event-counters { + description + "Grouping for IS-IS interface event counters"; + container event-counters { + config false; + description + "IS-IS interface event counters."; + 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 PPP 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."; + } + } + } + + grouping interface-state { + description + "IS-IS interface operational state."; + uses adjacency-state; + + uses event-counters; + } + + grouping notification-instance-hdr { + description + "Instance specific IS-IS notification data grouping"; + leaf routing-instance { + type string; + description + "Name of the routing-instance instance."; + } + + leaf routing-protocol-name { + type string; + 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 frr-interface: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 + "Eextended circuit-id of the interface."; + } + } + + grouping adjacency-sids { + description + "IS-IS segment routing adjacency SID grouping."; + container adjacency-sids { + description + "This container lists the information of adjacency SID."; + list adjacency-sid { + leaf af { + type uint8; + description + "This leaf describes the protocol-family associated with the + adjacency SID."; + } + + leaf value { + type uint32; + description + "This leaf describes the value of adjacency SID."; + } + + leaf weight { + type uint8; + description + "This leaf describes the weight of the adjacency SID."; + } + + leaf protection-requested { + type boolean; + description + "This leaf describes if the adjacency SID must be protected."; + } + } + } + } + + grouping lan-adjacency-sids { + description + "IS-IS segment routing LAN adjacency SID grouping."; + container lan-adjacency-sids { + description + "This container lists the information of LAN adjacency SID."; + list lan-adjacency-sid { + leaf af { + type uint8; + description + "This leaf describes the protocol-family associated with the + LAN adjacency SID."; + } + + leaf value { + type uint32; + description + "This leaf describes the value of LAN adjacency SID."; + } + + leaf weight { + type uint8; + description + "This leaf describes the weight of the LAN adjacency SID."; + } + + leaf protection-requested { + type boolean; + description + "This leaf describes if the LAN adjacency SID must be protected."; + } + } + } + } + + container isis { + description + "Configuration of the IS-IS routing daemon."; + list instance { + key "area-tag vrf"; + description + "IS-IS routing instance."; + leaf area-tag { + type string; + description + "Area-tag associated to this routing instance."; + } + + leaf vrf { + type frr-vrf:vrf-ref; + description + "VRF NAME."; + } + + leaf is-type { + type level; + default "level-1-2"; + description + "Level of the IS-IS routing instance (OSI only)."; + } + + leaf-list area-address { + type net-address; + max-elements 3; + description + "List of OSI NET addresses for this protocol instance."; + } + + leaf dynamic-hostname { + type boolean; + default "true"; + description + "Dynamic hostname support for IS-IS."; + } + + leaf attach-send { + type boolean; + default "true"; + description + "If true, attached bits are sent in LSP if L1/L2 router for inter-area traffic."; + } + + leaf attach-receive-ignore { + type boolean; + default "false"; + description + "If false, attached bits received in LSP, cause default route add, if L1 router for inter-area traffic."; + } + + leaf attached { + type boolean; + default "false"; + status deprecated; + description + "If true, identify as L1/L2 router for inter-area traffic."; + } + + container overload { + description + "Overload bit configuration."; + leaf enabled { + type boolean; + default "false"; + description + "If true, avoid any transit traffic."; + } + + leaf on-startup { + type uint32 { + range "0..86400"; + } + units "seconds"; + default "0"; + description + "The duration the overload bit should be set on startup."; + } + } + + leaf metric-style { + type metric-style-type; + must ". = 'wide' or count(../multi-topology/*) = 0"; + default "wide"; + description + "Define the style of TLVs metric supported."; + } + + leaf advertise-high-metrics { + type boolean; + default "false"; + description + "Advertise high metric value on all interfaces."; + } + + leaf purge-originator { + type boolean; + default "false"; + description + "Use the RFC 6232 purge-originator."; + reference + "RFC6232"; + } + + leaf advertise-passive-only { + type boolean; + default "false"; + description + "Advertise prefixes of passive interfaces only"; + } + + leaf admin-group-send-zero { + type boolean; + default "false"; + description + "Allow sending the default admin-group value of 0x00000000"; + } + + leaf asla-legacy-flag { + type boolean; + default "false"; + description + "Set the legacy flag (aka. L-FLAG) in the ASLA Sub-TLV."; + } + + container lsp { + description + "Configuration of Link-State Packets (LSP) parameters"; + leaf mtu { + type uint16 { + range "128..4352"; + } + default "1497"; + description + "MTU of an LSP."; + } + + container timers { + description + "LSP-related timers"; + container level-1 { + description + "Level-1 LSP-related timers"; + leaf refresh-interval { + type uint16; + units "seconds"; + default "900"; + description + "LSP refresh interval for level-1."; + } + + leaf maximum-lifetime { + type uint16 { + range "350..65535"; + } + units "seconds"; + must ". >= ../refresh-interval + 300"; + default "1200"; + description + "Maximum LSP lifetime for level-1."; + } + + leaf generation-interval { + type uint16 { + range "1..120"; + } + units "seconds"; + must ". < ../refresh-interval"; + default "30"; + description + "Minimum time allowed before level-1 LSP retransmissions."; + } + } + + container level-2 { + description + "Level-2 LSP-related timers"; + leaf refresh-interval { + type uint16; + units "seconds"; + default "900"; + description + "LSP refresh interval for level-2."; + } + + leaf maximum-lifetime { + type uint16 { + range "350..65535"; + } + units "seconds"; + must ". >= ../refresh-interval + 300"; + default "1200"; + description + "Maximum LSP lifetime for level-2."; + } + + leaf generation-interval { + type uint16 { + range "1..120"; + } + units "seconds"; + must ". < ../refresh-interval"; + default "30"; + description + "Minimum time allowed before level-2 LSP retransmissions."; + } + } + } + } + + container spf { + description + "Parameters related to the Shortest Path First algorithm."; + container ietf-backoff-delay { + presence "Present if IETF SPF back-off delay is enabled."; + description + "SPF back-off delay algorithm parameters (see RFC 8405)."; + leaf init-delay { + type uint16 { + range "0..60000"; + } + units "msec"; + mandatory true; + description + "Delay used while in QUIET state"; + } + + leaf short-delay { + type uint16 { + range "0..60000"; + } + units "msec"; + mandatory true; + description + "Delay used while in SHORT_WAIT state"; + } + + leaf long-delay { + type uint16 { + range "0..60000"; + } + units "msec"; + mandatory true; + description + "Delay used while in LONG_WAIT state"; + } + + leaf hold-down { + type uint16 { + range "0..60000"; + } + units "msec"; + mandatory true; + description + "Time with no received IGP events before considering IGP stable"; + } + + leaf time-to-learn { + type uint16 { + range "0..60000"; + } + units "msec"; + mandatory true; + description + "Maximum duration needed to learn all the events related to a + single failure"; + } + } + + container minimum-interval { + description + "Minimum interval between consecutive executions of the + SPF algorithm."; + leaf level-1 { + type uint16 { + range "1..120"; + } + units "seconds"; + default "1"; + description + "Minimum time between consecutive level-1 SPFs."; + } + + leaf level-2 { + type uint16 { + range "1..120"; + } + units "seconds"; + default "1"; + description + "Minimum time between consecutive level-2 SPFs."; + } + } + + container prefix-priorities { + description + "SPF Prefix Priority configuration"; + + container critical { + description + "Critical prefix priority"; + leaf access-list-name { + type access-list-ref; + description + "Access List to determine prefixes for + this priority"; + } + } + container high { + description + "High prefix priority"; + leaf access-list-name { + type access-list-ref; + description + "Access List to determine prefixes for + this priority"; + } + } + container medium { + description + "Medium prefix priority"; + leaf access-list-name { + type access-list-ref; + description + "Access List to determine prefixes for + this priority"; + } + } + } + } + + container area-password { + presence "Present if authentication is required for IS level-1."; + description + "Authentication password for an IS-IS area."; + uses isis-area-password; + } + + container domain-password { + presence "Present if authentication is required for IS level-2."; + description + "Authentication password for an IS-IS domain."; + uses isis-area-password; + } + + container default-information-originate { + description + "Distribution of default information."; + list ipv4 { + key "level"; + description + "Distribute default route for IPv4."; + leaf level { + type level; + must "(. != \"level-1-2\") and ((../../../is-type = \"level-1-2\") or (. = ../../../is-type))"; + } + + uses redistribute-default; + } + + list ipv6 { + key "level"; + description + "Distribute default route for IPv6."; + leaf level { + type level; + must "(. != \"level-1-2\") and ((../../../is-type = \"level-1-2\") or (. = ../../../is-type))"; + } + + uses redistribute-default; + } + } + + container redistribute { + description + "Redistributes routes learned from other routing protocols."; + list ipv4 { + key "protocol level"; + description + "IPv4 route redistribution."; + leaf protocol { + type frr-route-types:frr-route-types-v4; + must ". != \"isis\""; + description + "Originating routing protocol for the IPv4 routes."; + } + + leaf level { + type level; + must "(. != \"level-1-2\") and ((../../../is-type = \"level-1-2\") or (. = ../../../is-type))"; + description + "IS-IS level into which the routes should be redistributed."; + } + + choice protocol-type { + case protocol-table { + when "./protocol = \"table\""; + list table { + key "table"; + when "../protocol = \"table\""; + description + "Routing table number"; + + leaf table { + type uint16 { + range "1..65535"; + } + description + "Routing table number."; + } + + uses redistribute-attributes; + } + } + case protocol-other { + uses redistribute-attributes; + } + } + + } + list ipv6 { + key "protocol level"; + description + "IPv6 route redistribution."; + leaf protocol { + type frr-route-types:frr-route-types-v6; + must ". != \"isis\""; + description + "Originating routing protocol for the IPv6 routes."; + } + + leaf level { + type level; + must "(. != \"level-1-2\") and ((../../../is-type = \"level-1-2\") or (. = ../../../is-type))"; + description + "IS-IS level into which the routes should be redistributed."; + } + + choice protocol-type { + case protocol-table { + when "./protocol = \"table\""; + list table { + key "table"; + when "../protocol = \"table\""; + + leaf table { + type uint16 { + range "1..65535"; + } + description + "Routing table number."; + } + + uses redistribute-attributes; + } + } + case protocol-other { + uses redistribute-attributes; + } + } + + } + } + + container multi-topology { + description + "IS-IS topologies configured for this area."; + container ipv4-multicast { + presence "Present if a separate IPv4-multicast topology is configured for this area."; + description + "IPv4 multicast topology."; + leaf overload { + type boolean; + default "false"; + } + } + + container ipv4-management { + presence "Present if a separate IPv4-management topology is configured for this area."; + description + "IPv4 management topology."; + leaf overload { + type boolean; + default "false"; + } + } + + container ipv6-unicast { + presence "Present if a separate IPv6-unicast topology is configured for this area."; + description + "IPv6 unicast topology."; + leaf overload { + type boolean; + default "false"; + } + } + + container ipv6-multicast { + presence "Present if a separate IPv6-multicast topology is configured for this area."; + description + "IPv6 multicast topology."; + leaf overload { + type boolean; + default "false"; + } + } + + container ipv6-management { + presence "Present if a separate IPv6-management topology is configured for this area."; + description + "IPv6 management topology."; + leaf overload { + type boolean; + default "false"; + } + } + + container ipv6-dstsrc { + presence "Present if a separate IPv6 destination-source topology is configured for this area."; + description + "IPv6 destination-source topology."; + leaf overload { + type boolean; + default "false"; + } + } + } + + container fast-reroute { + description + "IP Fast-reroute configuration."; + container level-1 { + description + "Level-1 IP Fast-reroute configuration."; + uses global-config-lfa; + uses global-config-remote-lfa; + } + container level-2 { + description + "Level-2 IP Fast-reroute configuration."; + uses global-config-lfa; + uses global-config-remote-lfa; + } + } + + leaf log-adjacency-changes { + type boolean; + default "false"; + description + "Log changes to the IS-IS adjacencies in this area."; + } + + leaf log-pdu-drops { + type boolean; + default "false"; + description + "Log any dropped PDUs in this area."; + } + + container mpls-te { + presence "Present if MPLS-TE is enabled."; + description + "Enable MPLS-TE functionality."; + leaf router-address { + type inet:ipv4-address; + description + "Stable IP address of the advertising router."; + } + leaf router-address-v6 { + type inet:ipv6-address; + description + "Stable IPv6 address of the advertising router."; + } + leaf export { + type boolean; + default "false"; + description + "Export Link State informatin."; + } + } + + container flex-algos { + description + "Flex-Algo Table"; + list flex-algo { + key "flex-algo"; + description + "Configuration for an IS-IS Flex-Algo"; + leaf advertise-definition { + type boolean; + description + "If TRUE, Flex-Algo definition is advertised"; + } + container affinity-include-alls { + description + "Set the include-all affinity"; + leaf-list affinity-include-all { + type string; + max-elements "256"; + description + "Array of Attribute Names"; + } + } + container affinity-include-anies { + description + "Set the include-any affinity"; + leaf-list affinity-include-any { + type string; + max-elements "256"; + description + "Array of Attribute Names"; + } + } + container affinity-exclude-anies { + description + "Set the exclude-any affinity"; + leaf-list affinity-exclude-any { + type string; + max-elements "256"; + description + "Array of Attribute Names"; + } + } + leaf prefix-metric { + type empty; + description + "Use Flex-algo Prefix Metric"; + } + leaf metric-type { + default "igp"; + description + "Set the Flex-Algo metric-type"; + type enumeration { + enum "igp" { + value 0; + description + "IGP Metric"; + } + enum "min-uni-link-delay" { + value 1; + description + "RFC 8570 Sec 4.2 Min Unidirectional Link Delay"; + } + enum "te-default" { + value 2; + description + "RFC 5305 Sec 3.7 Traffic Engineering Default Metric"; + } + } + } + leaf priority { + type uint32 { + range "0..255"; + } + description + "Set the Flex-Algo priority"; + } + leaf dplane-sr-mpls { + type empty; + description + "Advertise and participate in the Flex-Algo Segment-Routing MPLS data-plane"; + } + leaf dplane-srv6 { + type empty; + description + "Advertise and participate in the Flex-Algo Segment-Routing SRv6 data-plane"; + } + leaf dplane-ip { + type empty; + description + "Advertise and participate in the Flex-Algo IP data-plane"; + } + leaf flex-algo { + type uint32 { + range "128..255"; + } + description + "Flex-Algo"; + } + } + } + + container segment-routing { + description + "Segment Routing global configuration."; + leaf enabled { + type boolean; + default "false"; + description + "Enables segment-routing protocol extensions."; + } + container label-blocks { + description + "Local and global label blocks."; + container srgb { + description + "Global blocks to be advertised."; + leaf lower-bound { + must "../upper-bound > ."; + type uint32; + default "16000"; + description + "Lower value in the label range."; + } + leaf upper-bound { + must ". > ../lower-bound"; + type uint32; + default "23999"; + description + "Upper value in the label range."; + } + } + container srlb { + description + "Local blocks to be advertised."; + leaf lower-bound { + must "../upper-bound > ."; + type uint32; + default "15000"; + description + "Lower value in the label range."; + } + leaf upper-bound { + must ". > ../lower-bound"; + type uint32; + default "15999"; + description + "Upper value in the label range."; + } + } + } + container msd { + description + "MSD configuration."; + leaf node-msd { + type uint8; + description + "Node MSD is the lowest MSD supported by the node."; + } + } + container prefix-sid-map { + description + "Prefix SID configuration."; + list prefix-sid { + key "prefix"; + unique "sid-value-type sid-value"; + description + "List of prefix SID mapped to IPv4/IPv6 + local prefixes."; + leaf prefix { + type inet:ip-prefix; + description + "Connected prefix sid."; + } + leaf sid-value-type { + type enumeration { + enum "index" { + value 0; + description + "The value will be interpreted as an index."; + } + enum "absolute" { + value 1; + description + "The value will become interpreted as an absolute + value."; + } + } + default "index"; + description + "This leaf defines how value must be interpreted."; + } + leaf sid-value { + type uint32; + mandatory true; + description + "Value associated with prefix. The value must be + interpreted in the context of sid-value-type."; + } + leaf last-hop-behavior { + type enumeration { + enum "explicit-null" { + value 0; + description + "Use explicit-null for the SID."; + } + enum "no-php" { + value 1; + description + "Do not use Penultimate Hop Popping (PHP) + for the SID."; + } + enum "php" { + value 2; + description + "Use PHP for the SID."; + } + } + default "php"; + description + "Configure last hop behavior."; + } + leaf n-flag-clear { + type boolean; + default "false"; + description + "Not a node SID"; + } + } + } + container algorithm-prefix-sids { + description + "Algorithm SID Table"; + list algorithm-prefix-sid { + key "prefix algo"; + description + "Assign prefix SID for algorithm to an + interface, ISISPHPFlag will be rejected + if set to disable, ISISEXPLICITNULLFlag + will override the value of ISISPHPFlag"; + leaf algo { + type uint32 { + range "128..255"; + } + description + "Algorithm"; + } + leaf prefix { + type inet:ip-prefix; + mandatory true; + description + "Connected prefix sid."; + } + leaf sid-value-type { + type enumeration { + enum "index" { + value 0; + description + "The value will be interpreted as an index."; + } + enum "absolute" { + value 1; + description + "The value will become interpreted as an absolute + value."; + } + } + default "index"; + description + "This leaf defines how value must be interpreted."; + } + leaf sid-value { + type uint32 { + range "0..1048575"; + } + mandatory true; + description + "Value associated with prefix. The value must be + interpreted in the context of sid-value-type."; + } + leaf last-hop-behavior { + type enumeration { + enum "explicit-null" { + value 0; + description + "Use explicit-null for the SID."; + } + enum "no-php" { + value 1; + description + "Do not use Penultimate Hop Popping (PHP) + for the SID."; + } + enum "php" { + value 2; + description + "Use PHP for the SID."; + } + } + default "php"; + description + "Configure last hop behavior."; + } + leaf n-flag-clear { + type boolean; + default "false"; + description + "Not a node SID"; + } + } + } + } + + container segment-routing-srv6 { + description + "Segment Routing over IPv6 (SRv6) global configuration."; + leaf enabled { + type boolean; + default "false"; + description + "Enable IS-IS extensions to support Segment Routing over + IPv6 data plane (SRv6)."; + reference + "RFC 9352"; + } + leaf locator { + type string; + description + "SRv6 locator."; + } + container msd { + description + "SRv6 Maximum SRv6 SID Depths."; + container node-msd { + description + "SRv6 Node Maximum SRv6 SID Depths."; + leaf max-segs-left { + type uint8 { + range "0..255"; + } + default 3; + description + "Maximum Segments Left MSD."; + } + leaf max-end-pop { + type uint8 { + range "0..255"; + } + default 3; + description + "Maximum End Pop MSD."; + } + leaf max-h-encaps { + type uint8 { + range "0..255"; + } + default 2; + description + "Maximum H.Encaps MSD."; + } + leaf max-end-d { + type uint8 { + range "0..255"; + } + default 5; + description + "Maximum End D MSD."; + } + } + } + leaf interface { + type string; + description + "Dummy interface used to install SRv6 SIDs into the Linux data plane."; + default "sr0"; + } + } + + container mpls { + description + "Configuration of MPLS parameters"; + container ldp-sync { + presence "Present if MPLS LDP-Sync is enabled."; + description + "Enable MPLS LDP-Sync functionality."; + leaf holddown { + type uint16 { + range "0..10000"; + } + units "seconds"; + default "0"; + description + "Time to wait for LDP-Sync to occur before restoring interface metric."; + } + } + } + + } + } + + augment "/frr-interface:lib/frr-interface:interface" { + description + "Extends interface model with IS-IS related parameters."; + container isis { + presence "Present if an IS-IS circuit is defined for this interface."; + description + "IS-IS interface parameters."; + uses interface-config; + } + } + + augment "/frr-interface:lib/frr-interface:interface/frr-interface:state" { + description + "Extends interface model with IS-IS operational data."; + container isis { + presence "Present if an IS-IS circuit is defined for this interface."; + description + "IS-IS interface operational data."; + + uses interface-state; + } + } + + notification database-overload { + description + "This notification is sent when an IS-IS instance + overload state changes."; + uses notification-instance-hdr; + + leaf overload { + type enumeration { + enum "off" { + value 0; + description + "Indicates IS-IS instance has left overload state"; + } + enum "on" { + value 1; + description + "Indicates IS-IS instance has entered overload state"; + } + } + description + "New overload state of the IS-IS instance"; + } + } + + notification lsp-too-large { + description + "This notification is sent when we attempt to propagate + an LSP that is larger than the dataLinkBlockSize for the + circuit. The notification generation must be throttled + with at least 5 seconds between successive + notifications."; + 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"; + } + } + + notification if-state-change { + description + "This notification is sent when an interface + state change is detected."; + uses notification-instance-hdr; + + uses notification-interface-hdr; + + leaf state { + type if-state-type; + description + "Interface state."; + } + } + + notification corrupted-lsp-detected { + description + "This notification is sent when we find that + an LSP that was stored in memory has become + corrupted."; + uses notification-instance-hdr; + + leaf lsp-id { + type lsp-id; + description + "LSP ID"; + } + } + + notification attempt-to-exceed-max-sequence { + description + "This notification is sent when the system + wraps the 32-bit sequence counter of an LSP."; + uses notification-instance-hdr; + + leaf lsp-id { + type lsp-id; + description + "LSP ID"; + } + } + + notification id-len-mismatch { + description + "This notification is sent when we receive a PDU + with a different value for the System ID length. + The notification generation must be throttled + with at least 5 seconds between successive + notifications."; + uses notification-instance-hdr; + + uses notification-interface-hdr; + + leaf pdu-field-len { + type uint8; + description + "Size of the ID length in the received PDU"; + } + + leaf raw-pdu { + type binary; + description + "Received raw PDU."; + } + } + + notification max-area-addresses-mismatch { + description + "This notification is sent when we receive a PDU + with a different value for the Maximum Area Addresses. + The notification generation must be throttled + with at least 5 seconds between successive + notifications."; + 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."; + } + } + + notification own-lsp-purge { + description + "This notification is sent when the system receives + a PDU with its own system ID and zero age."; + uses notification-instance-hdr; + + uses notification-interface-hdr; + + leaf lsp-id { + type lsp-id; + description + "LSP ID"; + } + } + + notification sequence-number-skipped { + description + "This notification is sent when the system receives a + PDU with its own system ID and different contents. The + system has to reoriginate the LSP with a higher sequence + number."; + uses notification-instance-hdr; + + uses notification-interface-hdr; + + leaf lsp-id { + type lsp-id; + description + "LSP ID"; + } + } + + notification authentication-type-failure { + description + "This notification is sent when the system receives a + PDU with the wrong authentication type field. + The notification generation must be throttled + with at least 5 seconds between successive + notifications."; + uses notification-instance-hdr; + + uses notification-interface-hdr; + + leaf raw-pdu { + type binary; + description + "Received raw PDU."; + } + } + + notification authentication-failure { + description + "This notification is sent when the system receives + a PDU with the wrong authentication information. + The notification generation must be throttled with + with at least 5 seconds between successive + notifications."; + uses notification-instance-hdr; + + uses notification-interface-hdr; + + leaf raw-pdu { + type binary; + description + "Received raw PDU."; + } + } + + notification version-skew { + description + "This notification is sent when the system receives a + PDU with a different protocol version number. + The notification generation must be throttled + with at least 5 seconds between successive + notifications."; + 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."; + } + } + + notification area-mismatch { + description + "This notification is sent when the system receives a + Hello PDU from an IS that does not share any area + address. The notification generation must be throttled + with at least 5 seconds between successive + notifications."; + uses notification-instance-hdr; + + uses notification-interface-hdr; + + leaf raw-pdu { + type binary; + description + "Received raw PDU."; + } + } + + notification rejected-adjacency { + 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 notification generation must be + throttled with at least 5 seconds between successive + notifications."; + uses notification-instance-hdr; + + uses notification-interface-hdr; + + leaf raw-pdu { + type binary; + description + "Received raw PDU."; + } + + leaf reason { + type string; + description + "The system may provide a reason to reject the + adjacency. If the reason is not available, + an empty string will be returned."; + } + } + + notification lsp-error-detected { + description + "This notification is sent when the system receives an + LSP with a parse error. The notification generation must + be throttled with at least 5 seconds between successive + notifications."; + 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."; + } + } + + notification adjacency-state-change { + description + "This notification is sent when an IS-IS adjacency + moves to Up state or to Down state."; + uses notification-instance-hdr; + + uses notification-interface-hdr; + + leaf neighbor { + type string; + description + "Name of the neighbor. If the name of the neighbor is + not available, it is not returned."; + } + + 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; + description + "If the adjacency is going to DOWN, this leaf provides + a reason for the adjacency going down. The reason is + provided as a text. If the adjacency is going to UP, no + reason is provided."; + } + } + + notification lsp-received { + description + "This notification is sent when an LSP is received. + The notification generation must be throttled with at + least 5 seconds between successive notifications."; + 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 LSP sender"; + } + } + + notification lsp-generation { + description + "This notification is sent when an LSP is regenerated. + The notification generation must be throttled with at + least 5 seconds between successive notifications."; + 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 our LSP was regenerated."; + } + } +} |