release: v0.9.6 [skip ci]

.taskid

@@ -1 +1 @@
-DEVX-24
+DEVX-27

CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.9.6] - 2026-06-24
+
+### Bug Fixes
+
+- Add Docker socket diagnostics to start_docker
+- Add Docker socket diagnostics to start_docker
+
+## [0.9.5] - 2026-06-24
+
+### Bug Fixes
+
+- Use host Docker socket with DOCKER_HOST fallback to local dockerd
+- Use host Docker socket with DOCKER_HOST fallback to local dockerd
+
 ## [0.9.4] - 2026-06-24
 
 ### Bug Fixes

src/devx/__init__.py

@@ -1,3 +1,3 @@
 """devx — reusable development and CI/CD tools for oblachno-oss projects."""
 
-__version__ = "0.9.4"
+__version__ = "0.9.6"

src/devx/molecule/start_docker.py

@@ -1,11 +1,13 @@
 #!/usr/bin/env python3
-"""Start a Docker daemon inside a CI runner container (Docker-in-Docker).
+"""Ensure Docker is available for molecule tests in CI.
 
 CI runners (e.g. ``gitea/runner-images:ubuntu-latest``) may have the host's
-Docker socket mounted, but molecule needs a local Docker daemon to create
-nested containers. This module starts ``dockerd`` on a separate socket
-and sets ``DOCKER_HOST`` so both the CLI and Python library connect to
-the local daemon.
+Docker socket mounted. This module verifies Docker is accessible and
+sets ``DOCKER_HOST`` explicitly so molecule's Python docker library
+connects to the same socket as the Docker CLI.
+
+If the host socket is not available, it starts a local ``dockerd``
+with the vfs storage driver (requires privileged container).
 
 Usage::
 
@@ -25,11 +27,11 @@ import click
 from devx.i18n import _
 
 DEFAULT_TIMEOUT = 30
-DOCKER_SOCK = "/tmp/dockerd.sock"  # nosec B108
+DOCKER_SOCK = "/var/run/docker.sock"
 
 
 def is_docker_ready() -> bool:
-    """Check if the local Docker daemon is responding."""
+    """Check if Docker daemon is responding on the configured socket."""
     result = subprocess.run(  # nosec B603 B607
         ["docker", "info"],
         capture_output=True,
@@ -39,24 +41,84 @@ def is_docker_ready() -> bool:
     return result.returncode == 0
 
 
-def start_docker_daemon(timeout: int = DEFAULT_TIMEOUT) -> bool:
-    """Start dockerd on a separate socket and wait for it to be ready.
+def _diagnose_socket() -> None:
+    """Print diagnostic info about the Docker socket."""
+    click.echo(f"DOCKER_HOST = {os.environ.get('DOCKER_HOST', '(not set)')}")
+    click.echo(f"Socket path: {DOCKER_SOCK}")
+    click.echo(f"Socket exists: {os.path.exists(DOCKER_SOCK)}")
+    if os.path.exists(DOCKER_SOCK):
+        stat = os.stat(DOCKER_SOCK)
+        click.echo(f"Socket mode: {oct(stat.st_mode)}")
+        click.echo(f"Socket uid: {stat.st_uid}, gid: {stat.st_gid}")
+    # Check if it's a mount point
+    result = subprocess.run(  # nosec B603 B607
+        ["mount"],
+        capture_output=True,
+        check=False,
+        text=True,
+    )
+    docker_mounts = [line for line in result.stdout.splitlines() if "docker" in line.lower()]
+    if docker_mounts:
+        click.echo("Docker-related mounts:")
+        for line in docker_mounts:
+            click.echo(f"  {line}")
+    else:
+        click.echo("No Docker-related mounts found")
+    # Check docker context
+    result = subprocess.run(  # nosec B603 B607
+        ["docker", "context", "ls"],
+        capture_output=True,
+        check=False,
+        text=True,
+    )
+    click.echo(f"Docker contexts:\n{result.stdout}")
+    # Try docker info without DOCKER_HOST
+    result = subprocess.run(  # nosec B603 B607
+        ["docker", "info"],
+        capture_output=True,
+        check=False,
+        text=True,
+    )
+    click.echo(f"docker info (no DOCKER_HOST): rc={result.returncode}")
+    if result.returncode != 0:
+        click.echo(f"  stderr: {result.stderr[:500]}")
+    else:
+        # Print server version and storage driver
+        for line in result.stdout.splitlines():
+            if "Server Version" in line or "Storage Driver" in line or "Docker Root Dir" in line:
+                click.echo(f"  {line.strip()}")
 
-    Uses ``/tmp/dockerd.sock`` instead of the default ``/var/run/docker.sock``
-    to avoid conflicts with host-mounted sockets. Sets ``DOCKER_HOST`` in the
-    current environment so molecule's Python docker library connects to the
-    local daemon.
+
+def start_docker_daemon(timeout: int = DEFAULT_TIMEOUT) -> bool:
+    """Ensure Docker is ready for molecule tests.
+
+    First tries the host socket. If that works, sets ``DOCKER_HOST`` and
+    returns immediately. If not, starts a local ``dockerd`` with vfs
+    storage driver (requires privileged container).
 
     Returns ``True`` if Docker is ready, ``False`` if it failed to
     start within the timeout.
     """
-    # Point Docker CLI and Python library to our local socket
+    # Point Docker CLI and Python library to the socket explicitly
     os.environ["DOCKER_HOST"] = f"unix://{DOCKER_SOCK}"
 
-    click.echo(_("Starting Docker daemon..."))
+    # Diagnose socket state
+    click.echo("--- Docker socket diagnostics ---")
+    _diagnose_socket()
+    click.echo("--- End diagnostics ---")
+
+    # Check if host Docker is already available
+    if is_docker_ready():
+        click.echo(_("Docker daemon already running"))
+        return True
+
+    click.echo(_("Host Docker not available, starting local dockerd..."))
+
+    # Start local dockerd (requires privileged container)
     log_file = tempfile.NamedTemporaryFile(  # noqa: SIM115
         mode="w", suffix="dockerd.log", delete=False
     )
+    click.echo(f"dockerd log: {log_file.name}")
     subprocess.Popen(  # nosec B603 B607
         [
             "dockerd",
@@ -76,7 +138,17 @@ def start_docker_daemon(timeout: int = DEFAULT_TIMEOUT) -> bool:
             return True
         time.sleep(1)
 
+    # Print dockerd log on failure
     click.echo(_("Docker daemon failed to start"))
+    click.echo("--- dockerd log ---")
+    try:
+        with open(log_file.name) as f:
+            log_content = f.read()
+        click.echo(log_content[-3000:] if len(log_content) > 3000 else log_content)
+    except OSError as e:
+        click.echo(f"Could not read log: {e}")
+    click.echo("--- End dockerd log ---")
+
     return False
 
 

src/devx/translations.json

@@ -419,6 +419,13 @@
     "ru": "Created release commit.",
     "zh": "Created release commit."
   },
+  "Docker daemon already running": {
+    "bg": "Докер демонът вече работи",
+    "de": "Docker-Daemon läuft bereits",
+    "en": "Docker daemon already running",
+    "ru": "Демон Docker уже работает",
+    "zh": "Docker 守护进程已在运行"
+  },
   "Docker daemon failed to start": {
     "bg": "Docker daemon failed to start",
     "de": "Docker-Daemon konnte nicht gestartet werden",
@@ -552,6 +559,13 @@
     "ru": "Head branch is behind master. Pulling and rebasing...",
     "zh": "Head branch is behind master. Pulling and rebasing..."
   },
+  "Host Docker not available, starting local dockerd...": {
+    "bg": "Хост Docker не е наличен, стартиране на локален dockerd...",
+    "de": "Host-Docker nicht verfügbar, lokaler dockerd wird gestartet...",
+    "en": "Host Docker not available, starting local dockerd...",
+    "ru": "Хост Docker недоступен, запускается локальный dockerd...",
+    "zh": "主机 Docker 不可用，正在启动本地 dockerd..."
+  },
   "Infrastructure commit (no DEVX-N task ID), skipping Vikunja update: {msg}": {
     "bg": "Инфраструктурен commit (без идентификатор на задача DEVX-N), пропускаме обновяването на Vikunja: {msg}",
     "de": "Infrastruktur-Commit (keine DEVX-N Task-ID), Vikunja-Update wird übersprungen: {msg}",
@@ -930,13 +944,6 @@
     "ru": "Skipping commit push — no staged changes.",
     "zh": "Skipping commit push — no staged changes."
   },
-  "Starting Docker daemon...": {
-    "bg": "Starting Docker daemon...",
-    "de": "Docker-Daemon wird gestartet...",
-    "en": "Starting Docker daemon...",
-    "ru": "Запуск Docker-демона...",
-    "zh": "正在启动 Docker 守护进程..."
-  },
   "Syncing {count} documentation pages to wiki...": {
     "bg": "Syncing {count} documentation pages to wiki...",
     "de": "Syncing {count} documentation pages to wiki...",

tests/unit/test_start_docker.py

@@ -1,10 +1,16 @@
 """Unit tests for devx.molecule.start_docker."""
 
-from unittest.mock import MagicMock, patch
+from unittest.mock import MagicMock, mock_open, patch
 
 from click.testing import CliRunner
 
-from devx.molecule.start_docker import DOCKER_SOCK, is_docker_ready, main, start_docker_daemon
+from devx.molecule.start_docker import (
+    DOCKER_SOCK,
+    _diagnose_socket,
+    is_docker_ready,
+    main,
+    start_docker_daemon,
+)
 
 
 class TestIsDockerReady:
@@ -22,20 +28,60 @@ class TestIsDockerReady:
         assert is_docker_ready() is False
 
 
+class TestDiagnoseSocket:
+    @patch("devx.molecule.start_docker.os.stat")
+    @patch("devx.molecule.start_docker.os.path.exists", return_value=True)
+    @patch("devx.molecule.start_docker.subprocess.run")
+    def test_socket_exists(self, mock_run: MagicMock, mock_exists: MagicMock, mock_stat: MagicMock) -> None:
+        mock_stat.return_value = MagicMock(st_mode=0o660, st_uid=0, st_gid=0)
+        mock_run.side_effect = [
+            MagicMock(stdout="/dev/sda1 /var/lib/docker ext4\n", returncode=0, text=""),
+            MagicMock(stdout="default\n", returncode=0, text=""),
+            MagicMock(
+                stdout="Server Version: 29.5.2\nStorage Driver: overlay2\nDocker Root Dir: /var/lib/docker\n",
+                returncode=0,
+                text="",
+            ),
+        ]
+        _diagnose_socket()
+        mock_exists.assert_called_with(DOCKER_SOCK)
+
+    @patch("devx.molecule.start_docker.os.path.exists", return_value=False)
+    @patch("devx.molecule.start_docker.subprocess.run")
+    def test_socket_missing(self, mock_run: MagicMock, mock_exists: MagicMock) -> None:
+        mock_run.side_effect = [
+            MagicMock(stdout="proc on /proc type proc\n", returncode=0, text=""),
+            MagicMock(stdout="default\n", returncode=0, text=""),
+            MagicMock(stdout="", stderr="Cannot connect", returncode=1, text=""),
+        ]
+        _diagnose_socket()
+        mock_exists.assert_called_with(DOCKER_SOCK)
+
+
 class TestStartDockerDaemon:
+    @patch("devx.molecule.start_docker._diagnose_socket")
+    @patch("devx.molecule.start_docker.is_docker_ready", return_value=True)
+    def test_host_socket_available(self, mock_ready: MagicMock, mock_diag: MagicMock) -> None:
+        """Should return immediately if host Docker is available."""
+        assert start_docker_daemon(timeout=5) is True
+        mock_ready.assert_called_once()
+        mock_diag.assert_called_once()
+
+    @patch("devx.molecule.start_docker._diagnose_socket")
     @patch("devx.molecule.start_docker.time.sleep")
     @patch("devx.molecule.start_docker.is_docker_ready")
     @patch("devx.molecule.start_docker.subprocess.Popen")
     @patch("devx.molecule.start_docker.tempfile.NamedTemporaryFile")
-    def test_starts_successfully(
+    def test_starts_local_daemon(
         self,
         mock_ntf: MagicMock,
         mock_popen: MagicMock,
         mock_ready: MagicMock,
         mock_sleep: MagicMock,
+        mock_diag: MagicMock,
     ) -> None:
-        mock_ntf.return_value = MagicMock()
-        mock_ready.side_effect = [False, True]
+        mock_ntf.return_value = MagicMock(name="/tmp/dockerd.log")
+        mock_ready.side_effect = [False, False, False, True]
         assert start_docker_daemon(timeout=5) is True
         mock_popen.assert_called_once()
         popen_args = mock_popen.call_args.args[0]
@@ -44,8 +90,9 @@ class TestStartDockerDaemon:
         assert "vfs" in popen_args
         assert "-H" in popen_args
         assert f"unix://{DOCKER_SOCK}" in popen_args
-        mock_sleep.assert_called_once_with(1)
+        assert mock_sleep.call_count == 2
 
+    @patch("devx.molecule.start_docker._diagnose_socket")
     @patch("devx.molecule.start_docker.time.sleep")
     @patch("devx.molecule.start_docker.is_docker_ready", return_value=False)
     @patch("devx.molecule.start_docker.subprocess.Popen")
@@ -56,61 +103,61 @@ class TestStartDockerDaemon:
         mock_popen: MagicMock,
         mock_ready: MagicMock,
         mock_sleep: MagicMock,
+        mock_diag: MagicMock,
     ) -> None:
-        mock_ntf.return_value = MagicMock()
-        assert start_docker_daemon(timeout=3) is False
+        mock_ntf.return_value = MagicMock(name="/tmp/dockerd.log")
+        with patch("builtins.open", mock_open(read_data="dockerd error log")):
+            assert start_docker_daemon(timeout=3) is False
         mock_popen.assert_called_once()
         assert mock_sleep.call_count == 3
 
+    @patch("devx.molecule.start_docker._diagnose_socket")
     @patch("devx.molecule.start_docker.time.sleep")
-    @patch("devx.molecule.start_docker.is_docker_ready")
+    @patch("devx.molecule.start_docker.is_docker_ready", return_value=False)
     @patch("devx.molecule.start_docker.subprocess.Popen")
     @patch("devx.molecule.start_docker.tempfile.NamedTemporaryFile")
-    def test_ready_on_first_check(
+    def test_fails_log_read_error(
         self,
         mock_ntf: MagicMock,
         mock_popen: MagicMock,
         mock_ready: MagicMock,
         mock_sleep: MagicMock,
+        mock_diag: MagicMock,
     ) -> None:
-        mock_ntf.return_value = MagicMock()
-        mock_ready.return_value = True
+        """Should handle log read errors gracefully."""
+        mock_ntf.return_value = MagicMock(name="/tmp/dockerd.log")
+        with patch("builtins.open", side_effect=OSError("permission denied")):
+            assert start_docker_daemon(timeout=2) is False
+
+    @patch("devx.molecule.start_docker._diagnose_socket")
+    @patch("devx.molecule.start_docker.time.sleep")
+    @patch("devx.molecule.start_docker.is_docker_ready")
+    @patch("devx.molecule.start_docker.subprocess.Popen")
+    @patch("devx.molecule.start_docker.tempfile.NamedTemporaryFile")
+    def test_local_daemon_ready_on_first_check(
+        self,
+        mock_ntf: MagicMock,
+        mock_popen: MagicMock,
+        mock_ready: MagicMock,
+        mock_sleep: MagicMock,
+        mock_diag: MagicMock,
+    ) -> None:
+        mock_ntf.return_value = MagicMock(name="/tmp/dockerd.log")
+        mock_ready.side_effect = [False, False, True]
         assert start_docker_daemon(timeout=5) is True
         mock_popen.assert_called_once()
-        mock_sleep.assert_not_called()
-
-    @patch("devx.molecule.start_docker.time.sleep")
-    @patch("devx.molecule.start_docker.is_docker_ready")
-    @patch("devx.molecule.start_docker.subprocess.Popen")
-    @patch("devx.molecule.start_docker.tempfile.NamedTemporaryFile")
-    def test_custom_timeout(
-        self,
-        mock_ntf: MagicMock,
-        mock_popen: MagicMock,
-        mock_ready: MagicMock,
-        mock_sleep: MagicMock,
-    ) -> None:
-        mock_ntf.return_value = MagicMock()
-        mock_ready.side_effect = [False] * 9 + [True]
-        assert start_docker_daemon(timeout=10) is True
-        assert mock_sleep.call_count == 9
+        mock_sleep.assert_called_once_with(1)
 
+    @patch("devx.molecule.start_docker._diagnose_socket")
     @patch("devx.molecule.start_docker.os.environ")
-    @patch("devx.molecule.start_docker.time.sleep")
-    @patch("devx.molecule.start_docker.is_docker_ready")
-    @patch("devx.molecule.start_docker.subprocess.Popen")
-    @patch("devx.molecule.start_docker.tempfile.NamedTemporaryFile")
+    @patch("devx.molecule.start_docker.is_docker_ready", return_value=True)
     def test_sets_docker_host(
         self,
-        mock_ntf: MagicMock,
-        mock_popen: MagicMock,
         mock_ready: MagicMock,
-        mock_sleep: MagicMock,
         mock_environ: MagicMock,
+        mock_diag: MagicMock,
     ) -> None:
-        """DOCKER_HOST must be set so molecule connects to local daemon."""
-        mock_ntf.return_value = MagicMock()
-        mock_ready.return_value = True
+        """DOCKER_HOST must be set so molecule connects to correct socket."""
         start_docker_daemon(timeout=5)
         mock_environ.__setitem__.assert_called_with("DOCKER_HOST", f"unix://{DOCKER_SOCK}")