async def load_apps_and_apis(self):
if not getattr(self, "path", False) and getattr(self, "db", False):
raise AppRepo.RepositoryNotInitialized
apps = {}
for app in self.path.iterdir():
# grabs only directories and ignores all __* directories i.e. __pycache__
if app.is_dir() and not re.fullmatch(r"(__.*)", app.name):
apps[app.name] = {}
for version in app.iterdir():
# grabs all valid version directories of form "v0.12.3.45..."
if re.fullmatch(r"(v(\d\.?)+)", version.name):
try:
# Store the api while we've got it here
api_name = app.name # TODO: f"{app.name}-{version.name}"
await self.store_api(validate_app_api(version / "api.yaml"), api_name)
project = get_project(project_dir=version, environment=load_docker_env())
if not len(project.services) == 1:
logger.error(
f"{app.name}-{version.name} compose file must define exactly one(1) service.")
else:
apps[app.name][version.name] = project
except ConnectionError:
logger.exception("Error connecting to Docker daemon while getting project.")
# TODO: Improve the error handling here
except Exception:
logger.exception(f"Error during {app.name}-{version.name} load.")
logger.info(f"Loaded {app.name} versions: {apps[app.name].keys()}")
return apps
def get_containers(self, service=None):
project = get_project('.', [self.compose_file_path],
project_name=self.name)
kwargs = {'one_off': OneOffFilter.include}
if service:
kwargs['service_names'] = [service]
return project.containers(**kwargs)
def test_up_external_networks(self):
filename = 'external-networks.yml'
self.base_dir = 'tests/fixtures/networks'
self._project = get_project(self.base_dir, [filename])
result = self.dispatch(['-f', filename, 'up', '-d'], returncode=1)
assert 'declared as external, but could not be found' in result.stderr
networks = [
n['Name'] for n in self.client.networks()
if n['Name'].startswith('{}_'.format(self.project.name))
]
assert not networks
network_names = [
'{}_{}'.format(self.project.name, n) for n in ['foo', 'bar']
]
for name in network_names:
self.client.create_network(name)
self.dispatch(['-f', filename, 'up', '-d'])
container = self.project.containers()[0]
assert sorted(list(container.get(
'NetworkSettings.Networks'))) == sorted(network_names)
def test_up_with_multiple_files(self):
self.base_dir = 'tests/fixtures/override-files'
config_paths = [
'docker-compose.yml',
'docker-compose.override.yml',
'extra.yml',
]
self._project = get_project(self.base_dir, config_paths)
self.dispatch(
[
'-f', config_paths[0],
'-f', config_paths[1],
'-f', config_paths[2],
'up', '-d',
],
None)
containers = self.project.containers()
self.assertEqual(len(containers), 3)
web, other, db = containers
self.assertEqual(web.human_readable_command, 'top')
self.assertTrue({'db', 'other'} <= set(get_links(web)))
self.assertEqual(db.human_readable_command, 'top')
self.assertEqual(other.human_readable_command, 'top')
def __init__(self, service, command, rm=True):
options = {
"--rm": rm,
"SERVICE": service,
"COMMAND": command,
}
self._project = get_project(os.getcwd(), config_path=os.getcwd(), project_name=PROJECT_NAME)
def test_up_with_network_mode(self):
c = self.client.create_container('busybox', 'top', name='composetest_network_mode_container')
self.addCleanup(self.client.remove_container, c, force=True)
self.client.start(c)
container_mode_source = 'container:{}'.format(c['Id'])
filename = 'network-mode.yml'
self.base_dir = 'tests/fixtures/networks'
self._project = get_project(self.base_dir, [filename])
self.dispatch(['-f', filename, 'up', '-d'], None)
networks = [
n for n in self.client.networks()
if n['Name'].startswith('{}_'.format(self.project.name))
]
assert not networks
for name in ['bridge', 'host', 'none']:
container = self.project.get_service(name).containers()[0]
assert list(container.get('NetworkSettings.Networks')) == [name]
assert container.get('HostConfig.NetworkMode') == name
service_mode_source = 'container:{}'.format(
self.project.get_service('bridge').containers()[0].id)
service_mode_container = self.project.get_service('service').containers()[0]
assert not service_mode_container.get('NetworkSettings.Networks')
assert service_mode_container.get('HostConfig.NetworkMode') == service_mode_source
container_mode_container = self.project.get_service('container').containers()[0]
assert not container_mode_container.get('NetworkSettings.Networks')
assert container_mode_container.get('HostConfig.NetworkMode') == container_mode_source
def test_up_with_network_mode(self):
c = self.client.create_container("busybox", "top", name="composetest_network_mode_container")
self.addCleanup(self.client.remove_container, c, force=True)
self.client.start(c)
container_mode_source = "container:{}".format(c["Id"])
filename = "network-mode.yml"
self.base_dir = "tests/fixtures/networks"
self._project = get_project(self.base_dir, [filename])
self.dispatch(["-f", filename, "up", "-d"], None)
networks = [n for n in self.client.networks() if n["Name"].startswith("{}_".format(self.project.name))]
assert not networks
for name in ["bridge", "host", "none"]:
container = self.project.get_service(name).containers()[0]
assert list(container.get("NetworkSettings.Networks")) == [name]
assert container.get("HostConfig.NetworkMode") == name
service_mode_source = "container:{}".format(self.project.get_service("bridge").containers()[0].id)
service_mode_container = self.project.get_service("service").containers()[0]
assert not service_mode_container.get("NetworkSettings.Networks")
assert service_mode_container.get("HostConfig.NetworkMode") == service_mode_source
container_mode_container = self.project.get_service("container").containers()[0]
assert not container_mode_container.get("NetworkSettings.Networks")
assert container_mode_container.get("HostConfig.NetworkMode") == container_mode_source
def top_level_cmd(self):
try:
compose_files = self.get_compose_files()
config_path = get_config_path_from_options(
".",
{},
{"COMPOSE_FILE": compose_files},
)
os.environ["COMPOSE_FILE"] = compose_files
for k, v in self.settings.items():
if k == "CONFIGURATION_OPTIONAL_SCOPES":
continue
if isinstance(v, bool):
v = f"{v}".lower()
if isinstance(v, int):
v = str(v)
os.environ[k] = v
env = Environment()
env.update(os.environ)
project = get_project(os.getcwd(), config_path, environment=env)
tlc = TopLevelCommand(project)
yield tlc
except Exception: # noqa: B902
raise
def test_up_with_multiple_files(self):
self.base_dir = 'tests/fixtures/override-files'
config_paths = [
'docker-compose.yml',
'docker-compose.override.yml',
'extra.yml',
]
self._project = get_project(self.base_dir, config_paths)
self.dispatch(
[
'-f', config_paths[0],
'-f', config_paths[1],
'-f', config_paths[2],
'up', '-d',
],
None)
containers = self.project.containers()
self.assertEqual(len(containers), 3)
web, other, db = containers
self.assertEqual(web.human_readable_command, 'top')
self.assertTrue({'db', 'other'} <= set(web.links()))
self.assertEqual(db.human_readable_command, 'top')
self.assertEqual(other.human_readable_command, 'top')
def test_up_with_network_mode(self):
c = self.client.create_container('busybox', 'top', name='composetest_network_mode_container')
self.addCleanup(self.client.remove_container, c, force=True)
self.client.start(c)
container_mode_source = 'container:{}'.format(c['Id'])
filename = 'network-mode.yml'
self.base_dir = 'tests/fixtures/networks'
self._project = get_project(self.base_dir, [filename])
self.dispatch(['-f', filename, 'up', '-d'], None)
networks = [
n for n in self.client.networks()
if n['Name'].startswith('{}_'.format(self.project.name))
]
assert not networks
for name in ['bridge', 'host', 'none']:
container = self.project.get_service(name).containers()[0]
assert list(container.get('NetworkSettings.Networks')) == [name]
assert container.get('HostConfig.NetworkMode') == name
service_mode_source = 'container:{}'.format(
self.project.get_service('bridge').containers()[0].id)
service_mode_container = self.project.get_service('service').containers()[0]
assert not service_mode_container.get('NetworkSettings.Networks')
assert service_mode_container.get('HostConfig.NetworkMode') == service_mode_source
container_mode_container = self.project.get_service('container').containers()[0]
assert not container_mode_container.get('NetworkSettings.Networks')
assert container_mode_container.get('HostConfig.NetworkMode') == container_mode_source
def _main(self, *args):
# docker compose do not kill the container odoo as is was run
# manually, so we implement our own kill
project = get_project('.', config_path=[
self.config_path.decode('utf-8')])
containers = project.containers(one_off=OneOffFilter.include)
parallel_kill(containers, {'signal': 'SIGKILL'})
def test_env_file_relative_to_compose_file(self):
config_path = os.path.abspath('tests/fixtures/env-file/docker-compose.yml')
self.dispatch(['-f', config_path, 'up', '-d'], None)
self._project = get_project(self.base_dir, [config_path])
containers = self.project.containers(stopped=True)
self.assertEqual(len(containers), 1)
self.assertIn("FOO=1", containers[0].get('Config.Env'))
def test_env_file_relative_to_compose_file(self):
config_path = os.path.abspath('tests/fixtures/env-file/docker-compose.yml')
self.dispatch(['-f', config_path, 'up', '-d'], None)
self._project = get_project(self.base_dir, [config_path])
containers = self.project.containers(stopped=True)
self.assertEqual(len(containers), 1)
self.assertIn("FOO=1", containers[0].get('Config.Env'))
def project(self):
config_path = config_path_for_environment_name(self.ctx.playbook_path,
self.environment_name)
return get_project(project_dir=self.ctx.playbook_dir_path.strpath,
config_path=config_path,
project_name=self.ctx.compose_project_name(
self.environment_name))
def test_get_project(self):
base_dir = 'tests/fixtures/longer-filename-composefile'
env = Environment.from_env_file(base_dir)
env['COMPOSE_API_VERSION'] = DEFAULT_DOCKER_API_VERSION
project = get_project(base_dir, environment=env)
assert project.name == 'longer-filename-composefile'
assert project.client
assert project.services
def project(self):
# Hack: allow project to be overridden. This needs refactoring so that
# the project object is built exactly once, by the command object, and
# accessed by the test case object.
if hasattr(self, '_project'):
return self._project
return get_project(self.command.base_dir)
def project(self):
config_path = config_path_for_environment_name(
self.ctx.playbook_path, self.environment_name)
return get_project(
project_dir=self.ctx.playbook_dir_path.strpath,
config_path=config_path,
project_name=self.ctx.compose_project_name(self.environment_name))
def test_env_file_relative_to_compose_file(self):
config_path = os.path.abspath("tests/fixtures/env-file/docker-compose.yml")
self.dispatch(["-f", config_path, "up", "-d"], None)
self._project = get_project(self.base_dir, [config_path])
containers = self.project.containers(stopped=True)
self.assertEqual(len(containers), 1)
self.assertIn("FOO=1", containers[0].get("Config.Env"))
def project(self):
# Hack: allow project to be overridden. This needs refactoring so that
# the project object is built exactly once, by the command object, and
# accessed by the test case object.
if hasattr(self, '_project'):
return self._project
return get_project(self.command.base_dir)
def create_dump(ctx):
manifest_log = StringIO()
manifest_handler = logging.StreamHandler(manifest_log)
setup_loghandler(manifest_handler, ctx.options["verbose"])
log.addHandler(manifest_handler)
scopes = ctx.options["scopes"]
meta = ctx.manifest["meta"] = OrderedDict()
meta["invocation_time"] = datetime.now().isoformat()
meta["finish_time"] = None
meta["argv"] = sys.argv
meta["options"] = ctx.options
meta["host"] = gethostname()
meta["uid"] = os.getuid()
meta["gid"] = os.getgid()
meta["version"] = VERSION
init_storage(ctx)
base_dir = str(ctx.options["project_dir"])
config_path = get_config_path_from_options(
base_dir, {"--file": ctx.options["compose_files"]}, ctx.environment
)
ctx.project = get_project(
base_dir,
config_path=config_path,
project_name=ctx.options["project_name"],
verbose=ctx.options["verbose"],
host=None,
tls_config=None,
environment=ctx.environment,
)
if "config" in scopes:
store_config(ctx)
if "mounted" in scopes or "volumes" in scopes:
if not ctx.options["no_pause"]:
ctx.project.pause(service_names=ctx.options["services"])
store_volumes(ctx)
if not ctx.options["no_pause"]:
ctx.project.unpause(service_names=ctx.options["services"])
meta["finish_time"] = datetime.now().isoformat()
normalize_manifest_mapping(ctx.manifest)
manifest_log.seek(0)
doc = yaml.dump(ctx.manifest, default_flow_style=False)
doc += "---\n"
doc += yaml.dump(
[x.strip() for x in manifest_log.readlines() if x], default_style='"'
)
ctx.storage.write_file(doc, "Manifest.yml")
ctx.storage.finalize()
def main(self, *args):
project = get_project('.', [self.config_path])
container = project.containers(service_names=[self.main_service],
one_off=OneOffFilter.include)
if container:
self._exec('docker', ["exec", "-ti", container[0].name, "bash"])
else:
raise_error("No container found for the service odoo "
"in the project %s" % project.name)
def test_up_with_default_network_config(self):
filename = 'default-network-config.yml'
self.base_dir = 'tests/fixtures/networks'
self._project = get_project(self.base_dir, [filename])
self.dispatch(['-f', filename, 'up', '-d'], None)
networks = self.client.networks(names=[self.project.default_network.full_name])
assert networks[0]['Options']['com.docker.network.bridge.enable_icc'] == 'false'
def main(self, *args):
project = get_project('.', [self.config_path])
container = project.containers(
service_names=[self.main_service], one_off=OneOffFilter.include)
if container:
self._exec('docker',
["exec", "-ti", container[0].name, "bash"])
else:
raise_error("No container found for the service odoo "
"in the project %s" % project.name)
def test_up_with_default_network_config(self):
filename = "default-network-config.yml"
self.base_dir = "tests/fixtures/networks"
self._project = get_project(self.base_dir, [filename])
self.dispatch(["-f", filename, "up", "-d"], None)
networks = self.client.networks(names=[self.project.default_network.full_name])
assert networks[0]["Options"]["com.docker.network.bridge.enable_icc"] == "false"
async def load_apps_and_apis(self):
if not getattr(self, "path", False) and getattr(self, "db", False):
raise AppRepo.RepositoryNotInitialized
self.apps = {}
await self.get_loaded_apis()
with open("./umpire/builtin.yaml") as f:
builtin = yaml.safe_load(f)
if builtin.get("name") not in self.loaded_apis:
await self.store_api(builtin)
for app in self.path.iterdir():
if not app.is_dir():
try:
zip_ref = zipfile.ZipFile(app, 'r')
zip_ref.extractall("apps/")
zip_ref.close()
os.remove(app)
except Exception as e:
logger.error(f"Zip error: {e}")
continue
for app in self.path.iterdir():
# grabs only directories and ignores all __* directories i.e. __pycache__
if app.is_dir() and not re.fullmatch(r"(__.*)", app.name):
self.apps[app.name] = {}
for version in app.iterdir():
# grabs all valid version directories of form "v0.12.3.45..."
if re.fullmatch(r"((\d\.?)+)", version.name):
try:
# Store the api while we've got it here
app_api_path = {fname for fname in {"api.yaml", "api.yml"} if (version / fname).exists()}
api = load_app_api(version / app_api_path.pop())
# The yaml was invalid and we logged that so lets skip it.
if api is None:
continue
await self.store_api(api)
project = get_project(version)
if not len(project.services) == 1:
logger.error(
f"{app.name}:{version.name} compose file must define exactly one(1) service.")
else:
self.apps[app.name][version.name] = project
except ConnectionError:
logger.exception("Error connecting to Docker daemon while getting project.")
# TODO: Improve the error handling here
except Exception:
logger.exception(f"Error during {app.name}:{version.name} load.")
logger.info(f"Loaded {app.name} versions: {list(self.apps[app.name].keys())}")
def run(src_path=None, mode='full', build='yes'):
"""
run is used to run (like docker-compose up)
:param src_path: path to folder of running package
:param mode:
full or env:
- env is environment running.
- full is service with environment running
:param build: is needed to build service container (like docker-compose up --build)
:return:
"""
global codes
if src_path is None:
src_path = './'
if mode == 'full': # TODO: NOT TESTED
file_path = f'{src_path}deployments/docker-compose.full.yml'
elif mode == 'env':
file_path = f'{src_path}deployments/docker-compose.env.yml'
else:
raise NotImplementedError('undefined mode')
if mode == 'full':
print('building container')
project = command_compose.get_project(project_dir='.',
config_path=[file_path])
build = build.lower()
if build == 'yes':
build_mode = service.BuildAction.force
elif build == 'no':
build_mode = None
else:
raise NotImplementedError('build may be only [yes, no]')
services = project.up(detached=True, do_build=build_mode)
if mode == 'full':
print('container started')
failed = False
codes = {}
for s in services:
if s.exit_code == 137:
codes[s.name] = init_pkg.DockerCompose.Started
continue
if s.exit_code == 0:
codes[s.name] = init_pkg.DockerCompose.AlreadyWorks
continue
codes[s.name] = f'status code: {s.exit_code}'
failed = True
if not failed:
print(
f'OK. all service exited with zero status codes. services: {codes}'
)
return
project.kill() # TODO: NOT TESTED
print(
f'FAILED. all service exited with NON-zero status codes. state: {codes}'
)
return
def run_docker_compose(network_prefix, environment, working_directory):
client = docker.from_env()
client.images.pull('jwilder/nginx-proxy')
try:
nginx_proxy = client.containers.list(
filters={'name': 'nginx-proxy'}).pop(0)
except IndexError:
ports = {
'8000/tcp': '8000',
'8001/tcp': '8001',
'8002/tcp': '8002',
'8003/tcp': '8003',
}
volumes = {
'/var/run/docker.sock': {'bind': '/tmp/docker.sock', 'mode': 'ro'},
os.getcwd() + '/nginx-proxy': {'bind': '/app/'}
}
nginx_proxy = client.containers.run('jwilder/nginx-proxy',
ports=ports,
volumes=volumes,
name="nginx-proxy",
detach=True)
if not os.path.isfile(working_directory + '/docker-compose.yml'):
print "No docker-compose file found"
return True
compose_network = None
try:
for network in client.networks.list([network_prefix + '_default']):
if network.name == network_prefix + '_default':
compose_network = network
break
except IndexError:
pass
if compose_network:
try:
print('disconnect ' + compose_network.name)
compose_network.disconnect(nginx_proxy)
except APIError:
pass
else:
compose_network = client.networks.create(network_prefix + '_default')
compose_network.connect(nginx_proxy)
os.environ = environment
project = get_project(working_directory)
project.pull()
project.build(pull=True)
project.up(detached=True)
return True
def get_dork_project(plugins, project_dir, config_path=None, project_name=None,
verbose=False, host=None, tls_config=None,
environment=None):
cmd.config.load = partial(dork_config_load, plugins)
project = get_project(project_dir, config_path, project_name, verbose, host, tls_config, environment)
if 'COMPOSE_PROJECT_NAME' in os.environ:
project.name = os.environ['COMPOSE_PROJECT_NAME']
return DorkProject.from_project(project, plugins)
def test_ps_alternate_composefile(self):
config_path = os.path.abspath("tests/fixtures/multiple-composefiles/compose2.yml")
self._project = get_project(self.base_dir, [config_path])
self.base_dir = "tests/fixtures/multiple-composefiles"
self.dispatch(["-f", "compose2.yml", "up", "-d"])
result = self.dispatch(["-f", "compose2.yml", "ps"])
self.assertNotIn("multiplecomposefiles_simple_1", result.stdout)
self.assertNotIn("multiplecomposefiles_another_1", result.stdout)
self.assertIn("multiplecomposefiles_yetanother_1", result.stdout)
def init_project(orgId):
print("[init_project]: Compose project init started...")
namespace, api_data, repl = create_customer(orgId)
environment = Environment.from_env_file(FOLDER_PATH)
config_path = get_config_path_from_options(FOLDER_PATH, dict(),
environment)
project = get_project(FOLDER_PATH, config_path, namespace)
project_name = get_project_name(FOLDER_PATH, namespace)
print("[init_project]: Compose project init finished...")
return (project, namespace, api_data, repl)
def __load_project(path):
'''
Load a docker-compose project from path
:param path:
:return:
'''
try:
project = get_project(path)
except Exception as inst:
return __handle_except(inst)
return project
def test_ls_alternate_composefile(self):
config_path = os.path.abspath(
'tests/fixtures/multiple-composefiles/compose2.yml')
self._project = get_project(self.command.base_dir, [config_path])
self.command.base_dir = 'tests/fixtures/multiple-composefiles'
with mock.patch('sys.stdout', new_callable=StringIO) as mock_stdout:
self.command.dispatch(['-f', 'compose2.yml', 'ls'], None)
output = mock_stdout.getvalue()
self.assertNotIn('simple', output)
self.assertIn('yetanother', output)
def test_ps_alternate_composefile(self):
config_path = os.path.abspath(
'tests/fixtures/multiple-composefiles/compose2.yml')
self._project = get_project(self.base_dir, [config_path])
self.base_dir = 'tests/fixtures/multiple-composefiles'
self.dispatch(['-f', 'compose2.yml', 'up', '-d'])
result = self.dispatch(['-f', 'compose2.yml', 'ps'])
self.assertNotIn('multiplecomposefiles_simple_1', result.stdout)
self.assertNotIn('multiplecomposefiles_another_1', result.stdout)
self.assertIn('multiplecomposefiles_yetanother_1', result.stdout)
def test_ps_alternate_composefile(self):
config_path = os.path.abspath(
'tests/fixtures/multiple-composefiles/compose2.yml')
self._project = get_project(self.base_dir, [config_path])
self.base_dir = 'tests/fixtures/multiple-composefiles'
self.dispatch(['-f', 'compose2.yml', 'up', '-d'])
result = self.dispatch(['-f', 'compose2.yml', 'ps'])
self.assertNotIn('multiplecomposefiles_simple_1', result.stdout)
self.assertNotIn('multiplecomposefiles_another_1', result.stdout)
self.assertIn('multiplecomposefiles_yetanother_1', result.stdout)
def __load_project(path):
'''
Load a docker-compose project from path
:param path:
:return:
'''
try:
project = get_project(path)
except Exception as inst:
return __handle_except(inst)
return project
def test_up_with_default_network_config(self):
filename = 'default-network-config.yml'
self.base_dir = 'tests/fixtures/networks'
self._project = get_project(self.base_dir, [filename])
self.dispatch(['-f', filename, 'up', '-d'], None)
network_name = self.project.networks.networks['default'].full_name
networks = self.client.networks(names=[network_name])
assert networks[0]['Options']['com.docker.network.bridge.enable_icc'] == 'false'
def __init__(self):
self.base_dir = abspath(join(dirname(__file__), "..", "..", "docker", "dev", "hydrachain"))
self.docker_host = None
if os.environ.get('DOCKER_HOST'):
self.docker_host = urlsplit(os.environ['DOCKER_HOST']).netloc.partition(":")[0]
# This needs to happen before the `get_project()` call below since it caches os.environ.
os.environ['HYDRACHAIN_HOST_PREFIX'] = PROJECT_NAME
self.project = get_project(self.base_dir, project_name=PROJECT_NAME)
self._modify_service_config()
self.project.build()
def test_ps_alternate_composefile(self, mock_stdout):
config_path = os.path.abspath(
'tests/fixtures/multiple-composefiles/compose2.yml')
self._project = get_project(self.command.base_dir, [config_path])
self.command.base_dir = 'tests/fixtures/multiple-composefiles'
self.command.dispatch(['-f', 'compose2.yml', 'up', '-d'], None)
self.command.dispatch(['-f', 'compose2.yml', 'ps'], None)
output = mock_stdout.getvalue()
self.assertNotIn('multiplecomposefiles_simple_1', output)
self.assertNotIn('multiplecomposefiles_another_1', output)
self.assertIn('multiplecomposefiles_yetanother_1', output)
def setUpClass(cls):
environment = docker_compose_env.Environment.from_env_file(".")
cls.sut = docker_compose_cmd.get_project('.',
environment=environment,
verbose=True)
cls.sut.pull()
cls.sut.up()
dsn = "host={host} dbname=template1 user=postgres connect_timeout=1".format(
host=os.getenv("PGHOST", "localhost"))
cls.db = psycopg2.connect(dsn)
cls.db.autocommit = True
wait_for_event_playback(3) # Wait for install and start of xrpcd
def __load_project_from_file_path(file_path):
'''
Load a docker-compose project from file path
:param path:
:return:
'''
try:
project = get_project(project_dir=os.path.dirname(file_path),
config_path=[os.path.basename(file_path)])
except Exception as inst:
return __handle_except(inst)
return project
def test_env_file_override(self):
base_dir = 'tests/fixtures/env-file-override'
dispatch(base_dir, ['--env-file', '.env.override', 'up'])
project = get_project(project_dir=base_dir,
config_path=['docker-compose.yml'],
environment=Environment.from_env_file(
base_dir, '.env.override'),
override_dir=base_dir)
containers = project.containers(stopped=True)
assert len(containers) == 1
assert "WHEREAMI=override" in containers[0].get('Config.Env')
assert "DEFAULT_CONF_LOADED=true" in containers[0].get('Config.Env')
dispatch(base_dir, ['--env-file', '.env.override', 'down'], None)
def test_dot_env_file(self):
base_dir = 'tests/fixtures/env-file-override'
# '.env' is relative to the project_dir (base_dir)
env = Environment.from_env_file(base_dir, None)
dispatch(base_dir, ['up'])
project = get_project(project_dir=base_dir,
config_path=['docker-compose.yml'],
environment=env,
override_dir=base_dir)
containers = project.containers(stopped=True)
assert len(containers) == 1
assert "WHEREAMI=default" in containers[0].get('Config.Env')
dispatch(base_dir, ['down'], None)
def create_dump(ctx):
manifest_log = StringIO()
manifest_handler = logging.StreamHandler(manifest_log)
setup_loghandler(manifest_handler, ctx.options['verbose'])
log.addHandler(manifest_handler)
scopes = ctx.options['scopes']
meta = ctx.manifest['meta'] = OrderedDict()
meta['invocation_time'] = datetime.now().isoformat()
meta['finish_time'] = None
meta['argv'] = sys.argv
meta['options'] = ctx.options
meta['host'] = gethostname()
meta['uid'] = os.getuid()
meta['gid'] = os.getgid()
meta['version'] = VERSION
init_storage(ctx)
base_dir = str(ctx.options['project_dir'])
config_path = get_config_path_from_options(
base_dir, {'--file': ctx.options['compose_files']}, ctx.environment)
ctx.project = \
get_project(base_dir, config_path=config_path,
project_name=ctx.options['project_name'],
verbose=ctx.options['verbose'], host=None, tls_config=None, environment=ctx.environment)
if 'config' in scopes:
store_config(ctx)
if 'mounted' in scopes or 'volumes' in scopes:
if not ctx.options['no_pause']:
ctx.project.pause(service_names=ctx.options['services'])
store_volumes(ctx)
if not ctx.options['no_pause']:
ctx.project.unpause(service_names=ctx.options['services'])
meta['finish_time'] = datetime.now().isoformat()
normalize_manifest_mapping(ctx.manifest)
manifest_log.seek(0)
doc = yaml.dump(ctx.manifest, default_flow_style=False)
doc += '---\n'
doc += yaml.dump([x.strip() for x in manifest_log.readlines() if x],
default_style='"')
ctx.storage.write_file(doc, 'Manifest.yml')
ctx.storage.finalize()
def create_dump(ctx):
manifest_log = StringIO()
manifest_handler = logging.StreamHandler(manifest_log)
setup_loghandler(manifest_handler, ctx.options['verbose'])
log.addHandler(manifest_handler)
scopes = ctx.options['scopes']
meta = ctx.manifest['meta'] = OrderedDict()
meta['invocation_time'] = datetime.now().isoformat()
meta['finish_time'] = None
meta['argv'] = sys.argv
meta['options'] = ctx.options
meta['host'] = gethostname()
meta['uid'] = os.getuid()
meta['gid'] = os.getgid()
meta['version'] = __version__
init_storage(ctx)
base_dir = str(ctx.options['project_dir'])
config_path = get_config_path_from_options(
base_dir, {'--file': ctx.options['compose_files']}, ctx.environment)
ctx.project = \
get_project(base_dir, config_path=config_path,
project_name=ctx.options['project_name'],
verbose=ctx.options['verbose'], host=None, tls_config=None, environment=ctx.environment)
if 'config' in scopes:
store_config(ctx)
if 'mounted' in scopes or 'volumes' in scopes:
if ctx.options['no_pause']:
ctx.project.pause(service_names=ctx.options['services'])
store_volumes(ctx)
if ctx.options['no_pause']:
ctx.project.unpause(service_names=ctx.options['services'])
meta['finish_time'] = datetime.now().isoformat()
normalize_manifest_mapping(ctx.manifest)
manifest_log.seek(0)
doc = yaml.dump(ctx.manifest, default_flow_style=False)
doc += '---\n'
doc += yaml.dump([x.strip() for x in manifest_log.readlines() if x], default_style='"')
ctx.storage.write_file(doc, 'Manifest.yml')
ctx.storage.finalize()
def test_up_with_multiple_files(self):
self.base_dir = "tests/fixtures/override-files"
config_paths = ["docker-compose.yml", "docker-compose.override.yml", "extra.yml"]
self._project = get_project(self.base_dir, config_paths)
self.dispatch(["-f", config_paths[0], "-f", config_paths[1], "-f", config_paths[2], "up", "-d"], None)
containers = self.project.containers()
self.assertEqual(len(containers), 3)
web, other, db = containers
self.assertEqual(web.human_readable_command, "top")
self.assertTrue({"db", "other"} <= set(get_links(web)))
self.assertEqual(db.human_readable_command, "top")
self.assertEqual(other.human_readable_command, "top")
def kill(src_path=None):
"""
kill is used to kill your docker-compose (like docker-compose kill)
:param src_path: path to folder of killing docker-compose
:return:
"""
if src_path is None:
src_path = './'
path = src_path + 'deployments/'
paths = [f'{path}docker-compose.full.yml', f'{path}docker-compose.env.yml']
project_dir = '.'
for file_path in paths:
project = command_compose.get_project(project_dir, [file_path])
project.kill()
def test_up_with_bridge_network_plus_default(self):
filename = 'bridge.yml'
self.base_dir = 'tests/fixtures/networks'
self._project = get_project(self.base_dir, [filename])
self.dispatch(['-f', filename, 'up', '-d'], None)
container = self.project.containers()[0]
assert sorted(list(container.get('NetworkSettings.Networks'))) == sorted([
'bridge',
self.project.default_network.full_name,
])
def deploy_service():
env = parser_vars()
make_swarm_env()
scale_conf = make_compose_file()
print os.popen("cd swarm-master && eval `cat activite` && cd .. && docker info").read()
from compose.cli import command
project = command.get_project(CUR_PATH)
services = project.services
project.stop()
project.remove_stopped()
for service in services:
scale = scale_conf.get(service.name)
if scale:
service.scale(scale)
def __load_project_from_file_path(file_path):
"""
Load a docker-compose project from file path
:param path:
:return:
"""
try:
project = get_project(
project_dir=os.path.dirname(file_path),
config_path=[os.path.basename(file_path)],
)
except Exception as inst: # pylint: disable=broad-except
return __handle_except(inst)
return project
def __init__(self):
self.base_dir = abspath(
join(dirname(__file__), "..", "..", "docker", "dev", "hydrachain"))
self.docker_host = None
if os.environ.get('DOCKER_HOST'):
self.docker_host = urlsplit(
os.environ['DOCKER_HOST']).netloc.partition(":")[0]
# This needs to happen before the `get_project()` call below since it caches os.environ.
os.environ['HYDRACHAIN_HOST_PREFIX'] = PROJECT_NAME
self.project = get_project(self.base_dir, project_name=PROJECT_NAME)
self._modify_service_config()
self.project.build()
def test_up_predefined_networks(self):
filename = 'predefined-networks.yml'
self.base_dir = 'tests/fixtures/networks'
self._project = get_project(self.base_dir, [filename])
self.dispatch(['-f', filename, 'up', '-d'], None)
networks = [
n for n in self.client.networks()
if n['Name'].startswith('{}_'.format(self.project.name))
]
assert not networks
for name in ['bridge', 'host', 'none']:
container = self.project.get_service(name).containers()[0]
assert list(container.get('NetworkSettings.Networks')) == [name]
assert container.get('HostConfig.NetworkMode') == name
def test_up_with_external_default_network(self):
filename = "external-default.yml"
self.base_dir = "tests/fixtures/networks"
self._project = get_project(self.base_dir, [filename])
result = self.dispatch(["-f", filename, "up", "-d"], returncode=1)
assert "declared as external, but could not be found" in result.stderr
networks = [n["Name"] for n in self.client.networks() if n["Name"].startswith("{}_".format(self.project.name))]
assert not networks
network_name = "composetest_external_network"
self.client.create_network(network_name)
self.dispatch(["-f", filename, "up", "-d"])
container = self.project.containers()[0]
assert list(container.get("NetworkSettings.Networks")) == [network_name]
def test_up_with_external_default_network(self):
filename = 'external-default.yml'
self.base_dir = 'tests/fixtures/networks'
self._project = get_project(self.base_dir, [filename])
result = self.dispatch(['-f', filename, 'up', '-d'], returncode=1)
assert 'declared as external, but could not be found' in result.stderr
networks = [
n['Name'] for n in self.client.networks()
if n['Name'].startswith('{}_'.format(self.project.name))
]
assert not networks
network_name = 'composetest_external_network'
self.client.create_network(network_name)
self.dispatch(['-f', filename, 'up', '-d'])
container = self.project.containers()[0]
assert list(container.get('NetworkSettings.Networks')) == [network_name]
def test_get_project(self):
base_dir = 'tests/fixtures/longer-filename-composefile'
project = get_project(base_dir)
self.assertEqual(project.name, 'longerfilenamecomposefile')
self.assertTrue(project.client)
self.assertTrue(project.services)
def __init__(self, name, dir):
self.project = command.get_project(project_dir=dir, project_name=name)
self.containers = []
def compose_project(cls):
return get_project(cls.COMPOSE_PROJECT_DIR, project_name=os.environ.get('DOCKER_COMPOSE_PROJECT_NAME'))
def project(self):
# Hack: allow project to be overridden
if not hasattr(self, '_project'):
self._project = get_project(self.base_dir)
return self._project
def main(self, *args):
# docker compose do not kill the container odoo as is was run
# manually, so we implement our own kill
project = get_project('.', config_path=[self.config_path])
containers = project.containers(one_off=OneOffFilter.include)
parallel_kill(containers, {'signal': 'SIGKILL'})
def test_get_project(self):
base_dir = 'tests/fixtures/longer-filename-composefile'
project = get_project(base_dir)
assert project.name == 'longer-filename-composefile'
assert project.client
assert project.services
