vnfapi/model/src/main/yang/VNF-API.yang

   1 module VNF-API {
   2
   3     yang-version 1;
   4
   5     namespace "org:onap:sdnctl:vnf";
   6
   7     prefix vnfapi;
   8
   9     import ietf-inet-types { prefix "ietf"; revision-date "2010-09-24"; }
  10
  11     include "vnfsubmodule";
  12
  13     organization "ONAP";
  14
  15     contact
  16     "Network Controller <onap-sdnc@lists.onap.org>";
  17
  18     description
  19         "Defines API interface for VNF Orchestration";
  20
  21     revision "2015-07-20" {
  22         description
  23             "Initial draft";
  24     }
  25     // Last updated on 8-17-2016
  26     grouping sdnc-request-header {
  27         container sdnc-request-header {
  28             leaf svc-request-id {
  29                 type string;
  30             }
  31             leaf svc-action {
  32                 type enumeration {
  33                     enum "reserve";
  34                     enum "assign";
  35                     enum "activate";  // equal to commit
  36                     enum "delete";    // equal to commit
  37                     enum "changeassign";
  38                     enum "changedelete";
  39                     enum "rollback";
  40                 }
  41             }
  42             leaf svc-notification-url {
  43                 type string;
  44             }
  45         }
  46     }
  47
  48     grouping request-information {
  49         container request-information {
  50             leaf request-id {
  51                 type string;
  52             }
  53             leaf request-action {
  54                 type enumeration {
  55                     enum "PreloadNetworkRequest";
  56                     enum "DeletePreloadNetworkRequest";
  57                     enum "NetworkActivateRequest";
  58                     enum "DisconnectNetworkRequest";
  59                     enum "PreloadVNFRequest";
  60                     enum "DeletePreloadVNFRequest";
  61                     enum "VNFActivateRequest";
  62                     enum "ChangeVNFActivateRequest";
  63                     enum "DisconnectVNFRequest";
  64                     enum "PreloadVnfInstanceRequest";
  65                     enum "DeletePreloadVnfInstanceRequest";
  66                     enum "VnfInstanceActivateRequest";
  67                     enum "ChangeVnfInstanceActivateRequest";
  68                     enum "DisconnectVnfInstanceRequest";
  69                     enum "PreloadVfModuleRequest";
  70                     enum "DeletePreloadVfModuleRequest";
  71                     enum "VfModuleActivateRequest";
  72                     enum "ChangeVfModuleActivateRequest";
  73                     enum "DisconnectVfModuleRequest";
  74                 }
  75             }
  76             leaf request-sub-action {
  77                 type enumeration {
  78                     enum "SUPP";
  79                     enum "CANCEL";
  80                     enum "RetainResource";
  81                 }
  82             }
  83             leaf source {
  84                 type string;
  85             }
  86             leaf notification-url {
  87                 type string;
  88             }
  89             leaf order-number {
  90                 type string;
  91             }
  92             leaf order-version {
  93                 type string;
  94             }
  95         }
  96     }
  97
  98     grouping service-information {
  99         container service-information {
 100             leaf service-type {
 101                 type string;
 102                 description "AnAI subscription-service-type";
 103             }
 104             leaf service-id {
 105                 type string;
 106             }
 107             leaf service-instance-id {
 108                 type string;
 109                 description "A service instance that a VNF or a l3-network is associated with";
 110             }
 111             leaf subscriber-name {
 112                 type string;
 113                 description "AnAI global-customer-id";
 114             }
 115         }
 116     }
 117
 118
 119     grouping vnf-request-information {
 120         container vnf-request-information {
 121             leaf vnf-request-version {
 122                 type string;
 123             }
 124             leaf model-customization-uuid {
 125                 type string;
 126                 description "customized resource, i.e. vf-module, for use within a given service";
 127             }
 128             leaf use-preload {
 129                 type enumeration {
 130                     enum "Y";
 131                     enum "N";
 132                 }
 133                 description "orchestrate vf-module with full preload data or TOSCA lookup plus EIPAM automation";
 134             }
 135             leaf vnf-id {
 136                 type string;
 137                 description "vf-module-id";
 138             }
 139             leaf vnf-type {
 140                 type string;
 141                 description "vf-module-type";
 142             }
 143             leaf vnf-name {
 144                 type string;
 145                 description "vf-module-name";
 146             }
 147             leaf generic-vnf-id {
 148                 type string;
 149                 description "generic vnf-id";
 150             }
 151             leaf generic-vnf-type {
 152                 type string;
 153                 description "generic vnf type";
 154             }
 155             leaf generic-vnf-name {
 156                 type string;
 157                 description "generic vnf name";
 158             }
 159             leaf tenant {
 160                 type string;
 161             }
 162             leaf aic-clli {
 163                 type string;
 164             }
 165             leaf aic-cloud-region {
 166                 type string;
 167                 description "The AIC cloud region which maps to contrail versions";
 168             }
 169             list vnf-networks {
 170                 key network-role;
 171                 uses vnf-network;
 172                 description "Network List";
 173             }
 174         }
 175     }
 176
 177     grouping network-request-information {
 178         container network-request-information {
 179             leaf network-id {
 180                 type string;
 181             }
 182             leaf network-type {
 183                 type string;
 184             }
 185             leaf network-name {
 186                 type string;
 187             }
 188             leaf tenant {
 189                 type string;
 190             }
 191             leaf aic-clli {
 192                 type string;
 193             }
 194             leaf aic-cloud-region {
 195                 type string;
 196                 description "The AIC cloud region which maps to contrail versions";
 197             }
 198         }
 199     }
 200
 201     /***********************************************************/
 202     /*               PRELOAD DATA                                 */
 203     /***********************************************************/
 204
 205     container preload-vnfs {
 206         uses preload-model-information;
 207     }
 208     grouping preload-model-information {
 209         list vnf-preload-list {
 210             key "vnf-name vnf-type";
 211             leaf vnf-name {
 212                 type string;
 213                 description "vf-module-name";
 214             }
 215             leaf vnf-type {
 216                 type string;
 217                 description "vf-module-type";
 218             }
 219             uses preload-data;
 220         }
 221     }
 222
 223     // For preload networks it will have network-topology-information
 224     // For preload vnfs, it will have vnf-topology-information
 225     grouping preload-data {
 226         container preload-data {
 227             uses vnf-topology-information;
 228             uses network-topology-information;
 229             uses oper-status;
 230         }
 231     }
 232
 233
 234     grouping vnf-topology-information {
 235         container vnf-topology-information {
 236             uses vnf-topology-identifier;
 237             uses vnf-assignments;
 238             uses vnf-parameters;
 239         }
 240     }
 241
 242     grouping vnf-topology-identifier {
 243         container vnf-topology-identifier {
 244             leaf service-type {
 245                 type string;
 246             }
 247             leaf service-id {
 248                 type string;
 249             }
 250             leaf vnf-name {
 251                 type string;
 252                 description "vf-module-name";
 253             }
 254             leaf vnf-type {
 255                 type string;
 256                 description "vf-module-type";
 257             }
 258             leaf generic-vnf-name {
 259                 type string;
 260             }
 261             leaf generic-vnf-type {
 262                 type string;
 263             }
 264             leaf generic-vnf-id {
 265                 type string;
 266             }
 267         }
 268     }
 269
 270     grouping vnf-assignments {
 271         container vnf-assignments {
 272             leaf vnf-status {
 273                 type string;
 274                 description "Orchestration Status from AAI - to be set by SDNC";
 275             }
 276             list availability-zones {
 277                 key "availability-zone";
 278                 ordered-by  user;
 279                 leaf availability-zone {
 280                     type string;
 281                     description "Openstack availability zone name or UUID";
 282                 }
 283             }
 284             list vnf-networks {
 285                 key network-role;
 286                 uses vnf-network;
 287                 uses sriov-vlan-filter-list;
 288                 description "Network List";
 289             }
 290             uses vm-topology;
 291         }
 292     }
 293
 294     grouping vm-topology {
 295         list vnf-vms {
 296             key vm-type;
 297             leaf vm-type {
 298                 type string;
 299             }
 300             leaf vm-count {
 301                 type uint8;
 302             }
 303             list vm-names {
 304                 ordered-by user;
 305                 key "vm-name";
 306                 leaf vm-name {
 307                     type string;
 308                 }
 309                 list vnfc-names {
 310                     ordered-by user;
 311                     key "vnfc-name";
 312                     leaf vnfc-name {
 313                         type string;
 314                     }
 315                     list vnfc-networks {
 316                         key vnfc-network-role;
 317                         uses vnfc-network;
 318                     }
 319                 }
 320             }
 321             list vm-networks {
 322                 key network-role;
 323                 uses vm-network;
 324                 description "Network List";
 325             }
 326         }
 327     }
 328
 329     grouping vnfc-network {
 330         leaf vnfc-network-role {
 331             type string;
 332         }
 333         list vnfc-subnets {
 334             key "vnfc-subnet-role";
 335             leaf vnfc-subnet-role {
 336                 type string;
 337         }
 338         list vnfc-ipassignments {
 339             key "vnfc-address-family";
 340             leaf vnfc-address-family {
 341                 description "Subnet Version tells if this is IpV4 or IpV6";
 342                 type enumeration {
 343                     enum "ipv4";
 344                     enum "ipv6";
 345                 }
 346             }
 347             leaf vnfc-subnet-dhcp {
 348                 description "Indicator to use DHCP on this network for this VNFC. Unless dhcp=N, we wouldnt have any address, since they would not be sdnc assigned ";
 349                 type enumeration {
 350                     enum "Y";
 351                     enum "N";
 352                 }
 353             }
 354             leaf vnfc-subnet-ipcount {
 355                 description "The number of ip addresses to be assigned per vnfc for this subnet role";
 356                 type uint8;
 357             }
 358             list vnfc-subnet-ips {
 359                 key "vnfc-client-key";
 360                 leaf vnfc-client-key {
 361                     type string;
 362                 }
 363                 leaf ip-type {
 364                     description "Capture what type of IP this is, if is virtual IP (AKA, floating IP) or Fixed IP. ";
 365                     type enumeration {
 366                         enum "FIXED";
 367                         enum "VIP";
 368                     }
 369                }
 370                leaf vnfc-address-ipv4 {
 371                     description "Either IpV4 IP addresses or IpV6 IP addresses should be present,  but not both within one VnfcVersion. ";
 372                     type inet:ip-address;
 373                }
 374                leaf vnfc-address-ipv6 {
 375                     description "Either IpV4 IP addresses or IpV6 IP addresses should be present,  but not both within one VnfcVersion.";
 376                     type inet:ipv6-address;
 377                }
 378             }
 379          }
 380       }
 381    }
 382
 383     grouping vnf-network {
 384         leaf network-role {
 385             type string;
 386             description "A Network Role to which a VNF must connect";
 387         }
 388         leaf network-role-tag {
 389             type string;
 390             description "The network-role that maps to the HEAT parameter {network-role}_net_id";
 391         }
 392         leaf network-name {
 393             type string;
 394             description "Unique Neutron UUID of an instance of the network role ";
 395         }
 396         leaf neutron-id {
 397             type string;
 398             description "Unique Neutron UUID of an instance of the network role ";
 399         }
 400         leaf network-id {
 401             type string;
 402             description "Unique Neutron UUID of an instance of the network role ";
 403         }
 404         leaf subnet-id {
 405             type string;
 406             description "ipv4 subnet UUID to be passed into the HEAT template for DHCP assignment";
 407         }
 408         leaf contrail-network-fqdn {
 409             type string;
 410             description "contrail network policy object";
 411         }
 412         leaf ipv6-subnet-id {
 413             type string;
 414             description "ipv6 subnet UUID to be passed into the HEAT template for DHCP assignment";
 415         }
 416         leaf ipv6-subnet-name {
 417             type string;
 418             description "ipv6 subnet-name that corresponds to the ipv6 subnet-id";
 419         }
 420         leaf subnet-name {
 421             type string;
 422             description "ipv4 subnet-name that corresponds to the ipv4 subnet-id";
 423         }
 424         leaf ipv4-key-subnet-id {
 425             description "Unique SDN-C generated UUID of the ipv4 subnet.Key into A&AI instance.";
 426             type string;
 427         }
 428         leaf ipv6-key-subnet-id {
 429             description "Unique SDN-C generated UUID of the ipv6 subnet.Key into A&AI instance.";
 430             type string;
 431         }
 432         leaf subnet-role {
 433             type string;
 434         }
 435     }
 436
 437     grouping sriov-vlan-filter-list {
 438         list sriov-vlan-filter-list {
 439             key "sriov-vlan-filter";
 440             leaf sriov-vlan-filter {
 441                 type string;
 442             }
 443         }
 444     }
 445
 446     grouping vm-network {
 447         leaf network-role {
 448             type string;
 449             description "network (identified by role) that this VM connects to.  Should also be included in the vnf-networks for the containing VNF";
 450         }
 451         leaf network-role-tag {
 452             type string;
 453             description "The network-role that maps to the HEAT parameter {network-role}_net_id";
 454         }
 455         leaf use-dhcp {
 456             type enumeration {
 457                   enum "Y";
 458                   enum "N";
 459             }
 460             description "Indicator to use DHCP on this network for this VM";
 461         }
 462         leaf ip-count {
 463             type uint8;
 464             description "The number of ip addresses to be assigned per vm for this network role";
 465         }
 466         leaf ip-count-ipv6 {
 467             type uint8;
 468             description "The number of ipv6 addresses to be assigned per vm for this network role";
 469         }
 470         list network-ips {
 471             ordered-by user;
 472             key ip-address;
 473             leaf ip-address {
 474                 type ietf:ip-address;
 475                 description "List of assigned ipv4 addresses on a network";
 476             }
 477         }
 478         list network-ips-v6 {
 479             ordered-by user;
 480             key ip-address-ipv6;
 481             leaf ip-address-ipv6 {
 482                 type ietf:ipv6-address;
 483                 description "List of assigned ipv6 addresses on a network";
 484             }
 485         }
 486         list network-macs {
 487             ordered-by user;
 488             key mac-address;
 489             leaf mac-address {
 490                 type string;
 491                 description "List of network assignments for this VM (one per network)";
 492             }
 493         }
 494         leaf floating-ip {
 495             type ietf:ip-address;
 496             description "Floating ipv4 for VMs of a given type on this network";
 497         }
 498         leaf floating-ip-v6 {
 499             type ietf:ipv6-address;
 500             description "Floating ipv6 for VMs of a given type on this network";
 501         }
 502         list interface-route-prefixes {
 503             ordered-by user;
 504             key interface-route-prefix;
 505             leaf interface-route-prefix {
 506                 type ietf:ip-address;
 507                 description "OBSOLETE, route prefixes (CIDRs) to be provided to MSO in vnf-topology as a list of static routes";
 508             }
 509             leaf interface-route-prefix-cidr {
 510                 type string;
 511                 description "route prefixes (CIDRs) in ip/cidr format to be provided to MSO in vnf-topology as a list of static routes";
 512             }
 513         }
 514     }
 515
 516     grouping vnf-parameters {
 517         list vnf-parameters {
 518             key vnf-parameter-name;
 519             leaf vnf-parameter-name {
 520                 type string;
 521                 description "The name of an arbitrary instance-specific vnf-parameters";
 522             }
 523             leaf vnf-parameter-value {
 524                 type string;
 525                 description "The value of an arbitrary instance-specific vnf-parameters ";
 526             }
 527         }
 528     }
 529
 530     grouping network-topology-information {
 531         container network-topology-information {
 532             uses network-topology-identifier;
 533             uses subnets;
 534             uses vpn-bindings;
 535             uses network-policy;
 536             uses route-table-reference;
 537             uses provider-network-information;
 538         }
 539     }
 540
 541     grouping network-topology-identifier {
 542         container network-topology-identifier {
 543             leaf service-type {
 544                 type string;
 545             }
 546             leaf network-name {
 547                 type string;
 548             }
 549             leaf network-role {
 550                 type string;
 551             }
 552             leaf network-type {
 553                 type string;
 554             }
 555             leaf network-technology{
 556                 type string;
 557             }
 558         }
 559     }
 560     grouping subnets {
 561         list subnets {
 562             key start-address;
 563             leaf start-address{
 564                 type ietf:ip-address;
 565             }
 566             leaf gateway-address{
 567                 type ietf:ip-address;
 568             }
 569             leaf cidr-mask{
 570                 type string;
 571             }
 572             leaf ip-version {
 573                 type string;
 574             }
 575             leaf dhcp-enabled {
 576                 type enumeration {
 577                     enum "Y";
 578                     enum "N";
 579                 }
 580             }
 581             leaf dhcp-start-address {
 582                 type string;
 583             }
 584             leaf dhcp-end-address {
 585                 type string;
 586             }
 587             leaf subnet-name {
 588                 type string;
 589             }
 590             leaf addr-from-start {
 591                 description "Default is N";
 592                 type enumeration {
 593                     enum "Y";
 594                     enum "N";
 595                 }
 596             }
 597             leaf subnet-role {
 598                 type string;
 599             }
 600             uses host-routes;
 601         }
 602     }
 603
 604     grouping vpn-bindings {
 605         list vpn-bindings {
 606             key vpn-binding-id;
 607             leaf vpn-binding-id {
 608                 type string;
 609             }
 610             leaf global-route-target {
 611                 type string;
 612             }
 613         }
 614     }
 615
 616     grouping network-policy {
 617         list network-policy {
 618             key network-policy-fqdn;
 619             leaf network-policy-fqdn {
 620                 type string;
 621             }
 622             leaf network-policy-id {
 623                 type string;
 624             }
 625         }
 626     }
 627
 628     grouping route-table-reference {
 629         list route-table-reference {
 630             key "route-table-reference-id";
 631             leaf route-table-reference-id {
 632                 type string;
 633             }
 634             leaf route-table-reference-fqdn {
 635                 type string;
 636             }
 637         }
 638     }
 639
 640     grouping provider-network-information {
 641         container provider-network-information {
 642             leaf physical-network-name {
 643                 type string;
 644             }
 645             leaf is-provider-network {
 646                 type boolean;
 647             }
 648             leaf is-shared-network {
 649                 type boolean;
 650             }
 651             leaf is-external-network {
 652                 type boolean;
 653             }
 654         }
 655     }
 656
 657     grouping host-routes {
 658         list host-routes {
 659             key "route-prefix";
 660             leaf route-prefix {
 661                 type string;
 662             }
 663             leaf next-hop {
 664                 description "Could be ip-address or hostname or service-instance";
 665                 type string;
 666             }
 667         }
 668     }
 669
 670     /***********************************************************/
 671     /*               SERVICE_DATA                                */
 672     /***********************************************************/
 673     container vnfs {
 674         uses vnf-model-infrastructure;
 675     }
 676     grouping vnf-model-infrastructure {
 677         list vnf-list {
 678             key vnf-id;
 679             leaf vnf-id {
 680                 type string;
 681                 mandatory true;
 682                 description "vf-module-id";
 683             }
 684             uses service-data;
 685             uses service-status;
 686         }
 687     }
 688     grouping service-data {
 689         container service-data {
 690             uses vnf-configuration-information;
 691             uses oper-status;
 692         }
 693     }
 694     grouping service-status {
 695         container service-status {
 696             leaf response-code {
 697                 type string;
 698             }
 699             leaf response-message {
 700                 type string;
 701             }
 702             leaf final-indicator {
 703                 type string;
 704             }
 705             leaf request-status {
 706                 type enumeration {
 707                     enum "synccomplete";
 708                     enum "asynccomplete";
 709                     enum "notifycomplete";
 710                 }
 711             }
 712             leaf vnfsdn-action {
 713                 type enumeration {
 714                     enum "PreloadNetworkRequest";
 715                     enum "DeletePreloadNetworkRequest";
 716                     enum "NetworkActivateRequest";
 717                     enum "DisconnectNetworkRequest";
 718                     enum "PreloadVNFRequest";
 719                     enum "DeletePreloadVNFRequest";
 720                     enum "VNFActivateRequest";
 721                     enum "ChangeVNFActivateRequest";
 722                     enum "DisconnectVNFRequest";
 723                     enum "PreloadVnfInstanceRequest";
 724                     enum "DeletePreloadVnfInstanceRequest";
 725                     enum "VnfInstanceActivateRequest";
 726                     enum "ChangeVnfInstanceActivateRequest";
 727                     enum "DisconnectVnfInstanceRequest";
 728                     enum "PreloadVfModuleRequest";
 729                     enum "DeletePreloadVfModuleRequest";
 730                     enum "VfModuleActivateRequest";
 731                     enum "ChangeVfModuleActivateRequest";
 732                     enum "DisconnectVfModuleRequest";
 733                 }
 734             }
 735             leaf vnfsdn-subaction {
 736                 type enumeration {
 737                     enum "SUPP";
 738                     enum "CANCEL";
 739                     enum "RetainResource";
 740                 }
 741             }
 742             leaf rpc-name {
 743                 type enumeration {
 744                     enum "vnf-topology-operation";
 745                     enum "preload-vnf-topology-operation";
 746                     enum "vnf-instance-topology-operation";
 747                     enum "preload-vnf-instance-topology-operation";
 748                     enum "vf-module-topology-operation";
 749                     enum "preload-vf-module-topology-operation";
 750                 }
 751             }
 752             leaf rpc-action {
 753                 type enumeration {
 754                     enum "reserve";
 755                     enum "assign";
 756                     enum "activate";  // equal to commit
 757                     enum "delete";      // equal to commit
 758                     enum "changeassign";
 759                     enum "changedelete";
 760                     enum "rollback";
 761                 }
 762             }
 763             leaf response-timestamp {
 764                 type string;
 765             }
 766         }
 767     }
 768     grouping vnf-configuration-information {
 769         uses sdnc-request-header;
 770         uses request-information;
 771         uses service-information;
 772         uses vnf-request-information;
 773         uses vnf-topology;
 774     }
 775     grouping vnf-topology-response-body {
 776         leaf svc-request-id {
 777             type string;
 778         }
 779         leaf response-code {
 780             type string;
 781         }
 782         leaf response-message {
 783             type string;
 784         }
 785         leaf ack-final-indicator {
 786             type string;
 787         }
 788     }
 789
 790     grouping vnf-information {
 791         container vnf-information {
 792             leaf vnf-service-type {
 793                 type string;
 794             }
 795             leaf vnf-id {
 796                 type string;
 797                 description "vf-module-id";
 798             }
 799         }
 800     }
 801
 802     grouping network-information {
 803         container network-information {
 804             leaf network-service-type {
 805                 type string;
 806             }
 807             leaf network-id {
 808                 type string;
 809             }
 810         }
 811     }
 812
 813
 814     // Carried over from l3sdn and potentially not needed
 815     grouping oper-status {
 816         container oper-status {
 817             leaf order-status {
 818                 type enumeration {
 819                     enum "Active";
 820                     enum "PendingAssignment";
 821                     enum "PendingCreate";
 822                     enum "PendingUpdate";
 823                     enum "PendingDelete";
 824                     enum "Deleted";
 825
 826                 }
 827             }
 828             leaf last-action {
 829                 type enumeration {
 830                     enum "VNFActivateRequest";
 831                     enum "ChangeVNFActivateRequest";
 832                     enum "VnfInstanceActivateRequest";
 833                     enum "ChangeVnfInstanceActivateRequest";
 834                     enum "VfModuleActivateRequest";
 835                     enum "ChangeVfModuleActivateRequest";
 836                     enum "DisconnectVNFRequest";
 837                     enum "DisconnectVnfInstanceRequest";
 838                     enum "DisconnectVfModuleRequest";
 839                     enum "PreloadVNFRequest";
 840                     enum "DeletePreloadVNFRequest";
 841                     enum "PreloadVnfInstanceRequest";
 842                     enum "DeletePreloadVnfInstanceRequest";
 843                     enum "PreloadVfModuleRequest";
 844                     enum "DeletePreloadVfModuleRequest";
 845                 }
 846             }
 847             leaf last-svc-request-id {
 848                 type string;
 849             }
 850             leaf last-order-status {
 851                 type enumeration {
 852                     enum "Active";
 853                     enum "PendingAssignment";
 854                     enum "PendingCreate";
 855                     enum "PendingUpdate";
 856                     enum "PendingDelete";
 857                     enum "Deleted";
 858                 }
 859             }
 860             leaf create-timestamp {
 861                 type string;
 862             }
 863             leaf modify-timestamp {
 864                 type string;
 865             }
 866             leaf maintenance-indicator {
 867                 type enumeration {
 868                     enum "Y";
 869                     enum "N";
 870                 }
 871             }
 872         }
 873     }
 874     grouping vnf-topology {
 875         leaf vnf-id {
 876             type string;
 877             description "vf-module-id";
 878         }
 879         uses vnf-topology-information;
 880     }
 881
 882
 883     rpc vnf-topology-operation {
 884         input {
 885             uses sdnc-request-header;
 886             uses request-information;
 887             uses service-information;
 888             uses vnf-request-information;
 889         }
 890         output {
 891             uses vnf-topology-response-body;
 892             uses vnf-information;
 893             uses service-information;
 894         }
 895     }
 896
 897     rpc network-topology-operation {
 898         input {
 899             uses sdnc-request-header;
 900             uses request-information;
 901             uses service-information;
 902             uses network-request-information;
 903         }
 904         output {
 905             uses vnf-topology-response-body;
 906             uses network-information;
 907             uses service-information;
 908         }
 909     }
 910
 911     rpc preload-vnf-topology-operation {
 912         input {
 913             uses sdnc-request-header;
 914             uses request-information;
 915             uses vnf-topology-information;
 916         }
 917         output {
 918             uses vnf-topology-response-body;
 919         }
 920     }
 921
 922     rpc preload-network-topology-operation {
 923         input {
 924             uses sdnc-request-header;
 925             uses request-information;
 926             uses network-topology-information;
 927         }
 928         output {
 929             uses vnf-topology-response-body;
 930         }
 931     }
 932 }