Merge "Change "KubernetesObject" class name to "ReplicationController""
[yardstick.git] / yardstick / network_services / vnf_generic / vnf / base.py
1 # Copyright (c) 2016-2017 Intel Corporation
2 #
3 # Licensed under the Apache License, Version 2.0 (the "License");
4 # you may not use this file except in compliance with the License.
5 # You may obtain a copy of the License at
6 #
7 #      http://www.apache.org/licenses/LICENSE-2.0
8 #
9 # Unless required by applicable law or agreed to in writing, software
10 # distributed under the License is distributed on an "AS IS" BASIS,
11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 # See the License for the specific language governing permissions and
13 # limitations under the License.
14 """ Base class implementation for generic vnf implementation """
15
16 import abc
17
18 import logging
19 import six
20
21 from yardstick.network_services.helpers.samplevnf_helper import PortPairs
22
23
24 LOG = logging.getLogger(__name__)
25
26
27 class QueueFileWrapper(object):
28     """ Class providing file-like API for talking with SSH connection """
29
30     def __init__(self, q_in, q_out, prompt):
31         self.q_in = q_in
32         self.q_out = q_out
33         self.closed = False
34         self.buf = []
35         self.bufsize = 20
36         self.prompt = prompt
37
38     def read(self, size):
39         """ read chunk from input queue """
40         if self.q_in.qsize() > 0 and size:
41             in_data = self.q_in.get()
42             return in_data
43
44     def write(self, chunk):
45         """ write chunk to output queue """
46         self.buf.append(chunk)
47         # flush on prompt or if we exceed bufsize
48
49         size = sum(len(c) for c in self.buf)
50         if self.prompt in chunk or size > self.bufsize:
51             out = ''.join(self.buf)
52             self.buf = []
53             self.q_out.put(out)
54
55     def close(self):
56         """ close multiprocessing queue """
57         pass
58
59     def clear(self):
60         """ clear queue """
61         while self.q_out.qsize() > 0:
62             self.q_out.get()
63
64
65 class VnfdHelper(dict):
66
67     def __init__(self, *args, **kwargs):
68         super(VnfdHelper, self).__init__(*args, **kwargs)
69         self.port_pairs = PortPairs(self['vdu'][0]['external-interface'])
70         # port num is not present until binding so we have to memoize
71         self._port_num_map = {}
72
73     @property
74     def mgmt_interface(self):
75         return self["mgmt-interface"]
76
77     @property
78     def vdu(self):
79         return self['vdu']
80
81     @property
82     def vdu0(self):
83         return self.vdu[0]
84
85     @property
86     def interfaces(self):
87         return self.vdu0['external-interface']
88
89     @property
90     def kpi(self):
91         return self['benchmark']['kpi']
92
93     def find_virtual_interface(self, **kwargs):
94         key, value = next(iter(kwargs.items()))
95         for interface in self.interfaces:
96             virtual_intf = interface["virtual-interface"]
97             if virtual_intf[key] == value:
98                 return interface
99         raise KeyError()
100
101     def find_interface(self, **kwargs):
102         key, value = next(iter(kwargs.items()))
103         for interface in self.interfaces:
104             if interface[key] == value:
105                 return interface
106         raise KeyError()
107
108     # hide dpdk_port_num key so we can abstract
109     def find_interface_by_port(self, port):
110         for interface in self.interfaces:
111             virtual_intf = interface["virtual-interface"]
112             # we have to convert to int to compare
113             if int(virtual_intf['dpdk_port_num']) == port:
114                 return interface
115         raise KeyError()
116
117     def port_num(self, port):
118         # we need interface name -> DPDK port num (PMD ID) -> LINK ID
119         # LINK ID -> PMD ID is governed by the port mask
120         """
121
122         :rtype: int
123         :type port: str
124         """
125         if isinstance(port, dict):
126             intf = port
127         else:
128             intf = self.find_interface(name=port)
129         return self._port_num_map.setdefault(intf["name"],
130                                              int(intf["virtual-interface"]["dpdk_port_num"]))
131
132     def port_nums(self, intfs):
133         return [self.port_num(i) for i in intfs]
134
135     def ports_iter(self):
136         for port_name in self.port_pairs.all_ports:
137             port_num = self.port_num(port_name)
138             yield port_name, port_num
139
140
141 @six.add_metaclass(abc.ABCMeta)
142 class GenericVNF(object):
143     """Class providing file-like API for generic VNF implementation
144
145     Currently the only class implementing this interface is
146     yardstick/network_services/vnf_generic/vnf/sample_vnf:SampleVNF.
147     """
148
149     # centralize network naming convention
150     UPLINK = PortPairs.UPLINK
151     DOWNLINK = PortPairs.DOWNLINK
152
153     def __init__(self, name, vnfd):
154         self.name = name
155         self.vnfd_helper = VnfdHelper(vnfd)
156         # List of statistics we can obtain from this VNF
157         # - ETSI MANO 6.3.1.1 monitoring_parameter
158         self.kpi = self.vnfd_helper.kpi
159         # Standard dictionary containing params like thread no, buffer size etc
160         self.config = {}
161         self.runs_traffic = False
162
163     @abc.abstractmethod
164     def instantiate(self, scenario_cfg, context_cfg):
165         """Prepare VNF for operation and start the VNF process/VM
166
167         :param scenario_cfg: Scenario config
168         :param context_cfg: Context config
169         :return: True/False
170         """
171
172     @abc.abstractmethod
173     def wait_for_instantiate(self):
174         """Wait for VNF to start
175
176         :return: True/False
177         """
178
179     @abc.abstractmethod
180     def terminate(self):
181         """Kill all VNF processes"""
182
183     @abc.abstractmethod
184     def scale(self, flavor=""):
185         """rest
186
187         :param flavor: Name of the flavor.
188         :return:
189         """
190
191     @abc.abstractmethod
192     def collect_kpi(self):
193         """Return a dict containing the selected KPI at a given point of time
194
195         :return: {"kpi": value, "kpi2": value}
196         """
197
198     @abc.abstractmethod
199     def start_collect(self):
200         """Start KPI collection
201         :return: None
202         """
203
204     @abc.abstractmethod
205     def stop_collect(self):
206         """Stop KPI collection
207         :return: None
208         """
209
210
211 @six.add_metaclass(abc.ABCMeta)
212 class GenericTrafficGen(GenericVNF):
213     """ Class providing file-like API for generic traffic generator """
214
215     def __init__(self, name, vnfd):
216         super(GenericTrafficGen, self).__init__(name, vnfd)
217         self.runs_traffic = True
218         self.traffic_finished = False
219
220     @abc.abstractmethod
221     def run_traffic(self, traffic_profile):
222         """Generate traffic on the wire according to the given params.
223
224         This method is non-blocking, returns immediately when traffic process
225         is running. Mandatory.
226
227         :param traffic_profile:
228         :return: True/False
229         """
230
231     @abc.abstractmethod
232     def terminate(self):
233         """After this method finishes, all traffic processes should stop.
234
235         Mandatory.
236
237         :return: True/False
238         """
239
240     def listen_traffic(self, traffic_profile):
241         """Listen to traffic with the given parameters.
242
243         Method is non-blocking, returns immediately when traffic process
244         is running. Optional.
245
246         :param traffic_profile:
247         :return: True/False
248         """
249         pass
250
251     def verify_traffic(self, traffic_profile):
252         """Verify captured traffic after it has ended.
253
254         Optional.
255
256         :param traffic_profile:
257         :return: dict
258         """
259         pass
260
261     def wait_for_instantiate(self):
262         """Wait for an instance to load.
263
264         Optional.
265
266         :return: True/False
267         """
268         pass
269
270     def start_collect(self):
271         """Start KPI collection.
272
273         Traffic measurements are always collected during injection.
274
275         Optional.
276
277         :return: True/False
278         """
279         pass
280
281     def stop_collect(self):
282         """Stop KPI collection.
283
284         Optional.
285
286         :return: True/False
287         """
288         pass