mirror of https://github.com/FRRouting/frr.git
2065 lines
51 KiB
YANG
2065 lines
51 KiB
YANG
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 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 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 {
|
|
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.";
|
|
}
|
|
}
|
|
}
|
|
|
|
grouping interface-config {
|
|
description
|
|
"Interface configuration grouping";
|
|
leaf area-tag {
|
|
type string;
|
|
mandatory true;
|
|
description
|
|
"Area-tag associated to this circuit.";
|
|
}
|
|
|
|
leaf vrf {
|
|
type frr-vrf:vrf-ref;
|
|
default "default";
|
|
description
|
|
"VRF NAME.";
|
|
}
|
|
|
|
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 boolean;
|
|
default "true";
|
|
description
|
|
"Add padding to IS-IS hello PDUs.";
|
|
}
|
|
|
|
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 ipv4-unicast {
|
|
type boolean;
|
|
default "true";
|
|
description
|
|
"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.";
|
|
must "./lfa/enable = 'false' or ./ti-lfa/enable = 'false'" {
|
|
error-message
|
|
"Can't enable both classic LFA and TI-LFA in the same interface.";
|
|
}
|
|
uses interface-config-lfa;
|
|
uses interface-config-remote-lfa;
|
|
uses interface-config-ti-lfa;
|
|
}
|
|
container level-2 {
|
|
description
|
|
"Level-2 IP Fast-reroute configuration.";
|
|
must "./lfa/enable = 'false' or ./ti-lfa/enable = 'false'" {
|
|
error-message
|
|
"Can't enable both classic LFA and TI-LFA in the same interface.";
|
|
}
|
|
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.";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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.";
|
|
}
|
|
}
|
|
|
|
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.";
|
|
}
|
|
|
|
leaf overload {
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"If true, avoid any transit traffic.";
|
|
}
|
|
|
|
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 purge-originator {
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"Use the RFC 6232 purge-originator.";
|
|
reference
|
|
"RFC6232";
|
|
}
|
|
|
|
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.";
|
|
}
|
|
|
|
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.";
|
|
}
|
|
|
|
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.";
|
|
}
|
|
|
|
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.";
|
|
}
|
|
}
|
|
|
|
container segment-routing {
|
|
description
|
|
"Segment Routing global configuration.";
|
|
leaf enabled {
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"Enables segment-routing protocol extensions.";
|
|
}
|
|
container srgb {
|
|
description
|
|
"Global blocks to be advertised.";
|
|
must "./upper-bound > ./lower-bound";
|
|
leaf lower-bound {
|
|
type uint32;
|
|
default "16000";
|
|
description
|
|
"Lower value in the label range.";
|
|
}
|
|
leaf upper-bound {
|
|
type uint32;
|
|
default "23999";
|
|
description
|
|
"Upper value in the label range.";
|
|
}
|
|
}
|
|
container srlb {
|
|
description
|
|
"Local blocks to be advertised.";
|
|
must "./upper-bound > ./lower-bound";
|
|
leaf lower-bound {
|
|
type uint32;
|
|
default "15000";
|
|
description
|
|
"Lower value in the label range.";
|
|
}
|
|
leaf upper-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 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.";
|
|
}
|
|
}
|
|
}
|