
/*
 *
 *   Copyright 2016-2017 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 vnfr
{
  namespace "urn:etsi:osm:yang:vnfr";
  prefix "vnfr";

  import mano-types {
    prefix "manotypes";
  }

  import vnfd-base {
    prefix "vnfd-base";
  }

  import project-vnfd {
    prefix "project-vnfd";
  }

  import project-nsd {
    prefix "project-nsd";
  }

  import vlr {
    prefix "vlr";
  }

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

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

  import osm-project {
    prefix "osm-project";
  }

  revision 2017-02-28 {
    description
      "Update model to support projects.";
  }

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

  typedef vdu-operational-status {
    type enumeration {
      enum init;
      enum vm-init-phase;
      enum vm-alloc-pending;
      enum running;
      enum upgrading;
      enum terminate;
      enum vl-terminate-phase;
      enum terminated;
      enum failed;
    }
  }

  typedef vnf-operational-status {
    type enumeration {
      enum pre-init;
      enum init;
      enum vl-init-phase;
      enum vm-init-phase;
      enum running;
      enum upgrading;   // Experimental
      enum terminate;
      enum vm-terminate-phase;
      enum vl-terminate-phase;
      enum terminated;
      enum failed;
    }
  }

  grouping placement-group-info {
    list placement-groups-info {
      description
          "
          Placement groups to which this VDU belongs and its
          cloud construct
          ";
      key "name";
      uses manotypes:placement-group-info;
      uses manotypes:placement-group-input;
    }
  }

  grouping virtual-interface {
    container virtual-interface {
      description
          "Container for the virtual interface properties";

      leaf type {
        description
            "Specifies the type of virtual interface
             between VM and host.
             PARAVIRT        : Use the default paravirtualized interface for the VIM (virtio, vmxnet3, etc.).
             VIRTIO          : Deprecated! Use the traditional VIRTIO interface.
             PCI-PASSTHROUGH : Use PCI-PASSTHROUGH interface.
             SR-IOV          : Use SR-IOV interface.";
        type enumeration {
          enum PARAVIRT;
          enum VIRTIO;
          enum PCI-PASSTHROUGH;
          enum SR-IOV;
        }
      }

      leaf bandwidth {
        description
            "Aggregate bandwidth of the NIC.";
        type uint64;
      }

      leaf ovs-offload {
        description
            "Defines if the NIC supports OVS offload.
             MANDATORY : OVS offload support in the NIC is mandatory.
             PREFERRED : OVS offload support in the NIC is preferred.";
        type enumeration {
          enum MANDATORY;
          enum PREFERRED;
        }
      }

      leaf vendor-id {
        description
            "Specifies the vendor specific id for
             the device. This is used when a NIC from
             specific HW vendor is required.";
        type string;
      }

      leaf datapath-library {
        description
            "Specifies the name and version of the datapath
             library the NIC is expected to support.";
        type string;
      }

      leaf provider-network-name {
        description
            "Name of the provider network to which this
             NIC is attached.";
        type string;
      }
    }
  }

  grouping associated-virtual-cps {
    list virtual-cps {
      key "name";
      uses vnfd-base:common-connection-point;

      leaf ip-address {
        description
            "IP address assigned to the virtual connection point";
        type inet:ip-address;
      }

      leaf mac-address {
        description
            "MAC address assigned to the virtual connection point";
        type string;
      }

      leaf connection-point-id {
        description "VIM identifier for connection point";
        type string;
      }
    }
  }

  augment "/osm-project:project" {
    container vnfr-catalog {
      leaf schema-version {
        description "Schema version for the VNFR. If unspecified, it assumes v3.0";
        type string;
        default "v3.0";
      }

      config false;
      list vnfr {
        description
          "Virtual Network Function Record (VNFR).";
        key "id";
        unique "name";

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

        leaf nsr-id-ref {
          description
            "NS instance identifier.
             This is a leafref /nsr:ns-instance-config/nsr:nsr/nsr:id";
          type yang:uuid;
        }

        leaf member-vnf-index-ref {
          description "Reference to member VNF index in Network service.";
          type leafref {
            path "../../../project-nsd:nsd-catalog/project-nsd:nsd/project-nsd:constituent-vnfd/project-nsd:member-vnf-index";
          }
        }

        leaf dashboard-url {
          description "Dashboard URL";
          type inet:uri;
        }

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

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

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

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

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

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

          type uint32;
        }

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

          type uint32;
        }

        container vnfd {
          description "VNF descriptor used to instantiate this VNF";
          uses vnfd-base:vnfd-descriptor;
        }

        leaf vnfd-ref {
          description "Reference to VNFD";
          type leafref {
            path "../../../project-vnfd:vnfd-catalog/project-vnfd:vnfd/project-vnfd:id";
          }
        }

        // Use parameters provided here to configure this VNF
        container vnf-configuration {
          uses manotypes:vca-configuration;
        }

        // Mainly used by Mon-params & dashboard url
        container mgmt-interface {
          leaf ip-address {
            type inet:ip-address;
          }

          leaf port {
            type inet:port-number;
          }

          container ssh-key {
            description "SSH key pair used for this VNF";
            leaf public-key {
              description "Public key configured on this VNF";
              type string;
            }

            leaf private-key-file {
              description "Path to the private key file";
              type string;
            }
          }
        }

        list internal-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";
            }
          }

          leaf-list internal-connection-point-ref {
            type leafref {
              path "../../vdur/internal-connection-point/id";
            }
          }
        }

        list connection-point {
          key "name";
          description
            "List for external connection points. Each VNF has one
             or more external connection points. As the name
             implies that external connection points are used for
             connecting the VNF to other VNFs or to external networks.
             Each VNF exposes these connection points to the
             orchestrator. The orchestrator can construct network
             services by connecting the connection points between
             different VNFs. The NFVO will use VLDs and VNFFGs at
             the network service level to construct network services.";

          uses vnfd-base:common-connection-point;

          leaf vlr-ref {
            description
              "Reference to the VLR associated with this connection point";
            type  leafref {
              path "../../../../vlr:vlr-catalog/vlr:vlr/vlr:id";
            }
          }

          leaf ip-address {
            description
              "IP address assigned to the external connection point";
            type inet:ip-address;
          }

          leaf mac-address {
            description
              "MAC address assigned to the external connection point";
            // type inet:mac-address;
            type string;
          }

          leaf connection-point-id {
            type string;
          }

          uses associated-virtual-cps;
        }

        list vdur {
          description "List of Virtual Deployment Units";
          key "id";
          unique "name";

          leaf id {
            description "Unique id for the VDU";
            type yang:uuid;
          }

          leaf name {
            description "name of the instantiated VDUR";
            type string;
          }

          leaf unique-short-name {
            description "Short Unique name of the VDU
                  This will be of the format NSR name-ShortnedString-VDUname
                  NSR name and VDU name shall be constrained to 10 characters";
            type string;
          }

          leaf vdu-id-ref {
            type leafref {
              path "../../vnfd/vdu/id";
            }
          }

          leaf vim-id {
            description "Allocated VM resource id";
            type string;
          }

          leaf flavor-id {
            description "VIM assigned flavor id";
            type string;
          }

          leaf image-id {
            description "VIM assigned image id";
            type string;
          }

          leaf management-ip {
            description "Management IP address";
            type inet:ip-address;
          }

          leaf vm-management-ip {
            description "VM Private Management IP address";
            type inet:ip-address;
          }

          leaf console-url {
            description "Console URL for this VDU, if available";
            type inet:uri;
          }

          uses manotypes:vm-flavor;
          uses manotypes:guest-epa;
          uses manotypes:vswitch-epa;
          uses manotypes:hypervisor-epa;
          uses manotypes:host-epa;

          uses manotypes:supplemental-boot-data;

          container vdu-configuration {
            uses manotypes:vca-configuration;
          }

          list monitoring-param {
            description
              "List of VDU-related monitoring parameters at NFVI level";
            key id;
            leaf id {
              description "The unique id of the monitoring param at VDU level";
              type string;
            }

            leaf nfvi-metric {
              description "The associated NFVI metric to be monitored";
              type manotypes:nfvi-metric-type;
            }

            leaf interface-name-ref {
              description
                "Reference to a VDU interface name. Applicable only when the nfvi-metric
                refers to an interface and not to the VM";
              type leafref {
                path "../../interface/name";
              }
            }
          }

          list volumes {
            key "name";

            leaf name {
              description "Name of the disk-volumes, e.g. vda, vdb etc";
              type string;
            }

            leaf volume-id {
              description "VIM assigned volume id";
              type string;
            }

            uses manotypes:volume-info;
          }

          list internal-connection-point {
            key "id";
            description
              "List for internal connection points. Each VNFC
               has zero or more internal connection points.
               Internal connection points are used for connecting
               the VNF components internal to the VNF. If a VNF
               has only one VNFC, it may not have any internal
               connection points.";

            uses vnfd-base:common-connection-point;

            leaf ip-address {
              description
                "IP address assigned to the internal connection point";
              type inet:ip-address;
            }

            leaf mac-address {
              description
                "MAC address assigned to the internal connection point";
              // type inet:mac-address;
              type string;
            }

            leaf connection-point-id {
              type string;
            }

            uses associated-virtual-cps;
          }

          list interface {
            description
                "List of interfaces (internal and external) for the VNF";
            key name;

            leaf name {
              description
                  "Name of the interface. Note that this
                  name has only local significance to the VDU.";
              type string;
            }

            leaf position {
              description
                  "Explicit Position of the interface within the list";
              type uint32;
            }

            leaf type {
              description
                  "Type of the Interface";

              type vnfd-base:interface-type;

              default "EXTERNAL";
            }
            choice connection-point-type {
              case internal {
                leaf internal-connection-point-ref {
                  description
                      "Leaf Ref to the particular internal connection point";
                  type leafref {
                    path "../../internal-connection-point/id";
                  }
                }
              }
              case external {
                leaf external-connection-point-ref {
                  description
                      "Leaf Ref to the particular external connection point";
                  type leafref {
                    path "../../../connection-point/name";
                  }
                }
              }
            }
            uses virtual-interface;
          }

          leaf operational-status {
            description
              "The operational status of the VDU
                init                : The VDU has just started.
                vm-init-phase       : The VDUs in the VNF is being created in VIM.
                vm-alloc-pending    : The  VM alloc is pending in VIM
                running             : The VDU is active in VM
                upgrading           : The VDU is being upgraded (EXPERIMENTAL)
                terminate           : The VDU is being terminated
                vm-terminate-phase  : The VDU in the VNF is being terminated in VIM.
                terminated          : The VDU is in the terminated state.
                failed              : The VDU  instantiation failed.
              ";
            type vdu-operational-status;
          }

          uses placement-group-info;
        }

        list monitoring-param {
          description
            "List of monitoring parameters at the network service level";
          key id;
          leaf id {
            type string;
          }

          leaf name {
            type string;
          }

          uses manotypes:monitoring-param-aggregation;

          choice monitoring-type {
            description
              "Defines the type of monitoring param to be used:
                * vdu-monitorin-param:     VDU-related metric (from NFVI)
                * vnf-metric:              VNF-related metric (from VCA)
                * vdu-metric:              VDU-related metric (from VCA)
              ";

            case vdu-monitoring-param {
              description "VDU-related metric from the infrastructure";
              container vdu-monitoring-param {
                leaf vdu-ref {
                  type leafref {
                    path "../../../vdur/id";
                  }
                }
                leaf vdu-monitoring-param-ref {
                  type leafref {
                    path "../../../vdur[id = current()/../vdu-ref]/monitoring-param/id";
                  }
                }
              }
            }

            case vnf-metric {
              description "VNF-related metric (from VCA)";
              container vnf-metric {
                leaf vnf-metric-name-ref {
                  type leafref {
                    path "../../../vnf-configuration/metrics/name";
                  }
                }
              }
            }

            case vdu-metric {
              description "VDU-related metric (from VCA)";
              container vdu-metric {
                leaf vdu-ref {
                  type leafref {
                    path "../../../vdur/id";
                  }
                }
                leaf vdu-metric-name-ref {
                  type leafref {
                    path "../../../vdur[id = current()/../vdu-ref]/vdu-configuration/metrics/name";
                  }
                }
              }
            }

          }

        }

        leaf operational-status {
          description
            "The operational status of the VNFR instance
              pre-init            : The VNF before Input Param Substitution.
              init                : The VNF has just started.
              vl-init-phase       : The internal VLs in the VNF are being instantiated.
              vm-init-phase       : The VMs for VDUs in the VNF are being instantiated.
              running             : The VNF is in running state.
              terminate           : The VNF is being terminated.
              vm-terminate-phase  : The VMs in the VNF are being terminated.
              vl-terminate-phase  : The internal VLs in the VNF are being terminated.
              terminated          : The VNF is in the terminated state.
              failed              : The VNF instantiation failed
            ";
          type vnf-operational-status;
        }

        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 enumeration {
            enum configuring {
              value 1;
            }
            enum configured {
              value 2;
            }
            enum failed {
              value 3;
            }
            enum config-not-needed {
              value 4;
            }
          }
        }
        uses placement-group-info;

        container cloud-config {
          uses manotypes:cloud-config;
        }
      }
    }
  }
}
