Fixes bug 1424 by adding ip-address on virtual-network-interface-requirement
[osm/IM.git] / models / augments / epa.yang
1 /*
2   Copyright 2020 Whitestack LLC
3
4   Licensed under the Apache License, Version 2.0 (the "License");
5   you may not use this file except in compliance with the License.
6   You may obtain a copy of the License at
7
8     http://www.apache.org/licenses/LICENSE-2.0
9
10   Unless required by applicable law or agreed to in writing, software
11   distributed under the License is distributed on an "AS IS" BASIS,
12   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
13   implied.
14   See the License for the specific language governing permissions and
15   limitations under the License.
16 */
17
18 module epa {
19     yang-version 1.1;
20     namespace "urn:etsi:osm:yang:augments:epa";
21     prefix "epa";
22
23     import etsi-nfv-vnfd {
24         prefix vnfd;
25     }
26
27     grouping allocation-properties {
28         leaf limit {
29             description
30               "Defines the maximum allocation. The value 0 indicates that usage is not limited.
31                This parameter ensures that the instance never uses more than the defined amount of resource.";
32             type uint64;
33         }
34
35         leaf reserve {
36             description
37               "Defines the guaranteed minimum reservation.
38                If needed, the machine will definitely get allocated the reserved amount of resources.";
39             type uint64;
40         }
41
42         leaf shares {
43             description
44               "Number of shares allocated.
45                Specifies the proportional weighted share for the domain.
46                If this element is omitted, the service defaults to the OS provided defaults";
47             type uint64;
48         }
49     }
50
51     grouping extended-mem-quota {
52         container mem-quota {
53             description
54               "Memory quota describes the memory resource allocation policy.
55                Limit and Reserve values are defined in MB";
56             uses allocation-properties;
57         }
58     }
59
60     grouping extended-vif-quota {
61         container vif-quota {
62             description
63               "Virtual interfaces quota describes the virtual interface bandwidth resource allocation policy.
64                Limit and Reserve values are defined in Mbps";
65             uses allocation-properties;
66         }
67     }
68
69     grouping extended-disk-io-quota {
70         container disk-io-quota {
71             description
72               "Disk IO quota describes the disk IO operations resource allocation policy.
73                Limit and Reserve values are defined in IOPS";
74             uses allocation-properties;
75         }
76     }
77
78     grouping extended-cpu-quota {
79         container cpu-quota {
80             description
81               "CPU quota describes the CPU resource allocation policy.
82                Limit and Reserve values are defined in MHz";
83             uses allocation-properties;
84         }
85     }
86
87     grouping extended-cpu-policy {
88         leaf thread-policy {
89             description
90               "CPU thread pinning policy describes how to
91                place the guest CPUs when the host supports
92                hyper threads:
93                AVOID   : Avoids placing a guest on a host
94                          with threads.
95                SEPARATE: Places vCPUs on separate cores,
96                          and avoids placing two vCPUs on
97                          two threads of same core.
98                ISOLATE : Places each vCPU on a different core,
99                          and places no vCPUs from a different
100                          guest on the same core.
101                PREFER  : Attempts to place vCPUs on threads
102                          of the same core.";
103             type enumeration {
104                 enum AVOID;
105                 enum SEPARATE;
106                 enum ISOLATE;
107                 enum PREFER;
108             }
109         }
110     }
111
112     grouping extended-mempage-size {
113         leaf mempage-size {
114             description
115               "Memory page allocation size. If a VM requires
116                hugepages, it should choose LARGE or SIZE_2MB
117                or SIZE_1GB. If the VM prefers hugepages it
118                should choose PREFER_LARGE.
119                LARGE        : Require hugepages (either 2MB or 1GB)
120                SMALL        : Doesn't require hugepages
121                SIZE_2MB     : Requires 2MB hugepages
122                SIZE_1GB     : Requires 1GB hugepages
123                PREFER_LARGE : Application prefers hugepages";
124             type enumeration {
125                 enum LARGE;
126                 enum SMALL;
127                 enum SIZE_2MB;
128                 enum SIZE_1GB;
129                 enum PREFER_LARGE;
130             }
131         }
132     }
133     grouping extended-numa {
134         container numa-node-policy {
135             description
136               "This policy defines NUMA topology of the
137                guest. Specifically identifies if the guest
138                should be run on a host with one NUMA
139                node or multiple NUMA nodes. As an example
140                a guest might need 8 VCPUs and 4 GB of
141                memory. However, it might need the VCPUs
142                and memory distributed across multiple
143                NUMA nodes. In this scenario, NUMA node
144                1 could run with 6 VCPUs and 3GB, and
145                NUMA node 2 could run with 2 VCPUs and
146                1GB.";
147
148             leaf node-cnt {
149                 description
150                   "The number of NUMA nodes to expose to the VM.";
151                 type uint16;
152             }
153
154             leaf mem-policy {
155                 description
156                   "This policy specifies how the memory should
157                    be allocated in a multi-node scenario.
158                    STRICT    : The memory must be allocated
159                                strictly from the memory attached
160                                to the NUMA node.
161                    PREFERRED : The memory should be allocated
162                                preferentially from the memory
163                                attached to the NUMA node";
164                 type enumeration {
165                     enum STRICT;
166                     enum PREFERRED;
167                 }
168             }
169
170             list node {
171                 key id;
172                 leaf id {
173                     description
174                       "NUMA node identification. Typically
175                        it's 0 or 1";
176                     type uint64;
177                 }
178
179                 list vcpu {
180                     key "id";
181                     description
182                       "List of VCPUs to allocate on
183                        this NUMA node.";
184                     leaf id {
185                         type uint64;
186                         description
187                           "List of VCPUs ids to allocate on
188                            this NUMA node";
189                     }
190                 }
191
192                 leaf memory-mb {
193                     description
194                       "Memory size expressed in MB
195                        for this NUMA node.";
196                     type uint64;
197                 }
198
199                 choice om-numa-type {
200                     description
201                       "OpenMANO Numa type selection";
202
203                     case cores {
204                         leaf num-cores {
205                             type uint8;
206                         }
207                     }
208
209                     case paired-threads {
210                         container paired-threads {
211                             leaf num-paired-threads {
212                                 type uint8;
213                             }
214
215                             list paired-thread-ids {
216                                 description
217                                   "List of thread pairs to use in case of paired-thread NUMA";
218                                 max-elements 16;
219                                 key thread-a;
220
221                                 leaf thread-a {
222                                     type uint8;
223                                 }
224
225                                 leaf thread-b {
226                                     type uint8;
227                                 }
228                             }
229                         }
230                     }
231                     case threads {
232                         leaf num-threads {
233                             type uint8;
234                         }
235                     }
236                 }
237             }
238         }
239     }
240
241     augment "/vnfd:vnfd/vnfd:virtual-compute-desc/vnfd:virtual-memory" {
242         uses extended-numa;
243         uses extended-mempage-size;
244         uses extended-mem-quota;
245     }
246
247     augment "/vnfd:vnfd/vnfd:virtual-compute-desc/vnfd:virtual-cpu/vnfd:pinning" {
248         uses extended-cpu-policy;
249     }
250
251     augment "/vnfd:vnfd/vnfd:virtual-compute-desc/vnfd:virtual-cpu" {
252         uses extended-cpu-quota;
253     }
254
255     augment "/vnfd:vnfd/vnfd:virtual-storage-desc" {
256         uses extended-disk-io-quota;
257     }
258
259     augment "/vnfd:vnfd/vnfd:vdu/vnfd:int-cpd/vnfd:virtual-network-interface-requirement" {
260         uses extended-vif-quota;
261     }
262 }