Add EPA augment

Change-Id: I507c26dc490f57e5552755fb0d47fb9b23d04612
Signed-off-by: Tomás Villaseca <tvillaseca@whitestack.com>

diff --git a/augments/epa.yang b/augments/epa.yang
new file mode 100644 (file)
index 0000000..d47d6a9
--- /dev/null
+++ b/augments/epa.yang
@@ -0,0 +1,262 @@
+/*
+  Copyright 2020 Whitestack LLC
+
+  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 epa {
+    yang-version 1.1;
+    namespace "urn:etsi:osm:yang:augments:epa";
+    prefix "epa";
+
+    import etsi-nfv-vnfd {
+        prefix vnfd;
+    }
+
+    grouping allocation-properties {
+        leaf limit {
+            description
+              "Defines the maximum allocation. The value 0 indicates that usage is not limited.
+               This parameter ensures that the instance never uses more than the defined amount of resource.";
+            type uint64;
+        }
+
+        leaf reserve {
+            description
+              "Defines the guaranteed minimum reservation.
+               If needed, the machine will definitely get allocated the reserved amount of resources.";
+            type uint64;
+        }
+
+        leaf shares {
+            description
+              "Number of shares allocated.
+               Specifies the proportional weighted share for the domain.
+               If this element is omitted, the service defaults to the OS provided defaults";
+            type uint64;
+        }
+    }
+
+    grouping extended-mem-quota {
+        container mem-quota {
+            description
+              "Memory quota describes the memory resource allocation policy.
+               Limit and Reserve values are defined in MB";
+            uses allocation-properties;
+        }
+    }
+
+    grouping extended-vif-quota {
+        container vif-quota {
+            description
+              "Virtual interfaces quota describes the virtual interface bandwidth resource allocation policy.
+               Limit and Reserve values are defined in Mbps";
+            uses allocation-properties;
+        }
+    }
+
+    grouping extended-disk-io-quota {
+        container disk-io-quota {
+            description
+              "Disk IO quota describes the disk IO operations resource allocation policy.
+               Limit and Reserve values are defined in IOPS";
+            uses allocation-properties;
+        }
+    }
+
+    grouping extended-cpu-quota {
+        container cpu-quota {
+            description
+              "CPU quota describes the CPU resource allocation policy.
+               Limit and Reserve values are defined in MHz";
+            uses allocation-properties;
+        }
+    }
+
+    grouping extended-cpu-policy {
+        leaf thread-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;
+            }
+        }
+    }
+
+    grouping extended-mempage-size {
+        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 choose 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 prefers hugepages";
+            type enumeration {
+                enum LARGE;
+                enum SMALL;
+                enum SIZE_2MB;
+                enum SIZE_1GB;
+                enum PREFER_LARGE;
+            }
+        }
+    }
+    grouping extended-numa {
+        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 might need 8 VCPUs and 4 GB of
+               memory. However, it might need the VCPUs
+               and memory distributed across multiple
+               NUMA nodes. In this scenario, NUMA node
+               1 could run with 6 VCPUs and 3GB, and
+               NUMA node 2 could 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
+                               preferentially 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;
+                }
+
+                list vcpu {
+                    key "id";
+                    description
+                      "List of VCPUs to allocate on
+                       this NUMA node.";
+                    leaf id {
+                        type uint64;
+                        description
+                          "List of VCPUs ids to allocate on
+                           this NUMA node";
+                    }
+                }
+
+                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;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    augment "/vnfd:vnfd/vnfd:virtual-compute-desc/vnfd:virtual-memory" {
+        uses extended-numa;
+        uses extended-mempage-size;
+        uses extended-mem-quota;
+    }
+
+    augment "/vnfd:vnfd/vnfd:virtual-compute-desc/vnfd:virtual-cpu/vnfd:pinning" {
+        uses extended-cpu-policy;
+    }
+
+    augment "/vnfd:vnfd/vnfd:virtual-compute-desc/vnfd:virtual-cpu" {
+        uses extended-cpu-quota;
+    }
+
+    augment "/vnfd:vnfd/vnfd:virtual-storage-desc" {
+        uses extended-disk-io-quota;
+    }
+
+    augment "/vnfd:vnfd/vnfd:vdu/vnfd:int-cpd/vnfd:virtual-network-interface-requirement" {
+        uses extended-vif-quota;
+    }
+}
\ No newline at end of file