sdk/python/tests/run_test_server.py

   1 # Copyright (C) The Arvados Authors. All rights reserved.
   2 #
   3 # SPDX-License-Identifier: Apache-2.0
   4
   5 from __future__ import print_function
   6 from __future__ import division
   7 from builtins import str
   8 from builtins import range
   9 import argparse
  10 import atexit
  11 import errno
  12 import glob
  13 import httplib2
  14 import os
  15 import pipes
  16 import random
  17 import re
  18 import shutil
  19 import signal
  20 import socket
  21 import string
  22 import subprocess
  23 import sys
  24 import tempfile
  25 import time
  26 import unittest
  27 import yaml
  28
  29 try:
  30     from urllib.parse import urlparse
  31 except ImportError:
  32     from urlparse import urlparse
  33
  34 MY_DIRNAME = os.path.dirname(os.path.realpath(__file__))
  35 if __name__ == '__main__' and os.path.exists(
  36       os.path.join(MY_DIRNAME, '..', 'arvados', '__init__.py')):
  37     # We're being launched to support another test suite.
  38     # Add the Python SDK source to the library path.
  39     sys.path.insert(1, os.path.dirname(MY_DIRNAME))
  40
  41 import arvados
  42 import arvados.config
  43
  44 ARVADOS_DIR = os.path.realpath(os.path.join(MY_DIRNAME, '../../..'))
  45 SERVICES_SRC_DIR = os.path.join(ARVADOS_DIR, 'services')
  46
  47 # Work around https://bugs.python.org/issue27805, should be no longer
  48 # necessary from sometime in Python 3.8.x
  49 if not os.environ.get('ARVADOS_DEBUG', ''):
  50     WRITE_MODE = 'a'
  51 else:
  52     WRITE_MODE = 'w'
  53
  54 if 'GOPATH' in os.environ:
  55     # Add all GOPATH bin dirs to PATH -- but insert them after the
  56     # ruby gems bin dir, to ensure "bundle" runs the Ruby bundler
  57     # command, not the golang.org/x/tools/cmd/bundle command.
  58     gopaths = os.environ['GOPATH'].split(':')
  59     addbins = [os.path.join(path, 'bin') for path in gopaths]
  60     newbins = []
  61     for path in os.environ['PATH'].split(':'):
  62         newbins.append(path)
  63         if os.path.exists(os.path.join(path, 'bundle')):
  64             newbins += addbins
  65             addbins = []
  66     newbins += addbins
  67     os.environ['PATH'] = ':'.join(newbins)
  68
  69 TEST_TMPDIR = os.path.join(ARVADOS_DIR, 'tmp')
  70 if not os.path.exists(TEST_TMPDIR):
  71     os.mkdir(TEST_TMPDIR)
  72
  73 my_api_host = None
  74 _cached_config = {}
  75 _cached_db_config = {}
  76 _already_used_port = {}
  77
  78 def find_server_pid(PID_PATH, wait=10):
  79     now = time.time()
  80     timeout = now + wait
  81     good_pid = False
  82     while (not good_pid) and (now <= timeout):
  83         time.sleep(0.2)
  84         try:
  85             with open(PID_PATH, 'r') as f:
  86                 server_pid = int(f.read())
  87             good_pid = (os.kill(server_pid, 0) is None)
  88         except EnvironmentError:
  89             good_pid = False
  90         now = time.time()
  91
  92     if not good_pid:
  93         return None
  94
  95     return server_pid
  96
  97 def kill_server_pid(pidfile, wait=10, passenger_root=False):
  98     # Must re-import modules in order to work during atexit
  99     import os
 100     import signal
 101     import subprocess
 102     import time
 103
 104     now = time.time()
 105     startTERM = now
 106     deadline = now + wait
 107
 108     if passenger_root:
 109         # First try to shut down nicely
 110         restore_cwd = os.getcwd()
 111         os.chdir(passenger_root)
 112         subprocess.call([
 113             'bundle', 'exec', 'passenger', 'stop', '--pid-file', pidfile])
 114         os.chdir(restore_cwd)
 115         # Use up to half of the +wait+ period waiting for "passenger
 116         # stop" to work. If the process hasn't exited by then, start
 117         # sending TERM signals.
 118         startTERM += wait//2
 119
 120     server_pid = None
 121     while now <= deadline and server_pid is None:
 122         try:
 123             with open(pidfile, 'r') as f:
 124                 server_pid = int(f.read())
 125         except IOError:
 126             # No pidfile = nothing to kill.
 127             return
 128         except ValueError as error:
 129             # Pidfile exists, but we can't parse it. Perhaps the
 130             # server has created the file but hasn't written its PID
 131             # yet?
 132             print("Parse error reading pidfile {}: {}".format(pidfile, error),
 133                   file=sys.stderr)
 134             time.sleep(0.1)
 135             now = time.time()
 136
 137     while now <= deadline:
 138         try:
 139             exited, _ = os.waitpid(server_pid, os.WNOHANG)
 140             if exited > 0:
 141                 _remove_pidfile(pidfile)
 142                 return
 143         except OSError:
 144             # already exited, or isn't our child process
 145             pass
 146         try:
 147             if now >= startTERM:
 148                 os.kill(server_pid, signal.SIGTERM)
 149                 print("Sent SIGTERM to {} ({})".format(server_pid, pidfile),
 150                       file=sys.stderr)
 151         except OSError as error:
 152             if error.errno == errno.ESRCH:
 153                 # Thrown by os.getpgid() or os.kill() if the process
 154                 # does not exist, i.e., our work here is done.
 155                 _remove_pidfile(pidfile)
 156                 return
 157             raise
 158         time.sleep(0.1)
 159         now = time.time()
 160
 161     print("Server PID {} ({}) did not exit, giving up after {}s".
 162           format(server_pid, pidfile, wait),
 163           file=sys.stderr)
 164
 165 def _remove_pidfile(pidfile):
 166     try:
 167         os.unlink(pidfile)
 168     except:
 169         if os.path.lexists(pidfile):
 170             raise
 171
 172 def find_available_port():
 173     """Return an IPv4 port number that is not in use right now.
 174
 175     We assume whoever needs to use the returned port is able to reuse
 176     a recently used port without waiting for TIME_WAIT (see
 177     SO_REUSEADDR / SO_REUSEPORT).
 178
 179     Some opportunity for races here, but it's better than choosing
 180     something at random and not checking at all. If all of our servers
 181     (hey Passenger) knew that listening on port 0 was a thing, the OS
 182     would take care of the races, and this wouldn't be needed at all.
 183     """
 184
 185     global _already_used_port
 186     while True:
 187         sock = socket.socket()
 188         sock.bind(('0.0.0.0', 0))
 189         port = sock.getsockname()[1]
 190         sock.close()
 191         if port not in _already_used_port:
 192             _already_used_port[port] = True
 193             return port
 194
 195 def _wait_until_port_listens(port, timeout=10, warn=True):
 196     """Wait for a process to start listening on the given port.
 197
 198     If nothing listens on the port within the specified timeout (given
 199     in seconds), print a warning on stderr before returning.
 200     """
 201     try:
 202         subprocess.check_output(['which', 'netstat'])
 203     except subprocess.CalledProcessError:
 204         print("WARNING: No `netstat` -- cannot wait for port to listen. "+
 205               "Sleeping 0.5 and hoping for the best.",
 206               file=sys.stderr)
 207         time.sleep(0.5)
 208         return
 209     deadline = time.time() + timeout
 210     while time.time() < deadline:
 211         if re.search(r'\ntcp.*:'+str(port)+' .* LISTEN *\n', subprocess.check_output(['netstat', '-Wln']).decode()):
 212             return True
 213         time.sleep(0.1)
 214     if warn:
 215         print(
 216             "WARNING: Nothing is listening on port {} (waited {} seconds).".
 217             format(port, timeout),
 218             file=sys.stderr)
 219     return False
 220
 221 def _logfilename(label):
 222     """Set up a labelled log file, and return a path to write logs to.
 223
 224     Normally, the returned path is {tmpdir}/{label}.log.
 225
 226     In debug mode, logs are also written to stderr, with [label]
 227     prepended to each line. The returned path is a FIFO.
 228
 229     +label+ should contain only alphanumerics: it is also used as part
 230     of the FIFO filename.
 231
 232     """
 233     logfilename = os.path.join(TEST_TMPDIR, label+'.log')
 234     if not os.environ.get('ARVADOS_DEBUG', ''):
 235         return logfilename
 236     fifo = os.path.join(TEST_TMPDIR, label+'.fifo')
 237     try:
 238         os.remove(fifo)
 239     except OSError as error:
 240         if error.errno != errno.ENOENT:
 241             raise
 242     os.mkfifo(fifo, 0o700)
 243     stdbuf = ['stdbuf', '-i0', '-oL', '-eL']
 244     # open(fifo, 'r') would block waiting for someone to open the fifo
 245     # for writing, so we need a separate cat process to open it for
 246     # us.
 247     cat = subprocess.Popen(
 248         stdbuf+['cat', fifo],
 249         stdin=open('/dev/null'),
 250         stdout=subprocess.PIPE)
 251     tee = subprocess.Popen(
 252         stdbuf+['tee', '-a', logfilename],
 253         stdin=cat.stdout,
 254         stdout=subprocess.PIPE)
 255     subprocess.Popen(
 256         stdbuf+['sed', '-e', 's/^/['+label+'] /'],
 257         stdin=tee.stdout,
 258         stdout=sys.stderr)
 259     return fifo
 260
 261 def run(leave_running_atexit=False):
 262     """Ensure an API server is running, and ARVADOS_API_* env vars have
 263     admin credentials for it.
 264
 265     If ARVADOS_TEST_API_HOST is set, a parent process has started a
 266     test server for us to use: we just need to reset() it using the
 267     admin token fixture.
 268
 269     If a previous call to run() started a new server process, and it
 270     is still running, we just need to reset() it to fixture state and
 271     return.
 272
 273     If neither of those options work out, we'll really start a new
 274     server.
 275     """
 276     global my_api_host
 277
 278     # Delete cached discovery documents.
 279     #
 280     # This will clear cached docs that belong to other processes (like
 281     # concurrent test suites) even if they're still running. They should
 282     # be able to tolerate that.
 283     for fn in glob.glob(os.path.join(
 284             str(arvados.http_cache('discovery')),
 285             '*,arvados,v1,rest,*')):
 286         os.unlink(fn)
 287
 288     pid_file = _pidfile('api')
 289     pid_file_ok = find_server_pid(pid_file, 0)
 290
 291     existing_api_host = os.environ.get('ARVADOS_TEST_API_HOST', my_api_host)
 292     if existing_api_host and pid_file_ok:
 293         if existing_api_host == my_api_host:
 294             try:
 295                 return reset()
 296             except:
 297                 # Fall through to shutdown-and-start case.
 298                 pass
 299         else:
 300             # Server was provided by parent. Can't recover if it's
 301             # unresettable.
 302             return reset()
 303
 304     # Before trying to start up our own server, call stop() to avoid
 305     # "Phusion Passenger Standalone is already running on PID 12345".
 306     # (If we've gotten this far, ARVADOS_TEST_API_HOST isn't set, so
 307     # we know the server is ours to kill.)
 308     stop(force=True)
 309
 310     restore_cwd = os.getcwd()
 311     api_src_dir = os.path.join(SERVICES_SRC_DIR, 'api')
 312     os.chdir(api_src_dir)
 313
 314     # Either we haven't started a server of our own yet, or it has
 315     # died, or we have lost our credentials, or something else is
 316     # preventing us from calling reset(). Start a new one.
 317
 318     if not os.path.exists('tmp'):
 319         os.makedirs('tmp')
 320
 321     if not os.path.exists('tmp/api'):
 322         os.makedirs('tmp/api')
 323
 324     if not os.path.exists('tmp/logs'):
 325         os.makedirs('tmp/logs')
 326
 327     # Install the git repository fixtures.
 328     gitdir = os.path.join(SERVICES_SRC_DIR, 'api', 'tmp', 'git')
 329     gittarball = os.path.join(SERVICES_SRC_DIR, 'api', 'test', 'test.git.tar')
 330     if not os.path.isdir(gitdir):
 331         os.makedirs(gitdir)
 332     subprocess.check_output(['tar', '-xC', gitdir, '-f', gittarball])
 333
 334     port = internal_port_from_config("RailsAPI")
 335     env = os.environ.copy()
 336     env['RAILS_ENV'] = 'test'
 337     env['ARVADOS_RAILS_LOG_TO_STDOUT'] = '1'
 338     env.pop('ARVADOS_WEBSOCKETS', None)
 339     env.pop('ARVADOS_TEST_API_HOST', None)
 340     env.pop('ARVADOS_API_HOST', None)
 341     env.pop('ARVADOS_API_HOST_INSECURE', None)
 342     env.pop('ARVADOS_API_TOKEN', None)
 343     logf = open(_logfilename('railsapi'), WRITE_MODE)
 344     railsapi = subprocess.Popen(
 345         ['bundle', 'exec',
 346          'passenger', 'start', '-p{}'.format(port),
 347          '--pid-file', pid_file,
 348          '--log-file', '/dev/stdout',
 349          '--ssl',
 350          '--ssl-certificate', 'tmp/self-signed.pem',
 351          '--ssl-certificate-key', 'tmp/self-signed.key'],
 352         env=env, stdin=open('/dev/null'), stdout=logf, stderr=logf)
 353
 354     if not leave_running_atexit:
 355         atexit.register(kill_server_pid, pid_file, passenger_root=api_src_dir)
 356
 357     my_api_host = "127.0.0.1:"+str(port)
 358     os.environ['ARVADOS_API_HOST'] = my_api_host
 359
 360     # Make sure the server has written its pid file and started
 361     # listening on its TCP port
 362     _wait_until_port_listens(port)
 363     find_server_pid(pid_file)
 364
 365     reset()
 366     os.chdir(restore_cwd)
 367
 368 def reset():
 369     """Reset the test server to fixture state.
 370
 371     This resets the ARVADOS_TEST_API_HOST provided by a parent process
 372     if any, otherwise the server started by run().
 373
 374     It also resets ARVADOS_* environment vars to point to the test
 375     server with admin credentials.
 376     """
 377     existing_api_host = os.environ.get('ARVADOS_TEST_API_HOST', my_api_host)
 378     token = auth_token('admin')
 379     httpclient = httplib2.Http(ca_certs=os.path.join(
 380         SERVICES_SRC_DIR, 'api', 'tmp', 'self-signed.pem'))
 381     httpclient.request(
 382         'https://{}/database/reset'.format(existing_api_host),
 383         'POST',
 384         headers={'Authorization': 'OAuth2 {}'.format(token), 'Connection':'close'})
 385
 386     os.environ['ARVADOS_API_HOST_INSECURE'] = 'true'
 387     os.environ['ARVADOS_API_TOKEN'] = token
 388     os.environ['ARVADOS_API_HOST'] = existing_api_host
 389
 390 def stop(force=False):
 391     """Stop the API server, if one is running.
 392
 393     If force==False, kill it only if we started it ourselves. (This
 394     supports the use case where a Python test suite calls run(), but
 395     run() just uses the ARVADOS_TEST_API_HOST provided by the parent
 396     process, and the test suite cleans up after itself by calling
 397     stop(). In this case the test server provided by the parent
 398     process should be left alone.)
 399
 400     If force==True, kill it even if we didn't start it
 401     ourselves. (This supports the use case in __main__, where "run"
 402     and "stop" happen in different processes.)
 403     """
 404     global my_api_host
 405     if force or my_api_host is not None:
 406         kill_server_pid(_pidfile('api'))
 407         my_api_host = None
 408
 409 def get_config():
 410     with open(os.environ["ARVADOS_CONFIG"]) as f:
 411         return yaml.safe_load(f)
 412
 413 def internal_port_from_config(service, idx=0):
 414     return int(urlparse(
 415         sorted(list(get_config()["Clusters"]["zzzzz"]["Services"][service]["InternalURLs"].keys()))[idx]).
 416                netloc.split(":")[1])
 417
 418 def external_port_from_config(service):
 419     return int(urlparse(get_config()["Clusters"]["zzzzz"]["Services"][service]["ExternalURL"]).netloc.split(":")[1])
 420
 421 def run_controller():
 422     if 'ARVADOS_TEST_PROXY_SERVICES' in os.environ:
 423         return
 424     stop_controller()
 425     logf = open(_logfilename('controller'), WRITE_MODE)
 426     port = internal_port_from_config("Controller")
 427     controller = subprocess.Popen(
 428         ["arvados-server", "controller"],
 429         stdin=open('/dev/null'), stdout=logf, stderr=logf, close_fds=True)
 430     with open(_pidfile('controller'), 'w') as f:
 431         f.write(str(controller.pid))
 432     _wait_until_port_listens(port)
 433     return port
 434
 435 def stop_controller():
 436     if 'ARVADOS_TEST_PROXY_SERVICES' in os.environ:
 437         return
 438     kill_server_pid(_pidfile('controller'))
 439
 440 def run_ws():
 441     if 'ARVADOS_TEST_PROXY_SERVICES' in os.environ:
 442         return
 443     stop_ws()
 444     port = internal_port_from_config("Websocket")
 445     logf = open(_logfilename('ws'), WRITE_MODE)
 446     ws = subprocess.Popen(
 447         ["arvados-server", "ws"],
 448         stdin=open('/dev/null'), stdout=logf, stderr=logf, close_fds=True)
 449     with open(_pidfile('ws'), 'w') as f:
 450         f.write(str(ws.pid))
 451     _wait_until_port_listens(port)
 452     return port
 453
 454 def stop_ws():
 455     if 'ARVADOS_TEST_PROXY_SERVICES' in os.environ:
 456         return
 457     kill_server_pid(_pidfile('ws'))
 458
 459 def _start_keep(n, blob_signing=False):
 460     datadir = os.path.join(TEST_TMPDIR, "keep%d.data"%n)
 461     if os.path.exists(datadir):
 462         shutil.rmtree(datadir)
 463     os.mkdir(datadir)
 464     port = internal_port_from_config("Keepstore", idx=n)
 465
 466     # Currently, if there are multiple InternalURLs for a single host,
 467     # the only way to tell a keepstore process which one it's supposed
 468     # to listen on is to supply a redacted version of the config, with
 469     # the other InternalURLs removed.
 470     conf = os.path.join(TEST_TMPDIR, "keep%d.yaml"%n)
 471     confdata = get_config()
 472     confdata['Clusters']['zzzzz']['Services']['Keepstore']['InternalURLs'] = {"http://127.0.0.1:%d"%port: {}}
 473     confdata['Clusters']['zzzzz']['Collections']['BlobSigning'] = blob_signing
 474     with open(conf, 'w') as f:
 475         yaml.safe_dump(confdata, f)
 476     keep_cmd = ["keepstore", "-config", conf]
 477
 478     with open(_logfilename('keep{}'.format(n)), WRITE_MODE) as logf:
 479         with open('/dev/null') as _stdin:
 480             child = subprocess.Popen(
 481                 keep_cmd, stdin=_stdin, stdout=logf, stderr=logf, close_fds=True)
 482
 483     print('child.pid is %d'%child.pid, file=sys.stderr)
 484     with open(_pidfile('keep{}'.format(n)), 'w') as f:
 485         f.write(str(child.pid))
 486
 487     _wait_until_port_listens(port)
 488
 489     return port
 490
 491 def run_keep(num_servers=2, **kwargs):
 492     stop_keep(num_servers)
 493
 494     api = arvados.api(
 495         version='v1',
 496         host=os.environ['ARVADOS_API_HOST'],
 497         token=os.environ['ARVADOS_API_TOKEN'],
 498         insecure=True)
 499
 500     for d in api.keep_services().list(filters=[['service_type','=','disk']]).execute()['items']:
 501         api.keep_services().delete(uuid=d['uuid']).execute()
 502     for d in api.keep_disks().list().execute()['items']:
 503         api.keep_disks().delete(uuid=d['uuid']).execute()
 504
 505     for d in range(0, num_servers):
 506         port = _start_keep(d, **kwargs)
 507         svc = api.keep_services().create(body={'keep_service': {
 508             'uuid': 'zzzzz-bi6l4-keepdisk{:07d}'.format(d),
 509             'service_host': 'localhost',
 510             'service_port': port,
 511             'service_type': 'disk',
 512             'service_ssl_flag': False,
 513         }}).execute()
 514         api.keep_disks().create(body={
 515             'keep_disk': {'keep_service_uuid': svc['uuid'] }
 516         }).execute()
 517
 518     # If keepproxy and/or keep-web is running, send SIGHUP to make
 519     # them discover the new keepstore services.
 520     for svc in ('keepproxy', 'keep-web'):
 521         pidfile = _pidfile('keepproxy')
 522         if os.path.exists(pidfile):
 523             try:
 524                 with open(pidfile) as pid:
 525                     os.kill(int(pid.read()), signal.SIGHUP)
 526             except OSError:
 527                 os.remove(pidfile)
 528
 529 def _stop_keep(n):
 530     kill_server_pid(_pidfile('keep{}'.format(n)))
 531
 532 def stop_keep(num_servers=2):
 533     for n in range(0, num_servers):
 534         _stop_keep(n)
 535
 536 def run_keep_proxy():
 537     if 'ARVADOS_TEST_PROXY_SERVICES' in os.environ:
 538         os.environ["ARVADOS_KEEP_SERVICES"] = "http://localhost:{}".format(internal_port_from_config('Keepproxy'))
 539         return
 540     stop_keep_proxy()
 541
 542     port = internal_port_from_config("Keepproxy")
 543     env = os.environ.copy()
 544     env['ARVADOS_API_TOKEN'] = auth_token('anonymous')
 545     logf = open(_logfilename('keepproxy'), WRITE_MODE)
 546     kp = subprocess.Popen(
 547         ['keepproxy'], env=env, stdin=open('/dev/null'), stdout=logf, stderr=logf, close_fds=True)
 548
 549     with open(_pidfile('keepproxy'), 'w') as f:
 550         f.write(str(kp.pid))
 551     _wait_until_port_listens(port)
 552
 553     print("Using API %s token %s" % (os.environ['ARVADOS_API_HOST'], auth_token('admin')), file=sys.stdout)
 554     api = arvados.api(
 555         version='v1',
 556         host=os.environ['ARVADOS_API_HOST'],
 557         token=auth_token('admin'),
 558         insecure=True)
 559     for d in api.keep_services().list(
 560             filters=[['service_type','=','proxy']]).execute()['items']:
 561         api.keep_services().delete(uuid=d['uuid']).execute()
 562     api.keep_services().create(body={'keep_service': {
 563         'service_host': 'localhost',
 564         'service_port': port,
 565         'service_type': 'proxy',
 566         'service_ssl_flag': False,
 567     }}).execute()
 568     os.environ["ARVADOS_KEEP_SERVICES"] = "http://localhost:{}".format(port)
 569     _wait_until_port_listens(port)
 570
 571 def stop_keep_proxy():
 572     if 'ARVADOS_TEST_PROXY_SERVICES' in os.environ:
 573         return
 574     kill_server_pid(_pidfile('keepproxy'))
 575
 576 def run_arv_git_httpd():
 577     if 'ARVADOS_TEST_PROXY_SERVICES' in os.environ:
 578         return
 579     stop_arv_git_httpd()
 580
 581     gitport = internal_port_from_config("GitHTTP")
 582     env = os.environ.copy()
 583     env.pop('ARVADOS_API_TOKEN', None)
 584     logf = open(_logfilename('arv-git-httpd'), WRITE_MODE)
 585     agh = subprocess.Popen(['arv-git-httpd'],
 586         env=env, stdin=open('/dev/null'), stdout=logf, stderr=logf)
 587     with open(_pidfile('arv-git-httpd'), 'w') as f:
 588         f.write(str(agh.pid))
 589     _wait_until_port_listens(gitport)
 590
 591 def stop_arv_git_httpd():
 592     if 'ARVADOS_TEST_PROXY_SERVICES' in os.environ:
 593         return
 594     kill_server_pid(_pidfile('arv-git-httpd'))
 595
 596 def run_keep_web():
 597     if 'ARVADOS_TEST_PROXY_SERVICES' in os.environ:
 598         return
 599     stop_keep_web()
 600
 601     keepwebport = internal_port_from_config("WebDAV")
 602     env = os.environ.copy()
 603     logf = open(_logfilename('keep-web'), WRITE_MODE)
 604     keepweb = subprocess.Popen(
 605         ['keep-web'],
 606         env=env, stdin=open('/dev/null'), stdout=logf, stderr=logf)
 607     with open(_pidfile('keep-web'), 'w') as f:
 608         f.write(str(keepweb.pid))
 609     _wait_until_port_listens(keepwebport)
 610
 611 def stop_keep_web():
 612     if 'ARVADOS_TEST_PROXY_SERVICES' in os.environ:
 613         return
 614     kill_server_pid(_pidfile('keep-web'))
 615
 616 def run_nginx():
 617     if 'ARVADOS_TEST_PROXY_SERVICES' in os.environ:
 618         return
 619     stop_nginx()
 620     nginxconf = {}
 621     nginxconf['LISTENHOST'] = 'localhost'
 622     nginxconf['CONTROLLERPORT'] = internal_port_from_config("Controller")
 623     nginxconf['CONTROLLERSSLPORT'] = external_port_from_config("Controller")
 624     nginxconf['KEEPWEBPORT'] = internal_port_from_config("WebDAV")
 625     nginxconf['KEEPWEBDLSSLPORT'] = external_port_from_config("WebDAVDownload")
 626     nginxconf['KEEPWEBSSLPORT'] = external_port_from_config("WebDAV")
 627     nginxconf['KEEPPROXYPORT'] = internal_port_from_config("Keepproxy")
 628     nginxconf['KEEPPROXYSSLPORT'] = external_port_from_config("Keepproxy")
 629     nginxconf['GITPORT'] = internal_port_from_config("GitHTTP")
 630     nginxconf['GITSSLPORT'] = external_port_from_config("GitHTTP")
 631     nginxconf['HEALTHPORT'] = internal_port_from_config("Health")
 632     nginxconf['HEALTHSSLPORT'] = external_port_from_config("Health")
 633     nginxconf['WSPORT'] = internal_port_from_config("Websocket")
 634     nginxconf['WSSSLPORT'] = external_port_from_config("Websocket")
 635     nginxconf['WORKBENCH1PORT'] = internal_port_from_config("Workbench1")
 636     nginxconf['WORKBENCH1SSLPORT'] = external_port_from_config("Workbench1")
 637     nginxconf['SSLCERT'] = os.path.join(SERVICES_SRC_DIR, 'api', 'tmp', 'self-signed.pem')
 638     nginxconf['SSLKEY'] = os.path.join(SERVICES_SRC_DIR, 'api', 'tmp', 'self-signed.key')
 639     nginxconf['ACCESSLOG'] = _logfilename('nginx_access')
 640     nginxconf['ERRORLOG'] = _logfilename('nginx_error')
 641     nginxconf['TMPDIR'] = TEST_TMPDIR
 642
 643     conftemplatefile = os.path.join(MY_DIRNAME, 'nginx.conf')
 644     conffile = os.path.join(TEST_TMPDIR, 'nginx.conf')
 645     with open(conffile, 'w') as f:
 646         f.write(re.sub(
 647             r'{{([A-Z]+[A-Z0-9]+)}}',
 648             lambda match: str(nginxconf.get(match.group(1))),
 649             open(conftemplatefile).read()))
 650
 651     env = os.environ.copy()
 652     env['PATH'] = env['PATH']+':/sbin:/usr/sbin:/usr/local/sbin'
 653
 654     nginx = subprocess.Popen(
 655         ['nginx',
 656          '-g', 'error_log stderr info;',
 657          '-g', 'pid '+_pidfile('nginx')+';',
 658          '-c', conffile],
 659         env=env, stdin=open('/dev/null'), stdout=sys.stderr)
 660     _wait_until_port_listens(nginxconf['CONTROLLERSSLPORT'])
 661
 662 def setup_config():
 663     rails_api_port = find_available_port()
 664     controller_port = find_available_port()
 665     controller_external_port = find_available_port()
 666     websocket_port = find_available_port()
 667     websocket_external_port = find_available_port()
 668     workbench1_port = find_available_port()
 669     workbench1_external_port = find_available_port()
 670     git_httpd_port = find_available_port()
 671     git_httpd_external_port = find_available_port()
 672     health_httpd_port = find_available_port()
 673     health_httpd_external_port = find_available_port()
 674     keepproxy_port = find_available_port()
 675     keepproxy_external_port = find_available_port()
 676     keepstore_ports = sorted([str(find_available_port()) for _ in range(0,4)])
 677     keep_web_port = find_available_port()
 678     keep_web_external_port = find_available_port()
 679     keep_web_dl_port = find_available_port()
 680     keep_web_dl_external_port = find_available_port()
 681
 682     configsrc = os.environ.get("CONFIGSRC", None)
 683     if configsrc:
 684         clusterconf = os.path.join(configsrc, "config.yml")
 685         print("Getting config from %s" % clusterconf, file=sys.stderr)
 686         pgconnection = yaml.safe_load(open(clusterconf))["Clusters"]["zzzzz"]["PostgreSQL"]["Connection"]
 687     else:
 688         # assume "arvados-server install -type test" has set up the
 689         # conventional db credentials
 690         pgconnection = {
 691             "client_encoding": "utf8",
 692             "host": "localhost",
 693             "dbname": "arvados_test",
 694             "user": "arvados",
 695             "password": "insecure_arvados_test",
 696         }
 697
 698     localhost = "127.0.0.1"
 699     services = {
 700         "RailsAPI": {
 701             "InternalURLs": {
 702                 "https://%s:%s"%(localhost, rails_api_port): {},
 703             },
 704         },
 705         "Controller": {
 706             "ExternalURL": "https://%s:%s" % (localhost, controller_external_port),
 707             "InternalURLs": {
 708                 "http://%s:%s"%(localhost, controller_port): {},
 709             },
 710         },
 711         "Websocket": {
 712             "ExternalURL": "wss://%s:%s/websocket" % (localhost, websocket_external_port),
 713             "InternalURLs": {
 714                 "http://%s:%s"%(localhost, websocket_port): {},
 715             },
 716         },
 717         "Workbench1": {
 718             "ExternalURL": "https://%s:%s/" % (localhost, workbench1_external_port),
 719             "InternalURLs": {
 720                 "http://%s:%s"%(localhost, workbench1_port): {},
 721             },
 722         },
 723         "GitHTTP": {
 724             "ExternalURL": "https://%s:%s" % (localhost, git_httpd_external_port),
 725             "InternalURLs": {
 726                 "http://%s:%s"%(localhost, git_httpd_port): {}
 727             },
 728         },
 729         "Health": {
 730             "ExternalURL": "https://%s:%s" % (localhost, health_httpd_external_port),
 731             "InternalURLs": {
 732                 "http://%s:%s"%(localhost, health_httpd_port): {}
 733             },
 734         },
 735         "Keepstore": {
 736             "InternalURLs": {
 737                 "http://%s:%s"%(localhost, port): {} for port in keepstore_ports
 738             },
 739         },
 740         "Keepproxy": {
 741             "ExternalURL": "https://%s:%s" % (localhost, keepproxy_external_port),
 742             "InternalURLs": {
 743                 "http://%s:%s"%(localhost, keepproxy_port): {},
 744             },
 745         },
 746         "WebDAV": {
 747             "ExternalURL": "https://%s:%s" % (localhost, keep_web_external_port),
 748             "InternalURLs": {
 749                 "http://%s:%s"%(localhost, keep_web_port): {},
 750             },
 751         },
 752         "WebDAVDownload": {
 753             "ExternalURL": "https://%s:%s" % (localhost, keep_web_dl_external_port),
 754             "InternalURLs": {
 755                 "http://%s:%s"%(localhost, keep_web_dl_port): {},
 756             },
 757         },
 758         "SSO": {
 759             "ExternalURL": "http://localhost:3002",
 760         },
 761     }
 762
 763     config = {
 764         "Clusters": {
 765             "zzzzz": {
 766                 "ManagementToken": "e687950a23c3a9bceec28c6223a06c79",
 767                 "SystemRootToken": auth_token('system_user'),
 768                 "API": {
 769                     "RequestTimeout": "30s",
 770                 },
 771                 "Login": {
 772                     "SSO": {
 773                         "ProviderAppID": "arvados-server",
 774                         "ProviderAppSecret": "608dbf356a327e2d0d4932b60161e212c2d8d8f5e25690d7b622f850a990cd33",
 775                     },
 776                 },
 777                 "SystemLogs": {
 778                     "LogLevel": ('info' if os.environ.get('ARVADOS_DEBUG', '') in ['','0'] else 'debug'),
 779                 },
 780                 "PostgreSQL": {
 781                     "Connection": pgconnection,
 782                 },
 783                 "TLS": {
 784                     "Insecure": True,
 785                 },
 786                 "Services": services,
 787                 "Users": {
 788                     "AnonymousUserToken": auth_token('anonymous'),
 789                     "UserProfileNotificationAddress": "arvados@example.com",
 790                 },
 791                 "Collections": {
 792                     "BlobSigningKey": "zfhgfenhffzltr9dixws36j1yhksjoll2grmku38mi7yxd66h5j4q9w4jzanezacp8s6q0ro3hxakfye02152hncy6zml2ed0uc",
 793                     "TrustAllContent": False,
 794                     "ForwardSlashNameSubstitution": "/",
 795                     "TrashSweepInterval": "-1s",
 796                 },
 797                 "Git": {
 798                     "Repositories": os.path.join(SERVICES_SRC_DIR, 'api', 'tmp', 'git', 'test'),
 799                 },
 800                 "Containers": {
 801                     "JobsAPI": {
 802                         "GitInternalDir": os.path.join(SERVICES_SRC_DIR, 'api', 'tmp', 'internal.git'),
 803                     },
 804                     "SupportedDockerImageFormats": {"v1": {}},
 805                     "ShellAccess": {
 806                         "Admin": True,
 807                         "User": True,
 808                     },
 809                 },
 810                 "Volumes": {
 811                     "zzzzz-nyw5e-%015d"%n: {
 812                         "AccessViaHosts": {
 813                             "http://%s:%s" % (localhost, keepstore_ports[n]): {},
 814                         },
 815                         "Driver": "Directory",
 816                         "DriverParameters": {
 817                             "Root": os.path.join(TEST_TMPDIR, "keep%d.data"%n),
 818                         },
 819                     } for n in range(len(keepstore_ports))
 820                 },
 821             },
 822         },
 823     }
 824
 825     conf = os.path.join(TEST_TMPDIR, 'arvados.yml')
 826     with open(conf, 'w') as f:
 827         yaml.safe_dump(config, f)
 828
 829     ex = "export ARVADOS_CONFIG="+conf
 830     print(ex)
 831
 832
 833 def stop_nginx():
 834     if 'ARVADOS_TEST_PROXY_SERVICES' in os.environ:
 835         return
 836     kill_server_pid(_pidfile('nginx'))
 837
 838 def _pidfile(program):
 839     return os.path.join(TEST_TMPDIR, program + '.pid')
 840
 841 def fixture(fix):
 842     '''load a fixture yaml file'''
 843     with open(os.path.join(SERVICES_SRC_DIR, 'api', "test", "fixtures",
 844                            fix + ".yml")) as f:
 845         yaml_file = f.read()
 846         try:
 847           trim_index = yaml_file.index("# Test Helper trims the rest of the file")
 848           yaml_file = yaml_file[0:trim_index]
 849         except ValueError:
 850           pass
 851         return yaml.safe_load(yaml_file)
 852
 853 def auth_token(token_name):
 854     return fixture("api_client_authorizations")[token_name]["api_token"]
 855
 856 def authorize_with(token_name):
 857     '''token_name is the symbolic name of the token from the api_client_authorizations fixture'''
 858     arvados.config.settings()["ARVADOS_API_TOKEN"] = auth_token(token_name)
 859     arvados.config.settings()["ARVADOS_API_HOST"] = os.environ.get("ARVADOS_API_HOST")
 860     arvados.config.settings()["ARVADOS_API_HOST_INSECURE"] = "true"
 861
 862 class TestCaseWithServers(unittest.TestCase):
 863     """TestCase to start and stop supporting Arvados servers.
 864
 865     Define any of MAIN_SERVER, KEEP_SERVER, and/or KEEP_PROXY_SERVER
 866     class variables as a dictionary of keyword arguments.  If you do,
 867     setUpClass will start the corresponding servers by passing these
 868     keyword arguments to the run, run_keep, and/or run_keep_server
 869     functions, respectively.  It will also set Arvados environment
 870     variables to point to these servers appropriately.  If you don't
 871     run a Keep or Keep proxy server, setUpClass will set up a
 872     temporary directory for Keep local storage, and set it as
 873     KEEP_LOCAL_STORE.
 874
 875     tearDownClass will stop any servers started, and restore the
 876     original environment.
 877     """
 878     MAIN_SERVER = None
 879     WS_SERVER = None
 880     KEEP_SERVER = None
 881     KEEP_PROXY_SERVER = None
 882     KEEP_WEB_SERVER = None
 883
 884     @staticmethod
 885     def _restore_dict(src, dest):
 886         for key in list(dest.keys()):
 887             if key not in src:
 888                 del dest[key]
 889         dest.update(src)
 890
 891     @classmethod
 892     def setUpClass(cls):
 893         cls._orig_environ = os.environ.copy()
 894         cls._orig_config = arvados.config.settings().copy()
 895         cls._cleanup_funcs = []
 896         os.environ.pop('ARVADOS_KEEP_SERVICES', None)
 897         os.environ.pop('ARVADOS_EXTERNAL_CLIENT', None)
 898         for server_kwargs, start_func, stop_func in (
 899                 (cls.MAIN_SERVER, run, reset),
 900                 (cls.WS_SERVER, run_ws, stop_ws),
 901                 (cls.KEEP_SERVER, run_keep, stop_keep),
 902                 (cls.KEEP_PROXY_SERVER, run_keep_proxy, stop_keep_proxy),
 903                 (cls.KEEP_WEB_SERVER, run_keep_web, stop_keep_web)):
 904             if server_kwargs is not None:
 905                 start_func(**server_kwargs)
 906                 cls._cleanup_funcs.append(stop_func)
 907         if (cls.KEEP_SERVER is None) and (cls.KEEP_PROXY_SERVER is None):
 908             cls.local_store = tempfile.mkdtemp()
 909             os.environ['KEEP_LOCAL_STORE'] = cls.local_store
 910             cls._cleanup_funcs.append(
 911                 lambda: shutil.rmtree(cls.local_store, ignore_errors=True))
 912         else:
 913             os.environ.pop('KEEP_LOCAL_STORE', None)
 914         arvados.config.initialize()
 915
 916     @classmethod
 917     def tearDownClass(cls):
 918         for clean_func in cls._cleanup_funcs:
 919             clean_func()
 920         cls._restore_dict(cls._orig_environ, os.environ)
 921         cls._restore_dict(cls._orig_config, arvados.config.settings())
 922
 923
 924 if __name__ == "__main__":
 925     actions = [
 926         'start', 'stop',
 927         'start_ws', 'stop_ws',
 928         'start_controller', 'stop_controller',
 929         'start_keep', 'stop_keep',
 930         'start_keep_proxy', 'stop_keep_proxy',
 931         'start_keep-web', 'stop_keep-web',
 932         'start_arv-git-httpd', 'stop_arv-git-httpd',
 933         'start_nginx', 'stop_nginx', 'setup_config',
 934     ]
 935     parser = argparse.ArgumentParser()
 936     parser.add_argument('action', type=str, help="one of {}".format(actions))
 937     parser.add_argument('--auth', type=str, metavar='FIXTURE_NAME', help='Print authorization info for given api_client_authorizations fixture')
 938     parser.add_argument('--num-keep-servers', metavar='int', type=int, default=2, help="Number of keep servers desired")
 939     parser.add_argument('--keep-blob-signing', action="store_true", help="Enable blob signing for keepstore servers")
 940
 941     args = parser.parse_args()
 942
 943     if args.action not in actions:
 944         print("Unrecognized action '{}'. Actions are: {}.".
 945               format(args.action, actions),
 946               file=sys.stderr)
 947         sys.exit(1)
 948     if args.action == 'start':
 949         stop(force=('ARVADOS_TEST_API_HOST' not in os.environ))
 950         run(leave_running_atexit=True)
 951         host = os.environ['ARVADOS_API_HOST']
 952         if args.auth is not None:
 953             token = auth_token(args.auth)
 954             print("export ARVADOS_API_TOKEN={}".format(pipes.quote(token)))
 955             print("export ARVADOS_API_HOST={}".format(pipes.quote(host)))
 956             print("export ARVADOS_API_HOST_INSECURE=true")
 957         else:
 958             print(host)
 959     elif args.action == 'stop':
 960         stop(force=('ARVADOS_TEST_API_HOST' not in os.environ))
 961     elif args.action == 'start_ws':
 962         run_ws()
 963     elif args.action == 'stop_ws':
 964         stop_ws()
 965     elif args.action == 'start_controller':
 966         run_controller()
 967     elif args.action == 'stop_controller':
 968         stop_controller()
 969     elif args.action == 'start_keep':
 970         run_keep(blob_signing=args.keep_blob_signing, num_servers=args.num_keep_servers)
 971     elif args.action == 'stop_keep':
 972         stop_keep(num_servers=args.num_keep_servers)
 973     elif args.action == 'start_keep_proxy':
 974         run_keep_proxy()
 975     elif args.action == 'stop_keep_proxy':
 976         stop_keep_proxy()
 977     elif args.action == 'start_arv-git-httpd':
 978         run_arv_git_httpd()
 979     elif args.action == 'stop_arv-git-httpd':
 980         stop_arv_git_httpd()
 981     elif args.action == 'start_keep-web':
 982         run_keep_web()
 983     elif args.action == 'stop_keep-web':
 984         stop_keep_web()
 985     elif args.action == 'start_nginx':
 986         run_nginx()
 987         print("export ARVADOS_API_HOST=0.0.0.0:{}".format(external_port_from_config('Controller')))
 988     elif args.action == 'stop_nginx':
 989         stop_nginx()
 990     elif args.action == 'setup_config':
 991         setup_config()
 992     else:
 993         raise Exception("action recognized but not implemented!?")