models/yang/nsr.yang

/*
 * 
 *   Copyright 2016 RIFT.IO Inc
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *
 */

module nsr
{
  namespace "urn:ietf:params:xml:ns:yang:nfvo:nsr";
  prefix "nsr";

  import rw-pb-ext {
    prefix "rwpb";
  }

  import vlr {
    prefix "vlr";
  }

  import nsd {
    prefix "nsd";
  }

  import vnfd {
    prefix "vnfd";
  }

  import vnfr {
    prefix "vnfr";
  }

  import ietf-inet-types {
    prefix "inet";
  }

  import ietf-yang-types {
    prefix "yang";
  }

  import mano-types {
    prefix "manotypes";
  }

  import rw-sdn {
    prefix "rwsdn";
  }

  revision 2015-09-10 {
    description
      "Initial revision. This YANG file defines
       the Network Service Record (NSR)";
    reference
      "Derived from earlier versions of base YANG files";
  }

  typedef config-states {
    type enumeration {
      enum init;
      enum configuring;
      enum config_not_needed;
      enum configured;
      enum failed;
    }
  }

  typedef trigger-type {
    type enumeration {
      enum ns-primitive;
      enum vnf-primitive;
    }
  }

  grouping cloud-config {
    description "List of cloud config parameters";

    list ssh-authorized-key {
      key "key-pair-ref";

      description "List of authorized ssh keys as part of cloud-config";

      leaf key-pair-ref {
        description "A reference to the key pair entry in the global key pair table";
        type leafref {
          path "/nsr:key-pair/nsr:name";
        }
      }
    }
    list user {
      key "name";

      description "List of users to be added through cloud-config";
      leaf name {
        description "Name of the user ";
        type string;
      }
      leaf user-info {
        description "The user name's real name";
        type string;
      }
      list ssh-authorized-key {
        key "key-pair-ref";

        description "Used to configure the list of public keys to be injected as part 
                        of ns instantiation";

        leaf key-pair-ref {
          description "A reference to the key pair entry in the global key pair table";
          type leafref {
            path "/nsr:key-pair/nsr:name";
          }
        }
      }
    }
  }

  list key-pair {
    key "name";
    description "Used to configure the list of public keys to be injected as part
                 of ns instantiation";
    leaf name {
      description "Name of this key pair";
      type string;
    }

    leaf key {
      description "Key associated with this key pair";
      type string;
    }
  }

  rpc start-network-service {
    description "Start the network service";
    input {
      leaf name {
        mandatory true;
        description "Name of the Network Service";
        type string;
      }
      leaf nsd-ref {
        description "Reference to NSR ID ref";
        mandatory true;
        type leafref {
          path "/nsd:nsd-catalog/nsd:nsd/nsd:id";
        }
      }
      uses ns-instance-config-params;
    }

    output {
      leaf nsr-id {
        description "Automatically generated parameter";
        type yang:uuid;
      }
    }
  }



  container ns-instance-config {

    list nsr {
      key "id";
      unique "name";

      leaf id {
        description "Identifier for the NSR.";
        type yang:uuid;
      }

      leaf name {
        description "NSR name.";
        type string;
      }

      leaf short-name {
        description "NSR short name.";
        type string;
      }

      leaf description {
        description "NSR description.";
        type string;
      }

      leaf admin-status {
        description
          "This is the administrative status of the NS instance";

        type enumeration {
          enum ENABLED;
          enum DISABLED;
        }
      }

      container nsd {
        description "NS descriptor used to instantiate this NS";
        uses nsd:nsd-descriptor;
      }

      uses ns-instance-config-params;
    }
  }

  grouping ns-instance-config-params {
    uses manotypes:input-parameter;

    list scaling-group {
      description "List of ns scaling group instances";
      key "scaling-group-name-ref";

      leaf scaling-group-name-ref {
        description "name of the scaling group
        leafref path ../../nsd/scaling-group-descriptor/name";
        type string;
      }

      list instance {
        description "The instance of the scaling group";
        key "id";
        leaf id {
          description "Scaling group instance uuid";
          type uint16;
        }
      }
    }

    list nsd-placement-group-maps {
      description
          "Mapping from mano-placement groups construct from NSD to cloud
          platform placement group construct";

      key "placement-group-ref";

      leaf placement-group-ref {
        description "Reference for NSD placement group
            leafref path ../../nsd/placement-groups/name";
        type string;
      }
      uses manotypes:placement-group-input;
    }

   list vnfd-placement-group-maps {
      description
          "Mapping from mano-placement groups construct from VNFD to cloud
          platform placement group construct";

    key "placement-group-ref vnfd-id-ref";

    leaf vnfd-id-ref {
      description
          "A reference to a vnfd. This is a
          leafref to path:
          ../../../../nsd:constituent-vnfd
          + [nsr:id = current()/../nsd:id-ref]
          + /nsd:vnfd-id-ref
          NOTE: confd limitations prevent the use of xpath";
      type yang:uuid;
    }

    leaf placement-group-ref {
      description
          "A reference to VNFD placement group";
      type leafref {
        path "/vnfd:vnfd-catalog/vnfd:vnfd[vnfd:id = current()/" +
            "../nsr:vnfd-id-ref]/vnfd:placement-groups/vnfd:name";
      }
    }

    uses manotypes:placement-group-input;
   }
   uses cloud-config;
  }

  grouping vnffgr {

    list vnffgr {
      key "id";

      leaf id {
        description "Identifier for the VNFFGR.";
        type yang:uuid;
      }

      leaf vnffgd-id-ref {
        description "VNFFG descriptor id reference";
        type leafref {
          path "/nsr:ns-instance-config/nsr:nsr"
            + "[nsr:id=current()/../../ns-instance-config-ref]"
            + "/nsr:nsd/nsr:vnffgd/nsr:id";
        }
      }

      leaf vnffgd-name-ref {
        description "VNFFG descriptor name reference";
        type leafref {
            path "/ns-instance-config/nsr"
              + "[id=current()/../../ns-instance-config-ref]"
              + "/nsd/vnffgd[nsr:id = current()/../vnffgd-id-ref]"
              + "/name";
        }
      }

      leaf sdn-account {
        description
            "The SDN account to use when requesting resources for
            this vnffgr";
        type leafref {
          path "/rwsdn:sdn/rwsdn:account/rwsdn:name";
        }
      }

      leaf operational-status {
        description
          "The operational status of the VNFFGR instance
            init                : The VNFFGR has just started.
            running             : The VNFFGR is in running state.
            terminate           : The VNFFGR is being terminated.
            terminated          : The VNFFGR is in the terminated state.
            failed              : The VNFFGR instantiation failed
          ";

        type enumeration {
          rwpb:enum-type "VnffgrOperationalStatus";
          enum init;
          enum running;
          enum terminate;
          enum terminated;
          enum failed;
        }
      }

      list rsp {
        key "id";

        leaf id {
          description
              "Identifier for the RSP.";
          type yang:uuid;
        }

        leaf name {
          description
              "Name for the RSP";
          type string;
        }

        leaf vnffgd-rsp-id-ref {
          description
              "Identifier for the VNFFG Descriptor RSP reference";
          type leafref {
            path "/ns-instance-config/nsr"
              + "[id=current()/../../../ns-instance-config-ref]"
              + "/nsd/vnffgd"
              + "[id=current()/../../vnffgd-id-ref]"
              + "/rsp/id";
          }
        }

        leaf vnffgd-rsp-name-ref {
          description
              "Name for the VNFFG Descriptor RSP reference";
          type leafref {
            path "/ns-instance-config/nsr:nsr"
              + "[id=current()/../../../ns-instance-config-ref]"
              + "/nsd/vnffgd"
              + "[id=current()/../../vnffgd-id-ref]"
              + "/rsp[id=current()/../vnffgd-rsp-id-ref]"
              + "/name";
          }
        }

        leaf classifier-name {
          type string;
        }

        leaf path-id {
          description
              "Unique Identifier for the service path";
          type uint32;
        }

        list vnfr-connection-point-ref {
          key "hop-number";
          leaf hop-number {
            description
                "Monotonically increasing number to show service path hop
                order";
            type uint8;
          }
          leaf service-function-type {
            description
                "Type of Service Function.
                NOTE: This needs to map with Service Function Type in ODL to
                support VNFFG. Service Function Type is mandatory param in ODL
                SFC. This is temporarily set to string for ease of use";
            type string;
          }

          leaf member-vnf-index-ref {
            type uint64;
          }
          leaf vnfd-id-ref {
            description
                "Reference to VNF Descriptor Id";
            type string;
          }
          leaf vnfr-id-ref {
            description
                "A reference to a vnfr id";
                type leafref {
                  path "/vnfr:vnfr-catalog/vnfr:vnfr/vnfr:id";
                }
          }
          leaf vnfr-name-ref {
            description
                "A reference to a vnfr name";
                type leafref {
                  path "/vnfr:vnfr-catalog/vnfr:vnfr/vnfr:name";
                }
          }
          leaf vnfr-connection-point-ref {
            description
                "A reference to a vnfr connection point.";
            type leafref {
              path "/vnfr:vnfr-catalog/vnfr:vnfr"
                 + "[vnfr:id = current()/../nsr:vnfr-id-ref]"
                 + "/vnfr:connection-point/vnfr:name";
            }
          }
          leaf service-index {
            description
                "Location within the service path";
            type uint8;
          }
          container connection-point-params {
            leaf mgmt-address {
              type inet:ip-address;
            }
            leaf name {
              type string;
            }
            leaf port-id {
              rwpb:field-inline "true";
              rwpb:field-string-max 64;
              type string;
            }
            leaf vm-id {
              rwpb:field-inline "true";
              rwpb:field-string-max 64;
              type string;
            }
            leaf address {
              type inet:ip-address;
            }
            leaf port {
              type inet:port-number;
            }
          }

          container service-function-forwarder {
            leaf name {
              description
                  "Service Function Forwarder name";
              type string;
            }
            leaf ip-address {
              description
                  "Data Plane IP Address of the SFF";
              type inet:ip-address;
            }
            leaf port {
              description
                  "Data Plane Port of the SFF";
              type inet:port-number;
            }
          }
        }
      }

      list classifier {
          key "id";

          leaf id {
            description
                "Identifier for the classifier rule.";
            type yang:uuid;
          }
          leaf name {
            description
                "Name of the classifier.";
            type string;
          }
          leaf rsp-id-ref {
            description
                "A reference to the RSP.";
            type leafref {
              path "../../nsr:rsp/nsr:id";
            }
          }
          leaf rsp-name {
            description
              "Name for the RSP";
            type string;
          }
          leaf vnfr-id-ref {
            description
                "A reference to a vnfr id";
                type leafref {
                  path "/vnfr:vnfr-catalog/vnfr:vnfr/vnfr:id";
                }
          }
          leaf vnfr-name-ref {
            description
                "A reference to a vnfr name";
                type leafref {
                  path "/vnfr:vnfr-catalog/vnfr:vnfr/vnfr:name";
                }
          }
          leaf vnfr-connection-point-ref {
            description
                "A reference to a vnfr connection point.";
            type leafref {
              path "/vnfr:vnfr-catalog/vnfr:vnfr"
                 + "[vnfr:id = current()/../nsr:vnfr-id-ref]"
                 + "/vnfr:connection-point/vnfr:name";
            }
          }
          leaf port-id {
            rwpb:field-inline "true";
            rwpb:field-string-max 64;
            type string;
          }
          leaf vm-id {
            rwpb:field-inline "true";
            rwpb:field-string-max 64;
            type string;
          }
          leaf ip-address {
            type string;
          }
          leaf sff-name {
            type string;
          }
      }
    }
  }

  container ns-instance-opdata {
    config false;

    list nsr {
      key "ns-instance-config-ref";

      leaf ns-instance-config-ref {
        type leafref {
          path "/nsr:ns-instance-config/nsr:nsr/nsr:id";
        }
      }

      leaf name-ref {
        description "Network service name reference";
        type leafref {
          path "/nsr:ns-instance-config/nsr:nsr/nsr:name";
        }
      }

      leaf nsd-ref {
        description "Network service descriptor id reference";
        type leafref {
          path "/ns-instance-config/nsr"
            + "[id=current()/../ns-instance-config-ref]"
            + "/nsd/id";
        }
      }

      leaf nsd-name-ref {
        description "Network service descriptor name reference";
        type leafref {
          path "/ns-instance-config/nsr"
            + "[id=current()/../ns-instance-config-ref]"
            + "/nsd/name";
        }
      }

      leaf create-time {
        description
          "Creation timestamp of this Network Service.
          The timestamp is expressed as seconds
          since unix epoch - 1970-01-01T00:00:00Z";

        type uint32;
      }

      leaf uptime {
        description
          "Active period of this Network Service.
          Uptime is expressed in seconds";

        type uint32;
      }

      list connection-point {
        description
            "List for external connection points.
            Each NS has one or more external connection points.
            As the name implies that external connection points
            are used for connecting the NS to other NS or to
            external networks. Each NS exposes these connection
            points to the orchestrator. The orchestrator can
            construct network service chains by connecting the
            connection points between different NS.";

        key "name";
        leaf name {
          description
              "Name of the NS connection point.";
          type string;
        }

        leaf type {
          description
              "Type of the connection point.";
          type manotypes:connection-point-type;
        }
      }

      list vlr {
        key "vlr-ref";
        leaf vlr-ref {
          description
              "Reference to a VLR record in the VLR catalog";
          type leafref {
            path "/vlr:vlr-catalog/vlr:vlr/vlr:id";
          }
        }


        list vnfr-connection-point-ref {
          description
            "A list of references to connection points.";
          key "vnfr-id";

          leaf vnfr-id {
            description "A reference to a vnfr";
            type leafref {
              path "/vnfr:vnfr-catalog/vnfr:vnfr/vnfr:id";
            }
          }

          leaf connection-point {
            description
                "A reference to a connection point name in a vnfr";
            type leafref {
              path "/vnfr:vnfr-catalog/vnfr:vnfr"
                 + "[vnfr:id = current()/../nsr:vnfr-id]"
                 + "/vnfr:connection-point/vnfr:name";
            }
          }
        }
      }

      list constituent-vnfr-ref {
        description
            "List of VNFRs that are part of this
             network service.";
        key "vnfr-id";

        leaf vnfr-id {
          description
            "Reference to the VNFR id
             This should be a leafref to /vnfr:vnfr-catalog/vnfr:vnfr/vnfr:id
             But due to confd bug (RIFT-9451), changing to string.
            ";
          type string;
        }
      }

      list scaling-group-record {
        description "List of scaling group records";
        key "scaling-group-name-ref";

        leaf scaling-group-name-ref {
          description "name of the scaling group";
          type leafref {
            path "/ns-instance-config/nsr"
              + "[id=current()/../../ns-instance-config-ref]"
              + "/nsd/scaling-group-descriptor/name";
          }
        }

        list instance {
          description "Reference to scaling group instance record";
          key "instance-id";
          leaf instance-id {
            description "Scaling group instance id";
            type uint16;
          }

          leaf is-default {
            description "Flag indicating whether this instance was part of
                default scaling group (and thus undeletable)";
            type boolean;
          }

          leaf op-status {
            description
              "The operational status of the NS instance
                init                : The scaling group has just started.
                vnf-init-phase      : The VNFs in the scaling group are being instantiated.
                running             : The scaling group  is in running state.
                terminate           : The scaling group is being terminated.
                vnf-terminate-phase : The VNFs in the scaling group are being terminated.
                terminated          : The scaling group  is in the terminated state.
                failed              : The scaling group instantiation failed.
              ";

            type enumeration {
              enum init;
              enum vnf-init-phase;
              enum running;
              enum terminate;
              enum vnf-terminate-phase;
              enum terminated;
              enum failed;
            }
          }

          leaf config-status {
            description
              "The configuration status of the scaling group instance
               configuring : At least one of the VNFs in this scaling group instance
                             is in configuring state
               configured  : All the VNFs in this scaling group instance are
                             configured or config-not-needed state
               failed      : Configuring this scaling group instance failed
              ";
            type config-states;
          }

          leaf error-msg {
            description
              "Reason for failure in configuration of this scaling instance";
            type string;
          }

          leaf create-time {
            description
              "Creation timestamp of this scaling group record.
              The timestamp is expressed as seconds
              since unix epoch - 1970-01-01T00:00:00Z";

              type uint32;
          }

          leaf-list vnfrs {
            description "Reference to VNFR within the scale instance";
            type leafref {
              path "../../../constituent-vnfr-ref/vnfr-id";
            }
          }
        }
      }

      uses vnffgr;

      leaf operational-status {
        description
          "The operational status of the NS instance
            init                : The network service has just started.
            vl-init-phase       : The VLs in the NS are being instantiated.
            vnf-init-phase      : The VNFs in the NS are being instantiated.
            running             : The NS is in running state.
            terminate           : The NS is being terminated.
            vnf-terminate-phase : The NS is terminating the VNFs in the NS.
            vl-terminate-phase  : The NS is terminating the VLs in the NS.
            terminated          : The NS is in the terminated state.
            failed              : The NS instantiation failed.
            scaling-out         : The NS is scaling out
            scaling-in          : The NS is scaling in
            vl-instantiate      : The NS is initiating a new VL
            vl-terminate        : The NS is terminating a VL
          ";

        type enumeration {
          enum init;
          enum vl-init-phase;
          enum vnf-init-phase;
          enum running;
          enum terminate;
          enum vnf-terminate-phase;
          enum vl-terminate-phase;
          enum terminated;
          enum failed;
          enum scaling-out;
          enum scaling-in;
          enum vl-instantiate;
          enum vl-terminate;
        }
      }

      leaf config-status {
        description
          "The configuration status of the NS instance
            configuring: At least one of the VNFs in this instance is in configuring state
            configured:  All the VNFs in this NS instance are configured or config-not-needed state
          ";
        type config-states;
      }

      list service-primitive {
         description
              "Network service level service primitives.";

         key "name";

         leaf name {
            description
                "Name of the service primitive.";
            type string;
         }

         list parameter {
            description
                "List of parameters for the service primitive.";

            key "name";
            uses manotypes:primitive-parameter;
         }

         uses manotypes:ui-primitive-group;

         list vnf-primitive-group {
            description
                "List of service primitives grouped by VNF.";

            key "member-vnf-index-ref";
            leaf member-vnf-index-ref {
              description
                 "Reference to member-vnf within constituent-vnfds";
              type uint64;
            }

            leaf vnfd-id-ref {
               description
                 "A reference to a vnfd. This is a 
                  leafref to path:
                      ../../../../nsd:constituent-vnfd
                      + [nsd:id = current()/../nsd:id-ref]
                      + /nsd:vnfd-id-ref
                  NOTE: confd limitations prevent the use of xpath";

               type string;
            }

            leaf vnfd-name {
               description
                 "Name of the VNFD";
               type string;
            }

            list primitive {
               key "index";

               leaf index {
                 description "Index of this primitive";
                 type uint32;
               }

               leaf name {
                 description "Name of the primitive in the VNF primitive ";
                 type string;
               }
            }
         }

         leaf user-defined-script {
           description
               "A user defined script.";
           type string;
         }
      }

      list initial-config-primitive {
        rwpb:msg-new NsrInitialConfigPrimitive;
        description
            "Initial set of configuration primitives for NSD.";
        key "seq";
        leaf seq {
          description
              "Sequence number for the configuration primitive.";
          type uint64;
        }

        leaf name {
          description
              "Name of the configuration primitive.";
          type string;
          mandatory "true";
        }

        leaf user-defined-script {
          description
              "A user defined script.";
          type string;
        }

        list parameter {
          description
              "List of parameters for the initial config primitive";
          key "name";
          leaf name {
            description "Name of the intitial config parameter";
            type string;
          }

          leaf value {
            description "Value associated with the initial config 
                        parameter";
            type string;
          }
        }
      }


      list monitoring-param {
        description
          "List of NS level params.";
        key "id";

        uses manotypes:monitoring-param-value;
        uses manotypes:monitoring-param-ui-data;
        uses manotypes:monitoring-param-aggregation;

        leaf id {
          type string;
        }

        leaf name {
          type string;
        }

        leaf nsd-mon-param-ref {
          description "Reference to the NSD monitoring param descriptor
                       that produced this result";
          type leafref {
            path "/nsd:nsd-catalog/nsd:nsd[nsd:id = current()/" +
                 "../../nsr:nsd-ref]/nsd:monitoring-param/nsd:id";
          }
        }

        list vnfr-mon-param-ref {
          description "A list of VNFR monitoring params associated with this monp";
          key "vnfr-id-ref vnfr-mon-param-ref";

          leaf vnfr-id-ref {
            description
               "A reference to a vnfr. This is a
                leafref to path:
                    /vnfr:vnfr-catalog/vnfr:vnfr/vnfr:id";

            type yang:uuid;
          }

          leaf vnfr-mon-param-ref {
            description "A reference to the VNFR monitoring param";
            type leafref {
              path "/vnfr:vnfr-catalog/vnfr:vnfr"
                + "[vnfr:id = current()/../nsr:vnfr-id-ref]"
                + "/vnfr:monitoring-param/vnfr:id";
            }
          }
        }
      }

      list config-agent-job {
        key "job-id";

        leaf job-id {
          description "config agent job Identifier for the NS.";
          type uint64;
        }

        leaf job-name {
          description "Config agent job name";
          type string;
        }

        leaf job-status {
          description
              "Job status to be set based on each VNF primitive execution,
               pending  - if at least one VNF is in pending state
                          and remaining VNFs are in success state.
               Success  - if all VNF executions are in success state
               failure  - if one of the VNF executions is failure";
          type enumeration {
            enum pending;
            enum success;
            enum failure;
          }
        }

        leaf triggered-by {
          description "The primitive is triggered from NS or VNF level";
          type trigger-type;
        }

        leaf create-time {
          description
            "Creation timestamp of this Config Agent Job.
            The timestamp is expressed as seconds
            since unix epoch - 1970-01-01T00:00:00Z";

          type uint32;
        }

        leaf job-status-details {
          description "Config agent job status details, in case of errors";
          type string;
        }

        uses manotypes:primitive-parameter-value;

        list parameter-group {
          description
              "List of NS Primitive parameter groups";
          key "name";
          leaf name {
            description
                "Name of the parameter.";
            type string;
          }

          uses manotypes:primitive-parameter-value;
        }

        list vnfr {
          key "id";
          leaf id {
            description "Identifier for the VNFR.";
            type yang:uuid;
          }
          leaf vnf-job-status {
            description
                "Job status to be set based on each VNF primitive execution,
                 pending  - if at least one primitive is in pending state
                            and remaining primitives are in success state.
                 Success  - if all primitive executions are in success state
                 failure  - if one of the primitive executions is failure";
            type enumeration {
              enum pending;
              enum success;
              enum failure;
            }
          }

          list primitive {
            key "name";
            leaf name {
              description "the name of the primitive";
              type string;
            }

            uses manotypes:primitive-parameter-value;

            leaf execution-id {
              description "Execution id of the primitive";
              type string;
            }
            leaf execution-status {
              description "status of the Execution";
              type enumeration {
                enum pending;
                enum success;
                enum failure;
              }
            }
            leaf execution-error-details {
              description "Error details if execution-status is failure";
              type string;
            }
          }
        }
      }
    }
  }

  rpc get-ns-service-primitive-values {
    description "Get the service primitive parameter values";
    input {
      leaf nsr_id_ref {
        description "Reference to NSR ID ref";
        mandatory true;
        type leafref {
          path "/nsr:ns-instance-config/nsr:nsr/nsr:id";
        }
      }

      leaf name {
        description "Name of the NS service primitive group";
        mandatory true;
        type string;
      }
    }

    output {
      list ns-parameter {
        description "Automatically generated parameter";
        key "name";

        leaf name {
          description "Parameter name which should be pulled from a parameter pool";
          type string;
        }
        leaf value {
          description "Automatically generated value";
          type string;
        }
      }

      list ns-parameter-group {
        description "Automatically generated parameters in parameter group";
        key "name";
        leaf name {
          description "Parameter group name";
          type string;
        }
        list parameter {
          description "Automatically generated group parameter";
          key "name";

          leaf name {
            description "Parameter name which should be pulled from a parameter pool";
            type string;
          }
          leaf value {
            description "Automatically generated value";
            type string;
          }
        }
      }

      list vnf-primitive-group {
        description
            "List of service primitives grouped by VNF.";

        key "member-vnf-index-ref";
        leaf member-vnf-index-ref {
          description
              "Reference to member-vnf within constituent-vnfds";
          type uint64;
        }

        leaf vnfd-id-ref {
          description
              "A reference to a vnfd. This is a
               leafref to path:
                   ../../../../nsd:constituent-vnfd
                   + [nsd:id = current()/../nsd:id-ref]
                   + /nsd:vnfd-id-ref
               NOTE: confd limitations prevent the use of xpath";

          type string;
        }

        list primitive {
          key "index";
          leaf index {
            description "Index of this primitive";
            type uint32;
          }

          leaf name {
            description "Name of the primitive associated with a value pool";
            type string;
          }

          list parameter {
            description "Automatically generated parameter";
            key "name";

            leaf name {
              description "Parameter name which should be pulled from a parameter pool";
              type string;
            }
            leaf value {
              description "Automatically generated value";
              type string;
            }
          }
        }
      }
    }
  }

  rpc exec-ns-service-primitive {
    description "Executes a NS service primitive or script";

    input {
      leaf name {
        description "Name of the primitive";
        type string;
      }

      leaf nsr_id_ref {
        description "Reference to NSR ID ref";
        type leafref {
          path "/nsr:ns-instance-config/nsr:nsr/nsr:id";
        }
      }

      leaf triggered-by {
        description "The primitive is triggered from NS or VNF level";
        type trigger-type;
        default ns-primitive;
      }

      uses manotypes:primitive-parameter-value;

      list parameter-group {
        description
            "List of NS Primitive parameter groups";
        key "name";
        leaf name {
          description
              "Name of the parameter.";
          type string;
        }

        uses manotypes:primitive-parameter-value;
      }

      list vnf-list {
        description
            "List of VNFs whose primitives are being set.";
        key "member_vnf_index_ref";

        leaf member_vnf_index_ref {
          description "Member VNF index";
          type uint64;
        }

        leaf vnfr-id-ref {
          description
              "A reference to a vnfr. This is a
               leafref to path";
          type yang:uuid;
        }

        list vnf-primitive {
          description
              "List of service primitives supported by the
            configuration agent for this VNF.";
          key "index";

          leaf index {
            description
                "index of the service primitive.";
            type uint32;
          }
          leaf name {
            description
                "Name of the service primitive.";
            type string;
          }

          uses manotypes:primitive-parameter-value;
        }
      }
      leaf user-defined-script {
        description
            "A user defined script.";
        type string;
      }
    }
    output {
      leaf job-id {
        description "Job identifier for this RPC";
        type uint64;
      }

      leaf name {
        description "Name of the service primitive";
        type string;
      }

      leaf nsr_id_ref {
        description "Reference to NSR ID ref";
        type leafref {
          path "/nsr:ns-instance-config/nsr:nsr/nsr:id";
        }
      }

      leaf triggered-by {
        description "The primitive is triggered from NS or VNF level";
        type trigger-type;
      }

      leaf create-time {
        description
          "Creation timestamp of this config agent JOB.
          The timestamp is expressed as seconds
          since unix epoch - 1970-01-01T00:00:00Z";

        type uint32;
      }

      leaf job-status-details {
        description "Job status details, in case of any errors";
        type string;
      }

      uses manotypes:primitive-parameter-value;

      list parameter-group {
        description
            "List of NS Primitive parameter groups";
        key "name";
        leaf name {
          description
              "Name of the parameter.";
          type string;
        }

        uses manotypes:primitive-parameter-value;
      }

      list vnf-out-list {
        description
            "List of VNFs whose primitives were set.";
        key "member_vnf_index_ref";

        leaf member_vnf_index_ref {
          description "Member VNF index";
          type uint64;
        }
        leaf vnfr-id-ref {
          description
              "A reference to a vnfr. This is a
               leafref to path";
          type yang:uuid;
        }

        list vnf-out-primitive {
          description
              "List of service primitives supported by the
            configuration agent for this VNF.";
          key "index";

          leaf index {
            description
                "index of the service primitive.";
            type uint32;
          }

          leaf name {
            description
                "Name of the service primitive.";
            type string;
          }

          uses manotypes:primitive-parameter-value;

          leaf execution-id {
            description "Execution id of this primitive";
            type string;
          }

          leaf execution-status {
            description "Status of the execution of this primitive";
            type string;
          }

          leaf execution-error-details {
            description "Error details if execution-status is failed";
            type string;
          }
        }
      }
    }
  }

  rpc exec-scale-in {
    description "Executes scale out request";

    input {

      leaf nsr-id-ref {
        description "Reference to NSR ID ref";
        type leafref {
          path "/nsr:ns-instance-config/nsr:nsr/nsr:id";
        }
      }

      leaf scaling-group-name-ref {
        description "name of the scaling group";
        type string;
      }

      leaf instance-id {
        description "id of the scaling group";
        type uint64;
      }


    }
    output {
      leaf instance-id {
        description "id of the scaling group";
        type uint64;
      }
    }
  }

  rpc exec-scale-out {
    description "Executes scale out request";

    input {

      leaf nsr-id-ref {
        description "Reference to NSR ID ref";
        type leafref {
          path "/nsr:ns-instance-config/nsr:nsr/nsr:id";
        }
      }

      leaf scaling-group-name-ref {
        description "name of the scaling group";
        type string;
      }

      leaf instance-id {
        description "id of the scaling group";
        type uint64;
      }

    }
    output {
     leaf instance-id {
        description "id of the scaling group";
        type uint64;
      }
    }
  }

}