| module ietf-hardware-state { |
| yang-version 1.1; |
| namespace "urn:ietf:params:xml:ns:yang:ietf-hardware-state"; |
| prefix hw-state; |
| |
| import ietf-inet-types { |
| prefix inet; |
| } |
| import ietf-yang-types { |
| prefix yang; |
| } |
| import iana-hardware { |
| prefix ianahw; |
| } |
| import ietf-hardware { |
| prefix hw; |
| } |
| |
| organization |
| "IETF NETMOD (Network Modeling) Working Group"; |
| |
| contact |
| "WG Web: <https://datatracker.ietf.org/wg/netmod/> |
| WG List: <mailto:netmod@ietf.org> |
| |
| Editor: Andy Bierman |
| <mailto:andy@yumaworks.com> |
| |
| Editor: Martin Bjorklund |
| <mailto:mbj@tail-f.com> |
| |
| Editor: Jie Dong |
| <mailto:jie.dong@huawei.com> |
| Editor: Dan Romascanu |
| <mailto:dromasca@gmail.com>"; |
| |
| description |
| "This module contains a collection of YANG definitions for |
| monitoring hardware. |
| |
| This data model is designed as a temporary solution for |
| implementations that do not yet support the Network Management |
| Datastore Architecture (NMDA) defined in RFC 8342. Such an |
| implementation cannot implement the module 'ietf-hardware' |
| properly, since without NMDA support, it is not possible to |
| distinguish between instances of nodes in the running |
| configuration and operational states. |
| |
| The data model in this module is the same as the data model in |
| 'ietf-hardware', except all nodes are marked as 'config false'. |
| |
| If a server that implements this module but doesn't support NMDA |
| also supports configuration of hardware components, it SHOULD |
| also implement the module 'ietf-hardware' in the configuration |
| datastores. The corresponding state data is found in the |
| '/hw-state:hardware' subtree. |
| |
| Copyright (c) 2018 IETF Trust and the persons identified as |
| authors of the code. All rights reserved. |
| |
| Redistribution and use in source and binary forms, with or |
| without modification, is permitted pursuant to, and subject |
| to the license terms contained in, the Simplified BSD License |
| set forth in Section 4.c of the IETF Trust's Legal Provisions |
| Relating to IETF Documents |
| (https://trustee.ietf.org/license-info). |
| |
| This version of this YANG module is part of RFC 8348; see |
| the RFC itself for full legal notices."; |
| |
| revision 2018-03-13 { |
| description |
| "Initial revision."; |
| reference |
| "RFC 8348: A YANG Data Model for Hardware Management"; |
| } |
| |
| /* |
| * Features |
| */ |
| |
| feature entity-mib { |
| status deprecated; |
| description |
| "This feature indicates that the device implements |
| the ENTITY-MIB."; |
| reference |
| "RFC 6933: Entity MIB (Version 4)"; |
| } |
| |
| feature hardware-state { |
| status deprecated; |
| description |
| "Indicates that ENTITY-STATE-MIB objects are supported"; |
| reference |
| "RFC 4268: Entity State MIB"; |
| } |
| |
| feature hardware-sensor { |
| status deprecated; |
| description |
| "Indicates that ENTITY-SENSOR-MIB objects are supported"; |
| reference |
| "RFC 3433: Entity Sensor Management Information Base"; |
| } |
| |
| /* |
| * Data nodes |
| */ |
| |
| container hardware { |
| config false; |
| status deprecated; |
| description |
| "Data nodes representing components."; |
| |
| leaf last-change { |
| type yang:date-and-time; |
| status deprecated; |
| description |
| "The time the '/hardware/component' list changed in the |
| operational state."; |
| } |
| |
| list component { |
| key name; |
| status deprecated; |
| description |
| "List of components. |
| When the server detects a new hardware component, it |
| initializes a list entry in the operational state. |
| |
| If the server does not support configuration of hardware |
| components, list entries in the operational state are |
| initialized with values for all nodes as detected by the |
| implementation. |
| |
| Otherwise, this procedure is followed: |
| |
| 1. If there is an entry in the '/hardware/component' list |
| in the intended configuration with values for the nodes |
| 'class', 'parent', and 'parent-rel-pos' that are equal |
| to the detected values, then: |
| |
| 1a. If the configured entry has a value for 'mfg-name' |
| that is equal to the detected value or if the |
| 'mfg-name' value cannot be detected, then the list |
| entry in the operational state is initialized with the |
| configured values for all configured nodes, including |
| the 'name'. |
| |
| Otherwise, the list entry in the operational state is |
| initialized with values for all nodes as detected by |
| the implementation. The implementation may raise an |
| alarm that informs about the 'mfg-name' mismatch |
| condition. How this is done is outside the scope of |
| this document. |
| |
| 1b. Otherwise (i.e., there is no matching configuration |
| entry), the list entry in the operational state is |
| initialized with values for all nodes as detected by |
| the implementation. |
| |
| If the '/hardware/component' list in the intended |
| configuration is modified, then the system MUST behave as if |
| it re-initializes itself and follow the procedure in (1)."; |
| reference |
| "RFC 6933: Entity MIB (Version 4) - entPhysicalEntry"; |
| |
| leaf name { |
| type string; |
| status deprecated; |
| description |
| "The name assigned to this component. |
| |
| This name is not required to be the same as |
| entPhysicalName."; |
| } |
| |
| leaf class { |
| type identityref { |
| base ianahw:hardware-class; |
| } |
| mandatory true; |
| status deprecated; |
| description |
| "An indication of the general hardware type of the |
| component."; |
| reference |
| "RFC 6933: Entity MIB (Version 4) - entPhysicalClass"; |
| } |
| |
| leaf physical-index { |
| if-feature entity-mib; |
| type int32 { |
| range "1..2147483647"; |
| } |
| status deprecated; |
| description |
| "The entPhysicalIndex for the entPhysicalEntry represented |
| by this list entry."; |
| reference |
| "RFC 6933: Entity MIB (Version 4) - entPhysicalIndex"; |
| } |
| |
| leaf description { |
| type string; |
| status deprecated; |
| description |
| "A textual description of the component. This node should |
| contain a string that identifies the manufacturer's name |
| for the component and should be set to a distinct value |
| for each version or model of the component."; |
| reference |
| "RFC 6933: Entity MIB (Version 4) - entPhysicalDescr"; |
| } |
| |
| leaf parent { |
| type leafref { |
| path "../../component/name"; |
| require-instance false; |
| } |
| status deprecated; |
| |
| description |
| "The name of the component that physically contains this |
| component. |
| |
| If this leaf is not instantiated, it indicates that this |
| component is not contained in any other component. |
| |
| In the event that a physical component is contained by |
| more than one physical component (e.g., double-wide |
| modules), this node contains the name of one of these |
| components. An implementation MUST use the same name |
| every time this node is instantiated."; |
| reference |
| "RFC 6933: Entity MIB (Version 4) - |
| entPhysicalContainedIn"; |
| } |
| |
| leaf parent-rel-pos { |
| type int32 { |
| range "0 .. 2147483647"; |
| } |
| status deprecated; |
| description |
| "An indication of the relative position of this child |
| component among all its sibling components. Sibling |
| components are defined as components that: |
| |
| o share the same value of the 'parent' node and |
| |
| o share a common base identity for the 'class' node. |
| |
| Note that the last rule gives implementations flexibility |
| in how components are numbered. For example, some |
| implementations might have a single number series for all |
| components derived from 'ianahw:port', while some others |
| might have different number series for different |
| components with identities derived from 'ianahw:port' (for |
| example, one for RJ45 and one for SFP)."; |
| |
| reference |
| "RFC 6933: Entity MIB (Version 4) - |
| entPhysicalParentRelPos"; |
| } |
| |
| leaf-list contains-child { |
| type leafref { |
| path "../../component/name"; |
| } |
| status deprecated; |
| description |
| "The name of the contained component."; |
| reference |
| "RFC 6933: Entity MIB (Version 4) - entPhysicalChildIndex"; |
| } |
| |
| leaf hardware-rev { |
| type string; |
| status deprecated; |
| description |
| "The vendor-specific hardware revision string for the |
| component. The preferred value is the hardware revision |
| identifier actually printed on the component itself (if |
| present)."; |
| reference |
| "RFC 6933: Entity MIB (Version 4) - |
| entPhysicalHardwareRev"; |
| } |
| |
| leaf firmware-rev { |
| type string; |
| status deprecated; |
| description |
| "The vendor-specific firmware revision string for the |
| component."; |
| reference |
| "RFC 6933: Entity MIB (Version 4) - |
| entPhysicalFirmwareRev"; |
| } |
| |
| leaf software-rev { |
| type string; |
| status deprecated; |
| description |
| "The vendor-specific software revision string for the |
| component."; |
| reference |
| "RFC 6933: Entity MIB (Version 4) - |
| entPhysicalSoftwareRev"; |
| } |
| |
| leaf serial-num { |
| type string; |
| status deprecated; |
| |
| description |
| "The vendor-specific serial number string for the |
| component. The preferred value is the serial number |
| string actually printed on the component itself (if |
| present)."; |
| reference |
| "RFC 6933: Entity MIB (Version 4) - entPhysicalSerialNum"; |
| } |
| |
| leaf mfg-name { |
| type string; |
| status deprecated; |
| description |
| "The name of the manufacturer of this physical component. |
| The preferred value is the manufacturer name string |
| actually printed on the component itself (if present). |
| |
| Note that comparisons between instances of the |
| 'model-name', 'firmware-rev', 'software-rev', and |
| 'serial-num' nodes are only meaningful amongst components |
| with the same value of 'mfg-name'. |
| |
| If the manufacturer name string associated with the |
| physical component is unknown to the server, then this |
| node is not instantiated."; |
| reference |
| "RFC 6933: Entity MIB (Version 4) - entPhysicalMfgName"; |
| } |
| |
| leaf model-name { |
| type string; |
| status deprecated; |
| description |
| "The vendor-specific model name identifier string |
| associated with this physical component. The preferred |
| value is the customer-visible part number, which may be |
| printed on the component itself. |
| |
| If the model name string associated with the physical |
| component is unknown to the server, then this node is not |
| instantiated."; |
| reference |
| "RFC 6933: Entity MIB (Version 4) - entPhysicalModelName"; |
| } |
| |
| leaf alias { |
| type string; |
| status deprecated; |
| description |
| "An 'alias' name for the component, as specified by a |
| network manager, that provides a non-volatile 'handle' for |
| the component. |
| |
| If no configured value exists, the server MAY set the |
| value of this node to a locally unique value in the |
| operational state. |
| |
| A server implementation MAY map this leaf to the |
| entPhysicalAlias MIB object. Such an implementation needs |
| to use some mechanism to handle the differences in size |
| and characters allowed between this leaf and |
| entPhysicalAlias. The definition of such a mechanism is |
| outside the scope of this document."; |
| reference |
| "RFC 6933: Entity MIB (Version 4) - entPhysicalAlias"; |
| } |
| |
| leaf asset-id { |
| type string; |
| status deprecated; |
| description |
| "This node is a user-assigned asset tracking identifier for |
| the component. |
| |
| A server implementation MAY map this leaf to the |
| entPhysicalAssetID MIB object. Such an implementation |
| needs to use some mechanism to handle the differences in |
| size and characters allowed between this leaf and |
| entPhysicalAssetID. The definition of such a mechanism is |
| outside the scope of this document."; |
| reference |
| "RFC 6933: Entity MIB (Version 4) - entPhysicalAssetID"; |
| } |
| |
| leaf is-fru { |
| type boolean; |
| status deprecated; |
| description |
| "This node indicates whether or not this component is |
| considered a 'field-replaceable unit' by the vendor. If |
| this node contains the value 'true', then this component |
| identifies a field-replaceable unit. For all components |
| that are permanently contained within a field-replaceable |
| unit, the value 'false' should be returned for this |
| node."; |
| |
| reference |
| "RFC 6933: Entity MIB (Version 4) - entPhysicalIsFRU"; |
| } |
| |
| leaf mfg-date { |
| type yang:date-and-time; |
| status deprecated; |
| description |
| "The date of manufacturing of the managed component."; |
| reference |
| "RFC 6933: Entity MIB (Version 4) - entPhysicalMfgDate"; |
| } |
| |
| leaf-list uri { |
| type inet:uri; |
| status deprecated; |
| description |
| "This node contains identification information about the |
| component."; |
| reference |
| "RFC 6933: Entity MIB (Version 4) - entPhysicalUris"; |
| } |
| |
| leaf uuid { |
| type yang:uuid; |
| status deprecated; |
| description |
| "A Universally Unique Identifier of the component."; |
| reference |
| "RFC 6933: Entity MIB (Version 4) - entPhysicalUUID"; |
| } |
| |
| container state { |
| if-feature hardware-state; |
| status deprecated; |
| description |
| "State-related nodes"; |
| reference |
| "RFC 4268: Entity State MIB"; |
| |
| leaf state-last-changed { |
| type yang:date-and-time; |
| status deprecated; |
| description |
| "The date and time when the value of any of the |
| admin-state, oper-state, usage-state, alarm-state, or |
| standby-state changed for this component. |
| |
| If there has been no change since the last |
| re-initialization of the local system, this node |
| contains the date and time of local system |
| initialization. If there has been no change since the |
| component was added to the local system, this node |
| contains the date and time of the insertion."; |
| reference |
| "RFC 4268: Entity State MIB - entStateLastChanged"; |
| } |
| |
| leaf admin-state { |
| type hw:admin-state; |
| status deprecated; |
| description |
| "The administrative state for this component. |
| |
| This node refers to a component's administrative |
| permission to service both other components within its |
| containment hierarchy as well as other users of its |
| services defined by means outside the scope of this |
| module. |
| |
| Some components exhibit only a subset of the remaining |
| administrative state values. Some components cannot be |
| locked; hence, this node exhibits only the 'unlocked' |
| state. Other components cannot be shut down gracefully; |
| hence, this node does not exhibit the 'shutting-down' |
| state."; |
| reference |
| "RFC 4268: Entity State MIB - entStateAdmin"; |
| } |
| |
| leaf oper-state { |
| type hw:oper-state; |
| status deprecated; |
| description |
| "The operational state for this component. |
| |
| Note that this node does not follow the administrative |
| state. An administrative state of 'down' does not |
| predict an operational state of 'disabled'. |
| |
| Note that some implementations may not be able to |
| accurately report oper-state while the admin-state node |
| has a value other than 'unlocked'. In these cases, this |
| node MUST have a value of 'unknown'."; |
| reference |
| "RFC 4268: Entity State MIB - entStateOper"; |
| } |
| |
| leaf usage-state { |
| type hw:usage-state; |
| status deprecated; |
| description |
| "The usage state for this component. |
| |
| This node refers to a component's ability to service |
| more components in a containment hierarchy. |
| |
| Some components will exhibit only a subset of the usage |
| state values. Components that are unable to ever |
| service any components within a containment hierarchy |
| will always have a usage state of 'busy'. In some |
| cases, a component will be able to support only one |
| other component within its containment hierarchy and |
| will therefore only exhibit values of 'idle' and |
| 'busy'."; |
| reference |
| "RFC 4268: Entity State MIB - entStateUsage"; |
| } |
| |
| leaf alarm-state { |
| type hw:alarm-state; |
| status deprecated; |
| description |
| "The alarm state for this component. It does not |
| include the alarms raised on child components within its |
| containment hierarchy."; |
| reference |
| "RFC 4268: Entity State MIB - entStateAlarm"; |
| } |
| |
| leaf standby-state { |
| type hw:standby-state; |
| status deprecated; |
| description |
| "The standby state for this component. |
| |
| Some components will exhibit only a subset of the |
| remaining standby state values. If this component |
| cannot operate in a standby role, the value of this node |
| will always be 'providing-service'."; |
| reference |
| "RFC 4268: Entity State MIB - entStateStandby"; |
| } |
| } |
| container sensor-data { |
| when 'derived-from-or-self(../class, |
| "ianahw:sensor")' { |
| description |
| "Sensor data nodes present for any component of type |
| 'sensor'"; |
| } |
| if-feature hardware-sensor; |
| status deprecated; |
| |
| description |
| "Sensor-related nodes."; |
| reference |
| "RFC 3433: Entity Sensor Management Information Base"; |
| |
| leaf value { |
| type hw:sensor-value; |
| status deprecated; |
| description |
| "The most recent measurement obtained by the server |
| for this sensor. |
| |
| A client that periodically fetches this node should also |
| fetch the nodes 'value-type', 'value-scale', and |
| 'value-precision', since they may change when the value |
| is changed."; |
| reference |
| "RFC 3433: Entity Sensor Management Information Base - |
| entPhySensorValue"; |
| } |
| |
| leaf value-type { |
| type hw:sensor-value-type; |
| status deprecated; |
| description |
| "The type of data units associated with the |
| sensor value"; |
| reference |
| "RFC 3433: Entity Sensor Management Information Base - |
| entPhySensorType"; |
| } |
| |
| leaf value-scale { |
| type hw:sensor-value-scale; |
| status deprecated; |
| description |
| "The (power of 10) scaling factor associated |
| with the sensor value"; |
| reference |
| "RFC 3433: Entity Sensor Management Information Base - |
| entPhySensorScale"; |
| } |
| |
| leaf value-precision { |
| type hw:sensor-value-precision; |
| status deprecated; |
| description |
| "The number of decimal places of precision |
| associated with the sensor value"; |
| reference |
| "RFC 3433: Entity Sensor Management Information Base - |
| entPhySensorPrecision"; |
| } |
| |
| leaf oper-status { |
| type hw:sensor-status; |
| status deprecated; |
| description |
| "The operational status of the sensor."; |
| reference |
| "RFC 3433: Entity Sensor Management Information Base - |
| entPhySensorOperStatus"; |
| } |
| |
| leaf units-display { |
| type string; |
| status deprecated; |
| description |
| "A textual description of the data units that should be |
| used in the display of the sensor value."; |
| reference |
| "RFC 3433: Entity Sensor Management Information Base - |
| entPhySensorUnitsDisplay"; |
| } |
| |
| leaf value-timestamp { |
| type yang:date-and-time; |
| status deprecated; |
| description |
| "The time the status and/or value of this sensor was last |
| obtained by the server."; |
| reference |
| "RFC 3433: Entity Sensor Management Information Base - |
| entPhySensorValueTimeStamp"; |
| } |
| |
| leaf value-update-rate { |
| type uint32; |
| units "milliseconds"; |
| status deprecated; |
| description |
| "An indication of the frequency that the server updates |
| the associated 'value' node, represented in |
| milliseconds. The value zero indicates: |
| |
| - the sensor value is updated on demand (e.g., |
| when polled by the server for a get-request), |
| |
| - the sensor value is updated when the sensor |
| value changes (event-driven), or |
| |
| - the server does not know the update rate."; |
| reference |
| "RFC 3433: Entity Sensor Management Information Base - |
| entPhySensorValueUpdateRate"; |
| } |
| } |
| } |
| } |
| |
| /* |
| * Notifications |
| */ |
| |
| notification hardware-state-change { |
| status deprecated; |
| description |
| "A hardware-state-change notification is generated when the |
| value of /hardware/last-change changes in the operational |
| state."; |
| reference |
| "RFC 6933: Entity MIB (Version 4) - entConfigChange"; |
| } |
| |
| notification hardware-state-oper-enabled { |
| if-feature hardware-state; |
| status deprecated; |
| description |
| "A hardware-state-oper-enabled notification signifies that a |
| component has transitioned into the 'enabled' state."; |
| |
| leaf name { |
| type leafref { |
| path "/hardware/component/name"; |
| } |
| status deprecated; |
| description |
| "The name of the component that has transitioned into the |
| 'enabled' state."; |
| } |
| leaf admin-state { |
| type leafref { |
| path "/hardware/component/state/admin-state"; |
| } |
| status deprecated; |
| description |
| "The administrative state for the component."; |
| } |
| leaf alarm-state { |
| type leafref { |
| path "/hardware/component/state/alarm-state"; |
| } |
| status deprecated; |
| description |
| "The alarm state for the component."; |
| } |
| reference |
| "RFC 4268: Entity State MIB - entStateOperEnabled"; |
| } |
| |
| notification hardware-state-oper-disabled { |
| if-feature hardware-state; |
| status deprecated; |
| description |
| "A hardware-state-oper-disabled notification signifies that a |
| component has transitioned into the 'disabled' state."; |
| |
| leaf name { |
| type leafref { |
| path "/hardware/component/name"; |
| } |
| status deprecated; |
| description |
| "The name of the component that has transitioned into the |
| 'disabled' state."; |
| } |
| leaf admin-state { |
| type leafref { |
| path "/hardware/component/state/admin-state"; |
| } |
| status deprecated; |
| |
| description |
| "The administrative state for the component."; |
| } |
| leaf alarm-state { |
| type leafref { |
| path "/hardware/component/state/alarm-state"; |
| } |
| status deprecated; |
| description |
| "The alarm state for the component."; |
| } |
| reference |
| "RFC 4268: Entity State MIB - entStateOperDisabled"; |
| } |
| |
| } |