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