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