docker-stack 2.0.2__tar.gz → 2.0.4__tar.gz

{docker_stack-2.0.2 → docker_stack-2.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docker-stack
-Version: 2.0.2
+Version: 2.0.4
 Summary: CLI for deploying and managing Docker stacks.
 Home-page: https://github.com/mesudip/docker-stack
 Author: Sudip Bhattarai

{docker_stack-2.0.2 → docker_stack-2.0.4}/docker_stack/cli.py

@@ -303,23 +303,59 @@ class DockerStack:
         Returns a tuple: (processed_objects, commands)
         """
         processed_objects = {}
+        manager_client = self._manager_client_for_feature(FEATURE_STACK_DEPLOY)
+        namespace = os.getenv("DOCKER_STACK_NAMESPACE", "default")
 
-        def add_obj(name, data, explicit_name=None, is_generated_secret=False):
+        def docker_object_name_for(name, explicit_name=None):
+            if explicit_name:
+                return explicit_name
+            if stack:
+                return f"{stack}_{name}"
+            return name
+
+        def normalize_labels(labels):
+            normalized = {}
+            for raw in labels:
+                key, _, value = raw.partition("=")
+                if key and _:
+                    normalized[key] = value
+            return normalized
+
+        def add_obj(name, data, explicit_name=None, is_generated_secret=False, generate_options=None):
             labels = []
             if is_generated_secret:
                 labels.append("mesudip.secret.generated=true")
 
-            if explicit_name:
-                docker_object_name = explicit_name
-            elif stack:
-                docker_object_name = f"{stack}_{name}"
-            else:
-                docker_object_name = name
+            docker_object_name = docker_object_name_for(name, explicit_name=explicit_name)
+
+            if manager_client and stack:
+                label_map = normalize_labels(labels)
+                if manager.object_type == "config":
+                    response = manager_client.resolve_config(
+                        stack=stack,
+                        namespace=namespace,
+                        name=docker_object_name,
+                        content=data,
+                        labels=label_map,
+                    )
+                else:
+                    response = manager_client.resolve_secret(
+                        stack=stack,
+                        namespace=namespace,
+                        name=docker_object_name,
+                        content=None if is_generated_secret else data,
+                        generate=generate_options if is_generated_secret else None,
+                        labels=label_map,
+                        return_generated_value=is_generated_secret,
+                    )
+                    if is_generated_secret and response.get("generated_value"):
+                        self.generated_secrets[name] = response["generated_value"]
+                processed_objects[name] = {"name": response["actual_name"], "external": True}
+                return
 
             (object_name, command) = manager.create(docker_object_name, data, labels=labels, stack=stack)
             if not command.isNop():
                 self.commands.append(command)
-                # If a new secret was actually created (not just reused), store it
                 if is_generated_secret:
                     self.generated_secrets[name] = data
             processed_objects[name] = {"name": object_name, "external": True}
@@ -338,28 +374,40 @@ class DockerStack:
                 with open(filename) as file:
                     add_obj(name, file.read(), explicit_name=explicit_name)
             elif isinstance(details, dict) and "x-generate" in details and manager.object_type == "secret":
-                is_generated_secret = True
                 generate_options = details["x-generate"]
-                secret_content = ""
-
-                # Determine the content to be used for the secret
-                # This logic is now simplified as DockerObjectManager.create handles persistence
                 if isinstance(generate_options, bool) and generate_options:
-                    secret_content = generate_secret()
+                    if manager_client and stack:
+                        add_obj(name, "", explicit_name=explicit_name, is_generated_secret=True, generate_options={})
+                    else:
+                        add_obj(name, generate_secret(), explicit_name=explicit_name, is_generated_secret=True)
                 elif isinstance(generate_options, int):
-                    secret_content = generate_secret(length=generate_options)
+                    if manager_client and stack:
+                        add_obj(name, "", explicit_name=explicit_name, is_generated_secret=True, generate_options={"length": generate_options})
+                    else:
+                        add_obj(name, generate_secret(length=generate_options), explicit_name=explicit_name, is_generated_secret=True)
                 elif isinstance(generate_options, dict):
-                    secret_content = generate_secret(
-                        length=generate_options.get("length"),
-                        numbers=generate_options.get("numbers", True),
-                        special=generate_options.get("special", True),
-                        uppercase=generate_options.get("uppercase", True),
-                    )
+                    options = {
+                        "length": generate_options.get("length"),
+                        "numbers": generate_options.get("numbers", True),
+                        "special": generate_options.get("special", True),
+                        "uppercase": generate_options.get("uppercase", True),
+                    }
+                    if manager_client and stack:
+                        add_obj(name, "", explicit_name=explicit_name, is_generated_secret=True, generate_options=options)
+                    else:
+                        add_obj(
+                            name,
+                            generate_secret(
+                                length=options.get("length"),
+                                numbers=options.get("numbers", True),
+                                special=options.get("special", True),
+                                uppercase=options.get("uppercase", True),
+                            ),
+                            explicit_name=explicit_name,
+                            is_generated_secret=True,
+                        )
                 else:
                     raise ValueError(f"Invalid x-generate value for secret {name}: {generate_options}")
-
-                # Call add_obj with the potentially new secret content and the generated flag
-                add_obj(name, secret_content, explicit_name=explicit_name, is_generated_secret=True)
             else:
                 processed_objects[name] = details
         return processed_objects

{docker_stack-2.0.2 → docker_stack-2.0.4}/docker_stack/manager_api.py

@@ -110,7 +110,16 @@ class ManagerApiClient:
             with urllib.request.urlopen(request, timeout=self.timeout_secs, context=context) as response:
                 return json.loads(response.read().decode("utf-8"))
         except urllib.error.HTTPError as exc:
-            raise RuntimeError(f"Manager request failed ({method} {path}): HTTP {exc.code}") from exc
+            body = ""
+            try:
+                payload = exc.read().decode("utf-8", errors="replace").strip()
+                if payload:
+                    body = f": {payload}"
+            except Exception:
+                body = ""
+            raise RuntimeError(
+                f"Manager request failed ({method} {path}): HTTP {exc.code}{body}"
+            ) from exc
         except urllib.error.URLError as exc:
             raise RuntimeError(f"Manager request failed ({method} {path}): {exc.reason}") from exc
         except json.JSONDecodeError as exc:
@@ -249,6 +258,60 @@ class ManagerApiClient:
 
         return {"nodes": nodes}
 
+
+
+    def resolve_config(
+        self,
+        *,
+        stack: str,
+        namespace: str,
+        name: str,
+        content: str,
+        labels: Optional[Dict[str, str]] = None,
+    ) -> Dict[str, Any]:
+        payload: Dict[str, Any] = {
+            "stack": stack,
+            "namespace": namespace,
+            "name": name,
+            "content": content,
+        }
+        if labels:
+            payload["labels"] = labels
+        return self._request_json(
+            "/api/configs/resolve",
+            method="POST",
+            payload=payload,
+        )
+
+    def resolve_secret(
+        self,
+        *,
+        stack: str,
+        namespace: str,
+        name: str,
+        content: Optional[str] = None,
+        generate: Optional[Dict[str, Any]] = None,
+        labels: Optional[Dict[str, str]] = None,
+        return_generated_value: bool = False,
+    ) -> Dict[str, Any]:
+        payload: Dict[str, Any] = {
+            "stack": stack,
+            "namespace": namespace,
+            "name": name,
+            "return_generated_value": return_generated_value,
+        }
+        if content is not None:
+            payload["content"] = content
+        if generate is not None:
+            payload["generate"] = generate
+        if labels:
+            payload["labels"] = labels
+        return self._request_json(
+            "/api/secrets/resolve",
+            method="POST",
+            payload=payload,
+        )
+
     def validate_stack(
         self,
         *,

{docker_stack-2.0.2 → docker_stack-2.0.4}/docker_stack.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docker-stack
-Version: 2.0.2
+Version: 2.0.4
 Summary: CLI for deploying and managing Docker stacks.
 Home-page: https://github.com/mesudip/docker-stack
 Author: Sudip Bhattarai

{docker_stack-2.0.2 → docker_stack-2.0.4}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="docker-stack",
-    version="2.0.2",
+    version="2.0.4",
     description="CLI for deploying and managing Docker stacks.",
     long_description=open("README.md").read(),  # You can include a README file to describe your package
     long_description_content_type="text/markdown",

{docker_stack-2.0.2 → docker_stack-2.0.4}/tests/test_docker_stack.py

@@ -32,6 +32,8 @@ class FakeManagerClient:
         self.features = {"docker_stack_query_v1", "docker_stack_deploy_v1"}
         self.deploy_payloads = []
         self.rollback_payloads = []
+        self.resolve_config_payloads = []
+        self.resolve_secret_payloads = []
 
     def supports(self, feature_name):
         return feature_name in self.features
@@ -83,6 +85,47 @@ class FakeManagerClient:
             ]
         }
 
+    def resolve_config(self, *, stack, namespace, name, content, labels=None):
+        self.resolve_config_payloads.append(
+            {
+                "stack": stack,
+                "namespace": namespace,
+                "name": name,
+                "content": content,
+                "labels": labels or {},
+            }
+        )
+        return {
+            "logical_name": name,
+            "actual_name": f"{name}_v2",
+            "version": 2,
+            "created": True,
+            "changed": True,
+        }
+
+    def resolve_secret(self, *, stack, namespace, name, content=None, generate=None, labels=None, return_generated_value=False):
+        self.resolve_secret_payloads.append(
+            {
+                "stack": stack,
+                "namespace": namespace,
+                "name": name,
+                "content": content,
+                "generate": generate,
+                "labels": labels or {},
+                "return_generated_value": return_generated_value,
+            }
+        )
+        payload = {
+            "logical_name": name,
+            "actual_name": name,
+            "version": 1,
+            "created": True,
+            "changed": True,
+        }
+        if return_generated_value:
+            payload["generated_value"] = "generated-from-manager"
+        return payload
+
     def deploy_stack(self, *, stack, namespace, compose, options=None):
         self.deploy_payloads.append(
             {"stack": stack, "namespace": namespace, "compose": compose, "options": options or {}}
@@ -151,6 +194,67 @@ def test_process_x_content_preserves_explicit_name_override():
     assert processed == {"config.json": {"name": "shared-config", "external": True}}
 
 
+def test_process_x_content_uses_manager_resolve_apis(monkeypatch):
+    fake_manager = FakeManagerClient()
+    monkeypatch.setattr("docker_stack.cli.discover_manager_client", lambda *_args, **_kwargs: fake_manager)
+
+    docker = Docker()
+    docker.stack._manager_client = fake_manager
+
+    processed_configs = docker.stack._process_x_content(
+        {
+            "app.conf": {
+                "x-content": "hello",
+            }
+        },
+        docker.config,
+        stack="govtool",
+    )
+    processed_secrets = docker.stack._process_x_content(
+        {
+            "app-secret": {
+                "x-generate": {
+                    "length": 24,
+                    "numbers": True,
+                    "special": False,
+                    "uppercase": True,
+                }
+            }
+        },
+        docker.secret,
+        stack="govtool",
+    )
+
+    assert fake_manager.resolve_config_payloads == [
+        {
+            "stack": "govtool",
+            "namespace": "default",
+            "name": "govtool_app.conf",
+            "content": "hello",
+            "labels": {},
+        }
+    ]
+    assert fake_manager.resolve_secret_payloads == [
+        {
+            "stack": "govtool",
+            "namespace": "default",
+            "name": "govtool_app-secret",
+            "content": None,
+            "generate": {
+                "length": 24,
+                "numbers": True,
+                "special": False,
+                "uppercase": True,
+            },
+            "labels": {"mesudip.secret.generated": "true"},
+            "return_generated_value": True,
+        }
+    ]
+    assert processed_configs == {"app.conf": {"name": "govtool_app.conf_v2", "external": True}}
+    assert processed_secrets == {"app-secret": {"name": "govtool_app-secret", "external": True}}
+    assert docker.stack.generated_secrets == {"app-secret": "generated-from-manager"}
+
+
 def test_build_uses_service_dockerfile(tmp_path):
     compose_file = tmp_path / "docker-compose.yml"
     compose_file.write_text(