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