Cisco-IOS-XR-ifmgr-oper

This module contains a collection of YANG definitions for Cisco IOS-XR ifmgr package operational data. This module contains def...

  • Version: 2020-10-01

    Cisco-IOS-XR-ifmgr-oper@2020-10-01


    
      module Cisco-IOS-XR-ifmgr-oper {
    
        yang-version 1;
    
        namespace
          "http://cisco.com/ns/yang/Cisco-IOS-XR-ifmgr-oper";
    
        prefix ifmgr-oper;
    
        import Cisco-IOS-XR-types {
          prefix xr;
        }
        import cisco-semver {
          prefix semver;
        }
    
        include Cisco-IOS-XR-ifmgr-oper-sub2 {
          revision-date "2020-10-01";
        }
        include Cisco-IOS-XR-ifmgr-oper-sub1 {
          revision-date "2020-10-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 ifmgr package operational data.
    
    This module contains definitions
    for the following management objects:
      interface-dampening: Interface dampening configuration for an
        interface
      interface-properties: Non feature-specific interface
        operational data
    
    Copyright (c) 2013-2020 by Cisco Systems, Inc.
    All rights reserved.";
    
        revision "2020-10-01" {
          description "64-bit bandwidth changes";
        }
    
        revision "2019-12-03" {
          description "Updated description.";
        }
    
        revision "2019-07-23" {
          description
            "IosApi version change
    2019-05-30
    64 bit bandwidth changes.";
        }
    
        revision "2019-04-05" {
          description
            "Establish semantic version baseline.";
        }
    
        revision "2015-07-30" {
          description "IOS XR 5.3.2 revision.";
        }
    
        revision "2015-01-07" {
          description "IOS XR 5.3.1 revision.";
        }
    
        semver:module-version "2.0.0";
        semver:module-version "2.0.0";
        semver:module-version "1.1.0";
        semver:module-version "1.0.0";
    
        container interface-dampening {
          config false;
          description
            "Interface dampening configuration for an
    interface";
          container interfaces {
            description
              "The interface list for which dampening info is
    available";
            list interface {
              key "interface-name";
              description
                "The interface for which dampening info is being
    queried";
              container if-dampening {
                description
                  "Dampening info for the interface";
                container interface-dampening {
                  description
                    "Interface dampening configuration for an
    interface";
                  leaf penalty {
                    type uint32;
                    description
                      "Dampening penalty of the interface";
                  }
    
                  leaf is-suppressed-enabled {
                    type boolean;
                    description
                      "Flag showing if state is suppressed";
                  }
    
                  leaf seconds-remaining {
                    type uint32;
                    units "second";
                    description
                      "Remaining period of suppression in secs";
                  }
    
                  leaf flaps {
                    type uint32;
                    description
                      "Number of underlying state flaps";
                  }
    
                  leaf state {
                    type Im-state-enum;
                    description
                      "Underlying state of the node";
                  }
                }  // container interface-dampening
    
                leaf state-transition-count {
                  type uint32;
                  description
                    "The number of times the state has changed";
                }
    
                leaf last-state-transition-time {
                  type uint64;
                  description
                    "The absolute time of last state change of the
    interface";
                }
    
                leaf is-dampening-enabled {
                  type boolean;
                  description
                    "Flag showing if dampening is enabled";
                }
    
                leaf half-life {
                  type uint32;
                  units "minute";
                  description
                    "Configured decay half life in mins";
                }
    
                leaf reuse-threshold {
                  type uint32;
                  description
                    "Configured reuse threshold";
                }
    
                leaf suppress-threshold {
                  type uint32;
                  description
                    "Value of suppress threshold";
                }
    
                leaf maximum-suppress-time {
                  type uint32;
                  units "minute";
                  description
                    "Maximum suppress time in mins";
                }
    
                leaf restart-penalty {
                  type uint32;
                  description
                    "Configured restart penalty";
                }
    
                list capsulation {
                  description
                    "Dampening information for capsulations";
                  container capsulation-dampening {
                    description
                      "Dampening information of capsulation";
                    leaf penalty {
                      type uint32;
                      description
                        "Dampening penalty of the interface";
                    }
    
                    leaf is-suppressed-enabled {
                      type boolean;
                      description
                        "Flag showing if state is suppressed";
                    }
    
                    leaf seconds-remaining {
                      type uint32;
                      units "second";
                      description
                        "Remaining period of suppression in secs";
                    }
    
                    leaf flaps {
                      type uint32;
                      description
                        "Number of underlying state flaps";
                    }
    
                    leaf state {
                      type Im-state-enum;
                      description
                        "Underlying state of the node";
                    }
                  }  // container capsulation-dampening
    
                  leaf capsulation-number {
                    type string;
                    description
                      "Capsulation number of the Interface";
                  }
                }  // list capsulation
              }  // container if-dampening
    
              leaf interface-name {
                type xr:Interface-name;
                description "The name of the";
              }
            }  // list interface
          }  // container interfaces
    
          container nodes {
            description
              "The location of the interface(s) being queried";
            list node {
              key "node-name";
              description
                "The location of the interface(s) being queried";
              container show {
                description
                  "Show details for the interfaces";
                container dampening {
                  description
                    "Dampening information of the interface(s)
    being queried";
                  container if-handles {
                    description
                      "Interface handle for which dampening info
    queried";
                    list if-handle {
                      key "interface-handle-name";
                      description
                        "Dampening info for the interface handle";
                      leaf interface-handle-name {
                        type xr:Cisco-ios-xr-string;
                        description
                          "The interface handle";
                      }
    
                      container interface-dampening {
                        description
                          "Interface dampening configuration for an
    interface";
                        leaf penalty {
                          type uint32;
                          description
                            "Dampening penalty of the interface";
                        }
    
                        leaf is-suppressed-enabled {
                          type boolean;
                          description
                            "Flag showing if state is suppressed";
                        }
    
                        leaf seconds-remaining {
                          type uint32;
                          units "second";
                          description
                            "Remaining period of suppression in secs";
                        }
    
                        leaf flaps {
                          type uint32;
                          description
                            "Number of underlying state flaps";
                        }
    
                        leaf state {
                          type Im-state-enum;
                          description
                            "Underlying state of the node";
                        }
                      }  // container interface-dampening
    
                      leaf state-transition-count {
                        type uint32;
                        description
                          "The number of times the state has changed";
                      }
    
                      leaf last-state-transition-time {
                        type uint64;
                        description
                          "The absolute time of last state change of the
    interface";
                      }
    
                      leaf is-dampening-enabled {
                        type boolean;
                        description
                          "Flag showing if dampening is enabled";
                      }
    
                      leaf half-life {
                        type uint32;
                        units "minute";
                        description
                          "Configured decay half life in mins";
                      }
    
                      leaf reuse-threshold {
                        type uint32;
                        description
                          "Configured reuse threshold";
                      }
    
                      leaf suppress-threshold {
                        type uint32;
                        description
                          "Value of suppress threshold";
                      }
    
                      leaf maximum-suppress-time {
                        type uint32;
                        units "minute";
                        description
                          "Maximum suppress time in mins";
                      }
    
                      leaf restart-penalty {
                        type uint32;
                        description
                          "Configured restart penalty";
                      }
    
                      list capsulation {
                        description
                          "Dampening information for capsulations";
                        container capsulation-dampening {
                          description
                            "Dampening information of capsulation";
                          leaf penalty {
                            type uint32;
                            description
                              "Dampening penalty of the interface";
                          }
    
                          leaf is-suppressed-enabled {
                            type boolean;
                            description
                              "Flag showing if state is suppressed";
                          }
    
                          leaf seconds-remaining {
                            type uint32;
                            units "second";
                            description
                              "Remaining period of suppression in secs";
                          }
    
                          leaf flaps {
                            type uint32;
                            description
                              "Number of underlying state flaps";
                          }
    
                          leaf state {
                            type Im-state-enum;
                            description
                              "Underlying state of the node";
                          }
                        }  // container capsulation-dampening
    
                        leaf capsulation-number {
                          type string;
                          description
                            "Capsulation number of the Interface";
                        }
                      }  // list capsulation
                    }  // list if-handle
                  }  // container if-handles
    
                  container interfaces {
                    description
                      "Table of interfaces for which dampening info
    can be queried";
                    list interface {
                      key "interface-name";
                      description
                        "Dampening info for the interface";
                      leaf interface-name {
                        type xr:Interface-name;
                        description
                          "The name of the";
                      }
    
                      container interface-dampening {
                        description
                          "Interface dampening configuration for an
    interface";
                        leaf penalty {
                          type uint32;
                          description
                            "Dampening penalty of the interface";
                        }
    
                        leaf is-suppressed-enabled {
                          type boolean;
                          description
                            "Flag showing if state is suppressed";
                        }
    
                        leaf seconds-remaining {
                          type uint32;
                          units "second";
                          description
                            "Remaining period of suppression in secs";
                        }
    
                        leaf flaps {
                          type uint32;
                          description
                            "Number of underlying state flaps";
                        }
    
                        leaf state {
                          type Im-state-enum;
                          description
                            "Underlying state of the node";
                        }
                      }  // container interface-dampening
    
                      leaf state-transition-count {
                        type uint32;
                        description
                          "The number of times the state has changed";
                      }
    
                      leaf last-state-transition-time {
                        type uint64;
                        description
                          "The absolute time of last state change of the
    interface";
                      }
    
                      leaf is-dampening-enabled {
                        type boolean;
                        description
                          "Flag showing if dampening is enabled";
                      }
    
                      leaf half-life {
                        type uint32;
                        units "minute";
                        description
                          "Configured decay half life in mins";
                      }
    
                      leaf reuse-threshold {
                        type uint32;
                        description
                          "Configured reuse threshold";
                      }
    
                      leaf suppress-threshold {
                        type uint32;
                        description
                          "Value of suppress threshold";
                      }
    
                      leaf maximum-suppress-time {
                        type uint32;
                        units "minute";
                        description
                          "Maximum suppress time in mins";
                      }
    
                      leaf restart-penalty {
                        type uint32;
                        description
                          "Configured restart penalty";
                      }
    
                      list capsulation {
                        description
                          "Dampening information for capsulations";
                        container capsulation-dampening {
                          description
                            "Dampening information of capsulation";
                          leaf penalty {
                            type uint32;
                            description
                              "Dampening penalty of the interface";
                          }
    
                          leaf is-suppressed-enabled {
                            type boolean;
                            description
                              "Flag showing if state is suppressed";
                          }
    
                          leaf seconds-remaining {
                            type uint32;
                            units "second";
                            description
                              "Remaining period of suppression in secs";
                          }
    
                          leaf flaps {
                            type uint32;
                            description
                              "Number of underlying state flaps";
                          }
    
                          leaf state {
                            type Im-state-enum;
                            description
                              "Underlying state of the node";
                          }
                        }  // container capsulation-dampening
    
                        leaf capsulation-number {
                          type string;
                          description
                            "Capsulation number of the Interface";
                        }
                      }  // list capsulation
                    }  // list interface
                  }  // container interfaces
                }  // container dampening
              }  // container show
    
              leaf node-name {
                type xr:Node-id;
                description
                  "The location of the interface(s)";
              }
            }  // list node
          }  // container nodes
        }  // container interface-dampening
    
        container interface-properties {
          config false;
          description
            "Non feature-specific interface operational data";
          container data-nodes {
            description
              "Operational data for interfaces";
            list data-node {
              key "data-node-name";
              description
                "The location of a (D)RP in the same LR as the
    interface being queried";
              container locationviews {
                description
                  "Location-specific view of interface
    operational data";
                list locationview {
                  key "locationview-name";
                  description
                    "Operational data for all interfaces and
    controllers on a particular node";
                  leaf locationview-name {
                    type xr:Node-id;
                    description
                      "The location to filter on";
                  }
    
                  container interfaces {
                    description
                      "Operational data for all interfaces and
    controllers";
                    list interface {
                      key "interface-name";
                      description
                        "The operational attributes for a particular
    interface";
                      leaf interface-name {
                        type xr:Interface-name;
                        description
                          "The name of the interface";
                      }
    
                      leaf interface {
                        type xr:Interface-name;
                        description "Interface";
                      }
    
                      leaf parent-interface {
                        type xr:Interface-name;
                        description
                          "Parent Interface";
                      }
    
                      leaf type {
                        type string;
                        description
                          "Interface type";
                      }
    
                      leaf state {
                        type Im-state-enum;
                        description
                          "Operational state";
                      }
    
                      leaf actual-state {
                        type Im-state-enum;
                        description
                          "Operational state with no translation of error
    disable or shutdown";
                      }
    
                      leaf line-state {
                        type Im-state-enum;
                        description
                          "Line protocol state";
                      }
    
                      leaf actual-line-state {
                        type Im-state-enum;
                        description
                          "Line protocol state with no translation of error
    disable or shutdown";
                      }
    
                      leaf encapsulation {
                        type string;
                        description
                          "Interface encapsulation";
                      }
    
                      leaf encapsulation-type-string {
                        type string {
                          length "0..32";
                        }
                        description
                          "Interface encapsulation description string";
                      }
    
                      leaf mtu {
                        type uint32;
                        units "byte";
                        description
                          "MTU in bytes";
                      }
    
                      leaf sub-interface-mtu-overhead {
                        type uint32;
                        description
                          "Subif MTU overhead";
                      }
    
                      leaf l2-transport {
                        type boolean;
                        description
                          "L2 transport";
                      }
    
                      leaf bandwidth {
                        type uint32;
                        description
                          "Interface bandwidth (Kb/s)";
                      }
    
                      leaf bandwidth64-bit {
                        type uint64;
                        description
                          "Interface bandwidth 64-bit (Kb/s)";
                      }
                    }  // list interface
                  }  // container interfaces
                }  // list locationview
              }  // container locationviews
    
              container pq-node-locations {
                description
                  "Partially qualified Location-specific view of
    interface operational data";
                list pq-node-location {
                  key "pq-node-name";
                  description
                    "Operational data for all interfaces and
    controllers on a particular pq_node";
                  leaf pq-node-name {
                    type xr:Pq-node-id;
                    description
                      "The partially qualified location to filter
    on";
                  }
    
                  container interfaces {
                    description
                      "Operational data for all interfaces and
    controllers";
                    list interface {
                      key "interface-name";
                      description
                        "The operational attributes for a particular
    interface";
                      leaf interface-name {
                        type xr:Interface-name;
                        description
                          "The name of the interface";
                      }
    
                      leaf interface {
                        type xr:Interface-name;
                        description "Interface";
                      }
    
                      leaf parent-interface {
                        type xr:Interface-name;
                        description
                          "Parent Interface";
                      }
    
                      leaf type {
                        type string;
                        description
                          "Interface type";
                      }
    
                      leaf state {
                        type Im-state-enum;
                        description
                          "Operational state";
                      }
    
                      leaf actual-state {
                        type Im-state-enum;
                        description
                          "Operational state with no translation of error
    disable or shutdown";
                      }
    
                      leaf line-state {
                        type Im-state-enum;
                        description
                          "Line protocol state";
                      }
    
                      leaf actual-line-state {
                        type Im-state-enum;
                        description
                          "Line protocol state with no translation of error
    disable or shutdown";
                      }
    
                      leaf encapsulation {
                        type string;
                        description
                          "Interface encapsulation";
                      }
    
                      leaf encapsulation-type-string {
                        type string {
                          length "0..32";
                        }
                        description
                          "Interface encapsulation description string";
                      }
    
                      leaf mtu {
                        type uint32;
                        units "byte";
                        description
                          "MTU in bytes";
                      }
    
                      leaf sub-interface-mtu-overhead {
                        type uint32;
                        description
                          "Subif MTU overhead";
                      }
    
                      leaf l2-transport {
                        type boolean;
                        description
                          "L2 transport";
                      }
    
                      leaf bandwidth {
                        type uint32;
                        description
                          "Interface bandwidth (Kb/s)";
                      }
    
                      leaf bandwidth64-bit {
                        type uint64;
                        description
                          "Interface bandwidth 64-bit (Kb/s)";
                      }
                    }  // list interface
                  }  // container interfaces
                }  // list pq-node-location
              }  // container pq-node-locations
    
              container system-view {
                description
                  "System-wide view of interface operational data";
                container interfaces {
                  description
                    "Operational data for all interfaces and
    controllers";
                  list interface {
                    key "interface-name";
                    description
                      "The operational attributes for a particular
    interface";
                    leaf interface-name {
                      type xr:Interface-name;
                      description
                        "The name of the interface";
                    }
    
                    leaf interface {
                      type xr:Interface-name;
                      description "Interface";
                    }
    
                    leaf parent-interface {
                      type xr:Interface-name;
                      description
                        "Parent Interface";
                    }
    
                    leaf type {
                      type string;
                      description
                        "Interface type";
                    }
    
                    leaf state {
                      type Im-state-enum;
                      description
                        "Operational state";
                    }
    
                    leaf actual-state {
                      type Im-state-enum;
                      description
                        "Operational state with no translation of error
    disable or shutdown";
                    }
    
                    leaf line-state {
                      type Im-state-enum;
                      description
                        "Line protocol state";
                    }
    
                    leaf actual-line-state {
                      type Im-state-enum;
                      description
                        "Line protocol state with no translation of error
    disable or shutdown";
                    }
    
                    leaf encapsulation {
                      type string;
                      description
                        "Interface encapsulation";
                    }
    
                    leaf encapsulation-type-string {
                      type string {
                        length "0..32";
                      }
                      description
                        "Interface encapsulation description string";
                    }
    
                    leaf mtu {
                      type uint32;
                      units "byte";
                      description "MTU in bytes";
                    }
    
                    leaf sub-interface-mtu-overhead {
                      type uint32;
                      description
                        "Subif MTU overhead";
                    }
    
                    leaf l2-transport {
                      type boolean;
                      description "L2 transport";
                    }
    
                    leaf bandwidth {
                      type uint32;
                      description
                        "Interface bandwidth (Kb/s)";
                    }
    
                    leaf bandwidth64-bit {
                      type uint64;
                      description
                        "Interface bandwidth 64-bit (Kb/s)";
                    }
                  }  // list interface
                }  // container interfaces
              }  // container system-view
    
              leaf data-node-name {
                type xr:Node-id;
                description
                  "The location of the (D)RP";
              }
            }  // list data-node
          }  // container data-nodes
        }  // container interface-properties
      }  // module Cisco-IOS-XR-ifmgr-oper
    

© 2023 YumaWorks, Inc. All rights reserved.