VPP startup config change (rss->txqueues)
[csit.git] / resources / libraries / python / VppConfigGenerator.py
1 # Copyright (c) 2016 Cisco and/or its affiliates.
2 # Licensed under the Apache License, Version 2.0 (the "License");
3 # you may not use this file except in compliance with the License.
4 # You may obtain a copy of the License at:
5 #
6 #     http://www.apache.org/licenses/LICENSE-2.0
7 #
8 # Unless required by applicable law or agreed to in writing, software
9 # distributed under the License is distributed on an "AS IS" BASIS,
10 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 # See the License for the specific language governing permissions and
12 # limitations under the License.
13
14 """VPP Configuration File Generator library"""
15
16 import re
17 import time
18
19 from robot.api import logger
20
21 from resources.libraries.python.ssh import SSH
22 from resources.libraries.python.topology import NodeType
23 from resources.libraries.python.topology import Topology
24
25 __all__ = ['VppConfigGenerator']
26
27 #
28 # VPP configuration template.
29 # TODO: Do we need a better place for this? Somewhere in an external
30 # (template) file?
31 # Note: We're going to pass this through Python string Formatter, so
32 # any literal curly braces need to be escaped.
33 #
34 VPP_SERVICE_NAME = "vpp"
35 VPP_CONFIG_FILENAME = "/etc/vpp/startup.conf"
36 DEFAULT_SOCKETMEM_CONFIG = "1024,1024"
37 VPP_CONFIG_TEMPLATE = """
38 unix {{
39   nodaemon
40   log /tmp/vpe.log
41   cli-listen localhost:5002
42   full-coredump
43 }}
44
45 api-trace {{
46   on
47 }}
48 {heapsizeconfig}
49 cpu {{
50 {cpuconfig}
51 }}
52
53 dpdk {{
54   socket-mem {socketmemconfig}
55   dev default {{
56   {rxqueuesconfig}
57   {txqueuesconfig}
58   }}
59 {pciconfig}
60 {nomultiseg}
61 }}
62 """
63 # End VPP configuration template.
64
65
66 class VppConfigGenerator(object):
67     """VPP Configuration File Generator"""
68
69     def __init__(self):
70         self._nodeconfig = {}
71
72     def add_pci_device(self, node, pci_device=None):
73         """Add PCI device configuration for node.
74
75         :param node: DUT node.
76         :param pci_device: PCI device (format 0000:00:00.0 or 00:00.0).
77         If none given, all PCI devices for this node as per topology will be
78         added.
79         :type node: dict
80         :type pci_device: str
81         :return: nothing
82         """
83         if node['type'] != NodeType.DUT:
84             raise ValueError('Node type is not a DUT')
85
86         if pci_device is None:
87             # No PCI device was given. Add all device from topology.
88             for port in node['interfaces'].values():
89                 port_name = port.get('name')
90                 pci_addr = Topology.get_interface_pci_addr(node, port_name)
91                 if pci_addr:
92                     self.add_pci_device(node, pci_addr)
93         else:
94             # Specific device was given.
95             hostname = Topology.get_node_hostname(node)
96
97             pattern = re.compile("^[0-9A-Fa-f]{4}:[0-9A-Fa-f]{2}:"
98                                  "[0-9A-Fa-f]{2}\\.[0-9A-Fa-f]$")
99             if not pattern.match(pci_device):
100                 raise ValueError('PCI address {} to be added to host {} '
101                                  'is not in valid format xxxx:xx:xx.x'.
102                                  format(pci_device, hostname))
103
104             if hostname not in self._nodeconfig:
105                 self._nodeconfig[hostname] = {}
106             if 'pci_addrs' not in self._nodeconfig[hostname]:
107                 self._nodeconfig[hostname]['pci_addrs'] = []
108             self._nodeconfig[hostname]['pci_addrs'].append(pci_device)
109             logger.debug('Adding PCI device {1} to {0}'.format(hostname,
110                                                                pci_device))
111
112     def add_cpu_config(self, node, cpu_config):
113         """Add CPU configuration for node.
114
115         :param node: DUT node.
116         :param cpu_config: CPU configuration option, as a string.
117         :type node: dict
118         :type cpu_config: str
119         :return: nothing
120         """
121         if node['type'] != NodeType.DUT:
122             raise ValueError('Node type is not a DUT')
123         hostname = Topology.get_node_hostname(node)
124         if hostname not in self._nodeconfig:
125             self._nodeconfig[hostname] = {}
126         if 'cpu_config' not in self._nodeconfig[hostname]:
127             self._nodeconfig[hostname]['cpu_config'] = []
128         self._nodeconfig[hostname]['cpu_config'].append(cpu_config)
129         logger.debug('Adding {} to hostname {} CPU config'.format(hostname,
130                                                                   cpu_config))
131
132     def add_socketmem_config(self, node, socketmem_config):
133         """Add Socket Memory configuration for node.
134
135         :param node: DUT node.
136         :param socketmem_config: Socket Memory configuration option,
137         as a string.
138         :type node: dict
139         :type socketmem_config: str
140         :return: nothing
141         """
142         if node['type'] != NodeType.DUT:
143             raise ValueError('Node type is not a DUT')
144         hostname = Topology.get_node_hostname(node)
145         if hostname not in self._nodeconfig:
146             self._nodeconfig[hostname] = {}
147         self._nodeconfig[hostname]['socketmem_config'] = socketmem_config
148         logger.debug('Setting hostname {} Socket Memory config to {}'.
149                      format(hostname, socketmem_config))
150
151     def add_heapsize_config(self, node, heapsize_config):
152         """Add Heap Size configuration for node.
153
154         :param node: DUT node.
155         :param heapsize_config: Heap Size configuration, as a string.
156         :type node: dict
157         :type heapsize_config: str
158         :return: nothing
159         """
160         if node['type'] != NodeType.DUT:
161             raise ValueError('Node type is not a DUT')
162         hostname = Topology.get_node_hostname(node)
163         if hostname not in self._nodeconfig:
164             self._nodeconfig[hostname] = {}
165         self._nodeconfig[hostname]['heapsize_config'] = heapsize_config
166         logger.debug('Setting hostname {} Heap Size config to {}'.
167                      format(hostname, heapsize_config))
168
169     def add_rxqueues_config(self, node, rxqueues_config):
170         """Add Rx Queues configuration for node.
171
172         :param node: DUT node.
173         :param rxqueues_config: Rxqueues configuration, as a string.
174         :type node: dict
175         :type rxqueues_config: str
176         :return: nothing
177         """
178         if node['type'] != NodeType.DUT:
179             raise ValueError('Node type is not a DUT')
180         hostname = Topology.get_node_hostname(node)
181         if not hostname in self._nodeconfig:
182             self._nodeconfig[hostname] = {}
183         if not 'rxqueues_config' in self._nodeconfig[hostname]:
184             self._nodeconfig[hostname]['rxqueues_config'] = []
185         self._nodeconfig[hostname]['rxqueues_config'].append(rxqueues_config)
186         logger.debug('Setting hostname {} rxqueues config to {}'.\
187             format(hostname, rxqueues_config))
188
189     def add_no_multi_seg_config(self, node):
190         """Add No Multi Seg configuration for node.
191
192         :param node: DUT node.
193         :type node: dict
194         :return: nothing
195         """
196         if node['type'] != NodeType.DUT:
197             raise ValueError('Node type is not a DUT')
198         hostname = Topology.get_node_hostname(node)
199         if not hostname in self._nodeconfig:
200             self._nodeconfig[hostname] = {}
201         if not 'no_multi_seg_config' in self._nodeconfig[hostname]:
202             self._nodeconfig[hostname]['no_multi_seg_config'] = []
203         self._nodeconfig[hostname]['no_multi_seg_config'].append(
204             "no-multi-seg")
205         logger.debug('Setting hostname {} config with {}'.\
206             format(hostname, "no-multi-seg"))
207
208     def remove_all_pci_devices(self, node):
209         """Remove PCI device configuration from node.
210
211         :param node: DUT node.
212         :type node: dict
213         :return: nothing
214         """
215         if node['type'] != NodeType.DUT:
216             raise ValueError('Node type is not a DUT')
217         hostname = Topology.get_node_hostname(node)
218         if hostname in self._nodeconfig:
219             self._nodeconfig[hostname]['pci_addrs'] = []
220         logger.debug('Clearing all PCI devices for hostname {}.'.
221                      format(hostname))
222
223     def remove_all_cpu_config(self, node):
224         """Remove CPU configuration from node.
225
226         :param node: DUT node.
227         :type node: dict
228         :return: nothing
229         """
230         if node['type'] != NodeType.DUT:
231             raise ValueError('Node type is not a DUT')
232         hostname = Topology.get_node_hostname(node)
233         if hostname in self._nodeconfig:
234             self._nodeconfig[hostname]['cpu_config'] = []
235         logger.debug('Clearing all CPU config for hostname {}.'.
236                      format(hostname))
237
238     def remove_socketmem_config(self, node):
239         """Remove Socket Memory configuration from node.
240
241         :param node: DUT node.
242         :type node: dict
243         :return: nothing
244         """
245         if node['type'] != NodeType.DUT:
246             raise ValueError('Node type is not a DUT')
247         hostname = Topology.get_node_hostname(node)
248         if hostname in self._nodeconfig:
249             self._nodeconfig[hostname].pop('socketmem_config', None)
250         logger.debug('Clearing Socket Memory config for hostname {}.'.
251                      format(hostname))
252
253     def remove_heapsize_config(self, node):
254         """Remove Heap Size configuration from node.
255
256         :param node: DUT node.
257         :type node: dict
258         :return: nothing
259         """
260         if node['type'] != NodeType.DUT:
261             raise ValueError('Node type is not a DUT')
262         hostname = Topology.get_node_hostname(node)
263         if hostname in self._nodeconfig:
264             self._nodeconfig[hostname].pop('heapsize_config', None)
265         logger.debug('Clearing Heap Size config for hostname {}.'.
266                      format(hostname))
267
268     def remove_rxqueues_config(self, node):
269         """Remove Rxqueues configuration from node.
270
271         :param node: DUT node.
272         :type node: dict
273         :return: nothing
274         """
275         if node['type'] != NodeType.DUT:
276             raise ValueError('Node type is not a DUT')
277         hostname = Topology.get_node_hostname(node)
278         if hostname in self._nodeconfig:
279             self._nodeconfig[hostname]['rxqueues_config'] = []
280         logger.debug('Clearing rxqueues config for hostname {}.'.\
281             format(hostname))
282
283     def remove_no_multi_seg_config(self, node):
284         """Remove No Multi Seg configuration from node.
285
286         :param node: DUT node.
287         :type node: dict
288         :return: nothing
289         """
290         if node['type'] != NodeType.DUT:
291             raise ValueError('Node type is not a DUT')
292         hostname = Topology.get_node_hostname(node)
293         if hostname in self._nodeconfig:
294             self._nodeconfig[hostname]['no_multi_seg_config'] = []
295         logger.debug('Clearing No Multi Seg config for hostname {}.'.\
296             format(hostname))
297
298     def apply_config(self, node, waittime=5, retries=12):
299         """Generate and apply VPP configuration for node.
300
301         Use data from calls to this class to form a startup.conf file and
302         replace /etc/vpp/startup.conf with it on node.
303
304         :param node: DUT node.
305         :param waittime: Time to wait for VPP to restart (default 5 seconds).
306         :param retries: Number of times (default 12) to re-try waiting.
307         :type node: dict
308         :type waittime: int
309         :type retries: int
310         """
311
312         if node['type'] != NodeType.DUT:
313             raise ValueError('Node type is not a DUT')
314         hostname = Topology.get_node_hostname(node)
315
316         cpuconfig = ""
317         pciconfig = ""
318         socketmemconfig = DEFAULT_SOCKETMEM_CONFIG
319         heapsizeconfig = ""
320         rxqueuesconfig = ""
321         txqueuesconfig = ""
322         nomultiseg = ""
323
324         if hostname in self._nodeconfig:
325             cfg = self._nodeconfig[hostname]
326             if 'cpu_config' in cfg:
327                 cpuconfig = "  " + "\n  ".join(cfg['cpu_config'])
328
329             if 'pci_addrs' in cfg:
330                 pciconfig = "  dev " + "\n  dev ".join(cfg['pci_addrs'])
331
332             if 'socketmem_config' in cfg:
333                 socketmemconfig = cfg['socketmem_config']
334
335             if 'heapsize_config' in cfg:
336                 heapsizeconfig = "\nheapsize {}\n".\
337                     format(cfg['heapsize_config'])
338
339             if 'rxqueues_config' in cfg:
340                 rxqueuesconfig = "  " + "\n  ".join(cfg['rxqueues_config'])
341
342             if 'no_multi_seg_config' in cfg:
343                 nomultiseg = "  " + "\n  ".join(cfg['no_multi_seg_config'])
344
345         vppconfig = VPP_CONFIG_TEMPLATE.format(cpuconfig=cpuconfig,
346                                                pciconfig=pciconfig,
347                                                socketmemconfig=socketmemconfig,
348                                                heapsizeconfig=heapsizeconfig,
349                                                rxqueuesconfig=rxqueuesconfig,
350                                                txqueuesconfig=txqueuesconfig,
351                                                nomultiseg = nomultiseg)
352
353         logger.debug('Writing VPP config to host {}: "{}"'.format(hostname,
354                                                                   vppconfig))
355
356         ssh = SSH()
357         ssh.connect(node)
358
359         # We're using this "| sudo tee" construct because redirecting
360         # a sudo'd outut ("sudo echo xxx > /path/to/file") does not
361         # work on most platforms...
362         (ret, stdout, stderr) = \
363             ssh.exec_command('echo "{0}" | sudo tee {1}'.
364                              format(vppconfig, VPP_CONFIG_FILENAME))
365
366         if ret != 0:
367             logger.debug('Writing config file failed to node {}'.
368                          format(hostname))
369             logger.debug('stdout: {}'.format(stdout))
370             logger.debug('stderr: {}'.format(stderr))
371             raise RuntimeError('Writing config file failed to node {}'.
372                                format(hostname))
373
374         # Instead of restarting, we'll do separate start and stop
375         # actions. This way we don't care whether VPP was running
376         # to begin with.
377         ssh.exec_command('sudo initctl stop {}'.format(VPP_SERVICE_NAME))
378         (ret, stdout, stderr) = \
379             ssh.exec_command('sudo initctl start {}'.format(VPP_SERVICE_NAME))
380         if ret != 0:
381             logger.debug('Restarting VPP failed on node {}'.
382                          format(hostname))
383             logger.debug('stdout: {}'.format(stdout))
384             logger.debug('stderr: {}'.format(stderr))
385             raise RuntimeError('Restarting VPP failed on node {}'.
386                                format(hostname))
387
388         # Sleep <waittime> seconds, up to <retry> times,
389         # and verify if VPP is running.
390         vpp_is_running = False
391         retries_left = retries
392         while (not vpp_is_running) and (retries_left > 0):
393             time.sleep(waittime)
394             retries_left -= 1
395
396             # FIXME: Need to find a good way to check if VPP is operational.
397             #
398             # If VatTerminal/VatExecutor is anything like vppctl or
399             # vpp_api_test, then in case VPP is NOT running it will block for
400             # 30 seconds or so and not even return if VPP becomes alive during
401             # that time. This makes it unsuitable in this case. We either need
402             # a call that returns immediately, indicating whether VPP is
403             # healthy or not, or a call that waits (up to a defined length
404             # of time) and returns immediately if VPP is or becomes healthy.
405             (ret, stdout, stderr) = \
406                 ssh.exec_command('echo show hardware-interfaces | '
407                                  'nc 0 5002')
408
409             if ret == 0:
410                 vpp_is_running = True
411             else:
412                 logger.debug('VPP not yet running, {} retries left'.
413                              format(retries_left))
414         if retries_left == 0:
415             raise RuntimeError('VPP failed to restart on node {}'.
416                                format(hostname))
417         logger.debug('VPP interfaces found on node {}'.
418                      format(stdout))

©2016 FD.io a Linux Foundation Collaborative Project. All Rights Reserved.
Linux Foundation is a registered trademark of The Linux Foundation. Linux is a registered trademark of Linus Torvalds.
Please see our privacy policy and terms of use.