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         :param name: Name of cgroup.
 361         :type name: str
 362         :raises RuntimeError: If applying cgroup settings via cgset failed.
 363         """
 364         ret, _, _ = self.container.ssh.exec_command_sudo(
 365             'cgcreate -g cpuset:/{name}'.format(name=name))
 366         if int(ret) != 0:
 367             raise RuntimeError('Failed to copy cgroup settings from root.')
 368
 369         ret, _, _ = self.container.ssh.exec_command_sudo(
 370             'cgset -r cpuset.cpu_exclusive=0 /{name}'.format(name=name))
 371         if int(ret) != 0:
 372             raise RuntimeError('Failed to apply cgroup settings.')
 373
 374         ret, _, _ = self.container.ssh.exec_command_sudo(
 375             'cgset -r cpuset.mem_exclusive=0 /{name}'.format(name=name))
 376         if int(ret) != 0:
 377             raise RuntimeError('Failed to apply cgroup settings.')
 378
 379
 380 class LXC(ContainerEngine):
 381     """LXC implementation."""
 382
 383     def __init__(self):
 384         """Initialize LXC object."""
 385         super(LXC, self).__init__()
 386
 387     def acquire(self, force=True):
 388         """Acquire a privileged system object where configuration is stored.
 389
 390         :param force: If a container exists, destroy it and create a new
 391         container.
 392         :type force: bool
 393         :raises RuntimeError: If creating the container or writing the container
 394         config fails.
 395         """
 396         if self.is_container_present():
 397             if force:
 398                 self.destroy()
 399             else:
 400                 return
 401
 402         image = self.container.image if self.container.image else\
 403             "-d ubuntu -r xenial -a amd64"
 404
 405         cmd = 'lxc-create -t download --name {c.name} -- {image} '\
 406             '--no-validate'.format(c=self.container, image=image)
 407
 408         ret, _, _ = self.container.ssh.exec_command_sudo(cmd, timeout=1800)
 409         if int(ret) != 0:
 410             raise RuntimeError('Failed to create container.')
 411
 412         if self.container.host_dir and self.container.guest_dir:
 413             entry = 'lxc.mount.entry = '\
 414                 '{c.host_dir} /var/lib/lxc/{c.name}/rootfs{c.guest_dir} ' \
 415                 'none bind,create=dir 0 0'.format(c=self.container)
 416             ret, _, _ = self.container.ssh.exec_command_sudo(
 417                 "sh -c 'echo \"{e}\" >> /var/lib/lxc/{c.name}/config'"
 418                 .format(e=entry, c=self.container))
 419             if int(ret) != 0:
 420                 raise RuntimeError('Failed to write {c.name} config.'
 421                                    .format(c=self.container))
 422         self._configure_cgroup('lxc')
 423
 424     def create(self):
 425         """Create/deploy an application inside a container on system.
 426
 427         :raises RuntimeError: If creating the container fails.
 428         """
 429         cpuset_cpus = '{0}'.format(
 430             ','.join('%s' % cpu for cpu in self.container.cpuset_cpus))\
 431             if self.container.cpuset_cpus else ''
 432
 433         cmd = 'lxc-start --name {c.name} --daemon'.format(c=self.container)
 434
 435         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
 436         if int(ret) != 0:
 437             raise RuntimeError('Failed to start container {c.name}.'
 438                                .format(c=self.container))
 439         self._lxc_wait('RUNNING')
 440
 441         # Workaround for LXC to be able to allocate all cpus including isolated.
 442         cmd = 'cgset --copy-from / lxc/'
 443         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
 444         if int(ret) != 0:
 445             raise RuntimeError('Failed to copy cgroup to LXC')
 446
 447         cmd = 'lxc-cgroup --name {c.name} cpuset.cpus {cpus}'\
 448             .format(c=self.container, cpus=cpuset_cpus)
 449         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
 450         if int(ret) != 0:
 451             raise RuntimeError('Failed to set cpuset.cpus to container '
 452                                '{c.name}.'.format(c=self.container))
 453
 454     def execute(self, command):
 455         """Start a process inside a running container.
 456
 457         Runs the specified command inside the container specified by name. The
 458         container has to be running already.
 459
 460         :param command: Command to run inside container.
 461         :type command: str
 462         :raises RuntimeError: If running the command failed.
 463         """
 464         env = '--keep-env {0}'.format(
 465             ' '.join('--set-var %s' % env for env in self.container.env))\
 466             if self.container.env else ''
 467
 468         cmd = "lxc-attach {env} --name {c.name} -- /bin/sh -c '{command}'"\
 469             .format(env=env, c=self.container, command=command)
 470
 471         ret, _, _ = self.container.ssh.exec_command_sudo(cmd, timeout=180)
 472         if int(ret) != 0:
 473             raise RuntimeError('Failed to run command inside container '
 474                                '{c.name}.'.format(c=self.container))
 475
 476     def stop(self):
 477         """Stop a container.
 478
 479         :raises RuntimeError: If stopping the container failed.
 480         """
 481         cmd = 'lxc-stop --name {c.name}'.format(c=self.container)
 482
 483         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
 484         if int(ret) != 0:
 485             raise RuntimeError('Failed to stop container {c.name}.'
 486                                .format(c=self.container))
 487         self._lxc_wait('STOPPED|FROZEN')
 488
 489     def destroy(self):
 490         """Destroy a container.
 491
 492         :raises RuntimeError: If destroying container failed.
 493         """
 494         cmd = 'lxc-destroy --force --name {c.name}'.format(c=self.container)
 495
 496         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
 497         if int(ret) != 0:
 498             raise RuntimeError('Failed to destroy container {c.name}.'
 499                                .format(c=self.container))
 500
 501     def info(self):
 502         """Query and shows information about a container.
 503
 504         :raises RuntimeError: If getting info about a container failed.
 505         """
 506         cmd = 'lxc-info --name {c.name}'.format(c=self.container)
 507
 508         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
 509         if int(ret) != 0:
 510             raise RuntimeError('Failed to get info about container {c.name}.'
 511                                .format(c=self.container))
 512
 513     def system_info(self):
 514         """Check the current kernel for LXC support.
 515
 516         :raises RuntimeError: If checking LXC support failed.
 517         """
 518         cmd = 'lxc-checkconfig'
 519
 520         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
 521         if int(ret) != 0:
 522             raise RuntimeError('Failed to check LXC support.')
 523
 524     def is_container_running(self):
 525         """Check if container is running on node.
 526
 527         :returns: True if container is running.
 528         :rtype: bool
 529         :raises RuntimeError: If getting info about a container failed.
 530         """
 531         cmd = 'lxc-info --no-humanize --state --name {c.name}'\
 532             .format(c=self.container)
 533
 534         ret, stdout, _ = self.container.ssh.exec_command_sudo(cmd)
 535         if int(ret) != 0:
 536             raise RuntimeError('Failed to get info about container {c.name}.'
 537                                .format(c=self.container))
 538         return True if 'RUNNING' in stdout else False
 539
 540     def is_container_present(self):
 541         """Check if container is existing on node.
 542
 543         :returns: True if container is present.
 544         :rtype: bool
 545         :raises RuntimeError: If getting info about a container failed.
 546         """
 547         cmd = 'lxc-info --no-humanize --name {c.name}'.format(c=self.container)
 548
 549         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
 550         return False if int(ret) else True
 551
 552     def _lxc_wait(self, state):
 553         """Wait for a specific container state.
 554
 555         :param state: Specify the container state(s) to wait for.
 556         :type state: str
 557         :raises RuntimeError: If waiting for state of a container failed.
 558         """
 559         cmd = 'lxc-wait --name {c.name} --state "{s}"'\
 560             .format(c=self.container, s=state)
 561
 562         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
 563         if int(ret) != 0:
 564             raise RuntimeError('Failed to wait for state "{s}" of container '
 565                                '{c.name}.'.format(s=state, c=self.container))
 566
 567
 568 class Docker(ContainerEngine):
 569     """Docker implementation."""
 570
 571     def __init__(self):
 572         """Initialize Docker object."""
 573         super(Docker, self).__init__()
 574
 575     def acquire(self, force=True):
 576         """Pull an image or a repository from a registry.
 577
 578         :param force: Destroy a container if exists.
 579         :type force: bool
 580         :raises RuntimeError: If pulling a container failed.
 581         """
 582         if self.is_container_present():
 583             if force:
 584                 self.destroy()
 585             else:
 586                 return
 587
 588         cmd = 'docker pull {c.image}'.format(c=self.container)
 589
 590         ret, _, _ = self.container.ssh.exec_command_sudo(cmd, timeout=1800)
 591         if int(ret) != 0:
 592             raise RuntimeError('Failed to create container {c.name}.'
 593                                .format(c=self.container))
 594         self._configure_cgroup('docker')
 595
 596     def create(self):
 597         """Create/deploy container.
 598
 599         :raises RuntimeError: If creating a container failed.
 600         """
 601         cpuset_cpus = '--cpuset-cpus={0}'.format(
 602             ','.join('%s' % cpu for cpu in self.container.cpuset_cpus))\
 603             if self.container.cpuset_cpus else ''
 604
 605         cpuset_mems = '--cpuset-mems={0}'.format(self.container.cpuset_mems)\
 606             if self.container.cpuset_mems is not None else ''
 607
 608         env = '{0}'.format(
 609             ' '.join('--env %s' % env for env in self.container.env))\
 610             if self.container.env else ''
 611
 612         command = '{0}'.format(self.container.command)\
 613             if self.container.command else ''
 614
 615         publish = '{0}'.format(
 616             ' '.join('--publish %s' % var for var in self.container.publish))\
 617             if self.container.publish else ''
 618
 619         volume = '--volume {c.host_dir}:{c.guest_dir}'.format(c=self.container)\
 620             if self.container.host_dir and self.container.guest_dir else ''
 621
 622         cmd = 'docker run '\
 623             '--privileged --detach --interactive --tty --rm '\
 624             '--cgroup-parent docker {cpuset_cpus} {cpuset_mems} {publish} '\
 625             '{env} {volume} --name {container.name} {container.image} '\
 626             '{command}'.format(cpuset_cpus=cpuset_cpus, cpuset_mems=cpuset_mems,
 627                                container=self.container, command=command,
 628                                env=env, publish=publish, volume=volume)
 629
 630         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
 631         if int(ret) != 0:
 632             raise RuntimeError('Failed to create container {c.name}'
 633                                .format(c=self.container))
 634
 635         self.info()
 636
 637     def execute(self, command):
 638         """Start a process inside a running container.
 639
 640         Runs the specified command inside the container specified by name. The
 641         container has to be running already.
 642
 643         :param command: Command to run inside container.
 644         :type command: str
 645         :raises RuntimeError: If runnig the command in a container failed.
 646         """
 647         cmd = "docker exec --interactive {c.name} /bin/sh -c '{command}'"\
 648             .format(c=self.container, command=command)
 649
 650         ret, _, _ = self.container.ssh.exec_command_sudo(cmd, timeout=180)
 651         if int(ret) != 0:
 652             raise RuntimeError('Failed to execute command in container '
 653                                '{c.name}.'.format(c=self.container))
 654
 655     def stop(self):
 656         """Stop running container.
 657
 658         :raises RuntimeError: If stopping a container failed.
 659         """
 660         cmd = 'docker stop {c.name}'.format(c=self.container)
 661
 662         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
 663         if int(ret) != 0:
 664             raise RuntimeError('Failed to stop container {c.name}.'
 665                                .format(c=self.container))
 666
 667     def destroy(self):
 668         """Remove a container.
 669
 670         :raises RuntimeError: If removing a container failed.
 671         """
 672         cmd = 'docker rm --force {c.name}'.format(c=self.container)
 673
 674         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
 675         if int(ret) != 0:
 676             raise RuntimeError('Failed to destroy container {c.name}.'
 677                                .format(c=self.container))
 678
 679     def info(self):
 680         """Return low-level information on Docker objects.
 681
 682         :raises RuntimeError: If getting info about a container failed.
 683         """
 684         cmd = 'docker inspect {c.name}'.format(c=self.container)
 685
 686         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
 687         if int(ret) != 0:
 688             raise RuntimeError('Failed to get info about container {c.name}.'
 689                                .format(c=self.container))
 690
 691     def system_info(self):
 692         """Display the docker system-wide information.
 693
 694         :raises RuntimeError: If displaying system information failed.
 695         """
 696         cmd = 'docker system info'
 697
 698         ret, _, _ = self.container.ssh.exec_command_sudo(cmd)
 699         if int(ret) != 0:
 700             raise RuntimeError('Failed to get system info.')
 701
 702     def is_container_present(self):
 703         """Check if container is present on node.
 704
 705         :returns: True if container is present.
 706         :rtype: bool
 707         :raises RuntimeError: If getting info about a container failed.
 708         """
 709         cmd = 'docker ps --all --quiet --filter name={c.name}'\
 710             .format(c=self.container)
 711
 712         ret, stdout, _ = self.container.ssh.exec_command_sudo(cmd)
 713         if int(ret) != 0:
 714             raise RuntimeError('Failed to get info about container {c.name}.'
 715                                .format(c=self.container))
 716         return True if stdout else False
 717
 718     def is_container_running(self):
 719         """Check if container is running on node.
 720
 721         :returns: True if container is running.
 722         :rtype: bool
 723         :raises RuntimeError: If getting info about a container failed.
 724         """
 725         cmd = 'docker ps --quiet --filter name={c.name}'\
 726             .format(c=self.container)
 727
 728         ret, stdout, _ = self.container.ssh.exec_command_sudo(cmd)
 729         if int(ret) != 0:
 730             raise RuntimeError('Failed to get info about container {c.name}.'
 731                                .format(c=self.container))
 732         return True if stdout else False
 733
 734
 735 class Container(object):
 736     """Container class."""
 737
 738     def __init__(self):
 739         """Initialize Container object."""
 740         pass
 741
 742     def __getattr__(self, attr):
 743         """Get attribute custom implementation.
 744
 745         :param attr: Attribute to get.
 746         :type attr: str
 747         :returns: Attribute value or None.
 748         :rtype: any
 749         """
 750         try:
 751             return self.__dict__[attr]
 752         except KeyError:
 753             return None
 754
 755     def __setattr__(self, attr, value):
 756         """Set attribute custom implementation.
 757
 758         :param attr: Attribute to set.
 759         :param value: Value to set.
 760         :type attr: str
 761         :type value: any
 762         """
 763         try:
 764             # Check if attribute exists
 765             self.__dict__[attr]
 766         except KeyError:
 767             # Creating new attribute
 768             if attr == 'node':
 769                 self.__dict__['ssh'] = SSH()
 770                 self.__dict__['ssh'].connect(value)
 771             self.__dict__[attr] = value
 772         else:
 773             # Updating attribute base of type
 774             if isinstance(self.__dict__[attr], list):
 775                 self.__dict__[attr].append(value)
 776             else:
 777                 self.__dict__[attr] = value