service-dev-env 0.5.0__py3-none-any.whl

service_dev_env/bash_scripts/bash_container.bash

@@ -0,0 +1,18 @@
+#!/bin/bash
+SCRIPT_PATH="$(dirname "$0")"
+BASE_PATH=$(realpath "$SCRIPT_PATH/..")
+DOCKER_PATH=$(realpath "$1")
+SERVICE="$2"
+
+if [ $# -eq 2 ]; then
+  ENV_FILE=$(realpath $BASE_PATH/local_vars.env)
+else
+  ENV_FILE=$3
+fi
+
+cd "$DOCKER_PATH" || exit 1
+
+ENV_FILE=$ENV_FILE docker compose --env-file $ENV_FILE run --rm "$SERVICE" bash
+
+echo "Press CTRL+C to close..."
+sleep infinity

service_dev_env/bash_scripts/docker_log.bash

@@ -0,0 +1,36 @@
+#!/bin/bash
+SCRIPT_PATH="$(dirname "$0")"
+BASE_PATH=$(realpath "$SCRIPT_PATH/..")
+DOCKER_PATH=$(realpath "$1")
+SERVICE="$2"
+
+if [ $# -eq 2 ]; then
+  ENV_FILE=$(realpath $BASE_PATH/local_vars.env)
+else
+  ENV_FILE=$3
+fi
+
+emoji[0]="😖"
+emoji[1]="😭"
+emoji[2]="😫"
+emoji[3]="😞"
+emoji[4]="😓"
+
+
+cd $DOCKER_PATH || exit 1
+
+while :
+do
+  ENV_FILE=$ENV_FILE docker compose --env-file $ENV_FILE logs -f --tail=50 $SERVICE
+
+  size=${#emoji[@]}
+  index=$(($RANDOM % $size))
+  echo "${emoji[$index]} $SERVICE log ended, press <CTRL+C> to close..."
+  sleep 5
+done
+
+
+ENV_FILE=$ENV_FILE docker compose --env-file $ENV_FILE logs -f $SERVICE
+
+echo "Press CTRL+C to close..."
+sleep infinity

service_dev_env/build/lib/docker_dev_env/ui.tcss

@@ -0,0 +1,10 @@
+#stats_box {
+    height: 3;
+    border: solid $accent;
+    background: $panel;
+}
+
+#table_box {
+    height: 1fr;
+    border: solid $accent;
+}

service_dev_env/cli.py

@@ -0,0 +1,111 @@
+import argparse
+
+from .docker_utils import DockerUtils
+from .fun import goodbye
+from .project import Project
+from .terminals import TERMINALS
+from .terminals.tilix import Tilix  # default terminal
+from .ui import DockerDevEnvUi
+
+
+def _setup_argparse() -> argparse.ArgumentParser:
+    """Configure argument parser."""
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.RawTextHelpFormatter)
+    parser.add_argument(
+        '-c', '--cleanup', action='store_true',
+        help='just cleanup, do not start')
+    parser.add_argument(
+        '-n', '--no-cleanup', action='store_true',
+        help='no cleanup after finish')
+    parser.add_argument(
+        '-p', '--project', default='project-config.yml',
+        help='project yaml file')
+    parser.add_argument(
+        '-s', '--stopped', action='store_true',
+        help='do not create container, start with all container stopped')
+    parser.add_argument(
+        '-l', '--log',
+        help='only show log of <service name>')
+    parser.add_argument(
+        '--cmd', action='store_true',
+        help='only show commands to run the services for easy copy-and-paste,'
+             'do not start.')
+    parser.add_argument(
+        '-e', '--env',
+        help='name of environment (defaults to default_env from your config)')
+    parser.add_argument(
+        '-t', '--terminal', default='tilix',
+        help='name of the terminal (defaults to tilix)')
+    parser.add_argument(
+        '-r', '--rebuild', action='store_true',
+        help='rebuild container before start')
+    parser.add_argument(
+        '-ro', '--rebuild-only', action='store_true',
+        help='rebuild container only, do not start')
+    parser.add_argument(
+        '-b', '--bash', default=None,
+        help='run bash inside the container')
+    parser.add_argument(
+        '-d', '--deploy', action='store_true',
+        help='build docker container for deploy environment and '
+             'run deploy script')
+    # we show "-i"/init for --help but as its already handled
+    # by the ./run bash script we ignore it.
+    parser.add_argument(
+        '-i', '--init', action='store_true',
+        help='(re)init: deletes the local dev and recreates it.')
+    return parser
+
+
+def main():
+    parser = _setup_argparse()
+    args = parser.parse_args()
+    project = Project(args.project)
+    if args.env:
+        project.select_env(args.env)
+    elif args.deploy:
+        if not project.select_deploy_env():
+            return
+    terminal = args.terminal
+    _terminal = TERMINALS[terminal] if terminal in TERMINALS else Tilix
+    _docker_utils = DockerUtils(project)
+    start = True
+    if args.cleanup:
+        _docker_utils.cleanup()
+        start = False
+    if args.rebuild or args.rebuild_only or args.deploy:
+        _docker_utils.build_all()
+        if args.rebuild_only:
+            start = False
+    if args.cmd:
+        _docker_utils.print_cmds()
+        start = False
+    if args.log:
+        _docker_utils.log(args.log)
+        # logs run forever, we don't want to continue
+        return
+    if args.bash:
+        _docker_utils.bash(args.bash)
+        # bash runs forever, we don't want to continue
+        return
+    if args.deploy:
+        project.deploy()
+        return
+    if not start:
+        return
+
+    if not args.stopped:
+        _docker_utils.autostart()
+    app = DockerDevEnvUi(_docker_utils, _terminal(project))
+    app.run()
+
+    # Cleanup at the end
+    if not args.no_cleanup:
+        _docker_utils.cleanup()
+    goodbye()
+
+
+if __name__ == '__main__':
+    main()

service_dev_env/docker_utils.py

@@ -0,0 +1,247 @@
+import os
+import subprocess
+from pathlib import Path
+
+from typing import Dict, List
+
+import docker
+
+from .model.project import ProjectConfig
+from .model.service import ServiceConfig
+from .runner import Runner
+
+
+BASE_PATH = Path(__file__).absolute().parent
+
+
+class DockerUtils(Runner):
+    """Wrapper around Popen and docker to manage docker container."""
+
+    def __init__(self, project: ProjectConfig):
+        super().__init__(project)
+        self.docker_client = docker.from_env()
+
+    def autostart(self):
+        if self.env.networks:
+            self.create_network(self.env.networks, )
+        for service in self.services:
+            if service.autostart:
+                self.compose_start(service)
+
+    def compose_cmd(self, cmd: List):
+        docker_cmd = ['docker', 'compose']
+        if self.env.docker_compose_path:
+            _path = self.env.docker_compose_path
+            if not Path(_path).exists():
+                raise RuntimeError(f'ERROR: {_path} does not exist.')
+            docker_cmd += ['-f', _path]
+        if self.env.env_file:
+            _path = self.env.env_path()
+            if not Path(_path).exists():
+                raise RuntimeError(f'ERROR: {_path} does not exist.')
+            docker_cmd += ['--env-file', _path]
+        if isinstance(cmd, str):
+            docker_cmd.append(cmd)
+        else:
+            docker_cmd += cmd
+        return docker_cmd
+
+    def compose_bash_cmd(self, service):
+        return self.compose_cmd(['run', '--rm', '-it', service.name, 'bash'])
+
+    def compose_logs_cmd(self, service):
+        return self.compose_cmd(['logs', '-f', '--tail=50', service.name])
+
+    def compose_start_cmd(self, service: ServiceConfig):
+        return self.compose_cmd(['up', '-d', service.name])
+
+    def _run_cmd(
+            self, cmd: List, service: ServiceConfig = None,
+            check: bool = False, env: Dict = None):
+        args = {'env': os.environ.copy()}
+        if env:
+            args['env'].update(env)
+        elif env is None:
+            args['env'].update(self._get_env())
+        if service and service.folder:
+            args['cwd'] = service.folder
+        args['check'] = check
+        try:
+            subprocess.run(cmd, **args)
+        except KeyboardInterrupt:
+            pass
+
+    def compose_start(self, service: ServiceConfig):
+        """Start docker compose command."""
+        if hasattr(service, 'description') and service.description:
+            print(f'🚀 Starting {service.description}...')
+        cmd = self.compose_start_cmd(service)
+        self._run_cmd(cmd, service)
+
+    def bash(self, service_name: str):
+        for service in self.services:
+            if service.name == service_name:
+                cmd = self.compose_bash_cmd(service)
+                self._run_cmd(cmd, service)
+                return
+        print(f'Error: unknown service {service_name}')
+
+    def log(self, service_name: str):
+        """Print out the log of the given service name."""
+        for service in self.services:
+            if service.name == service_name:
+                cmd = self.compose_logs_cmd(service)
+                self._run_cmd(cmd, service)
+                return
+        print(f'Error: unknown service {service_name}')
+
+    def print_cmds(self):
+        for env_name, env in self.project.env.items():
+            print(f'== {env_name} ==')
+            for service in env.services:
+                print(f'==== {service.name} ====')
+                print(' '.join(self.compose_build_cmd(service)))
+                print(' '.join(self.compose_start_cmd(service)))
+                print(' '.join(self.compose_logs_cmd(service)))
+                print(' '.join(self.compose_bash_cmd(service)))
+
+    def compose_kill_cmd(self, service: ServiceConfig):
+        """Kill container using compose (for faster down)."""
+        return self.compose_cmd(['kill', service.name])
+
+    def compose_kill(self, service: ServiceConfig):
+        """Kill container using compose (for faster down)."""
+        title = service.name
+        if hasattr(service, 'description') and service.description:
+            title = service.description
+        print(f'➜ Kill container {title}')
+        cmd = self.compose_kill_cmd(service)
+        self._run_cmd(cmd, service)
+
+    def compose_build_cmd(self, service: ServiceConfig):
+        """Build image by service name."""
+        return self.compose_cmd(['build', service.name])
+
+    def compose_build(self, service: ServiceConfig):
+        """Build image by service name."""
+        cmd = self.compose_build_cmd(service)
+        self._run_cmd(cmd, service)
+
+    def compose_down(self):
+        """Run docker compose down to clean up."""
+        cmd = self.compose_cmd(['down'])
+        self._run_cmd(cmd, check=False)
+
+    def create_network(self, networks):
+        if isinstance(networks, str):
+            networks = [networks]
+        for network in networks:
+            print(f'🌐 Create docker network {network}')
+            docker_cmd = ['docker', 'network', 'create', network]
+            subprocess.run(docker_cmd, check=False)
+
+    def rm_network(self, networks):
+        if isinstance(networks, str):
+            networks = [networks]
+        for network in networks:
+            print(f'➜ Remove network {network}')
+            docker_cmd = ['docker', 'network', 'rm', network]
+            subprocess.run(docker_cmd, check=False)
+
+    def _not_available(self, service: ServiceConfig):
+        return {
+            'service': service.title,
+            'container_id': 'N/A',
+            'status': 'not running',
+            'health': 'unknown',
+            'image': 'N/A',
+        }
+
+    def _get_health_status(self, container) -> str:
+        """Get health check status from container."""
+        container.reload()
+        state = container.attrs.get('State', {})
+
+        if state.get('Health'):
+            health = state['Health'].get('Status', 'unknown')
+            if health == 'healthy':
+                color = 'green'
+            elif health == 'unhealthy':
+                color = 'red'
+            else:
+                color = 'yellow'
+            return f'[{color}]{health}[/]'
+        return 'no check'
+
+    def service_status(self, service: ServiceConfig):
+        containers = self.docker_client.containers.list(
+            all=True,
+            filters={'label': f'com.docker.compose.service={service.name}'}
+        )
+        if not containers:
+            return self._not_available(service)
+        container = containers[0]
+        health_status = self._get_health_status(container)
+        tags = container.image.tags
+        return {
+            'service': service.title,
+            'container_id': container.short_id,
+            'status': container.status,
+            'health': health_status,
+            'image': tags[0] if tags else 'unknown',
+        }
+
+    def service_running(self, service: ServiceConfig):
+        containers = self.docker_client.containers.list(
+            all=True,
+            filters={'label': f'com.docker.compose.service={service.name}'}
+        )
+        if not containers:
+            return False
+        container = containers[0]
+        return container.status == 'running'
+
+    def health_row(self, service: ServiceConfig):
+        service_status = self.service_status(service)
+        return [
+            service_status['service'],
+            service_status['container_id'],
+            service_status['status'],
+            service_status['health'],
+            service_status['image'],
+        ]
+
+    def rebuild(self, app, service: ServiceConfig):
+        async def _rebuild_done():
+            app.notify(f'Rebuild for {service.name} done.')
+            if service.autostart:
+                self.run_background(
+                    service.folder, [self.compose_start_cmd(service)], app)
+        cmds = [
+            self.compose_kill_cmd(service),
+            self.compose_build_cmd(service)]
+        self.run_background(service.folder, cmds, app, _rebuild_done)
+
+    def restart(self, app, service: ServiceConfig):
+        cmds = []
+        if self.service_running(service):
+            cmds.append(self.compose_kill_cmd(service))
+        cmds.append(self.compose_start_cmd(service))
+        self.run_background(service.folder, cmds, app)
+
+    def kill(self, app, service: ServiceConfig):
+        self.run_background(
+            service.folder, [self.compose_kill_cmd(service)], app)
+
+    def build_all(self):
+        for service in self.services:
+            if service.rebuild:
+                self.compose_build(service)
+
+    def cleanup(self):
+        for service in self.services:
+            self.compose_kill(service)
+        self.compose_down()
+        if self.env.networks and self.env.cleanup_networks:
+            self.rm_network(self.env.networks)
+        print(' 🧽 Cleanup complete.')

service_dev_env/fun.py

@@ -0,0 +1,18 @@
+import random
+
+FAREWELL = [
+    'How lucky I am to have something that makes saying goodbye so hard.',
+    "Don't cry because it's over, smile because it happened.",
+    'The pain of parting is nothing to the joy of meeting again.',
+    "Man's feelings are always purest and most glowing in the "
+    'hour of meeting and farewell.',
+    'So long, and thanks for all the fish.',
+    'We only part to meet again.',
+    'Every goodbye makes the next hello closer.',
+    'Let there be spaces in your togetherness.',
+    'My battery is low, and its getting dark.'
+]
+
+
+def goodbye():
+    print(f'\n 👋 Goodbye: {random.choice(FAREWELL)} ')

service_dev_env/layout.py

@@ -0,0 +1,33 @@
+import math
+
+
+class LayoutCalculator:
+    """Calculates optimal layout dimensions."""
+
+    # Strategy pattern: custom layout functions
+    _custom_strategies: dict[int, tuple[int, int]] = {}
+
+    @classmethod
+    def register_strategy(cls, num_windows: int, rows: int, cols: int) -> None:
+        """Register a custom layout strategy."""
+        cls._custom_strategies[num_windows] = (rows, cols)
+
+    @classmethod
+    def calculate(
+        cls,
+        num_windows: int,
+        prefer_horizontal: bool = False,
+    ) -> tuple[int, int]:
+        """Calculate optimal rows and columns."""
+        # Check custom strategies first
+        if num_windows in cls._custom_strategies:
+            return cls._custom_strategies[num_windows]
+
+        if 12 > num_windows > 17:
+            # this would end up in a 3-5 window, we prefer 4x4 instead
+            return 4, 4
+        else:
+            # heuristic to calculate square-ish terminal alignment
+            cols = int(math.sqrt(num_windows))
+            rows = (num_windows + cols - 1) // cols
+        return (cols, rows) if prefer_horizontal else (rows, cols)

service_dev_env/model/env.py

@@ -0,0 +1,42 @@
+from dataclasses import dataclass
+from pathlib import Path
+
+from .publish import PublishConfig
+from .service import ServiceConfig
+
+
+@dataclass
+class EnvConfig:
+    """Defined environment with multiple services and its own compose file."""
+
+    services: list[ServiceConfig]
+    docker_compose_path: str | None = None
+    update_interval: int = 1
+    log_tail: int = 100
+    build_timeout: float = 3600
+    env_file: str | None = None
+    networks: list | None = None
+    cleanup_networks: bool | None = True
+    publish: PublishConfig | None = None
+    deploy_script: str | None = None
+    folder: str = '.'
+
+    def __post_init__(self):
+        services = []
+        if self.services:
+            for _service in self.services:
+                if isinstance(_service, ServiceConfig):
+                    services.append(_service)
+                else:
+                    services.append(ServiceConfig(**_service))
+        self.services = services
+        if self.publish:
+            if not isinstance(self.publish, PublishConfig):
+                self.publish = PublishConfig(**self.publish)
+
+    def env_path(self):
+        _env = self.env_file or ''
+        if _env.startswith('/'):
+            return _env
+        path = Path('.').absolute()
+        return str(path / _env)

service_dev_env/model/layout.py

@@ -0,0 +1,21 @@
+"""Layout mode and configuration models."""
+from dataclasses import dataclass
+from enum import Enum
+
+
+class LayoutMode(Enum):
+    """Provide layout configuration modes."""
+
+    AUTO = 'auto'  # Smart layout based on window count
+    GRID = 'grid'  # Manual rows x columns
+    CUSTOM = 'custom'  # Manual window specification
+
+
+@dataclass
+class LayoutConfig:
+    """Layout configuration."""
+
+    mode: LayoutMode
+    rows: int | None = None
+    cols: int | None = None
+    prefer_horizontal: bool = False  # Favor vertical alginment if True

service_dev_env/model/project.py

@@ -0,0 +1,23 @@
+"""Project definition."""
+from dataclasses import dataclass, field
+
+from .terminal import TerminalConfig
+from .env import EnvConfig
+
+
+@dataclass
+class ProjectConfig:
+    name: str = 'new project'
+    default_env: str = 'dev'
+    deploy_env: str = 'deploy'
+    env: dict[str, EnvConfig] = field(default_factory=dict)
+    terminal: TerminalConfig = field(default_factory=TerminalConfig)
+
+    def __post_init__(self):
+        _envs = {}
+        for env_name, env_data in self.env.items():
+            if isinstance(env_data, EnvConfig):
+                _envs[env_name] = env_data
+            else:
+                _envs[env_name] = EnvConfig(**env_data)
+        self.env = _envs

service_dev_env/model/publish.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class PublishConfig:
+    """Configuration for Server deployment."""
+
+    # rebuild before publishing
+    build: bool = True
+    # script to run after publishing is done
+    publish_script: str = ''

service_dev_env/model/service.py

@@ -0,0 +1,23 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class ServiceConfig:
+    # unique name, has to match docker service name in compose file
+    name: str
+    # (optional) description of the service
+    description: str | None = None
+    rebuild: bool = True  # set to false if you have just a base image
+    # do not start the service when calling service-dev-env
+    autostart: bool = True
+    folder: str | None = None
+    open_url: str | None = None
+
+    # allow terminal windows for log/bash
+    terminal_log: bool = True
+    terminal_bash: bool = True
+
+    @property
+    def title(self):
+        """Return the title we show to the user."""
+        return self.description if self.description else self.name

service_dev_env/model/terminal.py

@@ -0,0 +1,12 @@
+"""Terminal configuration models."""
+from dataclasses import dataclass, field
+from .layout import LayoutMode, LayoutConfig
+
+
+@dataclass
+class TerminalConfig:
+    """Base terminal configuration."""
+
+    terminal_type: str = 'tilix'
+    layout_config: LayoutConfig = field(
+        default_factory=lambda: LayoutConfig(mode=LayoutMode.AUTO))

service_dev_env/model/window.py

@@ -0,0 +1,17 @@
+"""Window specification models."""
+from dataclasses import dataclass, field
+from .service import ServiceConfig
+
+
+@dataclass
+class WindowConfig:
+    """Specification for a single terminal window."""
+
+    service_name: str
+    width_fraction: float = 1.0
+    height_fraction: float = 1.0
+    x_position: int = 0
+    y_position: int = 0
+    profile: str | None = None
+    extra_config: dict = field(default_factory=dict)
+    service: ServiceConfig | None = None