netconfcentral logo

openconfig-platform

HTML

openconfig-platform@2017-12-14



  module openconfig-platform {

    yang-version 1;

    namespace
      "http://openconfig.net/yang/platform";

    prefix oc-platform;

    import openconfig-platform-types {
      prefix oc-platform-types;
    }
    import openconfig-interfaces {
      prefix oc-if;
    }
    import openconfig-extensions {
      prefix oc-ext;
    }

    organization "OpenConfig working group";

    contact
      "OpenConfig working group
    www.openconfig.net";

    description
      "This module defines a data model for representing a system
    component inventory, which can include hardware or software
    elements arranged in an arbitrary structure. The primary
    relationship supported by the model is containment, e.g.,
    components containing subcomponents.

    It is expected that this model reflects every field replacable
    unit on the device at a minimum (i.e., additional information
    may be supplied about non-replacable components).

    Every element in the inventory is termed a 'component' with each
    component expected to have a unique name and type, and optionally
    a unique system-assigned identifier and FRU number.  The
    uniqueness is guaranteed by the system within the device.

    Components may have properties defined by the system that are
    modeled as a list of key-value pairs. These may or may not be
    user-configurable.  The model provides a flag for the system
    to optionally indicate which properties are user configurable.

    Each component also has a list of 'subcomponents' which are
    references to other components. Appearance in a list of
    subcomponents indicates a containment relationship as described
    above.  For example, a linecard component may have a list of
    references to port components that reside on the linecard.

    This schema is generic to allow devices to express their own
    platform-specific structure.  It may be augmented by additional
    component type-specific schemas that provide a common structure
    for well-known component types.  In these cases, the system is
    expected to populate the common component schema, and may
    optionally also represent the component and its properties in the
    generic structure.

    The properties for each component may include dynamic values,
    e.g., in the 'state' part of the schema.  For example, a CPU
    component may report its utilization, temperature, or other
    physical properties.  The intent is to capture all platform-
    specific physical data in one location, including inventory
    (presence or absence of a component) and state (physical
    attributes or status).";

    revision "2017-12-14" {
      description
        "Added anchor containers for component data, added new
      component types";
      reference
        "0.7.0";

    }

    revision "2017-08-16" {
      description
        "Added power state enumerated type";
      reference
        "0.6.0";

    }

    revision "2016-12-22" {
      description
        "Added temperature state variable to component";
      reference
        "0.5.0";

    }

    oc-ext:openconfig-version "0.7.0";

    grouping platform-component-properties-config {
      description
        "System-defined configuration data for component properties";
      leaf name {
        type string;
        description
          "System-supplied name of the property -- this is typically
        non-configurable";
      }

      leaf value {
        type union {
          type string;
          type boolean;
          type int64;
          type uint64;
          type decimal64 {
            fraction-digits 2;
          }
        }
        description
          "Property values can take on a variety of types.  Signed and
        unsigned integer types may be provided in smaller sizes,
        e.g., int8, uint16, etc.";
      }
    }  // grouping platform-component-properties-config

    grouping platform-component-properties-state {
      description
        "Operational state data for component properties";
      leaf configurable {
        type boolean;
        description
          "Indication whether the property is user-configurable";
      }
    }  // grouping platform-component-properties-state

    grouping platform-component-properties-top {
      description "Top-level grouping ";
      container properties {
        description "Enclosing container ";
        list property {
          key "name";
          description
            "List of system properties for the component";
          leaf name {
            type leafref {
              path "../config/name";
            }
            description
              "Reference to the property name.";
          }

          container config {
            description
              "Configuration data for each property";
            uses platform-component-properties-config;
          }  // container config

          container state {
            config false;
            description
              "Operational state data for each property";
            uses platform-component-properties-config;

            uses platform-component-properties-state;
          }  // container state
        }  // list property
      }  // container properties
    }  // grouping platform-component-properties-top

    grouping platform-subcomponent-ref-config {
      description
        "Configuration data for subcomponent references";
      leaf name {
        type leafref {
          path
            "../../../../../component/config/name";
        }
        description
          "Reference to the name of the subcomponent";
      }
    }  // grouping platform-subcomponent-ref-config

    grouping platform-subcomponent-ref-state {
      description
        "Operational state data for subcomponent references";
    }  // grouping platform-subcomponent-ref-state

    grouping platform-subcomponent-ref-top {
      description
        "Top-level grouping for list of subcomponent references";
      container subcomponents {
        description
          "Enclosing container for subcomponent references";
        list subcomponent {
          key "name";
          description
            "List of subcomponent references";
          leaf name {
            type leafref {
              path "../config/name";
            }
            description
              "Reference to the name list key";
          }

          container config {
            description
              "Configuration data ";
            uses platform-subcomponent-ref-config;
          }  // container config

          container state {
            config false;
            description
              "Operational state data ";
            uses platform-subcomponent-ref-config;

            uses platform-subcomponent-ref-state;
          }  // container state
        }  // list subcomponent
      }  // container subcomponents
    }  // grouping platform-subcomponent-ref-top

    grouping platform-component-config {
      description
        "Configuration data for components";
      leaf name {
        type string;
        description
          "Device name for the component -- this will not be a
        configurable parameter on many implementations";
      }
    }  // grouping platform-component-config

    grouping platform-component-state {
      description
        "Operational state data for device components.";
      leaf type {
        type union {
          type identityref {
            base oc-platform-types:OPENCONFIG_HARDWARE_COMPONENT;
          }
          type identityref {
            base oc-platform-types:OPENCONFIG_SOFTWARE_COMPONENT;
          }
        }
        description
          "Type of component as identified by the system";
      }

      leaf id {
        type string;
        description
          "Unique identifier assigned by the system for the
        component";
      }

      leaf description {
        type string;
        description
          "System-supplied description of the component";
      }

      leaf mfg-name {
        type string;
        description
          "System-supplied identifier for the manufacturer of the
        component.  This data is particularly useful when a
        component manufacturer is different than the overall
        device vendor.";
      }

      leaf version {
        type string;
        description
          "System-defined version string for a hardware, firmware,
        or software component.";
      }

      leaf serial-no {
        type string;
        description
          "System-assigned serial number of the component.";
      }

      leaf part-no {
        type string;
        description
          "System-assigned part number for the component.  This should
        be present in particular if the component is also an FRU
        (field replacable unit)";
      }
    }  // grouping platform-component-state

    grouping platform-component-temp-state {
      description
        "Temperature state data for device components";
      container temperature {
        description
          "Temperature in degrees Celsius of the component. Values include
        the instantaneous, average, minimum, and maximum statistics. If
        avg/min/max statistics are not supported, the target is expected
        to just supply the instant value";
        uses oc-platform-types:avg-min-max-instant-stats-precision1-celsius;
      }  // container temperature
    }  // grouping platform-component-temp-state

    grouping platform-anchors-top {
      description
        "This grouping is used to add containers for components that
      are common across systems, but do not have a defined schema
      within the openconfig-platform module.  Containers should be
      added to this grouping for components that are expected to
      exist in multiple systems, with corresponding modules
      augmenting the config/state containers directly.";
      container chassis {
        description
          "Data for chassis components";
        container config {
          description
            "Configuration data for chassis components";
        }  // container config

        container state {
          config false;
          description
            "Operational state data for chassis components";
        }  // container state
      }  // container chassis

      container port {
        description
          "Data for physical port components";
        container config {
          description
            "Configuration data for physical port components";
        }  // container config

        container state {
          config false;
          description
            "Operational state data for physical port components";
        }  // container state
      }  // container port

      container power-supply {
        description
          "Data for power supply components";
        container config {
          description
            "Configuration data for power supply components";
        }  // container config

        container state {
          config false;
          description
            "Operational state data for power supply components";
        }  // container state
      }  // container power-supply

      container fan {
        description
          "Data for fan components";
        container config {
          description
            "Configuration data for fan components";
        }  // container config

        container state {
          config false;
          description
            "Operational state data for fan components";
        }  // container state
      }  // container fan

      container fabric {
        description
          "Data for fabric components";
        container config {
          description
            "Configuration data for fabric components";
        }  // container config

        container state {
          config false;
          description
            "Operational state data for fabric components";
        }  // container state
      }  // container fabric

      container storage {
        description
          "Data for storage components";
        container config {
          description
            "Configuration data for storage components";
        }  // container config

        container state {
          config false;
          description
            "Operational state data for storage components";
        }  // container state
      }  // container storage

      container cpu {
        description
          "Data for cpu components";
        container config {
          description
            "Configuration data for cpu components";
        }  // container config

        container state {
          config false;
          description
            "Operational state data for cpu components";
        }  // container state
      }  // container cpu

      container integrated-circuit {
        description
          "Data for chip components, such as ASIC, NPUs, etc.";
        container config {
          description
            "Configuration data for chip components";
        }  // container config

        container state {
          config false;
          description
            "Operational state data for chip components";
        }  // container state
      }  // container integrated-circuit

      container backplane {
        description
          "Data for backplane components";
        container config {
          description
            "Configuration data for backplane components";
        }  // container config

        container state {
          config false;
          description
            "Operational state data for backplane components";
        }  // container state
      }  // container backplane
    }  // grouping platform-anchors-top

    grouping platform-component-top {
      description
        "Top-level grouping for components in the device inventory";
      container components {
        description
          "Enclosing container for the components in the system.";
        list component {
          key "name";
          description
            "List of components, keyed by component name.";
          leaf name {
            type leafref {
              path "../config/name";
            }
            description
              "References the component name";
          }

          container config {
            description
              "Configuration data for each component";
            uses platform-component-config;
          }  // container config

          container state {
            config false;
            description
              "Operational state data for each component";
            uses platform-component-config;

            uses platform-component-state;

            uses platform-component-temp-state;
          }  // container state

          uses platform-component-properties-top;

          uses platform-subcomponent-ref-top;

          uses platform-anchors-top;
        }  // list component
      }  // container components
    }  // grouping platform-component-top

    uses platform-component-top;

    augment /oc-if:interfaces/oc-if:interface/oc-if:state {
      description
        "Adds a reference from the base interface to the corresponding
      port component in the device inventory.";
      leaf hardware-port {
        type leafref {
          path "/oc-platform:components/oc-platform:component/oc-platform:name";
        }
        description
          "References the hardware port in the device inventory";
      }
    }
  }  // module openconfig-platform

Summary

  
  
Organization OpenConfig working group
  
Module openconfig-platform
Version 2017-12-14
File openconfig-platform.yang
  
Prefix oc-platform
Namespace http://openconfig.net/yang/platform
  
Cooked /cookedmodules/openconfig-platform/2017-12-14
YANG /src/openconfig-platform@2017-12-14.yang
XSD /xsd/openconfig-platform@2017-12-14.xsd
  
Abstract This module defines a data model for representing a system component inventory, which can include hardware or software elements ...
  
Contact
OpenConfig working group
www.openconfig.net

Description

 
This module defines a data model for representing a system
component inventory, which can include hardware or software
elements arranged in an arbitrary structure. The primary
relationship supported by the model is containment, e.g.,
components containing subcomponents.

It is expected that this model reflects every field replacable
unit on the device at a minimum (i.e., additional information
may be supplied about non-replacable components).

Every element in the inventory is termed a 'component' with each
component expected to have a unique name and type, and optionally
a unique system-assigned identifier and FRU number.  The
uniqueness is guaranteed by the system within the device.

Components may have properties defined by the system that are
modeled as a list of key-value pairs. These may or may not be
user-configurable.  The model provides a flag for the system
to optionally indicate which properties are user configurable.

Each component also has a list of 'subcomponents' which are
references to other components. Appearance in a list of
subcomponents indicates a containment relationship as described
above.  For example, a linecard component may have a list of
references to port components that reside on the linecard.

This schema is generic to allow devices to express their own
platform-specific structure.  It may be augmented by additional
component type-specific schemas that provide a common structure
for well-known component types.  In these cases, the system is
expected to populate the common component schema, and may
optionally also represent the component and its properties in the
generic structure.

The properties for each component may include dynamic values,
e.g., in the 'state' part of the schema.  For example, a CPU
component may report its utilization, temperature, or other
physical properties.  The intent is to capture all platform-
specific physical data in one location, including inventory
(presence or absence of a component) and state (physical
attributes or status).

Groupings

Grouping Objects Abstract
platform-anchors-top chassis port power-supply fan fabric storage cpu integrated-circuit backplane This grouping is used to add containers for components that are common across systems, but do not have a defined schema within the openconfig-platform module. Containers should be added to this grouping for components that are expected to exist in multip...
platform-component-config name Configuration data for components
platform-component-properties-config name value System-defined configuration data for component properties
platform-component-properties-state configurable Operational state data for component properties
platform-component-properties-top properties Top-level grouping
platform-component-state type id description mfg-name version serial-no part-no Operational state data for device components.
platform-component-temp-state temperature Temperature state data for device components
platform-component-top components Top-level grouping for components in the device inventory
platform-subcomponent-ref-config name Configuration data for subcomponent references
platform-subcomponent-ref-state Operational state data for subcomponent references
platform-subcomponent-ref-top subcomponents Top-level grouping for list of subcomponent references

Objects

Type Key
Mandatory config
Optional config
Not config
Object Type Abstract
components container Enclosing container for the components in the system.
   component list List of components, keyed by component name.
      backplane container Data for backplane components
         config container Configuration data for backplane components
         state container Operational state data for backplane components
      chassis container Data for chassis components
         config container Configuration data for chassis components
         state container Operational state data for chassis components
      config container Configuration data for each component
         name leaf Device name for the component -- this will not be a configurable parameter on many implementations
      cpu container Data for cpu components
         config container Configuration data for cpu components
         state container Operational state data for cpu components
      fabric container Data for fabric components
         config container Configuration data for fabric components
         state container Operational state data for fabric components
      fan container Data for fan components
         config container Configuration data for fan components
         state container Operational state data for fan components
      integrated-circuit container Data for chip components, such as ASIC, NPUs, etc.
         config container Configuration data for chip components
         state container Operational state data for chip components
      name leaf References the component name
      port container Data for physical port components
         config container Configuration data for physical port components
         state container Operational state data for physical port components
      power-supply container Data for power supply components
         config container Configuration data for power supply components
         state container Operational state data for power supply components
      properties container Enclosing container
         property list List of system properties for the component
            config container Configuration data for each property
               name leaf System-supplied name of the property -- this is typically non-configurable
               value leaf Property values can take on a variety of types. Signed and unsigned integer types may be provided in smaller sizes, e.g., int8, uint16, etc.
            name leaf Reference to the property name.
            state container Operational state data for each property
               configurable leaf Indication whether the property is user-configurable
               name leaf System-supplied name of the property -- this is typically non-configurable
               value leaf Property values can take on a variety of types. Signed and unsigned integer types may be provided in smaller sizes, e.g., int8, uint16, etc.
      state container Operational state data for each component
         description leaf System-supplied description of the component
         id leaf Unique identifier assigned by the system for the component
         mfg-name leaf System-supplied identifier for the manufacturer of the component. This data is particularly useful when a component manufacturer is different than the overall device vendor.
         name leaf Device name for the component -- this will not be a configurable parameter on many implementations
         part-no leaf System-assigned part number for the component. This should be present in particular if the component is also an FRU (field replacable unit)
         serial-no leaf System-assigned serial number of the component.
         temperature container Temperature in degrees Celsius of the component. Values include the instantaneous, average, minimum, and maximum statistics. If avg/min/max statistics are not supported, the target is expected to just supply the instant value
            avg leaf The arithmetic mean value of the statistic over the sampling period.
            instant leaf The instantaneous value of the statistic.
            max leaf The maximum value of the statistic over the sampling period
            min leaf The minimum value of the statistic over the sampling period
         type leaf Type of component as identified by the system
         version leaf System-defined version string for a hardware, firmware, or software component.
      storage container Data for storage components
         config container Configuration data for storage components
         state container Operational state data for storage components
      subcomponents container Enclosing container for subcomponent references
         subcomponent list List of subcomponent references
            config container Configuration data
               name leaf Reference to the name of the subcomponent
            name leaf Reference to the name list key
            state container Operational state data
               name leaf Reference to the name of the subcomponent