import unittest
import yaml
+try:
+ from urllib.parse import urlparse
+except ImportError:
+ from urlparse import urlparse
+
MY_DIRNAME = os.path.dirname(os.path.realpath(__file__))
if __name__ == '__main__' and os.path.exists(
os.path.join(MY_DIRNAME, '..', 'arvados', '__init__.py')):
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])
+ return int(urlparse(
+ list(get_config()["Clusters"]["zzzzz"]["Services"][service]["InternalURLs"].keys())[0]).
+ netloc.split(":")[1])
def external_port_from_config(service):
- return int(get_config()["Clusters"]["zzzzz"]["Services"][service]["ExternalURL"].split(":")[2])
+ return int(urlparse(get_config()["Clusters"]["zzzzz"]["Services"][service]["ExternalURL"]).netloc.split(":")[1])
def run_controller():
if 'ARVADOS_TEST_PROXY_SERVICES' in os.environ:
env['ARVADOS_API_TOKEN'] = auth_token('anonymous')
logf = open(_logfilename('keepproxy'), 'a')
kp = subprocess.Popen(
- ['keepproxy',
- '-pid='+_pidfile('keepproxy'),
- '-listen=:{}'.format(port)],
- env=env, stdin=open('/dev/null'), stdout=logf, stderr=logf, close_fds=True)
+ ['keepproxy'], env=env, stdin=open('/dev/null'), stdout=logf, stderr=logf, close_fds=True)
+
+ with open(_pidfile('keepproxy'), 'w') as f:
+ f.write(str(kp.pid))
+ _wait_until_port_listens(port)
print("Using API %s token %s" % (os.environ['ARVADOS_API_HOST'], auth_token('admin')), file=sys.stdout)
api = arvados.api(
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"
+ dbconf = os.path.join(os.environ["CONFIGSRC"], "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"
+ pgconnection = yaml.safe_load(open(dbconf))["Clusters"]["zzzzz"]["PostgreSQL"]["Connection"]
+ localhost = "127.0.0.1"
services = {
"RailsAPI": {
- "InternalURLs": { }
+ "InternalURLs": {
+ "https://%s:%s"%(localhost, rails_api_port): {}
+ }
},
"Controller": {
- "ExternalURL": "https://localhost:%s" % controller_external_port,
- "InternalURLs": { }
+ "ExternalURL": "https://%s:%s" % (localhost, controller_external_port),
+ "InternalURLs": {
+ "http://%s:%s"%(localhost, controller_port): {}
+ }
},
"Websocket": {
- "ExternalURL": "https://localhost:%s" % websocket_external_port,
- "InternalURLs": { }
+ "ExternalURL": "wss://%s:%s/websocket" % (localhost, websocket_external_port),
+ "InternalURLs": {
+ "http://%s:%s"%(localhost, websocket_port): {}
+ }
},
"GitHTTP": {
- "ExternalURL": "https://localhost:%s" % git_httpd_external_port,
- "InternalURLs": { }
+ "ExternalURL": "https://%s:%s" % (localhost, git_httpd_external_port),
+ "InternalURLs": {
+ "http://%s:%s"%(localhost, git_httpd_port): {}
+ }
},
"Keepproxy": {
- "ExternalURL": "https://localhost:%s" % keepproxy_external_port,
- "InternalURLs": { }
+ "ExternalURL": "https://%s:%s" % (localhost, keepproxy_external_port),
+ "InternalURLs": {
+ "http://%s:%s"%(localhost, keepproxy_port): {}
+ }
},
"WebDAV": {
- "ExternalURL": "https://localhost:%s" % keep_web_external_port,
- "InternalURLs": { }
+ "ExternalURL": "https://%s:%s" % (localhost, keep_web_external_port),
+ "InternalURLs": {
+ "http://%s:%s"%(localhost, keep_web_port): {}
+ }
},
"WebDAVDownload": {
- "ExternalURL": "https://localhost:%s" % keep_web_dl_external_port,
- "InternalURLs": { }
+ "ExternalURL": "https://%s:%s" % (localhost, keep_web_dl_external_port),
+ "InternalURLs": {
+ "http://%s:%s"%(localhost, keep_web_dl_port): {}
+ }
}
}
- 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": {
yaml.safe_dump(config, f)
ex = "export ARVADOS_CONFIG="+conf
- print(ex, file=sys.stderr)
print(ex)
def _pidfile(program):
return os.path.join(TEST_TMPDIR, program + '.pid')
-def _dbconfig(key):
- global _cached_db_config
- if not _cached_db_config:
- if "ARVADOS_CONFIG" in os.environ:
- _cached_db_config = list(yaml.safe_load(open(os.environ["ARVADOS_CONFIG"]))["Clusters"].values())[0]["PostgreSQL"]["Connection"]
- else:
- _cached_db_config = yaml.safe_load(open(os.path.join(
- SERVICES_SRC_DIR, 'api', 'config', 'database.yml')))["test"]
- _cached_db_config["dbname"] = _cached_db_config["database"]
- _cached_db_config["user"] = _cached_db_config["username"]
- return _cached_db_config[key]
-
-def _apiconfig(key):
- global _cached_config
- if _cached_config:
- return _cached_config[key]
- def _load(f, required=True):
- fullpath = os.path.join(SERVICES_SRC_DIR, 'api', 'config', f)
- if not required and not os.path.exists(fullpath):
- return {}
- return yaml.safe_load(fullpath)
- cdefault = _load('application.default.yml')
- csite = _load('application.yml', required=False)
- _cached_config = {}
- for section in [cdefault.get('common',{}), cdefault.get('test',{}),
- csite.get('common',{}), csite.get('test',{})]:
- _cached_config.update(section)
- return _cached_config[key]
-
def fixture(fix):
'''load a fixture yaml file'''
with open(os.path.join(SERVICES_SRC_DIR, 'api', "test", "fixtures",