compose2pod 0.4.0__tar.gz → 0.4.2__tar.gz

{compose2pod-0.4.0 → compose2pod-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compose2pod
-Version: 0.4.0
+Version: 0.4.2
 Summary: Convert a Docker Compose file into a script that runs its services as a single Podman pod
 Keywords: podman,docker-compose,compose,pod,ci,testing,containers
 Author: Artur Shiriev

{compose2pod-0.4.0 → compose2pod-0.4.2}/compose2pod/emit.py

@@ -335,7 +335,13 @@ def _plan(compose: dict[str, Any], options: EmitOptions) -> PlannedScript:
     # Only the closure joins the pod, so only the closure is resolvable. A name
     # pointing at 127.0.0.1 for a service that never runs would turn an honest
     # resolution failure into a connection-refused.
-    hosts = hostnames({name: services[name] for name in order})
+    # The pod name is added as a resolvable name so every container's own
+    # hostname (set to the pod name below) resolves. A pod shares one UTS
+    # namespace, so without this the hostname is the random container ID,
+    # absent from the owned /etc/hosts -- `hostname -f` then fails and images
+    # that resolve their own hostname at startup crash. Podman used to add this
+    # line itself; `--no-hosts` stops it, so the script owns it too.
+    hosts = [*hostnames({name: services[name] for name in order}), options.pod]
     host_tokens = hosts_file_tokens(services, order, hosts)
     completion_gated = {
         dep
@@ -355,12 +361,20 @@ def _plan(compose: dict[str, Any], options: EmitOptions) -> PlannedScript:
     lines.append(f"trap '{teardown}' EXIT")
     pod_flags = pod_create_flags(services, order)
     _collect_vars(pod_flags, names)
-    pod_create = f"podman pod create --name {shlex.quote(options.pod)} --no-hosts"
+    # `--uts private` gives the pod its own UTS namespace so `--hostname` is
+    # settable (in the host UTS namespace Podman refuses it); the pod name is
+    # the shared hostname, resolvable via the line added to the hosts file above.
+    pod_name = shlex.quote(options.pod)
+    pod_create = f"podman pod create --name {pod_name} --no-hosts --uts private --hostname {pod_name}"
     if pod_flags:
         pod_create += " " + _render(pod_flags)
     lines.append(pod_create)
     _collect_vars(host_tokens, names)
     lines.append(f"printf '%s\\n' {_render(host_tokens)} > \"$hostsfile\"")
+    # mktemp creates the file 0600; make it world-readable so a service image
+    # running as a non-root user can read the bind-mounted /etc/hosts. Without
+    # this, glibc falls through to DNS and name resolution fails.
+    lines.append('chmod 644 "$hostsfile"')
     lines.extend(stores.create_lines(compose, order, options.pod, options.project_dir))
     names |= stores.referenced_variables(compose, order, options.project_dir)
     waited: set[str] = set()

{compose2pod-0.4.0 → compose2pod-0.4.2}/compose2pod/keys.py

@@ -111,8 +111,8 @@ def is_number(value: Any) -> bool:  # noqa: ANN401 - Compose values are untyped
     return not isinstance(value, bool) and isinstance(value, int | float | str)
 
 
-def require_string_keys(where: str, mapping: dict[Any, Any]) -> None:
-    """Check every key of a raw YAML/JSON mapping is a string.
+def require_string_keys(where: str, mapping: dict[Any, Any]) -> set[str]:
+    """Check every key of a raw YAML/JSON mapping is a string; return them.
 
     PyYAML routinely produces non-string keys (a bare `3:` is an int; under
     YAML 1.1, a bare `on:`/`off:` is a bool). Every mapping-key consumer
@@ -120,11 +120,18 @@ def require_string_keys(where: str, mapping: dict[Any, Any]) -> None:
     `str` and crashes raw otherwise. This is the one shared check the gate
     runs before it reads any of `mapping`'s keys, so a non-string key fails
     clean regardless of which mapping it turned up in.
+
+    Returns the validated keys as a `set[str]` so an unsupported-key check can
+    build on it directly (`require_string_keys(...) - KNOWN`) with a statically
+    sortable type, instead of re-deriving `set(mapping)` as `set[object]`.
     """
+    keys: set[str] = set()
     for key in mapping:
         if not isinstance(key, str):
             msg = f"{where}: key {key!r} must be a string"
             raise UnsupportedComposeError(msg)
+        keys.add(key)
+    return keys
 
 
 def _validate_list_elements(name: str, key: str, value: list[Any]) -> None:

{compose2pod-0.4.0 → compose2pod-0.4.2}/compose2pod/parsing.py

@@ -216,12 +216,12 @@ def _validate_volume_long_form(name: str, entry: dict[str, Any]) -> None:
     here) because the check itself needs `vtype` to know which sub-map key --
     `bind`/`volume`/`tmpfs` -- the entry is allowed to carry alongside it.
     """
-    require_string_keys(f"service {name!r}: volume", entry)
+    keys = require_string_keys(f"service {name!r}: volume", entry)
     vtype = entry.get("type")
     if vtype not in _VOLUME_LONG_TYPES:
         msg = f"service {name!r}: volume 'type' must be one of {list(_VOLUME_LONG_TYPES)}"
         raise UnsupportedComposeError(msg)
-    unknown = set(entry) - _VOLUME_LONG_KEYS - {vtype}
+    unknown = keys - _VOLUME_LONG_KEYS - {vtype}
     if unknown:
         msg = f"service {name!r}: volume: unsupported keys {sorted(unknown)}"
         raise UnsupportedComposeError(msg)
@@ -333,8 +333,8 @@ def _validate_volume_options(name: str, vtype: str, options: Any) -> None:  # no
     if not isinstance(options, dict):
         msg = f"service {name!r}: {vtype} options must be a mapping"
         raise UnsupportedComposeError(msg)
-    require_string_keys(f"service {name!r}: {vtype} options", options)
-    unknown = set(options) - _VOLUME_OPTION_KEYS[vtype]
+    keys = require_string_keys(f"service {name!r}: {vtype} options", options)
+    unknown = keys - _VOLUME_OPTION_KEYS[vtype]
     if unknown:
         msg = f"service {name!r}: {vtype} options: unsupported keys {sorted(unknown)}"
         raise UnsupportedComposeError(msg)
@@ -529,8 +529,8 @@ def _validate_build_secret_entry(name: str, entry: Any) -> None:  # noqa: ANN401
     if not isinstance(entry, dict):
         msg = f"service {name!r}: build 'secrets' entries must be a string or mapping"
         raise UnsupportedComposeError(msg)
-    require_string_keys(f"service {name!r}: build 'secrets' entry", entry)
-    unknown = set(entry) - _BUILD_SECRET_REF_KEYS
+    keys = require_string_keys(f"service {name!r}: build 'secrets' entry", entry)
+    unknown = keys - _BUILD_SECRET_REF_KEYS
     if unknown:
         msg = f"service {name!r}: build 'secrets' entry: unsupported keys {sorted(unknown)}"
         raise UnsupportedComposeError(msg)
@@ -683,8 +683,8 @@ def _validate_env_file(name: str, svc: dict[str, Any]) -> None:
 
 def _validate_env_file_mapping(name: str, entry: dict[str, Any]) -> None:
     """Check one long-form env_file mapping against Docker's strict schema (measured, v5.1.2)."""
-    require_string_keys(f"service {name!r}: 'env_file'", entry)
-    unknown = set(entry) - _ENV_FILE_ENTRY_KEYS
+    keys = require_string_keys(f"service {name!r}: 'env_file'", entry)
+    unknown = keys - _ENV_FILE_ENTRY_KEYS
     if unknown:
         msg = f"service {name!r}: 'env_file' entry: unsupported keys {sorted(unknown)}"
         raise UnsupportedComposeError(msg)
@@ -1240,8 +1240,8 @@ def _validate_definition_external(label: str) -> Callable[[str, str, Any], None]
         if values.is_bool_like(value):
             return
         if isinstance(value, dict):
-            require_string_keys(f"{label} {ident!r}: {key!r}", value)
-            unknown = set(value) - _EXTERNAL_MAP_KEYS
+            keys = require_string_keys(f"{label} {ident!r}: {key!r}", value)
+            unknown = keys - _EXTERNAL_MAP_KEYS
             if unknown:
                 msg = f"{label} {ident!r}: {key!r}: unsupported keys {sorted(unknown)}"
                 raise UnsupportedComposeError(msg)
@@ -1278,8 +1278,8 @@ def _validate_ipam_config_entry(label: str, ident: str, entry: Any) -> None:  #
     if not isinstance(entry, dict):
         msg = f"{label} {ident!r}: ipam 'config' entries must be a mapping"
         raise UnsupportedComposeError(msg)
-    require_string_keys(f"{label} {ident!r}: ipam config entry", entry)
-    unknown = set(entry) - _IPAM_CONFIG_ENTRY_KEYS
+    keys = require_string_keys(f"{label} {ident!r}: ipam config entry", entry)
+    unknown = keys - _IPAM_CONFIG_ENTRY_KEYS
     if unknown:
         msg = f"{label} {ident!r}: ipam config entry: unsupported keys {sorted(unknown)}"
         raise UnsupportedComposeError(msg)
@@ -1309,8 +1309,8 @@ def _validate_definition_ipam(label: str) -> Callable[[str, str, Any], None]:
         if not isinstance(value, dict):
             msg = f"{label} {ident!r}: {key!r} must be a mapping"
             raise UnsupportedComposeError(msg)
-        require_string_keys(f"{label} {ident!r}: {key!r}", value)
-        unknown = set(value) - _IPAM_KEYS
+        keys = require_string_keys(f"{label} {ident!r}: {key!r}", value)
+        unknown = keys - _IPAM_KEYS
         if unknown:
             msg = f"{label} {ident!r}: {key!r}: unsupported keys {sorted(unknown)}"
             raise UnsupportedComposeError(msg)

{compose2pod-0.4.0 → compose2pod-0.4.2}/compose2pod/resources.py

@@ -36,8 +36,8 @@ def _validate_limits(name: str, svc: dict[str, Any], limits: Any) -> None:  # no
     if not isinstance(limits, dict):
         msg = f"service {name!r}: deploy.resources.limits must be a mapping"
         raise UnsupportedComposeError(msg)
-    require_string_keys(f"service {name!r}: deploy.resources.limits", limits)
-    unknown = set(limits) - set(_LIMITS)
+    keys = require_string_keys(f"service {name!r}: deploy.resources.limits", limits)
+    unknown = keys - set(_LIMITS)
     if unknown:
         msg = f"service {name!r}: deploy.resources.limits: unsupported keys {sorted(unknown)}"
         raise UnsupportedComposeError(msg)
@@ -54,8 +54,8 @@ def _validate_reservations(name: str, svc: dict[str, Any], reservations: Any) ->
     if not isinstance(reservations, dict):
         msg = f"service {name!r}: deploy.resources.reservations must be a mapping"
         raise UnsupportedComposeError(msg)
-    require_string_keys(f"service {name!r}: deploy.resources.reservations", reservations)
-    unknown = set(reservations) - {"cpus", "memory", "devices"}
+    keys = require_string_keys(f"service {name!r}: deploy.resources.reservations", reservations)
+    unknown = keys - {"cpus", "memory", "devices"}
     if unknown:
         msg = f"service {name!r}: deploy.resources.reservations: unsupported keys {sorted(unknown)}"
         raise UnsupportedComposeError(msg)
@@ -91,8 +91,8 @@ def validate_deploy(name: str, svc: dict[str, Any]) -> None:
     if not isinstance(deploy, dict):
         msg = f"service {name!r}: 'deploy' must be a mapping"
         raise UnsupportedComposeError(msg)
-    require_string_keys(f"service {name!r}: deploy", deploy)
-    unknown = set(deploy) - {"resources"}
+    keys = require_string_keys(f"service {name!r}: deploy", deploy)
+    unknown = keys - {"resources"}
     if unknown:
         msg = f"service {name!r}: deploy: only 'resources' is supported (got {sorted(unknown)})"
         raise UnsupportedComposeError(msg)
@@ -105,8 +105,8 @@ def validate_deploy(name: str, svc: dict[str, Any]) -> None:
         raise UnsupportedComposeError(msg)
     _reject_null_block(name, "deploy.resources.limits", resources, "limits")
     _reject_null_block(name, "deploy.resources.reservations", resources, "reservations")
-    require_string_keys(f"service {name!r}: deploy.resources", resources)
-    unknown = set(resources) - {"limits", "reservations"}
+    keys = require_string_keys(f"service {name!r}: deploy.resources", resources)
+    unknown = keys - {"limits", "reservations"}
     if unknown:
         msg = f"service {name!r}: deploy.resources: unsupported keys {sorted(unknown)}"
         raise UnsupportedComposeError(msg)

{compose2pod-0.4.0 → compose2pod-0.4.2}/compose2pod/stores.py

@@ -73,8 +73,8 @@ def _validate_def(name: str, definition: Any, kind: StoreKind) -> None:  # noqa:
     if not isinstance(definition, dict):
         msg = f"{kind.label} {name!r} must be a mapping"
         raise UnsupportedComposeError(msg)
-    require_string_keys(f"{kind.label} {name!r}", definition)
-    unknown = set(definition) - kind.sources
+    keys = require_string_keys(f"{kind.label} {name!r}", definition)
+    unknown = keys - kind.sources
     if unknown:
         if "external" in unknown:
             msg = (
@@ -131,8 +131,8 @@ def _ref_source(name: str, ref: Any, kind: StoreKind) -> str:  # noqa: ANN401 -
     if not isinstance(ref, dict):
         msg = f"service {name!r}: {kind.label} entry must be a string or mapping"
         raise UnsupportedComposeError(msg)
-    require_string_keys(f"service {name!r}: {kind.label} entry", ref)
-    unknown = set(ref) - _LONG_FORM_KEYS
+    keys = require_string_keys(f"service {name!r}: {kind.label} entry", ref)
+    unknown = keys - _LONG_FORM_KEYS
     if unknown:
         msg = f"service {name!r}: unsupported {kind.label} keys {sorted(unknown)}"
         raise UnsupportedComposeError(msg)

{compose2pod-0.4.0 → compose2pod-0.4.2}/pyproject.toml

@@ -18,7 +18,7 @@ classifiers = [
     "Topic :: Software Development :: Libraries",
     "Topic :: Software Development :: Testing",
 ]
-version = "0.4.0"
+version = "0.4.2"
 
 [project.optional-dependencies]
 yaml = ["PyYAML>=6"]