]> Huawei Technologies

italo.busi@huawei.com

Nokia

sergio.belotti@nokia.com

Telefonica

oscar.gonzalezdedios@telefonica.com

Google

ansha@google.com

China Unicom

shiyan49@chinaunicom.cn

Routing Traffic Engineering Architecture and Signaling next generation unicorn sparkling distributed ledger In certain scenarios — particularly within hierarchical Software-Defined Networking (SDN) environments—the topology information provided by a Traffic Engineering (TE) network provider may be insufficient for a client to perform end-to-end multi-domain path computation. In such cases, the client may need to delegate the computation of specific intra-domain paths to the TE provider, leveraging the resulting path segments to construct optimal multi-domain end-to-end paths. This document defines a mechanism to enable path computation requests by augmenting the Remote Procedure Calls (RPCs) specified in RFC YYYY. The augmented RPCs support path computation on demand, allowing clients to request intra-domain TE path computations from the provider while maintaining control over inter-domain path selection. Additionally, this document outlines several use cases in which such path computation requests are beneficial, particularly in environments where YANG-based management protocols—such as NETCONF or RESTCONF—are used for network automation and control. [RFC EDITOR NOTE: Please replace RFC YYYY with the RFC number assigned to draft-ietf-teas-yang-te upon publication.] About This Document The latest revision of this draft can be found at . Status information for this document may be found at . Discussion of this document takes place on the Traffic Engineering Architecture and Signaling Working Group mailing list (), which is archived at . Subscribe at . Source for this draft and an issue tracker can be found at .

Introduction There are scenarios, typically in a hierarchical Software-Defined Networking (SDN) context, where the topology information provided by a Traffic Engineering (TE) network provider may be insufficient for its client to perform multi-domain path computation. In these cases the client would need to request the TE network provider to compute some intra-domain paths that could be used together with its topology information to compute the multi-domain path. These types of scenarios can be applied to different interfaces in different reference architectures:

• Application-Based Network Operations (ABNO) control interface , in which an Application Service Coordinator can request the ABNO controller to take in charge path calculation (see Figure 1 in ).
• Abstraction and Control of TE Networks (ACTN) , where a controller hierarchy is defined. In the ACTN context, path computation is needed on the interface between Customer Network Controller (CNC) and Multi-Domain Service Coordinator (MDSC), called CNC-MDSC Interface (CMI), and on the interface between MDSC and Provisioning Network Controller (PNC), called MDSC-PNC Interface (MPI). describes an information model for the Path Computation request. Multiple protocol solutions can be used for communication between different controller hierarchical levels. This document assumes that the controllers are communicating using YANG-based protocols (e.g., NETCONF or RESTCONF ). Path Computation Elements (PCEs), controllers and orchestrators perform their operations based on Traffic Engineering Databases (TED). Such TEDs can be described, in a technology agnostic way, with the YANG data model for TE Topologies . Furthermore, the technology specific details of the TED are modelled in the technology specific topology models, e.g., the for Optical Transport Network (OTN) Optical Data Unit (ODU) technologies, which augment the common TE topology model in . The availability of such topology models allows the provisioning of the TED using YANG-based protocols (e.g., NETCONF or RESTCONF). Furthermore, it enables a PCE/controller performing the necessary abstractions or modifications and offering this customized topology to another PCE/controller or high level orchestrator. The tunnels that can be provided over the networks described with the topology models can be also set-up, deleted and modified via YANG- based protocols (e.g., NETCONF or RESTCONF) using the TE tunnel YANG data model .

This document defines a YANG data model that augments the RPC defined in . The use of this RPC is complementary to the configuration of a TE tunnel path in "compute-only" mode, as described in . The YANG data model definition does not make any assumption about whether the client or the server implement a "PCE" functionality, as defined in , and the Path Computation Element Communication Protocol (PCEP) protocol, as defined in . Moreover, this document describes some use cases where a path computation request, via YANG-based protocols (e.g., NETCONF or RESTCONF), can be needed. The YANG data model defined in this document conforms to the Network Management Datastore Architecture .

Terminology The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 when, and only when, they appear in all capitals, as shown here. TED:

• The traffic engineering database is a collection of all TE information about all TE nodes and TE links in a given network.

PCE:

• A Path Computation Element (PCE) is an entity that is capable of computing a network path or route based on a network graph, and of applying computational constraints during the computation. The PCE entity is an application that can be located within a network node or component, on an out-of-network server, etc. For example, a PCE would be able to compute the path of a TE Label Switched Path (LSP) by operating on the TED and considering bandwidth and other constraints applicable to the TE LSP service request. .

Domain:

• TE information is the data relating to nodes and TE links that is used in the process of selecting a TE path. TE information is usually only available within a network. We call such a zone of visibility of TE information a domain. An example of a domain may be an IGP area or an Autonomous System.

The terminology for describing YANG data models is found in .

Tree Diagram Tree diagrams used in this document follow the notation defined in .

Prefixes in Data Node Names In this document, names of data nodes and other data model objects are prefixed using the standard prefix associated with the corresponding YANG imported modules, as shown in . Prefixes and corresponding YANG modules

Prefix	YANG module	Reference
te-types	ietf-te-types	[RFCZZZZ]
te	ietf-te	[RFCYYYY]
te-pc	ietf-te-path-computation	RFCXXXX

RFC Editor Note: Please replace XXXX with the RFC number assigned to this document. Please replace YYYY with the RFC number of once it has been published. Please replace ZZZZ with the RFC number of once it has been published. Please remove this note.

Use Cases This section presents some use cases, where a client needs to request underlying SDN controllers for path computation. The use of the YANG data model defined in this document is not restricted to these use cases but can be used in any other use case when deemed useful. The presented uses cases have been grouped, depending on the different underlying topologies: Packet/Optical Integration (); multi-domain Traffic Engineered (TE) Networks (); and Data Center Interconnections (). Use cases in and respectively present how to apply this YANG data model for standard multi-domain PCE i.e. Backward Recursive Path Computation and Hierarchical PCE .

Packet/Optical Integration In this use case, an optical domain is used to provide connectivity to some nodes of a packet domain (see ).

Packet/Optical Integration use case

as well as describe two different examples of packet/optical topologies and only show a partial view of the packet network connectivity, before additional packet connectivity is provided by the optical network. It is assumed that the Optical Domain Controller provides to the Packet/Optical Coordinator an abstracted view of the optical network. A possible abstraction could be to represent the whole optical network as one "virtual node" with "virtual ports" connected to the access links, as shown in . It is also assumed that Packet Domain Controller can provide the Packet/Optical Coordinator the information it needs to set up connectivity between packet nodes through the optical network (e.g., the access links). The path computation request helps the Packet/Optical Coordinator to know the real connections that can be provided by the optical network.

Packet and Optical Topology Abstractions

In this use case, the Packet/Optical Coordinator needs to set up an optimal underlying path for an IP link between R1 and R2. As depicted in , the Packet/Optical Coordinator has only an "abstracted view" of the physical network, and it does not know the feasibility or the cost of the possible optical paths (e.g., VP1-VP4 and VP2-VP5), which depend on the current status of the physical resources within the optical network and on vendor-specific optical attributes. The Packet/Optical Coordinator can request the underlying Optical Domain Controller to compute a set of potential optimal paths, taking into account optical constraints. Then, based on its own constraints, policy and knowledge (e.g. cost of the access links), it can choose which one of these potential paths to use to set up the optimal end- to-end path crossing optical network.

Packet/Optical Integration path computation example

For example, in , the Packet/Optical Coordinator can request the Optical Domain Controller to compute the paths between VP1-VP4 and VP2-VP5 and then decide to set up the optimal end-to-end path using the VP2-VP5 optical path even if this is not the optimal path from the optical domain perspective. Considering the dynamicity of the connectivity constraints of an optical domain, it is possible that a path computed by the Optical Domain Controller when requested by the Packet/Optical Coordinator is no longer valid/available when the Packet/Optical Coordinator requests it to be set up. This is further discussed in .

Multi-domain TE networks In this use case there are two TE domains which are interconnected together by multiple inter-domains links. A possible example could be a multi-domain optical network.

Multi-domain multi-link interconnection

In order to set up an end-to-end multi-domain TE path (e.g., between nodes A and H), the Multi-Domain Controller needs to know the feasibility or the cost of the possible TE paths within the two TE domains, which depend on the current status of the physical resources within each TE domain. This is more challenging in case of optical networks because the optimal paths depend also on vendor-specific optical attributes (which may be different in the two domains if they are provided by different vendors). In order to set up a multi-domain TE path (e.g., between nodes A and H), the Multi-Domain Controller can request the TE Domain Controllers to compute a set of intra-domain optimal paths and take decisions based on the information received. For example:

• The Multi-Domain Controller asks TE Domain Controllers to provide set of paths between A-C, A-D, E-H and F-H
• TE Domain Controllers return a set of feasible paths with the associated costs: the path A-C is not part of this set (in optical networks, it is typical to have some paths not being feasible due to optical constraints that are known only by the Optical Domain Controller)
• The Multi-Domain Controller will select the path A-D-F-H since it is the only feasible multi-domain path and then request the TE Domain Controllers to set up the A-D and F-H intra-domain paths
• If there are multiple feasible paths, the Multi-Domain Controller can select the optimal path knowing the cost of the intra-domain paths (provided by the TE domain controllers) and the cost of the inter-domain links (known by the Multi-Domain Controller) This approach may have some scalability issues when the number of TE domains is quite big (e.g. 20). In this case, it would be worthwhile using the abstract TE topology information provided by the TE Domain Controllers to limit the number of potential optimal end-to-end paths and then request path computation from fewer TE Domain Controllers in order to decide what the optimal path within this limited set is. For more details, see .

Data Center Interconnections In these use case, there is a TE domain which is used to provide connectivity between Data Centers which are connected with the TE domain using access links.

Data Center Interconnection use case

In this use case, there is the need to transfer data from Data Center 1 (DC1) to either DC2 or DC3 (e.g. workload migration). The optimal decision depends both on the cost of the TE path (DC1-DC2 or DC1-DC3) and of the Data Center resources within DC2 or DC3. The Cloud Network Orchestrator needs to make a decision for optimal connection based on TE network constraints and Data Center resources. It may not be able to make this decision because it has only an abstract view of the TE network (as in ). The Cloud Network Orchestrator can request to the TE Network Controller to compute the cost of the possible TE paths (e.g., DC1- DC2 and DC1-DC3) and to the DC Controller to provide the information it needs about the required Data Center resources within DC2 and DC3 and then it can take the decision about the optimal solution based on this information and its policy.

Backward Recursive Path Computation scenario has defined the Virtual Source Path Tree (VSPT) flag within the RP (Request Parameters) object in order to compute inter-domain paths following a "Backward Recursive Path Computation" (BRPC) method. The main principle is to forward the PCReq message up to the destination domain. Then, each PCE involved in the computation will compute its part of the path and send it back to the requester through PCE Response message. The resulting computation is spread from destination PCE to source PCE. Each PCE is in charge of merging the path it received with the one it calculated. At the end, the source PCE merges its local part of the path with the received one to achieve the end-to-end path. below shows a typical BRPC scenario where 3 PCEs cooperate to compute inter-domain paths.

BRPC Scenario |D| | | / | Inter | - | +---|----^-------+ Domain +----------------+ | | Link PCEP | | | Inter-domain Link | | +---|----v-------+ | | | | | Domain (A) | | \ | | (PCE) - | | |S| | | - | +----------------+ ]]>

In this use case, a client can use the YANG data model defined in this document to request path computation from the PCE that controls the source of the tunnel. For example, a client can request to the PCE of domain A to compute a path from a source S, within domain A, to a destination D, within domain C. Then PCE of domain A will use PCEP protocol, as per , to compute the path from S to D and in turn gives the final answer to the requester.

Hierarchical PCE scenario has defined an architecture and extensions to the PCE standard to compute inter-domain path following a hierarchical method. Two new roles have been defined: parent PCE and child PCE. The parent PCE is in charge to coordinate the end-to-end path computation. For that purpose it sends to each child PCE involved in the multi-domain path computation a PCE Request message to obtain the local part of the path. Once received all answer through PCE Response message, the parent PCE will merge the different local parts of the path to achieve the end-to-end path. below shows a typical hierarchical scenario where a parent PCE request end-to-end path to the different child PCE. Note that a PCE could take independently the role of child or parent PCE depending on which PCE will request the path.

Hierarchical domain topology from RFC6805

In this use case, a client can use the YANG data model defined in this document to request to the parent PCE a path from a source S to a destination D. The parent PCE will in turn contact the child PCEs through PCEP protocol to compute the end-to-end path and then return the computed path to the client, using the YANG data model defined in this document. For example the YANG data model can be used to request to PCE5 acting as parent PCE to compute a path from source S, within domain 1, to destination D, within domain 3. PCE5 will contact child PCEs of domain 1, 2 and 3 to obtain local part of the end-to-end path through the PCEP protocol. Once received the PCRep message, it merges the answers to compute the end-to-end path and send it back to the client.

Motivations This section provides the motivation for the YANG data model defined in this document. describes the motivation for a YANG data model to request path computation. describes the motivation for a YANG data model which complements the TE topology YANG data model defined in . describes the motivation for a YANG RPC which complements the TE tunnel YANG data model defined in .

Motivation for a YANG Model

Benefits of common data models The YANG data model for requesting path computation is closely aligned with the YANG data models that provide (abstract) TE topology information, i.e., as well as that are used to configure and manage TE tunnels, i.e., . There are many benefits in aligning the data model used for path computation requests with the YANG data models used for TE topology information and for TE tunnels configuration and management:

• There is no need for an error-prone mapping or correlation of information.
• It is possible to use the same endpoint identifiers in path computation requests and in the topology modeling.
• The attributes used for path computation constraints are the same as those used when setting up a TE tunnel.

Benefits of a single interface The system integration effort is typically lower if a single, consistent interface is used by controllers, i.e., one data modeling language (i.e., YANG) and a common protocol (e.g., NETCONF or RESTCONF). Practical benefits of using a single, consistent interface include:

1. Simple authentication and authorization: The interface between different components has to be secured. If different protocols have different security mechanisms, ensuring a common access control model may result in overhead. For instance, there may be a need to deal with different security mechanisms, e.g., different credentials or keys. This can result in increased integration effort.
2. Consistency: Keeping data consistent over multiple different interfaces or protocols is not trivial. For instance, the sequence of actions can matter in certain use cases, or transaction semantics could be desired. While ensuring consistency within one protocol can already be challenging, it is typically cumbersome to achieve that across different protocols.
3. Testing: System integration requires comprehensive testing, including corner cases. The more different technologies are involved, the more difficult it is to run comprehensive test cases and ensure proper integration.
4. Middle-box friendliness: Provider and consumer of path computation requests may be located in different networks, and middle-boxes such as firewalls, NATs, or load balancers may be deployed. In such environments it is simpler to deploy a single protocol. Also, it may be easier to debug connectivity problems.
5. Tooling reuse: Implementers may want to implement path computation requests with tools and libraries that already exist in controllers and/or orchestrators, e.g., leveraging the rapidly growing eco-system for YANG tooling.

Extensibility Path computation is only a subset of the typical functionality of a controller. In many use cases, issuing path computation requests comes along with the need to access other functionality on the same system. In addition to obtaining TE topology, for instance also configuration of services (set-up/modification/deletion) may be required, as well as:

1. Receiving notifications for topology changes as well as integration with fault management
2. Performance management such as retrieving monitoring and telemetry data
3. Service assurance, e.g., by triggering OAM functionality
4. Other fulfilment and provisioning actions beyond tunnels and services, such as changing QoS configurations YANG is a very extensible and flexible data modeling language that can be used for all these use cases.

Interactions with TE topology The use cases described in have been described assuming that the topology view exported by each underlying controller to its client is aggregated using the "virtual node model", defined in . TE topology information, e.g., as provided by , could in theory be used by an underlying controller to provide TE information to its client thus allowing a PCE available within its client to perform multi-domain path computation on its own, without requesting path computations to the underlying controllers. In case the client does not implement a PCE function, as discussed in , it could not perform path computation based on TE topology information and would instead need to request path computation from the underlying controllers to get the information it needs to find the optimal end-to-end path. In case the client implements a PCE function, as discussed in , the TE topology information needs to be complete and accurate, which would bring to scalability issues. Using TE topology to provide a "virtual link model" aggregation, as described in , may be insufficient, unless the aggregation provides complete and accurate information, which would still cause scalability issues, as described in below. Using TE topology abstraction, as described in , may lead to compute an unfeasible path, as described in in below. Therefore when computing an optimal multi-domain path, there is a scalability trade-off between providing complete and accurate TE information and the number of path computation requests to the underlying controllers. The TE topology information used, in a complementary way, to reduce the number for path computation requests to the underlying controllers, are described in below.

TE topology aggregation Using the TE topology model, as defined in , the underlying controller can export the whole TE domain as a single TE node with a "detailed connectivity matrix" (which provides specific TE attributes, such as delay, Shared Risk Link Groups (SRLGs) and other TE metrics, between each ingress and egress links). The information provided by the "detailed connectivity matrix" would be equivalent to the information that should be provided by "virtual link model" as defined in . For example, in the Packet/Optical Integration use case, described in , the Optical Domain Controller can make the information shown in available to the Packet/Optical Coordinator as part of the TE topology information and the Packet/Optical Coordinator could use this information to calculate on its own the optimal path between R1 and R2, without requesting any additional information to the Optical Domain Controller. However, when designing the amount of information to provide within the "detailed connectivity matrix", there is a tradeoff to be considered between accuracy (i.e., providing "all" the information that might be needed by the PCE available within the client) and scalability. below shows another example, similar to , where there are two possible Optical paths between VP1 and VP4 with different properties (e.g., available bandwidth and cost).

Packet/Optical Integration path computation Example with multiple choices

If the information in the "detailed connectivity matrix" is not complete/accurate, we can have the following drawbacks:

• If only the VP1-VP4 path with available bandwidth of 2 Gb/s and cost 50 is reported, the client's PCE will fail to compute a 5 Gb/s path between routers R1 and R2, although this would be feasible;
• If only the VP1-VP4 path with available bandwidth of 10 Gb/s and cost 65 is reported, the client's PCE will compute, as optimal, the 1 Gb/s path between R1 and R2 going through the VP2-VP5 path within the optical domain while the optimal path would actually be the one going through the VP1-VP4 sub-path (with cost 50) within the optical domain. Reporting all the information, as in , using the "detailed connectivity matrix", is quite challenging from a scalability perspective. The amount of this information is not just based on number of end points (which would scale as N-square), but also on many other parameters, including client rate, user constraints/policies for the service, e.g. max latency < N ms, max cost, etc., exclusion policies to route around busy links, min Optical Signal to Noise Ratio (OSNR) margin, max pre-Forward Error Correction (FEC) Bit Error Rate (BER) etc. All these constraints could be different based on connectivity requirements. It is also worth noting that the "connectivity matrix" has been originally defined in Wavelength Switched Optical Networks (WSON), , to report the connectivity constraints of a physical node within the Wavelength Division Multiplexing (WDM) network: the information it contains is pretty "static" and therefore, once taken and stored in the TE data base, it can be always being considered valid and up-to-date in path computation request. The "connectivity matrix" is sometimes confused with "optical reach table" that contain multiple (e.g. k-shortest) regen-free reachable paths for every A-Z node combination in the network. Optical reach tables can be calculated offline, utilizing vendor optical design and planning tools, and periodically uploaded to the Controller: these optical path reach tables are fairly static. However, to get the connectivity matrix, between any two sites, either a regen free path can be used, if one is available, or multiple regen free paths are concatenated to get from the source to the destination, which can be a very large combination. Additionally, when the optical path within optical domain needs to be computed, it can result in different paths based on input objective, constraints, and network conditions. In summary, even though "optical reach table" is fairly static, which regen free paths to build the connectivity matrix between any source and destination is very dynamic, and is done using very sophisticated routing algorithms. Using the "basic connectivity matrix" with an abstract node to abstract the information regarding the connectivity constraints of an Optical domain, would make this information more "dynamic" since the connectivity constraints of an optical domain can change over time because some optical paths that are feasible at a given time may become unfeasible at a later time when e.g., another optical path is established. The information in the "detailed connectivity matrix" is even more dynamic since the establishment of another optical path may change some of the parameters (e.g., delay or available bandwidth) in the "detailed connectivity matrix" while not changing the feasibility of the path. There is therefore the need to keep the information in the "detailed connectivity matrix" updated which means that there another tradeoff between the accuracy (i.e., providing "all" the information that might be needed by the client's PCE) and having up-to-date information. The more the information is provided and the longer it takes to keep it up-to-date which increases the likelihood that the client's PCE computes paths using not updated information. It seems therefore quite challenging to have a "detailed connectivity matrix" that provides accurate, scalable and updated information to allow the client's PCE to take optimal decisions by its own. Considering the example in with the approach defined in this document, the client, when it needs to set up an end-to-end path, it can request the Optical Domain Controller to compute a set of optimal paths (e.g., for VP1-VP4 and VP2-VP5) and take decisions based on the information received:
• When setting up a 5 Gb/s path between routers R1 and R2, the Optical Domain Controller may report only the VP1-VP4 path as the only feasible path: the Packet/Optical Coordinator can successfully set up the end-to-end path passing though this optical path;
• When setting up a 1 Gb/s path between routers R1 and R2, the Optical Domain Controller (knowing that the path requires only 1 Gb/s) can report both the VP1-VP4 path, with cost 50, and the VP2- VP5 path, with cost 65. The Packet/Optical Coordinator can then compute the optimal path which is passing through the VP1-VP4 sub- path (with cost 50) within the optical domain.

TE topology abstraction Using the TE topology model, as defined in , the underlying controller can export to its client an abstract TE topology, composed by a set of TE nodes and TE links, representing the abstract view of the topology under its control. For example, in the multi-domain TE network use case, described in , the TE Domain Controller 1 can export a TE topology encompassing the TE nodes A, B, C and D and the TE links interconnecting them. In a similar way, the TE Domain Controller 2 can export a TE topology encompassing the TE nodes E, F, G and H and the TE links interconnecting them. In this example, for simplicity reasons, each abstract TE node maps with each physical node, but this is not necessary. In order to set up a multi-domain TE path (e.g., between nodes A and H), the Multi-Domain Controller can compute by its own an optimal end-to-end path based on the abstract TE topology information provided by the domain controllers. For example:

• Multi-Domain Controller can compute, based on its own TED data, the optimal multi-domain path being A-B-C-E-G-H, and then request the TE Domain Controllers to set up the A-B-C and E-G-H intra- domain paths
• But, during path set-up, the TE Domain Controller may find out that A-B-C intra-domain path is not feasible (as discussed in , in optical networks it is typical to have some paths not being feasible due to optical constraints that are known only by the Optical Domain Controller), while only the path A-B-D is feasible
• So what the Multi-Domain Controller has computed is not good and it needs to re-start the path computation from scratch As discussed in , providing more extensive abstract information from the TE Domain Controllers to the Multi-Domain Controller may lead to scalability problems. In a sense this is similar to the problem of routing and wavelength assignment within an optical domain. It is possible to do first routing (step 1) and then wavelength assignment (step 2), but the chances of ending up with a good path is low. Alternatively, it is possible to do combined routing and wavelength assignment, which is known to be a more optimal and effective way for optical path set-up. Similarly, it is possible to first compute an abstract end-to-end path within the Multi-Domain Controller (step 1) and then compute an intra-domain path within each optical domain (step 2), but there are more chances not to find a path or to get a suboptimal path than by performing multiple per-domain path computations and then stitching them together.

Complementary use of the TE topology As discussed in , there are some scalability issues with path computation requests in a multi-domain TE network with many TE domains, in terms of the number of requests to send to the TE Domain Controllers. It would therefore be worthwhile using the abstract TE topology information provided by the TE Domain Controllers to limit the number of requests. An example can be described considering the multi-domain abstract TE topology shown in . In this example, an end-to-end TE path between domains A and F needs to be set up. The transit TE domain should be selected between domains B, C, D and E.

Multi-domain with many domains (Topology information) =30 \: :.................: :/ cost>=30 : : O-----+ +-----O : :...........: | .........E......... | :...........: | : /-------------\ : | cost=5| :/ \: |cost=5 +---O cost >= 30 O---+ : : :.................: ]]>

The actual cost of each intra-domain path is not known a priori from the abstract topology information. The Multi-Domain Controller only knows, from the TE topology provided by the underlying domain controllers, the feasibility of some intra-domain paths and some upper-bound and/or lower-bound cost information. With this information, together with the cost of inter-domain links, the Multi- Domain Controller can understand by its own that:

• Domain B cannot be selected as the path connecting domains A and F is not feasible;
• Domain E cannot be selected as a transit domain since it is known from the abstract topology information provided by domain controllers that the cost of the multi-domain path A-E-F (which is 100, in the best case) will be always be higher than the cost of the multi-domain paths A-D-F (which is 90, in the worst case) and A-C-F (which is 80, in the worst case). Therefore, the Multi-Domain Controller can understand by its own that the optimal multi-domain path could be either A-D-F or A-C-F but it cannot know which one of the two possible option actually provides the optimal end-to-end path. The Multi-Domain Controller can therefore request path computation only to the TE Domain Controllers A, D, C and F (and not to all the possible TE Domain Controllers).

Multi-domain with many domains (Path Computation information)

Based on these requests, the Multi-Domain Controller can know the actual cost of each intra-domain paths which belongs to potential optimal end-to-end paths, as shown in , and then compute the optimal end-to-end path (e.g., A-D-F, having total cost of 50, instead of A-C-F having a total cost of 70).

Path Computation RPC The TE tunnel YANG data model, defined in , can support the need to request path computation, as described in section 5.1.2 of . This solution is stateful since the state of each created "compute- only" TE tunnel path needs to be maintained, in the YANG datastores (at least in the running datastore and operational datastore), and updated, when underlying network conditions change. The RPC mechanism allows requesting path computation using a simple atomic operation, without creating any state in the YANG datastores, and it is the natural option/choice, especially with stateless PCE. It is very useful to provide both the options of using an RPC as well as of setting up TE tunnel paths in "compute-only" mode. It is suggested to use the RPC as much as possible and to rely on "compute-only" TE tunnel paths, when really needed. Using the RPC solution would imply that the underlying controller (e.g., a PNC) computes a path twice during the process to set up an LSP: at time T1, when its client (e.g., an MDSC) sends a path computation RPC request to it, and later, at time T2, when the same client (MDSC) creates a TE tunnel requesting the set-up of the LSP. The underlying assumption is that, if network conditions have not changed, the same path that has been computed at time T1 is also computed at time T2 by the underlying controller (e.g. PNC) and therefore the path that is set up at time T2 is exactly the same path that has been computed at time T1. However, since the operation is stateless, there is no guarantee that the returned path would still be available when path set-up is requested: this does not cause major issues when the time between path computation and path set-up is short (especially if compared with the time that would be needed to update the information of a very detailed connectivity matrix). In most of the cases, there is even no need to guarantee that the path that has been set up is the exactly same as the path that has been returned by path computation, especially if it has the same or even better metrics. Depending on the abstraction level applied by the server, the client may also not know the actual computed path. The most important requirement is that the required global objectives (e.g., multi-domain path metrics and constraints) are met. For this reason a path verification phase is always necessary to verify that the actual path that has been set up meets the global objectives (for example in a multi-domain network, the resulting end-to-end path meets the required end-to-end metrics and constraints). In most of the cases, even if the path being set up is not exactly the same as the path returned by path computation, its metrics and constraints are "good enough" and the path verification passes successfully. In the few corner cases where the path verification fails, it is possible repeat the whole process (path computation, path set-up and path verification). In case it is required to set up at T2 exactly the same path computed at T1, the RPC solution should not be used and, instead, a "compute- only" TE tunnel path should be set up, allowing also notifications in case the computed path has been changed. In this case, at time T1, the client (MDSC) creates a TE tunnel in a compute-only mode in the running datastore and later, at time T2, changes the configuration of that TE tunnel (not to be any more in a compute-only mode) to trigger the set-up of the LSP over the path which have been computed at time T1 and reported in the operational datastore. It is worth noting that also using the "compute-only" TE tunnel path, although increasing the likelihood that the computed path is available at path set-up, does not guarantee that because notifications may not be reliable or delivered on time. Path verification is needed also in this case. The solution based on "compute-only" TE tunnel path has also the following drawbacks:

• Several messages required for any path computation
• Requires persistent storage in the underlying controller
• Need for garbage collection for stranded paths
• Process burden to detect changes on the computed paths in order to provide notifications update

Temporary reporting of the computed path state This section describes an optional extension to the stateless behavior of the path computation RPC, where the underlying controller, after having received a path computation RPC request, maintains some "transient state" associated with the computed path, allowing the client to request the set-up of exactly that path, if still available. This is similar to the "compute-only" TE tunnel path solution but, to avoid the drawbacks of the stateful approach, is leveraging the path computation RPC and the separation between configuration and operational datastore, as defined in the NMDA architecture . The underlying controller, after having computed a path, as requested by a path computation RPC, also creates a TE tunnel instance within the operational datastore, to store that computed path. This would be similar to a "compute-only" TE tunnel path, with the only difference that there is no associated TE tunnel instance within the running datastore. Since the underlying controller stores in the operational datastore the computed path based on an abstract topology it exposes, it also remembers, internally, which is the actual native path (physical path), within its native topology (physical topology), associated with that compute-only TE tunnel instance. Afterwards, the client (e.g., MDSC) can request the set-up of that specific path by creating a TE tunnel instance (not in compute-only mode) in the running datastore using the same tunnel-name of the existing TE tunnel in the operational datastore: this will trigger the underlying controller to set up that path, if still available. There are still cases where the path being set up is not exactly the same as the path that has been computed:

• When the tunnel is configured with path constraints which are not compatible with the computed path;
• When the tunnel set-up is requested after the resources of the computed path are no longer available;
• When the tunnel set-up is requested after the computed path is no longer known (e.g. due to a server reboot) by the underlying controller. In all these cases, the underlying controller should compute and set up a new path. Therefore the "path verification" phase, as described in above, is always needed to check that the path that has been set up is still "good enough". Since this new approach is not completely stateless, garbage collection is implemented using a timeout that, when it expires, triggers the removal of the computed path from the operational datastore. This operation is fully controlled by the underlying controller without the need for any action to be taken by the client that is not able to act on the operational datastore. The default value of this timeout is 10 minutes but a different value may be configured by the client. In addition, it is possible for the client to tag each path computation request with a transaction-id allowing for a faster removal of all the paths associated with a transaction-id, without waiting for their timers to expire. The underlying controller can remove from the operational datastore all the paths computed with a given transaction-id which have not been set up either when it receives a Path Delete RPC request for that transaction-id or, automatically, right after the set-up of a path that has been previously computed with that transaction-id. This possibility is useful when multiple paths are computed but, at most, only one is set up (e.g., in multi-domain path computation scenario scenarios). After the selected path has been set up (e.g, in one domain during multi-domain path set-up), all the other alternative computed paths can be automatically deleted by the underlying controller (since no longer needed). The client can also request, using the Path Delete RPC request, the underlying controller to remove all the computed paths, if none of them is going to be set up (e.g., in a transit domain not being selected by multi-domain path computation and so not being automatically deleted). This approach is complementary and not alternative to the timer which is always needed to avoid stranded computed paths being stored in the operational datastore when no path is set up and no explicit Path Delete RPC request is received.

Path computation and optimization for multiple paths There are use cases, where it is advantageous to request path computation for a set of paths, through a network or through a network domain, using a single request . In this case, sending a single request for multiple path computations, instead of sending multiple requests for each path computation, would reduce the protocol overhead and it would consume less resources (e.g., threads in the client and server). In the context of a typical multi-domain TE network, there could multiple choices for the ingress/egress points of a domain and the Multi-Domain Controller needs to request path computation between all the ingress/egress pairs to select the best pair. For example, in the example of , the Multi-Domain Controller needs to request the TE Network Controller 1 to compute the A-C and the A-D paths and to the TE Network Controller 2 to compute the E-H and the F-H paths. It is also possible that the Multi-Domain Controller receives a request to set up a group of multiple end to end connections. The Multi-Domain Controller needs to request each TE domain Controller to compute multiple paths, one (or more) for each end to end connection. There are also scenarios where it can be needed to request path computation for a set of paths in a synchronized fashion. One example could be computing multiple diverse paths. Computing a set of diverse paths in an unsynchronized fashion, leads to the possibility of not being able to satisfy the diversity requirement. In this case, it is preferable to compute a sub-optimal primary path for which a diversely routed secondary path exists. There are also scenarios where it is needed to request optimizing a set of paths using objective functions that apply to the whole set of paths, see , e.g. to minimize the sum of the costs of all the computed paths in the set.

YANG data model for requesting Path Computation This document defines a YANG RPC to request path computation as an "augmentation" of tunnel-rpc, defined in . This model provides the RPC input attributes that are needed to request path computation and the RPC output attributes that are needed to report the computed paths. This model extensively re-uses the grouping defined in and to ensure maximal syntax and semantics commonality. This YANG data model allows one RPC to include multiple path requests, each path request being identified by a request-id. Therefore, one RPC can return multiple responses, one for each path request, being identified by a response-id equal to the corresponding request-id. Each response reports one or more computed paths, as requested by the k-requested-paths attribute. By default, each response reports one computed path.

Synchronization of multiple path computation requests The YANG data model permits the synchronization of a set of multiple path requests (identified by specific request-id) all related to a "svec" container emulating the syntax of the Synchronization VECtor (SVEC) PCEP object, defined in . The model, in addition to the metric types, defined in , which can be applied to each individual path request, supports also additional metric types, which apply to a set of synchronized requests, as referenced in . These additional metric types are defined by the following YANG identities:

• svec-metric-type: base YANG identity from which cumulative metric types identities are derived.
• svec-metric-cumul-te: cumulative TE cost metric type, as defined in .
• svec-metric-cumul-igp: cumulative IGP cost metric type, as defined in .
• svec-metric-cumul-hop: cumulative Hop metric type, representing the cumulative version of the Hop metric type defined in .
• svec-metric-aggregate-bandwidth-consumption: aggregate bandwidth consumption metric type, as defined in .
• svec-metric-load-of-the-most-loaded-link: load of the most loaded link metric type, as defined in .

Returned metric values This YANG data model provides a way to return the values of the metrics computed by the path computation in the output of RPC, together with other important information (e.g. SRLG, affinities, explicit route), emulating the syntax of the "C" flag of the "METRIC" PCEP object : It also allows the client to request which information (metrics, SRLG and/or affinities) should be returned: This feature is essential for path computation in a multi-domain TE network as described in . In this case, the metrics returned by a path computation requested to a given underlying controller must be used by the client to compute the best end-to-end path. If they are missing, the client cannot compare different paths calculated by the underlying controllers and choose the best one for the optimal end-to-end (e2e) path.

Multiple Paths Requests for the same TE tunnel The YANG data model allows including multiple requests for different paths intended to be used within the same tunnel or within different tunnels. When multiple requested paths are intended to be used within the same tunnel (e.g., requesting path computation for the primary and secondary paths of a protected tunnel), the set of attributes that are intended to be configured on per-tunnel basis rather than on per- path basis are common to all these path requests. These attributes includes both attributes which can be configured only a per-tunnel basis (e.g., tunnel-name, source/destination TTP, encoding and switching-type) as well attributes which can be configured both on a per-tunnel and on a per-path basis (e.g., the te-bandwidth or the associations). Therefore, a tunnel-attributes list is defined, within the path computation request RPC: The path requests that are intended to be used within the same tunnel should reference the same entry in the tunnel-attributes list. This allows:

• avoiding repeating the same set of per-tunnel parameters on multiple requested paths;
• the server to understand what attributes are intended to be configured on a per-tunnel basis (e.g., the te-bandwidth configured in the tunnel-attributes) and what attributes are intended to be configured on a per-path basis(e.g., the te- bandwidth configured in the path-request). This could be useful especially when the server also creates a TE tunnel instance within the operational datastore to report the computed paths, as described in : in this case, the tunnel-name is also used as the suggested name for that TE tunnel instance. The YANG data model allows also including requests for paths intended to modify existing tunnels (e.g., adding a protection path for an existing un-protected tunnel). In this case, the per-tunnel attributes are already provided in an existing TE tunnel instance and do not need to be re-configured in the path computation request RPC. Therefore, these requests should reference an existing TE tunnel instance. It is also possible to request computing paths without indicating in which tunnel they are intended to be used (e.g., in case of an unprotected tunnel). In this case, the per-tunnel attributes could be provided together with the per-path attributes in the path request, without using the tunnel-attributes list. The choices below are defined to distinguish the cases above:
• whether the per-tunnel attributes are configured by reference (providing a leafref), to:
  • either a TE tunnel instance, if it exists;
  • or to an entry of the tunnel-attributes list, if the TE tunnel instance does not exist;
• or by value, providing the set of tunnel attributes within the path request:

Tunnel attributes specified by value The (value) case provides the set of attributes that are configured only on per-tunnel basis (e.g., tunnel-name, source/destination TTP, encoding and switching-type). In this case, it is assumed that the requested path will be the only path within a tunnel. If the only path within a tunnel is the transit segment of a multi-domain end-to-end path, it can be of any type (primary, secondary, reverse-primary or reverse-secondary). The (path-role) choice is used to specify its role in the path request: In all the other cases, the only path within a tunnel is a primary path. The secondary-path, the primary-reverse-path and the secondary- reverse-path are presence container used to indicate the role of the path: by default, the path is assumed to be a primary path. They optionally can contain the name of the primary-path under which the requested path could be associated within the YANG tree structure defined in , which could be useful when the server also creates a TE tunnel instance within the operational datastore to report the computed paths, as described in : in this case, the tunnel-name and the path names are also used as the suggested name for that TE tunnel and path instances.

Tunnel attributes specified by reference The (reference) case provides the information needed to associate multiple path requests that are intended to be used within the same tunnel. In order to indicate the role of the path being requested within the intended tunnel (e.g., primary or secondary path), the (path-role) choice is defined: The primary-path is a presence container used to indicate that the requested path is intended to be used as a primary path. It can also contain some attributes which are configured only on primary paths (e.g., the k-requested-paths). The secondary-path container indicates that the requested path is intended to be used as a secondary path and it contains at least references to one or more primary paths which can use it as a candidate secondary path: A requested secondary path can reference any requested primary paths, and, in case they are intended to be used within an existing TE tunnel, it could also reference any existing primary-paths. The secondary-path container can also contain some attributes which are configured only on secondary paths (e.g., the protection-type). The primary-reverse-path container indicates that the requested path is intended to be used as a primary reverse path and it contains only the reference to the primary path which is intended to use it as a reverse path: A requested primary reverse path can reference either a requested primary path, or, in case it is intended to be used within an existing TE tunnel, an existing primary-path. The secondary-reverse-path container indicates that the requested path is intended to be used as a secondary reverse path and it contains at least references to one or more primary paths, whose primary reverse path can use it as a candidate secondary reverse path: A requested secondary reverse path can reference any requested primary paths, and, in case they are intended to be used within an existing TE tunnel, it could reference also existing primary-paths. The secondary-reverse-path container can also contain some attributes which are configured only on secondary reverse paths (e.g., the protection-type). In case the requested path is a transit segment of a multi-domain end-to-end path, the primary-path may not be needed to be setup/computed. However, the request for path computation of a secondary-path or a primary-reverse or of a secondary-reverse-path requires that the primary-path exists or it is requested within the same RPC request. In the latter case, the path request for the primary-path should have an empty 'route-object-include-exclude' list, as described in section 5.1.1 of , to indicate to the server that path computation is not requested and no path properties will therefore be returned in the RPC response.

Multi-Layer Path Computation The models supports requesting multi-layer path computation following the same approach based on dependency tunnels, as defined in . The tunnel-attributes of a given client-layer path request can reference server-layer TE tunnels which can already exist in the YANG datastore or be specified in the tunnel-attributes list, within the same RPC request: /te:te/tunnels/tunnel/name | | | +-- encoding? identityref | | | +-- switching-type? identityref | | +-- dependency-tunnel-attributes* [name] | | +-- name leafref | | +-- encoding? identityref | | +-- switching-type? identityref ]]> In a similar way as in , the server-layer tunnel attributes should provide the information of what would be the dynamic link in the client layer topology supported by that tunnel, if instantiated: It is worth noting that since path computation RPC is stateless, the dynamic hierarchical links configured for the server-layer tunnel attributes cannot be used for path computation of any client-layer path unless explicitly referenced in the dependency-tunnel-attributes list within the same RPC request.

YANG data model for TE path computation

Tree diagram below shows the tree diagram of the YANG data model defined in module ietf-te-path-computation.yang, defined in .

TE path computation tree diagram

YANG module

TE path computation YANG module WG List: Editor: Italo Busi Editor: Sergio Belotti Editor: Victor Lopez Editor: Oscar Gonzalez de Dios Editor: Anurag Sharma Editor: Yan Shi Editor: Ricard Vilalta Editor: Karthik Sethuraman Editor: Michael Scharf Editor: Daniele Ceccarelli "; description "This module defines a YANG data model for requesting Traffic Engineering (TE) path computation. The YANG data model defined in this document augments the RPCs defined in the generic TE module (ietf-te). The model fully conforms to the Network Management Datastore Architecture (NMDA). Copyright (c) 2026 IETF Trust and the persons identified as authors of the code. All rights reserved. Redistribution and use in source and binary forms, with or without modification, is permitted pursuant to, and subject to the license terms contained in, the Revised BSD License set forth in Section 4.c of the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info). This version of this YANG module is part of RFC XXXX; see the RFC itself for full legal notices. The key words 'MUST', 'MUST NOT', 'REQUIRED', 'SHALL', 'SHALL NOT', 'SHOULD', 'SHOULD NOT', 'RECOMMENDED', 'NOT RECOMMENDED', 'MAY', and 'OPTIONAL' in this document are to be interpreted as described in BCP 14 (RFC 2119) (RFC 8174) when, and only when, they appear in all capitals, as shown here."; // RFC Ed.: replace XXXX with actual RFC number and remove // this note // replace the revision date with the module publication date // the format is (year-month-day) revision 2026-04-20 { description "Initial revision"; reference "RFC XXXX: A YANG Data Model for requesting path computation"; } // RFC Ed.: replace XXXX with actual RFC number and remove // this note /* * Features */ feature svec { description "This feature indicates that the server supports synchronized path computation requests."; reference "RFC 5440: Path Computation Element (PCE) Communication Protocol (PCEP), Section 7.13"; } feature compute-priority { description "This feature indicates that the server supports path computation request's priority"; reference "RFC 5440: Path Computation Element (PCE) Communication Protocol (PCEP), Section 7.4.1"; } /* * Identities */ identity tunnel-action-path-compute-delete { base te-types:tunnel-action-type; description "Action type to delete the transient states of computed paths."; reference "RFC XXXX: A YANG Data Model for requesting path computation, Section 3.3.1"; } /* * Groupings */ grouping protection-restoration-properties { description "This grouping defines the restoration and protection types for a path in the path computation request."; leaf protection-type { type identityref { base te-types:lsp-protection-type; } default "te-types:lsp-protection-unprotected"; description "LSP protection type."; } leaf restoration-type { type identityref { base te-types:lsp-restoration-type; } default "te-types:lsp-restoration-restore-any"; description "LSP restoration type."; } leaf restoration-scheme { type identityref { base te-types:restoration-scheme-type; } default "te-types:restoration-scheme-preconfigured"; description "LSP restoration scheme."; } } // grouping protection-restoration-properties grouping requested-info { description "This grouping defines the information which is requested (e.g., metrics), in the path computation request, to be returned in the path computation response."; list requested-metrics { key "metric-type"; description "The list of the requested metrics. The metrics listed here MUST be returned in the response. Returning other metrics in the response is OPTIONAL."; leaf metric-type { type identityref { base te-types:path-metric-type; } description "The metric requested to be returned in the response"; } } leaf return-srlgs { type boolean; default "false"; description "If true, path Shared Risk Link Groups (SRLGs) MUST be returned in the response. If false, returning path SRLGs in the response OPTIONAL."; } leaf return-affinities { type boolean; default "false"; description "If true, path affinities MUST be returned in the response. If false, returning path affinities in the response is OPTIONAL."; } } // grouping requested-info grouping requested-state { description "Configuration for the transient state used to report the computed path"; container requested-state { presence "Request temporary reporting of the computed path state"; description "Configures attributes for the temporary reporting of the computed path state (e.g., expiration timer)."; leaf timer { type uint16; units "minutes"; default "10"; description "The timeout after which the transient state reporting the computed path SHOULD be removed."; } leaf transaction-id { type string; description "The transaction-id associated with this path computation to be used for fast deletion of the transient states associated with multiple path computations. This transaction-id can be used to explicitly delete all the transient states of all the computed paths associated with the same transaction-id. When one path associated with a transaction-id is setup, the transient states of all the other computed paths with the same transaction-id are automatically removed. If not specified, the transient state is removed only when the timer expires (when the timer is specified) or not created at all (stateless path computation, when the timer is not specified)."; } } } // grouping requested-state grouping reported-state { description "This grouping defines the information, returned in the path computation response, reporting the transient state related to the computed path"; leaf tunnel-ref { type te:tunnel-ref; description " Reference to the tunnel that reports the transient state of the computed path. If no transient state is created, this attribute is omitted. "; } choice path-role { description "The transient state of the computed path can be reported as a primary, primary-reverse, secondary or a secondary-reverse path of a te-tunnel"; case primary { leaf primary-path-ref { type leafref { path "/te:te/te:tunnels/" + "te:tunnel[te:name=current()/../tunnel-ref]/" + "te:primary-paths/te:primary-path/" + "te:name"; } must '../tunnel-ref' { description "The primary-path name can only be reported if the tunnel name is also reported."; } description " Reference to the primary-path that reports the transient state of the computed path. If no transient state is created, this attribute is omitted. "; } } // case primary case primary-reverse { leaf primary-reverse-path-ref { type leafref { path "/te:te/te:tunnels/" + "te:tunnel[te:name=current()/../tunnel-ref]/" + "te:primary-paths/te:primary-path/" + "te:name"; } must '../tunnel-ref' { description "The primary-reverse-path name can only be reported if the tunnel name is also reported."; } description " Reference to the primary-reverse-path that reports the transient state of the computed path. If no transient state is created, this attribute is omitted. "; } } // case primary-reverse case secondary { leaf secondary-path-ref { type leafref { path "/te:te/te:tunnels/" + "te:tunnel[te:name=current()/../tunnel-ref]/" + "te:secondary-paths/te:secondary-path/" + "te:name"; } must '../tunnel-ref' { description "The secondary-path name can only be reported if the tunnel name is also reported."; } description " Reference to the secondary-path that reports the transient state of the computed path. If no transient state is created, this attribute is omitted. "; } } // case secondary case secondary-reverse { leaf secondary-reverse-path-ref { type leafref { path "/te:te/te:tunnels/" + "te:tunnel[te:name=current()/../tunnel-ref]/" + "te:secondary-reverse-paths/" + "te:secondary-reverse-path/te:name"; } must '../tunnel-ref' { description "The secondary-reverse-path name can only be reported if the tunnel name is also reported."; } description " Reference to the secondary-reverse-path that reports the transient state of the computed path. If no transient state is created, this attribute is omitted. "; } } // case secondary } // choice path } // grouping reported-state grouping synchronization-constraints { description "Global constraints applicable to synchronized path computation requests."; container svec-constraints { description "global svec constraints"; list path-metric-bound { key "metric-type"; description "list of bound metrics"; leaf metric-type { type identityref { base te-types:svec-metric-type; } description "SVEC metric type."; reference "RFC 5541: Encoding of Objective Functions in the Path Computation Element Communication Protocol (PCEP)"; } leaf upper-bound { type uint64; description "Upper bound on SVEC metric"; } } } uses te-types:generic-path-srlgs; container exclude-objects { description "Resources to be excluded"; list excludes { description "List of Explicit Route Objects to always exclude from synchronized path computation"; uses te-types:explicit-route-hop; } } } // grouping synchronization-constraints grouping synchronization-optimization { description "Optimizations applicable to synchronized path computation requests."; container optimizations { description "The objective function container that includes attributes to impose when computing a synchronized set of paths"; choice algorithm { description "Optimizations algorithm."; case metric { if-feature "te-types:path-optimization-metric"; list optimization-metric { key "metric-type"; description "svec path metric type"; leaf metric-type { type identityref { base te-types:svec-metric-type; } description "TE path metric type usable for computing a set of synchronized requests"; } leaf weight { type uint8; description "Metric normalization weight"; } } } case objective-function { if-feature "te-types:path-optimization-objective-function"; container objective-function { description "The objective function container that includes attributes to impose when computing a TE path"; leaf objective-function-type { type identityref { base te-types:svec-objective-function-type; } description "Objective function entry"; } } } } } } // grouping synchronization-optimization grouping synchronization-info { description "Information for synchronized path computation requests."; list synchronization { description "List of Synchronization VECtors."; container svec { description "Synchronization VECtor"; leaf relaxable { type boolean; default "true"; description "If this leaf is true, taking into account this svec is OPTIONAL and the path computation process is free to ignore svec content. Otherwise, it MUST take into account this svec."; } uses te-types:generic-path-disjointness; leaf-list request-id { type uint32; description "This list reports the set of path computation requests that are requested to be synchronized."; } } uses synchronization-constraints; uses synchronization-optimization; } } // grouping synchronization-info /* * Augment TE RPCs */ augment "/te:tunnels-path-compute/te:input/te:path-compute-info" { description "Augments Path Computation RPC input"; list path-request { key "request-id"; description "The list of the requested paths to be computed"; leaf request-id { type uint32; mandatory true; description "Each path computation request is uniquely identified within the RPC request by the request-id."; } leaf compute-priority { if-feature "compute-priority"; type uint8; default "0"; description "The path computation request's priority (from 1 to 7) which can be used to constraint the order by which the path computation server processes the path computation requests. A higher numerical value of the priority field reflects a higher priority. It MUST be set to the default value (i.e., 0) when unused."; reference "RFC 5440: Path Computation Element (PCE) Communication Protocol (PCEP), Section 7.4.1"; } choice tunnel-attributes { default "value"; description "Whether the tunnel attributes are specified by value within this path computation request or by reference. The reference could be either to an existing te-tunnel or to an entry in the tunnel-attributes list"; case reference { container tunnel-reference { description "Attributes for a requested path that belongs to either an exiting te-tunnel or to an entry in the tunnel-attributes list."; choice tunnel-exist { mandatory true; description "Whether the tunnel reference is to an existing te-tunnel or to an entry in the tunnel-attributes list"; case tunnel-ref { leaf tunnel-ref { type te:tunnel-ref; mandatory true; description "The referenced te-tunnel instance"; } } // case tunnel-ref case tunnel-attributes-ref { leaf tunnel-attributes-ref { type leafref { path "/te:tunnels-path-compute/" + "te:path-compute-info/" + "te-pc:tunnel-attributes/te-pc:tunnel-name"; } mandatory true; description "The referenced te-tunnel instance"; } } // case tunnel-attributes-ref } // choice tunnel-exist leaf path-name { type string; description "TE path name."; } choice path-role { mandatory true; description "Whether this path is a primary, or a reverse primary, or a secondary, or a reverse secondary path."; case primary-path { container primary-path { presence "Indicates that the requested path is a primary path"; description "TE primary path"; uses te:path-forward-properties; uses te:k-requested-paths; } // container primary-path } // case primary-path case secondary-path { container secondary-path { description "TE secondary path"; leaf secondary-reverse-path { type leafref { path "/te:tunnels-path-compute/" + "te:path-compute-info/" + "te-pc:path-request/te-pc:request-id"; } description "A reference to the reverse secondary path when co-routed with the secondary path."; } leaf preference { type uint8 { range "1..255"; } default "1"; description "Specifies a preference for this path. The lower the number higher the preference."; } uses protection-restoration-properties; list primary-path-ref { min-elements 1; description "The list of primary paths that reference this path as a candidate secondary path"; choice primary-path-exist { mandatory true; description "Whether the path reference is to an existing te-tunnel path or to another path request"; case path-ref { leaf primary-path-ref { type leafref { path "/te:te/te:tunnels/te:tunnel" + "[te:name=current()/../../../" + "tunnel-ref]/te:primary-paths/" + "te:primary-path/te:name"; } must '../../../tunnel-ref' { description "The primary-path can be referenced if also the tunnel is referenced."; } mandatory true; description "The referenced primary path"; } } // case path-ref case path-request-ref { leaf path-request-ref { type leafref { path "/te:tunnels-path-compute/" + "te:path-compute-info/" + "te-pc:path-request/" + "te-pc:request-id"; } mandatory true; description "The referenced primary path request"; } } // case path-request-ref } // choice primary-path-exist } // list primary-path-ref } // container secondary-path } // case secondary-path case primary-reverse-path { container primary-reverse-path { description "TE primary reverse path"; choice primary-path-exist { mandatory true; description "Whether the path reference to the primary paths for which this path is the reverse-path is to an existing te-tunnel path or to another path request."; case path-ref { leaf primary-path-ref { type leafref { path "/te:te/te:tunnels/te:tunnel[te:name" + "=current()/../../tunnel-ref]/" + "te:primary-paths/te:primary-path/" + "te:name"; } must '../../tunnel-ref' { description "The primary-path can be referenced if also the tunnel is referenced."; } mandatory true; description "The referenced primary path"; } } // case path-ref case path-request-ref { leaf path-request-ref { type leafref { path "/te:tunnels-path-compute/" + "te:path-compute-info/" + "te-pc:path-request/" + "te-pc:request-id"; } mandatory true; description "The referenced primary path request"; } } // case path-request-ref } // choice primary-path-exist } // container primary-reverse-path } // case primary-reverse-path case secondary-reverse-path { container secondary-reverse-path { description "TE secondary reverse path"; // uses te:path-preference; leaf preference { type uint8 { range "1..255"; } default "1"; description "Specifies a preference for this path. The lower the number higher the preference."; } uses protection-restoration-properties; list primary-reverse-path { min-elements 1; description "The list of primary reverse paths that reference this path as a candidate secondary reverse path"; choice primary-reverse-path-exist { mandatory true; description "Whether the path reference is to an existing te-tunnel path or to another path request"; case path-ref { leaf primary-path-ref { type leafref { path "/te:te/te:tunnels/te:tunnel" + "[te:name=current()/../../../" + "tunnel-ref]/te:primary-paths/" + "te:primary-path/te:name"; } must '../../../tunnel-ref' { description "The primary-path can be referenced if also the tunnel is referenced."; } mandatory true; description "The referenced primary path"; } } // case path-ref case path-request-ref { leaf path-request-ref { type leafref { path "/te:tunnels-path-compute/" + "te:path-compute-info/" + "te-pc:path-request/" + "te-pc:request-id"; } mandatory true; description "The referenced primary reverse path request"; } } // case path-request-ref } // choice primary-reverse-path-exist } // list primary-reverse-path-ref } // container secondary-reverse-path } // case secondary-reverse-path } // choice tunnel-path-role } } // case reference case value { leaf tunnel-name { type string; description "TE tunnel name."; } leaf path-name { type string; description "TE path name."; } choice path-role { when 'not (./source) and not (./destination)' { description "When the tunnel attributes are specified by value within this path computation, it is assumed that the requested path will be the only path of a tunnel. If the requested path is a transit segment path (i.e., the source and destination containers are not present), it could be of any type. Otherwise it could only be a primary path."; } default "primary-path"; description "Indicates whether the requested path is a primary path, a secondary path, a reverse primary path or a reverse secondary path."; case primary-path { description "The requested path is a primary path."; } container secondary-path { presence "Indicates that the requested path is a secondary path."; description "The name of the primary path which the requested secondary path belongs to."; leaf primary-path-name { type string; description "TE primary path name."; } } // container secondary-path container primary-reverse-path { presence "Indicates that the requested path is a primary reverse path."; description "The name of the primary path which the requested primary reverse path belongs to."; leaf primary-path-name { type string; description "TE primary path name."; } } // container primary-reverse-path container secondary-reverse-path { presence "Indicates that the requested path is a secondary reverse path."; description "The names of the primary path and of the primary reverse path which the requested secondary reverse path belongs to."; leaf primary-path-name { type string; description "TE primary path name."; } leaf primary-reverse-path-name { type string; description "TE primary reverse path name."; } } // container primary-reverse-path } // choice path-role uses te:k-requested-paths; uses te-types:encoding-and-switching-type; uses te:tunnel-common-attributes; uses te-types:te-topology-identifier; } // case value } // choice tunnel-attributes uses te:path-compute-info; uses requested-info; uses requested-state; } list tunnel-attributes { key "tunnel-name"; description "Tunnel attributes common to multiple request paths"; leaf tunnel-name { type string; description "TE tunnel name."; } uses te-types:encoding-and-switching-type; uses te:tunnel-common-attributes; uses te:tunnel-associations-properties; uses protection-restoration-properties; uses te-types:tunnel-constraints; uses te:tunnel-hierarchy-properties { augment "hierarchy/dependency-tunnels" { description "Augment with the list of dependency tunnel requests."; list dependency-tunnel-attributes { key "name"; description "A tunnel request entry that this tunnel request can potentially depend on."; leaf name { type leafref { path "/te:tunnels-path-compute/" + "te:path-compute-info/te-pc:tunnel-attributes/" + "te-pc:tunnel-name"; } description "Dependency tunnel request name."; } uses te-types:encoding-and-switching-type; } } } } uses synchronization-info { if-feature "svec"; } } // path-compute rpc input augment "/te:tunnels-path-compute/te:output/" + "te:path-compute-result" { description "Augments Path Computation RPC output"; list response { key "response-id"; config false; description "response"; leaf response-id { type uint32; description "The response-id has the same value of the corresponding request-id."; } uses te:path-computation-response; uses reported-state; } } // path-compute rpc output augment "/te:tunnels-actions/te:input/te:tunnel-info/" + "te:filter-type" { description "Augment Tunnels Action RPC input filter types"; case path-compute-transactions { when "derived-from-or-self(../te:action-info/te:action, " + "'tunnel-action-path-compute-delete')"; description "Path Delete RPC input"; leaf-list path-compute-transaction-id { type string; description "The list of the transaction-id values of the transient states to be deleted"; } } } // path-delete rpc input augment "/te:tunnels-actions/te:output" { description "Augment Tunnels Action RPC output with path delete result"; container path-computed-delete-result { description "Path Delete RPC output"; leaf-list path-compute-transaction-id { type string; description "The list of the transaction-id values of the transient states that have been successfully deleted"; } } } // path-delete rpc output } ]]>

Security Considerations This document describes use cases of requesting Path Computation using YANG data models, which could be used at the ABNO Control Interface and/or between controllers in ACTN . As such, it does not introduce any new security considerations compared to the ones related to YANG specification, ABNO specification and ACTN Framework defined in , and . The YANG module defined in this document is designed to be accessed via the NETCONF protocol or RESTCONF protocol . The lowest NETCONF layer is the secure transport layer, and the mandatory-to-implement secure transport is Secure Shell (SSH) . The lowest RESTCONF layer is HTTPS, and the mandatory-to- implement secure transport is TLS . The Network Configuration Access Control Model (NACM) provides the means to restrict access for particular NETCONF or RESTCONF users to a preconfigured subset of all available NETCONF or RESTCONF protocol operations and content. The YANG module defined in this document augments the "tunnels-path-compute" and the "tunnel-actions" RPCs defined in . The security considerations provided in are also applicable to the YANG module defined in this document. The RPC defined in this document can also be used for Denial-of-service (DoS) attacks. The security considerations defined in section 10.7.2 of also applies to the use of this RPC. The definition of the input shaping/policing mechanisms and of their configuration is outside the scope of this document. Some of the RPC operations defined in this YANG module may be considered sensitive or vulnerable in some network environments. It is thus important to control access to these operations. These are the operations and their sensitivity/vulnerability: "te-pc:response/computed-paths-properties": provides the same information provided by the "te:computed-paths-properties" defined in . The security considerations provided in for the TE tunnel state apply also to this subtree. "te-pc:response/te-pc:tunnel-ref", "te-pc:response/te-pc:primary-path-ref", "te-pc:response/te-pc:primary-reverse-path-ref", "te-pc:response/te-pc:secondary-path-ref" and "te-pc:response/te-pc:secondary-reverse-path-ref" provides a reference where the same information provided in "te-pc:response/computed-paths-properties" is temporarily stored with the operational datastore (see ). Therefore access to this information does not provide any additional security issue that the information provided with "te-pc:response/computed-paths-properties". "/te:tunnels-actions": the YANG model defined in this document augments this action with a new action type that allows deleting the transient states of computed paths (see ). A malicious use of this action would have no impact on the paths carrying live traffic but it would preclude the client from using the "transient states" to request the set-up of exactly that path, if still available. The security considerations spelled out in the YANG specification apply for this document as well.

IANA Considerations This document registers the following URIs in the "ns" subregistry within the "IETF XML registry" . This document registers a YANG module in the "YANG Module Names" registry .

References Normative References The Network Configuration Protocol (NETCONF) defined in this document provides mechanisms to install, manipulate, and delete the configuration of network devices. It uses an Extensible Markup Language (XML)-based data encoding for the configuration data as well as the protocol messages. The NETCONF protocol operations are realized as remote procedure calls (RPCs). This document obsoletes RFC 4741. [STANDARDS-TRACK] This document describes an HTTP-based protocol that provides a programmatic interface for accessing data defined in YANG, using the datastore concepts defined in the Network Configuration Protocol (NETCONF). This document defines a YANG data model for representing, retrieving, and manipulating Traffic Engineering (TE) Topologies. The model serves as a base model that other technology-specific TE topology models can augment. Cisco Systems Inc Cisco Systems Inc Alef Edge Juniper Networks Individual This document defines a YANG data model for the provisioning and management of Traffic Engineering (TE) tunnels, Label Switched Paths (LSPs), and interfaces. The model covers data pertinent to TE tunnels, TE LSPs, and TE interfaces that are independent of any technology or dataplane encapsulation. The model is divided into two YANG modules that address both device-specific and device-independent data, supporting configuration, operational state, Remote Procedure Calls (RPCs), and event notifications. YANG is a data modeling language used to model configuration data, state data, Remote Procedure Calls, and notifications for network management protocols. This document describes the syntax and semantics of version 1.1 of the YANG language. YANG version 1.1 is a maintenance release of the YANG language, addressing ambiguities and defects in the original specification. There are a small number of backward incompatibilities from YANG version 1. This document also specifies the YANG mappings to the Network Configuration Protocol (NETCONF). This document specifies the Path Computation Element (PCE) Communication Protocol (PCEP) for communications between a Path Computation Client (PCC) and a PCE, or between two PCEs. Such interactions include path computation requests and path computation replies as well as notifications of specific states related to the use of a PCE in the context of Multiprotocol Label Switching (MPLS) and Generalized MPLS (GMPLS) Traffic Engineering. PCEP is designed to be flexible and extensible so as to easily allow for the addition of further messages and objects, should further requirements be expressed in the future. [STANDARDS-TRACK] In many standards track documents several words are used to signify the requirements in the specification. These words are often capitalized. This document defines these words as they should be interpreted in IETF documents. This document specifies an Internet Best Current Practices for the Internet Community, and requests discussion and suggestions for improvements. RFC 2119 specifies common key words that may be used in protocol specifications. This document aims to reduce the ambiguity by clarifying that only UPPERCASE usage of the key words have the defined special meanings. In Traffic-Engineered (TE) systems, it is sometimes desirable to establish an end-to-end TE path with a set of constraints (such as bandwidth) across one or more networks from a source to a destination. TE information is the data relating to nodes and TE links that is used in the process of selecting a TE path. TE information is usually only available within a network. We call such a zone of visibility of TE information a domain. An example of a domain may be an IGP area or an Autonomous System. In order to determine the potential to establish a TE path through a series of connected networks, it is necessary to have available a certain amount of TE information about each network. This need not be the full set of TE information available within each network but does need to express the potential of providing TE connectivity. This subset of TE information is called TE reachability information. This document sets out the problem statement for the exchange of TE information between interconnected TE networks in support of end-to-end TE path establishment and describes the best current practice architecture to meet this problem statement. For reasons that are explained in this document, this work is limited to simple TE constraints and information that determine TE reachability. This document captures the current syntax used in YANG module tree diagrams. The purpose of this document is to provide a single location for this definition. This syntax may be updated from time to time based on the evolution of the YANG language. Huawei Futurewei Technologies Alef Edge Cisco Systems Inc. Individual This document defines a collection of common data types, identities, and groupings in YANG data modeling language. These derived common data types, identities and groupings are intended to be imported by other modules, e.g., those which model the Traffic Engineering (TE) configuration and state capabilities. This document obsoletes RFC 8776. The ability to compute shortest constrained Traffic Engineering Label Switched Paths (TE LSPs) in Multiprotocol Label Switching (MPLS) and Generalized MPLS (GMPLS) networks across multiple domains has been identified as a key requirement. In this context, a domain is a collection of network elements within a common sphere of address management or path computational responsibility such as an IGP area or an Autonomous Systems. This document specifies a procedure relying on the use of multiple Path Computation Elements (PCEs) to compute such inter-domain shortest constrained paths across a predetermined sequence of domains, using a backward-recursive path computation technique. This technique preserves confidentiality across domains, which is sometimes required when domains are managed by different service providers. [STANDARDS-TRACK] The computation of one or a set of Traffic Engineering Label Switched Paths (TE LSPs) in MultiProtocol Label Switching (MPLS) and Generalized MPLS (GMPLS) networks is subject to a set of one or more specific optimization criteria, referred to as objective functions (e.g., minimum cost path, widest path, etc.). In the Path Computation Element (PCE) architecture, a Path Computation Client (PCC) may want a path to be computed for one or more TE LSPs according to a specific objective function. Thus, the PCC needs to instruct the PCE to use the correct objective function. Furthermore, it is possible that not all PCEs support the same set of objective functions; therefore, it is useful for the PCC to be able to automatically discover the set of objective functions supported by each PCE. This document defines extensions to the PCE communication Protocol (PCEP) to allow a PCE to indicate the set of objective functions it supports. Extensions are also defined so that a PCC can indicate in a path computation request the required objective function, and a PCE can report in a path computation reply the objective function that was used for path computation. This document defines objective function code types for six objective functions previously listed in the PCE requirements work, and provides the definition of four new metric types that apply to a set of synchronized requests. [STANDARDS-TRACK] This document describes a method for invoking and running the Network Configuration Protocol (NETCONF) within a Secure Shell (SSH) session as an SSH subsystem. This document obsoletes RFC 4742. [STANDARDS-TRACK] This document specifies version 1.3 of the Transport Layer Security (TLS) protocol. TLS allows client/server applications to communicate over the Internet in a way that is designed to prevent eavesdropping, tampering, and message forgery. This document updates RFCs 5705 and 6066, and obsoletes RFCs 5077, 5246, and 6961. This document also specifies new requirements for TLS 1.2 implementations. The standardization of network configuration interfaces for use with the Network Configuration Protocol (NETCONF) or the RESTCONF protocol requires a structured and secure operating environment that promotes human usability and multi-vendor interoperability. There is a need for standard mechanisms to restrict NETCONF or RESTCONF protocol access for particular users to a preconfigured subset of all available NETCONF or RESTCONF protocol operations and content. This document defines such an access control model. This document obsoletes RFC 6536. This document describes an IANA maintained registry for IETF standards which use Extensible Markup Language (XML) related items such as Namespaces, Document Type Declarations (DTDs), Schemas, and Resource Description Framework (RDF) Schemas. Informative References Services such as content distribution, distributed databases, or inter-data center connectivity place a set of new requirements on the operation of networks. They need on-demand and application-specific reservation of network connectivity, reliability, and resources (such as bandwidth) in a variety of network applications (such as point-to-point connectivity, network virtualization, or mobile back-haul) and in a range of network technologies from packet (IP/MPLS) down to optical. An environment that operates to meet these types of requirements is said to have Application-Based Network Operations (ABNO). ABNO brings together many existing technologies and may be seen as the use of a toolbox of existing components enhanced with a few new elements. This document describes an architecture and framework for ABNO, showing how these components fit together. It provides a cookbook of existing technologies to satisfy the architecture and meet the needs of the applications. Traffic Engineered (TE) networks have a variety of mechanisms to facilitate the separation of the data plane and control plane. They also have a range of management and provisioning protocols to configure and activate network resources. These mechanisms represent key technologies for enabling flexible and dynamic networking. The term "Traffic Engineered network" refers to a network that uses any connection-oriented technology under the control of a distributed or centralized control plane to support dynamic provisioning of end-to- end connectivity. Abstraction of network resources is a technique that can be applied to a single network domain or across multiple domains to create a single virtualized network that is under the control of a network operator or the customer of the operator that actually owns the network resources. This document provides a framework for Abstraction and Control of TE Networks (ACTN) to support virtual network services and connectivity services. This document provides an information model for Abstraction and Control of TE Networks (ACTN). Huawei Technologies Huawei Technologies Alef Edge Nokia Telefonica This document defines a YANG data model for representing, retrieving, and manipulating Optical Transport Network (OTN) topologies. It is independent of control plane protocols and captures topological and resource-related information pertaining to OTN. Constraint-based path computation is a fundamental building block for traffic engineering systems such as Multiprotocol Label Switching (MPLS) and Generalized Multiprotocol Label Switching (GMPLS) networks. Path computation in large, multi-domain, multi-region, or multi-layer networks is complex and may require special computational components and cooperation between the different network domains. This document specifies the architecture for a Path Computation Element (PCE)-based model to address this problem space. This document does not attempt to provide a detailed description of all the architectural components, but rather it describes a set of building blocks for the PCE architecture from which solutions may be constructed. This memo provides information for the Internet community. Datastores are a fundamental concept binding the data models written in the YANG data modeling language to network management protocols such as the Network Configuration Protocol (NETCONF) and RESTCONF. This document defines an architectural framework for datastores based on the experience gained with the initial simpler model, addressing requirements that were not well supported in the initial model. This document updates RFC 7950. Computing optimum routes for Label Switched Paths (LSPs) across multiple domains in MPLS Traffic Engineering (MPLS-TE) and GMPLS networks presents a problem because no single point of path computation is aware of all of the links and resources in each domain. A solution may be achieved using the Path Computation Element (PCE) architecture. Where the sequence of domains is known a priori, various techniques can be employed to derive an optimum path. If the domains are simply connected, or if the preferred points of interconnection are also known, the Per-Domain Path Computation technique can be used. Where there are multiple connections between domains and there is no preference for the choice of points of interconnection, the Backward-Recursive PCE-based Computation (BRPC) procedure can be used to derive an optimal path. This document examines techniques to establish the optimum path when the sequence of domains is not known in advance. The document shows how the PCE architecture can be extended to allow the optimum sequence of domains to be selected, and the optimum end-to-end path to be derived through the use of a hierarchical relationship between domains. This document is not an Internet Standards Track specification; it is published for informational purposes. This document provides a model of information needed by the Routing and Wavelength Assignment (RWA) process in Wavelength Switched Optical Networks (WSONs). The purpose of the information described in this model is to facilitate constrained optical path computation in WSONs. This model takes into account compatibility constraints between WSON signal attributes and network elements but does not include constraints due to optical impairments. Aspects of this information that may be of use to other technologies utilizing a GMPLS control plane are discussed.

Examples This section contains examples of use of the model with RESTCONF and JSON encoding. These examples show how path computation can be requested for the tunnels configuration provided in Appendix A of .

Basic Path Computation This example uses the path computation RPC defined in this document to request the computation of the path for the tunnel defined in . In this case, the TE Tunnel has only one primary path with no specific constraints.

Path Computation with transient state This example uses the path computation RPC defined in this document to request the computation of the path for the tunnel defined in requesting some transient state to be reported within the operational datastore, as described . In this case, the TE Tunnel has only one primary path with no specific constraints.

Path Computation with Global Path Constraint This example uses the path computation RPC defined in this document to request the computation of the path for the tunnel defined in . The 'named path constraint' is created in section 12.2 of applies to this path computation request.

Path Computation with Per-tunnel Path Constraint This example uses the path computation RPC defined in this document to request the computation of the path for the tunnel defined in , using a per tunnel path constraint.

Path Computation result This example reports the output of the path computation RPC request described in .

Path Computation with Primary and Secondary Paths This section contains examples of use of the model to compute primary and secondary paths described in section 12.6 of . These examples consider the cases where: - primary and reverse paths are unidirectional and not co-routed (example-1); - primary and reverse paths are bidirectional (example-3); - primary and reverse paths are unidirectional and co-routed (example-4).

Acknowledgments The authors would like to thank Karthik Sethuraman, Igor Bryskin and Xian Zhang for participating in the initial discussions that have triggered this work and providing valuable insights. The authors would like to thank the authors of the TE tunnel YANG data model , in particular Igor Bryskin, Vishnu Pavan Beeram, Tarek Saad and Xufeng Liu, for their inputs to the discussions and support in having consistency between the Path Computation and TE tunnel YANG data models. The authors would like to thank Adrian Farrel, Dhruv Dhody, Igor Bryskin, Julien Meuric and Lou Berger for their valuable input to the discussions that has clarified that the path being set up is not necessarily the same as the path that has been previously computed and, in particular to Dhruv Dhody, for his suggestion to describe the need for a path verification phase to check that the actual path being set up meets the required end-to-end metrics and constraints. The authors would like to thank Aihua Guo, Lou Berger, Shaolong Gan, Martin Bjorklund and Tom Petch for their useful comments on how to define XPath statements in YANG RPCs. The authors would like to thank Haomian Zheng, Yanlei Zheng, Tom Petch, Aihua Guo and Martin Bjorklund for their review and valuable comments to this document. Previous versions of document were prepared using 2-Word-v2.0.template.dot. This document was prepared using kramdown.

Contributors Cisco

daniele.ietf@gmail.com

Nokia

victor.lopez@nokia.com

CTTC

ricard.vilalta@cttc.es

Nokia

michael.scharf@gmail.com

Nokia

dieter.beller@nokia.com

Ericsson

gianmarco.bruno@ericsson.com

Retired

Samsung Electronics

younglee.tx@gmail.com

Ericsson

carlo.perocchio@ericsson.com

Orange Labs

olivier.dugeon@orange.com

Orange Labs

julien.meuric@orange.com