ed058b75975d579c80f715138d554b101ee4e58c
[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 = dut_cnt/container_cnt
170
171         for i, container in enumerate(self.containers):
172             self.engine.container = self.containers[container]
173             self.engine.create_vpp_startup_config()
174             self.engine.create_vpp_exec_config(vat_template_file,
175                                                memif_id1=i % mod * 2 + 1,
176                                                memif_id2=i % mod * 2 + 2,
177                                                socket1='memif-{c.name}-1'
178                                                .format(c=self.engine.container),
179                                                socket2='memif-{c.name}-2'
180                                                .format(c=self.engine.container))
181
182     def stop_all_containers(self):
183         """Stop all containers."""
184         for container in self.containers:
185             self.engine.container = self.containers[container]
186             self.engine.stop()
187
188     def destroy_all_containers(self):
189         """Destroy all containers."""
190         for container in self.containers:
191             self.engine.container = self.containers[container]
192             self.engine.destroy()
193
194
195 class ContainerEngine(object):
196     """Abstract class for container engine."""
197
198     def __init__(self):
199         """Init ContainerEngine object."""
200         self.container = None
201
202     def initialize(self):
203         """Initialize container object."""
204         self.container = Container()
205
206     def acquire(self, force):
207         """Acquire/download container.
208
209         :param force: Destroy a container if exists and create.
210         :type force: bool
211         """
212         raise NotImplementedError
213
214     def build(self):
215         """Build container (compile)."""
216         raise NotImplementedError
217
218     def create(self):
219         """Create/deploy container."""
220         raise NotImplementedError
221
222     def execute(self, command):
223         """Execute process inside container.
224
225         :param command: Command to run inside container.
226         :type command: str
227         """
228         raise NotImplementedError
229
230     def stop(self):
231         """Stop container."""
232         raise NotImplementedError
233
234     def destroy(self):
235         """Destroy/remove container."""
236         raise NotImplementedError
237
238     def info(self):
239         """Info about container."""
240         raise NotImplementedError
241
242     def system_info(self):
243         """System info."""
244         raise NotImplementedError
245
246     def install_supervisor(self):
247         """Install supervisord inside a container."""
248         self.execute('sleep 3')
249         self.execute('apt-get update')
250         self.execute('apt-get install -y supervisor')
251         self.execute('echo "{0}" > {1}'
252                      .format(
253                          '[unix_http_server]\n'
254                          'file  = /tmp/supervisor.sock\n\n'
255                          '[rpcinterface:supervisor]\n'
256                          'supervisor.rpcinterface_factory = '
257                          'supervisor.rpcinterface:make_main_rpcinterface\n\n'
258                          '[supervisorctl]\n'
259                          'serverurl = unix:///tmp/supervisor.sock\n\n'
260                          '[supervisord]\n'
261                          'pidfile = /tmp/supervisord.pid\n'
262                          'identifier = supervisor\n'
263                          'directory = /tmp\n'
264                          'logfile=/tmp/supervisord.log\n'
265                          'loglevel=debug\n'
266                          'nodaemon=false\n\n',
267                          SUPERVISOR_CONF))
268         self.execute('supervisord -c {0}'.format(SUPERVISOR_CONF))
269
270     def install_vpp(self, install_dkms=False):
271         """Install VPP inside a container.
272
273         :param install_dkms: If install dkms package. This will impact install
274         time. Dkms is required for installation of vpp-dpdk-dkms. Default is
275         false.
276         :type install_dkms: bool
277         """
278         self.execute('ln -s /dev/null /etc/sysctl.d/80-vpp.conf')
279         self.execute('apt-get update')
280         if install_dkms:
281             self.execute('apt-get install -y dkms && '
282                          'dpkg -i --force-all {0}/install_dir/*.deb'
283                          .format(self.container.guest_dir))
284         else:
285             self.execute('for i in $(ls -I \"*dkms*\" {0}/install_dir/); '
286                          'do dpkg -i --force-all {0}/install_dir/$i; done'
287                          .format(self.container.guest_dir))
288         self.execute('apt-get -f install -y')
289         self.execute('echo "{0}" >> {1}'
290                      .format(
291                          '[program:vpp]\n'
292                          'command=/usr/bin/vpp -c /etc/vpp/startup.conf\n'
293                          'autorestart=false\n'
294                          'redirect_stderr=true\n'
295                          'priority=1',
296                          SUPERVISOR_CONF))
297         self.execute('supervisorctl reload')
298
299     def restart_vpp(self):
300         """Restart VPP service inside a container."""
301         self.execute('supervisorctl restart vpp')
302
303     def create_vpp_startup_config(self,
304                                   config_filename='/etc/vpp/startup.conf'):
305         """Create base startup configuration of VPP on container.
306
307         :param config_filename: Startup configuration file name.
308         :type config_filename: str
309         """
310         cpuset_cpus = self.container.cpuset_cpus
311
312         # Create config instance
313         vpp_config = VppConfigGenerator()
314         vpp_config.set_node(self.container.node)
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=config_filename))
330
331     def create_vpp_exec_config(self, vat_template_file, **kwargs):
332         """Create VPP exec configuration on container.
333
334         :param vat_template_file: File name of a VAT template script.
335         :param kwargs: Parameters for VAT script.
336         :type vat_template_file: str
337         :type kwargs: 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(**kwargs)
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     def _configure_cgroup(self, name):
358         """Configure the control group associated with a container.
359
360         By default the cpuset cgroup is using exclusive CPU/MEM. When Docker
361         container is initialized a new cgroup /docker or /lxc is created under
362         cpuset parent tree. This newly created cgroup is inheriting parent
363         setting for cpu/mem exclusive parameter and thus cannot be overriden
364         within /docker or /lxc cgroup. This patch is supposed to set cpu/mem
365         exclusive parameter for both parent and subgroup.
366
367         :param name: Name of cgroup.
368         :type name: str
369         :raises RuntimeError: If applying cgroup settings via cgset failed.
370         """
371         ret, _, _ = self.container.ssh.exec_command_sudo(
372             'cgset -r cpuset.cpu_exclusive=0 /')
373         if int(ret) != 0:
374             raise RuntimeError('Failed to apply cgroup settings.')
375
376         ret, _, _ = self.container.ssh.exec_command_sudo(
377             'cgset -r cpuset.mem_exclusive=0 /')
378         if int(ret) != 0:
379             raise RuntimeError('Failed to apply cgroup settings.')
380
381         ret, _, _ = self.container.ssh.exec_command_sudo(
382             'cgcreate -g cpuset:/{name}'.format(name=name))
383         if int(ret) != 0:
384             raise RuntimeError('Failed to copy cgroup settings from root.')
385
386         ret, _, _ = self.container.ssh.exec_command_sudo(
387             'cgset -r cpuset.cpu_exclusive=0 /{name}'.format(name=name))
388         if int(ret) != 0:
389             raise RuntimeError('Failed to apply cgroup settings.')
390
391         ret, _, _ = self.container.ssh.exec_command_sudo(
392             'cgset -r cpuset.mem_exclusive=0 /{name}'.format(name=name))
393         if int(ret) != 0:
394             raise RuntimeError('Failed to apply cgroup settings.')
395
396
397 class LXC(ContainerEngine):
398     """LXC implementation."""
399
400     def __init__(self):
401         """Initialize LXC object."""
402         super(LXC, self).__init__()
403
404     def acquire(self, force=True):
405         """Acquire a privileged system object where configuration is stored.
406
407         :param force: If a container exists, destroy it and create a new
408         container.
409         :type force: bool
410         :raises RuntimeError: If creating the container or writing the container
411         config fails.
412         """
413         if self.is_container_present():
414             if force:
415                 self.destroy()
416             else:
417                 return
418
419         image = self.container.image if self.container.image else\
420             "-d ubuntu -r xenial -a amd64"
421
422         cmd = 'lxc-create -t download --name {c.name} -- {image} '\
423             '--no-validate'.format(c=self.container, image=image)
424
425         ret, _, _ = self.container.ssh.exec_command_sudo(cmd, timeout=1800)
426         if int(ret) != 0:
427             raise RuntimeError('Failed to create container.')
428
429         if self.container.host_dir and self.container.guest_dir:
430             entry = 'lxc.mount.entry = '\
431                 '{c.host_dir} /var/lib/lxc/{c.name}/rootfs{c.guest_dir} ' \
432                 'none bind,create=dir 0 0'.format(c=self.container)
433             ret, _, _ = self.container.ssh.exec_command_sudo(
434                 "sh -c 'echo \"{e}\" >> /var/lib/lxc/{c.name}/config'"
435                 .format(e=entry, c=self.container))
436             if int(ret) != 0:
437                 raise RuntimeError('Failed to write {c.name} config.'
438                                    .format(c=self.container))
439         self._configure_cgroup('lxc')
440
441     def create(self):
442         """Create/deploy an application inside a container on system.
443
444         :raises RuntimeError: If creating the container fails.
445         """
446         cpuset_cpus = '{0}'.format(
447             ','.join('%s' % cpu for cpu in self.container.cpuset_cpus))\
448             if self.container.cpuset_cpus else ''
449
450         cmd = 'lxc-start --name {c.name} --daemon'.format(c=self.container)
451
452         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
453         if int(ret) != 0:
454             raise RuntimeError('Failed to start container {c.name}.'
455                                .format(c=self.container))
456         self._lxc_wait('RUNNING')
457
458         # Workaround for LXC to be able to allocate all cpus including isolated.
459         cmd = 'cgset --copy-from / lxc/'
460         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
461         if int(ret) != 0:
462             raise RuntimeError('Failed to copy cgroup to LXC')
463
464         cmd = 'lxc-cgroup --name {c.name} cpuset.cpus {cpus}'\
465             .format(c=self.container, cpus=cpuset_cpus)
466         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
467         if int(ret) != 0:
468             raise RuntimeError('Failed to set cpuset.cpus to container '
469                                '{c.name}.'.format(c=self.container))
470
471     def execute(self, command):
472         """Start a process inside a running container.
473
474         Runs the specified command inside the container specified by name. The
475         container has to be running already.
476
477         :param command: Command to run inside container.
478         :type command: str
479         :raises RuntimeError: If running the command failed.
480         """
481         env = '--keep-env {0}'.format(
482             ' '.join('--set-var %s' % env for env in self.container.env))\
483             if self.container.env else ''
484
485         cmd = "lxc-attach {env} --name {c.name} -- /bin/sh -c '{command}'"\
486             .format(env=env, c=self.container, command=command)
487
488         ret, _, _ = self.container.ssh.exec_command_sudo(cmd, timeout=180)
489         if int(ret) != 0:
490             raise RuntimeError('Failed to run command inside container '
491                                '{c.name}.'.format(c=self.container))
492
493     def stop(self):
494         """Stop a container.
495
496         :raises RuntimeError: If stopping the container failed.
497         """
498         cmd = 'lxc-stop --name {c.name}'.format(c=self.container)
499
500         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
501         if int(ret) != 0:
502             raise RuntimeError('Failed to stop container {c.name}.'
503                                .format(c=self.container))
504         self._lxc_wait('STOPPED|FROZEN')
505
506     def destroy(self):
507         """Destroy a container.
508
509         :raises RuntimeError: If destroying container failed.
510         """
511         cmd = 'lxc-destroy --force --name {c.name}'.format(c=self.container)
512
513         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
514         if int(ret) != 0:
515             raise RuntimeError('Failed to destroy container {c.name}.'
516                                .format(c=self.container))
517
518     def info(self):
519         """Query and shows information about a container.
520
521         :raises RuntimeError: If getting info about a container failed.
522         """
523         cmd = 'lxc-info --name {c.name}'.format(c=self.container)
524
525         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
526         if int(ret) != 0:
527             raise RuntimeError('Failed to get info about container {c.name}.'
528                                .format(c=self.container))
529
530     def system_info(self):
531         """Check the current kernel for LXC support.
532
533         :raises RuntimeError: If checking LXC support failed.
534         """
535         cmd = 'lxc-checkconfig'
536
537         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
538         if int(ret) != 0:
539             raise RuntimeError('Failed to check LXC support.')
540
541     def is_container_running(self):
542         """Check if container is running on node.
543
544         :returns: True if container is running.
545         :rtype: bool
546         :raises RuntimeError: If getting info about a container failed.
547         """
548         cmd = 'lxc-info --no-humanize --state --name {c.name}'\
549             .format(c=self.container)
550
551         ret, stdout, _ = self.container.ssh.exec_command_sudo(cmd)
552         if int(ret) != 0:
553             raise RuntimeError('Failed to get info about container {c.name}.'
554                                .format(c=self.container))
555         return True if 'RUNNING' in stdout else False
556
557     def is_container_present(self):
558         """Check if container is existing on node.
559
560         :returns: True if container is present.
561         :rtype: bool
562         :raises RuntimeError: If getting info about a container failed.
563         """
564         cmd = 'lxc-info --no-humanize --name {c.name}'.format(c=self.container)
565
566         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
567         return False if int(ret) else True
568
569     def _lxc_wait(self, state):
570         """Wait for a specific container state.
571
572         :param state: Specify the container state(s) to wait for.
573         :type state: str
574         :raises RuntimeError: If waiting for state of a container failed.
575         """
576         cmd = 'lxc-wait --name {c.name} --state "{s}"'\
577             .format(c=self.container, s=state)
578
579         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
580         if int(ret) != 0:
581             raise RuntimeError('Failed to wait for state "{s}" of container '
582                                '{c.name}.'.format(s=state, c=self.container))
583
584
585 class Docker(ContainerEngine):
586     """Docker implementation."""
587
588     def __init__(self):
589         """Initialize Docker object."""
590         super(Docker, self).__init__()
591
592     def acquire(self, force=True):
593         """Pull an image or a repository from a registry.
594
595         :param force: Destroy a container if exists.
596         :type force: bool
597         :raises RuntimeError: If pulling a container failed.
598         """
599         if self.is_container_present():
600             if force:
601                 self.destroy()
602             else:
603                 return
604
605         cmd = 'docker pull {c.image}'.format(c=self.container)
606
607         ret, _, _ = self.container.ssh.exec_command_sudo(cmd, timeout=1800)
608         if int(ret) != 0:
609             raise RuntimeError('Failed to create container {c.name}.'
610                                .format(c=self.container))
611         self._configure_cgroup('docker')
612
613     def create(self):
614         """Create/deploy container.
615
616         :raises RuntimeError: If creating a container failed.
617         """
618         cpuset_cpus = '--cpuset-cpus={0}'.format(
619             ','.join('%s' % cpu for cpu in self.container.cpuset_cpus))\
620             if self.container.cpuset_cpus else ''
621
622         cpuset_mems = '--cpuset-mems={0}'.format(self.container.cpuset_mems)\
623             if self.container.cpuset_mems is not None else ''
624
625         env = '{0}'.format(
626             ' '.join('--env %s' % env for env in self.container.env))\
627             if self.container.env else ''
628
629         command = '{0}'.format(self.container.command)\
630             if self.container.command else ''
631
632         publish = '{0}'.format(
633             ' '.join('--publish %s' % var for var in self.container.publish))\
634             if self.container.publish else ''
635
636         volume = '--volume {c.host_dir}:{c.guest_dir}'.format(c=self.container)\
637             if self.container.host_dir and self.container.guest_dir else ''
638
639         cmd = 'docker run '\
640             '--privileged --detach --interactive --tty --rm '\
641             '--cgroup-parent docker {cpuset_cpus} {cpuset_mems} {publish} '\
642             '{env} {volume} --name {container.name} {container.image} '\
643             '{command}'.format(cpuset_cpus=cpuset_cpus, cpuset_mems=cpuset_mems,
644                                container=self.container, command=command,
645                                env=env, publish=publish, volume=volume)
646
647         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
648         if int(ret) != 0:
649             raise RuntimeError('Failed to create container {c.name}'
650                                .format(c=self.container))
651
652         self.info()
653
654     def execute(self, command):
655         """Start a process inside a running container.
656
657         Runs the specified command inside the container specified by name. The
658         container has to be running already.
659
660         :param command: Command to run inside container.
661         :type command: str
662         :raises RuntimeError: If runnig the command in a container failed.
663         """
664         cmd = "docker exec --interactive {c.name} /bin/sh -c '{command}'"\
665             .format(c=self.container, command=command)
666
667         ret, _, _ = self.container.ssh.exec_command_sudo(cmd, timeout=180)
668         if int(ret) != 0:
669             raise RuntimeError('Failed to execute command in container '
670                                '{c.name}.'.format(c=self.container))
671
672     def stop(self):
673         """Stop running container.
674
675         :raises RuntimeError: If stopping a container failed.
676         """
677         cmd = 'docker stop {c.name}'.format(c=self.container)
678
679         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
680         if int(ret) != 0:
681             raise RuntimeError('Failed to stop container {c.name}.'
682                                .format(c=self.container))
683
684     def destroy(self):
685         """Remove a container.
686
687         :raises RuntimeError: If removing a container failed.
688         """
689         cmd = 'docker rm --force {c.name}'.format(c=self.container)
690
691         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
692         if int(ret) != 0:
693             raise RuntimeError('Failed to destroy container {c.name}.'
694                                .format(c=self.container))
695
696     def info(self):
697         """Return low-level information on Docker objects.
698
699         :raises RuntimeError: If getting info about a container failed.
700         """
701         cmd = 'docker inspect {c.name}'.format(c=self.container)
702
703         ret, _, _ = 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
708     def system_info(self):
709         """Display the docker system-wide information.
710
711         :raises RuntimeError: If displaying system information failed.
712         """
713         cmd = 'docker system info'
714
715         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
716         if int(ret) != 0:
717             raise RuntimeError('Failed to get system info.')
718
719     def is_container_present(self):
720         """Check if container is present on node.
721
722         :returns: True if container is present.
723         :rtype: bool
724         :raises RuntimeError: If getting info about a container failed.
725         """
726         cmd = 'docker ps --all --quiet --filter name={c.name}'\
727             .format(c=self.container)
728
729         ret, stdout, _ = self.container.ssh.exec_command_sudo(cmd)
730         if int(ret) != 0:
731             raise RuntimeError('Failed to get info about container {c.name}.'
732                                .format(c=self.container))
733         return True if stdout else False
734
735     def is_container_running(self):
736         """Check if container is running on node.
737
738         :returns: True if container is running.
739         :rtype: bool
740         :raises RuntimeError: If getting info about a container failed.
741         """
742         cmd = 'docker ps --quiet --filter name={c.name}'\
743             .format(c=self.container)
744
745         ret, stdout, _ = self.container.ssh.exec_command_sudo(cmd)
746         if int(ret) != 0:
747             raise RuntimeError('Failed to get info about container {c.name}.'
748                                .format(c=self.container))
749         return True if stdout else False
750
751
752 class Container(object):
753     """Container class."""
754
755     def __init__(self):
756         """Initialize Container object."""
757         pass
758
759     def __getattr__(self, attr):
760         """Get attribute custom implementation.
761
762         :param attr: Attribute to get.
763         :type attr: str
764         :returns: Attribute value or None.
765         :rtype: any
766         """
767         try:
768             return self.__dict__[attr]
769         except KeyError:
770             return None
771
772     def __setattr__(self, attr, value):
773         """Set attribute custom implementation.
774
775         :param attr: Attribute to set.
776         :param value: Value to set.
777         :type attr: str
778         :type value: any
779         """
780         try:
781             # Check if attribute exists
782             self.__dict__[attr]
783         except KeyError:
784             # Creating new attribute
785             if attr == 'node':
786                 self.__dict__['ssh'] = SSH()
787                 self.__dict__['ssh'].connect(value)
788             self.__dict__[attr] = value
789         else:
790             # Updating attribute base of type
791             if isinstance(self.__dict__[attr], list):
792                 self.__dict__[attr].append(value)
793             else:
794                 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.