| module openconfig-platform { |
| |
| yang-version "1"; |
| |
| // namespace |
| namespace "http://openconfig.net/yang/platform"; |
| |
| prefix "oc-platform"; |
| |
| import openconfig-platform-types { prefix oc-platform-types; } |
| import openconfig-extensions { prefix oc-ext; } |
| import openconfig-alarm-types { prefix oc-alarm-types; } |
| import openconfig-yang-types { prefix oc-yang; } |
| |
| |
| // meta |
| 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)."; |
| |
| oc-ext:openconfig-version "0.11.0"; |
| |
| revision "2018-06-03" { |
| description |
| "Added parent reference, empty flag and preconfiguration |
| for components"; |
| reference "0.11.0"; |
| } |
| |
| revision "2018-04-20" { |
| description |
| "Added new per-component state data: mfg-date and removable"; |
| reference "0.10.0"; |
| } |
| |
| revision "2018-01-30" { |
| description |
| "Amended approach for modelling CPU - rather than having |
| a local CPU utilisation state variable, a component with |
| a CPU should create a subcomponent of type CPU to report |
| statistics."; |
| reference "0.9.0"; |
| } |
| |
| revision "2018-01-16" { |
| description |
| "Added new per-component common data; add temp alarm; |
| moved hardware-port reference to port model"; |
| reference "0.8.0"; |
| } |
| |
| 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"; |
| } |
| |
| // grouping statements |
| |
| |
| 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-state { |
| description |
| "Operational state data for component properties"; |
| |
| leaf configurable { |
| type boolean; |
| description |
| "Indication whether the property is user-configurable"; |
| } |
| } |
| |
| 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 state { |
| |
| config false; |
| |
| description |
| "Operational state data for each property"; |
| |
| uses platform-component-properties-config; |
| uses platform-component-properties-state; |
| } |
| } |
| } |
| } |
| |
| 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-state { |
| description |
| "Operational state data for subcomponent references"; |
| |
| } |
| |
| 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 for the subcomponent"; |
| |
| uses platform-subcomponent-ref-config; |
| } |
| |
| container state { |
| |
| config false; |
| |
| description |
| "Operational state data for the subcomponent"; |
| |
| uses platform-subcomponent-ref-config; |
| uses platform-subcomponent-ref-state; |
| } |
| } |
| } |
| } |
| |
| grouping platform-component-config { |
| description |
| "Configuration data for components"; |
| |
| leaf name { |
| type string; |
| description |
| "Device name for the component -- this may not be a |
| configurable parameter on many implementations. Where |
| component preconfiguration is supported, for example, |
| the component name may be configurable."; |
| } |
| } |
| |
| 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 mfg-date { |
| type oc-yang:date; |
| description |
| "System-supplied representation of the component's |
| manufacturing date."; |
| } |
| |
| leaf hardware-version { |
| type string; |
| description |
| "For hardware components, this is the hardware revision of |
| the component."; |
| } |
| |
| leaf firmware-version { |
| type string; |
| description |
| "For hardware components, this is the version of associated |
| firmware that is running on the component, if applicable."; |
| } |
| |
| leaf software-version { |
| type string; |
| description |
| "For software components such as operating system or other |
| software module, this is the version of the currently |
| running software."; |
| } |
| |
| 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 replaceable unit)"; |
| } |
| |
| leaf removable { |
| type boolean; |
| description |
| "If true, this component is removable or is a field |
| replaceable unit"; |
| } |
| |
| leaf oper-status { |
| type identityref { |
| base oc-platform-types:COMPONENT_OPER_STATUS; |
| } |
| description |
| "If applicable, this reports the current operational status |
| of the component."; |
| } |
| |
| leaf empty { |
| type boolean; |
| default false; |
| description |
| "The empty leaf may be used by the device to indicate that a |
| component position exists but is not populated. Using this |
| flag, it is possible for the management system to learn how |
| many positions are available (e.g., occupied vs. empty |
| linecard slots in a chassis)."; |
| } |
| |
| leaf parent { |
| type leafref { |
| path "../../config/name"; |
| } |
| description |
| "Reference to the name of the parent component. Note that |
| this reference must be kept synchronized with the |
| corresponding subcomponent reference from the parent |
| component."; |
| } |
| } |
| |
| grouping platform-component-temp-alarm-state { |
| description |
| "Temperature alarm data for platform components"; |
| |
| // TODO(aashaikh): consider if these leaves could be in a |
| // reusable grouping (not temperature-specific); threshold |
| // may always need to be units specific. |
| |
| leaf alarm-status { |
| type boolean; |
| description |
| "A value of true indicates the alarm has been raised or |
| asserted. The value should be false when the alarm is |
| cleared."; |
| } |
| |
| leaf alarm-threshold { |
| type uint32; |
| description |
| "The threshold value that was crossed for this alarm."; |
| } |
| |
| leaf alarm-severity { |
| type identityref { |
| base oc-alarm-types:OPENCONFIG_ALARM_SEVERITY; |
| } |
| description |
| "The severity of the current alarm."; |
| } |
| } |
| |
| grouping platform-component-power-state { |
| description |
| "Power-related operational state for device components."; |
| |
| leaf allocated-power { |
| type uint32; |
| units watts; |
| description |
| "Power allocated by the system for the component."; |
| } |
| |
| leaf used-power { |
| type uint32; |
| units watts; |
| description |
| "Actual power used by the component."; |
| } |
| } |
| |
| 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; |
| uses platform-component-temp-alarm-state; |
| } |
| } |
| |
| grouping platform-component-memory-state { |
| description |
| "Per-component memory statistics"; |
| |
| container memory { |
| description |
| "For components that have associated memory, these values |
| report information about available and utilized memory."; |
| |
| leaf available { |
| type uint64; |
| units bytes; |
| description |
| "The available memory physically installed, or logically |
| allocated to the component."; |
| } |
| |
| // TODO(aashaikh): consider if this needs to be a |
| // min/max/avg statistic |
| leaf utilized { |
| type uint64; |
| units bytes; |
| description |
| "The memory currently in use by processes running on |
| the component, not considering reserved memory that is |
| not available for use."; |
| } |
| } |
| } |
| |
| 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 state { |
| config false; |
| description |
| "Operational state data for chassis components"; |
| } |
| } |
| |
| // TODO(aashaikh): linecard container is already defined in |
| // openconfig-platform-linecard; will move to this module |
| // in future. |
| /* |
| container linecard { |
| description |
| "Data for linecard components"; |
| |
| container config { |
| description |
| "Configuration data for linecard components"; |
| } |
| |
| container state { |
| config false; |
| description |
| "Operational state data for linecard components"; |
| } |
| } |
| */ |
| |
| container port { |
| description |
| "Data for physical port components"; |
| |
| container config { |
| description |
| "Configuration data for physical port components"; |
| } |
| |
| container state { |
| config false; |
| leaf type { |
| type string; |
| } |
| description |
| "Operational state data for physical port components"; |
| } |
| } |
| |
| // TODO(aashaikh): transceiver container is already defined in |
| // openconfig-platform-transceiver; will move to this module |
| // in future. |
| /* |
| container transceiver { |
| description |
| "Data for transceiver components"; |
| |
| container config { |
| description |
| "Configuration data for transceiver components"; |
| } |
| |
| container state { |
| config false; |
| description |
| "Operational state data for transceiver components"; |
| } |
| } |
| */ |
| |
| container power-supply { |
| description |
| "Data for power supply components"; |
| |
| container config { |
| description |
| "Configuration data for power supply components"; |
| } |
| |
| container state { |
| config false; |
| description |
| "Operational state data for power supply components"; |
| } |
| } |
| |
| container fan { |
| description |
| "Data for fan components"; |
| |
| container config { |
| description |
| "Configuration data for fan components"; |
| } |
| |
| container state { |
| config false; |
| description |
| "Operational state data for fan components"; |
| } |
| } |
| |
| container fabric { |
| description |
| "Data for fabric components"; |
| |
| container config { |
| description |
| "Configuration data for fabric components"; |
| } |
| |
| container state { |
| config false; |
| description |
| "Operational state data for fabric components"; |
| } |
| } |
| |
| container storage { |
| description |
| "Data for storage components"; |
| |
| container config { |
| description |
| "Configuration data for storage components"; |
| } |
| |
| container state { |
| config false; |
| description |
| "Operational state data for storage components"; |
| } |
| } |
| |
| container cpu { |
| description |
| "Data for cpu components"; |
| |
| container config { |
| description |
| "Configuration data for cpu components"; |
| } |
| |
| container state { |
| config false; |
| description |
| "Operational state data for cpu components"; |
| } |
| } |
| |
| container integrated-circuit { |
| description |
| "Data for chip components, such as ASIC, NPUs, etc."; |
| |
| container config { |
| description |
| "Configuration data for chip components"; |
| } |
| |
| container state { |
| config false; |
| description |
| "Operational state data for chip components"; |
| } |
| } |
| |
| container backplane { |
| description |
| "Data for backplane components"; |
| |
| container config { |
| description |
| "Configuration data for backplane components"; |
| } |
| |
| container state { |
| config false; |
| description |
| "Operational state data for backplane components"; |
| } |
| } |
| } |
| |
| 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 state { |
| |
| config false; |
| |
| description |
| "Operational state data for each component"; |
| |
| uses platform-component-config; |
| uses platform-component-state; |
| uses platform-component-temp-state; |
| uses platform-component-memory-state; |
| uses platform-component-power-state; |
| } |
| |
| uses platform-component-properties-top; |
| uses platform-subcomponent-ref-top; |
| uses platform-anchors-top; |
| } |
| } |
| } |
| |
| |
| // data definition statements |
| |
| uses platform-component-top; |
| |
| |
| // augments |
| |
| |
| } |