Fix: Do not validate LXC image
[csit.git] / resources / libraries / python / LXCUtils.py
1 # Copyright (c) 2017 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 """Library to manipulate LXC."""
15
16 from resources.libraries.python.ssh import SSH
17 from resources.libraries.python.constants import Constants
18 from resources.libraries.python.topology import NodeType
19
20
21 __all__ = ["LXCUtils"]
22
23 class LXCUtils(object):
24     """LXC utilities."""
25
26     def __init__(self, container_name='slave'):
27         # LXC container name
28         self._container_name = container_name
29         self._node = None
30         # Host hugepages dir that will be mounted inside LXC
31         self._host_hugepages_dir = '/dev/hugepages'
32         # Host dir that will be mounted inside LXC
33         self._host_dir = '/tmp/'
34         # Guest dir to mount host dir to
35         self._guest_dir = '/mnt/host'
36         # LXC container env variables
37         self._env_vars = ['LC_ALL="en_US.UTF-8"',
38                           'DEBIAN_FRONTEND=noninteractive']
39
40     def set_node(self, node):
41         """Set node for LXC execution.
42
43         :param node: Node to execute LXC on.
44         :type node: dict
45         :raises RuntimeError: If Node type is not DUT.
46         """
47         if node['type'] != NodeType.DUT:
48             raise RuntimeError('Node type is not DUT.')
49         self._node = node
50
51     def set_host_dir(self, node, host_dir):
52         """Set shared dir on parent node for LXC.
53
54         :param node: Node to control LXC on.
55         :type node: dict
56         :raises RuntimeError: If Node type is not DUT.
57         """
58         if node['type'] != NodeType.DUT:
59             raise RuntimeError('Node type is not DUT.')
60         self._host_dir = host_dir
61
62     def set_guest_dir(self, node, guest_dir):
63         """Set mount dir on LXC.
64
65         :param node: Node to control LXC on.
66         :param guest_dir: Guest dir for mount.
67         :type node: dict
68         :type guest_dir: str
69         :raises RuntimeError: If Node type is not DUT.
70         """
71         if node['type'] != NodeType.DUT:
72             raise RuntimeError('Node type is not DUT.')
73         self._guest_dir = guest_dir
74
75     def _lxc_checkconfig(self):
76         """Check the current kernel for LXC support.
77
78         :raises RuntimeError: If failed to check LXC support.
79         """
80
81         ssh = SSH()
82         ssh.connect(self._node)
83
84         ret, _, _ = ssh.exec_command_sudo('lxc-checkconfig')
85         if int(ret) != 0:
86             raise RuntimeError('Failed to check LXC support.')
87
88     def _lxc_create(self, distro='ubuntu', release='xenial', arch='amd64'):
89         """Creates a privileged system object where is stored the configuration
90         information and where can be stored user information.
91
92         :param distro: Linux distribution name.
93         :param release: Linux distribution release.
94         :param arch: Linux distribution architecture.
95         :type distro: str
96         :type release: str
97         :type arch: str
98         :raises RuntimeError: If failed to create a container.
99         """
100
101         ssh = SSH()
102         ssh.connect(self._node)
103
104         ret, _, _ = ssh.exec_command_sudo(
105             'lxc-create -t download --name {0} -- -d {1} -r {2} -a {3}'\
106             ' --no-validate'.format(self._container_name, distro, release,
107                                     arch), timeout=1800)
108         if int(ret) != 0:
109             raise RuntimeError('Failed to create LXC container.')
110
111     def _lxc_info(self):
112         """Queries and shows information about a container.
113
114         :raises RuntimeError: If failed to get info about a container.
115         """
116
117         ssh = SSH()
118         ssh.connect(self._node)
119
120         ret, _, _ = ssh.exec_command_sudo(
121             'lxc-info --name {0}'.format(self._container_name))
122         if int(ret) != 0:
123             raise RuntimeError('Failed to get info about LXC container {0}.'
124                                .format(self._container_name))
125
126     def _lxc_start(self):
127         """Start an application inside a container.
128
129         :raises RuntimeError: If failed to start container.
130         """
131
132         ssh = SSH()
133         ssh.connect(self._node)
134
135         ret, _, _ = ssh.exec_command_sudo(
136             'lxc-start --name {0} --daemon'.format(self._container_name))
137         if int(ret) != 0:
138             raise RuntimeError('Failed to start LXC container {0}.'
139                                .format(self._container_name))
140
141     def _lxc_stop(self):
142         """Stop an application inside a container.
143
144         :raises RuntimeError: If failed to stop container.
145         """
146
147         ssh = SSH()
148         ssh.connect(self._node)
149
150         ret, _, _ = ssh.exec_command_sudo(
151             'lxc-stop --name {0}'.format(self._container_name))
152         if int(ret) != 0:
153             raise RuntimeError('Failed to stop LXC container {}.'
154                                .format(self._container_name))
155
156     def _lxc_destroy(self):
157         """Destroy a container.
158
159         :raises RuntimeError: If failed to destroy container.
160         """
161
162         ssh = SSH()
163         ssh.connect(self._node)
164
165         ret, _, _ = ssh.exec_command_sudo(
166             'lxc-destroy --force --name {0}'.format(self._container_name))
167         if int(ret) != 0:
168             raise RuntimeError('Failed to destroy LXC container {}.'
169                                .format(self._container_name))
170
171     def _lxc_wait(self, state):
172         """Wait for a specific container state.
173
174         :param state: Specify the container state(s) to wait for.
175         :type state: str
176         :raises RuntimeError: If failed to wait for state of a container.
177         """
178
179         ssh = SSH()
180         ssh.connect(self._node)
181
182         ret, _, _ = ssh.exec_command_sudo(
183             'lxc-wait --name {0} --state "{1}"'
184             .format(self._container_name, state))
185         if int(ret) != 0:
186             raise RuntimeError('Failed to wait for "{0}" of LXC container {1}.'
187                                .format(state, self._container_name))
188
189     def _lxc_cgroup(self, state_object, value=''):
190         """Manage the control group associated with a container.
191
192         :param state_object: Specify the state object name.
193         :param value: Specify the value to assign to the state object. If empty,
194         then action is GET, otherwise is action SET.
195         :type state_object: str
196         :type value: str
197         :raises RuntimeError: If failed to get/set for state of a container.
198         """
199
200         ssh = SSH()
201         ssh.connect(self._node)
202
203         ret, _, _ = ssh.exec_command_sudo(
204             'lxc-cgroup --name {0} {1} {2}'
205             .format(self._container_name, state_object, value))
206         if int(ret) != 0:
207             if value:
208                 raise RuntimeError('Failed to set {0} of LXC container {1}.'
209                                    .format(state_object, self._container_name))
210             else:
211                 raise RuntimeError('Failed to get {0} of LXC container {1}.'
212                                    .format(state_object, self._container_name))
213
214     def lxc_attach(self, command):
215         """Start a process inside a running container. Runs the specified
216         command inside the container specified by name. The container has to
217         be running already.
218
219         :param command: Command to run inside container.
220         :type command: str
221         :raises RuntimeError: If container is not running.
222         :raises RuntimeError: If failed to run the command.
223         """
224         env_var = '--keep-env {0}'\
225             .format(' '.join('--set-var %s' % var for var in self._env_vars))
226
227         ssh = SSH()
228         ssh.connect(self._node)
229
230         if not self.is_container_running():
231             raise RuntimeError('LXC {0} is not running.'
232                                .format(self._container_name))
233
234         ret, _, _ = ssh.exec_command_lxc(lxc_cmd=command,
235                                          lxc_name=self._container_name,
236                                          lxc_params=env_var, timeout=180)
237         if int(ret) != 0:
238             raise RuntimeError('Failed to run "{0}" on LXC container {1}.'
239                                .format(command, self._container_name))
240
241     def is_container_present(self):
242         """Check if LXC container is existing on node."""
243
244         ssh = SSH()
245         ssh.connect(self._node)
246
247         ret, _, _ = ssh.exec_command_sudo(
248             'lxc-info --name {0}'.format(self._container_name))
249         return False if int(ret) else True
250
251     def create_container(self, force_create=True):
252         """Create and start a container.
253
254         :param force_create: Destroy a container if exists and create.
255         :type force_create: bool
256         """
257         if self.is_container_present():
258             if force_create:
259                 self.destroy_container()
260             else:
261                 return
262
263         self._lxc_checkconfig()
264         self._lxc_create(distro='ubuntu', release='xenial', arch='amd64')
265         self.start_container()
266
267     def start_container(self):
268         """Start a container and wait for running state."""
269
270         self._lxc_start()
271         self._lxc_wait('RUNNING')
272         self._lxc_info()
273
274     def is_container_running(self):
275         """Check if LXC container is running on node.
276
277         :raises RuntimeError: If failed to get info about a container.
278         """
279
280         ssh = SSH()
281         ssh.connect(self._node)
282
283         ret, stdout, _ = ssh.exec_command_sudo(
284             'lxc-info --state --name {0}'.format(self._container_name))
285         if int(ret) != 0:
286             raise RuntimeError('Failed to get info about LXC container {0}.'
287                                .format(self._container_name))
288
289         return True if 'RUNNING' in stdout else False
290
291     def stop_container(self):
292         """Stop a container and wait for stopped state."""
293
294         self._lxc_stop()
295         self._lxc_wait('STOPPED|FROZEN')
296         self._lxc_info()
297
298     def restart_container(self):
299         """Restart container."""
300
301         self.stop_container()
302         self.start_container()
303
304     def destroy_container(self):
305         """Stop and destroy a container."""
306
307         self._lxc_destroy()
308
309     def container_cpuset_cpus(self, container_cpu):
310         """Set cpuset.cpus control group associated with a container.
311
312         :param container_cpu: Cpuset.cpus string.
313         :type container_cpu: str
314         :raises RuntimeError: If failed to set cgroup for a container.
315         """
316
317         ssh = SSH()
318         ssh.connect(self._node)
319
320         ret, _, _ = ssh.exec_command_sudo('cgset --copy-from / lxc')
321         if int(ret) != 0:
322             raise RuntimeError('Failed to copy cgroup settings from root.')
323
324         self._lxc_cgroup(state_object='cpuset.cpus')
325         self._lxc_cgroup(state_object='cpuset.cpus', value=container_cpu)
326         self._lxc_cgroup(state_object='cpuset.cpus')
327
328     def mount_host_dir_in_container(self):
329         """Mount shared folder inside container.
330
331         :raises RuntimeError: If failed to mount host dir in a container.
332         """
333
334         ssh = SSH()
335         ssh.connect(self._node)
336
337         mnt_cfg = 'lxc.mount.entry = {0} /var/lib/lxc/{1}/rootfs{2} ' \
338             'none bind,create=dir 0 0'.format(self._host_dir,
339                                               self._container_name,
340                                               self._guest_dir)
341         ret, _, _ = ssh.exec_command_sudo(
342             "sh -c 'echo \"{0}\" >> /var/lib/lxc/{1}/config'"
343             .format(mnt_cfg, self._container_name))
344         if int(ret) != 0:
345             raise RuntimeError('Failed to mount {0} in lxc: {1}'
346                                .format(self._host_dir, self._container_name))
347
348         self.restart_container()
349
350     def mount_hugepages_in_container(self):
351         """Mount hugepages inside container.
352
353         :raises RuntimeError: If failed to mount hugepages in a container.
354         """
355
356         ssh = SSH()
357         ssh.connect(self._node)
358
359         mnt_cfg = 'lxc.mount.entry = {0} dev/hugepages ' \
360             'none bind,create=dir 0 0'.format(self._host_hugepages_dir)
361         ret, _, _ = ssh.exec_command_sudo(
362             "sh -c 'echo \"{0}\" >> /var/lib/lxc/{1}/config'"
363             .format(mnt_cfg, self._container_name))
364         if int(ret) != 0:
365             raise RuntimeError('Failed to mount {0} in lxc: {1}'
366                                .format(self._host_hugepages_dir,
367                                        self._container_name))
368
369         self.restart_container()
370
371     def install_vpp_in_container(self, install_dkms=False):
372         """Install vpp inside a container.
373
374         :param install_dkms: If install dkms package. This will impact install
375         time. Dkms is required for installation of vpp-dpdk-dkms. Default is
376         false.
377         :type install_dkms: bool
378         """
379
380         ssh = SSH()
381         ssh.connect(self._node)
382
383         self.lxc_attach('apt-get update')
384         if install_dkms:
385             self.lxc_attach('apt-get install -y dkms && '
386                             'dpkg -i --force-all {0}/install_dir/*.deb'
387                             .format(self._guest_dir))
388         else:
389             self.lxc_attach('for i in $(ls -I \"*dkms*\" {0}/install_dir/); '
390                             'do dpkg -i --force-all {0}/install_dir/$i; done'
391                             .format(self._guest_dir))
392         self.lxc_attach('apt-get -f install -y')
393
394     def restart_vpp_in_container(self):
395         """Restart vpp service inside a container."""
396
397         ssh = SSH()
398         ssh.connect(self._node)
399
400         self.lxc_attach('service vpp restart')
401
402     def create_vpp_cfg_in_container(self, vat_template_file, **args):
403         """Create VPP exec config for a container on given node.
404
405         :param vat_template_file: Template file name of a VAT script.
406         :param args: Parameters for VAT script.
407         :type vat_template_file: str
408         :type args: dict
409         """
410         ssh = SSH()
411         ssh.connect(self._node)
412
413         vat_file_path = '{}/{}'.format(Constants.RESOURCES_TPL_VAT,
414                                        vat_template_file)
415
416         with open(vat_file_path, 'r') as template_file:
417             cmd_template = template_file.readlines()
418             for line_tmpl in cmd_template:
419                 vat_cmd = line_tmpl.format(**args)
420                 ssh.exec_command('echo "{0}" | '
421                                  'sudo lxc-attach --name {1} -- '
422                                  '/bin/sh -c "/bin/cat >> /tmp/running.exec"'
423                                  .format(vat_cmd.replace('\n', ''),
424                                          self._container_name))

©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.