X-Git-Url: https://osm.etsi.org/gitweb/?a=blobdiff_plain;f=models%2Fplugins%2Fyang%2Fmano-types.yang;fp=models%2Fplugins%2Fyang%2Fmano-types.yang;h=cd5d446d8eba05c662d4d23801d24f05369d691d;hb=6f07e6f33f751ab4ffe624f6037f887b243bece2;hp=0000000000000000000000000000000000000000;hpb=72a563886272088feb7cb52e4aafbe6d2c580ff9;p=osm%2FSO.git diff --git a/models/plugins/yang/mano-types.yang b/models/plugins/yang/mano-types.yang new file mode 100644 index 00000000..cd5d446d --- /dev/null +++ b/models/plugins/yang/mano-types.yang @@ -0,0 +1,1991 @@ + +/* + * + * 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 mano-types +{ + namespace "urn:ietf:params:xml:ns:yang:nfvo:mano-types"; + prefix "manotypes"; + + import ietf-inet-types { + prefix "inet"; + } + + import rw-pb-ext { + prefix "rwpb"; + } + + revision 2015-04-23 { + description + "Initial revision. This YANG file defines + the reusable base types for VNF Management + and Orchestration (MANO)."; + reference + "Derived from earlier versions of base YANG files"; + } + + typedef parameter-data-type { + type enumeration { + enum STRING; + enum INTEGER; + enum BOOLEAN; + } + } + + grouping primitive-parameter-value { + list parameter { + description + "List of parameters to the configuration primitive."; + key "name"; + leaf name { + description + "Name of the parameter."; + type string; + } + + leaf value { + description + "Value associated with the name."; + type string; + } + } + } + + 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 paramter"; + type string; + } + + leaf read-only { + description + "The value should be greyed out by the UI. + Only applies to parameters with default values."; + type boolean; + } + + leaf hidden { + description + "The value should be hidden by the UI. + Only applies to parameters with default values."; + type boolean; + } + } + + + grouping vnf-configuration { + container vnf-configuration { + rwpb:msg-new VnfConfiguration; + description + "Information regarding the VNF configuration + is captured here. Note that if the NS contains + multiple instances of the same VNF, each instance + of the VNF may have different configuration"; + + choice config-method { + description + "Defines the configuration method for the VNF."; + case netconf { + description + "Use NETCONF for configuring the VNF."; + container netconf { + leaf target { + description + "Netconf configuration target"; + type enumeration { + enum running; + enum candidate; + } + } + + leaf protocol { + description + "Protocol to use for netconf (e.g. ssh)"; + type enumeration { + enum None; + enum ssh; + } + } + + leaf port { + description + "Port for the netconf server."; + type inet:port-number; + } + } + } + + case rest { + description + "Use REST for configuring the VNF."; + container rest { + leaf port { + description + "Port for the REST server."; + type inet:port-number; + } + } + } + + case script { + description + "Use custom script for configuring the VNF. + This script is executed in the context of + Orchestrator."; + container script { + leaf script-type { + description + "Script type - currently supported : bash, expect"; + type enumeration { + enum bash; + enum expect; + } + } + } + } + + case juju { + description + "Configure the VNF through Juju."; + container juju { + leaf charm { + description "Juju charm to use with the VNF."; + type string; + } + } + } + } + + container config-access { + leaf mgmt-ip-address { + description + "IP address to be used to configure this VNF, + optional if it is possible to resolve dynamically."; + type inet:ip-address; + } + + leaf username { + description + "username for configuration."; + type string; + } + + leaf password { + description + "Password for configuration access authentication."; + type string; + } + } + + container config-attributes { + description + "Miscelaneous input parameters to be considered + while processing the NSD to apply configuration"; + + leaf config-priority { + description + "Configuration priority - order of confgiration + to be applied to each VNF in this NS, + low number gets precedence over high number"; + type uint64; + } + + leaf config-delay { + description + "Wait (seconds) before applying the configuration to VNF"; + type uint64; + } + } + + list service-primitive { + rwpb:msg-new ServicePrimitive; + description + "List of service primitives supported by the + configuration agent for this VNF."; + key "name"; + + leaf name { + description + "Name of the service primitive."; + type string; + } + + list parameter { + description + "List of parameters to the service primitive."; + key "name"; + uses primitive-parameter; + } + } + + list initial-config-primitive { + rwpb:msg-new InitialConfigPrimitive; + description + "Initial set of configuration primitives."; + key "seq"; + leaf seq { + description + "Sequence number for the configuration primitive."; + type uint64; + } + + leaf name { + description + "Name of the configuration primitive."; + type string; + } + + list parameter { + key "name"; + leaf name { + type string; + } + + leaf value { + type string; + } + } + } + + leaf config-template { + description + "Configuration template for each VNF"; + type string; + } + } + } // END - grouping vnf-configuration + + typedef virtual-link-type { + description + "Type of virtual link + ELAN: A multipoint service connecting a set of VNFs + // ELINE: For a simple point to point connection + // between a VNF and the existing network. + // ETREE: A multipoint service connecting one or + // more roots and a set of leaves, but + // preventing inter-leaf communication."; + type enumeration { + enum ELAN; + // enum ETREE; + // enum ELINE; + } + } + + grouping named-value { + leaf name { + type string; + } + + leaf value { + type string; + } + } + + typedef http-method { + description + "Type of HTTP operation"; + + type enumeration { + enum POST; + enum PUT; + enum GET; + enum DELETE; + enum OPTIONS; + enum PATCH; + } + } + + typedef api-type { + description + "Type of API to fetch monitoring params"; + + type enumeration { + enum HTTP; + enum NETCONF; + enum SOAP; + } + } + + typedef json-query-method { + description + "The method to extract a value from a JSON response + + NAMEKEY - Use the name as the key for a non-nested value. + JSONPATH - Use jsonpath-rw implemenation to extract a value. + OBJECTPATH - Use objectpath implemenation to extract a value."; + type enumeration { + enum NAMEKEY; + enum JSONPATH; + enum OBJECTPATH; + } + } + + typedef param-value-type { + description + "The type of the parameter value"; + type enumeration { + enum INT; + enum DECIMAL; + enum STRING; + } + } + + typedef connection-point-type { + description + "Type of connection point + VPORT: Virtual Port + // VNIC_ADDR: Virtual NIC Address + // PNIC_ADDR: Physical NIC Address + // PPORT: Phsical Port."; + + type enumeration { + enum VPORT; + } + } + + typedef widget-type { + description + "Type of the widget, typically used by the UI."; + type enumeration { + enum HISTOGRAM; + enum BAR; + enum GAUGE; + enum SLIDER; + enum COUNTER; + enum TEXTBOX; + } + } + + typedef cpu-feature-type { + description + "Enumeration for CPU features. + + AES: CPU supports advanced instruction set for + AES (Advanced Encryption Standard). + + CAT: Cache Allocation Technology (CAT) allows + an Operating System, Hypervisor, or similar + system management agent to specify the amount + of L3 cache (currently the last-level cache + in most server and client platforms) space an + application can fill (as a hint to hardware + functionality, certain features such as power + management may override CAT settings). + + CMT: Cache Monitoring Technology (CMT) allows + an Operating System, Hypervisor, or similar + system management agent to determine the + usage of cache based on applications running + on the platform. The implementation is + directed at L3 cache monitoring (currently + the last-level cache in most server and + client platforms). + + DDIO: Intel Data Direct I/O (DDIO) enables + Ethernet server NICs and controllers talk + directly to the processor cache without a + detour via system memory. This enumeration + specifies if the VM requires a DDIO + capable host."; + + type enumeration { + enum PREFER_AES; + enum REQUIRE_AES; + enum PREFER_CAT; + enum REQUIRE_CAT; + enum PREFER_CMT; + enum REQUIRE_CMT; + enum PREFER_DDIO; + enum REQUIRE_DDIO; + enum REQUIRE_VME; + enum PREFER_VME; + enum REQUIRE_DE; + enum PREFER_DE; + enum REQUIRE_PSE; + enum PREFER_PSE; + enum REQUIRE_TSC; + enum PREFER_TSC; + enum REQUIRE_MSR; + enum PREFER_MSR; + enum REQUIRE_PAE; + enum PREFER_PAE; + enum REQUIRE_MCE; + enum PREFER_MCE; + enum REQUIRE_CX8; + enum PREFER_CX8; + enum REQUIRE_APIC; + enum PREFER_APIC; + enum REQUIRE_SEP; + enum PREFER_SEP; + enum REQUIRE_MTRR; + enum PREFER_MTRR; + enum REQUIRE_PGE; + enum PREFER_PGE; + enum REQUIRE_MCA; + enum PREFER_MCA; + enum REQUIRE_CMOV; + enum PREFER_CMOV; + enum REQUIRE_PAT; + enum PREFER_PAT; + enum REQUIRE_PSE36; + enum PREFER_PSE36; + enum REQUIRE_CLFLUSH; + enum PREFER_CLFLUSH; + enum REQUIRE_DTS; + enum PREFER_DTS; + enum REQUIRE_ACPI; + enum PREFER_ACPI; + enum REQUIRE_MMX; + enum PREFER_MMX; + enum REQUIRE_FXSR; + enum PREFER_FXSR; + enum REQUIRE_SSE; + enum PREFER_SSE; + enum REQUIRE_SSE2; + enum PREFER_SSE2; + enum REQUIRE_SS; + enum PREFER_SS; + enum REQUIRE_HT; + enum PREFER_HT; + enum REQUIRE_TM; + enum PREFER_TM; + enum REQUIRE_IA64; + enum PREFER_IA64; + enum REQUIRE_PBE; + enum PREFER_PBE; + enum REQUIRE_RDTSCP; + enum PREFER_RDTSCP; + enum REQUIRE_PNI; + enum PREFER_PNI; + enum REQUIRE_PCLMULQDQ; + enum PREFER_PCLMULQDQ; + enum REQUIRE_DTES64; + enum PREFER_DTES64; + enum REQUIRE_MONITOR; + enum PREFER_MONITOR; + enum REQUIRE_DS_CPL; + enum PREFER_DS_CPL; + enum REQUIRE_VMX; + enum PREFER_VMX; + enum REQUIRE_SMX; + enum PREFER_SMX; + enum REQUIRE_EST; + enum PREFER_EST; + enum REQUIRE_TM2; + enum PREFER_TM2; + enum REQUIRE_SSSE3; + enum PREFER_SSSE3; + enum REQUIRE_CID; + enum PREFER_CID; + enum REQUIRE_FMA; + enum PREFER_FMA; + enum REQUIRE_CX16; + enum PREFER_CX16; + enum REQUIRE_XTPR; + enum PREFER_XTPR; + enum REQUIRE_PDCM; + enum PREFER_PDCM; + enum REQUIRE_PCID; + enum PREFER_PCID; + enum REQUIRE_DCA; + enum PREFER_DCA; + enum REQUIRE_SSE4_1; + enum PREFER_SSE4_1; + enum REQUIRE_SSE4_2; + enum PREFER_SSE4_2; + enum REQUIRE_X2APIC; + enum PREFER_X2APIC; + enum REQUIRE_MOVBE; + enum PREFER_MOVBE; + enum REQUIRE_POPCNT; + enum PREFER_POPCNT; + enum REQUIRE_TSC_DEADLINE_TIMER; + enum PREFER_TSC_DEADLINE_TIMER; + enum REQUIRE_XSAVE; + enum PREFER_XSAVE; + enum REQUIRE_AVX; + enum PREFER_AVX; + enum REQUIRE_F16C; + enum PREFER_F16C; + enum REQUIRE_RDRAND; + enum PREFER_RDRAND; + enum REQUIRE_FSGSBASE; + enum PREFER_FSGSBASE; + enum REQUIRE_BMI1; + enum PREFER_BMI1; + enum REQUIRE_HLE; + enum PREFER_HLE; + enum REQUIRE_AVX2; + enum PREFER_AVX2; + enum REQUIRE_SMEP; + enum PREFER_SMEP; + enum REQUIRE_BMI2; + enum PREFER_BMI2; + enum REQUIRE_ERMS; + enum PREFER_ERMS; + enum REQUIRE_INVPCID; + enum PREFER_INVPCID; + enum REQUIRE_RTM; + enum PREFER_RTM; + enum REQUIRE_MPX; + enum PREFER_MPX; + enum REQUIRE_RDSEED; + enum PREFER_RDSEED; + enum REQUIRE_ADX; + enum PREFER_ADX; + enum REQUIRE_SMAP; + enum PREFER_SMAP; + } + } + + grouping vm-flavor { + container vm-flavor { + leaf vcpu-count { + description + "Number of vcpus for the VM."; + type uint16; + } + + leaf memory-mb { + description + "Amount of memory in MB."; + type uint64; + } + + leaf storage-gb { + description + "Amount of disk space in GB."; + type uint64; + } + } + } //grouping vm-flavor + + grouping vswitch-epa { + container vswitch-epa { + leaf ovs-acceleration { + description + "Specifies Open vSwitch acceleration mode. + MANDATORY: OVS acceleration is required + PREFERRED: OVS acceleration is preferred"; + type enumeration { + enum MANDATORY; + enum PREFERRED; + enum DISABLED; + } + } + + leaf ovs-offload { + description + "Specifies Open vSwitch hardware offload mode. + MANDATORY: OVS offload is required + PREFERRED: OVS offload is preferred"; + type enumeration { + enum MANDATORY; + enum PREFERRED; + enum DISABLED; + } + } + } + } + + grouping hypervisor-epa { + container hypervisor-epa { + leaf type { + description + "Specifies the type of hypervisor. + KVM: KVM + XEN: XEN"; + type enumeration { + enum PREFER_KVM; + enum REQUIRE_KVM; + } + } + leaf version { + type string; + } + } + } + + grouping host-epa { + container host-epa { + description "Specifies the host level EPA attributes."; + leaf cpu-model { + description + "Host CPU model. Examples include: SandyBridge, + IvyBridge"; + type enumeration { + enum PREFER_WESTMERE; + enum REQUIRE_WESTMERE; + enum PREFER_SANDYBRIDGE; + enum REQUIRE_SANDYBRIDGE; + enum PREFER_IVYBRIDGE; + enum REQUIRE_IVYBRIDGE; + enum PREFER_HASWELL; + enum REQUIRE_HASWELL; + enum PREFER_BROADWELL; + enum REQUIRE_BROADWELL; + enum PREFER_NEHALEM; + enum REQUIRE_NEHALEM; + enum PREFER_PENRYN; + enum REQUIRE_PENRYN; + enum PREFER_CONROE; + enum REQUIRE_CONROE; + enum PREFER_CORE2DUO; + enum REQUIRE_CORE2DUO; + } + } + + leaf cpu-arch { + description "Host CPU architecture."; + type enumeration { + enum PREFER_X86; + enum REQUIRE_X86; + enum PREFER_X86_64; + enum REQUIRE_X86_64; + enum PREFER_I686; + enum REQUIRE_I686; + enum PREFER_IA64; + enum REQUIRE_IA64; + enum PREFER_ARMV7; + enum REQUIRE_ARMV7; + enum PREFER_ARMV8; + enum REQUIRE_ARMV8; + } + } + + leaf cpu-vendor { + description "Host CPU Vendor."; + type enumeration { + enum PREFER_INTEL; + enum REQUIRE_INTEL; + enum PREFER_AMD; + enum REQUIRE_AMD; + } + } + + leaf cpu-socket-count { + description "Number of sockets on the host."; + type uint64; + } + + leaf cpu-core-count { + description "Number of cores on the host."; + type uint64; + } + + leaf cpu-core-thread-count { + description "Number of threads per cores on the host."; + type uint64; + } + + leaf-list cpu-feature { + description + "List of CPU features."; + type cpu-feature-type; + } + + + leaf om-cpu-model-string { + description "Openmano CPU model string"; + type string; + } + + leaf-list om-cpu-feature { + description "Openmano CPU features"; + type string; + } + } + } + + grouping guest-epa { + description "EPA attributes for the guest"; + container guest-epa { + leaf trusted-execution { + description "This VM should be allocated from trusted pool"; + type boolean; + } + + leaf mempage-size { + description + "Memory page allocation size. If a VM requires + hugepages, it should choose LARGE or SIZE_2MB + or SIZE_1GB. If the VM prefers hugepages it + should chose PREFER_LARGE. + LARGE : Require hugepages (either 2MB or 1GB) + SMALL : Doesn't require hugepages + SIZE_2MB : Requires 2MB hugepages + SIZE_1GB : Requires 1GB hugepages + PREFER_LARGE : Application perfers hugepages"; + type enumeration { + enum LARGE; + enum SMALL; + enum SIZE_2MB; + enum SIZE_1GB; + enum PREFER_LARGE; + } + } + + leaf cpu-pinning-policy { + description + "CPU pinning policy describes association + between virtual CPUs in guest and the + physical CPUs in the host. + DEDICATED : Virtual CPUs are pinned to + physical CPUs + SHARED : Multiple VMs may share the + same physical CPUs. + ANY : Any policy is acceptable for the VM"; + type enumeration { + enum DEDICATED; + enum SHARED; + enum ANY; + } + default "ANY"; + } + + leaf cpu-thread-pinning-policy { + description + "CPU thread pinning policy describes how to + place the guest CPUs when the host supports + hyper threads: + AVOID : Avoids placing a guest on a host + with threads. + SEPARATE: Places vCPUs on separate cores, + and avoids placing two vCPUs on + two threads of same core. + ISOLATE : Places each vCPU on a different core, + and places no vCPUs from a different + guest on the same core. + PREFER : Attempts to place vCPUs on threads + of the same core."; + type enumeration { + enum AVOID; + enum SEPARATE; + enum ISOLATE; + enum PREFER; + } + } + + list pcie-device { + description + "List of pcie passthrough devices."; + key device-id; + leaf device-id { + description + "Device identifier."; + type string; + } + leaf count { + description + "Number of devices to attach to the VM."; + type uint64; + } + } + + choice numa-policy { + case numa-unware { + leaf numa-unware { + type empty; + } + } + + case numa-aware { + container numa-node-policy { + description + "This policy defines numa topology of the + guest. Specifically identifies if the guest + should be run on a host with one numa + node or multiple numa nodes. As an example + a guest may want 8 vcpus and 4 GB of + memory. But may want the vcpus and memory + distributed across multiple numa nodes. + The NUMA node 1 may run with 6 vcpus and + 3GB, and NUMA node 2 may run with 2 vcpus + and 1GB."; + + leaf node-cnt { + description + "The number of numa nodes to expose to the VM."; + type uint16; + } + + leaf mem-policy { + description + "This policy specifies how the memory should + be allocated in a multi-node scenario. + STRICT : The memory must be allocated + strictly from the memory attached + to the NUMA node. + PREFERRED : The memory should be allocated + perferentially from the memory + attached to the NUMA node"; + type enumeration { + enum STRICT; + enum PREFERRED; + } + } + + list node { + key id; + leaf id { + description + "NUMA node identification. Typically + it's 0 or 1"; + type uint64; + } + + leaf-list vcpu { + description + "List of vcpus to allocate on + this numa node."; + type uint64; + } + + leaf memory-mb { + description + "Memory size expressed in MB + for this NUMA node."; + type uint64; + } + + choice om-numa-type { + description + "Openmano Numa type selection"; + + case cores { + leaf num-cores { + type uint8; + } + } + + case paired-threads { + container paired-threads { + leaf num-paired-threads { + type uint8; + } + + list paired-thread-ids { + description + "List of thread pairs to use in case of paired-thread numa"; + max-elements 16; + key thread-a; + + leaf thread-a { + type uint8; + } + + leaf thread-b { + type uint8; + } + } + } + } + case threads { + leaf num-threads { + type uint8; + } + } + } + } + + } + } + } + } + } + + grouping provider-network { + container provider-network { + description "Container for the provider network."; + leaf physical-network { + description + "Name of the phsyical network on which the provider + network is built."; + type string; + } + + leaf overlay-type { + description + "Type of the overlay network."; + type enumeration { + enum LOCAL; + enum FLAT; + enum VLAN; + enum VXLAN; + enum GRE; + } + } + leaf segmentation_id { + description + "Segmentation ID"; + type uint32; + } + } + } + + grouping ns-service-primitive { + 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; + } + + list parameter-group { + description + "Grouping of parameters which are logically grouped in UI"; + key "name"; + + leaf name { + description + "Name of the parameter group"; + type string; + } + + list parameter { + description + "List of parameters for the service primitive."; + key "name"; + uses manotypes:primitive-parameter; + } + + leaf mandatory { + description "Is this parameter group mandatory"; + type boolean; + default true; + } + } + + 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: An issue with confd is preventing the + use of xpath. Seems to be an issue with leafref + to leafref, whose target is in a different module. + Once that is resovled this will switched to use + leafref"; + + 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; + } + } + } + + grouping monitoring-param { + list http-endpoint { + description + "List of http endpoints to be used by monitoring params"; + key path; + + leaf path { + description "The HTTP path on the management server"; + type string; + } + + leaf https { + description "Pick HTTPS instead of HTTP , Default is false"; + type boolean; + default "false"; + } + + leaf port { + description "The HTTP port to connect to"; + type inet:port-number; + } + + leaf username { + description "The HTTP basic auth username"; + type string; + } + + leaf password { + description "The HTTP basic auth password"; + type string; + } + + leaf polling_interval_secs { + description "The HTTP polling interval in seconds"; + type uint8; + default 2; + } + + leaf method { + description + "This is the method to be performed at the uri. + GET by default for action"; + + type manotypes:http-method; + default "GET"; + } + + list headers { + description "Custom HTTP headers to put on HTTP request"; + key key; + leaf key{ + description "HTTP header key"; + type string; + } + + leaf value{ + description "HTTP header value"; + type string; + } + } + } + + list monitoring-param { + description + "List of monitoring parameters at the NS level"; + key id; + leaf id { + type string; + } + + leaf name { + type string; + } + + leaf http-endpoint-ref { + type leafref { + path "../../http-endpoint/path"; + } + } + + leaf json-query-method { + type json-query-method; + default "NAMEKEY"; + } + + container json-query-params { + leaf json-path { + description + "The jsonpath to use to extract value from JSON structure"; + type string; + } + leaf object-path { + description + "The objectpath to use to extract value from JSON structure"; + type string; + } + } + + uses monitoring-param-ui-data; + uses monitoring-param-value; + + } + } + + grouping monitoring-param-aggregation { + typedef aggregation-type { + description "aggregation-type"; + type enumeration { + enum AVERAGE; + enum MINIMUM; + enum MAXIMUM; + enum COUNT; + enum SUM; + } + } + + leaf aggregation-type { + type aggregation-type; + } + } + + grouping monitoring-param-ui-data { + leaf description { + type string; + } + + leaf group-tag { + description "A simple tag to group monitoring parameters"; + type string; + } + + + leaf widget-type { + type manotypes:widget-type; + } + + leaf units { + type string; + } + } + + grouping monitoring-param-value { + leaf value-type { + type param-value-type; + default "INT"; + } + + container numeric-constraints { + leaf min-value { + description + "Minimum value for the parameter"; + type uint64; + } + leaf max-value { + description + "Maxium value for the parameter"; + type uint64; + } + } + + container text-constraints { + leaf min-length { + description + "Minimum string length for the parameter"; + type uint8; + } + leaf max-length { + description + "Maximum string length for the parameter"; + type uint8; + } + } + + leaf value-integer { + description + "Current value for an integer parameter"; + type int64; + } + + leaf value-decimal { + description + "Current value for a decimal parameter"; + type decimal64 { + fraction-digits 4; + } + } + + leaf value-string { + description + "Current value for a string parameter"; + type string; + } + } + + grouping control-param { + list control-param { + description + "List of control parameters to manage and + update the running configuration of the VNF"; + key id; + + leaf id { + type string; + } + + leaf name { + type string; + } + + leaf description { + type string; + } + + leaf group-tag { + description "A simple tag to group control parameters"; + type string; + } + + leaf min-value { + description + "Minimum value for the parameter"; + type uint64; + } + + leaf max-value { + description + "Maxium value for the parameter"; + type uint64; + } + + leaf current-value { + description + "Current value for the parameter"; + type uint64; + } + + leaf step-value { + description + "Step value for the parameter"; + type uint64; + } + + leaf units { + type string; + } + + leaf widget-type { + type manotypes:widget-type; + } + + leaf url { + description + "This is the URL where to perform the operation"; + + type inet:uri; + } + + leaf method { + description + "This is the method to be performed at the uri. + POST by default for action"; + + type manotypes:http-method; + default "POST"; + } + + leaf payload { + description + "This is the operation payload or payload template as stringified + JSON. This field provides the data to be sent for this operation + call"; + + type string; + } + } + } + + grouping action-param { + list action-param { + description + "List of action parameters to + control VNF"; + key id; + leaf id { + type string; + } + + leaf name { + type string; + } + + leaf description { + type string; + } + + leaf group-tag { + description "A simple tag to group monitoring parameter"; + type string; + } + + leaf url { + description + "This is the URL where to perform the operation"; + type inet:uri; + } + + leaf method { + description + "This is the method to be performed at the uri. + POST by default for action"; + + type manotypes:http-method; + default "POST"; + } + + leaf payload { + description + "This is the operation payload or payload template to be sent in + the data for this operation call"; + + type string; + } + } + } + + grouping input-parameter { + description ""; + + list input-parameter { + description + "List of input parameters"; + + key xpath; + + + leaf xpath { + description + "A an xpath that specfies which element in a descriptor is to be + modified."; + type string; + } + + leaf value { + description + "The value that the element specified by the xpath should take when a + record is created."; + type string; + } + } + } + + grouping input-parameter-xpath { + list input-parameter-xpath { + description + "List of xpaths to parameters inside the NSD + the can be customized during the instantiation."; + + key "xpath"; + leaf xpath { + description + "An xpath that specifies the element in a descriptor."; + type string; + } + + leaf label { + description "A descriptive string"; + type string; + } + + leaf default-value { + description " A default value for this input parameter"; + type string; + } + } + } + + grouping nfvi-metrics { + container vcpu { + leaf label { + description + "Label to show in UI"; + type string; + default "VCPU"; + } + + leaf total { + description + "The total number of VCPUs available."; + type uint64; + } + + leaf utilization { + description + "The VCPU utilization (percentage)."; + type decimal64 { + fraction-digits 2; + range "0 .. 100"; + } + } + } + + container memory { + leaf label { + description + "Label to show in UI"; + type string; + default "MEMORY"; + } + + leaf used { + description + "The amount of memory (bytes) currently in use."; + type uint64; + } + + leaf total { + description + "The amount of memory (bytes) available."; + type uint64; + } + + leaf utilization { + description + "The memory utilization (percentage)."; + type decimal64 { + fraction-digits 2; + range "0 .. 100"; + } + } + } + + container storage { + leaf label { + description + "Label to show in UI"; + type string; + default "STORAGE"; + } + + leaf used { + description + "The amount of storage (bytes) currently in use."; + type uint64; + } + + leaf total { + description + "The amount of storage (bytes) available."; + type uint64; + } + + leaf utilization { + description + "The storage utilization (percentage)."; + type decimal64 { + fraction-digits 2; + range "0 .. 100"; + } + } + } + + container external-ports { + leaf label { + description + "Label to show in UI"; + type string; + default "EXTERNAL PORTS"; + } + + leaf total { + description + "The total number of external ports."; + type uint64; + } + } + + container internal-ports { + leaf label { + description + "Label to show in UI"; + type string; + default "INTERNAL PORTS"; + } + + leaf total { + description + "The total number of internal ports."; + type uint64; + } + } + + container network { + leaf label { + description + "Label to show in UI"; + type string; + default "NETWORK TRAFFIC"; + } + + container incoming { + leaf label { + description + "Label to show in UI"; + type string; + default "INCOMING NETWORK TRAFFIC"; + } + + leaf bytes { + description + "The cumulative number of incoming bytes."; + type uint64; + } + + leaf packets { + description + "The cumulative number of incoming packets."; + type uint64; + } + + leaf byte-rate { + description + "The current incoming byte-rate (bytes per second)."; + type decimal64 { + fraction-digits 2; + } + } + + leaf packet-rate { + description + "The current incoming packet (packets per second)."; + type decimal64 { + fraction-digits 2; + } + } + } + + container outgoing { + leaf label { + description + "Label to show in UI"; + type string; + default "OUTGOING NETWORK TRAFFIC"; + } + + leaf bytes { + description + "The cumulative number of outgoing bytes."; + type uint64; + } + + leaf packets { + description + "The cumulative number of outgoing packets."; + type uint64; + } + + leaf byte-rate { + description + "The current outgoing byte-rate (bytes per second)."; + type decimal64 { + fraction-digits 2; + } + } + + leaf packet-rate { + description + "The current outgoing packet (packets per second)."; + type decimal64 { + fraction-digits 2; + } + } + } + } + } + + typedef alarm-severity-type { + description "An indication of the importance or ugency of the alarm"; + type enumeration { + enum LOW; + enum MODERATE; + enum CRITICAL; + } + } + + typedef alarm-metric-type { + description "The type of metrics to register the alarm for"; + type enumeration { + enum CPU_UTILIZATION; + enum MEMORY_UTILIZATION; + enum STORAGE_UTILIZATION; + } + } + + typedef alarm-statistic-type { + description + "The type of statistic to used to measure a metric to determine + threshold crossing for an alarm."; + type enumeration { + enum AVERAGE; + enum MINIMUM; + enum MAXIMUM; + enum COUNT; + enum SUM; + } + } + + typedef alarm-operation-type { + description + "The relational operator used to define whether an alarm should be + triggered when, say, the metric statistic goes above or below a + specified value."; + type enumeration { + enum GE; // greater than or equal + enum LE; // less than or equal + enum GT; // greater than + enum LT; // less than + enum EQ; // equal + } + } + + grouping alarm { + leaf alarm-id { + description + "This field is reserved for the identifier assigned by the cloud + provider"; + + type string; + } + + leaf name { + description "A human readable string to identify the alarm"; + type string; + } + + leaf description { + description "A string containing a description of this alarm"; + type string; + } + + leaf vdur-id { + description + "The identifier of the VDUR that the alarm is associated with"; + type string; + } + + container actions { + list ok { + key "url"; + leaf url { + type string; + } + } + + list insufficient-data { + key "url"; + leaf url { + type string; + } + } + + list alarm { + key "url"; + leaf url { + type string; + } + } + } + + leaf repeat { + description + "This flag indicates whether the alarm should be repeatedly emitted + while the associated threshold has been crossed."; + + type boolean; + default true; + } + + leaf enabled { + description + "This flag indicates whether the alarm has been enabled or + disabled."; + + type boolean; + default true; + } + + leaf severity { + description "A measure of the important or urgency of the alarm"; + type alarm-severity-type; + } + + leaf metric { + description "The metric to be tracked by this alarm."; + type alarm-metric-type; + } + + leaf statistic { + description "The type of metric statistic that is tracked by this alarm"; + type alarm-statistic-type; + } + + leaf operation { + description + "The relational operator that defines whether the alarm should be + triggered when the metric statistic is, say, above or below the + specified threshold value."; + type alarm-operation-type; + } + + leaf value { + description + "This value defines the threshold that, if crossed, will trigger + the alarm."; + type decimal64 { + fraction-digits 4; + } + } + + leaf period { + description + "The period defines the length of time (seconds) that the metric + data are collected over in oreder to evaluate the chosen + statistic."; + type uint32; + } + + leaf evaluations { + description + "This is the number of samples of the metric statistic used to + evaluate threshold crossing. Each sample or evaluation is equal to + the metric statistic obtained for a given period. This can be used + to mitigate spikes in the metric that may skew the statistic of + interest."; + type uint32; + } + } + + typedef cloud-account-type { + description "cloud account type"; + type enumeration { + enum aws; + enum cloudsim; + enum cloudsim_proxy; + enum mock; + enum openmano; + enum openstack; + enum vsphere; + enum openvim; + } + } + + grouping host-aggregate { + list host-aggregate { + description "Name of the Host Aggregate"; + key "metadata-key"; + + leaf metadata-key { + type string; + } + leaf metadata-value { + type string; + } + } + } + + grouping placement-group-input { + leaf cloud-type { + type manotypes:cloud-account-type; + } + choice cloud-provider { + case openstack { + container availability-zone { + description "Name of the Availability Zone"; + leaf name { + type string; + } + } + container server-group { + description "Name of the Affinity/Anti-Affinity Server Group"; + leaf name { + type string; + } + } + uses host-aggregate; + } + case aws { + leaf aws-construct { + type empty; + } + } + case openmano { + leaf openmano-construct { + type empty; + } + } + case vsphere { + leaf vsphere-construct { + type empty; + } + } + case mock { + leaf mock-construct { + type empty; + } + } + case cloudsim { + leaf cloudsim-construct { + type empty; + } + } + } + } + + grouping placement-group-info { + description ""; + + leaf name { + description + "Place group construct to define the compute resource placement strategy + in cloud environment"; + type string; + } + + leaf requirement { + description "This is free text space used to describe the intent/rationale + behind this placement group. This is for human consumption only"; + type string; + } + + leaf strategy { + description + "Strategy associated with this placement group + Following values are possible + - COLOCATION: Colocation strategy imply intent to share the physical + infrastructure (hypervisor/network) among all members + of this group. + - ISOLATION: Isolation strategy imply intent to not share the physical + infrastructure (hypervisor/network) among the members + of this group. + "; + type enumeration { + enum COLOCATION; + enum ISOLATION; + } + default "COLOCATION"; + } + } + + grouping ip-profile-info { + description "Grouping for IP-Profile"; + container ip-profile-params { + + leaf ip-version { + type inet:ip-version; + default ipv4; + } + + leaf subnet-address { + description "Subnet IP prefix associated with IP Profile"; + type inet:ip-prefix; + } + + leaf gateway-address { + description "IP Address of the default gateway associated with IP Profile"; + type inet:ip-address; + } + + leaf security-group { + description "Name of the security group"; + type string; + } + + leaf-list dns-server { + description "List of DNS Servers associated with IP Profile"; + type inet:ip-address; + } + + container dhcp-params { + leaf enabled { + description "This flag indicates if DHCP is enabled or not"; + type boolean; + default true; + } + + leaf start-address { + description "Start IP address of the IP-Address range associated with DHCP domain"; + type inet:ip-address; + } + + leaf count { + description "Size of the DHCP pool associated with DHCP domain"; + type uint32; + } + } + + leaf subnet-prefix-pool { + description "VIM Specific reference to pre-created subnet prefix"; + type string; + } + } + } + + grouping ip-profile-list { + list ip-profiles { + description + "List of IP Profiles. + IP Profile describes the IP characteristics for the Virtual-Link"; + + key "name"; + + leaf name { + description "Name of the IP-Profile"; + type string; + } + + leaf description { + description "Description for IP profile"; + type string; + } + + uses ip-profile-info; + } + } + +}