refactor: Refactor into python

.dockerignore

@@ -5,6 +5,35 @@
 .vscode/
 tests/
 
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+.venv/
+venv/
+ENV/
+env/
+.coverage
+.pytest_cache/
+htmlcov/
+
 # Ignore common archive and executable files
 *.exe
 *.zip
@@ -20,7 +49,20 @@ tests/
 README.md
 LICENSE
 renovate.json
+pyproject.toml
 
 # Docker-specific files
 Dockerfile
 docker-compose.yml
+.dockerignore
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+autoheal_logs.txt
+
+# Environment
+.env

.github/workflows/docker-publish-dev.yml

@@ -0,0 +1,19 @@
+name: Docker Publish Dev
+
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - dev
+
+permissions:
+  packages: write
+
+jobs:
+  call-reusable-workflow:
+    uses: JourneyDocker/github-workflows/.github/workflows/docker-publish.yml@main
+    with:
+      tag: dev
+      platforms: linux/amd64
+      registry: github
+    secrets: inherit

.gitignore

@@ -3,3 +3,51 @@
 # IDE
 .idea
 *.iml
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+env/
+
+# Testing
+.coverage
+.pytest_cache/
+htmlcov/
+
+# Docker
+.dockerignore
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+autoheal_logs.txt
+
+# Environment
+.env

Dockerfile

@@ -1,7 +1,16 @@
-FROM alpine:3.22.2
+FROM python:3.14.1-alpine
 
 # Install required packages
-RUN apk add --no-cache curl jq tzdata
+RUN apk add --no-cache curl tzdata procps
+
+# Set working directory
+WORKDIR /app
+
+# Copy source code
+COPY autoheal/ /app/autoheal/
+
+# Install Python dependencies
+RUN pip install --no-cache-dir requests docker
 
 # Environment variables
 ENV AUTOHEAL_CONTAINER_LABEL=autoheal \
@@ -13,16 +22,13 @@ ENV AUTOHEAL_CONTAINER_LABEL=autoheal \
     DOCKER_SOCK=/var/run/docker.sock \
     CURL_TIMEOUT=30 \
     WEBHOOK_URL="" \
-    WEBHOOK_JSON_KEY="text" \
+    WEBHOOK_JSON_ENTRY="text" \
     APPRISE_URL="" \
     POST_RESTART_SCRIPT=""
 
-# Copy entrypoint script
-COPY docker-entrypoint /
-
 # Health check to ensure the process is running
-HEALTHCHECK --interval=5s CMD pgrep -f autoheal || exit 1
+HEALTHCHECK --interval=5s CMD pgrep -f python || exit 1
 
 # Set entrypoint and default command
-ENTRYPOINT ["/docker-entrypoint"]
+ENTRYPOINT ["python", "-m", "autoheal"]
 CMD ["autoheal"]

autoheal/__init__.py

@@ -0,0 +1,3 @@
+"""Docker Autoheal - Monitor and automatically restart unhealthy Docker containers."""
+
+__version__ = "2.0.0"

autoheal/__main__.py

@@ -0,0 +1,55 @@
+"""Main entry point for Docker Autoheal."""
+
+import signal
+import sys
+import time
+import os
+import threading
+from .config import Config
+from .health_monitor import monitor_containers
+from .logging_utils import setup_logging
+def main():
+    """Main function."""
+    config = Config()
+    logger = setup_logging(config.log_level)
+
+    def signal_handler(signum, frame, shutdown_event):
+        """Handle SIGTERM and SIGINT."""
+        logger.info(f"Received signal {signum}, shutting down gracefully")
+        shutdown_event.set()
+
+    logger.info(f"Docker Autoheal v{__import__('autoheal').__version__} starting up")
+    logger.info("Configuration:")
+    for key, value in config.__dict__.items():
+        if key.lower() == 'webhook_url':
+            # Mask sensitive URLs
+            str_value = str(value)
+            if str_value:
+                masked_value = str_value[:20] + '...' if len(str_value) > 20 else '***'
+            else:
+                masked_value = str_value
+        else:
+            masked_value = str(value)
+        logger.info(f"  {key.upper()}={masked_value}")
+
+    if config.unix_sock and not os.path.exists(config.docker_sock):
+        logger.error("Unix socket is currently not available")
+        sys.exit(1)
+
+    shutdown_event = threading.Event()
+    signal.signal(signal.SIGTERM, lambda signum, frame: signal_handler(signum, frame, shutdown_event))
+    signal.signal(signal.SIGINT, lambda signum, frame: signal_handler(signum, frame, shutdown_event))
+
+    if config.autoheal_start_period > 0:
+        logger.info(f"Waiting {config.autoheal_start_period} second(s) before starting monitoring")
+        time.sleep(config.autoheal_start_period)
+
+    monitor_containers(config, shutdown_event)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1 and sys.argv[1] == "autoheal":
+        main()
+    else:
+        # Exec other commands
+        os.execvp(sys.argv[1], sys.argv[1:])

autoheal/config.py

@@ -0,0 +1,56 @@
+"""Configuration management for Docker Autoheal."""
+
+import os
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Config:
+    """Configuration class for environment variables."""
+
+    docker_sock: str = field(default_factory=lambda: os.getenv("DOCKER_SOCK", "/var/run/docker.sock"))
+    curl_timeout: int = field(default_factory=lambda: int(os.getenv("CURL_TIMEOUT", "30")))
+    webhook_url: str = field(default_factory=lambda: os.getenv("WEBHOOK_URL", ""))
+    webhook_json_entry: str = field(default_factory=lambda: os.getenv("WEBHOOK_JSON_ENTRY", "text"))
+    apprise_url: str = field(default_factory=lambda: os.getenv("APPRISE_URL", ""))
+    post_restart_script: str = field(default_factory=lambda: os.getenv("POST_RESTART_SCRIPT", ""))
+    autoheal_container_label: str = field(default_factory=lambda: os.getenv("AUTOHEAL_CONTAINER_LABEL", "autoheal"))
+    autoheal_start_period: int = field(default_factory=lambda: int(os.getenv("AUTOHEAL_START_PERIOD", "0")))
+    autoheal_interval: int = field(default_factory=lambda: int(os.getenv("AUTOHEAL_INTERVAL", "5")))
+    autoheal_default_stop_timeout: int = field(default_factory=lambda: int(os.getenv("AUTOHEAL_DEFAULT_STOP_TIMEOUT", "10")))
+    autoheal_only_monitor_running: bool = field(default_factory=lambda: os.getenv("AUTOHEAL_ONLY_MONITOR_RUNNING", "false").lower() == "true")
+    autoheal_restart_threshold: int = field(default_factory=lambda: int(os.getenv("AUTOHEAL_RESTART_THRESHOLD", "5")))
+    autoheal_restart_window: int = field(default_factory=lambda: int(os.getenv("AUTOHEAL_RESTART_WINDOW", "600")))
+    log_level: int = field(default_factory=lambda: int(os.getenv("LOG_LEVEL", "1")))  # 1=INFO, 2=DEBUG
+
+    @property
+    def http_endpoint(self) -> str:
+        """Determine the HTTP endpoint based on DOCKER_SOCK."""
+        if self.docker_sock.startswith("tcp://"):
+            return self.docker_sock.replace("tcp://", "http://", 1)
+        elif self.docker_sock.startswith("tcps://"):
+            return self.docker_sock.replace("tcps://", "https://", 1)
+        else:
+            return "http://localhost"
+
+    @property
+    def unix_sock(self) -> str:
+        """Return unix socket path if applicable."""
+        if not self.docker_sock.startswith(("tcp://", "tcps://")):
+            return self.docker_sock
+        return ""
+
+    @property
+    def ca_cert(self) -> str:
+        """CA cert path for TLS."""
+        return "/certs/ca.pem" if self.docker_sock.startswith("tcps://") else ""
+
+    @property
+    def client_key(self) -> str:
+        """Client key path for TLS."""
+        return "/certs/client-key.pem" if self.docker_sock.startswith("tcps://") else ""
+
+    @property
+    def client_cert(self) -> str:
+        """Client cert path for TLS."""
+        return "/certs/client-cert.pem" if self.docker_sock.startswith("tcps://") else ""

autoheal/docker_api.py

@@ -0,0 +1,76 @@
+"""Docker API interaction functions."""
+
+import docker
+from .config import Config
+from .logging_utils import get_logger
+
+logger = get_logger()
+
+
+def get_docker_client(config: Config) -> docker.DockerClient:
+    """Get Docker client."""
+    kwargs = {}
+    if config.unix_sock:
+        kwargs["base_url"] = f"unix://{config.unix_sock}"
+    elif config.docker_sock.startswith("tcp://"):
+        kwargs["base_url"] = config.docker_sock
+    elif config.docker_sock.startswith("tcps://"):
+        tls_config = docker.tls.TLSConfig(
+            ca_cert=config.ca_cert,
+            client_cert=(config.client_cert, config.client_key),
+            verify=True
+        )
+        kwargs["base_url"] = config.docker_sock
+        kwargs["tls"] = tls_config
+    else:
+        pass  # default
+    try:
+        return docker.DockerClient(**kwargs)
+    except Exception as e:
+        logger.error(f"Failed to create Docker client: {e}")
+        raise
+
+
+def get_container_info(config: Config) -> list:
+    """Get list of unhealthy containers."""
+    try:
+        client = get_docker_client(config)
+        filters = {"health": ["unhealthy"]}
+        if config.autoheal_container_label != "all":
+            filters["label"] = [f"{config.autoheal_container_label}=true"]
+        if config.autoheal_only_monitor_running:
+            filters["status"] = ["running"]
+        return client.containers.list(filters=filters)
+    except Exception as e:
+        logger.error(f"Failed to get container info: {e}")
+        return []
+
+
+def restart_container(container_id: str, timeout: int, config: Config) -> bool:
+    """Restart a container."""
+    try:
+        client = get_docker_client(config)
+        container = client.containers.get(container_id)
+        container.restart(timeout=timeout)
+        return True
+    except docker.errors.APIError as e:
+        logger.error(f"Failed to restart container {container_id}: {e}")
+        return False
+    except Exception as e:
+        logger.error(f"Unexpected error restarting container {container_id}: {e}")
+        return False
+
+
+def stop_container(container_id: str, timeout: int, config: Config) -> bool:
+    """Stop a container."""
+    try:
+        client = get_docker_client(config)
+        container = client.containers.get(container_id)
+        container.stop(timeout=timeout)
+        return True
+    except docker.errors.APIError as e:
+        logger.error(f"Failed to stop container {container_id}: {e}")
+        return False
+    except Exception as e:
+        logger.error(f"Unexpected error stopping container {container_id}: {e}")
+        return False