CSIT-989 Fix: Reflect latest memif API changes
[csit.git] / resources / libraries / python / ContainerUtils.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 # Bug workaround in pylint for abstract classes.
15 # pylint: disable=W0223
16
17 """Library to manipulate Containers."""
18
19 from collections import OrderedDict, Counter
20
21 from resources.libraries.python.ssh import SSH
22 from resources.libraries.python.constants import Constants
23 from resources.libraries.python.CpuUtils import CpuUtils
24 from resources.libraries.python.VppConfigGenerator import VppConfigGenerator
25
26
27 __all__ = ["ContainerManager", "ContainerEngine", "LXC", "Docker", "Container"]
28
29 SUPERVISOR_CONF = '/etc/supervisord.conf'
30
31
32 class ContainerManager(object):
33     """Container lifecycle management class."""
34
35     def __init__(self, engine):
36         """Initialize Container Manager class.
37
38         :param engine: Container technology used (LXC/Docker/...).
39         :type engine: str
40         :raises NotImplementedError: If container technology is not implemented.
41         """
42         try:
43             self.engine = globals()[engine]()
44         except KeyError:
45             raise NotImplementedError('{e} is not implemented.'
46                                       .format(e=engine))
47         self.containers = OrderedDict()
48
49     def get_container_by_name(self, name):
50         """Get container instance.
51
52         :param name: Container name.
53         :type name: str
54         :returns: Container instance.
55         :rtype: Container
56         :raises RuntimeError: If failed to get container with name.
57         """
58         try:
59             return self.containers[name]
60         except KeyError:
61             raise RuntimeError('Failed to get container with name: {n}'
62                                .format(n=name))
63
64     def construct_container(self, **kwargs):
65         """Construct container object on node with specified parameters.
66
67         :param kwargs: Key-value pairs used to construct container.
68         :param kwargs: dict
69         """
70         # Create base class
71         self.engine.initialize()
72         # Set parameters
73         for key in kwargs:
74             setattr(self.engine.container, key, kwargs[key])
75
76         # Set additional environmental variables
77         setattr(self.engine.container, 'env',
78                 'MICROSERVICE_LABEL={n}'.format(n=kwargs['name']))
79
80         # Set cpuset.cpus cgroup
81         skip_cnt = kwargs['cpu_skip']
82         if not kwargs['cpu_shared']:
83             skip_cnt += kwargs['i'] * kwargs['cpu_count']
84         self.engine.container.cpuset_cpus = \
85             CpuUtils.cpu_slice_of_list_per_node(node=kwargs['node'],
86                                                 cpu_node=kwargs['cpuset_mems'],
87                                                 skip_cnt=skip_cnt,
88                                                 cpu_cnt=kwargs['cpu_count'],
89                                                 smt_used=kwargs['smt_used'])
90
91         # Store container instance
92         self.containers[kwargs['name']] = self.engine.container
93
94     def construct_containers(self, **kwargs):
95         """Construct 1..N container(s) on node with specified name.
96
97         Ordinal number is automatically added to the name of container as
98         suffix.
99
100         :param kwargs: Named parameters.
101         :param kwargs: dict
102         """
103         name = kwargs['name']
104         for i in range(kwargs['count']):
105             # Name will contain ordinal suffix
106             kwargs['name'] = ''.join([name, str(i+1)])
107             # Create container
108             self.construct_container(i=i, **kwargs)
109
110     def acquire_all_containers(self):
111         """Acquire all containers."""
112         for container in self.containers:
113             self.engine.container = self.containers[container]
114             self.engine.acquire()
115
116     def build_all_containers(self):
117         """Build all containers."""
118         for container in self.containers:
119             self.engine.container = self.containers[container]
120             self.engine.build()
121
122     def create_all_containers(self):
123         """Create all containers."""
124         for container in self.containers:
125             self.engine.container = self.containers[container]
126             self.engine.create()
127
128     def execute_on_container(self, name, command):
129         """Execute command on container with name.
130
131         :param name: Container name.
132         :param command: Command to execute.
133         :type name: str
134         :type command: str
135         """
136         self.engine.container = self.get_container_by_name(name)
137         self.engine.execute(command)
138
139     def execute_on_all_containers(self, command):
140         """Execute command on all containers.
141
142         :param command: Command to execute.
143         :type command: str
144         """
145         for container in self.containers:
146             self.engine.container = self.containers[container]
147             self.engine.execute(command)
148
149     def install_vpp_in_all_containers(self):
150         """Install VPP into all containers."""
151         for container in self.containers:
152             self.engine.container = self.containers[container]
153             # We need to install supervisor client/server system to control VPP
154             # as a service
155             self.engine.install_supervisor()
156             self.engine.install_vpp()
157             self.engine.restart_vpp()
158
159     def configure_vpp_in_all_containers(self, vat_template_file):
160         """Configure VPP in all containers.
161
162         :param vat_template_file: Template file name of a VAT script.
163         :type vat_template_file: str
164         """
165         # Count number of DUTs based on node's host information
166         dut_cnt = len(Counter([self.containers[container].node['host']
167                                for container in self.containers]))
168         container_cnt = len(self.containers)
169         mod = container_cnt/dut_cnt
170
171         for i, container in enumerate(self.containers):
172             mid1 = i % mod + 1
173             mid2 = i % mod + 1
174             sid1 = i % mod * 2 + 1
175             sid2 = i % mod * 2 + 2
176             self.engine.container = self.containers[container]
177             self.engine.create_vpp_startup_config()
178             self.engine.create_vpp_exec_config(vat_template_file, mid1=mid1,
179                                                mid2=mid2, sid1=sid1, sid2=sid2,
180                                                socket1='memif-{c.name}-{sid}'
181                                                .format(c=self.engine.container,
182                                                        sid=sid1),
183                                                socket2='memif-{c.name}-{sid}'
184                                                .format(c=self.engine.container,
185                                                        sid=sid2))
186
187     def stop_all_containers(self):
188         """Stop all containers."""
189         for container in self.containers:
190             self.engine.container = self.containers[container]
191             self.engine.stop()
192
193     def destroy_all_containers(self):
194         """Destroy all containers."""
195         for container in self.containers:
196             self.engine.container = self.containers[container]
197             self.engine.destroy()
198
199
200 class ContainerEngine(object):
201     """Abstract class for container engine."""
202
203     def __init__(self):
204         """Init ContainerEngine object."""
205         self.container = None
206
207     def initialize(self):
208         """Initialize container object."""
209         self.container = Container()
210
211     def acquire(self, force):
212         """Acquire/download container.
213
214         :param force: Destroy a container if exists and create.
215         :type force: bool
216         """
217         raise NotImplementedError
218
219     def build(self):
220         """Build container (compile)."""
221         raise NotImplementedError
222
223     def create(self):
224         """Create/deploy container."""
225         raise NotImplementedError
226
227     def execute(self, command):
228         """Execute process inside container.
229
230         :param command: Command to run inside container.
231         :type command: str
232         """
233         raise NotImplementedError
234
235     def stop(self):
236         """Stop container."""
237         raise NotImplementedError
238
239     def destroy(self):
240         """Destroy/remove container."""
241         raise NotImplementedError
242
243     def info(self):
244         """Info about container."""
245         raise NotImplementedError
246
247     def system_info(self):
248         """System info."""
249         raise NotImplementedError
250
251     def install_supervisor(self):
252         """Install supervisord inside a container."""
253         self.execute('sleep 3')
254         self.execute('apt-get update')
255         self.execute('apt-get install -y supervisor')
256         self.execute('echo "{0}" > {1}'
257                      .format(
258                          '[unix_http_server]\n'
259                          'file  = /tmp/supervisor.sock\n\n'
260                          '[rpcinterface:supervisor]\n'
261                          'supervisor.rpcinterface_factory = '
262                          'supervisor.rpcinterface:make_main_rpcinterface\n\n'
263                          '[supervisorctl]\n'
264                          'serverurl = unix:///tmp/supervisor.sock\n\n'
265                          '[supervisord]\n'
266                          'pidfile = /tmp/supervisord.pid\n'
267                          'identifier = supervisor\n'
268                          'directory = /tmp\n'
269                          'logfile=/tmp/supervisord.log\n'
270                          'loglevel=debug\n'
271                          'nodaemon=false\n\n',
272                          SUPERVISOR_CONF))
273         self.execute('supervisord -c {0}'.format(SUPERVISOR_CONF))
274
275     def install_vpp(self, install_dkms=False):
276         """Install VPP inside a container.
277
278         :param install_dkms: If install dkms package. This will impact install
279         time. Dkms is required for installation of vpp-dpdk-dkms. Default is
280         false.
281         :type install_dkms: bool
282         """
283         self.execute('ln -s /dev/null /etc/sysctl.d/80-vpp.conf')
284         self.execute('apt-get update')
285         if install_dkms:
286             self.execute('apt-get install -y dkms && '
287                          'dpkg -i --force-all {0}/install_dir/*.deb'
288                          .format(self.container.guest_dir))
289         else:
290             self.execute('for i in $(ls -I \"*dkms*\" {0}/install_dir/); '
291                          'do dpkg -i --force-all {0}/install_dir/$i; done'
292                          .format(self.container.guest_dir))
293         self.execute('apt-get -f install -y')
294         self.execute('apt-get install -y ca-certificates')
295         self.execute('echo "{0}" >> {1}'
296                      .format(
297                          '[program:vpp]\n'
298                          'command=/usr/bin/vpp -c /etc/vpp/startup.conf\n'
299                          'autorestart=false\n'
300                          'redirect_stderr=true\n'
301                          'priority=1',
302                          SUPERVISOR_CONF))
303         self.execute('supervisorctl reload')
304
305     def restart_vpp(self):
306         """Restart VPP service inside a container."""
307         self.execute('supervisorctl restart vpp')
308
309     def create_vpp_startup_config(self,
310                                   config_filename='/etc/vpp/startup.conf'):
311         """Create base startup configuration of VPP on container.
312
313         :param config_filename: Startup configuration file name.
314         :type config_filename: str
315         """
316         cpuset_cpus = self.container.cpuset_cpus
317
318         # Create config instance
319         vpp_config = VppConfigGenerator()
320         vpp_config.set_node(self.container.node)
321         vpp_config.add_unix_cli_listen()
322         vpp_config.add_unix_nodaemon()
323         vpp_config.add_unix_exec('/tmp/running.exec')
324         # We will pop first core from list to be main core
325         vpp_config.add_cpu_main_core(str(cpuset_cpus.pop(0)))
326         # if this is not only core in list, the rest will be used as workers.
327         if cpuset_cpus:
328             corelist_workers = ','.join(str(cpu) for cpu in cpuset_cpus)
329             vpp_config.add_cpu_corelist_workers(corelist_workers)
330         vpp_config.add_plugin_disable('dpdk_plugin.so')
331
332         self.execute('mkdir -p /etc/vpp/')
333         self.execute('echo "{c}" | tee {f}'
334                      .format(c=vpp_config.get_config_str(),
335                              f=config_filename))
336
337     def create_vpp_exec_config(self, vat_template_file, **kwargs):
338         """Create VPP exec configuration on container.
339
340         :param vat_template_file: File name of a VAT template script.
341         :param kwargs: Parameters for VAT script.
342         :type vat_template_file: str
343         :type kwargs: dict
344         """
345         vat_file_path = '{p}/{f}'.format(p=Constants.RESOURCES_TPL_VAT,
346                                          f=vat_template_file)
347
348         with open(vat_file_path, 'r') as template_file:
349             cmd_template = template_file.readlines()
350             for line_tmpl in cmd_template:
351                 vat_cmd = line_tmpl.format(**kwargs)
352                 self.execute('echo "{c}" >> /tmp/running.exec'
353                              .format(c=vat_cmd.replace('\n', '')))
354
355     def is_container_running(self):
356         """Check if container is running."""
357         raise NotImplementedError
358
359     def is_container_present(self):
360         """Check if container is present."""
361         raise NotImplementedError
362
363     def _configure_cgroup(self, name):
364         """Configure the control group associated with a container.
365
366         By default the cpuset cgroup is using exclusive CPU/MEM. When Docker
367         container is initialized a new cgroup /docker or /lxc is created under
368         cpuset parent tree. This newly created cgroup is inheriting parent
369         setting for cpu/mem exclusive parameter and thus cannot be overriden
370         within /docker or /lxc cgroup. This patch is supposed to set cpu/mem
371         exclusive parameter for both parent and subgroup.
372
373         :param name: Name of cgroup.
374         :type name: str
375         :raises RuntimeError: If applying cgroup settings via cgset failed.
376         """
377         ret, _, _ = self.container.ssh.exec_command_sudo(
378             'cgset -r cpuset.cpu_exclusive=0 /')
379         if int(ret) != 0:
380             raise RuntimeError('Failed to apply cgroup settings.')
381
382         ret, _, _ = self.container.ssh.exec_command_sudo(
383             'cgset -r cpuset.mem_exclusive=0 /')
384         if int(ret) != 0:
385             raise RuntimeError('Failed to apply cgroup settings.')
386
387         ret, _, _ = self.container.ssh.exec_command_sudo(
388             'cgcreate -g cpuset:/{name}'.format(name=name))
389         if int(ret) != 0:
390             raise RuntimeError('Failed to copy cgroup settings from root.')
391
392         ret, _, _ = self.container.ssh.exec_command_sudo(
393             'cgset -r cpuset.cpu_exclusive=0 /{name}'.format(name=name))
394         if int(ret) != 0:
395             raise RuntimeError('Failed to apply cgroup settings.')
396
397         ret, _, _ = self.container.ssh.exec_command_sudo(
398             'cgset -r cpuset.mem_exclusive=0 /{name}'.format(name=name))
399         if int(ret) != 0:
400             raise RuntimeError('Failed to apply cgroup settings.')
401
402
403 class LXC(ContainerEngine):
404     """LXC implementation."""
405
406     def __init__(self):
407         """Initialize LXC object."""
408         super(LXC, self).__init__()
409
410     def acquire(self, force=True):
411         """Acquire a privileged system object where configuration is stored.
412
413         :param force: If a container exists, destroy it and create a new
414         container.
415         :type force: bool
416         :raises RuntimeError: If creating the container or writing the container
417         config fails.
418         """
419         if self.is_container_present():
420             if force:
421                 self.destroy()
422             else:
423                 return
424
425         image = self.container.image if self.container.image else\
426             "-d ubuntu -r xenial -a amd64"
427
428         cmd = 'lxc-create -t download --name {c.name} -- {image} '\
429             '--no-validate'.format(c=self.container, image=image)
430
431         ret, _, _ = self.container.ssh.exec_command_sudo(cmd, timeout=1800)
432         if int(ret) != 0:
433             raise RuntimeError('Failed to create container.')
434
435         if self.container.host_dir and self.container.guest_dir:
436             entry = 'lxc.mount.entry = '\
437                 '{c.host_dir} /var/lib/lxc/{c.name}/rootfs{c.guest_dir} ' \
438                 'none bind,create=dir 0 0'.format(c=self.container)
439             ret, _, _ = self.container.ssh.exec_command_sudo(
440                 "sh -c 'echo \"{e}\" >> /var/lib/lxc/{c.name}/config'"
441                 .format(e=entry, c=self.container))
442             if int(ret) != 0:
443                 raise RuntimeError('Failed to write {c.name} config.'
444                                    .format(c=self.container))
445         self._configure_cgroup('lxc')
446
447     def create(self):
448         """Create/deploy an application inside a container on system.
449
450         :raises RuntimeError: If creating the container fails.
451         """
452         cpuset_cpus = '{0}'.format(
453             ','.join('%s' % cpu for cpu in self.container.cpuset_cpus))\
454             if self.container.cpuset_cpus else ''
455
456         cmd = 'lxc-start --name {c.name} --daemon'.format(c=self.container)
457
458         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
459         if int(ret) != 0:
460             raise RuntimeError('Failed to start container {c.name}.'
461                                .format(c=self.container))
462         self._lxc_wait('RUNNING')
463
464         # Workaround for LXC to be able to allocate all cpus including isolated.
465         cmd = 'cgset --copy-from / lxc/'
466         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
467         if int(ret) != 0:
468             raise RuntimeError('Failed to copy cgroup to LXC')
469
470         cmd = 'lxc-cgroup --name {c.name} cpuset.cpus {cpus}'\
471             .format(c=self.container, cpus=cpuset_cpus)
472         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
473         if int(ret) != 0:
474             raise RuntimeError('Failed to set cpuset.cpus to container '
475                                '{c.name}.'.format(c=self.container))
476
477     def execute(self, command):
478         """Start a process inside a running container.
479
480         Runs the specified command inside the container specified by name. The
481         container has to be running already.
482
483         :param command: Command to run inside container.
484         :type command: str
485         :raises RuntimeError: If running the command failed.
486         """
487         env = '--keep-env {0}'.format(
488             ' '.join('--set-var %s' % env for env in self.container.env))\
489             if self.container.env else ''
490
491         cmd = "lxc-attach {env} --name {c.name} -- /bin/sh -c '{command}'"\
492             .format(env=env, c=self.container, command=command)
493
494         ret, _, _ = self.container.ssh.exec_command_sudo(cmd, timeout=180)
495         if int(ret) != 0:
496             raise RuntimeError('Failed to run command inside container '
497                                '{c.name}.'.format(c=self.container))
498
499     def stop(self):
500         """Stop a container.
501
502         :raises RuntimeError: If stopping the container failed.
503         """
504         cmd = 'lxc-stop --name {c.name}'.format(c=self.container)
505
506         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
507         if int(ret) != 0:
508             raise RuntimeError('Failed to stop container {c.name}.'
509                                .format(c=self.container))
510         self._lxc_wait('STOPPED|FROZEN')
511
512     def destroy(self):
513         """Destroy a container.
514
515         :raises RuntimeError: If destroying container failed.
516         """
517         cmd = 'lxc-destroy --force --name {c.name}'.format(c=self.container)
518
519         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
520         if int(ret) != 0:
521             raise RuntimeError('Failed to destroy container {c.name}.'
522                                .format(c=self.container))
523
524     def info(self):
525         """Query and shows information about a container.
526
527         :raises RuntimeError: If getting info about a container failed.
528         """
529         cmd = 'lxc-info --name {c.name}'.format(c=self.container)
530
531         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
532         if int(ret) != 0:
533             raise RuntimeError('Failed to get info about container {c.name}.'
534                                .format(c=self.container))
535
536     def system_info(self):
537         """Check the current kernel for LXC support.
538
539         :raises RuntimeError: If checking LXC support failed.
540         """
541         cmd = 'lxc-checkconfig'
542
543         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
544         if int(ret) != 0:
545             raise RuntimeError('Failed to check LXC support.')
546
547     def is_container_running(self):
548         """Check if container is running on node.
549
550         :returns: True if container is running.
551         :rtype: bool
552         :raises RuntimeError: If getting info about a container failed.
553         """
554         cmd = 'lxc-info --no-humanize --state --name {c.name}'\
555             .format(c=self.container)
556
557         ret, stdout, _ = self.container.ssh.exec_command_sudo(cmd)
558         if int(ret) != 0:
559             raise RuntimeError('Failed to get info about container {c.name}.'
560                                .format(c=self.container))
561         return True if 'RUNNING' in stdout else False
562
563     def is_container_present(self):
564         """Check if container is existing on node.
565
566         :returns: True if container is present.
567         :rtype: bool
568         :raises RuntimeError: If getting info about a container failed.
569         """
570         cmd = 'lxc-info --no-humanize --name {c.name}'.format(c=self.container)
571
572         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
573         return False if int(ret) else True
574
575     def _lxc_wait(self, state):
576         """Wait for a specific container state.
577
578         :param state: Specify the container state(s) to wait for.
579         :type state: str
580         :raises RuntimeError: If waiting for state of a container failed.
581         """
582         cmd = 'lxc-wait --name {c.name} --state "{s}"'\
583             .format(c=self.container, s=state)
584
585         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
586         if int(ret) != 0:
587             raise RuntimeError('Failed to wait for state "{s}" of container '
588                                '{c.name}.'.format(s=state, c=self.container))
589
590
591 class Docker(ContainerEngine):
592     """Docker implementation."""
593
594     def __init__(self):
595         """Initialize Docker object."""
596         super(Docker, self).__init__()
597
598     def acquire(self, force=True):
599         """Pull an image or a repository from a registry.
600
601         :param force: Destroy a container if exists.
602         :type force: bool
603         :raises RuntimeError: If pulling a container failed.
604         """
605         if self.is_container_present():
606             if force:
607                 self.destroy()
608             else:
609                 return
610
611         cmd = 'docker pull {c.image}'.format(c=self.container)
612
613         ret, _, _ = self.container.ssh.exec_command_sudo(cmd, timeout=1800)
614         if int(ret) != 0:
615             raise RuntimeError('Failed to create container {c.name}.'
616                                .format(c=self.container))
617         self._configure_cgroup('docker')
618
619     def create(self):
620         """Create/deploy container.
621
622         :raises RuntimeError: If creating a container failed.
623         """
624         cpuset_cpus = '--cpuset-cpus={0}'.format(
625             ','.join('%s' % cpu for cpu in self.container.cpuset_cpus))\
626             if self.container.cpuset_cpus else ''
627
628         cpuset_mems = '--cpuset-mems={0}'.format(self.container.cpuset_mems)\
629             if self.container.cpuset_mems is not None else ''
630
631         env = '{0}'.format(
632             ' '.join('--env %s' % env for env in self.container.env))\
633             if self.container.env else ''
634
635         command = '{0}'.format(self.container.command)\
636             if self.container.command else ''
637
638         publish = '{0}'.format(
639             ' '.join('--publish %s' % var for var in self.container.publish))\
640             if self.container.publish else ''
641
642         volume = '--volume {c.host_dir}:{c.guest_dir}'.format(c=self.container)\
643             if self.container.host_dir and self.container.guest_dir else ''
644
645         cmd = 'docker run '\
646             '--privileged --detach --interactive --tty --rm '\
647             '--cgroup-parent docker {cpuset_cpus} {cpuset_mems} {publish} '\
648             '{env} {volume} --name {container.name} {container.image} '\
649             '{command}'.format(cpuset_cpus=cpuset_cpus, cpuset_mems=cpuset_mems,
650                                container=self.container, command=command,
651                                env=env, publish=publish, volume=volume)
652
653         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
654         if int(ret) != 0:
655             raise RuntimeError('Failed to create container {c.name}'
656                                .format(c=self.container))
657
658         self.info()
659
660     def execute(self, command):
661         """Start a process inside a running container.
662
663         Runs the specified command inside the container specified by name. The
664         container has to be running already.
665
666         :param command: Command to run inside container.
667         :type command: str
668         :raises RuntimeError: If runnig the command in a container failed.
669         """
670         cmd = "docker exec --interactive {c.name} /bin/sh -c '{command}'"\
671             .format(c=self.container, command=command)
672
673         ret, _, _ = self.container.ssh.exec_command_sudo(cmd, timeout=180)
674         if int(ret) != 0:
675             raise RuntimeError('Failed to execute command in container '
676                                '{c.name}.'.format(c=self.container))
677
678     def stop(self):
679         """Stop running container.
680
681         :raises RuntimeError: If stopping a container failed.
682         """
683         cmd = 'docker stop {c.name}'.format(c=self.container)
684
685         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
686         if int(ret) != 0:
687             raise RuntimeError('Failed to stop container {c.name}.'
688                                .format(c=self.container))
689
690     def destroy(self):
691         """Remove a container.
692
693         :raises RuntimeError: If removing a container failed.
694         """
695         cmd = 'docker rm --force {c.name}'.format(c=self.container)
696
697         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
698         if int(ret) != 0:
699             raise RuntimeError('Failed to destroy container {c.name}.'
700                                .format(c=self.container))
701
702     def info(self):
703         """Return low-level information on Docker objects.
704
705         :raises RuntimeError: If getting info about a container failed.
706         """
707         cmd = 'docker inspect {c.name}'.format(c=self.container)
708
709         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
710         if int(ret) != 0:
711             raise RuntimeError('Failed to get info about container {c.name}.'
712                                .format(c=self.container))
713
714     def system_info(self):
715         """Display the docker system-wide information.
716
717         :raises RuntimeError: If displaying system information failed.
718         """
719         cmd = 'docker system info'
720
721         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
722         if int(ret) != 0:
723             raise RuntimeError('Failed to get system info.')
724
725     def is_container_present(self):
726         """Check if container is present on node.
727
728         :returns: True if container is present.
729         :rtype: bool
730         :raises RuntimeError: If getting info about a container failed.
731         """
732         cmd = 'docker ps --all --quiet --filter name={c.name}'\
733             .format(c=self.container)
734
735         ret, stdout, _ = self.container.ssh.exec_command_sudo(cmd)
736         if int(ret) != 0:
737             raise RuntimeError('Failed to get info about container {c.name}.'
738                                .format(c=self.container))
739         return True if stdout else False
740
741     def is_container_running(self):
742         """Check if container is running on node.
743
744         :returns: True if container is running.
745         :rtype: bool
746         :raises RuntimeError: If getting info about a container failed.
747         """
748         cmd = 'docker ps --quiet --filter name={c.name}'\
749             .format(c=self.container)
750
751         ret, stdout, _ = self.container.ssh.exec_command_sudo(cmd)
752         if int(ret) != 0:
753             raise RuntimeError('Failed to get info about container {c.name}.'
754                                .format(c=self.container))
755         return True if stdout else False
756
757
758 class Container(object):
759     """Container class."""
760
761     def __init__(self):
762         """Initialize Container object."""
763         pass
764
765     def __getattr__(self, attr):
766         """Get attribute custom implementation.
767
768         :param attr: Attribute to get.
769         :type attr: str
770         :returns: Attribute value or None.
771         :rtype: any
772         """
773         try:
774             return self.__dict__[attr]
775         except KeyError:
776             return None
777
778     def __setattr__(self, attr, value):
779         """Set attribute custom implementation.
780
781         :param attr: Attribute to set.
782         :param value: Value to set.
783         :type attr: str
784         :type value: any
785         """
786         try:
787             # Check if attribute exists
788             self.__dict__[attr]
789         except KeyError:
790             # Creating new attribute
791             if attr == 'node':
792                 self.__dict__['ssh'] = SSH()
793                 self.__dict__['ssh'].connect(value)
794             self.__dict__[attr] = value
795         else:
796             # Updating attribute base of type
797             if isinstance(self.__dict__[attr], list):
798                 self.__dict__[attr].append(value)
799             else:
800                 self.__dict__[attr] = value

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