Cisco-IOS-XR-igp-topodb-oper

This module contains a collection of YANG definitions for Cisco IOS-XR igp-topodb package operational data. This module contain...

  • Version: 2021-06-01

    Cisco-IOS-XR-igp-topodb-oper@2021-06-01


    
      module Cisco-IOS-XR-igp-topodb-oper {
    
        yang-version 1;
    
        namespace
          "http://cisco.com/ns/yang/Cisco-IOS-XR-igp-topodb-oper";
    
        prefix igp-topodb-oper;
    
        import Cisco-IOS-XR-types {
          prefix xr;
        }
        import cisco-semver {
          prefix semver;
        }
    
        include Cisco-IOS-XR-igp-topodb-oper-sub1 {
          revision-date "2021-06-01";
        }
    
        organization "Cisco Systems, Inc.";
    
        contact
          "Cisco Systems, Inc.
    Customer Service
    
    Postal: 170 West Tasman Drive
    San Jose, CA 95134
    
    Tel: +1 800 553-NETS
    
    E-mail: cs-yang@cisco.com";
    
        description
          "This module contains a collection of YANG definitions
    for Cisco IOS-XR igp-topodb package operational data.
    
    This module contains definitions
    for the following management objects:
      topo-db: Open Topology Database library operational data
    
    Copyright (c) 2013-2021 by Cisco Systems, Inc.
    All rights reserved.";
    
        revision "2021-06-01" {
          description
            "Added changes to show if a FAD contains unknown parameters
    2020-10-20
      Modified for Flex algo Uloop support.
    2020-08-13
      Added task name ospf to restrict unlimited permission.
    2020-03-20
      Modified for Flex algo TILFA support.";
        }
    
        revision "2020-01-02" {
          description
            "Added topodb operational data support.";
        }
    
        revision "2019-04-05" {
          description
            "Establish semantic version baseline.";
        }
    
        revision "2015-11-09" {
          description "IOS XR 6.0 revision.";
        }
    
        semver:module-version "2.0.0";
        semver:module-version "1.1.0";
        semver:module-version "1.0.1";
    
        container topo-db {
          config false;
          description
            "Open Topology Database library operational data";
          container topo-db-processes {
            description
              "Table for each process using topology library";
            list topo-db-process {
              key "process-name";
              description
                "Operational data for a particular process";
              container topology-prefixes {
                description
                  "Container for Topology prefix information";
                list topology-prefix {
                  key "topo-vrf-name";
                  description
                    "Topology prefix information";
                  leaf topo-vrf-name {
                    type xr:Cisco-ios-xr-string;
                    description "VRF Name";
                  }
    
                  leaf vrf-name {
                    type string;
                    description "VRF Name";
                  }
    
                  leaf router-id {
                    type inet:ipv4-address;
                    description "Router ID";
                  }
    
                  list area {
                    description "List of Areas";
                    leaf area-id-string {
                      type string {
                        length "0..16";
                      }
                      description
                        "Area ID string";
                    }
    
                    leaf num-nodes {
                      type uint16;
                      description
                        "No. of nodes under area";
                    }
    
                    list node {
                      description
                        "List of Nodes";
                      container node-id {
                        description "Node ID";
                        leaf adv-router-id {
                          type inet:ipv4-address;
                          description
                            "Advertising Router ID";
                        }
    
                        leaf dr-identifier {
                          type inet:ipv4-address;
                          description
                            "Node DR Identifier";
                        }
                      }  // container node-id
    
                      leaf num-links {
                        type uint16;
                        description
                          "Number of Links";
                      }
    
                      leaf num-prefixes {
                        type uint32;
                        description
                          "Number of prefixes";
                      }
    
                      leaf is-root-node {
                        type boolean;
                        description
                          "Is root node";
                      }
    
                      leaf is-area-border-router {
                        type boolean;
                        description
                          "Node is ABR";
                      }
    
                      leaf is-as-border-router {
                        type boolean;
                        description
                          "Node is ASBR";
                      }
    
                      leaf node-oper-flags {
                        type uint16;
                        description
                          "Node Operational flags";
                      }
    
                      leaf is-router-lsa-contrib {
                        type boolean;
                        description
                          "Is Router LSA Contributing";
                      }
    
                      leaf is-network-lsa-contrib {
                        type boolean;
                        description
                          "Is Network LSA Contributing";
                      }
    
                      leaf is-router-info-lsa-contrib {
                        type boolean;
                        description
                          "Is Router Info LSA Contributing";
                      }
    
                      leaf-list node-algo {
                        type uint8;
                        description
                          "Node algo support list";
                      }
    
                      list link {
                        description
                          "List of Links";
                        container link-id {
                          description "Link ID";
                          leaf link-id {
                            type inet:ipv4-address;
                            description
                              "Link ID";
                          }
    
                          leaf link-data {
                            type inet:ipv4-address;
                            description
                              "Link Data";
                          }
    
                          leaf link-type {
                            type uint8;
                            description
                              "Link Type";
                          }
                        }  // container link-id
    
                        container remote-link-id {
                          description
                            "Remote Link ID";
                          leaf link-id {
                            type inet:ipv4-address;
                            description
                              "Link ID";
                          }
    
                          leaf link-data {
                            type inet:ipv4-address;
                            description
                              "Link Data";
                          }
    
                          leaf link-type {
                            type uint8;
                            description
                              "Link Type";
                          }
                        }  // container remote-link-id
    
                        container link-attrs {
                          description
                            "Link Attributes";
                          container flex-algo-asla-attrs {
                            description
                              "Flex Algo ASLA Attributes";
                            leaf srte-metric {
                              type uint32;
                              description
                                "SR-TE Metric";
                            }
    
                            leaf min-delay {
                              type uint32;
                              description
                                "Min Delay";
                            }
    
                            leaf-list ext-admin-group {
                              type uint32;
                              units "bit";
                              description
                                "Ext. Admin Group bits";
                            }
    
                            leaf-list srlg {
                              type uint32;
                              description
                                "SRLG values";
                            }
                          }  // container flex-algo-asla-attrs
    
                          leaf lsid {
                            type inet:ipv4-address;
                            description
                              "Ext Link LSA ID";
                          }
    
                          leaf local-interface-id {
                            type uint32;
                            description
                              "Local Interface ID";
                          }
    
                          leaf remote-interface-id {
                            type uint32;
                            description
                              "Remote Interface ID";
                          }
    
                          leaf remote-ipv4-address {
                            type inet:ipv4-address;
                            description
                              "Remote IPv4 Address";
                          }
    
                          leaf max-bandwidth {
                            type uint32;
                            description
                              "Max Bandwidth";
                          }
                        }  // container link-attrs
    
                        leaf link-metric {
                          type uint16;
                          description
                            "Link Metric";
                        }
    
                        leaf link-subnet-mask {
                          type inet:ipv4-address;
                          description
                            "Link Subnet Mask";
                        }
    
                        leaf link-oper-flags {
                          type uint16;
                          description
                            "Link Operational flags";
                        }
    
                        leaf is-router-lsa-contrib {
                          type boolean;
                          description
                            "Is Router LSA Contributing";
                        }
    
                        leaf is-network-lsa-contrib {
                          type boolean;
                          description
                            "Is Network LSA Contributing";
                        }
    
                        leaf is-ext-link-lsa-contrib {
                          type boolean;
                          description
                            "Is Ext Link LSA Contributing";
                        }
                      }  // list link
    
                      list prefix {
                        description
                          "List of prefixes";
                        leaf prefix-address {
                          type inet:ipv4-address;
                          description
                            "Prefix Address";
                        }
    
                        leaf prefix-length {
                          type uint8;
                          description
                            "Prefix Length";
                        }
    
                        leaf prefix-metric {
                          type uint32;
                          description
                            "Prefix metric";
                        }
    
                        leaf route-type {
                          type uint32;
                          description
                            "Route Type";
                        }
    
                        list prefix-contributor {
                          description
                            "Prefix Contributors";
                          leaf algo {
                            type uint8;
                            description
                              "Algo number";
                          }
    
                          leaf sid {
                            type uint32;
                            description "SID";
                          }
    
                          leaf total-metric {
                            type uint64;
                            description
                              "Total metric";
                          }
    
                          leaf contrib-flags {
                            type uint8;
                            description
                              "Prefix contributor flags";
                          }
    
                          leaf sid-flags {
                            type uint8;
                            description
                              "SID flags";
                          }
                        }  // list prefix-contributor
                      }  // list prefix
    
                      list srgb {
                        description
                          "Node SRGB List";
                        leaf range-start {
                          type uint32;
                          description
                            "Range Start";
                        }
    
                        leaf range-size {
                          type uint32;
                          description
                            "Range Size";
                        }
                      }  // list srgb
    
                      list fad {
                        description
                          "Flex Algo Definition List";
                        leaf algo-number {
                          type uint8;
                          description
                            "Algo Number";
                        }
    
                        leaf metric-type {
                          type uint8;
                          description
                            "Metric Type";
                        }
    
                        leaf algo-type {
                          type uint8;
                          description
                            "Algo Type";
                        }
    
                        leaf priority {
                          type uint8;
                          description
                            "Algo Priority";
                        }
    
                        leaf fad-oper-flags {
                          type uint16;
                          description
                            "FAD Operational Flags";
                        }
    
                        leaf fad-has-unsupported-params {
                          type boolean;
                          description
                            "The FAD defintion contains TLVs or Flags that
    are not supported by this node";
                        }
    
                        leaf-list exclude-affinity {
                          type uint32;
                          description
                            "Exclude Affinity";
                        }
    
                        leaf-list include-any-affinity {
                          type uint32;
                          description
                            "Include Any Affinity";
                        }
    
                        leaf-list include-all-affinity {
                          type uint32;
                          description
                            "Include All Affinity";
                        }
                      }  // list fad
                    }  // list node
                  }  // list area
                }  // list topology-prefix
              }  // container topology-prefixes
    
              container topology-paths {
                description
                  "Container for Topology path information";
                list topology-path {
                  key "topo-vrf-name";
                  description
                    "Topology path information";
                  leaf topo-vrf-name {
                    type xr:Cisco-ios-xr-string;
                    description "VRF Name";
                  }
    
                  leaf vrf-name {
                    type string;
                    description "VRF Name";
                  }
    
                  leaf router-id {
                    type inet:ipv4-address;
                    description "Router ID";
                  }
    
                  list area {
                    description "List of Areas";
                    leaf area-id-string {
                      type string {
                        length "0..16";
                      }
                      description "Area ID";
                    }
    
                    list node {
                      description
                        "List of Nodes";
                      container node-id {
                        description "Node ID";
                        leaf adv-router-id {
                          type inet:ipv4-address;
                          description
                            "Advertising Router ID";
                        }
    
                        leaf dr-identifier {
                          type inet:ipv4-address;
                          description
                            "Node DR Identifier";
                        }
                      }  // container node-id
    
                      leaf is-root-node {
                        type boolean;
                        description
                          "Is root node";
                      }
    
                      leaf is-area-border-router {
                        type boolean;
                        description
                          "Node is ABR";
                      }
    
                      leaf is-as-border-router {
                        type boolean;
                        description
                          "Node is ASBR";
                      }
    
                      list algo {
                        description
                          "List of node Algos";
                        leaf algo-number {
                          type uint8;
                          description
                            "Algo Number";
                        }
    
                        leaf node-distance {
                          type uint64;
                          description
                            "Node Distance";
                        }
    
                        leaf is-node-reachable {
                          type boolean;
                          description
                            "Node reachable";
                        }
    
                        leaf is-direct-node {
                          type boolean;
                          description
                            "Direct Node";
                        }
    
                        leaf is-path-dirty {
                          type boolean;
                          description
                            "Node is dirty";
                        }
    
                        list path {
                          description
                            "Algo Path List";
                          leaf next-hop-address {
                            type inet:ipv4-address;
                            description
                              "NextHop IP Address";
                          }
    
                          leaf interface-handle {
                            type uint32;
                            description
                              "Interface Handle";
                          }
    
                          leaf neighbor-id {
                            type inet:ipv4-address;
                            description
                              "Neighbor ID";
                          }
    
                          leaf path-weight {
                            type uint32;
                            description
                              "Path Weight";
                          }
                        }  // list path
                      }  // list algo
                    }  // list node
                  }  // list area
                }  // list topology-path
              }  // container topology-paths
    
              container topology-routes {
                description
                  "Container for Topology route information";
                list topology-route {
                  key "topo-vrf-name";
                  description
                    "Topology Route Information";
                  leaf topo-vrf-name {
                    type xr:Cisco-ios-xr-string;
                    description "VRF Name";
                  }
    
                  leaf vrf-name {
                    type string;
                    description "VRF Name";
                  }
    
                  leaf router-id {
                    type inet:ipv4-address;
                    description "Router ID";
                  }
    
                  leaf num-routes {
                    type uint32;
                    description "No. of routes";
                  }
    
                  list route {
                    description "List of Routes";
                    leaf route-prefix {
                      type inet:ipv4-address;
                      description
                        "Route Prefix Address";
                    }
    
                    leaf route-prefix-length {
                      type uint8;
                      description
                        "Route Prefix Length";
                    }
    
                    leaf route-priority {
                      type uint8;
                      description
                        "Route priority";
                    }
    
                    leaf route-flags {
                      type uint16;
                      description "Route flags";
                    }
    
                    list algo {
                      description
                        "Route Algo list";
                      container route-update-time {
                        description
                          "Time at which this route was updated";
                        leaf second {
                          type uint32;
                          description "Second";
                        }
    
                        leaf nanosecond {
                          type uint32;
                          description
                            "Nanosecond";
                        }
                      }  // container route-update-time
    
                      leaf algo-number {
                        type uint8;
                        description
                          "Algo Number";
                      }
    
                      leaf route-metric {
                        type uint64;
                        description
                          "Route Metric";
                      }
    
                      leaf route-algo-flags {
                        type uint8;
                        description
                          "Route algo flags";
                      }
    
                      leaf route-type {
                        type uint8;
                        description "Route Type";
                      }
    
                      leaf route-sid {
                        type uint32;
                        description "Route SID";
                      }
    
                      leaf route-label {
                        type uint32;
                        description
                          "Route label";
                      }
    
                      leaf path-count {
                        type uint32;
                        description
                          "Route path count";
                      }
    
                      list path {
                        description
                          "Algo Path List";
                        container backup-path {
                          description
                            "Backup path details";
                          leaf interface-handle {
                            type uint32;
                            description
                              "Interface Handle";
                          }
    
                          leaf next-hop-address {
                            type inet:ipv4-address;
                            description
                              "NextHop IP Address";
                          }
    
                          leaf neighbor-id {
                            type inet:ipv4-address;
                            description
                              "Neighbor ID";
                          }
    
                          leaf backup-route-source {
                            type inet:ipv4-address;
                            description
                              "IP address of source of route";
                          }
    
                          leaf backup-metric {
                            type uint64;
                            description
                              "Backup Metric";
                          }
    
                          leaf primary-path {
                            type boolean;
                            description
                              "Whether this is also a Primary Path";
                          }
    
                          leaf interface-disjoint {
                            type boolean;
                            description
                              "Wheher this is a Interface Disjoint path";
                          }
    
                          leaf line-card-disjoint {
                            type boolean;
                            description
                              "Whether this is a Line Card Disjoint path";
                          }
    
                          leaf downstream {
                            type boolean;
                            description
                              "Whether this is a downstream path";
                          }
    
                          leaf node-protect {
                            type boolean;
                            description
                              "Whether this is a Node Protect path";
                          }
    
                          leaf srlg-disjoint {
                            type boolean;
                            description
                              "Whether this is a SRLG Disjoint path";
                          }
    
                          leaf weighted-srlg {
                            type boolean;
                            description
                              "Whether this is a Weighted SRLG path";
                          }
    
                          leaf lfa-type {
                            type Otlib-lfa;
                            description
                              "LFA type";
                          }
    
                          leaf backup-repair-list-size {
                            type uint32;
                            description
                              "Repair List Size";
                          }
    
                          leaf backup-tunnel-interface-name {
                            type uint32;
                            description
                              "Backup Tunnel Interface";
                          }
    
                          list backup-repair {
                            max-elements 12;
                            description
                              "Backup Repair List";
                            leaf repair-element-id {
                              type inet:ipv4-address;
                              description
                                "ID of the Repair Element";
                            }
    
                            leaf repair-label {
                              type uint32;
                              description
                                "Label of Repair Element";
                            }
    
                            leaf repair-element-type {
                              type Otlib-repair-el;
                              description
                                "Type of the Repair Element";
                            }
                          }  // list backup-repair
                        }  // container backup-path
    
                        container uloop-path {
                          description
                            "Microloop Avoidance Path";
                          leaf repair-list-size {
                            type uint32;
                            description
                              "Repair List Size";
                          }
    
                          leaf tunnel-interface-name {
                            type uint32;
                            description
                              "Microloop Avoidance Tunnel Interface";
                          }
    
                          list repair {
                            max-elements 12;
                            description
                              "Microloop Avoidance Repair List";
                            leaf repair-element-id {
                              type inet:ipv4-address;
                              description
                                "ID of the Repair Element";
                            }
    
                            leaf repair-label {
                              type uint32;
                              description
                                "Label of Repair Element";
                            }
    
                            leaf repair-element-type {
                              type Otlib-repair-el;
                              description
                                "Type of the Repair Element";
                            }
                          }  // list repair
                        }  // container uloop-path
    
                        leaf next-hop-address {
                          type inet:ipv4-address;
                          description
                            "NextHop IP Address";
                        }
    
                        leaf interface-handle {
                          type uint32;
                          description
                            "Interface Handle";
                        }
    
                        leaf neighbor-id {
                          type inet:ipv4-address;
                          description
                            "Neighbor ID";
                        }
    
                        leaf path-weight {
                          type uint32;
                          description
                            "Path Weight";
                        }
    
                        leaf path-label {
                          type uint32;
                          description
                            "Path Label";
                        }
                      }  // list path
    
                      list route-contributor {
                        description
                          "Route prefix contributors";
                        leaf algo {
                          type uint8;
                          description
                            "Algo number";
                        }
    
                        leaf sid {
                          type uint32;
                          description "SID";
                        }
    
                        leaf total-metric {
                          type uint64;
                          description
                            "Total metric";
                        }
    
                        leaf contrib-flags {
                          type uint8;
                          description
                            "Prefix contributor flags";
                        }
    
                        leaf sid-flags {
                          type uint8;
                          description
                            "SID flags";
                        }
                      }  // list route-contributor
                    }  // list algo
                  }  // list route
                }  // list topology-route
              }  // container topology-routes
    
              container topology-summaries {
                description
                  "Container for Topology summary information";
                list topology-summary {
                  key "topo-vrf-name";
                  description
                    "Topology summary information";
                  leaf topo-vrf-name {
                    type xr:Cisco-ios-xr-string;
                    description "VRF Name";
                  }
    
                  leaf vrf-name {
                    type string;
                    description "VRF Name";
                  }
    
                  leaf router-id {
                    type inet:ipv4-address;
                    description "Router ID";
                  }
    
                  leaf num-areas {
                    type uint16;
                    description "No. of Areas";
                  }
    
                  leaf spf-trigger-flags {
                    type uint8;
                    description
                      "SPF Trigger Flags";
                  }
    
                  leaf spf-schedule-flags {
                    type uint8;
                    description
                      "SPF Schedule Flags";
                  }
    
                  leaf num-algos {
                    type uint8;
                    description
                      "No. of Algos supported";
                  }
    
                  leaf algo-status {
                    type yang:hex-string;
                    description "Algo Status";
                  }
    
                  leaf max-paths {
                    type uint16;
                    description "Max Paths";
                  }
    
                  leaf num-routes {
                    type uint32;
                    description "No. of Routes";
                  }
    
                  leaf-list route-work-queue-size {
                    type uint32;
                    max-elements 4;
                    description
                      "Route Work Queue Sizes";
                  }
    
                  list srgb {
                    description "SRGB List";
                    leaf range-start {
                      type uint32;
                      description "Range Start";
                    }
    
                    leaf range-size {
                      type uint32;
                      description "Range Size";
                    }
                  }  // list srgb
    
                  list area {
                    description "List of Areas";
                    leaf area-id-string {
                      type string {
                        length "0..16";
                      }
                      description "Area ID";
                    }
    
                    leaf num-nodes {
                      type uint16;
                      description "No. of Nodes";
                    }
    
                    leaf ulooptime-remaining {
                      type uint32;
                      description
                        "Time remaining for the active Microloop
    avoidance paths";
                    }
    
                    list algo {
                      description
                        "List of Algos";
                      container uloop-timestamp-begin-last-successful-calc {
                        description
                          "Time at which last successful microloop
    calculation began";
                        leaf second {
                          type uint32;
                          description "Second";
                        }
    
                        leaf nanosecond {
                          type uint32;
                          description
                            "Nanosecond";
                        }
                      }  // container uloop-timestamp-begin-last-successful-calc
    
                      container uloop-timestamp-end-last-successful-calc {
                        description
                          "Time at which last successful microloop
    calculation was completed";
                        leaf second {
                          type uint32;
                          description "Second";
                        }
    
                        leaf nanosecond {
                          type uint32;
                          description
                            "Nanosecond";
                        }
                      }  // container uloop-timestamp-end-last-successful-calc
    
                      leaf algo-number {
                        type uint8;
                        description
                          "Algo Number";
                      }
    
                      leaf spf-trigger-flags {
                        type uint8;
                        description
                          "SPF Trigger Flags";
                      }
    
                      leaf spf-schedule-flags {
                        type uint8;
                        description
                          "SPF Schedule Flags";
                      }
    
                      leaf spf-count {
                        type uint8;
                        description "SPF Count";
                      }
    
                      leaf fad-adv-router-id {
                        type inet:ipv4-address;
                        description
                          "FAD Adv Router ID";
                      }
    
                      leaf fad-area-id-string {
                        type string {
                          length "0..16";
                        }
                        description
                          "FAD Adv Router's Area ID";
                      }
    
                      leaf metric-type {
                        type uint8;
                        description
                          "Metric Type";
                      }
    
                      leaf algo-type {
                        type uint8;
                        description "Algo Type";
                      }
    
                      leaf is-uloop-active {
                        type boolean;
                        description
                          "Whether microloop avoidance is active";
                      }
    
                      leaf uloop-near-end-node {
                        type uint32;
                        description
                          "Near end node in the active microloop
    calculation";
                      }
    
                      leaf uloop-far-end-node {
                        type uint32;
                        description
                          "Far end node in the active microloop calculation";
                      }
    
                      leaf uloop-cost-in-out-node {
                        type uint32;
                        description
                          "Node that had a cost in or cost out in the
    active microloop calculation";
                      }
    
                      leaf uloop-news {
                        type uint8;
                        description
                          "Action that triggered the active microloop
    calculation";
                      }
    
                      leaf uloop-last-successful-near-end-node {
                        type uint32;
                        description
                          "Near end node in the last successful microloop
    calculation";
                      }
    
                      leaf uloop-last-successful-far-end-node {
                        type uint32;
                        description
                          "Far end node in the last successful microloop
    calculation";
                      }
    
                      leaf uloop-last-successful-cost-in-out-node {
                        type uint32;
                        description
                          "Node that had a cost in or cost out in the last
    successful microloop calculation";
                      }
    
                      leaf uloop-last-successful-news {
                        type uint8;
                        description
                          "Action that triggered the last successful
    microloop calculation";
                      }
    
                      leaf-list exclude-affinity {
                        type uint32;
                        description
                          "Exclude Affinity";
                      }
    
                      leaf-list include-any-affinity {
                        type uint32;
                        description
                          "Include Any Affinity";
                      }
    
                      leaf-list include-all-affinity {
                        type uint32;
                        description
                          "Include All Affinity";
                      }
                    }  // list algo
                  }  // list area
                }  // list topology-summary
              }  // container topology-summaries
    
              container topologies {
                description
                  "Container for Topology information";
                list topology {
                  key "topo-vrf-name";
                  description
                    "Topology information";
                  leaf topo-vrf-name {
                    type xr:Cisco-ios-xr-string;
                    description "VRF Name";
                  }
    
                  leaf vrf-name {
                    type string;
                    description "VRF Name";
                  }
    
                  leaf router-id {
                    type inet:ipv4-address;
                    description "Router ID";
                  }
    
                  list area {
                    description "List of Areas";
                    leaf area-id-string {
                      type string {
                        length "0..16";
                      }
                      description
                        "Area ID string";
                    }
    
                    leaf num-nodes {
                      type uint16;
                      description
                        "No. of nodes under area";
                    }
    
                    list node {
                      description
                        "List of Nodes";
                      container node-id {
                        description "Node ID";
                        leaf adv-router-id {
                          type inet:ipv4-address;
                          description
                            "Advertising Router ID";
                        }
    
                        leaf dr-identifier {
                          type inet:ipv4-address;
                          description
                            "Node DR Identifier";
                        }
                      }  // container node-id
    
                      leaf num-links {
                        type uint16;
                        description
                          "Number of Links";
                      }
    
                      leaf num-prefixes {
                        type uint32;
                        description
                          "Number of prefixes";
                      }
    
                      leaf is-root-node {
                        type boolean;
                        description
                          "Is root node";
                      }
    
                      leaf is-area-border-router {
                        type boolean;
                        description
                          "Node is ABR";
                      }
    
                      leaf is-as-border-router {
                        type boolean;
                        description
                          "Node is ASBR";
                      }
    
                      leaf node-oper-flags {
                        type uint16;
                        description
                          "Node Operational flags";
                      }
    
                      leaf is-router-lsa-contrib {
                        type boolean;
                        description
                          "Is Router LSA Contributing";
                      }
    
                      leaf is-network-lsa-contrib {
                        type boolean;
                        description
                          "Is Network LSA Contributing";
                      }
    
                      leaf is-router-info-lsa-contrib {
                        type boolean;
                        description
                          "Is Router Info LSA Contributing";
                      }
    
                      leaf-list node-algo {
                        type uint8;
                        description
                          "Node algo support list";
                      }
    
                      list link {
                        description
                          "List of Links";
                        container link-id {
                          description "Link ID";
                          leaf link-id {
                            type inet:ipv4-address;
                            description
                              "Link ID";
                          }
    
                          leaf link-data {
                            type inet:ipv4-address;
                            description
                              "Link Data";
                          }
    
                          leaf link-type {
                            type uint8;
                            description
                              "Link Type";
                          }
                        }  // container link-id
    
                        container remote-link-id {
                          description
                            "Remote Link ID";
                          leaf link-id {
                            type inet:ipv4-address;
                            description
                              "Link ID";
                          }
    
                          leaf link-data {
                            type inet:ipv4-address;
                            description
                              "Link Data";
                          }
    
                          leaf link-type {
                            type uint8;
                            description
                              "Link Type";
                          }
                        }  // container remote-link-id
    
                        container link-attrs {
                          description
                            "Link Attributes";
                          container flex-algo-asla-attrs {
                            description
                              "Flex Algo ASLA Attributes";
                            leaf srte-metric {
                              type uint32;
                              description
                                "SR-TE Metric";
                            }
    
                            leaf min-delay {
                              type uint32;
                              description
                                "Min Delay";
                            }
    
                            leaf-list ext-admin-group {
                              type uint32;
                              units "bit";
                              description
                                "Ext. Admin Group bits";
                            }
    
                            leaf-list srlg {
                              type uint32;
                              description
                                "SRLG values";
                            }
                          }  // container flex-algo-asla-attrs
    
                          leaf lsid {
                            type inet:ipv4-address;
                            description
                              "Ext Link LSA ID";
                          }
    
                          leaf local-interface-id {
                            type uint32;
                            description
                              "Local Interface ID";
                          }
    
                          leaf remote-interface-id {
                            type uint32;
                            description
                              "Remote Interface ID";
                          }
    
                          leaf remote-ipv4-address {
                            type inet:ipv4-address;
                            description
                              "Remote IPv4 Address";
                          }
    
                          leaf max-bandwidth {
                            type uint32;
                            description
                              "Max Bandwidth";
                          }
                        }  // container link-attrs
    
                        leaf link-metric {
                          type uint16;
                          description
                            "Link Metric";
                        }
    
                        leaf link-subnet-mask {
                          type inet:ipv4-address;
                          description
                            "Link Subnet Mask";
                        }
    
                        leaf link-oper-flags {
                          type uint16;
                          description
                            "Link Operational flags";
                        }
    
                        leaf is-router-lsa-contrib {
                          type boolean;
                          description
                            "Is Router LSA Contributing";
                        }
    
                        leaf is-network-lsa-contrib {
                          type boolean;
                          description
                            "Is Network LSA Contributing";
                        }
    
                        leaf is-ext-link-lsa-contrib {
                          type boolean;
                          description
                            "Is Ext Link LSA Contributing";
                        }
                      }  // list link
    
                      list prefix {
                        description
                          "List of prefixes";
                        leaf prefix-address {
                          type inet:ipv4-address;
                          description
                            "Prefix Address";
                        }
    
                        leaf prefix-length {
                          type uint8;
                          description
                            "Prefix Length";
                        }
    
                        leaf prefix-metric {
                          type uint32;
                          description
                            "Prefix metric";
                        }
    
                        leaf route-type {
                          type uint32;
                          description
                            "Route Type";
                        }
    
                        list prefix-contributor {
                          description
                            "Prefix Contributors";
                          leaf algo {
                            type uint8;
                            description
                              "Algo number";
                          }
    
                          leaf sid {
                            type uint32;
                            description "SID";
                          }
    
                          leaf total-metric {
                            type uint64;
                            description
                              "Total metric";
                          }
    
                          leaf contrib-flags {
                            type uint8;
                            description
                              "Prefix contributor flags";
                          }
    
                          leaf sid-flags {
                            type uint8;
                            description
                              "SID flags";
                          }
                        }  // list prefix-contributor
                      }  // list prefix
    
                      list srgb {
                        description
                          "Node SRGB List";
                        leaf range-start {
                          type uint32;
                          description
                            "Range Start";
                        }
    
                        leaf range-size {
                          type uint32;
                          description
                            "Range Size";
                        }
                      }  // list srgb
    
                      list fad {
                        description
                          "Flex Algo Definition List";
                        leaf algo-number {
                          type uint8;
                          description
                            "Algo Number";
                        }
    
                        leaf metric-type {
                          type uint8;
                          description
                            "Metric Type";
                        }
    
                        leaf algo-type {
                          type uint8;
                          description
                            "Algo Type";
                        }
    
                        leaf priority {
                          type uint8;
                          description
                            "Algo Priority";
                        }
    
                        leaf fad-oper-flags {
                          type uint16;
                          description
                            "FAD Operational Flags";
                        }
    
                        leaf fad-has-unsupported-params {
                          type boolean;
                          description
                            "The FAD defintion contains TLVs or Flags that
    are not supported by this node";
                        }
    
                        leaf-list exclude-affinity {
                          type uint32;
                          description
                            "Exclude Affinity";
                        }
    
                        leaf-list include-any-affinity {
                          type uint32;
                          description
                            "Include Any Affinity";
                        }
    
                        leaf-list include-all-affinity {
                          type uint32;
                          description
                            "Include All Affinity";
                        }
                      }  // list fad
                    }  // list node
                  }  // list area
                }  // list topology
              }  // container topologies
    
              leaf process-name {
                type xr:Cisco-ios-xr-string;
                description "Process name";
              }
            }  // list topo-db-process
          }  // container topo-db-processes
        }  // container topo-db
      }  // module Cisco-IOS-XR-igp-topodb-oper
    

© 2023 YumaWorks, Inc. All rights reserved.