nrp-api/src/main/yang/tapi-connectivity@2018-03-07.yang

   1 module tapi-connectivity {
   2     namespace "urn:onf:otcc:yang:tapi-connectivity";
   3     prefix tapi-connectivity;
   4     import tapi-common {
   5         prefix tapi-common;
   6     }
   7     import tapi-topology {
   8         prefix tapi-topology;
   9     }
  10     import tapi-path-computation {
  11         prefix tapi-path-computation;
  12     }
  13     organization "ONF OTCC (Open Transport Configuration & Control) Project";
  14     contact "
  15         Project Web: <https://wiki.opennetworking.org/display/OTCC/TAPI>
  16         Project List: <mailto:transport-api@opennetworking.org>
  17         Editor: Karthik Sethuraman
  18                 <mailto:karthik.sethuraman@necam.com>";
  19     description "
  20         This module contains TAPI Connectivity Model definitions.
  21         Source: TapiConnectivity.uml
  22         Copyright (c) 2018 Open Networking Foundation (ONF). All rights reserved.
  23         License: This module is distributed under the Apache License 2.0";
  24     revision 2018-03-07 {
  25         description "ONF Transport API version 2.0.2
  26         This YANG module has been generated from the TAPI UML Model using the IISOMI-Eagle xmi2yang mapping tool version .
  27         <https://wiki.opennetworking.org/display/OIMT/IISOMI>
  28         Changes in this revision: <https://github.com/OpenNetworkingFoundation/TAPI/blob/develop/change-log.md>";
  29         reference "ONF-TR-527, ONF-TR-512, ONF-TR-531, RFC 6020, RFC 6087 and ONF TAPI UML model
  30                   <https://github.com/OpenNetworkingFoundation/TAPI/tree/develop/UML>";
  31     }
  32     augment "/tapi-common:context" {
  33         uses connectivity-context;
  34         description "Augments the base TAPI Context with ConnectivityService information";
  35     }
  36     augment "/tapi-common:context/tapi-topology:topology/tapi-topology:node/tapi-topology:owned-node-edge-point" {
  37         uses cep-list;
  38         description "none";
  39     }
  40
  41     /*************************
  42     * definitions of refrences
  43     *************************/
  44     grouping connectivity-service-ref {
  45         leaf connectivity-service-id {
  46             type leafref {
  47                 path '/tapi-common:context/tapi-connectivity:connectivity-service/tapi-connectivity:uuid';
  48             }
  49         }
  50     }
  51
  52     grouping connection-end-point-ref {
  53         uses tapi-topology:owned-node-edge-point-ref;
  54         leaf connection-end-point-id {
  55             type leafref {
  56                 path '/tapi-common:context/tapi-topology:topology/tapi-topology:node/tapi-topology:owned-node-edge-point/tapi-connectivity:connection-end-point/tapi-connectivity:uuid';
  57             }
  58         }
  59     }
  60
  61     grouping connection-ref {
  62         leaf connection-id {
  63             type leafref {
  64                 path '/tapi-common:context/tapi-connectivity:connection/tapi-connectivity:uuid';
  65             }
  66         }
  67     }
  68
  69     grouping switch-control-ref {
  70         uses connection-ref;
  71         leaf switch-control-id {
  72             type leafref {
  73                 path '/tapi-common:context/tapi-connectivity:connection/tapi-connectivity:switch-control/tapi-connectivity:uuid';
  74             }
  75         }
  76     }
  77
  78     /***********************
  79     * package object-classes
  80     **********************/
  81         grouping connection {
  82             list connection-end-point {
  83                 uses connection-end-point-ref;
  84                 key 'topology-id node-id owned-node-edge-point-id connection-end-point-id';
  85                 config false;
  86                 min-elements 2;
  87                 description "none";
  88             }
  89             leaf-list lower-connection {
  90                 type leafref {
  91                     path '/tapi-common:context/tapi-connectivity:connection/tapi-connectivity:uuid';
  92                 }
  93                 description "An Connection object supports a recursive aggregation relationship such that the internal construction of an Connection can be exposed as multiple lower level Connection objects (partitioning).
  94                     Aggregation is used as for the Node/Topology  to allow changes in hierarchy.
  95                     Connection aggregation reflects Node/Topology aggregation.
  96                     The FC represents a Cross-Connection in an NE. The Cross-Connection in an NE is not necessarily the lowest level of FC partitioning.";
  97             }
  98             list route {
  99                 key 'local-id';
 100                 config false;
 101                 uses route;
 102                 description "none";
 103             }
 104             list switch-control {
 105                 key 'uuid';
 106                 config false;
 107                 uses switch-control;
 108                 description "none";
 109             }
 110             leaf direction {
 111                 type tapi-common:forwarding-direction;
 112                 config false;
 113                 description "none";
 114             }
 115             leaf layer-protocol-name {
 116                 type tapi-common:layer-protocol-name;
 117                 config false;
 118                 description "none";
 119             }
 120             uses tapi-common:resource-spec;
 121             uses tapi-common:operational-state-pac;
 122             description "The ForwardingConstruct (FC) object class models enabled potential for forwarding between two or more LTPs and like the LTP supports any transport protocol including all circuit and packet forms.
 123                 At the lowest level of recursion, a FC represents a cross-connection within an NE.";
 124         }
 125         grouping connection-end-point {
 126             leaf layer-protocol-name {
 127                 type tapi-common:layer-protocol-name;
 128                 config false;
 129                 description "none";
 130             }
 131             leaf connectivity-service-end-point {
 132                 type leafref {
 133                     path '/tapi-common:context/tapi-connectivity:connectivity-service/tapi-connectivity:end-point/tapi-connectivity:local-id';
 134                 }
 135                 description "none";
 136             }
 137             list parent-node-edge-point {
 138                 uses tapi-topology:owned-node-edge-point-ref;
 139                 key 'topology-id node-id owned-node-edge-point-id';
 140                 config false;
 141                 min-elements 1;
 142                 description "none";
 143             }
 144             list client-node-edge-point {
 145                 uses tapi-topology:owned-node-edge-point-ref;
 146                 key 'topology-id node-id owned-node-edge-point-id';
 147                 config false;
 148                 description "none";
 149             }
 150             leaf connection-port-direction {
 151                 type tapi-common:port-direction;
 152                 config false;
 153                 description "The orientation of defined flow at the EndPoint.";
 154             }
 155             leaf connection-port-role {
 156                 type tapi-common:port-role;
 157                 config false;
 158                 description "Each EP of the FC has a role (e.g., working, protection, protected, symmetric, hub, spoke, leaf, root)  in the context of the FC with respect to the FC function. ";
 159             }
 160             uses tapi-common:resource-spec;
 161             uses tapi-common:operational-state-pac;
 162             uses tapi-common:termination-pac;
 163             description "The LogicalTerminationPoint (LTP) object class encapsulates the termination and adaptation functions of one or more transport layers.
 164                 The structure of LTP supports all transport protocols including circuit and packet forms.";
 165         }
 166         grouping connectivity-constraint {
 167             leaf service-type {
 168                 type service-type;
 169                 description "none";
 170             }
 171             leaf service-level {
 172                 type string;
 173                 description "An abstract value the meaning of which is mutually agreed – typically represents metrics such as - Class of service, priority, resiliency, availability";
 174             }
 175             leaf is-exclusive {
 176                 type boolean;
 177                 default "true";
 178                 description "To distinguish if the resources are exclusive to the service  - for example between EPL(isExclusive=true) and EVPL (isExclusive=false), or between EPLAN (isExclusive=true) and EVPLAN (isExclusive=false)";
 179             }
 180             container requested-capacity {
 181                 uses tapi-common:capacity;
 182                 description "none";
 183             }
 184             container schedule {
 185                 uses tapi-common:time-range;
 186                 description "none";
 187             }
 188             list cost-characteristic {
 189                 key 'cost-name';
 190                 uses tapi-topology:cost-characteristic;
 191                 description "The list of costs where each cost relates to some aspect of the TopologicalEntity.";
 192             }
 193             list latency-characteristic {
 194                 key 'traffic-property-name';
 195                 uses tapi-topology:latency-characteristic;
 196                 description "The effect on the latency of a queuing process. This only has significant effect for packet based systems and has a complex characteristic.";
 197             }
 198             leaf coroute-inclusion {
 199                 type leafref {
 200                     path '/tapi-common:context/tapi-connectivity:connectivity-service/tapi-connectivity:uuid';
 201                 }
 202                 description "none";
 203             }
 204             list diversity-exclusion {
 205                 uses connectivity-service-ref;
 206                 key 'connectivity-service-id';
 207                 description "none";
 208             }
 209             uses route-compute-policy;
 210             description "none";
 211         }
 212         grouping connectivity-service {
 213             list end-point {
 214                 key 'local-id';
 215                 min-elements 2;
 216                 uses connectivity-service-end-point;
 217                 description "none";
 218             }
 219             leaf-list connection {
 220                 type leafref {
 221                     path '/tapi-common:context/tapi-connectivity:connection/tapi-connectivity:uuid';
 222                 }
 223                 config false;
 224                 description "none";
 225             }
 226             leaf direction {
 227                 type tapi-common:forwarding-direction;
 228                 description "none";
 229             }
 230             leaf layer-protocol-name {
 231                 type tapi-common:layer-protocol-name;
 232                 description "none";
 233             }
 234             uses tapi-common:service-spec;
 235             uses connectivity-constraint;
 236             uses topology-constraint;
 237             uses tapi-common:admin-state-pac;
 238             uses resilience-constraint;
 239             description "The ForwardingConstruct (FC) object class models enabled potential for forwarding between two or more LTPs and like the LTP supports any transport protocol including all circuit and packet forms.
 240                 At the lowest level of recursion, a FC represents a cross-connection within an NE.";
 241         }
 242         grouping connectivity-service-end-point {
 243             leaf layer-protocol-name {
 244                 type tapi-common:layer-protocol-name;
 245                 description "none";
 246             }
 247             container service-interface-point {
 248                 uses tapi-common:service-interface-point-ref;
 249                 description "none";
 250             }
 251             container capacity {
 252                 uses tapi-common:capacity;
 253                 description "none";
 254             }
 255             leaf direction {
 256                 type tapi-common:port-direction;
 257                 description "The orientation of defined flow at the EndPoint.";
 258             }
 259             leaf role {
 260                 type tapi-common:port-role;
 261                 description "Each EP of the FC has a role (e.g., working, protection, protected, symmetric, hub, spoke, leaf, root)  in the context of the FC with respect to the FC function. ";
 262             }
 263             leaf protection-role {
 264                 type protection-role;
 265                 description "To specify the protection role of this Port when create or update ConnectivityService.";
 266             }
 267             uses tapi-common:local-class;
 268             uses tapi-common:admin-state-pac;
 269             description "The association of the FC to LTPs is made via EndPoints.
 270                 The EndPoint (EP) object class models the access to the FC function.
 271                 The traffic forwarding between the associated EPs of the FC depends upon the type of FC and may be associated with FcSwitch object instances.
 272                 In cases where there is resilience the EndPoint may convey the resilience role of the access to the FC.
 273                 It can represent a protected (resilient/reliable) point or a protecting (unreliable working or protection) point.
 274                 The EP replaces the Protection Unit of a traditional protection model.
 275                 The ForwadingConstruct can be considered as a component and the EndPoint as a Port on that component";
 276         }
 277         grouping route {
 278             leaf-list connection-end-point {
 279                 type leafref {
 280                     path '/tapi-common:context/tapi-topology:topology/tapi-topology:node/tapi-topology:owned-node-edge-point/tapi-connectivity:connection-end-point/tapi-connectivity:uuid';
 281                 }
 282                 config false;
 283                 min-elements 2;
 284                 description "none";
 285             }
 286             uses tapi-common:local-class;
 287             description "The FC Route (FcRoute) object class models the individual routes of an FC.
 288                 The route of an FC object is represented by a list of FCs at a lower level.
 289                 Note that depending on the service supported by an FC, an the FC can have multiple routes.";
 290         }
 291         grouping connectivity-context {
 292             list connectivity-service {
 293                 key 'uuid';
 294                 uses connectivity-service;
 295                 description "none";
 296             }
 297             list connection {
 298                 key 'uuid';
 299                 config false;
 300                 uses connection;
 301                 description "none";
 302             }
 303             description "none";
 304         }
 305         grouping switch {
 306             list selected-connection-end-point {
 307                 uses connection-end-point-ref;
 308                 key 'topology-id node-id owned-node-edge-point-id connection-end-point-id';
 309                 min-elements 1;
 310                 description "none";
 311             }
 312             leaf-list selected-route {
 313                 type leafref {
 314                     path '/tapi-common:context/tapi-connectivity:connection/tapi-connectivity:route/tapi-connectivity:local-id';
 315                 }
 316                 min-elements 1;
 317                 description "none";
 318             }
 319             leaf selection-control {
 320                 type selection-control;
 321                 description "Degree of administrative control applied to the switch selection.";
 322             }
 323             leaf selection-reason {
 324                 type selection-reason;
 325                 config false;
 326                 description "The reason for the current switch selection.";
 327             }
 328             leaf switch-direction {
 329                 type tapi-common:port-direction;
 330                 description "Indicates whether the switch selects from ingress to the FC or to egress of the FC, or both.";
 331             }
 332             uses tapi-common:local-class;
 333             description "The class models the switched forwarding of traffic (traffic flow) between FcPorts (ConnectionEndPoints) and is present where there is protection functionality in the FC (Connection).
 334                 If an FC exposes protection (having two or more FcPorts that provide alternative identical inputs/outputs), the FC will have one or more associated FcSwitch objects to represent the alternative flow choices visible at the edge of the FC.
 335                 The FC switch represents and defines a protection switch structure encapsulated in the FC.
 336                 Essentially performs one of the functions of the Protection Group in a traditional model. It associates to 2 or more FcPorts each playing the role of a Protection Unit.
 337                 One or more protection, i.e. standby/backup, FcPorts provide protection for one or more working (i.e. regular/main/preferred) FcPorts where either protection or working can feed one or more protected FcPort.
 338                 The switch may be used in revertive or non-revertive (symmetric) mode. When in revertive mode it may define a waitToRestore time.
 339                 It may be used in one of several modes including source switch, destination switched, source and destination switched etc (covering cases such as 1+1 and 1:1).
 340                 It may be locked out (prevented from switching), force switched or manual switched.
 341                 It will indicate switch state and change of state.
 342                 The switch can be switched away from all sources such that it becomes open and hence two coordinated switches can both feed the same LTP so long as at least one of the two is switched away from all sources (is 'open').
 343                 The ability for a Switch to be 'high impedance' allows bidirectional ForwardingConstructs to be overlaid on the same bidirectional LTP where the appropriate control is enabled to prevent signal conflict.
 344                 This ability allows multiple alternate routes to be present that otherwise would be in conflict.";
 345         }
 346         grouping switch-control {
 347             list sub-switch-control {
 348                 uses switch-control-ref;
 349                 key 'connection-id switch-control-id';
 350                 description "none";
 351             }
 352             list switch {
 353                 key 'local-id';
 354                 uses switch;
 355                 description "none";
 356             }
 357             uses tapi-common:resource-spec;
 358             uses resilience-constraint;
 359             description "Represents the capability to control and coordinate switches, to add/delete/modify FCs and to add/delete/modify LTPs/LPs so as to realize a protection scheme.";
 360         }
 361         grouping resilience-constraint {
 362             container resilience-type {
 363                 uses tapi-topology:resilience-type;
 364                 description "none";
 365             }
 366             leaf restoration-coordinate-type {
 367                 type coordinate-type;
 368                 description " The coordination mechanism between multi-layers.";
 369             }
 370             leaf restore-priority {
 371                 type uint64;
 372                 description "none";
 373             }
 374             leaf reversion-mode {
 375                 type reversion-mode;
 376                 description "Indcates whether the protection scheme is revertive or non-revertive.";
 377             }
 378             leaf wait-to-revert-time {
 379                 type uint64;
 380                 default "15";
 381                 description "If the protection system is revertive, this attribute specifies the time, in minutes, to wait after a fault clears on a higher priority (preferred) resource before reverting to the preferred resource.";
 382             }
 383             leaf hold-off-time {
 384                 type uint64;
 385                 description "This attribute indicates the time, in milliseconds, between declaration of signal degrade or signal fail, and the initialization of the protection switching algorithm.";
 386             }
 387             leaf is-lock-out {
 388                 type boolean;
 389                 description "The resource is configured to temporarily not be available for use in the protection scheme(s) it is part of.
 390                     This overrides all other protection control states including forced.
 391                     If the item is locked out then it cannot be used under any circumstances.
 392                     Note: Only relevant when part of a protection scheme.";
 393             }
 394             leaf is-frozen {
 395                 type boolean;
 396                 description "Temporarily prevents any switch action to be taken and, as such, freezes the current state.
 397                     Until the freeze is cleared, additional near-end external commands are rejected and fault condition changes and received APS messages are ignored.
 398                     All administrative controls of any aspect of protection are rejected.";
 399             }
 400             leaf is-coordinated-switching-both-ends {
 401                 type boolean;
 402                 description "Is operating such that switching at both ends of each flow acorss the FC is coordinated at both ingress and egress ends.";
 403             }
 404             leaf max-switch-times {
 405                 type uint64;
 406                 description "Used to limit the maximum swtich times. When work fault disappears , and traffic return to the original work path, switch counter reset.";
 407             }
 408             leaf layer-protocol {
 409                 type tapi-common:layer-protocol-name;
 410                 description "Indicate which layer this resilience parameters package configured for.";
 411             }
 412             description "A list of control parameters to apply to a switch.";
 413         }
 414         grouping topology-constraint {
 415             list include-topology {
 416                 uses tapi-topology:topology-ref;
 417                 key 'topology-id';
 418                 config false;
 419                 description "none";
 420             }
 421             list avoid-topology {
 422                 uses tapi-topology:topology-ref;
 423                 key 'topology-id';
 424                 config false;
 425                 description "none";
 426             }
 427             list include-path {
 428                 uses tapi-path-computation:path-ref;
 429                 key 'path-id';
 430                 config false;
 431                 description "none";
 432             }
 433             list exclude-path {
 434                 uses tapi-path-computation:path-ref;
 435                 key 'path-id';
 436                 config false;
 437                 description "none";
 438             }
 439             list include-link {
 440                 uses tapi-topology:link-ref;
 441                 key 'topology-id link-id';
 442                 config false;
 443                 description "This is a loose constraint - that is it is unordered and could be a partial list ";
 444             }
 445             list exclude-link {
 446                 uses tapi-topology:link-ref;
 447                 key 'topology-id link-id';
 448                 config false;
 449                 description "none";
 450             }
 451             list include-node {
 452                 uses tapi-topology:node-ref;
 453                 key 'topology-id node-id';
 454                 config false;
 455                 description "This is a loose constraint - that is it is unordered and could be a partial list";
 456             }
 457             list exclude-node {
 458                 uses tapi-topology:node-ref;
 459                 key 'topology-id node-id';
 460                 config false;
 461                 description "none";
 462             }
 463             leaf-list preferred-transport-layer {
 464                 type tapi-common:layer-protocol-name;
 465                 config false;
 466                 description "soft constraint requested by client to indicate the layer(s) of transport connection that it prefers to carry the service. This could be same as the service layer or one of the supported server layers";
 467             }
 468             description "none";
 469         }
 470         grouping cep-list {
 471             list connection-end-point {
 472                 key 'uuid';
 473                 uses connection-end-point;
 474                 description "none";
 475             }
 476             description "none";
 477         }
 478         grouping route-compute-policy {
 479             leaf route-objective-function {
 480                 type route-objective-function;
 481                 description "none";
 482             }
 483             leaf diversity-policy {
 484                 type diversity-policy;
 485                 description "none";
 486             }
 487             description "none";
 488         }
 489
 490     /***********************
 491     * package type-definitions
 492     **********************/
 493         typedef service-type {
 494             type enumeration {
 495                 enum POINT_TO_POINT_CONNECTIVITY {
 496                     description "none";
 497                 }
 498                 enum POINT_TO_MULTIPOINT_CONNECTIVITY {
 499                     description "none";
 500                 }
 501                 enum MULTIPOINT_CONNECTIVITY {
 502                     description "none";
 503                 }
 504                 enum ROOTED_MULTIPOINT_CONNECTIVITY {
 505                     description "none";
 506                 }
 507             }
 508             description "none";
 509         }
 510         typedef reversion-mode {
 511             type enumeration {
 512                 enum REVERTIVE {
 513                     description "An FC switched to a lower priority (non-preferred) resource will revert to a higher priority (preferred) resource when that recovers (potentially after some hold-off time).";
 514                 }
 515                 enum NON-REVERTIVE {
 516                     description "An FC switched to a lower priority (non-preferred) resource will not revert to a higher priority (preferred) resource when that recovers.";
 517                 }
 518             }
 519             description "The reversion mode associated with protection.";
 520         }
 521         typedef selection-control {
 522             type enumeration {
 523                 enum LOCK_OUT {
 524                     description "The resource is configured to temporarily not be available for use in the protection scheme(s) it is part of.
 525                         This overrides all other protection control states including forced.
 526                         If the item is locked out then it cannot be used under any circumstances.
 527                         Note: Only relevant when part of a protection scheme.";
 528                 }
 529                 enum NORMAL {
 530                     description "none";
 531                 }
 532                 enum MANUAL {
 533                     description "none";
 534                 }
 535                 enum FORCED {
 536                     description "none";
 537                 }
 538             }
 539             description "Possible degrees of administrative control applied to the Route selection.";
 540         }
 541         typedef selection-reason {
 542             type enumeration {
 543                 enum LOCKOUT {
 544                     description "none";
 545                 }
 546                 enum NORMAL {
 547                     description "none";
 548                 }
 549                 enum MANUAL {
 550                     description "none";
 551                 }
 552                 enum FORCED {
 553                     description "none";
 554                 }
 555                 enum WAIT_TO_REVERT {
 556                     description "none";
 557                 }
 558                 enum SIGNAL_DEGRADE {
 559                     description "none";
 560                 }
 561                 enum SIGNAL_FAIL {
 562                     description "none";
 563                 }
 564             }
 565             description "The cause of the current route selection.";
 566         }
 567         typedef coordinate-type {
 568             type enumeration {
 569                 enum NO_COORDINATE {
 570                     description "none";
 571                 }
 572                 enum HOLD_OFF_TIME {
 573                     description "none";
 574                 }
 575                 enum WAIT_FOR_NOTIFICATION {
 576                     description "none";
 577                 }
 578             }
 579             description "none";
 580         }
 581         typedef route-objective-function {
 582             type enumeration {
 583                 enum MIN_WORK_ROUTE_HOP {
 584                     description "none";
 585                 }
 586                 enum MIN_WORK_ROUTE_COST {
 587                     description "none";
 588                 }
 589                 enum MIN_WORK_ROUTE_LATENCY {
 590                     description "none";
 591                 }
 592                 enum MIN_SUM_OF_WORK_AND_PROTECTION_ROUTE_HOP {
 593                     description "none";
 594                 }
 595                 enum MIN_SUM_OF_WORK_AND_PROTECTION_ROUTE_COST {
 596                     description "none";
 597                 }
 598                 enum MIN_SUM_OF_WORK_AND_PROTECTION_ROUTE_LATENCY {
 599                     description "none";
 600                 }
 601                 enum LOAD_BALANCE_MAX_UNUSED_CAPACITY {
 602                     description "none";
 603                 }
 604             }
 605             description "none";
 606         }
 607         typedef diversity-policy {
 608             type enumeration {
 609                 enum SRLG {
 610                     description "none";
 611                 }
 612                 enum SRNG {
 613                     description "none";
 614                 }
 615                 enum SNG {
 616                     description "none";
 617                 }
 618                 enum NODE {
 619                     description "none";
 620                 }
 621                 enum LINK {
 622                     description "none";
 623                 }
 624             }
 625             description "none";
 626         }
 627         typedef protection-role {
 628             type enumeration {
 629                 enum WORK {
 630                     description "none";
 631                 }
 632                 enum PROTECT {
 633                     description "none";
 634                 }
 635                 enum PROTECTED {
 636                     description "none";
 637                 }
 638                 enum NA {
 639                     description "none";
 640                 }
 641                 enum WORK_RESTORE {
 642                     description "none";
 643                 }
 644                 enum PROTECT_RESTORE {
 645                     description "none";
 646                 }
 647             }
 648             description "none";
 649         }
 650
 651     /***********************
 652     * package interfaces
 653     **********************/
 654         rpc get-connection-details {
 655             description "none";
 656             input {
 657                 leaf service-id-or-name {
 658                     type string;
 659                     description "none";
 660                 }
 661                 leaf connection-id-or-name {
 662                     type string;
 663                     description "none";
 664                 }
 665             }
 666             output {
 667                 container connection {
 668                     uses connection;
 669                     description "none";
 670                 }
 671             }
 672         }
 673         rpc get-connectivity-service-list {
 674             description "none";
 675             output {
 676                 list service {
 677                     uses connectivity-service;
 678                     description "none";
 679                 }
 680             }
 681         }
 682         rpc get-connectivity-service-details {
 683             description "none";
 684             input {
 685                 leaf service-id-or-name {
 686                     type string;
 687                     description "none";
 688                 }
 689             }
 690             output {
 691                 container service {
 692                     uses connectivity-service;
 693                     description "none";
 694                 }
 695             }
 696         }
 697         rpc create-connectivity-service {
 698             description "none";
 699             input {
 700                 list end-point {
 701                     min-elements 2;
 702                     uses connectivity-service-end-point;
 703                     description "none";
 704                 }
 705                 container conn-constraint {
 706                     uses connectivity-constraint;
 707                     description "none";
 708                 }
 709                 container topo-constraint {
 710                     uses topology-constraint;
 711                     description "none";
 712                 }
 713                 list resilience-constraint {
 714                     uses resilience-constraint;
 715                     description "none";
 716                 }
 717                 leaf state {
 718                     type string;
 719                     description "none";
 720                 }
 721             }
 722             output {
 723                 container service {
 724                     uses connectivity-service;
 725                     description "none";
 726                 }
 727             }
 728         }
 729         rpc update-connectivity-service {
 730             description "none";
 731             input {
 732                 leaf service-id-or-name {
 733                     type string;
 734                     description "none";
 735                 }
 736                 container end-point {
 737                     uses connectivity-service-end-point;
 738                     description "none";
 739                 }
 740                 container conn-constraint {
 741                     uses connectivity-constraint;
 742                     description "none";
 743                 }
 744                 container topo-constraint {
 745                     uses topology-constraint;
 746                     description "none";
 747                 }
 748                 list resilience-constraint {
 749                     uses resilience-constraint;
 750                     description "none";
 751                 }
 752                 leaf state {
 753                     type string;
 754                     description "none";
 755                 }
 756             }
 757             output {
 758                 container service {
 759                     uses connectivity-service;
 760                     description "none";
 761                 }
 762             }
 763         }
 764         rpc delete-connectivity-service {
 765             description "none";
 766             input {
 767                 leaf service-id-or-name {
 768                     type string;
 769                     description "none";
 770                 }
 771             }
 772             output {
 773                 container service {
 774                     uses connectivity-service;
 775                     description "none";
 776                 }
 777             }
 778         }
 779
 780 }