Teodora
dd8a6eaaf5
Ideally, we should load the yang models from the RU operational datastore, but the issues are following: 1) the yang models order is not good - dependancy models have to be loaded first 2) earlier O-RAN yang versions (e.g. v4) is not properly defined (i.e. optional parameters should not be included by default) Added support in both cases, loading from RU with <get-schema> RPC, and loading statically from "radio/fhi_72/mplane/yang/models" folder.
1142 lines
34 KiB
YANG
Executable File
1142 lines
34 KiB
YANG
Executable File
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";
|
|
}
|
|
|
|
}
|