github2gerrit 0.1.11__tar.gz → 0.1.13__tar.gz

{github2gerrit-0.1.11 → github2gerrit-0.1.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: github2gerrit
-Version: 0.1.11
+Version: 0.1.13
 Summary: Submit a GitHub pull request to a Gerrit repository.
 Project-URL: Homepage, https://github.com/lfreleng-actions/github2gerrit
 Project-URL: Repository, https://github.com/lfreleng-actions/github2gerrit

{github2gerrit-0.1.11 → github2gerrit-0.1.13}/action.yaml

@@ -132,7 +132,7 @@ runs:
       # yamllint disable-line rule:line-length
       uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065  # v5.6.0
       with:
-        python-version-file: 'pyproject.toml'
+        python-version-file: '${{ github.action_path }}/pyproject.toml'
 
     - name: Setup uv
       # yamllint disable-line rule:line-length
@@ -186,8 +186,14 @@ runs:
       run: |
         set -euo pipefail
         uv --version
-        # Install the package into the system environment using the lockfile
-        uv pip install --system .
+        # Install from PyPI when called from external repos, local source for self-testing
+        if [[ "${{ github.repository }}" == "modeseven-lfreleng-actions/github2gerrit-action" ]]; then
+          echo "Installing from local source (self-testing)"
+          uv pip install --system ${{ github.action_path }}
+        else
+          echo "Installing from PyPI (external repository)"
+          uv pip install --system github2gerrit
+        fi
 
     - name: Validate PR_NUMBER usage (non-dispatch)
       # yamllint disable-line rule:line-length

{github2gerrit-0.1.11 → github2gerrit-0.1.13}/src/github2gerrit/cli.py

@@ -525,7 +525,7 @@ def main(
     if _is_github_actions_context():
         try:
             app_version = get_version("github2gerrit")
-            log.info("github2gerrit version %s", app_version)
+            log.debug("github2gerrit version %s", app_version)
         except Exception:
             log.warning("Version information not available")
 

{github2gerrit-0.1.11 → github2gerrit-0.1.13}/src/github2gerrit/core.py

@@ -1115,6 +1115,41 @@ class Orchestrator:
             log.debug("SSH private key not provided, skipping SSH setup")
             return
 
+        # Check for ssh-keyscan availability early if auto-discovery needed
+        if (
+            auto_discover_gerrit_host_keys is not None
+            and not inputs.gerrit_known_hosts
+        ):
+            import shutil
+
+            keyscan_path = shutil.which("ssh-keyscan")
+            if not keyscan_path:
+                log.error(
+                    "❌ ssh-keyscan not found in PATH but is required for SSH "
+                    "host key auto-discovery"
+                )
+                log.error(
+                    "Available tools in PATH: %s",
+                    ", ".join(
+                        [
+                            tool
+                            for tool in [
+                                "ssh",
+                                "ssh-keygen",
+                                "ssh-add",
+                                "ssh-agent",
+                                "ssh-keyscan",
+                            ]
+                            if shutil.which(tool)
+                        ]
+                    ),
+                )
+                log.error("To fix this issue:")
+                log.error("1. Install openssh-client package, OR")
+                log.error("2. Provide GERRIT_KNOWN_HOSTS manually")
+            else:
+                log.debug("✅ ssh-keyscan found at: %s", keyscan_path)
+
         # Auto-discover or augment host keys (merge missing
         # types/[host]:port entries)
         effective_known_hosts = inputs.gerrit_known_hosts
@@ -1122,9 +1157,18 @@ class Orchestrator:
             try:
                 if not effective_known_hosts:
                     log.info(
-                        "GERRIT_KNOWN_HOSTS not provided, attempting "
-                        "auto-discovery..."
+                        "🔍 GERRIT_KNOWN_HOSTS not provided, attempting "
+                        "auto-discovery for %s:%d...",
+                        gerrit.host,
+                        gerrit.port,
                     )
+                    log.debug(
+                        "Auto-discovery params: host=%s, port=%d, org=%s",
+                        gerrit.host,
+                        gerrit.port,
+                        inputs.organization,
+                    )
+
                     discovered_keys = auto_discover_gerrit_host_keys(
                         gerrit_hostname=gerrit.host,
                         gerrit_port=gerrit.port,
@@ -1134,15 +1178,18 @@ class Orchestrator:
                     if discovered_keys:
                         effective_known_hosts = discovered_keys
                         log.info(
-                            "Successfully auto-discovered SSH host keys for "
+                            "✅ Successfully auto-discovered SSH host keys for "
                             "%s:%d",
                             gerrit.host,
                             gerrit.port,
                         )
                     else:
-                        log.warning(
-                            "Auto-discovery failed, SSH host key verification "
-                            "may fail"
+                        log.error(
+                            "❌ Auto-discovery failed for %s:%d - SSH host key "
+                            "verification will likely fail. Check network "
+                            "connectivity and ssh-keyscan availability.",
+                            gerrit.host,
+                            gerrit.port,
                         )
                 else:
                     # Provided known_hosts exists; ensure it contains
@@ -1191,15 +1238,22 @@ class Orchestrator:
                                 "Auto-discovery returned no keys; known_hosts "
                                 "not augmented"
                             )
-            except Exception as exc:
-                log.warning(
-                    "SSH host key auto-discovery/augmentation failed: %s", exc
+            except Exception:
+                log.exception(
+                    "❌ SSH host key auto-discovery/augmentation failed "
+                    "for %s:%d",
+                    gerrit.host,
+                    gerrit.port,
                 )
 
         if not effective_known_hosts:
-            log.debug(
-                "No SSH host keys available (manual or auto-discovered), "
-                "skipping SSH setup"
+            log.warning(
+                "⚠️  No SSH host keys available (manual or auto-discovered) "
+                "for %s:%d. SSH connections may fail due to host key "
+                "verification. Consider setting GERRIT_KNOWN_HOSTS or ensure "
+                "ssh-keyscan is available.",
+                gerrit.host,
+                gerrit.port,
             )
             return
 

{github2gerrit-0.1.11 → github2gerrit-0.1.13}/src/github2gerrit/duplicate_detection.py

@@ -20,7 +20,6 @@ from collections.abc import Iterable
 from datetime import UTC
 from datetime import datetime
 from datetime import timedelta
-from pathlib import Path
 from typing import Any
 
 from .gerrit_urls import create_gerrit_url_builder
@@ -205,20 +204,11 @@ class DuplicateDetector:
         if gerrit_host and gerrit_project:
             return (gerrit_host, gerrit_project)
 
-        # Try to read .gitreview file locally first
-        gitreview_path = Path(".gitreview")
-        if gitreview_path.exists():
-            try:
-                text = gitreview_path.read_text(encoding="utf-8")
-                host = self._match_first_group(r"(?m)^host=(.+)$", text)
-                proj = self._match_first_group(r"(?m)^project=(.+)$", text)
-                if host and proj:
-                    project = proj.removesuffix(".git")
-                    return (host.strip(), project.strip())
-                if host and not proj:
-                    return (host.strip(), "")
-            except Exception as exc:
-                log.debug("Failed to read local .gitreview: %s", exc)
+        # Skip local .gitreview check in composite action context
+        # The duplicate detection runs before workspace setup, so there's no
+        # reliable local .gitreview file to check. Instead, rely on environment
+        # variables or remote fetching.
+        log.debug("Skipping local .gitreview check (composite action context)")
 
         # Try to fetch .gitreview remotely (simplified version of core logic)
         try:

{github2gerrit-0.1.11 → github2gerrit-0.1.13}/src/github2gerrit/ssh_discovery.py

@@ -13,6 +13,7 @@ from __future__ import annotations
 
 import logging
 import os
+import shutil
 import socket
 from pathlib import Path
 
@@ -55,6 +56,18 @@ _MSG_UNEXPECTED_ERROR = (
 _MSG_SAVE_FAILED = (
     "Failed to save host keys to configuration file {config_file}: {error}"
 )
+_MSG_KEYSCAN_NOT_FOUND = (
+    "ssh-keyscan command not found in PATH. This tool is required for SSH "
+    "host key auto-discovery."
+)
+_MSG_KEYSCAN_CHECK_FAILED = (
+    "Failed to check for ssh-keyscan availability: {error}"
+)
+
+
+def _raise_keyscan_not_found() -> None:
+    """Helper function to raise keyscan not found error."""
+    raise SSHDiscoveryError(_MSG_KEYSCAN_NOT_FOUND)
 
 
 def is_host_reachable(hostname: str, port: int, timeout: int = 5) -> bool:
@@ -84,13 +97,36 @@ def fetch_ssh_host_keys(
     Raises:
         SSHDiscoveryError: If the host keys cannot be fetched
     """
-    log.debug("Fetching SSH host keys for %s:%d", hostname, port)
+    log.info("🔍 Starting SSH host key discovery for %s:%d", hostname, port)
+
+    # Check if ssh-keyscan is available
+    try:
+        keyscan_path = shutil.which("ssh-keyscan")
+        if not keyscan_path:
+            log.error("❌ ssh-keyscan not found in PATH")
+            _raise_keyscan_not_found()
+        log.debug("✅ Found ssh-keyscan at: %s", keyscan_path)
+    except Exception as exc:
+        log.exception("❌ Failed to check for ssh-keyscan")
+        raise SSHDiscoveryError(
+            _MSG_KEYSCAN_CHECK_FAILED.format(error=exc)
+        ) from exc
+
+    log.debug(
+        "🔍 Fetching SSH host keys for %s:%d (timeout: %ds)",
+        hostname,
+        port,
+        timeout,
+    )
 
     # First check if the host is reachable
+    log.debug("🔍 Testing connectivity to %s:%d...", hostname, port)
     if not is_host_reachable(hostname, port, timeout=5):
+        log.error("❌ Host %s:%d is not reachable", hostname, port)
         raise SSHDiscoveryError(
             _MSG_HOST_UNREACHABLE.format(hostname=hostname, port=port)
         )
+    log.debug("✅ Host %s:%d is reachable", hostname, port)
 
     try:
         # Use ssh-keyscan to fetch all available key types
@@ -105,9 +141,26 @@ def fetch_ssh_host_keys(
             hostname,
         ]
 
+        log.debug("🔍 Running command: %s", " ".join(cmd))
         result = run_cmd(cmd, timeout=timeout + 5)
 
+        log.debug(
+            "ssh-keyscan stdout length: %d chars",
+            len(result.stdout) if result.stdout else 0,
+        )
+        log.debug(
+            "ssh-keyscan stderr: %s",
+            result.stderr if result.stderr else "(empty)",
+        )
+
         if not result.stdout or not result.stdout.strip():
+            log.error(
+                "❌ ssh-keyscan returned no output for %s:%d", hostname, port
+            )
+            log.error("Command: %s", " ".join(cmd))
+            log.error(
+                "Stderr: %s", result.stderr if result.stderr else "(none)"
+            )
             raise SSHDiscoveryError(  # noqa: TRY301
                 _MSG_NO_KEYS_FOUND.format(hostname=hostname, port=port)
             )
@@ -127,20 +180,34 @@ def fetch_ssh_host_keys(
                 valid_lines.append(stripped_line)
 
         if not valid_lines:
+            log.error(
+                "❌ No valid SSH host keys found in output for %s:%d",
+                hostname,
+                port,
+            )
+            log.error("Raw output was: %s", result.stdout)
             raise SSHDiscoveryError(  # noqa: TRY301
                 _MSG_NO_VALID_KEYS.format(hostname=hostname, port=port)
             )
 
         discovered_keys = "\n".join(valid_lines)
         log.info(
-            "Successfully discovered %d SSH host key(s) for %s:%d",
+            "✅ Successfully discovered %d SSH host key(s) for %s:%d",
             len(valid_lines),
             hostname,
             port,
         )
-        log.debug("Discovered keys:\n%s", discovered_keys)
+        log.info("📋 Discovered keys:\n%s", discovered_keys)
 
     except CommandError as exc:
+        log.exception("❌ ssh-keyscan command failed for %s:%d", hostname, port)
+        log.debug("Return code: %d", exc.returncode)
+        stdout_msg = exc.stdout if exc.stdout else "(empty)"
+        stderr_msg = exc.stderr if exc.stderr else "(empty)"
+        log.debug("Stdout: %s", stdout_msg)
+        log.debug("Stderr: %s", stderr_msg)
+        log.debug("Command: %s", " ".join(cmd))
+
         if exc.returncode == 1:
             # ssh-keyscan returns 1 when it can't connect
             error_msg = exc.stderr or exc.stdout or "Connection failed"
@@ -381,11 +448,60 @@ def auto_discover_gerrit_host_keys(
             )
             save_to_config = False
 
+        # Log system diagnostics for debugging
+
         log.info(
-            "Attempting to auto-discover SSH host keys for %s:%d",
+            "🔍 Attempting to auto-discover SSH host keys for %s:%d "
+            "(org: %s, save: %s)",
             gerrit_hostname,
             gerrit_port,
+            organization or "none",
+            save_to_config,
+        )
+
+        # System diagnostics
+        log.debug("🔧 System diagnostics:")
+        log.debug("  - OS: %s", os.name)
+        log.debug(
+            "  - Platform: %s",
+            os.uname() if hasattr(os, "uname") else "unknown",
+        )
+        path_env = os.getenv("PATH", "not set")
+        path_display = (
+            path_env[:200] + "..." if len(path_env) > 200 else path_env
         )
+        log.debug("  - PATH: %s", path_display)
+        ssh_tools = [
+            f"{tool}={shutil.which(tool) or 'missing'}"
+            for tool in [
+                "ssh",
+                "ssh-keygen",
+                "ssh-add",
+                "ssh-agent",
+                "ssh-keyscan",
+            ]
+        ]
+        log.debug("  - Available SSH tools: %s", ", ".join(ssh_tools))
+        dns_status = "checking..." if gerrit_hostname else "no hostname"
+        log.debug("  - Network test (DNS resolution): %s", dns_status)
+
+        # Test DNS resolution
+        if gerrit_hostname:
+            try:
+                import socket
+
+                addr_info = socket.getaddrinfo(gerrit_hostname, gerrit_port)
+                log.debug(
+                    "  - DNS resolution: ✅ %s resolves to %d addresses",
+                    gerrit_hostname,
+                    len(addr_info),
+                )
+            except Exception as dns_exc:
+                log.debug(
+                    "  - DNS resolution: ❌ %s failed: %s",
+                    gerrit_hostname,
+                    dns_exc,
+                )
 
         # Discover the host keys
         host_keys = fetch_ssh_host_keys(gerrit_hostname, gerrit_port)
@@ -404,12 +520,18 @@ def auto_discover_gerrit_host_keys(
                 "Set ORGANIZATION environment variable to enable auto-saving."
             )
 
-    except SSHDiscoveryError as exc:
-        log.warning("SSH host key auto-discovery failed: %s", exc)
+    except SSHDiscoveryError:
+        log.exception(
+            "❌ SSH host key auto-discovery failed for %s:%d",
+            gerrit_hostname,
+            gerrit_port,
+        )
         return None
-    except Exception as exc:
-        log.warning(
-            "Unexpected error during SSH host key auto-discovery: %s", exc
+    except Exception:
+        log.exception(
+            "❌ Unexpected error during SSH host key auto-discovery for %s:%d",
+            gerrit_hostname,
+            gerrit_port,
         )
         return None
     else:

{github2gerrit-0.1.11 → github2gerrit-0.1.13}/tests/test_action_step_validation.py

@@ -164,7 +164,10 @@ class TestActionStepValidation:
 
         with_config = python_step.get("with", {})
         assert "python-version-file" in with_config
-        assert with_config["python-version-file"] == "pyproject.toml"
+        assert (
+            with_config["python-version-file"]
+            == "${{ github.action_path }}/pyproject.toml"
+        )
         # No pip caching since we use uv for dependency management
         assert "cache" not in with_config
 
@@ -216,7 +219,11 @@ class TestActionStepValidation:
 
         script = install_step["run"]
         assert "uv --version" in script
-        assert "uv pip install --system ." in script
+        # Should contain both PyPI and local installation logic
+        assert "github.repository" in script
+        assert "modeseven-lfreleng-actions/github2gerrit-action" in script
+        assert "uv pip install --system ${{ github.action_path }}" in script
+        assert "uv pip install --system github2gerrit" in script
 
     def test_cli_execution_step(self, action_config):
         """Test CLI execution step configuration."""

{github2gerrit-0.1.11 → github2gerrit-0.1.13}/tests/test_duplicate_detection.py

@@ -342,25 +342,18 @@ class TestGerritDuplicateDetection:
             result = detector._resolve_gerrit_info_from_env_or_gitreview(gh)
             assert result is None
 
-    @patch("pathlib.Path.exists")
-    @patch("pathlib.Path.read_text")
-    def test_resolve_gerrit_info_from_local_gitreview(
-        self, mock_read_text: Any, mock_exists: Any
-    ) -> None:
-        """Test resolving Gerrit info from local .gitreview file."""
+    def test_resolve_gerrit_info_skips_local_gitreview(self) -> None:
+        """Test that local .gitreview reading is skipped in composite action context."""
         detector = DuplicateDetector(Mock())
         gh = self._create_mock_github_context()
 
-        mock_exists.return_value = True
-        mock_read_text.return_value = """[gerrit]
-host=gerrit.example.org
-port=29418
-project=test/project.git
-"""
-
+        # Even if a local .gitreview exists, it should be skipped
+        # and fall back to remote fetching or return None
         with patch.dict("os.environ", {}, clear=True):
             result = detector._resolve_gerrit_info_from_env_or_gitreview(gh)
-            assert result == ("gerrit.example.org", "test/project")
+            assert (
+                result is None
+            )  # Should skip local file and return None for remote fallback
 
     @patch("urllib.request.urlopen")
     @patch("pathlib.Path.exists")