os.makedirs(gitdir)
subprocess.check_output(['tar', '-xC', gitdir, '-f', gittarball])
- # The nginx proxy isn't listening here yet, but we need to choose
- # the wss:// port now so we can write the API server config file.
- wss_port = find_available_port()
- _setport('wss', wss_port)
-
- port = find_available_port()
+ port = internal_port_from_config("RailsAPI")
env = os.environ.copy()
env['RAILS_ENV'] = 'test'
- env['ARVADOS_TEST_WSS_PORT'] = str(wss_port)
env.pop('ARVADOS_WEBSOCKETS', None)
env.pop('ARVADOS_TEST_API_HOST', None)
env.pop('ARVADOS_API_HOST', None)
os.environ['ARVADOS_API_HOST_INSECURE'] = 'true'
os.environ['ARVADOS_API_TOKEN'] = token
- if _wait_until_port_listens(_getport('controller-ssl'), timeout=0.5, warn=False):
- os.environ['ARVADOS_API_HOST'] = '0.0.0.0:'+str(_getport('controller-ssl'))
- else:
- os.environ['ARVADOS_API_HOST'] = existing_api_host
+ os.environ['ARVADOS_API_HOST'] = existing_api_host
def stop(force=False):
"""Stop the API server, if one is running.
kill_server_pid(_pidfile('api'))
my_api_host = None
+def get_config():
+ with open(os.environ["ARVADOS_CONFIG"]) as f:
+ return yaml.safe_load(f)
+
+def internal_port_from_config(service):
+ return int(list(get_config()["Clusters"]["zzzzz"]["Services"][service]["InternalURLs"].keys())[0].split(":")[2])
+
+def external_port_from_config(service):
+ return int(get_config()["Clusters"]["zzzzz"]["Services"][service]["ExternalURL"].split(":")[2])
+
def run_controller():
if 'ARVADOS_TEST_PROXY_SERVICES' in os.environ:
return
stop_controller()
- rails_api_port = int(string.split(os.environ.get('ARVADOS_TEST_API_HOST', my_api_host), ':')[-1])
- port = find_available_port()
- conf = os.path.join(TEST_TMPDIR, 'arvados.yml')
- with open(conf, 'w') as f:
- f.write("""
-Clusters:
- zzzzz:
- EnableBetaController14287: {beta14287}
- ManagementToken: e687950a23c3a9bceec28c6223a06c79
- API:
- RequestTimeout: 30s
- Logging:
- Level: "{loglevel}"
- HTTPRequestTimeout: 30s
- PostgreSQL:
- ConnectionPool: 32
- Connection:
- host: {dbhost}
- dbname: {dbname}
- user: {dbuser}
- password: {dbpass}
- TLS:
- Insecure: true
- Services:
- Controller:
- InternalURLs:
- "http://localhost:{controllerport}": {{}}
- RailsAPI:
- InternalURLs:
- "https://localhost:{railsport}": {{}}
- """.format(
- beta14287=('true' if '14287' in os.environ.get('ARVADOS_EXPERIMENTAL', '') else 'false'),
- loglevel=('info' if os.environ.get('ARVADOS_DEBUG', '') in ['','0'] else 'debug'),
- dbhost=_dbconfig('host'),
- dbname=_dbconfig('dbname'),
- dbuser=_dbconfig('user'),
- dbpass=_dbconfig('password'),
- controllerport=port,
- railsport=rails_api_port,
- ))
logf = open(_logfilename('controller'), 'a')
+ port = internal_port_from_config("Controller")
controller = subprocess.Popen(
- ["arvados-server", "controller", "-config", conf],
+ ["arvados-server", "controller"],
stdin=open('/dev/null'), stdout=logf, stderr=logf, close_fds=True)
with open(_pidfile('controller'), 'w') as f:
f.write(str(controller.pid))
_wait_until_port_listens(port)
- _setport('controller', port)
return port
def stop_controller():
if 'ARVADOS_TEST_PROXY_SERVICES' in os.environ:
return
stop_ws()
- port = find_available_port()
- conf = os.path.join(TEST_TMPDIR, 'ws.yml')
- with open(conf, 'w') as f:
- f.write("""
-Client:
- APIHost: {}
- Insecure: true
-Listen: :{}
-LogLevel: {}
-Postgres:
- host: {}
- dbname: {}
- user: {}
- password: {}
- sslmode: require
- """.format(os.environ['ARVADOS_API_HOST'],
- port,
- ('info' if os.environ.get('ARVADOS_DEBUG', '') in ['','0'] else 'debug'),
- _dbconfig('host'),
- _dbconfig('dbname'),
- _dbconfig('user'),
- _dbconfig('password')))
+ port = internal_port_from_config("Websocket")
logf = open(_logfilename('ws'), 'a')
- ws = subprocess.Popen(
- ["ws", "-config", conf],
+ ws = subprocess.Popen(["ws"],
stdin=open('/dev/null'), stdout=logf, stderr=logf, close_fds=True)
with open(_pidfile('ws'), 'w') as f:
f.write(str(ws.pid))
_wait_until_port_listens(port)
- _setport('ws', port)
return port
def stop_ws():
def run_keep_proxy():
if 'ARVADOS_TEST_PROXY_SERVICES' in os.environ:
- os.environ["ARVADOS_KEEP_SERVICES"] = "http://localhost:{}".format(_getport('keepproxy'))
+ os.environ["ARVADOS_KEEP_SERVICES"] = "http://localhost:{}".format(internal_port_from_config('Keepproxy'))
return
stop_keep_proxy()
- port = find_available_port()
+ port = internal_port_from_config("Keepproxy")
env = os.environ.copy()
env['ARVADOS_API_TOKEN'] = auth_token('anonymous')
logf = open(_logfilename('keepproxy'), 'a')
'-listen=:{}'.format(port)],
env=env, stdin=open('/dev/null'), stdout=logf, stderr=logf, close_fds=True)
+ print("Using API %s token %s" % (os.environ['ARVADOS_API_HOST'], auth_token('admin')), file=sys.stdout)
api = arvados.api(
version='v1',
host=os.environ['ARVADOS_API_HOST'],
'service_ssl_flag': False,
}}).execute()
os.environ["ARVADOS_KEEP_SERVICES"] = "http://localhost:{}".format(port)
- _setport('keepproxy', port)
_wait_until_port_listens(port)
def stop_keep_proxy():
stop_arv_git_httpd()
gitdir = os.path.join(SERVICES_SRC_DIR, 'api', 'tmp', 'git')
- gitport = find_available_port()
+ gitport = internal_port_from_config("GitHTTP")
env = os.environ.copy()
env.pop('ARVADOS_API_TOKEN', None)
logf = open(_logfilename('arv-git-httpd'), 'a')
env=env, stdin=open('/dev/null'), stdout=logf, stderr=logf)
with open(_pidfile('arv-git-httpd'), 'w') as f:
f.write(str(agh.pid))
- _setport('arv-git-httpd', gitport)
_wait_until_port_listens(gitport)
def stop_arv_git_httpd():
return
stop_keep_web()
- keepwebport = find_available_port()
+ keepwebport = internal_port_from_config("WebDAV")
env = os.environ.copy()
env['ARVADOS_API_TOKEN'] = auth_token('anonymous')
logf = open(_logfilename('keep-web'), 'a')
env=env, stdin=open('/dev/null'), stdout=logf, stderr=logf)
with open(_pidfile('keep-web'), 'w') as f:
f.write(str(keepweb.pid))
- _setport('keep-web', keepwebport)
_wait_until_port_listens(keepwebport)
def stop_keep_web():
return
stop_nginx()
nginxconf = {}
- nginxconf['CONTROLLERPORT'] = _getport('controller')
- nginxconf['CONTROLLERSSLPORT'] = find_available_port()
- nginxconf['KEEPWEBPORT'] = _getport('keep-web')
- nginxconf['KEEPWEBDLSSLPORT'] = find_available_port()
- nginxconf['KEEPWEBSSLPORT'] = find_available_port()
- nginxconf['KEEPPROXYPORT'] = _getport('keepproxy')
- nginxconf['KEEPPROXYSSLPORT'] = find_available_port()
- nginxconf['GITPORT'] = _getport('arv-git-httpd')
- nginxconf['GITSSLPORT'] = find_available_port()
- nginxconf['WSPORT'] = _getport('ws')
- nginxconf['WSSPORT'] = _getport('wss')
+ nginxconf['CONTROLLERPORT'] = internal_port_from_config("Controller")
+ nginxconf['CONTROLLERSSLPORT'] = external_port_from_config("Controller")
+ nginxconf['KEEPWEBPORT'] = internal_port_from_config("WebDAV")
+ nginxconf['KEEPWEBDLSSLPORT'] = external_port_from_config("WebDAVDownload")
+ nginxconf['KEEPWEBSSLPORT'] = external_port_from_config("WebDAV")
+ nginxconf['KEEPPROXYPORT'] = internal_port_from_config("Keepproxy")
+ nginxconf['KEEPPROXYSSLPORT'] = external_port_from_config("Keepproxy")
+ nginxconf['GITPORT'] = internal_port_from_config("GitHTTP")
+ nginxconf['GITSSLPORT'] = external_port_from_config("GitHTTP")
+ nginxconf['WSPORT'] = internal_port_from_config("Websocket")
+ nginxconf['WSSPORT'] = external_port_from_config("Websocket")
nginxconf['SSLCERT'] = os.path.join(SERVICES_SRC_DIR, 'api', 'tmp', 'self-signed.pem')
nginxconf['SSLKEY'] = os.path.join(SERVICES_SRC_DIR, 'api', 'tmp', 'self-signed.key')
nginxconf['ACCESSLOG'] = _logfilename('nginx_access')
'-g', 'pid '+_pidfile('nginx')+';',
'-c', conffile],
env=env, stdin=open('/dev/null'), stdout=sys.stderr)
- _setport('controller-ssl', nginxconf['CONTROLLERSSLPORT'])
- _setport('keep-web-dl-ssl', nginxconf['KEEPWEBDLSSLPORT'])
- _setport('keep-web-ssl', nginxconf['KEEPWEBSSLPORT'])
- _setport('keepproxy-ssl', nginxconf['KEEPPROXYSSLPORT'])
- _setport('arv-git-httpd-ssl', nginxconf['GITSSLPORT'])
+
+def setup_config():
+ rails_api_port = find_available_port()
+ controller_port = find_available_port()
+ controller_external_port = find_available_port()
+ websocket_port = find_available_port()
+ websocket_external_port = find_available_port()
+ git_httpd_port = find_available_port()
+ git_httpd_external_port = find_available_port()
+ keepproxy_port = find_available_port()
+ keepproxy_external_port = find_available_port()
+ keep_web_port = find_available_port()
+ keep_web_external_port = find_available_port()
+ keep_web_dl_port = find_available_port()
+ keep_web_dl_external_port = find_available_port()
+
+ if "CONFIGSRC" in os.environ:
+ dbconf = os.path.join(os.environ["CONFIGSRC"], "config.yml")
+ else:
+ dbconf = "/etc/arvados/config.yml"
+
+ print("Getting config from %s" % dbconf, file=sys.stderr)
+
+ pgconnection = list(yaml.safe_load(open(dbconf))["Clusters"].values())[0]["PostgreSQL"]["Connection"]
+
+ if "test" not in pgconnection["dbname"]:
+ pgconnection["dbname"] = "arvados_test"
+
+ services = {
+ "RailsAPI": {
+ "InternalURLs": { }
+ },
+ "Controller": {
+ "ExternalURL": "https://localhost:%s" % controller_external_port,
+ "InternalURLs": { }
+ },
+ "Websocket": {
+ "ExternalURL": "https://localhost:%s" % websocket_external_port,
+ "InternalURLs": { }
+ },
+ "GitHTTP": {
+ "ExternalURL": "https://localhost:%s" % git_httpd_external_port,
+ "InternalURLs": { }
+ },
+ "Keepproxy": {
+ "ExternalURL": "https://localhost:%s" % keepproxy_external_port,
+ "InternalURLs": { }
+ },
+ "WebDAV": {
+ "ExternalURL": "https://localhost:%s" % keep_web_external_port,
+ "InternalURLs": { }
+ },
+ "WebDAVDownload": {
+ "ExternalURL": "https://localhost:%s" % keep_web_dl_external_port,
+ "InternalURLs": { }
+ }
+ }
+ services["RailsAPI"]["InternalURLs"]["https://localhost:%s"%rails_api_port] = {}
+ services["Controller"]["InternalURLs"]["http://localhost:%s"%controller_port] = {}
+ services["Websocket"]["InternalURLs"]["http://localhost:%s"%websocket_port] = {}
+ services["GitHTTP"]["InternalURLs"]["http://localhost:%s"%git_httpd_port] = {}
+ services["Keepproxy"]["InternalURLs"]["http://localhost:%s"%keepproxy_port] = {}
+ services["WebDAV"]["InternalURLs"]["http://localhost:%s"%keep_web_port] = {}
+ services["WebDAVDownload"]["InternalURLs"]["http://localhost:%s"%keep_web_dl_port] = {}
+
+ config = {
+ "Clusters": {
+ "zzzzz": {
+ "EnableBetaController14287": ('14287' in os.environ.get('ARVADOS_EXPERIMENTAL', '')),
+ "ManagementToken": "e687950a23c3a9bceec28c6223a06c79",
+ "API": {
+ "RequestTimeout": "30s"
+ },
+ "SystemLogs": {
+ "LogLevel": ('info' if os.environ.get('ARVADOS_DEBUG', '') in ['','0'] else 'debug')
+ },
+ "PostgreSQL": {
+ "Connection": pgconnection,
+ },
+ "TLS": {
+ "Insecure": True
+ },
+ "Services": services
+ }
+ }
+ }
+
+ conf = os.path.join(TEST_TMPDIR, 'arvados.yml')
+ with open(conf, 'w') as f:
+ yaml.safe_dump(config, f)
+
+ ex = "export ARVADOS_CONFIG="+conf
+ print(ex, file=sys.stderr)
+ print(ex)
+
def stop_nginx():
if 'ARVADOS_TEST_PROXY_SERVICES' in os.environ:
def _pidfile(program):
return os.path.join(TEST_TMPDIR, program + '.pid')
-def _portfile(program):
- return os.path.join(TEST_TMPDIR, program + '.port')
-
-def _setport(program, port):
- with open(_portfile(program), 'w') as f:
- f.write(str(port))
-
-# Returns 9 if program is not up.
-def _getport(program):
- try:
- with open(_portfile(program)) as prog:
- return int(prog.read())
- except IOError:
- return 9
-
def _dbconfig(key):
global _cached_db_config
if not _cached_db_config:
'start_keep_proxy', 'stop_keep_proxy',
'start_keep-web', 'stop_keep-web',
'start_arv-git-httpd', 'stop_arv-git-httpd',
- 'start_nginx', 'stop_nginx',
+ 'start_nginx', 'stop_nginx', 'setup_config',
]
parser = argparse.ArgumentParser()
parser.add_argument('action', type=str, help="one of {}".format(actions))
stop_keep_web()
elif args.action == 'start_nginx':
run_nginx()
- print("export ARVADOS_API_HOST=0.0.0.0:{}".format(_getport('controller-ssl')))
+ print("export ARVADOS_API_HOST=0.0.0.0:{}".format(external_port_from_config('Controller')))
elif args.action == 'stop_nginx':
stop_nginx()
+ elif args.action == 'setup_config':
+ setup_config()
else:
raise Exception("action recognized but not implemented!?")
projects / arvados.git / commitdiff