docker-stack 0.1.1__tar.gz

docker-stack-0.1.1/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.1
+Name: docker-stack
+Version: 0.1.1
+Summary: CLI for deploying and managing Docker stacks.
+Home-page: https://github.com/mesuidp/docker-stack
+Author: Sudip Bhattarai
+Author-email: sudip.dev.np@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+
+Docker Stack
+==============
+cli utility for stack deployment in docker-swarm.
+#### Features
+- docker config and secret creation and versioning
+- docker stack versioning and config backup for rollback

docker-stack-0.1.1/README.md

@@ -0,0 +1,6 @@
+Docker Stack
+==============
+cli utility for stack deployment in docker-swarm.
+#### Features
+- docker config and secret creation and versioning
+- docker stack versioning and config backup for rollback

docker-stack-0.1.1/docker_stack/__init__.py

@@ -0,0 +1,21 @@
+from .envsubst import envsubst
+from .compose import read_compose_file
+from .docker_objects import DockerConfig, DockerSecret
+from .cli import main
+
+"""
+Functions:
+
+1. read_compose_file(compose_file_path):
+   - Reads a Docker Compose YAML file and returns its contents as a dictionary.
+   
+2. create_config(config_name, config_content):
+   - Creates a Docker config from the given string content. Adds a label with the SHA256 hash of the config content.
+   
+3. check_config(config_name):
+   - Checks if a Docker config with the given name already exists.
+   
+4. update_config(config_name, config_content):
+   - Updates an existing Docker config or creates a new one if it doesn't exist. 
+     If the config exists, checks the SHA256 hash and recreates the config if the hash doesn't match.
+"""

docker-stack-0.1.1/docker_stack/cli.py

@@ -0,0 +1,169 @@
+#!/usr/bin/env python3
+import argparse
+import sys
+from pathlib import Path
+from typing import List
+from docker_stack import DockerConfig, DockerSecret
+import os
+import yaml
+import json
+from docker_stack.docker_objects import DockerObjectManager
+from docker_stack.helpers import Command
+from docker_stack.registry import DockerRegistry
+from .envsubst import envsubst
+
+class Docker:
+    def __init__(self,resgistry_url='https://docker.io',userpass=''):
+        self.stack = DockerStack(self)
+        self.config = DockerConfig()
+        self.secret = DockerSecret()
+        self.registry = DockerRegistry(resgistry_url, userpass)
+
+    @staticmethod
+    def load_env(env_file=".env"):
+        if Path(env_file).is_file():
+            with open(env_file) as f:
+                for line in f:
+                    line = line.strip()
+                    if line and not line.startswith("#"):
+                        key, _, value = line.partition("=")
+                        os.environ[key.strip()] = value.strip()
+
+    @staticmethod
+    def check_env(example_file=".env.example"):
+        if not Path(example_file).is_file():
+            return
+
+        unset_keys = []
+        with open(example_file) as f:
+            for line in f:
+                line = line.strip()
+                if line and not line.startswith("#"):
+                    key = line.split("=")[0].strip()
+                    if not os.environ.get(key):
+                        unset_keys.append(key)
+
+        if unset_keys:
+            print("The following keys are not set in the environment:")
+            for key in unset_keys:
+                print(f"- {key}")
+            print("Exiting due to missing environment variables.")
+            sys.exit(2)
+
+class DockerStack:
+    def __init__(self, docker: Docker):
+        self.docker = docker
+        self.commands: List[Command] = []
+        
+    def render_compose_file(self, compose_file):
+        """
+        Render the Docker Compose file with environment variables and create Docker configs/secrets.
+        """
+        with open(compose_file) as f:
+            template_content = f.read()
+        rendered_content = envsubst(template_content)
+
+        # Parse the YAML content
+        compose_data = yaml.safe_load(rendered_content)
+
+        # Process configs and secrets with x-content
+        if "configs" in compose_data:
+            compose_data["configs"] = self._process_x_content(compose_data["configs"], self.docker.config)
+        if "secrets" in compose_data:
+            compose_data["secrets"] = self._process_x_content(compose_data["secrets"], self.docker.secret)
+
+        # Convert the modified data back to YAML
+        
+        rendered_content = yaml.dump(compose_data)
+
+        # Write the rendered file
+        rendered_filename = Path(compose_file).with_name(
+            f"{Path(compose_file).stem}-rendered{Path(compose_file).suffix}"
+        )
+        with open(rendered_filename, "w") as f:
+            f.write(rendered_content)
+        with open(rendered_filename.as_posix()+".json","w") as f:
+            f.write(json.dumps(compose_data,indent=2))
+        return (rendered_filename,rendered_content)
+
+
+
+    def _process_x_content(self, objects, manager:DockerObjectManager):
+        """
+        Process configs or secrets with x-content keys.
+        Returns a tuple: (processed_objects, commands)
+        """
+        processed_objects = {}
+        for name, details in objects.items():
+            if isinstance(details, dict) and "x-content" in details:
+                # Create the Docker object (config or secret)
+                (object_name,command)=manager.create(name, details['x-content'])                
+                if not command.isNop():
+                    self.commands.append(command)
+                # Replace x-content with the name of the created object
+                processed_objects[name] = {"name": object_name,"external": True}
+            else:
+                processed_objects[name] = details
+        return processed_objects
+
+    def deploy(self, stack_name, compose_file, with_registry_auth=False):
+        rendered_filename, rendered_content = self.render_compose_file(compose_file)
+        _, cmd = self.docker.config.increment(stack_name, rendered_content, [f"mesudip.stack.name={stack_name}"])
+        if not cmd.isNop():
+            self.commands.append(cmd)
+        cmd = ["docker", "stack", "deploy", "-c", str(rendered_filename), stack_name]
+        if with_registry_auth:
+            cmd.insert(3, "--with-registry-auth")
+        self.commands.append(Command(cmd))
+
+    def push(self, compose_file, credentials):
+        with open(compose_file) as f:
+            compose_data = yaml.safe_load(f)
+        for service_name, service_data in compose_data.get("services", {}).items():
+            if "build" in service_data:
+                build_path = service_data["build"]
+                print(f"++ docker build -t {service_data['image']} {build_path}")
+                build_command = ["docker", "build", "-t", service_data['image'], build_path.get('context', '.')]
+                self.commands.append(Command(build_command))
+                push_result = self.check_and_push_pull_image(service_data['image'], 'push')
+                if push_result:
+                    self.commands.append(push_result)
+                else:
+                    print("No need to push: Already exists")
+
+    def check_and_push_pull_image(self, image_name: str, action: str):
+        if self.docker.registry.check_image(image_name):
+            print(f"Image {image_name} already in the registry.")
+            return None
+        if action == 'push':
+            print(f"Pushing image {image_name} to the registry...")
+            cmd = self.docker.registry.push(image_name)
+            if cmd:
+                self.commands.append(cmd)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Deploy and manage Docker stacks.")
+    parser.add_argument("command", choices=["deploy", "push"], help="Command to execute")
+    parser.add_argument("stack_name", help="Name of the stack", nargs="?")
+    parser.add_argument("compose_file", help="Path to the compose file")
+    parser.add_argument("--with-registry-auth", action="store_true", help="Use registry authentication")
+    parser.add_argument("-u", "--user", help="Registry credentials in format username:password", required=False)
+
+    args = parser.parse_args()
+    docker = Docker(resgistry_url="https://registry.sireto.io",userpass='admin:69a017f5de7509e5e7ab0e89a5687dbda58f4fa70762bee17d2e454704bd7a4f')
+    docker.load_env()
+    docker.check_env()
+    docker.registry.login()
+
+    if args.command == "push":
+        docker.stack.push(args.compose_file, args.user)
+    else:
+        docker.stack.deploy(args.stack_name, args.compose_file, args.with_registry_auth)
+
+    print("Commands to Execute")
+    [print("   >", x) for x in docker.stack.commands] if docker.stack.commands else print("-- empty --")
+    [x.execute() for x in docker.stack.commands]
+
+if __name__ == "__main__":
+    main()

docker-stack-0.1.1/docker_stack/compose.py

@@ -0,0 +1,17 @@
+import yaml
+
+
+def read_compose_file(compose_file_path):
+    """
+    Reads a Docker Compose YAML file and returns its contents as a dictionary.
+
+    :param compose_file_path: Path to the Docker Compose file.
+    :return: Dictionary representation of the YAML contents.
+    """
+    if not os.path.exists(compose_file_path):
+        raise FileNotFoundError(f"Compose file {compose_file_path} does not exist.")
+
+    with open(compose_file_path, "r") as file:
+        compose_data = yaml.safe_load(file)
+
+    return compose_data

docker-stack-0.1.1/docker_stack/docker_objects.py

@@ -0,0 +1,221 @@
+import hashlib
+import re
+import json
+from typing import List, Tuple
+from docker_stack.helpers import Command, run_cli_command  # Import the helper function
+
+
+class DockerObjectManager:
+    def __init__(self, object_type, log=False):
+        self.object_type = object_type
+        self.log = log
+
+    def _create(
+        self, object_name, object_content, labels: List[str] = [], sha_hash=None
+    ):
+        sha_hash = (
+            sha_hash if sha_hash else self.calculate_hash(object_name, object_content)
+        )
+        command = ["docker", self.object_type, "create"]
+        command.append("--label")
+        command.append(f"sha256={sha_hash}")
+
+        for label in labels:
+            command.append("--label")
+            command.append(label.strip())
+
+        command.append(object_name)
+        command.append("-")
+
+        # Return a Command object with the object_content as stdin
+        return Command(command, stdin=object_content, id=sha_hash)
+
+    def calculate_hash(self, object_name, object_content):
+        hash_input = f"{self.object_type}{object_name}{object_content}"
+        return hashlib.sha256(hash_input.encode("utf-8")).hexdigest()
+
+    def check(self, object_name):
+        command = ["docker", self.object_type, "inspect", object_name]
+
+        try:
+            # Use run_cli_command instead of subprocess.run
+            run_cli_command(command, raise_error=True, log=self.log)
+            return True
+        except Exception:
+            return False
+
+    def create(
+        self, object_name, object_content, labels: List[str] = []
+    ) -> Tuple[str, Command]:
+        sha_hash = self.calculate_hash(object_name, object_content)
+
+        # Check if any version of the object already exists by its label
+        command = [
+            "docker",
+            self.object_type,
+            "ls",
+            "--filter",
+            f"label=mesudip.object.name={object_name}",
+            "--format",
+            "{{json .}}",
+        ]
+        output = run_cli_command(command, raise_error=True, log=self.log)
+
+        # Parse existing versions
+        existing_versions = {}
+        max_version = 0
+
+        for line in output.splitlines():
+            object_info = json.loads(line)
+            object_name_in_docker = object_info["Name"]
+            if object_name_in_docker == object_name:
+                max_version = max(max_version, 1)
+                existing_versions[1] = object_info
+            else:
+                match = re.search(r"_(v\d+)$", object_name_in_docker)
+                if match:
+                    version = int(match.group(1)[1:])
+                    max_version = max(version, max_version)
+                    existing_versions[version] = object_info
+
+        # Determine the next version number
+        new_version_suffix = ""
+        if len(existing_versions) > 0:
+            new_version = max_version + 1
+            new_version_suffix = f"_v{new_version}"
+        else:
+            new_version = 1
+
+        new_object_name = f"{object_name}{new_version_suffix}"
+
+        # Check if the SHA hash for the new content already exists in any version
+        existing_sha_hash = None
+        matching_object = None
+
+        for object_info in existing_versions.values():
+            object_name_in_docker = object_info["Name"]
+            parsed_labels = parse_labels(object_info["Labels"])
+            object_sha_hash = parsed_labels.get("sha256")
+
+            if object_sha_hash == sha_hash:
+                existing_sha_hash = sha_hash
+                matching_object = object_info
+                break
+
+        if existing_sha_hash == sha_hash:
+            existing_name = matching_object["Name"]
+            if self.log:
+                print(
+                    f"{self.object_type.capitalize()} {existing_name} already exists with the same SHA hash. No update needed."
+                )
+            return existing_name, Command.nop
+
+        if self.log:
+            print(f"SHA mismatch. Creating a new version: {new_object_name}")
+        labels = [
+            f"mesudip.object.version={new_version:01d}",
+            f"mesudip.object.name={object_name}",
+        ] + labels
+        return new_object_name, self._create(
+            new_object_name, object_content, labels, sha_hash=sha_hash
+        )
+
+    def increment(
+        self, object_name, object_content, labels: List[str] = []
+    ) -> Tuple[str, Command]:
+        sha_hash = self.calculate_hash(object_name, object_content)
+
+        # Check if any version of the object already exists by its label
+        command = [
+            "docker",
+            self.object_type,
+            "ls",
+            "--filter",
+            f"label=mesudip.object.name={object_name}",
+            "--format",
+            "{{json .}}",
+        ]
+        output = run_cli_command(command, raise_error=True, log=self.log)
+
+        # Parse existing versions
+        existing_versions = {}
+        max_version = 0
+
+        for line in output.splitlines():
+            object_info = json.loads(line)
+            object_name_in_docker = object_info["Name"]
+            if object_name_in_docker == object_name:
+                max_version = max(max_version, 1)
+                existing_versions[1] = object_info
+            else:
+                match = re.search(r"_(v\d+)$", object_name_in_docker)
+                if match:
+                    version = int(match.group(1)[1:])
+                    max_version = max(version, max_version)
+                    existing_versions[version] = object_info
+
+        # Determine the next version number
+        new_version_suffix = ""
+        if len(existing_versions) > 0:
+            new_version = max_version + 1
+            new_version_suffix = f"_v{new_version}"
+        else:
+            new_version = 1
+
+        new_object_name = f"{object_name}{new_version_suffix}"
+        last_sha = None
+        if max_version > 0:
+            last_object = existing_versions[max_version]
+            command = [
+                "docker",
+                self.object_type,
+                "inspect",
+                last_object["Name"],
+                "--format",
+                "{{json .Spec.Labels}}",
+            ]
+            inspect_result = run_cli_command(command, raise_error=True, log=self.log)
+            labels_info = json.loads(inspect_result)
+            last_sha = labels_info.get("sha256")
+
+        if sha_hash == last_sha:
+            return (last_object["Name"], Command.nop)
+        else:
+            labels = [
+                f"mesudip.object.version={new_version:01d}",
+                f"mesudip.object.name={object_name}",
+            ] + labels
+            return new_object_name, self._create(
+                new_object_name, object_content, labels, sha_hash=sha_hash
+            )
+
+
+class DockerConfig(DockerObjectManager):
+    def __init__(self, log=False):
+        super().__init__("config", log)
+
+
+class DockerSecret(DockerObjectManager):
+    def __init__(self, log=False):
+        super().__init__("secret", log)
+
+
+def parse_labels(label_string):
+    """
+    Parse a comma-separated string of key-value pairs into a dictionary.
+    Handles cases where values may contain commas.
+
+    Args:
+        label_string (str): A string containing key-value pairs separated by commas.
+
+    Returns:
+        dict: A dictionary of labels and their corresponding values.
+    """
+    labels = {}
+    # Use a regex to split on commas that are not part of a value
+    pattern = re.compile(r",(?![^=,]*(?:,|$))")
+    for pair in pattern.split(label_string):
+        if "=" in pair:
+            key, value = pair.split("=", 1)  # Split on the first '=' only
+            labels[key.strip()] = value.strip()
+    return labels

docker-stack-0.1.1/docker_stack/envsubst.py

@@ -0,0 +1,72 @@
+#!/usr/bin/python3
+"""
+NAME
+       envsubst.py - substitutes environment variables in bash format strings
+
+DESCRIPTION
+    envsubst.py is an upgrade of the POSIX command `envsubst`
+
+    supported syntax:
+      normal       - ${VARIABLE1} or $VARIABLE1
+      with default - ${VARIABLE1:-somevalue}
+"""
+
+import os
+import re
+import sys
+
+
+def envsubst(template_str, env=os.environ):
+    """Substitute environment variables in the template string, supporting default values."""
+
+    # Regex for ${VARIABLE} with optional default
+    pattern_with_default = re.compile(r"\$\{([^}:\s]+)(?::-(.*?))?\}")
+
+    # Regex for $VARIABLE without default
+    pattern_without_default = re.compile(r"\$([a-zA-Z_][a-zA-Z0-9_]*)")
+
+    def replace_with_default(match):
+        var = match.group(1)
+        default_value = match.group(2) if match.group(2) is not None else None
+        result = env.get(var, default_value)
+        if result is None:
+            print(f"Missing template variable with default: {var}", file=sys.stderr)
+            exit(1)
+        return result
+
+    def replace_without_default(match):
+        var = match.group(1)
+        result = env.get(var, None)
+        if result is None:
+            print(f"Missing template variable: {var}", file=sys.stderr)
+            exit(1)
+        return result
+
+    # Substitute variables with default values
+    template_str = pattern_with_default.sub(replace_with_default, template_str)
+
+    # Substitute variables without default values
+    template_str = pattern_without_default.sub(replace_without_default, template_str)
+
+    return template_str
+
+
+def main():
+    if len(sys.argv) > 2:
+        print("Usage: python envsubst.py [template_file]")
+        sys.exit(1)
+
+    if len(sys.argv) == 2:
+        template_file = sys.argv[1]
+        with open(template_file, "r") as file:
+            template_str = file.read()
+    else:
+        template_str = sys.stdin.read()
+
+    result = envsubst(template_str)
+
+    print(result)
+
+
+if __name__ == "__main__":
+    main()

docker-stack-0.1.1/docker_stack/envsubst_merge.py

@@ -0,0 +1,125 @@
+#!/usr/bin/python3
+"""
+NAME
+       envsubst_merge.py - merges files and substitutes environment variables in the content
+
+DESCRIPTION
+    envsubst_merge.py combines the functionality of merging files and substituting environment
+    variables in bash format strings. An optional file extension can be provided to filter the files to be merged.
+"""
+
+import os
+import re
+import sys
+
+
+def envsubst(template_str, env=os.environ):
+    """Substitute environment variables in the template string, supporting default values."""
+
+    # Regex for ${VARIABLE} with optional default
+    pattern_with_default = re.compile(r"\$\{([^}:\s]+)(?::-([^}]*))?\}")
+
+    # Regex for $VARIABLE without default
+    pattern_without_default = re.compile(r"\$([a-zA-Z_][a-zA-Z0-9_]*)")
+
+    def replace_with_default(match):
+        var = match.group(1)
+        default_value = match.group(2) if match.group(2) is not None else None
+        result = env.get(var, default_value)
+        if result is None:
+            print(f"Missing template variable with default: {var}", file=sys.stderr)
+            exit(1)
+        return result
+
+    def replace_without_default(match):
+        var = match.group(1)
+        result = env.get(var, None)
+        if result is None:
+            print(f"Missing template variable: {var}", file=sys.stderr)
+            exit(1)
+        return result
+
+    # Substitute variables with default values
+    template_str = pattern_with_default.sub(replace_with_default, template_str)
+
+    # Substitute variables without default values
+    template_str = pattern_without_default.sub(replace_without_default, template_str)
+
+    return template_str
+
+
+def merge_files_from_directories(directories, file_extension=None):
+    merged_content = []
+
+    for path in directories:
+        if os.path.isdir(path):
+            # If the path is a directory, read files with the specified extension
+            for filename in os.listdir(path):
+                if not file_extension or filename.endswith(file_extension):
+                    filepath = os.path.join(path, filename)
+                    with open(filepath, "r") as file:
+                        content = (
+                            file.read().strip()
+                        )  # Strip leading/trailing whitespace
+                        if content:  # Add only non-empty content
+                            # Add directory and filename as a comment at the start of the content
+                            merged_content.append(f"# {path}/{filename}\n{content}")
+        elif os.path.isfile(path) and (
+            not file_extension or path.endswith(file_extension)
+        ):
+            # If the path is a file with the specified extension, read its content
+            with open(path, "r") as file:
+                content = file.read().strip()  # Strip leading/trailing whitespace
+                if content:  # Add only non-empty content
+                    # Add the file name as a comment at the start of the content
+                    merged_content.append(f"# {path}\n{content}")
+        else:
+            print(
+                f"Warning: '{path}' is not a valid directory or file. Skipping.",
+                file=sys.stderr,
+            )
+
+    # Join the content with a single newline between entries
+    result = "\n\n".join(merged_content)
+
+    # Strip extra empty lines from the beginning and end
+    result = result.strip()
+
+    # Perform environment variable substitution on the final result
+    return envsubst(result)
+
+
+def main():
+    # Take directories or files from command-line arguments
+    if len(sys.argv) < 2:
+        print(
+            "Usage: python envsubst_merge.py <directory1|file1> <directory2|file2> ... [--ext <file_extension>] [--ext=<file_extension>]",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    paths_to_read = []
+    file_extension = None
+
+    # Parse arguments
+    args = iter(sys.argv[1:])
+    for arg in args:
+        if arg.startswith("--ext="):
+            file_extension = arg.split("=", 1)[1]
+        elif arg == "--ext":
+            try:
+                file_extension = next(args)
+            except StopIteration:
+                print("Error: Missing file extension after --ext.", file=sys.stderr)
+                sys.exit(1)
+        else:
+            paths_to_read.append(arg)
+
+    result = merge_files_from_directories(paths_to_read, file_extension)
+
+    # Print the output to stdout
+    print(result)
+
+
+if __name__ == "__main__":
+    main()

docker-stack-0.1.1/docker_stack/helpers.py

@@ -0,0 +1,107 @@
+import subprocess
+from typing import List, Optional
+
+
+def run_cli_command(
+    command: List[str],
+    stdin: Optional[str] = None,
+    raise_error: bool = True,
+    log: bool = True,
+    shell: bool = False,
+    interactive: bool = False,
+) -> str:
+    """
+    Run a CLI command and return its output.
+
+    Args:
+        command: The command to run as a list of strings.
+        stdin: Input to pass to the command via stdin.
+        raise_error: If True, raise an exception if the command fails.
+        log: If True, log the command before executing it.
+        shell: If True, run the command in a shell.
+        interactive: If True, run the command with everything sent to the current console.
+
+    Returns:
+        The stdout of the command as a string, or None if interactive mode is enabled.
+    """
+    if log:
+        print("> " + " ".join(command))
+
+    try:
+        if interactive:
+            result = subprocess.run(command, shell=shell)
+            return None
+        else:
+            result = subprocess.run(
+                command,
+                input=stdin,
+                text=True,
+                capture_output=True,
+                check=raise_error,
+                shell=shell,
+            )
+            return result.stdout.strip()
+    except subprocess.CalledProcessError as e:
+        # Log the error and re-raise the exception
+        print(f"Error running command: {e}")
+        print(f"stdout: {e.stdout}")
+        print(f"stderr: {e.stderr}")
+        raise e
+
+
+class Command:
+    nop: "Command" = None
+
+    def isNop(self):
+        return self == Command.nop
+
+    def __init__(
+        self, command: List[str], stdin: Optional[str] = None, log: bool = True, id=None
+    ):
+        """
+        Initialize a Command object.
+
+        Args:
+            command: The command to run as a list of strings.
+            stdin: Input to pass to the command via stdin.
+            log: If True, log the command before executing it.
+        """
+        self.command = command
+        self.stdin = stdin
+        self.log = log
+        self.id = id
+
+    def execute(self, log: Optional[bool] = None) -> str:
+        """
+        Execute the command and return its output.
+
+        Args:
+            log: If provided, overrides the log setting from the constructor.
+
+        Returns:
+            The stdout of the command as a string.
+        """
+        if not self.command:
+            return
+        # Use the provided log value if available, otherwise use the one from the constructor
+        use_log = log if log is not None else self.log
+        if not self.stdin:
+            subprocess.run(self.command)
+        return run_cli_command(self.command, stdin=self.stdin, log=use_log, shell=False)
+
+    def __str__(self) -> str:
+        """
+        Return a string representation of the command.
+
+        Returns:
+            A string representation of the command, including stdin if applicable.
+        """
+        if self.stdin:
+            return f"echo '{self.stdin}' | {' '.join(self.command)}"
+        elif self.command:
+            return " ".join(self.command)
+        else:
+            return "NOP"
+
+
+Command.nop = Command([])

docker-stack-0.1.1/docker_stack/merge_conf.py

@@ -0,0 +1,52 @@
+import os
+import sys
+
+
+def merge_files_from_directories(directories):
+    merged_content = []
+
+    for path in directories:
+        if os.path.isdir(path):
+            # If the path is a directory, read .conf files from it
+            for filename in os.listdir(path):
+                if filename.endswith(".conf"):  # Only consider .conf files
+                    filepath = os.path.join(path, filename)
+                    with open(filepath, "r") as file:
+                        content = (
+                            file.read().strip()
+                        )  # Strip leading/trailing whitespace
+                        if content:  # Add only non-empty content
+                            # Add directory and filename as a comment at the start of the content
+                            merged_content.append(f"# {path}/{filename}\n{content}")
+        elif os.path.isfile(path) and path.endswith(".conf"):
+            # If the path is a .conf file, read its content
+            with open(path, "r") as file:
+                content = file.read().strip()  # Strip leading/trailing whitespace
+                if content:  # Add only non-empty content
+                    # Add the file name as a comment at the start of the content
+                    merged_content.append(f"# {path}\n{content}")
+        else:
+            print(
+                f"Warning: '{path}' is not a valid directory or .conf file. Skipping."
+            )
+
+    # Join the content with a single newline between entries
+    result = "\n\n".join(merged_content)
+
+    # Strip extra empty lines from the beginning and end
+    result = result.strip()
+
+    # Print the output to stdout
+    print(result)
+
+
+if __name__ == "__main__":
+    # Take directories or .conf files from command-line arguments
+    if len(sys.argv) < 2:
+        print(
+            "Usage: python merge_files.py <directory1|file1.conf> <directory2|file2.conf> ..."
+        )
+        sys.exit(1)
+
+    paths_to_read = sys.argv[1:]
+    merge_files_from_directories(paths_to_read)

docker-stack-0.1.1/docker_stack/registry.py

@@ -0,0 +1,150 @@
+import json
+import http.client
+import select
+import subprocess
+from base64 import b64encode
+
+from docker_stack.helpers import Command
+
+class DockerRegistry:
+    def __init__(self, registry_url, userpass:str=None):
+        """
+        Initializes the DockerRegistry class with the registry URL, and optional
+        username and password for authentication.
+        
+        :param registry_url: URL of the Docker registry (e.g., 'registry.hub.docker.com')
+        :param username: Optional username for authentication
+        :param password: Optional password for authentication
+        """
+        self.registry_url = registry_url
+        self.username = None
+        self.password = None
+        if userpass:
+            splitted=userpass.split(':')
+            
+            self.username=splitted[0]
+            self.password=splitted[1]
+       
+        # Parse registry host and port
+        self.host = self._get_host_from_url(registry_url)
+        self.port = 443 if self.registry_url.startswith("https") else 80
+    
+    def _get_host_from_url(self, url):
+        """Extracts the host from the URL."""
+        # Remove protocol part (http:// or https://)
+        return url.split('://')[1].split('/')[0]
+    
+    def _send_request(self, method, endpoint, auth=None):
+        """Send a generic HTTP request to the Docker registry."""
+        connection = http.client.HTTPSConnection(self.host, self.port)
+        
+        # Add Authorization header if needed
+        headers = {}
+        if auth:
+            headers['Authorization'] = f"Basic {b64encode(auth.encode()).decode()}"
+        
+        connection.request(method, endpoint, headers=headers)
+        response = connection.getresponse()
+        return response
+    
+    def check_auth(self):
+        """
+        Check if the authentication credentials (if provided) are valid for the Docker registry.
+        
+        :return: Boolean indicating whether authentication is successful
+        """
+        url = "/v2/"
+        if self.username and self.password:
+            auth = f"{self.username}:{self.password}"
+            response = self._send_request('GET', url, auth)
+        else:
+            response = self._send_request('GET', url)
+
+        # Check if the status code is 200
+        return response.status == 200
+
+    def check_image(self, image_name):
+        """
+        Check if an image exists in the Docker registry.
+        
+        :param image_name: Name of the image (e.g., 'ubuntu' or 'python')
+        :return: Boolean indicating whether the image exists in the registry
+        """
+        url = f"/v2/{image_name}/tags/list"
+        if self.username and self.password:
+            auth = f"{self.username}:{self.password}"
+            response = self._send_request('GET', url, auth)
+        else:
+            response = self._send_request('GET', url)
+
+        # Check if the status code is 200
+        return response.status == 200
+    
+    def _run_docker_command(self, command):
+        """
+        Run a Docker command using the subprocess module and stream the output to the terminal in real-time.
+        
+        :param command: A list of strings representing the Docker command to run
+        :return: None
+        """
+        try:
+            process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, bufsize=1)
+
+            # Use select to handle both stdout and stderr without blocking
+            while process.poll() is None:
+                readable, _, _ = select.select([process.stdout, process.stderr], [], [], 0.1)
+                for stream in readable:
+                    line = stream.readline()
+                    if line:
+                        print(line, end="", flush=True)
+
+            # Ensure remaining output is printed
+            for stream in (process.stdout, process.stderr):
+                for line in iter(stream.readline, ""):
+                    print(line, end="", flush=True)
+
+            process.stdout.close()
+            process.stderr.close()
+            process.wait()
+
+            if process.returncode != 0:
+                print(f"Command failed with return code {process.returncode}")
+            
+        except FileNotFoundError:
+            print("Docker command not found. Please ensure Docker is installed and accessible.")
+            
+    def _run_docker_command_(self, command):
+        """
+        Run a Docker command using the subprocess module.
+        
+        :param command: A list of strings representing the Docker command to run
+        :return: Tuple of (stdout, stderr)
+        """
+        try:
+            result = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+            return result.stdout, result.stderr
+        except FileNotFoundError:
+            return '', 'Docker not found. Please install Docker.'
+
+    def push(self, image_name)->Command:
+        """
+        Push an image to the Docker registry.
+        
+        :param image_name: Name of the image to push (e.g., 'myrepo/myimage:tag')
+        :return: Tuple of (stdout, stderr)
+        """
+        return Command(['docker', 'push', image_name])
+
+    def pull(self, image_name):
+        """
+        Pull an image from the Docker registry.
+        
+        :param image_name: Name of the image to pull (e.g., 'myrepo/myimage:tag')
+        :return: Tuple of (stdout, stderr)
+        """
+        command = ['docker', 'pull', image_name]
+        return self._run_docker_command(command)
+
+    def login(self):
+        print("> " ,['docker','login','-u',self.username,'-p',self.password])
+        subprocess.run(['docker','login','-u',self.username,'-p',self.password,self.host])

docker-stack-0.1.1/docker_stack.egg-info/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.1
+Name: docker-stack
+Version: 0.1.1
+Summary: CLI for deploying and managing Docker stacks.
+Home-page: https://github.com/mesuidp/docker-stack
+Author: Sudip Bhattarai
+Author-email: sudip.dev.np@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+
+Docker Stack
+==============
+cli utility for stack deployment in docker-swarm.
+#### Features
+- docker config and secret creation and versioning
+- docker stack versioning and config backup for rollback

docker-stack-0.1.1/docker_stack.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+README.md
+pyproject.toml
+setup.py
+docker_stack/__init__.py
+docker_stack/cli.py
+docker_stack/compose.py
+docker_stack/docker_objects.py
+docker_stack/envsubst.py
+docker_stack/envsubst_merge.py
+docker_stack/helpers.py
+docker_stack/merge_conf.py
+docker_stack/registry.py
+docker_stack.egg-info/PKG-INFO
+docker_stack.egg-info/SOURCES.txt
+docker_stack.egg-info/dependency_links.txt
+docker_stack.egg-info/entry_points.txt
+docker_stack.egg-info/requires.txt
+docker_stack.egg-info/top_level.txt

docker-stack-0.1.1/docker_stack.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

docker-stack-0.1.1/docker_stack.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+docker-stack = docker_stack.cli:main

docker-stack-0.1.1/docker_stack.egg-info/requires.txt

@@ -0,0 +1 @@
+PyYAML

docker-stack-0.1.1/docker_stack.egg-info/top_level.txt

@@ -0,0 +1 @@
+docker_stack

docker-stack-0.1.1/pyproject.toml

@@ -0,0 +1,5 @@
+[tool.pytest.ini_options]
+testpaths = [
+    "tests", 
+]
+pythonpath = ["docker_stack", "."]

docker-stack-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

docker-stack-0.1.1/setup.py

@@ -0,0 +1,27 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="docker-stack",
+    version="0.1.1",
+    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",
+    author="Sudip Bhattarai",
+    author_email="sudip.dev.np@gmail.com",
+    url="https://github.com/mesuidp/docker-stack",  # Replace with your project URL
+    packages=find_packages(),
+    install_requires=[
+        "PyYAML"
+    ],
+    entry_points={
+        "console_scripts": [
+            "docker-stack=docker_stack.cli:main",  # The function main() inside docker_stack.cli module
+        ],
+    },
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.6",
+)