Add support for cross-file service dependency

podman_compose.py

@@ -1013,19 +1013,13 @@ def rec_deps(services, service_name, start_point=None):
  return deps
 
 
-def flat_deps(services, with_extends=False):
+def flat_deps(services):
  """
  create dependencies "_deps" or update it recursively for all services
  """
  for name, srv in services.items():
  deps = set()
  srv["_deps"] = deps
- if with_extends:
- ext = srv.get("extends", {}).get("service", None)
- if ext:
- if ext != name:
- deps.add(ext)
- continue
  deps_ls = srv.get("depends_on", None) or []
  if is_str(deps_ls):
  deps_ls = [deps_ls]
@@ -1211,7 +1205,9 @@ def rec_merge_one(target, source):
  raise ValueError(
  f"can't merge value of {key} of type {value_type} and {value2_type}"
  )
- if is_list(value2):
+ if type(value) == set:
+ value = value.update(value2)
+ elif is_list(value2):
  if key == "volumes":
  # clean duplicate mount targets
  pts = {v.split(":", 1)[1] for v in value2 if ":" in v}
@@ -1241,36 +1237,179 @@ def rec_merge(target, *sources):
  return ret
 
 
-def resolve_extends(services, service_names, environ):
- for name in service_names:
- service = services[name]
- ext = service.get("extends", {})
- if is_str(ext):
- ext = {"service": ext}
- from_service_name = ext.get("service", None)
- if not from_service_name:
- continue
- filename = ext.get("file", None)
- if filename:
- if filename.startswith("./"):
- filename = filename[2:]
+class ComposeFileParsingException(Exception):
+ pass
+
+class ComposeFileParsingCircularDependencyException(ComposeFileParsingException):
+ pass
+
+def pretty_print_tuple(tup, data):
+ file, service = tup
+ if file is None:
+ return ",".join(data), service
+ return file, service
+
+class OrderedSet():
+ def __init__(self):
+ self.as_list = list()
+ self.as_set = set()
+
+ def pop(self):
+ r = self.as_list.pop()
+ self.as_set.remove(r)
+
+ def add(self, element):
+ self.as_list.append(element)
+ self.as_set.add(element)
+
+ def __contains__(self, element):
+ return element in self.as_set
+
+ def __str__(self):
+ return str(self.as_list)
+
+ def pretty_print(self, data):
+ new_list = []
+ for tup in self.as_list:
+ new_list.append(pretty_print_tuple(tup,data))
+ return new_list
+
+class CachedComposeFileParser():
+ """
+ This class handles preprocessed merged_yaml, and then recursively updates services
+ in order to remove extends field
+ # TODO: make all parsing recursive and move it to this class
+ """
+ def __init__(self, environ, files):
+ self.environ = environ
+ self.merged_yaml = {}
+ self.merged_files = [os.path.realpath(file) for file in files]
+ self.cache = dict()
+
+ def generate_compose(self):
+ for filename in self.merged_files:
  with open(filename, "r", encoding="utf-8") as f:
- content = yaml.safe_load(f) or {}
+ content = yaml.safe_load(f)
+ # log(filename, json.dumps(content, indent = 2))
+ if not isinstance(content, dict):
+ raise ComposeFileParsingException(
+ "Compose file does not contain a top level object: %s\n"
+ % filename
+ )
+ content = normalize(content)
+ # log(filename, json.dumps(content, indent = 2))
+ content = rec_subs(content, self.environ)
+ rec_merge(self.merged_yaml, content)
+ return self.merged_yaml
+
+ def read_file_and_cache_it(self, filename):
+ real_file = os.path.realpath(filename)
+ if real_file in self.merged_files:
+ return self.merged_yaml
+ if real_file not in self.cache:
+ with open(filename, "r", encoding="utf-8") as f:
+ content = yaml.safe_load(f) or dict()
  if "services" in content:
- content = content["services"]
- subdirectory = os.path.dirname(filename)
- content = rec_subs(content, environ)
- from_service = content.get(from_service_name, {})
- normalize_service(from_service, subdirectory)
- else:
- from_service = services.get(from_service_name, {}).copy()
- del from_service["_deps"]
- try:
- del from_service["extends"]
- except KeyError:
- pass
- new_service = rec_merge({}, from_service, service)
- services[name] = new_service
+ services = content["services"]
+ services = rec_subs(services, self.environ)
+ content['services'] = services
+ self.cache[real_file] = content
+ return self.cache[real_file]
+
+ def _pretty_file(self, name):
+ if name is None:
+ # merged docker-compose files passed to script
+ # are treated as a single file
+ return ",".join(self.merged_files)
+ return name
+
+ def _service_not_found(self, service_name, parent_service_name, parent_filename):
+ pretty_file = self._pretty_file(parent_filename)
+ msg = f"Service {service_name} has dependency of '{parent_service_name}" \
+ f"which does not exist in {pretty_file}"
+ raise ComposeFileParsingException(msg)
+
+ def resolve_extend(self, services, service, service_name, current_filename,
+ circular_dep_detector):
+ def patch_parent_filename_if_default(parent_filename):
+ if os.path.isabs(parent_filename):
+ return parent_filename
+ temp_name = current_filename
+ if temp_name is None:
+ temp_name = self.merged_files[0]
+ parent_filename = os.path.join(os.path.dirname(temp_name), parent_filename)
+ return parent_filename
+ if current_filename is not None:
+ current_filename = os.path.realpath(current_filename)
+ if current_filename in self.merged_files:
+ current_filename = None
+ service_unique_identifier = (current_filename, service_name,)
+ if service_unique_identifier in circular_dep_detector:
+ msg = f"Circular dependency to {pretty_print_tuple(service_unique_identifier, self.merged_files)} " \
+ f"detected: {circular_dep_detector.pretty_print(self.merged_files)}"
+ raise ComposeFileParsingCircularDependencyException(msg)
+ circular_dep_detector.add(service_unique_identifier)
+ try:
+ extends_section = service.get("extends")
+ if extends_section is None:
+ return service
+
+ if is_str(extends_section):
+ parent_service_name = extends_section
+ else:
+ parent_service_name = extends_section.get("service")
+
+ if parent_service_name is None:
+ pretty_name = self._pretty_file(current_filename)
+ raise ComposeFileParsingException(f"Service {service_name} in {pretty_name} has" \
+ f"extends field and no service name")
+ parent_filename = extends_section.get("file")
+ if parent_filename:
+ if parent_filename.startswith("./"):
+ parent_filename = parent_filename[2:]
+ subdirectory = os.path.dirname(parent_filename)
+ parent_filename = patch_parent_filename_if_default(parent_filename)
+ content = self.read_file_and_cache_it(parent_filename)
+ # ADDED: normalize each service later
+ from_service_ref = content['services'].get(parent_service_name)
+ if from_service_ref is None:
+ self._service_not_found(service_name, parent_service_name, parent_filename)
+ from_service_ref = self.resolve_extend(content['services'],from_service_ref, parent_service_name,
+ parent_filename, circular_dep_detector)
+ from_service_ref = normalize_service(from_service_ref, subdirectory)
+ content[parent_service_name] = from_service_ref
+ from_service = from_service_ref.copy()
+ else:
+ mutable_parent_service = services.get(parent_service_name)
+ if mutable_parent_service is None:
+ self._service_not_found(service_name, parent_service_name, current_filename)
+ from_service_ref = self.resolve_extend(services, mutable_parent_service,
+ parent_service_name, current_filename, circular_dep_detector)
+ from_service = from_service_ref.copy()
+ assert 'extends' in service # ensure, same service is not processed twice
+ del service['extends']
+ normalize_service(service)
+ services[service_name] = rec_merge(dict(), from_service, service)
+ assert services[service_name] is not None
+ finally:
+ circular_dep_detector.pop()
+ return services[service_name]
+
+ def parse_services(self):
+ # if current_filename is None it means
+ # we are handling merged compose file
+ current_filename = ",".join(self.merged_files)
+ services = self.merged_yaml.get("services", None)
+ if services is None:
+ services = {}
+ log(f"WARNING: No services defined in {current_filename}")
+ for service_name in services.keys():
+ services[service_name] = self.resolve_extend(services, services[service_name],
+ service_name, current_filename,
+ OrderedSet())
+ assert services[service_name] is not None
+ flat_deps(services)
+ return services
 
 
 def dotenv_to_dict(dotenv_path):
@@ -1444,21 +1583,10 @@ def _parse_compose_file(self):
  "COMPOSE_PATH_SEPARATOR": pathsep,
  }
  )
- compose = {}
- for filename in files:
- with open(filename, "r", encoding="utf-8") as f:
- content = yaml.safe_load(f)
- # log(filename, json.dumps(content, indent = 2))
- if not isinstance(content, dict):
- sys.stderr.write(
- "Compose file does not contain a top level object: %s\n"
- % filename
- )
- sys.exit(1)
- content = normalize(content)
- # log(filename, json.dumps(content, indent = 2))
- content = rec_subs(content, self.environ)
- rec_merge(compose, content)
+
+ parser = CachedComposeFileParser(self.environ, files)
+ compose = parser.generate_compose()
+
  self.merged_yaml = yaml.safe_dump(compose)
  merged_json_b = json.dumps(compose, separators=(",", ":")).encode("utf-8")
  self.yaml_hash = hashlib.sha256(merged_json_b).hexdigest()
@@ -1484,19 +1612,8 @@ def _parse_compose_file(self):
  self.project_name = project_name
  self.environ.update({"COMPOSE_PROJECT_NAME": self.project_name})
 
- services = compose.get("services", None)
- if services is None:
- services = {}
- log("WARNING: No services defined")
+ services = parser.parse_services()
 
- # NOTE: maybe add "extends.service" to _deps at this stage
- flat_deps(services, with_extends=True)
- service_names = sorted(
- [(len(srv["_deps"]), name) for name, srv in services.items()]
- )
- service_names = [name for _, name in service_names]
- resolve_extends(services, service_names, self.environ)
- flat_deps(services)
  service_names = sorted(
  [(len(srv["_deps"]), name) for name, srv in services.items()]
  )
@@ -1616,6 +1733,7 @@ def _parse_args(self):
  if not self.global_args.command or self.global_args.command == "help":
  parser.print_help()
  sys.exit(-1)
+ print(self.global_args)
  return self.global_args
 
  @staticmethod

pytests/test_recursive_parsing.py

@@ -0,0 +1,86 @@
+import argparse
+import pytest
+import subprocess
+import os
+from podman_compose import PodmanCompose, ComposeFileParsingCircularDependencyException
+from pathlib import Path
+
+
+NONEMPTY_STRING = "non_empty_string.yml"
+TESTS_PATH = Path(__file__).parent / '../tests/'
+
+def fake_podman_env():
+ env_with_fake_podman = os.environ.copy()
+ here = TESTS_PATH / 'fake_podman'
+ env_with_fake_podman.update({
+ 'PATH': f"{here}:{os.getenv('PATH','')}"
+ })
+ return env_with_fake_podman
+
+def MockedPodmanCompose(compose_file: Path, *args, **kwargs):
+ pc = PodmanCompose()
+ pc.global_args = argparse.Namespace(file=[str(compose_file)],
+ project_name=None,
+ env_file=NONEMPTY_STRING,
+ no_pod=True, *args, **kwargs)
+ return pc
+
+def test_given_compose_file_and_no_deps_arg_when_run_then_only_one_service_is_up():
+ # https://github.com/containers/podman-compose/issues/398
+
+ run = subprocess.run([str((Path(__file__).parent / "../podman_compose.py").absolute()),
+ '--dry-run', '-f', str(TESTS_PATH /
+ 'extends_to_be_run/docker-compose.yml'), 'run',
+ 'sh', 'sh'],
+ env=fake_podman_env(),
+ stderr=subprocess.PIPE,
+ universal_newlines=True
+ )
+ assert 'podman run' in run.stderr
+
+def test_given_compose_file_with_mounts_when_parsing_then_mounts_resolved_correctly():
+ # https://github.com/containers/podman-compose/issues/462
+ pc = MockedPodmanCompose(
+ TESTS_PATH / 'extends_valid_mounts_resolved/docker-compose.yml')
+ pc._parse_compose_file()
+ assert set([
+ '/tmp/service_other-bash:/tmp/service_other-bash:rw',
+ '/tmp/service_bash:/tmp/service_bash:rw']) == set(pc.services['other-bash']['volumes'])
+
+
+def test_given_cli_volume_and_compose_file_volume_when_parsing_then_both_are_used():
+ # https://github.com/containers/podman-compose/issues/464
+ run = subprocess.run([str((Path(__file__).parent / "../podman_compose.py").absolute()),
+ '--dry-run', '-f', str(TESTS_PATH /
+ 'file_and_cli_mounts/docker-compose.yml'), 'run',
+ '-v', '/tmp/test:/tmp/test', 'sh', 'sh'],
+ env=fake_podman_env(),
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE,
+ universal_newlines=True
+ )
+ assert '-v /tmp/test:/tmp/test' in run.stderr
+ assert '-v /tmp/service_sh:/tmp/service_sh' in run.stderr
+
+def test_given_ping_pong_dependencies_between_two_files_when_parsing_then_resolved_correctly():
+ # https://github.com/containers/podman-compose/issues/465
+ pc = MockedPodmanCompose(
+ TESTS_PATH / 'extends_recursive/docker-compose.yml')
+ pc._parse_compose_file()
+ assert pc.services['sh1'].items() >= {
+ 'image': 'busybox',
+ 'volumes': ['/host/7:/cnt/7:rw', '/host/4:/cnt/4:rw', '/host/1:/cnt/1:rw']}.items()
+ assert pc.services['sh2'].items() >= {
+ 'image': 'busybox',
+ 'volumes': ['/host/7:/cnt/7:rw']}.items()
+ assert pc.services['sh3'].items() >= {
+ 'image': 'busybox',
+ 'volumes': ['/host/7:/cnt/7:rw']}.items()
+
+
+def tests_given_compose_file_with_circular_dependency_when_parsing_then_raises_exception():
+ # https://github.com/containers/podman-compose/issues/465
+ pc = MockedPodmanCompose(
+ TESTS_PATH / 'extends_recursive_circular/docker-compose.yml')
+ with pytest.raises(ComposeFileParsingCircularDependencyException) as e:
+ pc._parse_compose_file()