docker-stack 0.1.1__tar.gz → 0.2.1__tar.gz

{docker-stack-0.1.1 → docker-stack-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: docker-stack
-Version: 0.1.1
+Version: 0.2.1
 Summary: CLI for deploying and managing Docker stacks.
 Home-page: https://github.com/mesuidp/docker-stack
 Author: Sudip Bhattarai

{docker-stack-0.1.1 → docker-stack-0.2.1}/docker_stack/__init__.py

@@ -1,4 +1,5 @@
-from .envsubst import envsubst
+
+from .envsubst import envsubst, envsubst_load_file
 from .compose import read_compose_file
 from .docker_objects import DockerConfig, DockerSecret
 from .cli import main

docker-stack-0.2.1/docker_stack/cli.py

@@ -0,0 +1,238 @@
+#!/usr/bin/env python3
+import argparse
+import sys
+from pathlib import Path
+from typing import List
+import os
+import yaml
+import json
+from docker_stack.docker_objects import DockerConfig, DockerObjectManager, DockerSecret
+from docker_stack.helpers import Command
+from docker_stack.registry import DockerRegistry
+from .envsubst import envsubst, envsubst_load_file
+
+class Docker:
+    def __init__(self,registries:List[str]=[]):
+        self.stack = DockerStack(self)
+        self.config = DockerConfig()
+        self.secret = DockerSecret()
+        self.registry = DockerRegistry(registries)
+
+    @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 read_compose_file(self,compose_file)->dict:
+        with open(compose_file) as f:
+           return self.decode_yaml(f.read())
+    
+    def rendered_compose_file(self,compose_file,stack=None)->str:
+        with open(compose_file) as f:
+            template_content = f.read()
+        # Parse the YAML content
+        compose_data = self.decode_yaml(template_content)
+        if stack:
+            base_dir = os.path.dirname(os.path.abspath(compose_file))
+            if "configs" in compose_data:
+                compose_data["configs"] = self._process_x_content(compose_data["configs"], self.docker.config,base_dir=base_dir,stack=stack)
+            if "secrets" in compose_data:
+                compose_data["secrets"] = self._process_x_content(compose_data["secrets"], self.docker.secret,base_dir=base_dir,stack=stack)
+        return envsubst(yaml.dump(compose_data))
+    
+    def decode_yaml(self,data:str)->dict:
+        return yaml.safe_load(data)
+        
+    def render_compose_file(self, compose_file,stack=None):
+        """
+        Render the Docker Compose file with environment variables and create Docker configs/secrets.
+        """
+        
+        # Convert the modified data back to YAML
+        rendered_content = self.rendered_compose_file(compose_file,stack)
+
+        # 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(rendered_content,indent=2))
+        return (rendered_filename,rendered_content)
+
+
+
+    def _process_x_content(self, objects, manager:DockerObjectManager,base_dir="",stack=None):
+        """
+        Process configs or secrets with x-content keys.
+        Returns a tuple: (processed_objects, commands)
+        """
+        processed_objects = {}
+        
+        def add_obj(name,data):
+            (object_name,command)=manager.create(name, data,stack=stack)                
+            if not command.isNop():
+                self.commands.append(command)
+            processed_objects[name] = {"name": object_name,"external": True}
+        for name, details in objects.items():
+            if isinstance(details, dict) and "x-content" in details:
+                add_obj(name,details['x-content'])
+            elif isinstance(details, dict) and 'x-template' in details:
+                add_obj(name,envsubst(details['x-content'],os.environ))
+            elif isinstance(details, dict) and 'x-template-file' in details:
+                filename=os.path.join(base_dir,details['x-template-file'])
+                add_obj(name,envsubst_load_file(filename,os.environ))
+            elif isinstance(details, dict) and 'file' in details:
+                filename=os.path.join(base_dir,details['file'])
+                with open(filename) as file:
+                    add_obj(name,file.read())
+            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,stack=stack_name)
+        _, cmd = self.docker.config.increment(stack_name, rendered_content, [f"mesudip.stack.name={stack_name}"],stack=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,give_console=True))
+
+    def push(self, compose_file):
+        compose_data = self.read_compose_file(compose_file)
+        for service_name, service_data in compose_data.get("services", {}).items():
+            if "build" in service_data:
+                image= envsubst(service_data['image'])
+                push_result = self.check_and_push_pull_image(image, 'push')
+                if push_result:
+                    self.commands.append(push_result)
+                else:
+                    # print("No need to push: Already exists")
+                    pass
+
+    def build_and_push(self, compose_file: str, push: bool = False) -> None:
+        """
+        Build Docker images from a Compose file and optionally push them.
+
+        Args:
+            compose_file (str): Path to the Docker Compose file.
+            push (bool): Whether to push the built images. Defaults to False.
+        """
+        compose_data = self.read_compose_file(compose_file)
+        base_dir = os.path.dirname(os.path.abspath(compose_file))
+
+        for service_name, service_data in compose_data.get("services", {}).items():
+            if "build" in service_data:
+                build_config = service_data["build"]
+                image = envsubst(service_data['image'])
+
+                build_command = ["docker", "build", "-t", image]
+              
+                              
+                for  value in build_config.get('args', []):
+                    build_command.extend(["--build-arg", envsubst(value)])
+
+                build_command.append(os.path.join(base_dir, build_config.get('context', '.')))
+                self.commands.append(Command(build_command))
+
+                if push:
+                    push_result = self.check_and_push_pull_image(image, 'push')
+                    if push_result:
+                        self.commands.append(push_result)
+                    else:
+                        # print("No need to push: Already exists")
+                        pass
+    def check_and_push_pull_image(self, image_name: str, action: str):
+        if self.docker.registry.check_image(image_name):
+            return None
+        if action == 'push':
+            cmd = self.docker.registry.push(image_name)
+            if cmd:
+                self.commands.append(cmd)
+
+
+def main(args:List[str]=None):
+    parser = argparse.ArgumentParser(description="Deploy and manage Docker stacks.")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # Build subcommand
+    build_parser = subparsers.add_parser("build", help="Build images using docker-compose")
+    build_parser.add_argument("compose_file", help="Path to the compose file")
+    build_parser.add_argument("--push", action="store_true", help="Use registry authentication")
+
+    # Push subcommand
+    push_parser = subparsers.add_parser("push", help="Push images to registry")
+    push_parser.add_argument("compose_file", help="Path to the compose file")
+    
+    # Deploy subcommand
+    deploy_parser = subparsers.add_parser("deploy", help="Deploy stack using docker stack deploy")
+    deploy_parser.add_argument("stack_name", help="Name of the stack")
+    deploy_parser.add_argument("compose_file", help="Path to the compose file")
+    deploy_parser.add_argument("--with-registry-auth", action="store_true", help="Use registry authentication")
+    
+    # Remove subcommand
+    rm_parser = subparsers.add_parser("rm", help="Remove a deployed stack")
+    rm_parser.add_argument("stack_name", help="Name of the stack")
+    
+    parser.add_argument("-u", "--user", help="Registry credentials in format hostname:username:password", action="append", required=False, default=[])
+    parser.add_argument("-t", "--tag", help="Tag the current deployment for later checkout", required=False)
+    parser.add_argument("-ro",'-r',"--ro","--r", "--dry-run", action="store_true", help="Print commands, don't execute them", required=False)
+    
+    args = parser.parse_args(args if args else sys.argv[1:])
+    
+    docker = Docker(registries=args.user)
+    docker.load_env()
+    
+    if args.command == "build":
+        docker.stack.build_and_push(args.compose_file,push=args.push)
+    elif args.command == "push":
+        docker.stack.push(args.compose_file)
+    elif args.command == "deploy":
+        docker.stack.deploy(args.stack_name, args.compose_file, args.with_registry_auth)
+    elif args.command == "rm":
+        docker.stack.rm(args.stack_name)
+    
+
+    if args.ro:
+        print("Following commands were not executed:")
+        [print(" >> "+str(x)) for x in docker.stack.commands if x]
+    else:
+        [ x.execute() for x in docker.stack.commands]
+
+
+if __name__ == "__main__":
+    main([""])

{docker-stack-0.1.1 → docker-stack-0.2.1}/docker_stack/compose.py

@@ -1,5 +1,5 @@
 import yaml
-
+import os
 
 def read_compose_file(compose_file_path):
     """

{docker-stack-0.1.1 → docker-stack-0.2.1}/docker_stack/docker_objects.py

@@ -45,10 +45,11 @@ class DockerObjectManager:
             return False
 
     def create(
-        self, object_name, object_content, labels: List[str] = []
+        self, object_name, object_content, labels: List[str] = [],stack=None
     ) -> Tuple[str, Command]:
         sha_hash = self.calculate_hash(object_name, object_content)
-
+        if stack :
+            labels=labels + ["com.docker.stack.namespace="+stack]
         # Check if any version of the object already exists by its label
         command = [
             "docker",
@@ -121,10 +122,11 @@ class DockerObjectManager:
         )
 
     def increment(
-        self, object_name, object_content, labels: List[str] = []
+        self, object_name, object_content, labels: List[str] = [],stack=None
     ) -> Tuple[str, Command]:
         sha_hash = self.calculate_hash(object_name, object_content)
-
+        if stack :
+            labels=labels + ["com.docker.stack.namespace="+stack]
         # Check if any version of the object already exists by its label
         command = [
             "docker",

{docker-stack-0.1.1 → docker-stack-0.2.1}/docker_stack/envsubst.py

@@ -25,20 +25,49 @@ def envsubst(template_str, env=os.environ):
     # Regex for $VARIABLE without default
     pattern_without_default = re.compile(r"\$([a-zA-Z_][a-zA-Z0-9_]*)")
 
-    def replace_with_default(match):
+    def print_error_line(template_str, match_span):
+        """Helper function to print the error context."""
+        lines = template_str.splitlines()
+        
+        # Determine the start position and line
+        start_pos = match_span[0]
+        end_pos = match_span[1]
+
+        # Calculate line numbers based on character positions
+        char_count = 0
+        start_line = end_line = None
+        for i, line in enumerate(lines):
+            char_count += len(line) + 1  # +1 for the newline character
+            if start_line is None and char_count > start_pos:
+                start_line = i
+            if char_count >= end_pos:
+                end_line = i
+                break
+        
+        # Display lines before, the error line, and after (with line numbers)
+        start = max(start_line - 1, 0)
+        end = min(end_line + 1, len(lines) - 1)
+
+        for i in range(start, end + 1):
+            print(f"{i + 1}: {lines[i]}",file=sys.stderr)
+
+    def replace_with_default(match: re.Match[str]):
         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)
+            print_error_line(template_str, match.span())
+            print(f"ERROR :: Missing template variable with default: {var}", file=sys.stderr)
+
             exit(1)
         return result
 
-    def replace_without_default(match):
+    def replace_without_default(match: re.Match[str]):
         var = match.group(1)
         result = env.get(var, None)
         if result is None:
-            print(f"Missing template variable: {var}", file=sys.stderr)
+            print_error_line(template_str, match.span())
+            print(f"ERROR :: Missing template variable: {var}", file=sys.stderr)
             exit(1)
         return result
 
@@ -51,6 +80,10 @@ def envsubst(template_str, env=os.environ):
     return template_str
 
 
+def envsubst_load_file(template_file,env=os.environ):
+    with open(template_file) as file:
+        return envsubst(file.read(),env)
+
 def main():
     if len(sys.argv) > 2:
         print("Usage: python envsubst.py [template_file]")

{docker-stack-0.1.1 → docker-stack-0.2.1}/docker_stack/helpers.py

@@ -9,6 +9,7 @@ def run_cli_command(
     log: bool = True,
     shell: bool = False,
     interactive: bool = False,
+    cwd=None
 ) -> str:
     """
     Run a CLI command and return its output.
@@ -25,11 +26,11 @@ def run_cli_command(
         The stdout of the command as a string, or None if interactive mode is enabled.
     """
     if log:
-        print("> " + " ".join(command))
+        print("> " + " ".join(command),flush=True)
 
     try:
         if interactive:
-            result = subprocess.run(command, shell=shell)
+            result = subprocess.run(command, shell=shell,cwd=cwd)
             return None
         else:
             result = subprocess.run(
@@ -39,6 +40,7 @@ def run_cli_command(
                 capture_output=True,
                 check=raise_error,
                 shell=shell,
+                cwd=cwd
             )
             return result.stdout.strip()
     except subprocess.CalledProcessError as e:
@@ -56,7 +58,8 @@ class Command:
         return self == Command.nop
 
     def __init__(
-        self, command: List[str], stdin: Optional[str] = None, log: bool = True, id=None
+        self, command: List[str], stdin: Optional[str] = None, log: bool = True, id=None,give_console=False
+        ,cwd:str=None
     ):
         """
         Initialize a Command object.
@@ -70,6 +73,9 @@ class Command:
         self.stdin = stdin
         self.log = log
         self.id = id
+        self.give_console=give_console
+        self.cwd=cwd
+        
 
     def execute(self, log: Optional[bool] = None) -> str:
         """
@@ -85,9 +91,15 @@ class 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)
+            if self.give_console:
+                print("Giving console")
+                process = subprocess.Popen(self.command, shell=True,cwd=self.cwd)
+                process.wait()
+            else:
+                subprocess.run(self.command)
+        return run_cli_command(self.command, stdin=self.stdin, log=use_log, shell=False,cwd=self.cwd)
 
     def __str__(self) -> str:
         """

docker-stack-0.2.1/docker_stack/registry.py

@@ -0,0 +1,239 @@
+import json
+import http.client
+import select
+import subprocess
+from base64 import b64encode
+from typing import Dict, List
+
+from docker_stack.helpers import Command
+from docker_stack.url_parser import ConnectionDetails, parse_url
+import os
+class DockerRegistry:
+    def __init__(self, _registries:List[str]):
+        """
+        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
+        """
+        registries = [ parse_url(registry) for registry in _registries]
+        for registry in registries:
+            splitted=registry["host"].split(':')
+            if len(splitted)> 1:
+                if splitted[1] =='443':
+                    registry['host']=splitted[0]
+                    registry["scheme"] = "https"
+        
+        self.registries:Dict[str,ConnectionDetails] = {x["host"]:x for x in self.load_system_connections()} 
+        for reg in registries:
+            self.registries[reg["host"]]=reg
+            
+        self.authenticated=set()
+
+    def load_system_connections(self) -> List[ConnectionDetails]:
+        # Determine the path to the Docker config file
+        home_dir = os.getenv('HOME', '/root')
+        config_path = os.path.join(home_dir, '.docker', 'config.json')
+
+        # Initialize an empty list to store connection details
+        connections = []
+
+        try:
+            # Open and read the Docker config file
+            with open(config_path, 'r') as file:
+                config = json.load(file)
+
+                # Extract the 'auths' section
+                auths = config.get('auths', {})
+                for host, auth_info in auths.items():
+                    # Extract the auth token (username:password in base64)
+                    auth_token = auth_info.get('auth', '')
+                    if auth_token:
+                        # Decode the base64 token to get username:password
+                        import base64
+                        decoded_token = base64.b64decode(auth_token).decode('utf-8')
+                        username, password = decoded_token.split(':', 1)
+
+                        # Create a ConnectionDetails dictionary
+                        connection: ConnectionDetails = {
+                            'scheme': 'https',  # Docker registries typically use HTTPS
+                            'host': host,
+                            'username': username,
+                            'password': password
+                        }
+                        connections.append(connection)
+
+        except FileNotFoundError:
+            print("[Docker Config Load] Docker config file not found.")
+        except json.JSONDecodeError:
+            print("[Docker Config Load] Invalid JSON in Docker config file.")
+        except Exception as e:
+            print(f"[Docker Config Load] An error occurred: {e}")
+
+        return connections
+
+
+    def _get_host_from_url(self, url:str):
+        """Extracts the host from the URL."""
+        # Remove protocol part (http:// or https://)
+        if url.startswith('http://') or url.startswith("https://"):
+            return url.split('://')[1].split('/')[0]
+        return url
+    
+    def _send_request(self, conn:ConnectionDetails ,method, endpoint)->http.client.HTTPResponse:
+        """Send a generic HTTP request to the Docker registry."""
+        connection = http.client.HTTPSConnection(conn["host"]) if conn["scheme"]=='https' else http.client.HTTPConnection(conn["host"])
+        
+        # Add Authorization header if needed
+        headers = {}
+        if conn["username"]:
+            auth_string=conn['username']+':'+conn['password']
+            headers['Authorization'] = f"Basic {b64encode(auth_string.encode()).decode()}"
+        
+        connection.request(method, endpoint, headers=headers)
+        response = connection.getresponse()
+        return response
+    
+    def check_auth(self,conn:ConnectionDetails):
+        """
+        Check if the authentication credentials (if provided) are valid for the Docker registry.
+        
+        :return: Boolean indicating whether authentication is successful
+        """
+        url = "/v2/"
+        response = self._send_request(conn,'GET', url)
+        if response.status == 200:
+            self.authenticated.add(conn["host"])
+            return True
+
+
+    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
+        """
+        self.login_for_image(image_name)
+        hostname=extract_host_from_image_name(image_name)
+        url = f"/v2/{image_name}/tags/list"
+
+        if hostname in self.registries:
+            response = self._send_request(self.registries[hostname],'GET',url)
+        else:
+            registry=parse_url(hostname)
+            response =  self._send_request(registry,'GET',url)
+        print("response",response.read())
+        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)
+        """
+        self.login_for_image(image_name)
+        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)
+        """
+        self.login_for_image(image_name)
+        command = ['docker', 'pull', image_name]
+        return self._run_docker_command(command)
+            
+
+    def login_for_image(self,image):
+        hostname= extract_host_from_image_name(image)
+        if hostname  in self.authenticated:
+            return True
+        if hostname in self.registries and self.check_auth(self.registries[hostname]):
+            self.authenticated.add(hostname)
+        else:
+            registry=self.registries.get(hostname)
+            if registry:
+                print("> " ," ".join(['docker','login','-u',registry["username"],'-p','[redacted]',registry["host"]]) )
+                subprocess.run(['docker','login','-u',registry['username'],'-p',registry['password'],registry["host"]])
+                self.authenticated.add(hostname)  
+        return hostname
+
+
+def extract_host_from_image_name(image_name: str) -> str:
+    """
+    Extracts the hostname (registry address) from a Docker image name.
+    
+    :param image_name: Docker image name (e.g., 'ubuntu', 'myregistry.com/myimage', or 'myregistry.com/myrepo/myimage:tag')
+    :return: Hostname (e.g., 'docker.io', 'myregistry.com')
+    """
+    # Remove protocol part (http:// or https://) if present
+    if image_name.startswith('http://'):
+        image_name = image_name[len('http://'):]
+    elif image_name.startswith('https://'):
+        image_name = image_name[len('https://'):]
+
+    # Check if the image name has a registry/hostname
+    if '/' in image_name:
+        parts = image_name.split('/', 1)
+        # If it looks like a full URL (e.g., myregistry.com/myimage:tag)
+        if '.' in parts[0] and not parts[0].startswith('http'):
+            splitted=parts[0].split(':')
+            if len(splitted)> 1:
+                if splitted[1] =='443':
+                    return splitted[0]
+            return parts[0]
+        # If it looks like a username/repository (e.g., 'username/myimage')
+        return 'docker.io'
+    return 'docker.io'

docker-stack-0.2.1/docker_stack/url_parser.py

@@ -0,0 +1,171 @@
+import re
+from typing import TypedDict
+
+class ConnectionDetails(TypedDict):
+    scheme: str
+    host: str
+    username: str
+    password: str
+
+class URLParsingError(Exception):
+    """Custom exception raised when URL parsing fails."""
+    pass
+
+def is_valid_hostname(hostname: str) -> bool:
+    """
+    https://stackoverflow.com/a/33214423/2804342
+    :return: True if for valid hostname False otherwise
+    """
+    if hostname[-1] == ".":
+        # strip exactly one dot from the right, if present
+        hostname = hostname[:-1]
+    if len(hostname) > 253:
+        return False
+
+    labels = hostname.split(".")
+
+    # the TLD must be not all-numeric
+    if re.match(r"[0-9]+$", labels[-1]):
+        return False
+
+    allowed = re.compile(r"(?!-)[a-z0-9-]{1,63}(?<!-)$", re.IGNORECASE)
+    return all(allowed.match(label) for label in labels)
+def is_valid_hostport(str):
+    results=str.split(':')
+    def is_valid_integer(s):
+        try:
+            int(s)  # Try converting the string to an integer
+            return True
+        except ValueError:
+            return False
+    if len(results)==2:
+        return is_valid_hostname(results[0]) and is_valid_integer(results[1])
+    elif len(results)==1:
+            return is_valid_hostname(results[0])
+    else:
+        return False
+def parse_url(url)-> ConnectionDetails:
+    """
+    Parses a URL and returns a dictionary with scheme, host, username, and password.
+
+    Args:
+        url (str): The URL string to be parsed.
+
+    Returns:
+        dict: A dictionary containing parsed components of the URL.
+            {
+                'scheme': 'https' or 'http', 
+                'host': The host of the URL, 
+                'username': The username (if any),
+                'password': The password (if any)
+            }
+
+    Raises:
+        URLParsingError: If the URL cannot be parsed.
+    """
+    # Regular expression to match the URL with scheme, host:username:password or host:port:username:password format
+    pattern = re.compile(r'^(?P<scheme>https?|ftp)://(?:(?P<username>[^:@]+)(?::(?P<password>[^@]+))?@)?(?P<host>[^:/]+)(?::(?P<port>\d+))?$')
+
+    # Attempt to match the URL with the regular expression
+    match = pattern.match(url)
+
+    if match:
+        scheme = match.group('scheme') if match.group('scheme') else 'https'  # Default to https
+        host = match.group('host')
+        port = match.group('port')
+        username = match.group('username')
+        password = match.group('password')
+
+        # If there's a port, append it to the host
+        if port:
+            host = f"{host}:{port}"
+        
+        return {
+            "scheme": scheme,
+            "host": host,
+            "username": username,
+            "password": password
+        }
+    
+    # Handle special cases where the URL is in host:username:password or host:port:username:password format (may include scheme)
+    special_match = re.match(r'^(?P<scheme>https?|ftp)://(?P<host>[^:/]+)(?::(?P<port>\d+))?:(?P<username>[^:]+):(?P<password>.+)$', url)
+    if special_match:
+        scheme = special_match.group('scheme') if special_match.group('scheme') else 'https'  # Default to https
+        host = special_match.group('host')
+        port = special_match.group('port')
+        username = special_match.group('username')
+        password = special_match.group('password')
+
+        # If there's a port, append it to the host
+        if port:
+            host = f"{host}:{port}"
+
+        return {
+            "scheme": scheme,
+            "host": host,
+            "username": username,
+            "password": password
+        }
+        
+
+    # Handle special case where no scheme is given, but it is in host:username:password or host:port:username:password format
+    special_no_scheme_match = re.match(r'^(?P<host>[^:/]+)(?::(?P<port>\d+))?:(?P<username>[^:]+):(?P<password>.+)$', url)
+    if special_no_scheme_match:
+        host = special_no_scheme_match.group('host')
+        port = special_no_scheme_match.group('port')
+        username = special_no_scheme_match.group('username')
+        password = special_no_scheme_match.group('password')
+
+        # If there's a port, append it to the host
+        if port:
+            host = f"{host}:{port}"
+
+        return {
+            "scheme": 'https',  # Default to https for the special case
+            "host": host,
+            "username": username,
+            "password": password
+        }
+    
+    simple_regex = r'^(?:(?P<username>\S+):(?P<password>\S+)@)?(?P<hostport>\S+)(?::\d+)?$'
+    match = re.match(simple_regex, url)
+
+    if match:
+        username = match.group("username")
+        password = match.group("password")
+        hostport = match.group("hostport")
+        if is_valid_hostport(hostport):
+            return {
+            "scheme": "https",
+            "host": hostport,
+            "username": username,
+            "password": password
+        }        
+    # If no match was found, raise a parsing error
+    raise URLParsingError(f"Failed to parse URL: {url}")
+
+
+# Run tests when this file is executed directly
+if __name__ == "__main__":
+    # Test cases
+    test_urls = [
+        ("registry.sireto.io", {'scheme': 'https', 'host': 'registry.sireto.io', 'username': None, 'password': None}),
+        ("user:password@registry.sireto.io", {'scheme': 'https', 'host': 'registry.sireto.io', 'username': 'user', 'password': 'password'}),
+        ("https://registry.sireto.io", {'scheme': 'https', 'host': 'registry.sireto.io', 'username': None, 'password': None}),
+        ("https://user:password@registry.sireto.io", {'scheme': 'https', 'host': 'registry.sireto.io', 'username': 'user', 'password': 'password'}),
+        ("registry.sireto.io:user:password", {'scheme': 'https', 'host': 'registry.sireto.io', 'username': 'user', 'password': 'password'}),
+        ("registry.sireto.io:5050:user:password", {'scheme': 'https', 'host': 'registry.sireto.io:5050', 'username': 'user', 'password': 'password'}),
+        ("http://registry.sireto.io:5050:user:password", {'scheme': 'http', 'host': 'registry.sireto.io:5050', 'username': 'user', 'password': 'password'}),
+        ("https://registry.sireto.io:5050:user:password", {'scheme': 'https', 'host': 'registry.sireto.io:5050', 'username': 'user', 'password': 'password'}),
+        ("registry.sireto.io:5050:user:password", {'scheme': 'https', 'host': 'registry.sireto.io:5050', 'username': 'user', 'password': 'password'}),
+        ("registry.sireto.io:user:password", {'scheme': 'https', 'host': 'registry.sireto.io', 'username': 'user', 'password': 'password'})
+    ]
+    
+    for url, expected in test_urls:
+        try:
+            print(f"Testing URL: {url}")
+            result = parse_url(url)
+            assert result == expected, f"Test failed for {url}. Expected {expected}, got {result}"
+            print(f"Success: {result}")
+        except Exception as e:
+            print(f"Error: {e}")

{docker-stack-0.1.1 → docker-stack-0.2.1}/docker_stack.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: docker-stack
-Version: 0.1.1
+Version: 0.2.1
 Summary: CLI for deploying and managing Docker stacks.
 Home-page: https://github.com/mesuidp/docker-stack
 Author: Sudip Bhattarai

{docker-stack-0.1.1 → docker-stack-0.2.1}/docker_stack.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ docker_stack/envsubst_merge.py
 docker_stack/helpers.py
 docker_stack/merge_conf.py
 docker_stack/registry.py
+docker_stack/url_parser.py
 docker_stack.egg-info/PKG-INFO
 docker_stack.egg-info/SOURCES.txt
 docker_stack.egg-info/dependency_links.txt

{docker-stack-0.1.1 → docker-stack-0.2.1}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="docker-stack",
-    version="0.1.1",
+    version="0.2.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",

docker-stack-0.1.1/docker_stack/cli.py

@@ -1,169 +0,0 @@
-#!/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/registry.py

@@ -1,150 +0,0 @@
-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])