tapi-path-computation@2019-03-31.yang

module tapi-path-computation {
    namespace "urn:onf:otcc:yang:tapi-path-computation";
    prefix tapi-path-computation;
    import tapi-topology {
        prefix tapi-topology;
    }
    import tapi-common {
        prefix tapi-common;
    }
    organization "ONF OTCC (Open Transport Configuration & Control) Project";
    contact "
         Project Web: <https://wiki.opennetworking.org/display/OTCC/TAPI>
         Project List: <mailto:transport-api@opennetworking.org>
         Editor: Karthik Sethuraman
                 <mailto:karthik.sethuraman@necam.com>";
    description "
        This module contains TAPI Path Computation Model definitions.
        Source: TapiPathComputation.uml
        Copyright (c) 2018 Open Networking Foundation (ONF). All rights reserved.
        License: This module is distributed under the Apache License 2.0
        - 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]
        <https://github.com/OpenNetworkingFoundation/EagleUmlYang>
        and further edited manually to comply with the [ONF IISOMI UML2YANG mapping guidelines]
        <https://wiki.opennetworking.org/display/OIMT/UML+-+YANG+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 <https://tools.ietf.org/html/rfc7950>.
        YANG models included in this release may not be backward compatible with previous TAPI releases.";
    revision 2019-03-31 {
        description "ONF Transport API version 2.2-RC1.
                   Changes included in this TAPI release (v2.2) are listed in
                  <https://github.com/OpenNetworkingFoundation/TAPI/blob/develop/CHANGE_LOG/change-log.2.2.md>";
        reference "ONF-TR-527, ONF-TR-512, ONF-TR-531, RFC 7950, RFC 6087 and ONF TAPI UML model
                  <https://github.com/OpenNetworkingFoundation/TAPI/tree/v2.2.0/UML>";
    }
    revision 2018-12-10 {
        description "ONF Transport API version 2.1.1.
                   Changes included in this TAPI release (v2.1.1) are listed in
                  <https://github.com/OpenNetworkingFoundation/TAPI/blob/develop/CHANGE_LOG/change-log.2.1.1.md>";
        reference "ONF-TR-527, ONF-TR-512, ONF-TR-531, RFC 7950, RFC 6087 and ONF TAPI UML model
                  <https://github.com/OpenNetworkingFoundation/TAPI/tree/v2.1.1/UML>";
    }
    revision 2018-10-16 {
        description "ONF Transport API version 2.1.0.
                   Changes included in this TAPI release (v2.1.0) are listed in
                  <https://github.com/OpenNetworkingFoundation/TAPI/blob/develop/CHANGE_LOG/change-log.2.1.0.md>";
        reference "ONF-TR-527, ONF-TR-512, ONF-TR-531, RFC 7950, RFC 6087 and ONF TAPI UML model
                  <https://github.com/OpenNetworkingFoundation/TAPI/tree/v2.1.0/UML>";
    }
    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: <https://github.com/OpenNetworkingFoundation/TAPI/blob/develop/CHANGE_LOG/change-log.2.0.2.md>";
        reference "ONF-TR-527, ONF-TR-512, ONF-TR-531, RFC 6020, RFC 6087 and ONF TAPI UML model
                  <https://github.com/OpenNetworkingFoundation/TAPI/tree/v2.0.2/UML>";
    }
    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: <https://github.com/OpenNetworkingFoundation/TAPI/blob/develop/CHANGE_LOG/change-log.2.0.1.md>";
        reference "ONF-TR-527, ONF-TR-512, ONF-TR-531, RFC 6020, RFC 6087 and ONF TAPI UML model
                  <https://github.com/OpenNetworkingFoundation/TAPI/tree/v2.0.1/UML>";
    }
    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: <https://github.com/OpenNetworkingFoundation/TAPI/blob/develop/CHANGE_LOG/change-log.2.0.0.md>";
        reference "ONF-TR-527, ONF-TR-512, ONF-TR-531, RFC 6020, RFC 6087 and ONF TAPI UML model
                  <https://github.com/OpenNetworkingFoundation/TAPI/tree/v2.0.0/UML>";
    }
    augment "/tapi-common:context" {
        container path-computation-context {
            uses path-computation-context;
            description "Augments the base TAPI Context with PathComputationService information";
        }
        description "Augments the base TAPI Context with PathComputationService information";
    }
    /**************************
    * definitions of references
    **************************/
    grouping path-ref {
        leaf path-uuid {
            type leafref {
                path '/tapi-common:context/tapi-path-computation:path-computation-context/tapi-path-computation:path/tapi-path-computation:uuid';
            }
            description "none";
        }
        description "none";
    }
    
    /**************************
    * package object-classes
    **************************/ 
    grouping path {
        list link {
            uses tapi-topology:link-ref;
            key 'topology-uuid link-uuid';
            config false;
            min-elements 1;
            description "none";
        }
        container routing-constraint {
            config false;
            uses routing-constraint;
            description "none";
        }
        leaf direction {
            type tapi-common:forwarding-direction;
            config false;
            description "none";
        }
        leaf layer-protocol-name {
            type tapi-common:layer-protocol-name;
            config false;
            description "none";
        }
        uses tapi-common:global-class;
        description "Path is described by an ordered list of TE Links. A TE Link is defined by a pair of Node/NodeEdgePoint IDs. A Connection is realized by concatenating link resources (associated with a Link) and the lower-level connections (cross-connections) in the different nodes";
    }
    grouping path-service-end-point {
        container service-interface-point {
            uses tapi-common:service-interface-point-ref;
            description "none";
        }
        leaf layer-protocol-name {
            type tapi-common:layer-protocol-name;
            description "none";
        }
        leaf layer-protocol-qualifier {
            type tapi-common:layer-protocol-qualifier;
            description "none";
        }
        container capacity {
            uses tapi-common:capacity;
            description "none";
        }
        leaf role {
            type tapi-common:port-role;
            description "Each EP of the FC has a role (e.g., working, protection, protected, symmetric, hub, spoke, leaf, root)  in the context of the FC with respect to the FC function. ";
        }
        leaf direction {
            type tapi-common:port-direction;
            description "The orientation of defined flow at the EndPoint.";
        }
        uses tapi-common:local-class;
        description "The association of the FC to LTPs is made via EndPoints.
            The EndPoint (EP) object class models the access to the FC function. 
            The traffic forwarding between the associated EPs of the FC depends upon the type of FC and may be associated with FcSwitch object instances.  
            In cases where there is resilience the EndPoint may convey the resilience role of the access to the FC. 
            It can represent a protected (resilient/reliable) point or a protecting (unreliable working or protection) point.
            The EP replaces the Protection Unit of a traditional protection model. 
            The ForwadingConstruct can be considered as a component and the EndPoint as a Port on that component";
    }
    grouping path-computation-service {
        list path {
            uses path-ref;
            key 'path-uuid';
            config false;
            min-elements 1;
            description "none";
        }
        list end-point {
            key 'local-id';
            min-elements 2;
            max-elements 2;
            uses path-service-end-point;
            description "none";
        }
        container routing-constraint {
            uses routing-constraint;
            description "none";
        }
        list topology-constraint {
            key 'local-id';
            uses topology-constraint;
            description "none";
        }
        container objective-function {
            uses path-objective-function;
            description "none";
        }
        container optimization-constraint {
            uses path-optimization-constraint;
            description "none";
        }
        leaf direction {
            type tapi-common:forwarding-direction;
            description "none";
        }
        leaf layer-protocol-name {
            type tapi-common:layer-protocol-name;
            description "none";
        }
        uses tapi-common:global-class;
        description "none";
    }
    grouping path-objective-function {
        leaf bandwidth-optimization {
            type tapi-common:directive-value;
            config false;
            description "none";
        }
        leaf concurrent-paths {
            type tapi-common:directive-value;
            config false;
            description "none";
        }
        leaf cost-optimization {
            type tapi-common:directive-value;
            config false;
            description "none";
        }
        leaf link-utilization {
            type tapi-common:directive-value;
            config false;
            description "none";
        }
        leaf resource-sharing {
            type tapi-common:directive-value;
            config false;
            description "none";
        }
        uses tapi-common:local-class;
        description "none";
    }
    grouping path-optimization-constraint {
        leaf traffic-interruption {
            type tapi-common:directive-value;
            config false;
            description "none";
        }
        uses tapi-common:local-class;
        description "none";
    }
    grouping routing-constraint {
        list cost-characteristic {
            key 'cost-name';
            uses tapi-topology:cost-characteristic;
            description "The list of costs where each cost relates to some aspect of the TopologicalEntity.";
        }
        list latency-characteristic {
            key 'traffic-property-name';
            uses tapi-topology:latency-characteristic;
            description "The effect on the latency of a queuing process. This only has significant effect for packet based systems and has a complex characteristic.";
        }
        list risk-diversity-characteristic {
            key 'risk-characteristic-name';
            uses tapi-topology:risk-characteristic;
            description "none";
        }
        leaf diversity-policy {
            type diversity-policy;
            description "none";
        }
        leaf route-objective-function {
            type route-objective-function;
            description "none";
        }
        leaf is-exclusive {
            type boolean;
            default "true";
            description "To distinguish if the resources are to be exclusive to the service";
        }
        leaf tolerable-impact {
            type grades-of-impact;
            description "Grades of maximum tolerable disruption to traffic.";
        }
        container max-allowed-cost {
            uses value-or-priority;
            description "none";
        }
        container max-allowed-hops {
            uses value-or-priority;
            description "none";
        }
        container max-allowed-delay {
            uses value-or-priority;
            description "Delay unit is microseconds.";
        }
        description "none";
    }
    grouping path-computation-context {
        list path-comp-service {
            key 'uuid';
            uses path-computation-service;
            description "none";
        }
        list path {
            key 'uuid';
            config false;
            uses path;
            description "none";
        }
        description "none";
    }
    grouping topology-constraint {
        leaf include-topology {
            type tapi-common:uuid;
            description "none";
        }
        leaf avoid-topology {
            type tapi-common:uuid;
            description "none";
        }
        leaf include-path {
            type tapi-common:uuid;
            description "none";
        }
        leaf exclude-path {
            type tapi-common:uuid;
            description "none";
        }
        leaf include-link {
            type tapi-common:uuid;
            description "This is a loose constraint - that is it is unordered and could be a partial list ";
        }
        leaf exclude-link {
            type tapi-common:uuid;
            description "none";
        }
        leaf include-node {
            type tapi-common:uuid;
            description "This is a loose constraint - that is it is unordered and could be a partial list";
        }
        leaf exclude-node {
            type tapi-common:uuid;
            description "none";
        }
        leaf include-node-edge-point {
            type tapi-common:uuid;
            description "none";
        }
        leaf exclude-node-edge-point {
            type tapi-common:uuid;
            description "none";
        }
        leaf preferred-transport-layer {
            type tapi-common:layer-protocol-name;
            description "soft constraint requested by client to indicate the layer(s) of transport connection that it prefers to carry the service. This could be same as the service layer or one of the supported server layers";
        }
        leaf constraint-weight {
            type uint64;
            description "Zero and positive values: zero means 'strongly required to be included', +1 means 'less strongly required to be included', etc.
                For example the work/intended route will be calculated considering the topologies which weights are lowest (but not negative).
                Negative values: -1 means 'strongly required to be excluded', -2 means 'less strongly required to be excluded', etc.";
        }
        uses tapi-common:local-class;
        description "The TopologyConstraint allows to specify topology entities in order to impose specific constraints (as denoted by the attribute name) on Connectivity/Path.
            The  topology entities are specified by their instance uuid rather than using references/path (to allow for mapping to Yang 1.0).
            This loose typing and reference necessitates that implementations validate not only the presence of the instance, but also that it is of the correct type as implied by the attribute name.
            If this validation fails, then the implementation is expceted to return an error.
            ";
    }

    /**************************
    * package type-definitions
    **************************/ 
    identity GRADES_OF_IMPACT {
        description "none";
    }
    identity GRADES_OF_IMPACT_HITLESS {
        base GRADES_OF_IMPACT;
        description "none";
    }
    identity GRADES_OF_IMPACT_MINOR_IMPACT {
        base GRADES_OF_IMPACT;
        description "less or equal to 50ms";
    }
    identity GRADES_OF_IMPACT_MAJOR_IMPACT {
        base GRADES_OF_IMPACT;
        description "Order of magnitude: several seconds to minutes.";
    }
    identity GRADES_OF_IMPACT_LONG_IMPACT {
        base GRADES_OF_IMPACT;
        description "Order of magnitude: several minutes to hours.";
    }
    identity PATH_COMPUTATION_OBJECT_TYPE {
    	base tapi-common:OBJECT_TYPE;
        description "none";
    }
    identity PATH_COMPUTATION_OBJECT_TYPE_PATH_COMPUTATION_SERVICE {
        base PATH_COMPUTATION_OBJECT_TYPE;
        description "none";
    }
    identity PATH_COMPUTATION_OBJECT_TYPE_PATH_COMPUTATION_SERVICE_END_POINT {
        base PATH_COMPUTATION_OBJECT_TYPE;
        description "none";
    }
    identity PATH_COMPUTATION_OBJECT_TYPE_PATH {
        base PATH_COMPUTATION_OBJECT_TYPE;
        description "none";
    }
    typedef route-objective-function {
        type enumeration {
            enum MIN_WORK_ROUTE_HOP {
                description "none";
            }
            enum MIN_WORK_ROUTE_COST {
                description "none";
            }
            enum MIN_WORK_ROUTE_LATENCY {
                description "none";
            }
            enum MIN_SUM_OF_WORK_AND_PROTECTION_ROUTE_HOP {
                description "none";
            }
            enum MIN_SUM_OF_WORK_AND_PROTECTION_ROUTE_COST {
                description "none";
            }
            enum MIN_SUM_OF_WORK_AND_PROTECTION_ROUTE_LATENCY {
                description "none";
            }
            enum LOAD_BALANCE_MAX_UNUSED_CAPACITY {
                description "none";
            }
        }
        description "none";
    }
    typedef diversity-policy {
        type enumeration {
            enum SRLG {
                description "none";
            }
            enum SRNG {
                description "none";
            }
            enum SNG {
                description "none";
            }
            enum NODE {
                description "none";
            }
            enum LINK {
                description "none";
            }
        }
        description "none";
    }
    typedef grades-of-impact {
        type identityref {
            base GRADES_OF_IMPACT;
        }
        description "none";
    }
    typedef path-computation-object-type {
        type identityref {
            base PATH_COMPUTATION_OBJECT_TYPE;
        }
        description "The list of TAPI Path Computation Object types/classes.";
    }
    grouping value-or-priority {
        leaf value {
            type uint64;
            description "none";
        }
        leaf priority {
            type uint64;
            description "none";
        }
        description "Quantitative target: when a value is specified it is intended as mandatory for fulfilment. If value is specified, priority is not considered.
            Qualitative target: when priority is specified. Zero means 'unspecified', 1 is highest priority, then 2 has lower priority than 1, 3 has lower priority than 2, etc.";
    }

    /**************************
    * package interfaces
    **************************/ 
    rpc compute-p-2-p-path {
        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";
            }
            list name {
                key 'value-name';
                uses tapi-common:name-and-value;
                description "List of names. This value is 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.";
            }
            container routing-constraint {
                uses routing-constraint;
                description "none";
            }
            container topology-constraint {
                uses topology-constraint;
                description "none";
            }
            container objective-function {
                uses path-objective-function;
                description "none";
            }
            list end-point {
                key 'local-id';
                min-elements 2;
                max-elements 2;
                uses path-service-end-point;
                description "none";
            }
        }
        output {
            container service {
                uses path-computation-service;
                description "none";
            }
        }
    }
    rpc optimize-p-2-p-path {
        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";
            }
            list name {
                key 'value-name';
                uses tapi-common:name-and-value;
                description "List of names. This value is 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.";
            }
            container routing-constraint {
                uses routing-constraint;
                description "none";
            }
            container optimization-constraint {
                uses path-optimization-constraint;
                description "none";
            }
            container objective-function {
                uses path-objective-function;
                description "none";
            }
        }
        output {
            container service {
                uses path-computation-service;
                description "none";
            }
        }
    }
    rpc delete-p-2-p-path {
        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 service {
                uses path-computation-service;
                description "none";
            }
        }
    }

}