docker/docker-toool

   1 #!/usr/bin/env python
   2 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
   3 #    not use this file except in compliance with the License. You may obtain
   4 #    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, WITHOUT
  10 #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  11 #    License for the specific language governing permissions and limitations
  12 #    under the License.
  13
  14 import argparse
  15 import os
  16 import shutil
  17 import sys
  18 import json
  19
  20 docker_cmd = '/bin/docker'
  21
  22 # Tool to start docker containers as configured via
  23 # tripleo-heat-templates.
  24 #
  25 # This tool reads data from a json file generated from heat when the
  26 # TripleO stack is run.  All the configuration data used to start the
  27 # containerized services is in this file.
  28 #
  29 # By default this tool lists all the containers that are started and
  30 # their start order.
  31 #
  32 # If you wish to see the command line used to start a given container,
  33 # specify it by name using the --container argument.  --run can then be
  34 # used with this to actually execute docker to run the container.\n
  35 #
  36 # Other options listed allow you to modify this command line for
  37 # debugging purposes.  For example:
  38 #
  39 # docker-toool -c swift-proxy -r -e /bin/bash -u root -i -n test
  40 #
  41 # will run the swift proxy container as user root, executing /bin/bash,
  42 #
  43 # named 'test', and will run interactively (eg -ti).
  44
  45
  46 def parse_opts(argv):
  47     parser = argparse.ArgumentParser("Tool to start docker containers via "
  48                                      "TripleO configurations")
  49     parser.add_argument('-f', '--config',
  50                         help="""File to use as docker startup configuration data.""",
  51                         default='/var/lib/docker-container-startup-configs.json')
  52     parser.add_argument('-r', '--run',
  53                         action='store_true',
  54                         help="""Run the container as specified with --container.""",
  55                         default=False)
  56     parser.add_argument('-e', '--command',
  57                         help="""Override the command used to run the container.""",
  58                         default='')
  59     parser.add_argument('-c', '--container',
  60                         help="""Specify a container to run or show the command for.""",
  61                         default='')
  62     parser.add_argument('-u', '--user',
  63                         help="""User to run container as.""",
  64                         default='')
  65     parser.add_argument('-n', '--name',
  66                         help="""Name of container.""",
  67                         default='')
  68     parser.add_argument('-i', '--interactive',
  69                         action='store_true',
  70                         help="""Start docker container interactively (-ti).""",
  71                         default=False)
  72     parser.add_argument('-d', '--detach',
  73                         action='store_true',
  74                         help="""Start container detached.""",
  75                         default=False)
  76     opts = parser.parse_args(argv[1:])
  77
  78     return opts
  79
  80
  81 def docker_arg_map(key, value):
  82     value = str(value).encode('ascii', 'ignore')
  83     return {
  84         'environment': "--env=%s" % value,
  85         # 'image': value,
  86         'net': "--net=%s" % value,
  87         'pid': "--pid=%s" % value,
  88         'privileged': "--privileged=%s" % value.lower(),
  89         'user': "--user=%s" % value,
  90         'volumes': "--volume=%s" % value,
  91         'volumes_from': "--volumes-from=%s" % value,
  92     }.get(key, None)
  93
  94
  95 def run_docker_container(opts, container_name):
  96     container_found = False
  97
  98     with open(opts.config) as f:
  99         json_data = json.load(f)
 100
 101     for step in (json_data or []):
 102         if step is None:
 103             continue
 104         for container in (json_data[step] or []):
 105             if container == container_name:
 106                 print('container found: %s' % container)
 107                 container_found = True
 108                 # A few positional arguments:
 109                 command = ''
 110                 image = ''
 111
 112                 cmd = [
 113                     docker_cmd,
 114                     'run',
 115                     '--name',
 116                     opts.name or container
 117                 ]
 118                 for container_data in (json_data[step][container] or []):
 119                     if container_data == "environment":
 120                         for env in (json_data[step][container][container_data] or []):
 121                             arg = docker_arg_map("environment", env)
 122                             if arg:
 123                                 cmd.append(arg)
 124                     elif container_data == "volumes":
 125                         for volume in (json_data[step][container][container_data] or []):
 126                             arg = docker_arg_map("volumes", volume)
 127                             if arg:
 128                                 cmd.append(arg)
 129                     elif container_data == "volumes_from":
 130                         for volume in (json_data[step][container][container_data] or []):
 131                             arg = docker_arg_map("volumes_from", volume)
 132                             if arg:
 133                                 cmd.append(arg)
 134                     elif container_data == 'command':
 135                         command = json_data[step][container][container_data]
 136                     elif container_data == 'image':
 137                         image = json_data[step][container][container_data]
 138                     else:
 139                         # Only add a restart if we're not interactive
 140                         if container_data == 'restart':
 141                             if opts.interactive:
 142                                 continue
 143                         if container_data == 'user':
 144                             if opts.user:
 145                                 continue
 146                         arg = docker_arg_map(container_data,
 147                                              json_data[step][container][container_data])
 148                         if arg:
 149                             cmd.append(arg)
 150
 151                 if opts.user:
 152                     cmd.append('--user')
 153                     cmd.append(opts.user)
 154                 if opts.detach:
 155                     cmd.append('--detach')
 156                 if opts.interactive:
 157                     cmd.append('-ti')
 158                     # May as well remove it when we're done too
 159                     cmd.append('--rm')
 160                 cmd.append(image)
 161                 if opts.command:
 162                     cmd.append(opts.command)
 163                 elif command:
 164                     cmd.extend(command)
 165
 166                 print ' '.join(cmd)
 167
 168                 if opts.run:
 169                     os.execl(docker_cmd, *cmd)
 170
 171     if not container_found:
 172         print("Container '%s' not found!" % container_name)
 173
 174
 175 def list_docker_containers(opts):
 176     with open(opts.config) as f:
 177         json_data = json.load(f)
 178
 179     for step in (json_data or []):
 180         if step is None:
 181             continue
 182         for container in (json_data[step] or []):
 183             print('\tcontainer: %s' % container)
 184             for container_data in (json_data[step][container] or []):
 185                 if container_data == "start_order":
 186                     print('\t\tstart_order: %s' % json_data[step][container][container_data])
 187
 188 opts = parse_opts(sys.argv)
 189
 190 if opts.container:
 191     run_docker_container(opts, opts.container)
 192 else:
 193     list_docker_containers(opts)