module tapi-connectivity { yang-version "1.1"; namespace "urn:onf:otcc:yang:tapi-connectivity"; prefix tapi-connectivity; import tapi-common { prefix tapi-common; revision-date 2022-11-21; } import tapi-topology { prefix tapi-topology; revision-date 2022-11-21; } import tapi-path-computation { prefix tapi-path-computation; revision-date 2022-11-21; } import tapi-streaming { prefix tapi-streaming; revision-date 2022-11-21; } import tapi-notification { prefix tapi-notification; revision-date 2022-11-21; } organization "ONF OTCC (Open Transport Configuration & Control) Project"; contact " Project Web: Project List: Editor: Karthik Sethuraman Andrea Mazzini Arturo Mayoral Nigel Davis Ramon Casellas "; description " This module contains TAPI Connectivity Model definitions. Source: TapiConnectivity.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) 2022 Open Networking Foundation (ONF). All rights reserved. License: This module is distributed under the Apache License 2.0."; revision 2022-11-21 { description "ONF Transport API version 2.4.0 RC1. Changes included in this TAPI release (v2.4.0) are listed in "; reference "ONF-TR-527, ONF-TR-512, ONF-TR-531, RFC 7950, RFC 6087 and ONF TAPI UML model "; } revision 2021-09-24 { description "ONF Transport API version 2.3.1. Changes included in this TAPI release (v2.3.1) are listed in "; reference "ONF-TR-527, ONF-TR-512, ONF-TR-531, RFC 7950, RFC 6087 and ONF TAPI UML model "; } revision 2021-08-04 { description "ONF Transport API version 2.3. Changes included in this TAPI release (v2.3) are listed in "; reference "ONF-TR-527, ONF-TR-512, ONF-TR-531, RFC 7950, RFC 6087 and ONF TAPI UML model "; } revision 2021-05-24 { description "ONF Transport API version 2.3 RC1. Changes included in this TAPI release (v2.3) are listed in "; reference "ONF-TR-527, ONF-TR-512, ONF-TR-531, RFC 7950, RFC 6087 and ONF TAPI UML model "; } 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 2019-03-31 { description "ONF Transport API version 2.2-RC1. Changes included in this TAPI release (v2.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 connectivity-context { uses connectivity-context; description "Augments the base TAPI Context with ConnectivityContext model."; } description "Augments the base TAPI Context with ConnectivityContext model."; } augment "/tapi-common:context/tapi-topology:topology-context/tapi-topology:topology/tapi-topology:node/tapi-topology:owned-node-edge-point" { container cep-list { uses cep-list; description "This augment allows NEP to refer to its CEPs despite TapiTopology model does not import TapiConnectivity model."; } description "This augment allows NEP to refer to its CEPs despite TapiTopology model does not import TapiConnectivity model."; } augment "/tapi-streaming:stream-record/tapi-streaming:log-record/tapi-streaming:log-record-body" { when 'derived-from-or-self(tapi-streaming:record-content, "CONNECTIVITY_OBJECT_TYPE_CONNECTION")'; container connection { uses connection; description "none"; } description "none"; } augment "/tapi-streaming:stream-record/tapi-streaming:log-record/tapi-streaming:log-record-body" { when 'derived-from-or-self(tapi-streaming:record-content, "CONNECTIVITY_OBJECT_TYPE_CONNECTION_END_POINT")'; container connection-end-point { uses connection-end-point; description "none"; } description "none"; } augment "/tapi-streaming:stream-record/tapi-streaming:log-record/tapi-streaming:log-record-body" { when 'derived-from-or-self(tapi-streaming:record-content, "CONNECTIVITY_OBJECT_TYPE_CONNECTIVITY_SERVICE")'; container connectivity-service { uses connectivity-service; description "none"; } description "none"; } augment "/tapi-streaming:stream-record/tapi-streaming:log-record/tapi-streaming:log-record-body" { when 'derived-from-or-self(tapi-streaming:record-content, "CONNECTIVITY_OBJECT_TYPE_CONNECTIVITY_SERVICE_END_POINT")'; container connectivity-service-end-point { uses connectivity-service-end-point; description "none"; } description "none"; } augment "/tapi-streaming:stream-record/tapi-streaming:log-record/tapi-streaming:log-record-body" { when 'derived-from-or-self(tapi-streaming:record-content, "CONNECTIVITY_OBJECT_TYPE_ROUTE")'; container route { uses route; description "none"; } description "none"; } augment "/tapi-streaming:stream-record/tapi-streaming:log-record/tapi-streaming:log-record-body" { when 'derived-from-or-self(tapi-streaming:record-content, "CONNECTIVITY_OBJECT_TYPE_SWITCH")'; container switch { uses switch; description "none"; } description "none"; } augment "/tapi-common:context/tapi-notification:notification-context/tapi-notification:event-notification" { when 'derived-from-or-self(tapi-notification:target-object-type, "CONNECTIVITY_OBJECT_TYPE_CONNECTIVITY_SERVICE")'; container connectivity-service { uses connectivity-service; description "none"; } description "none"; } augment "/tapi-common:context/tapi-notification:notification-context/tapi-notification:event-notification" { when 'derived-from-or-self(tapi-notification:target-object-type, "CONNECTIVITY_OBJECT_TYPE_CONNECTIVITY_SERVICE_END_POINT")'; container connectivity-service-end-point { uses connectivity-service-end-point; description "none"; } description "none"; } augment "/tapi-common:context/tapi-notification:notification-context/tapi-notification:event-notification" { when 'derived-from-or-self(tapi-notification:target-object-type, "CONNECTIVITY_OBJECT_TYPE_CONNECTION")'; container connection { uses connection; description "none"; } description "none"; } augment "/tapi-common:context/tapi-notification:notification-context/tapi-notification:event-notification" { when 'derived-from-or-self(tapi-notification:target-object-type, "CONNECTIVITY_OBJECT_TYPE_CONNECTION_END_POINT")'; container connection-end-point { uses connection-end-point; description "none"; } description "none"; } augment "/tapi-common:context/tapi-notification:notification-context/tapi-notification:event-notification" { when 'derived-from-or-self(tapi-notification:target-object-type, "CONNECTIVITY_OBJECT_TYPE_ROUTE")'; container route { uses route; description "none"; } description "none"; } augment "/tapi-common:context/tapi-notification:notification-context/tapi-notification:event-notification" { when 'derived-from-or-self(tapi-notification:target-object-type, "CONNECTIVITY_OBJECT_TYPE_SWITCH")'; container switch { uses switch; description "none"; } description "none"; } augment "/tapi-common:context/tapi-notification:notification-context/tapi-notification:event-notification" { when 'derived-from-or-self(tapi-notification:target-object-type, "CONNECTIVITY_OBJECT_TYPE_SWITCH_CONTROL")'; container switch-control { uses switch-control; description "none"; } description "none"; } augment "/tapi-notification:event-notification" { when 'derived-from-or-self(tapi-notification:target-object-type, "CONNECTIVITY_OBJECT_TYPE_CONNECTIVITY_SERVICE")'; container connectivity-service { uses connectivity-service; description "none"; } description "none"; } augment "/tapi-notification:event-notification" { when 'derived-from-or-self(tapi-notification:target-object-type, "CONNECTIVITY_OBJECT_TYPE_CONNECTIVITY_SERVICE_END_POINT")'; container connectivity-service-end-point { uses connectivity-service-end-point; description "none"; } description "none"; } augment "/tapi-notification:event-notification" { when 'derived-from-or-self(tapi-notification:target-object-type, "CONNECTIVITY_OBJECT_TYPE_CONNECTION")'; container connection { uses connection; description "none"; } description "none"; } augment "/tapi-notification:event-notification" { when 'derived-from-or-self(tapi-notification:target-object-type, "CONNECTIVITY_OBJECT_TYPE_ROUTE")'; container route { uses route; description "none"; } description "none"; } augment "/tapi-notification:event-notification" { when 'derived-from-or-self(tapi-notification:target-object-type, "CONNECTIVITY_OBJECT_TYPE_SWITCH")'; container switch { uses switch; description "none"; } description "none"; } augment "/tapi-notification:event-notification" { when 'derived-from-or-self(tapi-notification:target-object-type, "CONNECTIVITY_OBJECT_TYPE_SWITCH_CONTROL")'; container switch-control { uses switch-control; description "none"; } description "none"; } augment "/tapi-streaming:stream-record/tapi-streaming:log-record/tapi-streaming:log-record-body" { when 'derived-from-or-self(tapi-streaming:record-content, "CONNECTIVITY_OBJECT_TYPE_SWITCH_CONTROL")'; container switch-control { uses switch-control; description "none"; } description "none"; } augment "/tapi-notification:event-notification" { when 'derived-from-or-self(tapi-notification:target-object-type, "CONNECTIVITY_OBJECT_TYPE_CONNECTION_END_POINT")'; container connection-end-point { uses connection-end-point; description "none"; } description "none"; } /************************** * definitions of references **************************/ grouping connectivity-service-ref { leaf connectivity-service-uuid { type leafref { path '/tapi-common:context/tapi-connectivity:connectivity-context/tapi-connectivity:connectivity-service/tapi-connectivity:uuid'; } description "none"; } description "none"; } grouping connectivity-service-end-point-ref { uses connectivity-service-ref; leaf connectivity-service-end-point-local-id { type leafref { path '/tapi-common:context/tapi-connectivity:connectivity-context/tapi-connectivity:connectivity-service/tapi-connectivity:end-point/tapi-connectivity:local-id'; } description "none"; } description "none"; } grouping connectivity-service-internal-point-ref { uses connectivity-service-ref; leaf connectivity-service-internal-point-local-id { type leafref { path '/tapi-common:context/tapi-connectivity:connectivity-context/tapi-connectivity:connectivity-service/tapi-connectivity:internal-point/tapi-connectivity:local-id'; } description "none"; } description "none"; } grouping connection-end-point-ref { uses tapi-topology:node-edge-point-ref; leaf connection-end-point-uuid { type leafref { path '/tapi-common:context/tapi-topology:topology-context/tapi-topology:topology/tapi-topology:node/tapi-topology:owned-node-edge-point/tapi-connectivity:cep-list/tapi-connectivity:connection-end-point/tapi-connectivity:uuid'; } description "none"; } description "none"; } grouping connection-ref { leaf connection-uuid { type leafref { path '/tapi-common:context/tapi-connectivity:connectivity-context/tapi-connectivity:connection/tapi-connectivity:uuid'; require-instance false; } description "The require-instance statement is used as a workaround to enable write operation on a data node that refers to a read only list item. Furthermore a referenced instance of a Connection may be deleted by the TAPI Server, leaving a dangling reference. Implementations shall deal with this case."; } description "none"; } grouping switch-control-ref { uses connection-ref; leaf switch-control-uuid { type leafref { path '/tapi-common:context/tapi-connectivity:connectivity-context/tapi-connectivity:connection/tapi-connectivity:switch-control/tapi-connectivity:uuid'; } description "none"; } description "none"; } grouping route-ref { uses connection-ref; leaf route-local-id { type leafref { path '/tapi-common:context/tapi-connectivity:connectivity-context/tapi-connectivity:connection/tapi-connectivity:route/tapi-connectivity:local-id'; } description "none"; } description "none"; } /************************** * package object-classes **************************/ grouping connection { leaf layer-protocol-name { type tapi-common:layer-protocol-name; config false; description "The layer protocol of the Connection."; } leaf layer-protocol-qualifier { type tapi-common:layer-protocol-qualifier; description "none"; } leaf direction { type tapi-common:forwarding-direction; config false; description "The forwarding direction of the Connection."; } list connection-end-point { uses connection-end-point-ref; key 'topology-uuid node-uuid node-edge-point-uuid connection-end-point-uuid'; config false; min-elements 2; description "The ConnectionEndPoint (CEP) instances of the Connection."; } list lower-connection { uses connection-ref; key 'connection-uuid'; config false; description "A Connection supports a recursive aggregation relationship such that the internal construction of a Connection can be exposed as multiple lower level Connection objects (partitioning). Aggregation is used as for the Node/Topology to allow changes in hierarchy. Connection aggregation reflects Node/Topology aggregation. Note that a cross-connection in a switch matrix (i.e., a fabric) is not necessarily the lowest level of Connection partitioning."; } list server-connection { uses connection-ref; key 'connection-uuid'; config false; description "The server layer Connections supporting this Connection."; } list supported-client-link { uses tapi-topology:link-ref; key 'topology-uuid link-uuid'; config false; description "A Connection instance supports one or more Link instances. G.800: 'The links in a client layer network are supported by trails in a server layer network'."; } container bounding-node { uses tapi-topology:node-ref; config false; description "A Connection may or may not be bounded by a Node, which defines the forwarding scope."; } list route { key 'local-id'; config false; uses route; description "The Route instances of the Connection."; } list switch-control { key 'uuid'; config false; uses switch-control; description "The SwitchControl instances associated to the Connection."; } container connection-spec-reference { config false; uses connection-spec-reference; description "Provides the reference to the spec that defines the connection type and cepRoles."; } uses tapi-common:global-class; uses tapi-common:operational-state-pac; description "A Connection represents an enabled (provisioned) potential for forwarding (of transport characteristic information including all circuit/packet forms) between two or more ConnectionEndPoint instances. The bounding Node of a Connection may be explicit or be conceptually implicit. The Connection is a container for provisioned connectivity that tracks the state of the allocated resources and is distinct from the ConnectivityService. At the lowest level of recursion, a Connection may represent a cross-connection in a switch matrix (i.e., a fabric) in an equipment."; } grouping connection-end-point { leaf layer-protocol-name { type tapi-common:layer-protocol-name; config false; description "The layer protocol of the ConnectionEndPoint (CEP)."; } leaf layer-protocol-qualifier { type tapi-common:layer-protocol-qualifier; config false; description "The layer protocol qualifier of the ConnectionEndPoint (CEP)."; } leaf direction { type tapi-common:direction; config false; description "The CEP direction."; } leaf connection-port-role { type tapi-common:port-role; config false; description "The role of the (conceptual) port of the associated Connection."; } leaf protection-role { type protection-role; config false; description "The protection role of the (conceptual) port of the associated Connection. It is recommended the alignment with the priority of ResilienceRoute."; } list cep-role { key 'role-name'; config false; uses cep-role; description "Defines the role of the CEP in the context of the Connection spec. There may be many CEP role - Connection spec combinations for a particular CEP where each corresponds to a specific Connection associated with the CEP."; } leaf termination-state { type tapi-common:termination-state; config false; description "none"; } list client-node-edge-point { uses tapi-topology:node-edge-point-ref; key 'topology-uuid node-uuid node-edge-point-uuid'; config false; description "The supported NodeEdgePoint instance(s)."; } list aggregated-connection-end-point { uses connection-end-point-ref; key 'topology-uuid node-uuid node-edge-point-uuid connection-end-point-uuid'; config false; description "A ConnectionEndPoint (CEP) instance may aggregate one or more other CEP instances for e.g. pooling purposes, when a set of CEP instances are equivalent for usage."; } container parent-node-edge-point { uses tapi-topology:node-edge-point-ref; config false; description "The supporting NodeEdgePoint (NEP) instance."; } list profile { uses tapi-common:profile-ref; key 'profile-uuid'; config false; description "none"; } list sink-profile { uses tapi-common:profile-ref; key 'profile-uuid'; config false; description "none"; } list source-profile { uses tapi-common:profile-ref; key 'profile-uuid'; config false; description "none"; } uses tapi-common:global-class; uses tapi-common:operational-state-pac; description "The ConnectionEndPoint (CEP) encapsulates information related to a Connection at the ingress/egress points of every Node that the Connection traverses in a Topology. The CEP includes the termination and adaptation functions of one or more transport layers (circuit and packet forms) plus the information of the (conceptual) port of associated Connection."; } grouping connectivity-constraint { leaf service-type { type service-type; description "The ConnectivityService type."; } leaf service-level { type string; description "Class of Service Name. An abstract value the meaning of which is mutually agreed - typically represents metrics such as - Class of service, priority, resiliency, availability."; } container requested-capacity { uses tapi-common:capacity; description "The ConnectivityService capacity."; } container schedule { uses tapi-common:time-range; description "The ConnectivityService timing."; } container coroute-inclusion { uses connectivity-service-ref; description "The reference to another ConnectivityService instance for corouting purposes."; } list diversity-exclusion { uses connectivity-service-ref; key 'connectivity-service-uuid'; description "The references to other ConnectivityService instances for routing diversity purposes."; } list connection-inclusion { uses connection-ref; key 'connection-uuid'; description "A ConnectivityService may use one or more existing Connections. A common traditional strategy is to set up 'stranded' connectivity in the core of the network as 'express channels' (this is essentially a serial compound link, but can be treated as simple connections). A Connection inclusion capability allows for adoption of discovered Connections, i.e. will allow discovered Connections with no stated intent to be associated with an intent via the ConnectivityService. A ConnectivityService is requested with a Connection inclusion constraint that identifies a Connection (or chain of Connections) that is bounded by CEPs that each belong to a NEP that references a SIP that is referenced by a CSEP of the ConnectivityService such that all CSEPs are satisfied by CEPs of the existing Connection. The type is generic UUID given read/write constraints, the Connection is a readonly node."; } list connection-exclusion { uses connection-ref; key 'connection-uuid'; description "The list of Connection instances which shall not be used to implement the ConnectivityService. The type is generic UUID given read/write constraints, the Connection is a readonly node."; } description "The connectivity constraints associated to a ConnectivityService instance."; } grouping connectivity-service { leaf layer-protocol-name { type tapi-common:layer-protocol-name; description "The layer protocol of the CS."; } leaf layer-protocol-qualifier { type tapi-common:layer-protocol-qualifier; description "The layer protocol qualifier of the CS."; } leaf direction { type tapi-common:forwarding-direction; description "The forwarding direction of the ConnectivityService."; } list end-point { key 'local-id'; min-elements 2; uses connectivity-service-end-point; description "The ConnectivityServiceEndPoint (CSEP) instances of the ConnectivityService."; } container connectivity-constraint { uses connectivity-constraint; description "The associated connectivity constraints."; } container routing-constraint { uses tapi-path-computation:routing-constraint; description "The associated routing constraints."; } list topology-constraint { key 'local-id'; uses tapi-path-computation:topology-constraint; description "The associated topology constraints. Different instances of TopologyConstraints may be used to specify constraints at different layer networks."; } container resilience-constraint { uses resilience-constraint; description "The associated resilience constraints."; } list connection { uses connection-ref; key 'connection-uuid'; config false; description "The Connection instance(s) tracking the state of the allocated resources for the support of the ConnectivityService."; } list connectivity-service { uses connectivity-service-ref; key 'connectivity-service-uuid'; description "Association to other ConnectivityService instances for complex connectivity provisioning."; } list internal-point { key 'local-id'; uses connectivity-service-internal-point; description "The ConnectivityServiceInternalPoint (CSIP) instances of the ConnectivityService."; } uses tapi-common:global-class; uses tapi-common:admin-state-pac; description "A ConnectivityService represents an intent-like request for connectivity between two or more ConnectivityServiceEndPoint (CSEP) instances. The ConnectivityService is a container for connectivity request details and is distinct from the Connection(s) that realize the request."; } grouping connectivity-service-end-point { leaf layer-protocol-name { type tapi-common:layer-protocol-name; description "The layer protocol of the ConnectivityServiceEndPoint (CSEP)."; } leaf layer-protocol-qualifier { type tapi-common:layer-protocol-qualifier; description "The layer protocol qualifier of the ConnectivityServiceEndPoint (CSEP)."; } leaf direction { type tapi-common:direction; description "The CSEP direction. It is intended the 'internal viewpoint', i.e. the source CSEP is sending to the network, the sink CSEP is sending from the network."; } leaf role { type tapi-common:port-role; description "The role of the (conceptual) port of the associated ConnectivityService. "; } leaf protection-role { type protection-role; description "The protection role of the (conceptual) port of the associated ConnectivityService. It is recommended the alignment with the priority of ResilienceRoute."; } list csep-role { key 'role-name'; config false; uses csep-role; description "Defines the role of the CSEP in the context of the Connectivity Service spec. There may be many CSEP role - CS spec combinations for a particular CSEP where each corresponds to a specific Connectivity Service associated with the CSEP."; } container capacity { uses tapi-common:capacity; description "The ConnectivityServiceEndPoint (CSEP) capacity."; } container service-interface-point { uses tapi-common:service-interface-point-ref; description "The supporting ServiceInterfacePoint (SIP) instance."; } list connection-end-point { uses connection-end-point-ref; key 'topology-uuid node-uuid node-edge-point-uuid connection-end-point-uuid'; config false; description "The associated ConnectionEndPoint (CEP) instances."; } container peer-fwd-connectivity-service-end-point { uses connectivity-service-end-point-ref; description "The associated ConnectivityServiceEndPoint (CSEP) instance from forwarding perspective."; } container server-connectivity-service-end-point { uses connectivity-service-end-point-ref; description "The associated ConnectivityServiceEndPoint (CSEP) instance at a server layer protocol (qualifier)."; } container protecting-connectivity-service-end-point { uses connectivity-service-end-point-ref; description "The associated ConnectivityServiceEndPoint (CSEP) instance from resilience perspective."; } list assembled-connectivity-service-end-point { uses connectivity-service-end-point-ref; key 'connectivity-service-uuid connectivity-service-end-point-local-id'; description "The associated ConnectivityServiceEndPoint (CSEP) instances from assembling perspective, e.g. in inverse multiplexing schemes."; } list layer-protocol-constraint { key 'local-id'; uses layer-protocol-constraint; description "The constraints applicable at specific layers."; } list profile { uses tapi-common:profile-ref; key 'profile-uuid'; description "none"; } list sink-profile { uses tapi-common:profile-ref; key 'profile-uuid'; description "none"; } list source-profile { uses tapi-common:profile-ref; key 'profile-uuid'; description "none"; } uses tapi-common:local-class; uses tapi-common:admin-state-pac; description "The ConnectivityServiceEndPoint (CSEP) encapsulates information related to a ConnectivityService at the ingress/egress points of that ConnectivityService."; } grouping route { container resilience-route { uses resilience-route; description "Provides optional resilience and state attributes to the Route."; } list connection-end-point { uses connection-end-point-ref; key 'topology-uuid node-uuid node-edge-point-uuid connection-end-point-uuid'; config false; min-elements 2; description "The ConnectionEndPoint (CEP) instances composing the Route."; } uses tapi-common:local-class; description "The Route of a Connection is modeled as a collection of ConnectionEndPoint (CEP) instances. The logical order of the ConnectionEndPoint (CEP) instances within the Route object can be inferred by the TAPI client by the knowledge of the topology information."; } grouping connectivity-context { list connectivity-service { key 'uuid'; uses connectivity-service; description "The included ConnectivityService instances."; } list connection { key 'uuid'; config false; uses connection; description "The included Connection instances."; } description "This object class represents the scope of control that a particular SDN controller has with respect to a particular network, specifically regarding the connectivity description. An instance of this class includes its ConnectivityService and Connection object instances."; } grouping switch { list selected-connection-end-point { uses connection-end-point-ref; key 'topology-uuid node-uuid node-edge-point-uuid connection-end-point-uuid'; config false; min-elements 1; description "The ConnectionEndPoint (CEP) instance(s) which is (are) currently selected for traffic flow."; } list selected-route { uses route-ref; key 'connection-uuid route-local-id'; config false; min-elements 1; description "The Route instance(s) which is (are) currently selected for traffic flow."; } leaf selection-reason { type selection-reason; config false; description "The reason for the current switch selection."; } leaf switch-direction { type tapi-common:direction; description "Sink direction is intended from the unreliable to reliable CEPs. Source direction is the reverse."; } uses tapi-common:local-class; description "The class models the switched forwarding of traffic (traffic flow) between (conceptual) ports of resilient forwarding entities (e.g. resilient ConnectivityService, resilient Connection), these ports being mapped to ConnectionEndPoint (CEP) instances. A resilient forwarding entity may have two or more (conceptual) ports that provide alternative identical inputs/outputs, and one or more associated Switch instances to represent the alternative flow choices visible at the edge of the forwarding entity. The Switch instance represents and defines a protection switch structure conceptually encapsulated in the forwarding entity. The Switch instance essentially performs one of the functions of the Protection Group in a traditional model. It associates to 2 or more (conceptual) ports each playing the role of a Protection Unit. One or more protection, i.e. standby/backup, conceptual ports provide protection for one or more working (i.e. regular/main/preferred) ports where either protection or working can feed one or more protected port. The switch may be used in revertive or non-revertive (symmetric) mode. When in revertive mode it may define a waitToRestore time. It may be used in one of several modes including source switch, destination switched, source and destination switched, etc. (covering cases such as 1+1 and 1:1). It may be locked out (prevented from switching), force switched or manual switched. It will indicate switch state and change of state. The Switch can be switched away from all sources such that it becomes open and hence two coordinated switches can both feed the same (conceptual) port or CEP so long as at least one of the two is switched away from all sources (is 'open'). The ability for a Switch to be 'high impedance' allows bidirectional forwarding entities to be overlaid on the same bidirectional CEP where the appropriate control is enabled to prevent signal conflict. This ability allows multiple alternate routes to be present that otherwise would be in conflict."; } grouping switch-control { list sub-switch-control { uses switch-control-ref; key 'connection-uuid switch-control-uuid'; config false; description "Recursive association to represents hierarchical schemes."; } list switch { key 'local-id'; uses switch; description "The Switch instances composing the protection scheme."; } container control-parameters { uses resilience-constraint; description "The parameters of the protection scheme."; } uses tapi-common:global-class; description "Represents the capability to control and coordinate Switch instances, to add/delete/modify Connections and to add/delete/modify CEPs so as to realize a protection scheme."; } grouping resilience-constraint { container resilience-type { uses tapi-topology:resilience-type; description "The type of resiliency (protection/restoration)."; } leaf restoration-coordinate-type { type coordinate-type; description " The coordination mechanism between protection/restoration operations across multiple layers."; } leaf fault-condition-determination { type fault-condition-determination; description "The types of the determinations of a fault condition on a serial compound link connection within the protected domain. Ref: G.808 Amendment 1 (03/2018)"; } leaf restore-priority { type uint64; description "0 highest priority, 1 lower, etc."; } leaf set-up-priority { type uint64; description "The priority with respect to other possible concurrent requests. 0 highest priority, 1 lower, etc."; } leaf reversion-mode { type reversion-mode; description "Indicates whether the protection/restoration scheme is revertive or non-revertive."; } container wait-to-revert-time { uses tapi-common:time-period; description "If the protection/restoration scheme is revertive, this attribute specifies the time to wait after a fault clears on a higher priority (preferred) resource before reverting to the preferred resource."; } leaf hold-off-time { type uint64; description "This attribute indicates the time, in milliseconds, between declaration of signal degrade or signal fail, and the initialization of the protection/restoration switching algorithm."; } leaf is-lock-out { type boolean; description "The resource is configured to temporarily not be available for use in the protection/restoration scheme(s) it is part of. This overrides all other control states including e.g. 'forced'. If the item is locked out then it cannot be used under any circumstances. Note: Only relevant when part of a protection/restoration scheme."; } leaf is-frozen { type boolean; description "Temporarily prevents any switch action to be taken and, as such, freezes the current state of the protection/restoration scheme. Until the freeze is cleared, additional near-end external commands are rejected and fault condition changes and signalling (e,g, received APS messages) are ignored. All administrative controls of any aspect of the protection/restoration scheme are rejected."; } leaf is-coordinated-switching-both-ends { type boolean; description "Is operating such that the switching at both ends of each flow across the resilient forwarding entity (e.g. ConnectivityService or Connection) is coordinated at both ingress and egress ends."; } leaf max-switch-times { type uint64; description "Used to limit the maximum switch times. When the impairment on preferred/intended resource disappears and traffic returns to the preferred/intended resource, switch counter reset."; } leaf-list preferred-restoration-layer { type tapi-common:layer-protocol-name; description "Indicates which layer protocol this resilience parameters package is configured for."; } leaf selection-control { type selection-control; description "Degree of administrative control applied to the switch selection."; } list resiliency-route-constraint { key 'local-id'; uses resiliency-route-constraint; description "The associated constraints related to resiliency routes."; } description "The parameters of a protection/restoration scheme of a ConnectivityService or Connection."; } grouping cep-list { list connection-end-point { key 'uuid'; uses connection-end-point; description "The list of supported ConnectionEndPoint (CEP) instances."; } description "This class provides the linkage between the NodeEdgePoint (NEP) instance and its supported ConnectionEndPoint CEP instances. The NEP class, which is defined in TapiTopology module, cannot directly include the reference to its CEPs, because CEP class is defined in another module, TapiConnectivity."; } grouping resilience-route { leaf route-state { type route-state; config false; description "Current information on the route selection."; } leaf priority { type uint64; config false; description "Value of 0 (zero) means 'unspecified priority'. Highest priority is 1, sometimes referred as 'preferred' or 'main' or 'intended' route. 2 has lower priority than 1, 3 has lower priority than 2, etc. It is recommended the alignment with the protectionRole of CEP/CSEP."; } description "This object adds resilience and state attributes to the Route. When this object is not present, then the Route is intended as 'current' Route of the Connection."; } grouping resiliency-route-constraint { leaf priority { type uint64; description "Value of 0 (zero) means 'unspecified priority'. Highest priority is 1, sometimes referred as 'preferred' or 'main' or 'intended' route. 2 has lower priority than 1, 3 has lower priority than 2, etc."; } container routing-constraint { uses tapi-path-computation:routing-constraint; description "The associated routing constraints."; } container topology-constraint { uses tapi-path-computation:topology-constraint; description "The associated topology constraints."; } uses tapi-common:local-class; description "The constraints related to the Resiliency route."; } grouping connectivity-service-internal-point { leaf layer-protocol-name { type tapi-common:layer-protocol-name; description "The layer protocol of the ConnectivityServiceInternalPoint (CSIP)."; } leaf layer-protocol-qualifier { type tapi-common:layer-protocol-qualifier; description "The layer protocol qualifier of the ConnectivityServiceInternalPoint (CSIP)."; } list connection-end-point { uses connection-end-point-ref; key 'topology-uuid node-uuid node-edge-point-uuid connection-end-point-uuid'; config false; description "The associated ConnectionEndPoint (CEP) instances."; } container node-edge-point { uses tapi-topology:node-edge-point-ref; config false; description "The supporting NodeEdgePoint (NEP) instance."; } uses tapi-common:local-class; description "Experimental class for complex/detailed provisioning schemes."; } grouping layer-protocol-constraint { leaf layer-protocol-name { type tapi-common:layer-protocol-name; description "none"; } leaf layer-protocol-qualifier { type tapi-common:layer-protocol-qualifier; description "none"; } uses tapi-common:local-class; description "LayerProtocolConstraint allows to specify constraints at any layer, by allowing the technology specific augmentations of the generic CSEP."; } /************************** * package type-definitions **************************/ identity FAULT_CONDITION_DETERMINATION { description "none"; } identity FAULT_CONDITION_DETERMINATION_INHERENT { base FAULT_CONDITION_DETERMINATION; description "Inherent monitored (/I): The fault condition status of each link connection is derived from the status of the underlying server layer trail."; } identity FAULT_CONDITION_DETERMINATION_NON_INTRUSIVE { base FAULT_CONDITION_DETERMINATION; description "Non-intrusive monitored (/N): Each serial compound link connection is extended with a non-intrusive monitoring termination sink function to derive the fault condition status from the traffic signal that is present."; } identity FAULT_CONDITION_DETERMINATION_SUBLAYER { base FAULT_CONDITION_DETERMINATION; description "Sublayer monitored (/S): Each serial compound link connection is extended with tandem connection monitoring or segment termination/adaptation functions to derive the fault condition status independent of the traffic signal present."; } identity FAULT_CONDITION_DETERMINATION_TEST { base FAULT_CONDITION_DETERMINATION; description "Test monitored (/T): Each serial compound link connection's fault condition status is derived from an additional monitored serial compound link connection transported via the same serial compound link."; } identity CONNECTIVITY_OBJECT_TYPE { base tapi-common:OBJECT_TYPE; description "none"; } identity CONNECTIVITY_OBJECT_TYPE_CONNECTIVITY_SERVICE { base CONNECTIVITY_OBJECT_TYPE; description "The ConnectivityService class."; } identity CONNECTIVITY_OBJECT_TYPE_CONNECTIVITY_SERVICE_END_POINT { base CONNECTIVITY_OBJECT_TYPE; description "The ConnectivityServiceEndPoint (CSEP) class."; } identity CONNECTIVITY_OBJECT_TYPE_CONNECTION { base CONNECTIVITY_OBJECT_TYPE; description "The Connection class."; } identity CONNECTIVITY_OBJECT_TYPE_CONNECTION_END_POINT { base CONNECTIVITY_OBJECT_TYPE; description "The ConnectionEndPoint (CEP) class."; } identity CONNECTIVITY_OBJECT_TYPE_SWITCH_CONTROL { base CONNECTIVITY_OBJECT_TYPE; description "The SwitchControl class."; } identity CONNECTIVITY_OBJECT_TYPE_SWITCH { base CONNECTIVITY_OBJECT_TYPE; description "The Switch class."; } identity CONNECTIVITY_OBJECT_TYPE_ROUTE { base CONNECTIVITY_OBJECT_TYPE; description "The Route class."; } identity CONNECTIVITY_OBJECT_TYPE_RESILIENCE_CONSTRAINT { base CONNECTIVITY_OBJECT_TYPE; description "The ResilienceConstraint class."; } identity CONNECTIVITY_OBJECT_TYPE_RESILIENCE_ROUTE { base CONNECTIVITY_OBJECT_TYPE; description "The ResilienceRoute class."; } identity CONNECTIVITY_OBJECT_TYPE_RESILIENCE_ROUTE_CONSTRAINT { base CONNECTIVITY_OBJECT_TYPE; description "The ResilienceRouteConstraint class."; } identity CONNECTIVITY_OBJECT_TYPE_LAYER_PROTOCOL_CONSTRAINT { base CONNECTIVITY_OBJECT_TYPE; description "The ServerConstraint class."; } identity ROUTE_STATE { description "none"; } identity ROUTE_STATE_CURRENT { base ROUTE_STATE; description "The Route instance identified is the current Route, i.e., is the one that is active and selected to support service."; } identity ROUTE_STATE_NOT_CURRENT { base ROUTE_STATE; description "The Route instance is not the one supporting the service."; } identity ROUTE_STATE_UNKNOWN { base ROUTE_STATE; description "The Route state is unknown."; } typedef service-type { type enumeration { enum POINT_TO_POINT_CONNECTIVITY { description "Point to point."; } enum POINT_TO_MULTIPOINT_CONNECTIVITY { description "Point to multipoint."; } enum MULTIPOINT_CONNECTIVITY { description "Multipoint to multipoint."; } enum ROOTED_MULTIPOINT_CONNECTIVITY { description "Rooted multipoint."; } } description "List of simple connectivity types."; } typedef reversion-mode { type enumeration { enum REVERTIVE { description "A Connection switched to a lower priority (non-preferred/spare/protection) resource will revert to a higher priority (preferred/intended/nominal) resource when that recovers (potentially after some wait-to-revert-time)."; } enum NON_REVERTIVE { description "A Connection switched to a lower priority (non-preferred/spare/protection) resource will not revert to a higher priority (preferred/intended/nominal) resource when that recovers. This mode is typically applied when there is no ranking between the redundant resources."; } } description "The reversion mode associated with protection scheme."; } typedef selection-control { type enumeration { enum LOCK_OUT { description "The resource is configured to temporarily not be available for use in the protection/restoration scheme(s) it is part of. This overrides all other protection/restoration control states including 'forced'. If the item is locked out then it cannot be used under any circumstances. Note: Only relevant when part of a protection/restoration scheme."; } enum NORMAL { description "Remove of any previous administrative command."; } enum MANUAL { description "The traffic is temporarily switched to the spare/protection resource, unless it is in a fault condition state. Note: Only relevant when part of a protection/restoration scheme."; } enum FORCED { description "The traffic is temporarily switched to the spare/protection resource, regardless its fault condition state. Note: Only relevant when part of a protection/restoration scheme."; } } description "Possible degrees of administrative control applied to the Route selection."; } typedef selection-reason { type enumeration { enum LOCKOUT { description "A 'lockout' administrative command has been issued."; } enum NORMAL { description "No administrative command currently issued."; } enum MANUAL { description "A 'manual' administrative command has been issued."; } enum FORCED { description "A 'forced' administrative command has been issued."; } enum WAIT_TO_REVERT { description "The scheme is waiting for reversion to preferred/intended/nominal resource."; } enum SIGNAL_DEGRADE { description "A 'signal degrade' condition is active."; } enum SIGNAL_FAIL { description "A 'signal fail' condition is active."; } } description "The cause of the current Route selection."; } typedef coordinate-type { type enumeration { enum NO_COORDINATE { description "No coordination, i.e. each layer network restores independently."; } enum HOLD_OFF_TIME { description "The client layer network protection/restoration process is suspended for a certain time to possibly allow server layer network to protect/restore, avoiding useless multi-layer protection/restoration. It is assumed that the server layer network successful protection/restoration operation will inherently cancel the protection/restoration trigger at client layer."; } enum WAIT_FOR_NOTIFICATION { description "The client layer network protection/restoration process is suspended until a notification is received from the server layer protection/restoration process. The notification should inform about the success or failure of the protection/restoration process at server layer."; } } description " The types of coordination mechanisms between protection/restoration operations across multiple layers."; } typedef protection-role { type enumeration { enum WORK { description "The unreliable/unprotected resource is assumed to be the preferred/intended/nominal/highest priority for usage. "; } enum PROTECT { description "The unreliable/unprotected resource is assumed to be the spare/protection of a higher priority resource. "; } enum PROTECTED { description "The resource which is reliable/protected/resilient by the protection/restoration scheme. "; } enum NA { description "Protection role not applicable to the resource."; } enum WORK_RESTORE { description "The unreliable/unprotected resource is assumed to be the preferred/intended/nominal/highest priority for usage. Revertive behavior."; } enum PROTECT_RESTORE { description "The unreliable/unprotected resource is assumed to be the spare/protection of a higher priority resource. Revertive behavior."; } } description "The protection role of a (conceptual) port of a forwarding entity, e.g. Link, ConnectivityService, Connection, PathComputationService, Path, VirtualNetworkService."; } typedef fault-condition-determination { type identityref { base FAULT_CONDITION_DETERMINATION; } description "ITU-T G.808 Amendment 1 (03/2018) - 3.2.6.8 subnetwork connection protection: 'Transport entity protection for the case where the transport entity is a subnetwork connection. The serial compound link connection within the subnetwork connection is protected by adding bridges and selectors in the connection functions at the edges of the protected domain and an additional serial compound link connection between these connection functions. The determination of a fault condition on a serial compound link connection within the protected domain can be performed as follows: (see enumeration entries).'"; } typedef connectivity-object-type { type identityref { base CONNECTIVITY_OBJECT_TYPE; } description "The list of TAPI Connectivity Global Object Class types on which Notification signals can be raised."; } typedef route-state { type identityref { base ROUTE_STATE; } description "Potential Route states concerning the service support."; } grouping cep-role { leaf role-name { type string; config false; description "The name of the CEP role in the context of the referenced spec."; } container connection-spec-reference { config false; uses connection-spec-reference; description "The reference to the spec that defines the CEP role."; } description "The role of the CEP in the context of the Connection spec."; } grouping connection-spec-reference { leaf connection-spec-name { type string; config false; description "The name of the Connection spec. This can be used alone (with no spec reference) where there is only a paper spec."; } leaf connection-spec-id { type tapi-common:uuid; config false; description "The reference to a formal spec. This reference need not be provided (e.g., where there is no formal machine interpretable spec for the type of Connection)."; } description "The reference to a spec for a type of Connection."; } grouping csep-role { leaf role-name { type string; config false; description "The name of the CSEP role in the context of the referenced spec."; } container connectivity-service-spec-reference { config false; uses connectivity-service-spec-reference; description "The reference to the spec that defines the CSEP role."; } description "The role of the CSEP in the context of the Connectivity Service spec."; } grouping connectivity-service-spec-reference { leaf connectivity-service-spec-name { type string; config false; description "The name of the Connectivity Service spec. This can be used alone (with no spec reference) where there is only a paper spec."; } leaf connectivity-service-spec-id { type tapi-common:uuid; config false; description "The reference to a formal spec. This reference need not be provided (e.g., where there is no formal machine interpretable spec for the type of Connectivity Service)."; } description "The reference to a spec for a type of Connectivity Service"; } /************************** * package interfaces **************************/ rpc get-connection-details { description "none"; input { leaf uuid { type tapi-common:uuid; description "UUID of the Connection instance. 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 connection { uses connection; description "The requested Connection instance."; } } } rpc get-connectivity-service-list { description "none"; output { list service { key 'uuid'; uses connectivity-service; description "The requested list of ConnectivityService instances."; } } } rpc get-connectivity-service-details { description "none"; input { leaf uuid { type tapi-common:uuid; description "UUID of the ConnectivityService instance. 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 service { uses connectivity-service; description "The requested ConnectivityService instance."; } } } rpc create-connectivity-service { description "none"; input { leaf uuid { type tapi-common:uuid; description "UUID of the ConnectivityService instance to be created. 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"; } list name { key 'value-name'; uses tapi-common:name-and-value; description "List of names of the ConnectivityService instance to be created. The value(s) is (are) unique in some namespace but may change during the life of the entity. A name carries no semantics with respect to the purpose of the entity."; } leaf layer-protocol-name { type tapi-common:layer-protocol-name; description "The layer protocol of the ConnectivityService instance to be created."; } list end-point { key 'local-id'; min-elements 2; uses connectivity-service-end-point; description "The parameters of the ConnectivityServiceEndPoint (CSEP) instances to be created as end points of the ConnectivityService instance under creation."; } container connectivity-constraint { uses connectivity-constraint; description "The connectivity constraints of the ConnectivityService instance to be created."; } container routing-constraint { uses tapi-path-computation:routing-constraint; description "The routing constraints of the ConnectivityService instance to be created."; } list topology-constraint { key 'local-id'; uses tapi-path-computation:topology-constraint; description "The topology constraints of the ConnectivityService instance to be created."; } container resilience-constraint { uses resilience-constraint; description "The resiliency constraints of the ConnectivityService instance to be created."; } leaf state { type tapi-common:administrative-state; description "The Administrative State of the ConnectivityService instance to be created."; } } output { container service { uses connectivity-service; description "The created ConnectivityService instance."; } } } rpc update-connectivity-service { description "none"; input { leaf uuid { type tapi-common:uuid; description "UUID of the ConnectivityService instance to be updated. 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"; } list name { key 'value-name'; uses tapi-common:name-and-value; description "List of names of the ConnectivityService instance to be updated. The value(s) is (are) unique in some namespace but may change during the life of the entity. A name carries no semantics with respect to the purpose of the entity."; } list end-point { key 'local-id'; uses connectivity-service-end-point; description "The parameters of the ConnectivityServiceEndPoint (CSEP) instances to be updated as end points of the ConnectivityService instance under update."; } container connectivity-constraint { uses connectivity-constraint; description "The updated connectivity constraints of the ConnectivityService instance under update."; } container routing-constraint { uses tapi-path-computation:routing-constraint; description "The updated routing constraints of the ConnectivityService instance under update."; } list topology-constraint { key 'local-id'; uses tapi-path-computation:topology-constraint; description "The updated topology constraints of the ConnectivityService instance under update."; } container resilience-constraint { uses resilience-constraint; description "The updated resiliency constraints of the ConnectivityService instance under update."; } leaf state { type tapi-common:administrative-state; description "The (updated) Administrative State of the ConnectivityService instance under update."; } } output { container service { uses connectivity-service; description "The updated ConnectivityService instance."; } } } rpc delete-connectivity-service { description "none"; input { leaf uuid { type tapi-common:uuid; description "UUID of the ConnectivityService instance to be deleted. 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"; } } } rpc get-connection-end-point-details { description "none"; input { leaf uuid { type tapi-common:uuid; description "UUID of the ConnectionEndPoint (CEP) instance. 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 connection-end-point { uses connection-end-point; description "The requested ConnectionEndPoint (CEP) instance."; } } } }