| module ietf-hardware { |
| yang-version 1.1; |
| namespace "urn:ietf:params:xml:ns:yang:ietf-hardware"; |
| prefix hw; |
| |
| import ietf-inet-types { |
| prefix inet; |
| } |
| import ietf-yang-types { |
| prefix yang; |
| } |
| import iana-hardware { |
| prefix ianahw; |
| } |
| |
| 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 |
| managing hardware. |
| |
| This data model is designed for the Network Management Datastore |
| Architecture (NMDA) defined in RFC 8342. |
| 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 { |
| description |
| "This feature indicates that the device implements |
| the ENTITY-MIB."; |
| reference |
| "RFC 6933: Entity MIB (Version 4)"; |
| } |
| |
| feature hardware-state { |
| description |
| "Indicates that ENTITY-STATE-MIB objects are supported"; |
| reference |
| "RFC 4268: Entity State MIB"; |
| } |
| |
| feature hardware-sensor { |
| description |
| "Indicates that ENTITY-SENSOR-MIB objects are supported"; |
| reference |
| "RFC 3433: Entity Sensor Management Information Base"; |
| } |
| |
| /* |
| * Typedefs |
| */ |
| |
| typedef admin-state { |
| type enumeration { |
| enum unknown { |
| value 1; |
| description |
| "The resource is unable to report administrative state."; |
| } |
| enum locked { |
| value 2; |
| description |
| "The resource is administratively prohibited from use."; |
| } |
| enum shutting-down { |
| value 3; |
| description |
| "The resource usage is administratively limited to current |
| instances of use."; |
| } |
| enum unlocked { |
| value 4; |
| description |
| "The resource is not administratively prohibited from |
| use."; |
| } |
| } |
| description |
| "Represents the various possible administrative states."; |
| reference |
| "RFC 4268: Entity State MIB - EntityAdminState"; |
| } |
| |
| typedef oper-state { |
| type enumeration { |
| enum unknown { |
| value 1; |
| description |
| "The resource is unable to report its operational state."; |
| } |
| enum disabled { |
| value 2; |
| description |
| "The resource is totally inoperable."; |
| } |
| enum enabled { |
| value 3; |
| |
| description |
| "The resource is partially or fully operable."; |
| } |
| enum testing { |
| value 4; |
| description |
| "The resource is currently being tested and cannot |
| therefore report whether or not it is operational."; |
| } |
| } |
| description |
| "Represents the possible values of operational states."; |
| reference |
| "RFC 4268: Entity State MIB - EntityOperState"; |
| } |
| |
| typedef usage-state { |
| type enumeration { |
| enum unknown { |
| value 1; |
| description |
| "The resource is unable to report usage state."; |
| } |
| enum idle { |
| value 2; |
| description |
| "The resource is servicing no users."; |
| } |
| enum active { |
| value 3; |
| description |
| "The resource is currently in use, and it has sufficient |
| spare capacity to provide for additional users."; |
| } |
| enum busy { |
| value 4; |
| description |
| "The resource is currently in use, but it currently has no |
| spare capacity to provide for additional users."; |
| } |
| } |
| description |
| "Represents the possible values of usage states."; |
| reference |
| "RFC 4268: Entity State MIB - EntityUsageState"; |
| } |
| |
| typedef alarm-state { |
| type bits { |
| bit unknown { |
| position 0; |
| description |
| "The resource is unable to report alarm state."; |
| } |
| bit under-repair { |
| position 1; |
| description |
| "The resource is currently being repaired, which, depending |
| on the implementation, may make the other values in this |
| bit string not meaningful."; |
| } |
| bit critical { |
| position 2; |
| description |
| "One or more critical alarms are active against the |
| resource."; |
| } |
| bit major { |
| position 3; |
| description |
| "One or more major alarms are active against the |
| resource."; |
| } |
| bit minor { |
| position 4; |
| description |
| "One or more minor alarms are active against the |
| resource."; |
| } |
| bit warning { |
| position 5; |
| description |
| "One or more warning alarms are active against the |
| resource."; |
| } |
| bit indeterminate { |
| position 6; |
| description |
| "One or more alarms of whose perceived severity cannot be |
| determined are active against this resource."; |
| } |
| } |
| description |
| "Represents the possible values of alarm states. An alarm is a |
| persistent indication of an error or warning condition. |
| |
| When no bits of this attribute are set, then no active alarms |
| are known against this component and it is not under repair."; |
| reference |
| "RFC 4268: Entity State MIB - EntityAlarmStatus"; |
| } |
| |
| typedef standby-state { |
| type enumeration { |
| enum unknown { |
| value 1; |
| description |
| "The resource is unable to report standby state."; |
| } |
| enum hot-standby { |
| value 2; |
| description |
| "The resource is not providing service, but it will be |
| immediately able to take over the role of the resource to |
| be backed up, without the need for initialization |
| activity, and will contain the same information as the |
| resource to be backed up."; |
| } |
| enum cold-standby { |
| value 3; |
| description |
| "The resource is to back up another resource, but it will |
| not be immediately able to take over the role of a |
| resource to be backed up and will require some |
| initialization activity."; |
| } |
| enum providing-service { |
| value 4; |
| description |
| "The resource is providing service."; |
| } |
| } |
| description |
| "Represents the possible values of standby states."; |
| reference |
| "RFC 4268: Entity State MIB - EntityStandbyStatus"; |
| } |
| |
| typedef sensor-value-type { |
| type enumeration { |
| enum other { |
| value 1; |
| description |
| "A measure other than those listed below."; |
| } |
| enum unknown { |
| value 2; |
| description |
| "An unknown measurement or arbitrary, relative numbers"; |
| } |
| enum volts-AC { |
| value 3; |
| description |
| "A measure of electric potential (alternating current)."; |
| } |
| enum volts-DC { |
| value 4; |
| description |
| "A measure of electric potential (direct current)."; |
| } |
| enum amperes { |
| value 5; |
| description |
| "A measure of electric current."; |
| } |
| enum watts { |
| value 6; |
| description |
| "A measure of power."; |
| } |
| enum hertz { |
| value 7; |
| description |
| "A measure of frequency."; |
| } |
| enum celsius { |
| value 8; |
| description |
| "A measure of temperature."; |
| } |
| enum percent-RH { |
| value 9; |
| description |
| "A measure of percent relative humidity."; |
| } |
| enum rpm { |
| value 10; |
| description |
| "A measure of shaft revolutions per minute."; |
| } |
| enum cmm { |
| value 11; |
| description |
| "A measure of cubic meters per minute (airflow)."; |
| } |
| enum truth-value { |
| value 12; |
| description |
| "Value is one of 1 (true) or 2 (false)"; |
| } |
| } |
| description |
| "A node using this data type represents the sensor measurement |
| data type associated with a physical sensor value. The actual |
| data units are determined by examining a node of this type |
| together with the associated sensor-value-scale node. |
| |
| A node of this type SHOULD be defined together with nodes of |
| type sensor-value-scale and type sensor-value-precision. |
| These three types are used to identify the semantics of a node |
| of type sensor-value."; |
| reference |
| "RFC 3433: Entity Sensor Management Information Base - |
| EntitySensorDataType"; |
| } |
| |
| typedef sensor-value-scale { |
| type enumeration { |
| enum yocto { |
| value 1; |
| description |
| "Data scaling factor of 10^-24."; |
| } |
| enum zepto { |
| value 2; |
| description |
| "Data scaling factor of 10^-21."; |
| } |
| enum atto { |
| value 3; |
| description |
| "Data scaling factor of 10^-18."; |
| } |
| enum femto { |
| value 4; |
| description |
| "Data scaling factor of 10^-15."; |
| } |
| enum pico { |
| value 5; |
| description |
| "Data scaling factor of 10^-12."; |
| } |
| enum nano { |
| value 6; |
| description |
| "Data scaling factor of 10^-9."; |
| } |
| enum micro { |
| value 7; |
| description |
| "Data scaling factor of 10^-6."; |
| } |
| enum milli { |
| value 8; |
| description |
| "Data scaling factor of 10^-3."; |
| } |
| enum units { |
| value 9; |
| description |
| "Data scaling factor of 10^0."; |
| } |
| enum kilo { |
| value 10; |
| description |
| "Data scaling factor of 10^3."; |
| } |
| enum mega { |
| value 11; |
| description |
| "Data scaling factor of 10^6."; |
| } |
| enum giga { |
| value 12; |
| description |
| "Data scaling factor of 10^9."; |
| } |
| enum tera { |
| value 13; |
| description |
| "Data scaling factor of 10^12."; |
| } |
| enum peta { |
| value 14; |
| description |
| "Data scaling factor of 10^15."; |
| } |
| enum exa { |
| value 15; |
| description |
| "Data scaling factor of 10^18."; |
| } |
| enum zetta { |
| value 16; |
| description |
| "Data scaling factor of 10^21."; |
| } |
| enum yotta { |
| value 17; |
| description |
| "Data scaling factor of 10^24."; |
| } |
| } |
| description |
| "A node using this data type represents a data scaling factor, |
| represented with an International System of Units (SI) prefix. |
| The actual data units are determined by examining a node of |
| this type together with the associated sensor-value-type. |
| |
| A node of this type SHOULD be defined together with nodes of |
| type sensor-value-type and type sensor-value-precision. |
| Together, associated nodes of these three types are used to |
| identify the semantics of a node of type sensor-value."; |
| reference |
| "RFC 3433: Entity Sensor Management Information Base - |
| EntitySensorDataScale"; |
| } |
| |
| typedef sensor-value-precision { |
| type int8 { |
| range "-8 .. 9"; |
| } |
| description |
| "A node using this data type represents a sensor value |
| precision range. |
| |
| A node of this type SHOULD be defined together with nodes of |
| type sensor-value-type and type sensor-value-scale. Together, |
| associated nodes of these three types are used to identify the |
| semantics of a node of type sensor-value. |
| |
| If a node of this type contains a value in the range 1 to 9, |
| it represents the number of decimal places in the fractional |
| part of an associated sensor-value fixed-point number. |
| |
| If a node of this type contains a value in the range -8 to -1, |
| it represents the number of accurate digits in the associated |
| sensor-value fixed-point number. |
| |
| The value zero indicates the associated sensor-value node is |
| not a fixed-point number. |
| |
| Server implementers must choose a value for the associated |
| sensor-value-precision node so that the precision and accuracy |
| of the associated sensor-value node is correctly indicated. |
| |
| For example, a component representing a temperature sensor |
| that can measure 0 to 100 degrees C in 0.1 degree |
| increments, +/- 0.05 degrees, would have a |
| sensor-value-precision value of '1', a sensor-value-scale |
| value of 'units', and a sensor-value ranging from '0' to |
| '1000'. The sensor-value would be interpreted as |
| 'degrees C * 10'."; |
| reference |
| "RFC 3433: Entity Sensor Management Information Base - |
| EntitySensorPrecision"; |
| } |
| |
| typedef sensor-value { |
| type int32 { |
| range "-1000000000 .. 1000000000"; |
| } |
| description |
| "A node using this data type represents a sensor value. |
| |
| A node of this type SHOULD be defined together with nodes of |
| type sensor-value-type, type sensor-value-scale, and |
| type sensor-value-precision. Together, associated nodes of |
| those three types are used to identify the semantics of a node |
| of this data type. |
| |
| The semantics of a node using this data type are determined by |
| the value of the associated sensor-value-type node. |
| |
| If the associated sensor-value-type node is equal to 'voltsAC', |
| 'voltsDC', 'amperes', 'watts', 'hertz', 'celsius', or 'cmm', |
| then a node of this type MUST contain a fixed-point number |
| ranging from -999,999,999 to +999,999,999. The value |
| -1000000000 indicates an underflow error. The value |
| +1000000000 indicates an overflow error. The |
| sensor-value-precision indicates how many fractional digits |
| are represented in the associated sensor-value node. |
| |
| If the associated sensor-value-type node is equal to |
| 'percentRH', then a node of this type MUST contain a number |
| ranging from 0 to 100. |
| |
| If the associated sensor-value-type node is equal to 'rpm', |
| then a node of this type MUST contain a number ranging from |
| -999,999,999 to +999,999,999. |
| |
| If the associated sensor-value-type node is equal to |
| 'truth-value', then a node of this type MUST contain either the |
| value 1 (true) or the value 2 (false). |
| |
| If the associated sensor-value-type node is equal to 'other' or |
| 'unknown', then a node of this type MUST contain a number |
| ranging from -1000000000 to 1000000000."; |
| reference |
| "RFC 3433: Entity Sensor Management Information Base - |
| EntitySensorValue"; |
| } |
| |
| typedef sensor-status { |
| type enumeration { |
| enum ok { |
| value 1; |
| description |
| "Indicates that the server can obtain the sensor value."; |
| } |
| enum unavailable { |
| value 2; |
| description |
| "Indicates that the server presently cannot obtain the |
| sensor value."; |
| } |
| enum nonoperational { |
| value 3; |
| description |
| "Indicates that the server believes the sensor is broken. |
| The sensor could have a hard failure (disconnected wire) |
| or a soft failure such as out-of-range, jittery, or wildly |
| fluctuating readings."; |
| } |
| } |
| description |
| "A node using this data type represents the operational status |
| of a physical sensor."; |
| reference |
| "RFC 3433: Entity Sensor Management Information Base - |
| EntitySensorStatus"; |
| } |
| |
| /* |
| * Data nodes |
| */ |
| |
| container hardware { |
| description |
| "Data nodes representing components. |
| |
| If the server supports configuration of hardware components, |
| then this data model is instantiated in the configuration |
| datastores supported by the server. The leaf-list 'datastore' |
| for the module 'ietf-hardware' in the YANG library provides |
| this information."; |
| |
| leaf last-change { |
| type yang:date-and-time; |
| config false; |
| description |
| "The time the '/hardware/component' list changed in the |
| operational state."; |
| } |
| |
| list component { |
| key name; |
| 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 the list entry in the |
| operational state is initialized with the configured |
| values, including the 'name'. |
| |
| 2. 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; |
| 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; |
| 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"; |
| } |
| config false; |
| description |
| "The entPhysicalIndex for the entPhysicalEntry represented |
| by this list entry."; |
| reference |
| "RFC 6933: Entity MIB (Version 4) - entPhysicalIndex"; |
| } |
| |
| leaf description { |
| type string; |
| config false; |
| 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; |
| } |
| 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"; |
| } |
| 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 registered jack 45 (RJ45) and one for |
| small form-factor pluggable (SFP))."; |
| |
| reference |
| "RFC 6933: Entity MIB (Version 4) - |
| entPhysicalParentRelPos"; |
| } |
| |
| leaf-list contains-child { |
| type leafref { |
| path "../../component/name"; |
| } |
| config false; |
| description |
| "The name of the contained component."; |
| reference |
| "RFC 6933: Entity MIB (Version 4) - entPhysicalChildIndex"; |
| } |
| |
| leaf hardware-rev { |
| type string; |
| config false; |
| 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; |
| config false; |
| description |
| "The vendor-specific firmware revision string for the |
| component."; |
| reference |
| "RFC 6933: Entity MIB (Version 4) - |
| entPhysicalFirmwareRev"; |
| } |
| |
| leaf software-rev { |
| type string; |
| config false; |
| |
| description |
| "The vendor-specific software revision string for the |
| component."; |
| reference |
| "RFC 6933: Entity MIB (Version 4) - |
| entPhysicalSoftwareRev"; |
| } |
| |
| leaf serial-num { |
| type string; |
| config false; |
| 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; |
| config false; |
| 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; |
| config false; |
| 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; |
| 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; |
| 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; |
| config false; |
| |
| 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; |
| config false; |
| description |
| "The date of manufacturing of the managed component."; |
| reference |
| "RFC 6933: Entity MIB (Version 4) - entPhysicalMfgDate"; |
| } |
| |
| leaf-list uri { |
| type inet:uri; |
| description |
| "This node contains identification information about the |
| component."; |
| reference |
| "RFC 6933: Entity MIB (Version 4) - entPhysicalUris"; |
| } |
| |
| leaf uuid { |
| type yang:uuid; |
| config false; |
| description |
| "A Universally Unique Identifier of the component."; |
| reference |
| "RFC 6933: Entity MIB (Version 4) - entPhysicalUUID"; |
| } |
| |
| container state { |
| if-feature hardware-state; |
| description |
| "State-related nodes"; |
| reference |
| "RFC 4268: Entity State MIB"; |
| |
| leaf state-last-changed { |
| type yang:date-and-time; |
| config false; |
| 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 admin-state; |
| 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 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 oper-state; |
| config false; |
| 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 usage-state; |
| config false; |
| 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 alarm-state; |
| config false; |
| 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 standby-state; |
| config false; |
| 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; |
| config false; |
| |
| description |
| "Sensor-related nodes."; |
| reference |
| "RFC 3433: Entity Sensor Management Information Base"; |
| |
| leaf value { |
| type sensor-value; |
| 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 sensor-value-type; |
| description |
| "The type of data units associated with the |
| sensor value"; |
| reference |
| "RFC 3433: Entity Sensor Management Information Base - |
| entPhySensorType"; |
| } |
| leaf value-scale { |
| type sensor-value-scale; |
| 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 sensor-value-precision; |
| 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 sensor-status; |
| description |
| "The operational status of the sensor."; |
| reference |
| "RFC 3433: Entity Sensor Management Information Base - |
| entPhySensorOperStatus"; |
| } |
| |
| leaf units-display { |
| type string; |
| 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; |
| 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"; |
| 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 { |
| 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; |
| 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"; |
| } |
| |
| description |
| "The name of the component that has transitioned into the |
| 'enabled' state."; |
| } |
| leaf admin-state { |
| type leafref { |
| path "/hardware/component/state/admin-state"; |
| } |
| description |
| "The administrative state for the component."; |
| } |
| leaf alarm-state { |
| type leafref { |
| path "/hardware/component/state/alarm-state"; |
| } |
| description |
| "The alarm state for the component."; |
| } |
| reference |
| "RFC 4268: Entity State MIB - entStateOperEnabled"; |
| } |
| |
| notification hardware-state-oper-disabled { |
| if-feature hardware-state; |
| 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"; |
| } |
| description |
| "The name of the component that has transitioned into the |
| 'disabled' state."; |
| } |
| leaf admin-state { |
| type leafref { |
| path "/hardware/component/state/admin-state"; |
| } |
| description |
| "The administrative state for the component."; |
| } |
| leaf alarm-state { |
| type leafref { |
| path "/hardware/component/state/alarm-state"; |
| } |
| |
| description |
| "The alarm state for the component."; |
| } |
| reference |
| "RFC 4268: Entity State MIB - entStateOperDisabled"; |
| } |
| |
| } |