X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=ntsimulator%2Fdeploy%2Fsmo-nts-ng-topology-server%2Fyang%2Ftapi-equipment%402020-04-23.yang;fp=ntsimulator%2Fdeploy%2Fsmo-nts-ng-topology-server%2Fyang%2Ftapi-equipment%402020-04-23.yang;h=d99fdea0eabd8e2853221ce7e00ad0b8f3a86c0b;hb=f5b69d55ddd03b4e504efdd33e2047901d3be807;hp=0000000000000000000000000000000000000000;hpb=e85f9a6771693aa11baee5cd48df871da2583f6a;p=sim%2Fo1-interface.git diff --git a/ntsimulator/deploy/smo-nts-ng-topology-server/yang/tapi-equipment@2020-04-23.yang b/ntsimulator/deploy/smo-nts-ng-topology-server/yang/tapi-equipment@2020-04-23.yang new file mode 100644 index 0000000..d99fdea --- /dev/null +++ b/ntsimulator/deploy/smo-nts-ng-topology-server/yang/tapi-equipment@2020-04-23.yang @@ -0,0 +1,731 @@ +module tapi-equipment { + namespace "urn:onf:otcc:yang:tapi-equipment"; + prefix tapi-equipment; + import tapi-common { + prefix tapi-common; + } + import tapi-topology { + prefix tapi-topology; + } + organization "ONF OTCC (Open Transport Configuration & Control) Project"; + contact " + Project Web: + Project List: + Editor: Karthik Sethuraman + Andrea Mazzini + Arturo Mayoral + Nigel Davis "; + description " + This module contains TAPI Equipment Model definitions. + Source: TapiEquipment.uml + - The TAPI YANG models included in this TAPI release are a *normative* part of the TAPI SDK. + - The YANG specifications have been generated from the corresponding UML model using the [ONF EAGLE UML2YANG mapping tool] + + and further edited manually to comply with the [ONF IISOMI UML2YANG mapping guidelines] + + - Status of YANG model artifacts can be determined by referring to the corresponding UML artifacts. + As described in the UML models, some artifacts are considered *experimental*, and thus the corresponding YANG artifacts. + - The ONF TAPI release process does not guarantee backward compatibility of YANG models across major versions of TAPI releases. + The YANG model backward compatibility criteria are outlined in section 11 of . + YANG models included in this release may not be backward compatible with previous TAPI releases. + Copyright (c) 2018 Open Networking Foundation (ONF). All rights reserved. + License: This module is distributed under the Apache License 2.0."; + revision 2020-04-23 { + description "ONF Transport API version 2.1.3. + Changes included in this TAPI release (v2.1.3) are listed in + "; + reference "ONF-TR-527, ONF-TR-512, ONF-TR-531, RFC 7950, RFC 6087 and ONF TAPI UML model + "; + } + revision 2019-07-16 { + description "ONF Transport API version 2.1.2. + Changes included in this TAPI release (v2.1.2) are listed in + "; + reference "ONF-TR-527, ONF-TR-512, ONF-TR-531, RFC 7950, RFC 6087 and ONF TAPI UML model + "; + } + revision 2018-12-10 { + description "ONF Transport API version 2.1.1. + Changes included in this TAPI release (v2.1.1) are listed in + "; + reference "ONF-TR-527, ONF-TR-512, ONF-TR-531, RFC 7950, RFC 6087 and ONF TAPI UML model + "; + } + revision 2018-10-16 { + description "ONF Transport API version 2.1.0. + Changes included in this TAPI release (v2.1.0) are listed in + "; + reference "ONF-TR-527, ONF-TR-512, ONF-TR-531, RFC 7950, RFC 6087 and ONF TAPI UML model + "; + } + revision 2018-03-07 { + description "ONF Transport API version 2.0.2 + This YANG module has been generated from the TAPI UML Model using the IISOMI-Eagle xmi2yang mapping tool. + Changes in this revision: "; + reference "ONF-TR-527, ONF-TR-512, ONF-TR-531, RFC 6020, RFC 6087 and ONF TAPI UML model + "; + } + revision 2018-02-16 { + description "ONF Transport API version 2.0.1 + This YANG module has been generated from the TAPI UML Model using the IISOMI-Eagle xmi2yang mapping tool. + Changes in this revision: "; + reference "ONF-TR-527, ONF-TR-512, ONF-TR-531, RFC 6020, RFC 6087 and ONF TAPI UML model + "; + } + revision 2018-01-02 { + description "ONF Transport API version 2.0.0 + This YANG module has been generated from the TAPI UML Model using the IISOMI-Eagle xmi2yang mapping tool. + Changes in this revision: "; + reference "ONF-TR-527, ONF-TR-512, ONF-TR-531, RFC 6020, RFC 6087 and ONF TAPI UML model + "; + } + augment "/tapi-common:context" { + container physical-context { + uses physical-context; + description "none"; + } + description "none"; + } + augment "/tapi-common:context/tapi-topology:topology-context/tapi-topology:topology/tapi-topology:node" { + container supporting-physical-span { + uses supporting-physical-span; + description "none"; + } + description "none"; + } + augment "/tapi-common:context/tapi-topology:topology-context/tapi-topology:topology/tapi-topology:node/tapi-topology:owned-node-edge-point" { + container supporting-access-port { + uses supporting-access-port; + description "none"; + } + description "none"; + } + /************************** + * definitions of references + **************************/ + grouping device-ref { + leaf device-uuid { + type leafref { + path '/tapi-common:context/tapi-equipment:physical-context/tapi-equipment:device/tapi-equipment:uuid'; + } + description "none"; + } + description "none"; + } + grouping equipment-ref { + uses device-ref; + leaf equipment-uuid { + type leafref { + path '/tapi-common:context/tapi-equipment:physical-context/tapi-equipment:device/tapi-equipment:equipment/tapi-equipment:uuid'; + } + description "none"; + } + description "none"; + } + grouping equipment-holder-ref { + uses equipment-ref; + leaf equipment-holder-uuid { + type leafref { + path '/tapi-common:context/tapi-equipment:physical-context/tapi-equipment:device/tapi-equipment:equipment/tapi-equipment:contained-holder/tapi-equipment:uuid'; + } + description "none"; + } + description "none"; + } + grouping access-port-ref { + uses device-ref; + leaf access-port-uuid { + type leafref { + path '/tapi-common:context/tapi-equipment:physical-context/tapi-equipment:device/tapi-equipment:access-port/tapi-equipment:uuid'; + } + description "none"; + } + description "none"; + } + grouping physical-span-ref { + leaf physical-span-uuid { + type leafref { + path '/tapi-common:context/tapi-equipment:physical-context/tapi-equipment:physical-span/tapi-equipment:uuid'; + } + description "none"; + } + description "none"; + } + grouping abstract-strand-ref { + uses physical-span-ref; + leaf abstract-strand-local-id { + type leafref { + path '/tapi-common:context/tapi-equipment:physical-context/tapi-equipment:physical-span/tapi-equipment:abstract-strand/tapi-equipment:local-id'; + } + description "none"; + } + description "none"; + } + /************************** + * package type-definitions + **************************/ + identity CONNECTOR_AND_PIN_ORIENTATION { + description "none"; + } + identity CONNECTOR_AND_PIN_ORIENTATION_MALE { + base CONNECTOR_AND_PIN_ORIENTATION; + description "The connecting elements are dominantly protrusions."; + } + identity CONNECTOR_AND_PIN_ORIENTATION_FEMALE { + base CONNECTOR_AND_PIN_ORIENTATION; + description "The connecting elements are dominantly indentations."; + } + identity CONNECTOR_AND_PIN_ORIENTATION_SYMMETRIC_NEUTRAL { + base CONNECTOR_AND_PIN_ORIENTATION; + description "The pin (and housing) orientation combination is such that it is symmetric so a connector is compatible with itself. + The connecting element may be a surface rather than protrusions or indentations."; + } + identity EQUIPMENT_CATEGORY { + description "none"; + } + identity EQUIPMENT_CATEGORY_SUBRACK { + base EQUIPMENT_CATEGORY; + description "An assembly with holders designed to accommodate CIRCUIT_PACKs. + The assembly is designed to be mounted in a RACK."; + } + identity EQUIPMENT_CATEGORY_CIRCUIT_PACK { + base EQUIPMENT_CATEGORY; + description "An assembly with connectors compatible with those in a holder. + The assembly is designed to be mounted in a holder (SLOT) of a SUBRACK. + May also support holders (SLOTs) for SMALL_FORMFACTOR_PLUGGABLEs."; + } + identity EQUIPMENT_CATEGORY_SMALL_FORMFACTOR_PLUGGABLE { + base EQUIPMENT_CATEGORY; + description "A small assembly (compared to a CIRCUIT_PACK) with connectors compatible with those in a holder. + The assembly is designed to be mounted in a holder (SLOT) of a CIRCUIT_PACK or STAND_ALONE_UNIT."; + } + identity EQUIPMENT_CATEGORY_STAND_ALONE_UNIT { + base EQUIPMENT_CATEGORY; + description "An assembly with connectors for cabling and potentially with holders. + The assembly is designed to be mounted in a freeform environment (on a table or simple mechanical cabinet). + May support holders (SLOTs) for CIRCUIT_PACKs or for SMALL_FORMFACTOR_PLUGGABLEs."; + } + identity EQUIPMENT_CATEGORY_RACK { + base EQUIPMENT_CATEGORY; + description "A mechanical assembly with cabling and predefined mounting points for particular SUBRACK types. + The assembly is designed to be mounted on the floor in a row with other RACKs."; + } + identity HOLDER_CATEGORY { + description "none"; + } + identity HOLDER_CATEGORY_SLOT { + base HOLDER_CATEGORY; + description "A guided holder with fixed connectors. + The guided holder is designed to take a particular form of CIRCUIT_PACK or SMALL_FORMFACTOR_PLUGGABLE"; + } + identity EQUIPMENT_OBJECT_TYPE { + description "none"; + } + identity EQUIPMENT_OBJECT_TYPE_DEVICE { + base EQUIPMENT_OBJECT_TYPE; + description "none"; + } + identity EQUIPMENT_OBJECT_TYPE_ACCESS_PORT { + base EQUIPMENT_OBJECT_TYPE; + description "none"; + } + identity EQUIPMENT_OBJECT_TYPE_EQUIPMENT { + base EQUIPMENT_OBJECT_TYPE; + description "none"; + } + identity EQUIPMENT_OBJECT_TYPE_HOLDER { + base EQUIPMENT_OBJECT_TYPE; + description "none"; + } + identity EQUIPMENT_OBJECT_TYPE_PHYSICAL_SPAN { + base EQUIPMENT_OBJECT_TYPE; + description "none"; + } + identity EQUIPMENT_OBJECT_TYPE_ABSTRACT_STRAND { + base EQUIPMENT_OBJECT_TYPE; + description "none"; + } + typedef connector-and-pin-orientation { + type identityref { + base CONNECTOR_AND_PIN_ORIENTATION; + } + description "Most connector schemes are asymmetric such that there are two orientations of the connector where a mating is only possible between two connectors of different orientations. + A multi-pin connector may have a mix of pin orientations. In this case, it is expected that the dominant orientation of pin is chosen for the connector orientation."; + } + typedef equipment-category { + type identityref { + base EQUIPMENT_CATEGORY; + } + description "The form of equipment."; + } + typedef holder-category { + type identityref { + base HOLDER_CATEGORY; + } + description "The form of holder."; + } + grouping connector-pin-address { + leaf connector-identification { + type string; + description "Identification of the Connector in the context of the referenced Equipment."; + } + leaf pin-identification { + type string; + description "Where relevant, identification of the Pin in the context of the connector. + Where the whole connector is used, then individual Pins need not be identified. + Simple alternative to pinAndRole."; + } + leaf equipment-uuid { + type tapi-common:uuid; + description "Reference to the Equipment that is fitted with the Connector/Pin."; + } + list pin-and-role { + config false; + uses pin-and-role; + description "If there is more than one pin used in a connector and/or there is a need to identify the role of one or more pins then this property can be used. + For simple cases pinIdentification can be used instead."; + } + description "The identification of the location of the Connector and/or Pin."; + } + grouping actual-equipment { + list actual-non-field-replaceable-module { + config false; + uses actual-non-field-replaceable-module; + description "none"; + } + container common-actual-properties { + config false; + uses common-actual-properties; + description "none"; + } + container common-equipment-properties { + config false; + uses common-equipment-properties; + description "none"; + } + description "The equipment that is actually present in the physical network. + It will expose all dynamic properties and some critical static properties."; + } + grouping actual-holder { + container common-holder-properties { + config false; + uses common-holder-properties; + description "none"; + } + description "A holder in the ActualEquipment."; + } + grouping actual-non-field-replaceable-module { + container common-actual-properties { + config false; + uses common-actual-properties; + description "none"; + } + container common-equipment-properties { + config false; + uses common-equipment-properties; + description "none"; + } + description "A structure that represents an actual equipment that cannot be replaced in the field. + Is simply a subordinate part of an ActualEquipment (FRU). + Does not have any exposed holders (any associated holders are assumed to belong to the containing FRU). + Does not have any connectors (any associated connectors are assumed to belong to the containing FRU). + "; + } + grouping common-actual-properties { + leaf asset-instance-identifier { + type string; + description "This attribute represents the asset identifier of this instance from the manufacturer's perspective."; + } + leaf is-powered { + type boolean; + description "The state of the power being supplied to the equipment. + Note that this attribute summarizes the power state. + Full details on the actual power system would be provided from a number of PC instances representing the relevant parts of the Power function (e.g. different voltage supplies)."; + } + leaf manufacture-date { + type tapi-common:date-and-time; + description "This attribute represents the date on which this instance is manufactured."; + } + leaf serial-number { + type string; + description "This attribute represents the serial number of this instance."; + } + leaf temperature { + type decimal64 { + fraction-digits 7; + } + description "The measured temperature of the Equipment."; + } + description "Properties common to actual Equipment."; + } + grouping common-equipment-properties { + leaf asset-type-identifier { + type string; + description "Represents the invariant properties of the equipment asset allocated by the operator that define and characterize the type."; + } + leaf equipment-type-description { + type string; + description "Text describing the type of Equipment."; + } + leaf equipment-type-identifier { + type string; + description "This attribute identifies the part type of the equipment."; + } + leaf equipment-type-name { + type string; + description "This attribute identifies the type of the equipment."; + } + leaf equipment-type-version { + type string; + description "This attribute identifies the version of the equipment."; + } + leaf manufacturer-identifier { + type string; + description "The formal unique identifier of the manufacturer."; + } + leaf manufacturer-name { + type string; + description "The formal name of the manufacturer of the Equipment."; + } + description "Properties common to all aspects of Equipment."; + } + grouping common-holder-properties { + leaf holder-category { + type holder-category; + description "The type of holder."; + } + leaf is-guided { + type boolean; + description "This attribute indicates whether the holder has guides that constrain the position of the equipment in the holder or not."; + } + leaf holder-location { + type string; + description "The relative position of the holder in the context of its containing equipment along with the position of that containing Equipment (and further recursion)."; + } + description "Properties common to all aspects of Holder."; + } + grouping expected-equipment { + list expected-non-field-replaceable-module { + config false; + uses expected-non-field-replaceable-module; + description "none"; + } + list expected-holder { + config false; + uses expected-holder; + description "none"; + } + container common-equipment-properties { + config false; + uses common-equipment-properties; + description "none"; + } + description "A definition of the restrictions on the equipment that is expected to be present in the physical network at a particular 'place'. + The expected equipment will state the type and may constrain any other invariant properties. + It may also provide desired ranges for dynamic properties."; + } + grouping expected-holder { + container common-holder-properties { + config false; + uses common-holder-properties; + description "none"; + } + description "A definition of a holder expected in the ActualEquipment (i.e. an ActualHolder) as part of the constraints provided by the ExpectedEquipment."; + } + grouping expected-non-field-replaceable-module { + container common-equipment-properties { + config false; + uses common-equipment-properties; + description "none"; + } + description "A structure that represents an expected equipment that cannot be replaced in the field. + Is simply a subordinate part of an ExpectedEquipment (FRU). + Does not have any exposed holders (any associated holders are assumed to belong to the containing FRU). + Does not have any connectors (any associated connectors are assumed to belong to the containing FRU). + "; + } + typedef equipment-object-type { + type identityref { + base EQUIPMENT_OBJECT_TYPE; + } + description "The list of TAPI Equipment Object types/classes."; + } + grouping pin-and-role { + leaf location-in-connector { + type string; + config false; + description "The named location of the pin in the context of the connector. + This is likely to be the normal numbering/naming for the type of connetor, e.g. '7', '6-GND', 'Common' etc."; + } + leaf-list pin-role { + type string; + config false; + description "It is not always necessary to specify a role (or list of roles) as the connector locationInConnector may be sufficient (as these are sometimes clearly role based. + Each entry represents a role in the context of the specific access port. + Each entry ties the pin to a functional element in the associated NEP(s) etc. + For example: + - a pin might carry several distinct signals where each signal is idenitified in the list + - a pin may carry a signal and power + - a signal carried by a pin may be the receive flow (INPUT) to a bidirectional NEP or the transmit flow (OUTPUT) or indeed both (BIDIRECTIONAL)."; + } + leaf pin-name { + type string; + config false; + description "Where the pin has a distinct location identifier and a distinct name this field can be used for the name. + For example: + - locationInConnector = 6, pinName = GND"; + } + description "Provides an opportunity, for a pin, to give the location of the pin and the role of the pin."; + } + + /************************** + * package object-classes + **************************/ + grouping equipment { + list contained-holder { + key 'uuid'; + config false; + uses holder; + description "References the Holder in an Equipment that is available to take other Equipments. + For example: + - Slot in a sub-rack + - Slot in a Field Replaceable Unit that can take a small form-factor pluggable."; + } + leaf category { + type equipment-category; + config false; + description "This attribute provides the identifier for the form of equipments regarded as having particular shared characteristics."; + } + leaf equipment-location { + type string; + config false; + description "none"; + } + leaf geographical-location { + type string; + config false; + description "none"; + } + leaf is-expected-actual-mismatch { + type boolean; + config false; + description "none"; + } + list expected-equipment { + uses expected-equipment; + description "none"; + } + container actual-equipment { + uses actual-equipment; + description "none"; + } + uses tapi-common:global-class; + description "Represents any relevant physical thing. + Can be either field replaceable or not field replaceable. + Note: The model is currently constrained to inside plant."; + } + grouping holder { + container occupying-fru { + uses equipment-ref; + config false; + description "The FRU that is occupying the holder. + A holder may be unoccupied. + An FRU may occupy more hat one holder (using or blocking are intentionally not distinguished here)."; + } + container expected-holder { + config false; + uses expected-holder; + description "none"; + } + container actual-holder { + config false; + uses actual-holder; + description "none"; + } + uses tapi-common:global-class; + description "Represents a space in an equipment in which another equipment can be fitted in the field."; + } + grouping access-port { + list connector-pin { + key 'connector-identification pin-identification equipment-uuid'; + config false; + min-elements 1; + uses connector-pin-address; + description "The list of Pins that support the AccessPort."; + } + uses tapi-common:global-class; + description "A group of pins that together support a signal group where any one pin removed from the group will prevent all signals of the signal group from flowing successfully. + In some cases the AccessPort may simply reference a single connector (e.g., where the pin-connector association is simpe such that the AccessPort references all pinsof one connector)."; + } + grouping physical-span { + list access-port { + uses access-port-ref; + key "device-uuid access-port-uuid"; + config false; + min-elements 2; + max-elements 2; + description "none"; + } + list abstract-strand { + key 'local-id'; + config false; + uses abstract-strand; + description "Both the serial segments that form an end-end strand and the parallel end-end strands."; + } + uses tapi-common:global-class; + description "An adjacency between AccessPorts. + The adjacency is supported by a group of strands between pins of the AccessPorts. + This is a physical abstraction."; + } + grouping abstract-strand { + list adjacent-strand { + uses abstract-strand-ref; + key "physical-span-uuid abstract-strand-local-id"; + config false; + description "none"; + } + list spliced-strand { + uses abstract-strand-ref; + key "physical-span-uuid abstract-strand-local-id"; + config false; + max-elements 2; + description "none"; + } + list connector-pin { + key 'connector-identification pin-identification equipment-uuid'; + config false; + max-elements 2; + uses connector-pin-address; + description "A strand can end on two or more Pins (usually 2 pins, but a strand my be spliced to split a signal). This model supports only 2 ended strands. + A abstract strand may be spliced at both ends and hence have no direct relationship to pins or may be connected to pins at one or both ends. + In the essential model these Pins would be on connectors that plug in to connectors on Equipments. + The AbstractStrand is extended to the pins of the AccessPort which are the Pins on the Connectors of the Equipment. + In some cases it may not be relevant to represent the pin detail and hence the reference is to a connector alone."; + } + list strand-media-characteristics { + key 'value-name'; + config false; + uses tapi-common:name-and-value; + description "Relevant physical properties of the abstract strand."; + } + uses tapi-common:local-class; + description "This object represents an abstraction of one or more strands in series that provides sufficient detail to enable appropriate engineering. + A strand represents a continuous long, thin piece of a medium such as glass fiber or copper wire. + In this model a Strand: + - a strand has two ends + - a splice can only be between 2 strands. + - the end of a strand may have a splice, a connector or be hidden + - only one end can be hidden in an equipment + - where a cable has more than two end each strand only goes between two of the ends + This model does NOT account for multiple copper strands being spliced."; + } + grouping device { + list equipment { + key 'uuid'; + config false; + uses equipment; + description "none"; + } + list access-port { + key 'uuid'; + config false; + uses access-port; + description "none"; + } + uses tapi-common:global-class; + description "A logical grouping of Equipments and AccessPorts that are closely located and form a support a coherent system of related functions."; + } + grouping physical-context { + list device { + key 'uuid'; + config false; + uses device; + description "none"; + } + list physical-span { + key 'uuid'; + config false; + uses physical-span; + description "none"; + } + uses tapi-common:global-class; + description "none"; + } + grouping supporting-physical-span { + container physical-span { + uses physical-span-ref; + description "none"; + } + description "none"; + } + grouping supporting-access-port { + container access-port { + uses access-port-ref; + description "none"; + } + description "none"; + } + + /************************** + * package interfaces + **************************/ + rpc get-device-list { + description "none"; + output { + list device { + key 'uuid'; + uses device; + description "none"; + } + } + } + rpc get-physical-span-list { + description "none"; + output { + list physical-span { + key 'uuid'; + uses physical-span; + description "none"; + } + } + } + rpc get-device { + description "none"; + input { + leaf uuid { + type tapi-common:uuid; + description "UUID: An identifier that is universally unique within an identifier space, where the identifier space is itself globally unique, and immutable. + An UUID carries no semantics with respect to the purpose or state of the entity. + UUID here uses string representation as defined in RFC 4122. The canonical representation uses lowercase characters. + Pattern: [0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-' + '[0-9a-fA-F]{4}-[0-9a-fA-F]{12} + Example of a UUID in string representation: f81d4fae-7dec-11d0-a765-00a0c91e6bf6"; + } + } + output { + container device { + uses device; + description "none"; + } + } + } + rpc get-physical-span { + description "none"; + input { + leaf uuid { + type tapi-common:uuid; + description "UUID: An identifier that is universally unique within an identifier space, where the identifier space is itself globally unique, and immutable. + An UUID carries no semantics with respect to the purpose or state of the entity. + UUID here uses string representation as defined in RFC 4122. The canonical representation uses lowercase characters. + Pattern: [0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-' + '[0-9a-fA-F]{4}-[0-9a-fA-F]{12} + Example of a UUID in string representation: f81d4fae-7dec-11d0-a765-00a0c91e6bf6"; + } + } + output { + container physical-span { + uses physical-span; + description "none"; + } + } + } + +}