org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.hardware.rev180313

Interface IetfHardwareData

All Superinterfaces:

DataRoot

public interface IetfHardwareData
extends DataRoot

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.

This class represents the following YANG schema fragment defined in module ietf-hardware

 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;
   }
   revision 2018-03-13 {
   }
   feature entity-mib {
   }
   feature hardware-state {
   }
   feature hardware-sensor {
   }
   typedef admin-state {
     type enumeration {
       enum unknown {
         value 1;
       }
       enum locked {
         value 2;
       }
       enum shutting-down {
         value 3;
       }
       enum unlocked {
         value 4;
       }
     }
   }
   typedef oper-state {
     type enumeration {
       enum unknown {
         value 1;
       }
       enum disabled {
         value 2;
       }
       enum enabled {
         value 3;
       }
       enum testing {
         value 4;
       }
     }
   }
   typedef usage-state {
     type enumeration {
       enum unknown {
         value 1;
       }
       enum idle {
         value 2;
       }
       enum active {
         value 3;
       }
       enum busy {
         value 4;
       }
     }
   }
   typedef alarm-state {
     type bits {
       bit unknown {
         position 0;
       }
       bit under-repair {
         position 1;
       }
       bit critical {
         position 2;
       }
       bit major {
         position 3;
       }
       bit minor {
         position 4;
       }
       bit warning {
         position 5;
       }
       bit indeterminate {
         position 6;
       }
     }
   }
   typedef standby-state {
     type enumeration {
       enum unknown {
         value 1;
       }
       enum hot-standby {
         value 2;
       }
       enum cold-standby {
         value 3;
       }
       enum providing-service {
         value 4;
       }
     }
   }
   typedef sensor-value-type {
     type enumeration {
       enum other {
         value 1;
       }
       enum unknown {
         value 2;
       }
       enum volts-AC {
         value 3;
       }
       enum volts-DC {
         value 4;
       }
       enum amperes {
         value 5;
       }
       enum watts {
         value 6;
       }
       enum hertz {
         value 7;
       }
       enum celsius {
         value 8;
       }
       enum percent-RH {
         value 9;
       }
       enum rpm {
         value 10;
       }
       enum cmm {
         value 11;
       }
       enum truth-value {
         value 12;
       }
     }
   }
   typedef sensor-value-scale {
     type enumeration {
       enum yocto {
         value 1;
       }
       enum zepto {
         value 2;
       }
       enum atto {
         value 3;
       }
       enum femto {
         value 4;
       }
       enum pico {
         value 5;
       }
       enum nano {
         value 6;
       }
       enum micro {
         value 7;
       }
       enum milli {
         value 8;
       }
       enum units {
         value 9;
       }
       enum kilo {
         value 10;
       }
       enum mega {
         value 11;
       }
       enum giga {
         value 12;
       }
       enum tera {
         value 13;
       }
       enum peta {
         value 14;
       }
       enum exa {
         value 15;
       }
       enum zetta {
         value 16;
       }
       enum yotta {
         value 17;
       }
     }
   }
   typedef sensor-value-precision {
     type int8 {
       range "-8 .. 9";
     }
   }
   typedef sensor-value {
     type int32 {
       range "-1000000000 .. 1000000000";
     }
   }
   typedef sensor-status {
     type enumeration {
       enum ok {
         value 1;
       }
       enum unavailable {
         value 2;
       }
       enum nonoperational {
         value 3;
       }
     }
   }
   container hardware {
     leaf last-change {
       type yang:date-and-time;
       config false;
     }
     list component {
       key name;
       leaf name {
         type string;
       }
       leaf class {
         type identityref {
           base ianahw:hardware-class;
         }
       }
       leaf physical-index {
         if-feature entity-mib;
         type int32 {
           range 1..2147483647;
         }
         config false;
       }
       leaf description {
         type string;
         config false;
       }
       leaf parent {
         type leafref {
           path ../../component/name;
           require-instance false;
         }
       }
       leaf parent-rel-pos {
         type int32 {
           range "0 .. 2147483647";
         }
       }
       leaf-list contains-child {
         type leafref {
           path ../../component/name;
         }
         config false;
       }
       leaf hardware-rev {
         type string;
         config false;
       }
       leaf firmware-rev {
         type string;
         config false;
       }
       leaf software-rev {
         type string;
         config false;
       }
       leaf serial-num {
         type string;
         config false;
       }
       leaf mfg-name {
         type string;
         config false;
       }
       leaf model-name {
         type string;
         config false;
       }
       leaf alias {
         type string;
       }
       leaf asset-id {
         type string;
       }
       leaf is-fru {
         type boolean;
         config false;
       }
       leaf mfg-date {
         type yang:date-and-time;
         config false;
       }
       leaf-list uri {
         type inet:uri;
       }
       leaf uuid {
         type yang:uuid;
         config false;
       }
       container state {
         if-feature hardware-state;
         leaf state-last-changed {
           type yang:date-and-time;
           config false;
         }
         leaf admin-state {
           type admin-state;
         }
         leaf oper-state {
           type oper-state;
           config false;
         }
         leaf usage-state {
           type usage-state;
           config false;
         }
         leaf alarm-state {
           type alarm-state;
           config false;
         }
         leaf standby-state {
           type standby-state;
           config false;
         }
       }
       container sensor-data {
         when
           "derived-from-or-self(../class,
                                               \"ianahw:sensor\")" {
         }
         if-feature hardware-sensor;
         config false;
         leaf value {
           type sensor-value;
         }
         leaf value-type {
           type sensor-value-type;
         }
         leaf value-scale {
           type sensor-value-scale;
         }
         leaf value-precision {
           type sensor-value-precision;
         }
         leaf oper-status {
           type sensor-status;
         }
         leaf units-display {
           type string;
         }
         leaf value-timestamp {
           type yang:date-and-time;
         }
         leaf value-update-rate {
           type uint32;
           units milliseconds;
         }
       }
     }
   }
   notification hardware-state-change {
   }
   notification hardware-state-oper-enabled {
     if-feature hardware-state;
     leaf name {
       type leafref {
         path /hardware/component/name;
       }
     }
     leaf admin-state {
       type leafref {
         path /hardware/component/state/admin-state;
       }
     }
     leaf alarm-state {
       type leafref {
         path /hardware/component/state/alarm-state;
       }
     }
   }
   notification hardware-state-oper-disabled {
     if-feature hardware-state;
     leaf name {
       type leafref {
         path /hardware/component/name;
       }
     }
     leaf admin-state {
       type leafref {
         path /hardware/component/state/admin-state;
       }
     }
     leaf alarm-state {
       type leafref {
         path /hardware/component/state/alarm-state;
       }
     }
   }
 }
 

Method Summary

Modifier and Type	Method and Description
@Nullable Hardware	getHardware() Data nodes representing components.If the server supports configuration of hardware components,then this data model is instantiated in the configurationdatastores supported by the server.

Method Detail

getHardware

@Nullable Hardware getHardware()

Data nodes representing components.If the server supports configuration of hardware components,then this data model is instantiated in the configurationdatastores supported by the server. The leaf-list 'datastore'for the module 'ietf-hardware' in the YANG library providesthis information.

Returns:

org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.hardware.rev180313.Hardware hardware, or null if not present