sdk/python/tests/run_test_server.py

   1 #!/usr/bin/env python
   2
   3 from __future__ import print_function
   4 import argparse
   5 import atexit
   6 import errno
   7 import httplib2
   8 import os
   9 import pipes
  10 import random
  11 import re
  12 import shutil
  13 import signal
  14 import socket
  15 import subprocess
  16 import string
  17 import sys
  18 import tempfile
  19 import time
  20 import unittest
  21 import yaml
  22
  23 MY_DIRNAME = os.path.dirname(os.path.realpath(__file__))
  24 if __name__ == '__main__' and os.path.exists(
  25       os.path.join(MY_DIRNAME, '..', 'arvados', '__init__.py')):
  26     # We're being launched to support another test suite.
  27     # Add the Python SDK source to the library path.
  28     sys.path.insert(1, os.path.dirname(MY_DIRNAME))
  29
  30 import arvados
  31 import arvados.config
  32
  33 ARVADOS_DIR = os.path.realpath(os.path.join(MY_DIRNAME, '../../..'))
  34 SERVICES_SRC_DIR = os.path.join(ARVADOS_DIR, 'services')
  35 if 'GOPATH' in os.environ:
  36     gopaths = os.environ['GOPATH'].split(':')
  37     gobins = [os.path.join(path, 'bin') for path in gopaths]
  38     os.environ['PATH'] = ':'.join(gobins) + ':' + os.environ['PATH']
  39
  40 TEST_TMPDIR = os.path.join(ARVADOS_DIR, 'tmp')
  41 if not os.path.exists(TEST_TMPDIR):
  42     os.mkdir(TEST_TMPDIR)
  43
  44 my_api_host = None
  45 _cached_config = {}
  46
  47 def find_server_pid(PID_PATH, wait=10):
  48     now = time.time()
  49     timeout = now + wait
  50     good_pid = False
  51     while (not good_pid) and (now <= timeout):
  52         time.sleep(0.2)
  53         try:
  54             with open(PID_PATH, 'r') as f:
  55                 server_pid = int(f.read())
  56             good_pid = (os.kill(server_pid, 0) is None)
  57         except EnvironmentError:
  58             good_pid = False
  59         now = time.time()
  60
  61     if not good_pid:
  62         return None
  63
  64     return server_pid
  65
  66 def kill_server_pid(pidfile, wait=10, passenger_root=False):
  67     # Must re-import modules in order to work during atexit
  68     import os
  69     import signal
  70     import subprocess
  71     import time
  72
  73     now = time.time()
  74     startTERM = now
  75     deadline = now + wait
  76
  77     if passenger_root:
  78         # First try to shut down nicely
  79         restore_cwd = os.getcwd()
  80         os.chdir(passenger_root)
  81         subprocess.call([
  82             'bundle', 'exec', 'passenger', 'stop', '--pid-file', pidfile])
  83         os.chdir(restore_cwd)
  84         # Use up to half of the +wait+ period waiting for "passenger
  85         # stop" to work. If the process hasn't exited by then, start
  86         # sending TERM signals.
  87         startTERM += wait/2
  88
  89     server_pid = None
  90     while now <= deadline and server_pid is None:
  91         try:
  92             with open(pidfile, 'r') as f:
  93                 server_pid = int(f.read())
  94         except IOError:
  95             # No pidfile = nothing to kill.
  96             return
  97         except ValueError as error:
  98             # Pidfile exists, but we can't parse it. Perhaps the
  99             # server has created the file but hasn't written its PID
 100             # yet?
 101             print("Parse error reading pidfile {}: {}".format(pidfile, error))
 102             time.sleep(0.1)
 103             now = time.time()
 104
 105     while now <= deadline:
 106         try:
 107             exited, _ = os.waitpid(server_pid, os.WNOHANG)
 108             if exited > 0:
 109                 return
 110         except OSError:
 111             # already exited, or isn't our child process
 112             pass
 113         try:
 114             if now >= startTERM:
 115                 os.kill(server_pid, signal.SIGTERM)
 116                 print("Sent SIGTERM to {} ({})".format(server_pid, pidfile))
 117         except OSError as error:
 118             if error.errno == errno.ESRCH:
 119                 # Thrown by os.getpgid() or os.kill() if the process
 120                 # does not exist, i.e., our work here is done.
 121                 return
 122             raise
 123         time.sleep(0.1)
 124         now = time.time()
 125
 126     print("Server PID {} ({}) did not exit, giving up after {}s".
 127           format(server_pid, pidfile, wait))
 128
 129 def find_available_port():
 130     """Return an IPv4 port number that is not in use right now.
 131
 132     We assume whoever needs to use the returned port is able to reuse
 133     a recently used port without waiting for TIME_WAIT (see
 134     SO_REUSEADDR / SO_REUSEPORT).
 135
 136     Some opportunity for races here, but it's better than choosing
 137     something at random and not checking at all. If all of our servers
 138     (hey Passenger) knew that listening on port 0 was a thing, the OS
 139     would take care of the races, and this wouldn't be needed at all.
 140     """
 141
 142     sock = socket.socket()
 143     sock.bind(('0.0.0.0', 0))
 144     port = sock.getsockname()[1]
 145     sock.close()
 146     return port
 147
 148 def _wait_until_port_listens(port, timeout=10):
 149     """Wait for a process to start listening on the given port.
 150
 151     If nothing listens on the port within the specified timeout (given
 152     in seconds), print a warning on stderr before returning.
 153     """
 154     try:
 155         subprocess.check_output(['which', 'lsof'])
 156     except subprocess.CalledProcessError:
 157         print("WARNING: No `lsof` -- cannot wait for port to listen. "+
 158               "Sleeping 0.5 and hoping for the best.")
 159         time.sleep(0.5)
 160         return
 161     deadline = time.time() + timeout
 162     while time.time() < deadline:
 163         try:
 164             subprocess.check_output(
 165                 ['lsof', '-t', '-i', 'tcp:'+str(port)])
 166         except subprocess.CalledProcessError:
 167             time.sleep(0.1)
 168             continue
 169         return
 170     print(
 171         "WARNING: Nothing is listening on port {} (waited {} seconds).".
 172         format(port, timeout),
 173         file=sys.stderr)
 174
 175 def _fifo2stderr(label):
 176     """Create a fifo, and copy it to stderr, prepending label to each line.
 177
 178     Return value is the path to the new FIFO.
 179
 180     +label+ should contain only alphanumerics: it is also used as part
 181     of the FIFO filename.
 182     """
 183     fifo = os.path.join(TEST_TMPDIR, label+'.fifo')
 184     try:
 185         os.remove(fifo)
 186     except OSError as error:
 187         if error.errno != errno.ENOENT:
 188             raise
 189     os.mkfifo(fifo, 0700)
 190     subprocess.Popen(
 191         ['sed', '-e', 's/^/['+label+'] /', fifo],
 192         stdout=sys.stderr)
 193     return fifo
 194
 195 def run(leave_running_atexit=False):
 196     """Ensure an API server is running, and ARVADOS_API_* env vars have
 197     admin credentials for it.
 198
 199     If ARVADOS_TEST_API_HOST is set, a parent process has started a
 200     test server for us to use: we just need to reset() it using the
 201     admin token fixture.
 202
 203     If a previous call to run() started a new server process, and it
 204     is still running, we just need to reset() it to fixture state and
 205     return.
 206
 207     If neither of those options work out, we'll really start a new
 208     server.
 209     """
 210     global my_api_host
 211
 212     # Delete cached discovery document.
 213     shutil.rmtree(arvados.http_cache('discovery'))
 214
 215     pid_file = _pidfile('api')
 216     pid_file_ok = find_server_pid(pid_file, 0)
 217
 218     existing_api_host = os.environ.get('ARVADOS_TEST_API_HOST', my_api_host)
 219     if existing_api_host and pid_file_ok:
 220         if existing_api_host == my_api_host:
 221             try:
 222                 return reset()
 223             except:
 224                 # Fall through to shutdown-and-start case.
 225                 pass
 226         else:
 227             # Server was provided by parent. Can't recover if it's
 228             # unresettable.
 229             return reset()
 230
 231     # Before trying to start up our own server, call stop() to avoid
 232     # "Phusion Passenger Standalone is already running on PID 12345".
 233     # (If we've gotten this far, ARVADOS_TEST_API_HOST isn't set, so
 234     # we know the server is ours to kill.)
 235     stop(force=True)
 236
 237     restore_cwd = os.getcwd()
 238     api_src_dir = os.path.join(SERVICES_SRC_DIR, 'api')
 239     os.chdir(api_src_dir)
 240
 241     # Either we haven't started a server of our own yet, or it has
 242     # died, or we have lost our credentials, or something else is
 243     # preventing us from calling reset(). Start a new one.
 244
 245     if not os.path.exists('tmp'):
 246         os.makedirs('tmp')
 247
 248     if not os.path.exists('tmp/api'):
 249         os.makedirs('tmp/api')
 250
 251     if not os.path.exists('tmp/logs'):
 252         os.makedirs('tmp/logs')
 253
 254     if not os.path.exists('tmp/self-signed.pem'):
 255         # We assume here that either passenger reports its listening
 256         # address as https:/0.0.0.0:port/. If it reports "127.0.0.1"
 257         # then the certificate won't match the host and reset() will
 258         # fail certificate verification. If it reports "localhost",
 259         # clients (notably Python SDK's websocket client) might
 260         # resolve localhost as ::1 and then fail to connect.
 261         subprocess.check_call([
 262             'openssl', 'req', '-new', '-x509', '-nodes',
 263             '-out', 'tmp/self-signed.pem',
 264             '-keyout', 'tmp/self-signed.key',
 265             '-days', '3650',
 266             '-subj', '/CN=0.0.0.0'],
 267         stdout=sys.stderr)
 268
 269     # Install the git repository fixtures.
 270     gitdir = os.path.join(SERVICES_SRC_DIR, 'api', 'tmp', 'git')
 271     gittarball = os.path.join(SERVICES_SRC_DIR, 'api', 'test', 'test.git.tar')
 272     if not os.path.isdir(gitdir):
 273         os.makedirs(gitdir)
 274     subprocess.check_output(['tar', '-xC', gitdir, '-f', gittarball])
 275
 276     port = find_available_port()
 277     env = os.environ.copy()
 278     env['RAILS_ENV'] = 'test'
 279     env['ARVADOS_WEBSOCKETS'] = 'yes'
 280     env.pop('ARVADOS_TEST_API_HOST', None)
 281     env.pop('ARVADOS_API_HOST', None)
 282     env.pop('ARVADOS_API_HOST_INSECURE', None)
 283     env.pop('ARVADOS_API_TOKEN', None)
 284     start_msg = subprocess.check_output(
 285         ['bundle', 'exec',
 286          'passenger', 'start', '-d', '-p{}'.format(port),
 287          '--pid-file', pid_file,
 288          '--log-file', os.path.join(os.getcwd(), 'log/test.log'),
 289          '--ssl',
 290          '--ssl-certificate', 'tmp/self-signed.pem',
 291          '--ssl-certificate-key', 'tmp/self-signed.key'],
 292         env=env)
 293
 294     if not leave_running_atexit:
 295         atexit.register(kill_server_pid, pid_file, passenger_root=api_src_dir)
 296
 297     match = re.search(r'Accessible via: https://(.*?)/', start_msg)
 298     if not match:
 299         raise Exception(
 300             "Passenger did not report endpoint: {}".format(start_msg))
 301     my_api_host = match.group(1)
 302     os.environ['ARVADOS_API_HOST'] = my_api_host
 303
 304     # Make sure the server has written its pid file and started
 305     # listening on its TCP port
 306     find_server_pid(pid_file)
 307     _wait_until_port_listens(port)
 308
 309     reset()
 310     os.chdir(restore_cwd)
 311
 312 def reset():
 313     """Reset the test server to fixture state.
 314
 315     This resets the ARVADOS_TEST_API_HOST provided by a parent process
 316     if any, otherwise the server started by run().
 317
 318     It also resets ARVADOS_* environment vars to point to the test
 319     server with admin credentials.
 320     """
 321     existing_api_host = os.environ.get('ARVADOS_TEST_API_HOST', my_api_host)
 322     token = auth_token('admin')
 323     httpclient = httplib2.Http(ca_certs=os.path.join(
 324         SERVICES_SRC_DIR, 'api', 'tmp', 'self-signed.pem'))
 325     httpclient.request(
 326         'https://{}/database/reset'.format(existing_api_host),
 327         'POST',
 328         headers={'Authorization': 'OAuth2 {}'.format(token)})
 329     os.environ['ARVADOS_API_HOST_INSECURE'] = 'true'
 330     os.environ['ARVADOS_API_HOST'] = existing_api_host
 331     os.environ['ARVADOS_API_TOKEN'] = token
 332
 333 def stop(force=False):
 334     """Stop the API server, if one is running.
 335
 336     If force==False, kill it only if we started it ourselves. (This
 337     supports the use case where a Python test suite calls run(), but
 338     run() just uses the ARVADOS_TEST_API_HOST provided by the parent
 339     process, and the test suite cleans up after itself by calling
 340     stop(). In this case the test server provided by the parent
 341     process should be left alone.)
 342
 343     If force==True, kill it even if we didn't start it
 344     ourselves. (This supports the use case in __main__, where "run"
 345     and "stop" happen in different processes.)
 346     """
 347     global my_api_host
 348     if force or my_api_host is not None:
 349         kill_server_pid(_pidfile('api'))
 350         my_api_host = None
 351
 352 def _start_keep(n, keep_args):
 353     keep0 = tempfile.mkdtemp()
 354     port = find_available_port()
 355     keep_cmd = ["keepstore",
 356                 "-volume={}".format(keep0),
 357                 "-listen=:{}".format(port),
 358                 "-pid="+_pidfile('keep{}'.format(n))]
 359
 360     for arg, val in keep_args.iteritems():
 361         keep_cmd.append("{}={}".format(arg, val))
 362
 363     logf = open(_fifo2stderr('keep{}'.format(n)), 'w')
 364     kp0 = subprocess.Popen(
 365         keep_cmd, stdin=open('/dev/null'), stdout=logf, stderr=logf, close_fds=True)
 366
 367     with open(_pidfile('keep{}'.format(n)), 'w') as f:
 368         f.write(str(kp0.pid))
 369
 370     with open("{}/keep{}.volume".format(TEST_TMPDIR, n), 'w') as f:
 371         f.write(keep0)
 372
 373     _wait_until_port_listens(port)
 374
 375     return port
 376
 377 def run_keep(blob_signing_key=None, enforce_permissions=False, num_servers=2):
 378     stop_keep(num_servers)
 379
 380     keep_args = {}
 381     if not blob_signing_key:
 382         blob_signing_key = 'zfhgfenhffzltr9dixws36j1yhksjoll2grmku38mi7yxd66h5j4q9w4jzanezacp8s6q0ro3hxakfye02152hncy6zml2ed0uc'
 383     with open(os.path.join(TEST_TMPDIR, "keep.blob_signing_key"), "w") as f:
 384         keep_args['-blob-signing-key-file'] = f.name
 385         f.write(blob_signing_key)
 386     if enforce_permissions:
 387         keep_args['-enforce-permissions'] = 'true'
 388     with open(os.path.join(TEST_TMPDIR, "keep.data-manager-token-file"), "w") as f:
 389         keep_args['-data-manager-token-file'] = f.name
 390         f.write(auth_token('data_manager'))
 391     keep_args['-never-delete'] = 'false'
 392
 393     api = arvados.api(
 394         version='v1',
 395         host=os.environ['ARVADOS_API_HOST'],
 396         token=os.environ['ARVADOS_API_TOKEN'],
 397         insecure=True)
 398
 399     for d in api.keep_services().list(filters=[['service_type','=','disk']]).execute()['items']:
 400         api.keep_services().delete(uuid=d['uuid']).execute()
 401     for d in api.keep_disks().list().execute()['items']:
 402         api.keep_disks().delete(uuid=d['uuid']).execute()
 403
 404     for d in range(0, num_servers):
 405         port = _start_keep(d, keep_args)
 406         svc = api.keep_services().create(body={'keep_service': {
 407             'uuid': 'zzzzz-bi6l4-keepdisk{:07d}'.format(d),
 408             'service_host': 'localhost',
 409             'service_port': port,
 410             'service_type': 'disk',
 411             'service_ssl_flag': False,
 412         }}).execute()
 413         api.keep_disks().create(body={
 414             'keep_disk': {'keep_service_uuid': svc['uuid'] }
 415         }).execute()
 416
 417     # If keepproxy is running, send SIGHUP to make it discover the new
 418     # keepstore services.
 419     proxypidfile = _pidfile('keepproxy')
 420     if os.path.exists(proxypidfile):
 421         os.kill(int(open(proxypidfile).read()), signal.SIGHUP)
 422
 423 def _stop_keep(n):
 424     kill_server_pid(_pidfile('keep{}'.format(n)))
 425     if os.path.exists("{}/keep{}.volume".format(TEST_TMPDIR, n)):
 426         with open("{}/keep{}.volume".format(TEST_TMPDIR, n), 'r') as r:
 427             shutil.rmtree(r.read(), True)
 428         os.unlink("{}/keep{}.volume".format(TEST_TMPDIR, n))
 429     if os.path.exists(os.path.join(TEST_TMPDIR, "keep.blob_signing_key")):
 430         os.remove(os.path.join(TEST_TMPDIR, "keep.blob_signing_key"))
 431
 432 def stop_keep(num_servers=2):
 433     for n in range(0, num_servers):
 434         _stop_keep(n)
 435
 436 def run_keep_proxy():
 437     if 'ARVADOS_TEST_PROXY_SERVICES' in os.environ:
 438         return
 439     stop_keep_proxy()
 440
 441     port = find_available_port()
 442     env = os.environ.copy()
 443     env['ARVADOS_API_TOKEN'] = auth_token('anonymous')
 444     logf = open(_fifo2stderr('keepproxy'), 'w')
 445     kp = subprocess.Popen(
 446         ['keepproxy',
 447          '-pid='+_pidfile('keepproxy'),
 448          '-listen=:{}'.format(port)],
 449         env=env, stdin=open('/dev/null'), stdout=logf, stderr=logf, close_fds=True)
 450
 451     api = arvados.api(
 452         version='v1',
 453         host=os.environ['ARVADOS_API_HOST'],
 454         token=auth_token('admin'),
 455         insecure=True)
 456     for d in api.keep_services().list(
 457             filters=[['service_type','=','proxy']]).execute()['items']:
 458         api.keep_services().delete(uuid=d['uuid']).execute()
 459     api.keep_services().create(body={'keep_service': {
 460         'service_host': 'localhost',
 461         'service_port': port,
 462         'service_type': 'proxy',
 463         'service_ssl_flag': False,
 464     }}).execute()
 465     os.environ["ARVADOS_KEEP_PROXY"] = "http://localhost:{}".format(port)
 466     _setport('keepproxy', port)
 467     _wait_until_port_listens(port)
 468
 469 def stop_keep_proxy():
 470     if 'ARVADOS_TEST_PROXY_SERVICES' in os.environ:
 471         return
 472     kill_server_pid(_pidfile('keepproxy'))
 473
 474 def run_arv_git_httpd():
 475     if 'ARVADOS_TEST_PROXY_SERVICES' in os.environ:
 476         return
 477     stop_arv_git_httpd()
 478
 479     gitdir = os.path.join(SERVICES_SRC_DIR, 'api', 'tmp', 'git')
 480     gitport = find_available_port()
 481     env = os.environ.copy()
 482     env.pop('ARVADOS_API_TOKEN', None)
 483     logf = open(_fifo2stderr('arv-git-httpd'), 'w')
 484     agh = subprocess.Popen(
 485         ['arv-git-httpd',
 486          '-repo-root='+gitdir+'/test',
 487          '-address=:'+str(gitport)],
 488         env=env, stdin=open('/dev/null'), stdout=logf, stderr=logf)
 489     with open(_pidfile('arv-git-httpd'), 'w') as f:
 490         f.write(str(agh.pid))
 491     _setport('arv-git-httpd', gitport)
 492     _wait_until_port_listens(gitport)
 493
 494 def stop_arv_git_httpd():
 495     if 'ARVADOS_TEST_PROXY_SERVICES' in os.environ:
 496         return
 497     kill_server_pid(_pidfile('arv-git-httpd'))
 498
 499 def run_keep_web():
 500     if 'ARVADOS_TEST_PROXY_SERVICES' in os.environ:
 501         return
 502     stop_keep_web()
 503
 504     keepwebport = find_available_port()
 505     env = os.environ.copy()
 506     env['ARVADOS_API_TOKEN'] = auth_token('anonymous')
 507     logf = open(_fifo2stderr('keep-web'), 'w')
 508     keepweb = subprocess.Popen(
 509         ['keep-web',
 510          '-allow-anonymous',
 511          '-attachment-only-host=localhost:'+str(keepwebport),
 512          '-listen=:'+str(keepwebport)],
 513         env=env, stdin=open('/dev/null'), stdout=logf, stderr=logf)
 514     with open(_pidfile('keep-web'), 'w') as f:
 515         f.write(str(keepweb.pid))
 516     _setport('keep-web', keepwebport)
 517     _wait_until_port_listens(keepwebport)
 518
 519 def stop_keep_web():
 520     if 'ARVADOS_TEST_PROXY_SERVICES' in os.environ:
 521         return
 522     kill_server_pid(_pidfile('keep-web'))
 523
 524 def run_nginx():
 525     if 'ARVADOS_TEST_PROXY_SERVICES' in os.environ:
 526         return
 527     nginxconf = {}
 528     nginxconf['KEEPWEBPORT'] = _getport('keep-web')
 529     nginxconf['KEEPWEBSSLPORT'] = find_available_port()
 530     nginxconf['KEEPPROXYPORT'] = _getport('keepproxy')
 531     nginxconf['KEEPPROXYSSLPORT'] = find_available_port()
 532     nginxconf['GITPORT'] = _getport('arv-git-httpd')
 533     nginxconf['GITSSLPORT'] = find_available_port()
 534     nginxconf['SSLCERT'] = os.path.join(SERVICES_SRC_DIR, 'api', 'tmp', 'self-signed.pem')
 535     nginxconf['SSLKEY'] = os.path.join(SERVICES_SRC_DIR, 'api', 'tmp', 'self-signed.key')
 536     nginxconf['ACCESSLOG'] = _fifo2stderr('nginx_access_log')
 537
 538     conftemplatefile = os.path.join(MY_DIRNAME, 'nginx.conf')
 539     conffile = os.path.join(TEST_TMPDIR, 'nginx.conf')
 540     with open(conffile, 'w') as f:
 541         f.write(re.sub(
 542             r'{{([A-Z]+)}}',
 543             lambda match: str(nginxconf.get(match.group(1))),
 544             open(conftemplatefile).read()))
 545
 546     env = os.environ.copy()
 547     env['PATH'] = env['PATH']+':/sbin:/usr/sbin:/usr/local/sbin'
 548
 549     nginx = subprocess.Popen(
 550         ['nginx',
 551          '-g', 'error_log stderr info;',
 552          '-g', 'pid '+_pidfile('nginx')+';',
 553          '-c', conffile],
 554         env=env, stdin=open('/dev/null'), stdout=sys.stderr)
 555     _setport('keep-web-ssl', nginxconf['KEEPWEBSSLPORT'])
 556     _setport('keepproxy-ssl', nginxconf['KEEPPROXYSSLPORT'])
 557     _setport('arv-git-httpd-ssl', nginxconf['GITSSLPORT'])
 558
 559 def stop_nginx():
 560     if 'ARVADOS_TEST_PROXY_SERVICES' in os.environ:
 561         return
 562     kill_server_pid(_pidfile('nginx'))
 563
 564 def _pidfile(program):
 565     return os.path.join(TEST_TMPDIR, program + '.pid')
 566
 567 def _portfile(program):
 568     return os.path.join(TEST_TMPDIR, program + '.port')
 569
 570 def _setport(program, port):
 571     with open(_portfile(program), 'w') as f:
 572         f.write(str(port))
 573
 574 # Returns 9 if program is not up.
 575 def _getport(program):
 576     try:
 577         return int(open(_portfile(program)).read())
 578     except IOError:
 579         return 9
 580
 581 def _apiconfig(key):
 582     if _cached_config:
 583         return _cached_config[key]
 584     def _load(f, required=True):
 585         fullpath = os.path.join(SERVICES_SRC_DIR, 'api', 'config', f)
 586         if not required and not os.path.exists(fullpath):
 587             return {}
 588         return yaml.load(fullpath)
 589     cdefault = _load('application.default.yml')
 590     csite = _load('application.yml', required=False)
 591     _cached_config = {}
 592     for section in [cdefault.get('common',{}), cdefault.get('test',{}),
 593                     csite.get('common',{}), csite.get('test',{})]:
 594         _cached_config.update(section)
 595     return _cached_config[key]
 596
 597 def fixture(fix):
 598     '''load a fixture yaml file'''
 599     with open(os.path.join(SERVICES_SRC_DIR, 'api', "test", "fixtures",
 600                            fix + ".yml")) as f:
 601         yaml_file = f.read()
 602         try:
 603           trim_index = yaml_file.index("# Test Helper trims the rest of the file")
 604           yaml_file = yaml_file[0:trim_index]
 605         except ValueError:
 606           pass
 607         return yaml.load(yaml_file)
 608
 609 def auth_token(token_name):
 610     return fixture("api_client_authorizations")[token_name]["api_token"]
 611
 612 def authorize_with(token_name):
 613     '''token_name is the symbolic name of the token from the api_client_authorizations fixture'''
 614     arvados.config.settings()["ARVADOS_API_TOKEN"] = auth_token(token_name)
 615     arvados.config.settings()["ARVADOS_API_HOST"] = os.environ.get("ARVADOS_API_HOST")
 616     arvados.config.settings()["ARVADOS_API_HOST_INSECURE"] = "true"
 617
 618 class TestCaseWithServers(unittest.TestCase):
 619     """TestCase to start and stop supporting Arvados servers.
 620
 621     Define any of MAIN_SERVER, KEEP_SERVER, and/or KEEP_PROXY_SERVER
 622     class variables as a dictionary of keyword arguments.  If you do,
 623     setUpClass will start the corresponding servers by passing these
 624     keyword arguments to the run, run_keep, and/or run_keep_server
 625     functions, respectively.  It will also set Arvados environment
 626     variables to point to these servers appropriately.  If you don't
 627     run a Keep or Keep proxy server, setUpClass will set up a
 628     temporary directory for Keep local storage, and set it as
 629     KEEP_LOCAL_STORE.
 630
 631     tearDownClass will stop any servers started, and restore the
 632     original environment.
 633     """
 634     MAIN_SERVER = None
 635     KEEP_SERVER = None
 636     KEEP_PROXY_SERVER = None
 637     KEEP_WEB_SERVER = None
 638
 639     @staticmethod
 640     def _restore_dict(src, dest):
 641         for key in dest.keys():
 642             if key not in src:
 643                 del dest[key]
 644         dest.update(src)
 645
 646     @classmethod
 647     def setUpClass(cls):
 648         cls._orig_environ = os.environ.copy()
 649         cls._orig_config = arvados.config.settings().copy()
 650         cls._cleanup_funcs = []
 651         os.environ.pop('ARVADOS_KEEP_PROXY', None)
 652         os.environ.pop('ARVADOS_EXTERNAL_CLIENT', None)
 653         for server_kwargs, start_func, stop_func in (
 654                 (cls.MAIN_SERVER, run, reset),
 655                 (cls.KEEP_SERVER, run_keep, stop_keep),
 656                 (cls.KEEP_PROXY_SERVER, run_keep_proxy, stop_keep_proxy),
 657                 (cls.KEEP_WEB_SERVER, run_keep_web, stop_keep_web)):
 658             if server_kwargs is not None:
 659                 start_func(**server_kwargs)
 660                 cls._cleanup_funcs.append(stop_func)
 661         if (cls.KEEP_SERVER is None) and (cls.KEEP_PROXY_SERVER is None):
 662             cls.local_store = tempfile.mkdtemp()
 663             os.environ['KEEP_LOCAL_STORE'] = cls.local_store
 664             cls._cleanup_funcs.append(
 665                 lambda: shutil.rmtree(cls.local_store, ignore_errors=True))
 666         else:
 667             os.environ.pop('KEEP_LOCAL_STORE', None)
 668         arvados.config.initialize()
 669
 670     @classmethod
 671     def tearDownClass(cls):
 672         for clean_func in cls._cleanup_funcs:
 673             clean_func()
 674         cls._restore_dict(cls._orig_environ, os.environ)
 675         cls._restore_dict(cls._orig_config, arvados.config.settings())
 676
 677
 678 if __name__ == "__main__":
 679     actions = [
 680         'start', 'stop',
 681         'start_keep', 'stop_keep',
 682         'start_keep_proxy', 'stop_keep_proxy',
 683         'start_keep-web', 'stop_keep-web',
 684         'start_arv-git-httpd', 'stop_arv-git-httpd',
 685         'start_nginx', 'stop_nginx',
 686     ]
 687     parser = argparse.ArgumentParser()
 688     parser.add_argument('action', type=str, help="one of {}".format(actions))
 689     parser.add_argument('--auth', type=str, metavar='FIXTURE_NAME', help='Print authorization info for given api_client_authorizations fixture')
 690     parser.add_argument('--num-keep-servers', metavar='int', type=int, default=2, help="Number of keep servers desired")
 691     parser.add_argument('--keep-enforce-permissions', action="store_true", help="Enforce keep permissions")
 692
 693     args = parser.parse_args()
 694
 695     if args.action not in actions:
 696         print("Unrecognized action '{}'. Actions are: {}.".format(args.action, actions), file=sys.stderr)
 697         sys.exit(1)
 698     if args.action == 'start':
 699         stop(force=('ARVADOS_TEST_API_HOST' not in os.environ))
 700         run(leave_running_atexit=True)
 701         host = os.environ['ARVADOS_API_HOST']
 702         if args.auth is not None:
 703             token = auth_token(args.auth)
 704             print("export ARVADOS_API_TOKEN={}".format(pipes.quote(token)))
 705             print("export ARVADOS_API_HOST={}".format(pipes.quote(host)))
 706             print("export ARVADOS_API_HOST_INSECURE=true")
 707         else:
 708             print(host)
 709     elif args.action == 'stop':
 710         stop(force=('ARVADOS_TEST_API_HOST' not in os.environ))
 711     elif args.action == 'start_keep':
 712         run_keep(enforce_permissions=args.keep_enforce_permissions, num_servers=args.num_keep_servers)
 713     elif args.action == 'stop_keep':
 714         stop_keep(num_servers=args.num_keep_servers)
 715     elif args.action == 'start_keep_proxy':
 716         run_keep_proxy()
 717     elif args.action == 'stop_keep_proxy':
 718         stop_keep_proxy()
 719     elif args.action == 'start_arv-git-httpd':
 720         run_arv_git_httpd()
 721     elif args.action == 'stop_arv-git-httpd':
 722         stop_arv_git_httpd()
 723     elif args.action == 'start_keep-web':
 724         run_keep_web()
 725     elif args.action == 'stop_keep-web':
 726         stop_keep_web()
 727     elif args.action == 'start_nginx':
 728         run_nginx()
 729     elif args.action == 'stop_nginx':
 730         stop_nginx()
 731     else:
 732         raise Exception("action recognized but not implemented!?")