models/yang/nsd.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 nsd
{
  namespace "urn:ietf:params:xml:ns:yang:nfvo:nsd";
  prefix "nsd";

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

  import vnfd {
    prefix "vnfd";
  }

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

  import mano-types {
    prefix "manotypes";
  }

  revision 2014-10-27 {
    description
      "Initial revision. This YANG file defines
       the Network Service Descriptor (NSD)";
    reference
      "Derived from earlier versions of base YANG files";
  }

  typedef scaling-trigger {
    type enumeration {
      enum pre-scale-in {
        value 1;
      }
      enum post-scale-in {
        value 2;
      }
      enum pre-scale-out {
        value 3;
      }
      enum post-scale-out {
        value 4;
      }
    }
  }

  typedef scaling-policy-type {
    type enumeration {
      enum manual {
        value 1;
      }
      enum automatic {
        value 2;
      }
    }
  }

  typedef scaling-criteria-operation {
    type enumeration {
      enum AND {
        value 1;
      }
      enum OR {
        value 2;
      }
    }
  }

  grouping primitive-parameter {
    leaf name {
      description
          "Name of the parameter.";
      type string;
    }

    leaf data-type {
      description
          "Data type associated with the name.";
      type manotypes:parameter-data-type;
    }

    leaf mandatory {
      description "Is this field mandatory";
      type boolean;
      default false;
    }

    leaf default-value {
      description "The default value for this field";
      type string;
    }

    leaf parameter-pool {
      description "NSD parameter pool name to use for this parameter";
      type string;
    }
  }

  grouping nsd-descriptor {
    leaf id {
      description "Identifier for the NSD.";
      type string;
    }

    leaf name {
      description "NSD name.";
      mandatory true;
      type string;
    }

    leaf short-name {
      description "Short name to appear as label in the UI";
      type string;
    }

    leaf vendor {
      description "Vendor of the NSD.";
      type string;
    }

    leaf logo {
      description
        "File path for the vendor-specific logo. For example, icons/mylogo.png.
         The logo should be part of the network service";
      type string;
    }

    leaf description {
      description "Description of the NSD.";
      type string;
    }

    leaf version {
      description "Version of the NSD";
      type string;
    }

    list connection-point {
      description
          "List for external connection points.
          Each network service (NS) has one or more external connection
          points that connect the NS to other NSs or to external networks.
          Each NS exposes connection points to the orchestrator, which can
          construct network service chains by connecting the connection
          points between different NSs.";
      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;
      }
    }

    /* Model Limitations,
       see the comments under vnfd-connection-point-ref
     */
    list vld {
      description
          "List of Virtual Link Descriptors (VLDs).";

      key "id";

      leaf id {
        description
            "Identifier for the VLD.";
        type string;
      }

      leaf name {
        description
            "Virtual Link Descriptor (VLD) name.";
        type string;
      }

      leaf short-name {
        description
            "Short name to appear as label in the UI";
        type string;
      }

      leaf vendor {
        description "Provider of the VLD.";
        type string;
      }

      leaf description {
        description "Description of the VLD.";
        type string;
      }

      leaf version {
        description "Version of the VLD";
        type string;
      }

      leaf type {
        type manotypes:virtual-link-type;
      }

      leaf root-bandwidth {
        description
            "For ELAN this is the aggregate bandwidth.";
        type uint64;
      }

      leaf leaf-bandwidth {
        description
            "For ELAN this is the bandwidth of branches.";
        type uint64;
      }

      list vnfd-connection-point-ref {
        description
            "A list of references to connection points.";
        key "member-vnf-index-ref vnfd-connection-point-ref";

        leaf member-vnf-index-ref {
          description "Reference to member-vnf within constituent-vnfds";
          type leafref {
            path "../../../constituent-vnfd/member-vnf-index";
          }
        }

        leaf vnfd-id-ref {
          description
              "A reference to a VNFD";
          type leafref {
            path "../../../constituent-vnfd" +
                 "[member-vnf-index = current()/../member-vnf-index-ref]" +
                 "/vnfd-id-ref";
          }
        }

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

      // replicate for pnfd container here
      uses manotypes:provider-network;

      leaf mgmt-network {
         description "Flag indicating whether this network is a VIM management network";
         type boolean;
         default false;
      }

      choice init-params {
        description "Extra parameters for VLD instantiation";

        case vim-network-ref {
          leaf vim-network-name {
            description
                "Name of network in VIM account. This is used to indicate
                   pre-provisioned network name in cloud account.";
            type string;
          }
        }

        case vim-network-profile {
          leaf ip-profile-ref {
            description "Named reference to IP-profile object";
            type leafref {
              path "../../ip-profiles/name";
            }
          }
        }
      }
    }

    list constituent-vnfd {
      description
          "List of VNFDs that are part of this
          network service.";

      key "member-vnf-index";

      leaf member-vnf-index {
        description
          "Identifier/index for the VNFD. This separate id
           is required so that multiple VNFs can be part of
           single NS";
        type uint64;
      }

      leaf vnfd-id-ref {
        description
          "Identifier for the VNFD.";
        type leafref {
          path "/vnfd:vnfd-catalog/vnfd:vnfd/vnfd:id";
        }
      }

      leaf start-by-default {
        description
          "VNFD is started as part of the NS instantiation";
        type boolean;
        default true;
      }
    }

    list scaling-group-descriptor {
      description
          "Scaling group descriptor within this network service.
           The scaling group defines a group of VNFs,
           and the ratio of VNFs in the network service
           that is used as target for scaling action";

      key "name";

      leaf name {
        description "Name of this scaling group.";
        type string;
      }

      list scaling-policy {

        key "name";

        leaf name {
          description
              "Name of the scaling policy";
          type string;
        }

        leaf scaling-type {
          description
              "Type of scaling";
          type scaling-policy-type;
        }

        leaf enabled {
          description
            "Specifies if the scaling policy can be applied";
          type boolean;
          default true;
        }

        leaf scale-in-operation-type {
          description
              "Operation to be applied to check between scaling criterias to
               check if the scale in threshold condition has been met.
               Defaults to AND";
          type scaling-criteria-operation;
          default AND;
        }

        leaf scale-out-operation-type {
          description
              "Operation to be applied to check between scaling criterias to
               check if the scale out threshold condition has been met.
               Defaults to OR";
          type scaling-criteria-operation;
          default OR;
        }

        leaf threshold-time {
          description
            "The duration for which the criteria must hold true";
          type uint32;
          mandatory true;
        }

        leaf cooldown-time {
          description
            "The duration after a scaling-in/scaling-out action has been
            triggered, for which there will be no further scaling activity";
          type uint32;
          mandatory true;
        }

        list scaling-criteria {
          description
              "list of conditions to be met for generating scaling
                 requests";
          key "name";

          leaf name {
            description "Name of the scaling criteria";
            type string;
          }

          leaf scale-in-threshold {
            description
                "Value below which scale-in requests are generated
                 (depends on monitoring parameters)";
            type uint64;
          }

          leaf scale-out-threshold {
            description
                "Value above which scale-out requests are generated
                 (depends on monitoring parameters)";
            type uint64;
          }

          leaf ns-monitoring-param-ref {
            description
               "Reference to the NS level monitoring parameter
                that is aggregated";
            type leafref {
              path "../../../../monitoring-param/id";
            }
          }
        }
      }

      list vnfd-member {
        description "List of VNFs in this scaling group";
        key "member-vnf-index-ref";

        leaf member-vnf-index-ref {
          description "Member VNF index of this member VNF";
          type leafref {
            path "../../../constituent-vnfd/member-vnf-index";
          }
        }

        leaf count {
          description
            "Count of this member VNF  within this scaling group.
             The count defines the number of instances when a
             scaling action targets this scaling group.";
          type uint32;
          default 1;
        }
      }

      leaf min-instance-count {
        description
          "Minimum number of instances of the scaling group that
          are allowed in a single network service. These instances
          are created by default when the network service is
          instantiated.";
        type uint32;
        default 0;
      }

      leaf max-instance-count {
        description
          "Maximum number of instances of this scaling group that
          are allowed in a single network service. The network
          service scaling fails when the number of service group
          instances exceeds the max-instance-count specified.";
        type uint32;
        default 10;
      }

      list scaling-config-action {
        description "List of scaling config actions";
        key "trigger";

        leaf trigger {
          description "Scaling trigger";
          type scaling-trigger;
        }

        leaf ns-config-primitive-name-ref {
          description "Reference to the NS config name primitive";
          type leafref {
            path "../../../service-primitive/name";
          }
        }
      }
    }

    list placement-groups {
      description "List of placement groups at NS level";

      key "name";
      uses manotypes:placement-group-info;

      list member-vnfd {
        description
            "List of VNFDs that are part of this placement group";

        key "member-vnf-index-ref";

        leaf member-vnf-index-ref {
          description "Member VNF index of this member VNF";
          type leafref {
            path "../../../constituent-vnfd/member-vnf-index";
          }
        }

        leaf vnfd-id-ref {
          description
              "Identifier for the VNFD.";
          type leafref {
            path "../../../constituent-vnfd" +
                 "[member-vnf-index = current()/../member-vnf-index-ref]" +
                 "/vnfd-id-ref";
          }
        }
      }
    }

    uses manotypes:ip-profile-list;

    list vnf-dependency {
      description
          "List of VNF dependencies.";
      key vnf-source-ref;
      leaf vnf-source-ref {
        type leafref {
          path "../../constituent-vnfd/vnfd-id-ref";
        }
      }
      leaf vnf-depends-on-ref {
        description
            "Reference to VNF on which the source VNF depends.";
        type leafref {
          path "../../constituent-vnfd/vnfd-id-ref";
        }
      }
    }

    list vnffgd {
      description
          "List of VNF Forwarding Graph Descriptors (VNFFGD).";

      key "id";

      leaf id {
        description
            "Identifier for the VNFFGD.";
        type string;
      }

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

      leaf short-name {
        description
            "Short name to appear as label in the UI";
        type string;
      }

      leaf vendor {
        description "Provider of the VNFFGD.";
        type string;
      }

      leaf description {
        description "Description of the VNFFGD.";
        type string;
      }

      leaf version {
        description "Version of the VNFFGD";
        type string;
      }

      list rsp {
        description
            "List of Rendered Service Paths (RSP).";

        key "id";

        leaf id {
          description
              "Identifier for the RSP.";
          type string;
        }

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

        list vnfd-connection-point-ref {
          description
                "A list of references to connection points.";
          key "member-vnf-index-ref";

          leaf member-vnf-index-ref {
            description "Reference to member-vnf within constituent-vnfds";
            type leafref {
              path "../../../../constituent-vnfd/member-vnf-index";
            }
          }

          leaf order {
            type uint8;
            description
                "A number that denotes the order of a VNF in a chain";
          }

           leaf vnfd-id-ref {
             description
                 "A reference to a vnfd";
             type leafref {
                path "../../../../constituent-vnfd" +
                     "[member-vnf-index = current()/../member-vnf-index-ref]" +
                     "/vnfd-id-ref";
             }
           }

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

      list classifier {
        description
            "List of classifier rules.";

        key "id";

        leaf id {
          description
              "Identifier for the classifier rule.";
          type string;
        }

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

        leaf rsp-id-ref {
          description
              "A reference to the RSP.";
          type leafref {
            path "../../rsp/id";
          }
        }

        leaf member-vnf-index-ref {
          description "Reference to member-vnf within constituent-vnfds";
          type leafref {
            path "../../../constituent-vnfd/member-vnf-index";
          }
        }

        leaf vnfd-id-ref {
          description
              "A reference to a VNFD";
          type leafref {
              path "../../../constituent-vnfd" +
                   "[member-vnf-index = current()/../member-vnf-index-ref]" +
                   "/vnfd-id-ref";
          }
        }

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

        list match-attributes {
          description
              "List of match attributes.";

          key "id";

          leaf id {
            description
                "Identifier for the classifier match attribute rule.";
            type string;
          }

          leaf ip-proto {
            description
                "Internet Protocol.";
            type uint8;
          }

          leaf source-ip-address {
            description
                "Source IP address.";
            type inet:ip-address;
          }

          leaf destination-ip-address {
            description
                "Destination IP address.";
            type inet:ip-address;
          }

          leaf source-port {
            description
                "Source port number.";
            type inet:port-number;
          }

          leaf destination-port {
            description
                "Destination port number.";
            type inet:port-number;
          }
        } //match-attributes
      } // classifier
    } // vnffgd

    list monitoring-param {
      description
        "List of monitoring parameters from VNFs that should be
        propogated up into NSR";
      key "id";

      leaf id {
        description "Identifier for a monitoring parameter";
        type string;
      }

      leaf name {
        description "Name of the monitoring parameter";
        type string;
      }

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

      list vnfd-monitoring-param {
        description "A list of VNFD monitoring params";
        key "member-vnf-index-ref vnfd-monitoring-param-ref";

        leaf vnfd-id-ref {
          description
             "A reference to a VNFD. This is a leafref";

          type leafref {
            path "../../../constituent-vnfd" +
                 "[member-vnf-index = current()/../member-vnf-index-ref]" +
                 "/vnfd-id-ref";
          }
        }

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

        leaf member-vnf-index-ref {
          description
            "Mandatory reference to member-vnf within constituent-vnfds";
          type leafref {
            path "../../../constituent-vnfd/member-vnf-index";
          }
        }
      }
    }

    uses manotypes:input-parameter-xpath;

    list parameter-pool {
      description
         "Pool of parameter values from which to choose during
         configuration.";
      key "name";

      leaf name {
        description
            "Name of the configuration value pool";
        type string;
      }

      container range {
        description
            "Create a range of values from which to populate the pool with";

        leaf start-value {
          description
              "Generated pool values start at this value";
          type uint32;
          mandatory true;
        }

        leaf end-value {
          description
              "Generated pool values stop at this value";
          type uint32;
          mandatory true;
        }
      }
    }

    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 leafref {
             path "../../../constituent-vnfd/member-vnf-index";
          }
        }

        leaf vnfd-id-ref {
          description
              "A reference to a VNFD. This is a leafref";

          type leafref {
             path "../../../constituent-vnfd" +
                "[member-vnf-index = current()/../member-vnf-index-ref]" + "/vnfd-id-ref";
          }
        }

        leaf vnfd-name {
          description
              "Name of the VNFD";
          type leafref {
              path "/vnfd:vnfd-catalog/vnfd:vnfd"
                    + "[vnfd:id = current()/../vnfd-id-ref]"
                    + "/vnfd:name";
          }
        }

        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 NsdInitialConfigPrimitive;
      description
        "Initial set of configuration primitives for NSD.";
      key "seq";

      uses manotypes:initial-config;
    }

    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;
      }
    }

    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 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;
        }
      }
    }
  }


  container nsd-catalog {

    list nsd {
      key "id";

      uses nsd-descriptor;
    }
  }

}