multi-lang-build 0.2.8__py3-none-any.whl → 0.2.10__py3-none-any.whl

multi_lang_build/compiler/go_support/builder.py

@@ -0,0 +1,228 @@
+"""Go build utilities."""
+
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Final
+
+from loguru import logger
+
+from multi_lang_build.compiler.base import BuildResult
+
+
+class GoBuilder:
+    """Build Go binaries with various options."""
+
+    DEFAULT_TARGETS: Final[list[str]] = ["linux/amd64", "linux/arm64", "darwin/amd64", "darwin/arm64"]
+
+    @staticmethod
+    def build(
+        go_executable: str,
+        source_dir: Path,
+        output_path: Path,
+        *,
+        ldflags: str | None = None,
+        tags: list[str] | None = None,
+        environment: dict[str, str],
+        stream_output: bool = True,
+    ) -> BuildResult:
+        """Build a Go binary.
+
+        Args:
+            go_executable: Path to Go executable
+            source_dir: Source directory
+            output_path: Output path for binary
+            ldflags: Linker flags
+            tags: Build tags
+            environment: Environment variables
+            stream_output: Whether to stream output
+
+        Returns:
+            BuildResult with success status
+        """
+        build_args = [go_executable, "build", "-o", str(output_path)]
+
+        if ldflags:
+            build_args.extend(["-ldflags", ldflags])
+
+        if tags:
+            build_args.extend(["-tags", ",".join(tags)])
+
+        return GoBuilder._run_build(
+            build_args, source_dir, environment, stream_output
+        )
+
+    @staticmethod
+    def build_all(
+        go_executable: str,
+        source_dir: Path,
+        output_dir: Path,
+        *,
+        environment: dict[str, str],
+        stream_output: bool = True,
+    ) -> BuildResult:
+        """Build all packages in the module.
+
+        Args:
+            go_executable: Path to Go executable
+            source_dir: Source directory
+            output_dir: Output directory for binaries
+            environment: Environment variables
+            stream_output: Whether to stream output
+
+        Returns:
+            BuildResult with success status
+        """
+        build_args = [go_executable, "build", "-o", str(output_dir), "./..."]
+
+        return GoBuilder._run_build(
+            build_args, source_dir, environment, stream_output
+        )
+
+    @staticmethod
+    def cross_compile(
+        go_executable: str,
+        source_dir: Path,
+        output_path: Path,
+        target: str,
+        *,
+        ldflags: str | None = None,
+        environment: dict[str, str],
+        stream_output: bool = True,
+    ) -> BuildResult:
+        """Cross-compile for a specific platform.
+
+        Args:
+            go_executable: Path to Go executable
+            source_dir: Source directory
+            output_path: Output path for binary
+            target: Target platform (e.g., "linux/amd64")
+            ldflags: Linker flags
+            environment: Environment variables
+            stream_output: Whether to stream output
+
+        Returns:
+            BuildResult with success status
+        """
+        build_args = [
+            go_executable, "build",
+            "-o", str(output_path),
+            "-ldflags", f"{ldflags or ''} -s -w",
+            "-GOOS", target.split("/")[0],
+            "-GOARCH", target.split("/")[1],
+        ]
+
+        return GoBuilder._run_build(
+            build_args, source_dir, environment, stream_output
+        )
+
+    @staticmethod
+    def _run_build(
+        command: list[str],
+        source_dir: Path,
+        environment: dict[str, str],
+        stream_output: bool,
+    ) -> BuildResult:
+        """Execute build command."""
+        import time
+
+        start_time = time.perf_counter()
+
+        try:
+            if stream_output:
+                return GoBuilder._stream_build(
+                    command, source_dir, environment, start_time
+                )
+            else:
+                return GoBuilder._capture_build(
+                    command, source_dir, environment, start_time
+                )
+        except Exception as e:
+            duration = time.perf_counter() - start_time
+            return BuildResult(
+                success=False,
+                return_code=-2,
+                stdout="",
+                stderr=f"Build error: {str(e)}",
+                output_path=None,
+                duration_seconds=duration,
+            )
+
+    @staticmethod
+    def _stream_build(
+        command: list[str],
+        source_dir: Path,
+        environment: dict[str, str],
+        start_time: float,
+    ) -> BuildResult:
+        """Execute build with streaming output."""
+        import os
+        import sys
+
+        stdout_buffer = []
+        stderr_buffer = []
+
+        process = subprocess.Popen(
+            command,
+            cwd=source_dir,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            env={**os.environ, **environment},
+        )
+
+        # Read stdout
+        if process.stdout:
+            for line in process.stdout:
+                line = line.rstrip('\n\r')
+                stdout_buffer.append(line)
+                print(line)
+                sys.stdout.flush()
+
+        # Read stderr
+        if process.stderr:
+            for line in process.stderr:
+                line = line.rstrip('\n\r')
+                stderr_buffer.append(line)
+                print(line, file=sys.stderr)
+                sys.stderr.flush()
+
+        return_code = process.wait()
+        duration = time.perf_counter() - start_time
+
+        return BuildResult(
+            success=return_code == 0,
+            return_code=return_code,
+            stdout='\n'.join(stdout_buffer),
+            stderr='\n'.join(stderr_buffer),
+            output_path=source_dir if return_code == 0 else None,
+            duration_seconds=duration,
+        )
+
+    @staticmethod
+    def _capture_build(
+        command: list[str],
+        source_dir: Path,
+        environment: dict[str, str],
+        start_time: float,
+    ) -> BuildResult:
+        """Execute build with captured output."""
+        result = subprocess.run(
+            command,
+            cwd=source_dir,
+            capture_output=True,
+            text=True,
+            timeout=3600,
+            env={**os.environ, **environment},
+        )
+
+        duration = time.perf_counter() - start_time
+
+        return BuildResult(
+            success=result.returncode == 0,
+            return_code=result.returncode,
+            stdout=result.stdout,
+            stderr=result.stderr,
+            output_path=source_dir if result.returncode == 0 else None,
+            duration_seconds=duration,
+        )

multi_lang_build/compiler/go_support/cleaner.py

@@ -0,0 +1,40 @@
+"""Go build artifact cleaning utilities."""
+
+import shutil
+from pathlib import Path
+
+
+class GoCleaner:
+    """Clean Go build artifacts."""
+
+    @staticmethod
+    def clean(directory: Path) -> bool:
+        """Clean Go build artifacts in the specified directory.
+
+        Args:
+            directory: Directory to clean
+
+        Returns:
+            True if successful, False otherwise.
+        """
+        try:
+            # Remove go.sum
+            go_sum = directory / "go.sum"
+            if go_sum.exists():
+                go_sum.unlink()
+
+            # Remove vendor directory
+            vendor_dir = directory / "vendor"
+            if vendor_dir.exists() and vendor_dir.is_dir():
+                shutil.rmtree(vendor_dir)
+
+            # Remove build artifacts
+            for pattern in ["*.exe", "*.exe~", "*.test", "*.test~"]:
+                for file in directory.glob(pattern):
+                    if file.is_file():
+                        file.unlink()
+
+            return True
+
+        except Exception:
+            return False

multi_lang_build/compiler/go_support/env.py

@@ -0,0 +1,41 @@
+"""Go environment preparation utilities."""
+
+import os
+from pathlib import Path
+
+from loguru import logger
+
+
+class GoEnvironment:
+    """Prepare Go build environment with cache paths."""
+
+    @staticmethod
+    def prepare(environment: dict[str, str] | None = None) -> dict[str, str]:
+        """Prepare environment with GOMODCACHE and GOCACHE set.
+
+        Args:
+            environment: Base environment variables
+
+        Returns:
+            Environment with cache paths set
+        """
+        env = environment.copy() if environment else {}
+
+        # Set HOME if not present (needed for Path.home() and GOCACHE)
+        if "HOME" not in env:
+            home = os.environ.get("HOME") or "/root"
+            env["HOME"] = home
+
+        # Set GOMODCACHE if not present
+        if "GOMODCACHE" not in env and "GOPATH" not in env:
+            default_cache = Path(env["HOME"]) / "go" / "pkg" / "mod"
+            env["GOMODCACHE"] = str(default_cache)
+            logger.info(f"Go模块缓存: {default_cache}")
+
+        # Set GOCACHE if not present
+        if "GOCACHE" not in env:
+            cache_dir = Path(env["HOME"]) / ".cache" / "go-build"
+            env["GOCACHE"] = str(cache_dir)
+            logger.info(f"Go构建缓存: {cache_dir}")
+
+        return env

multi_lang_build/compiler/go_support/mirror.py

@@ -0,0 +1,111 @@
+"""Go mirror failover support."""
+
+from pathlib import Path
+from loguru import logger
+
+from multi_lang_build.compiler.base import BuildResult
+from multi_lang_build.mirror.config import (
+    MIRROR_CONFIGS,
+    get_go_mirror_with_fallback,
+    apply_mirror_environment,
+)
+
+
+class GoMirrorFailover:
+    """Handle Go mirror failover logic."""
+
+    def __init__(self, configured_mirror: str | None = None):
+        """Initialize mirror failover handler.
+
+        Args:
+            configured_mirror: User-configured mirror key (if any).
+                              If None, will use failover mode.
+        """
+        self.configured_mirror = configured_mirror
+
+    def get_mirror_info(self, mirror_key: str) -> tuple[str, str]:
+        """Get mirror name and URL.
+
+        Args:
+            mirror_key: Mirror configuration key
+
+        Returns:
+            Tuple of (name, url)
+        """
+        config = MIRROR_CONFIGS.get(mirror_key, {})
+        return config.get("name", mirror_key), config.get("url", "")
+
+    def apply_mirror(self, mirror_key: str, environment: dict[str, str]) -> dict[str, str]:
+        """Apply mirror environment variables.
+
+        Args:
+            mirror_key: Mirror configuration key
+            environment: Base environment variables
+
+        Returns:
+            Updated environment with mirror variables
+        """
+        config_key = self.configured_mirror or mirror_key
+        return apply_mirror_environment(config_key, environment)
+
+    def try_build_with_fallback(
+        self,
+        command: list[str],
+        source_dir: Path,
+        output_dir: Path,
+        environment: dict[str, str],
+        stream_output: bool,
+        run_build_func,
+    ) -> BuildResult:
+        """Try build command with mirror failover.
+
+        Tries mirrors in order: goproxy.io → goproxy.cn → goproxy.vip.cn
+        Only switches to next mirror on failure.
+
+        Args:
+            command: Build command to execute
+            source_dir: Source directory for the build
+            output_dir: Output directory for build artifacts
+            environment: Environment variables
+            stream_output: Whether to stream output in real-time
+            run_build_func: Function to execute the build
+
+        Returns:
+            BuildResult with success status and output information.
+        """
+        # If user configured a specific mirror, use it without failover
+        if self.configured_mirror:
+            mirror_name, _ = self.get_mirror_info(self.configured_mirror)
+            logger.info(f"🔗 使用代理: {mirror_name}")
+            env = self.apply_mirror(self.configured_mirror, environment)
+            return run_build_func(command, source_dir, output_dir, env, stream_output)
+
+        # Use failover mode
+        mirror_keys = get_go_mirror_with_fallback(failover=True)
+        last_result: BuildResult | None = None
+
+        for i, mirror_key in enumerate(mirror_keys):
+            env = environment.copy()
+            mirror_name, mirror_url = self.get_mirror_info(mirror_key)
+            logger.info(f"🔗 使用代理: {mirror_name} ({mirror_url})")
+
+            env = self.apply_mirror(mirror_key, env)
+
+            result = run_build_func(command, source_dir, output_dir, env, stream_output)
+            last_result = result
+
+            if result["success"]:
+                return result
+
+            # Failed, try next mirror
+            if i < len(mirror_keys) - 1:
+                logger.warning(f"❌ {mirror_name} 失败，切换到备用镜像...")
+            else:
+                logger.error(f"❌ 所有镜像均失败")
+
+        assert last_result is not None
+        return last_result
+
+
+# Also export fallback order constant for direct access
+GO_MIRROR_FALLBACK_ORDER = ["go_qiniu", "go", "go_vip"]

multi_lang_build/compiler/go_support/module.py

@@ -0,0 +1,77 @@
+"""Go module building utilities."""
+
+from pathlib import Path
+
+from loguru import logger
+
+from multi_lang_build.compiler.base import BuildResult
+
+
+class GoModuleBuilder:
+    """Build all packages in a Go module."""
+
+    @staticmethod
+    def build_all(
+        go_executable: str,
+        source_dir: Path,
+        output_dir: Path,
+        env: dict[str, str],
+        platform: str | None,
+        run_build,
+        stream_output: bool = True,
+    ) -> BuildResult:
+        """Build all packages in the module.
+
+        Args:
+            go_executable: Path to Go executable
+            source_dir: Source directory
+            output_dir: Output directory for binaries
+            env: Environment variables
+            platform: Target platform (e.g., "linux/amd64")
+            run_build: Callback to execute build
+            stream_output: Whether to stream output
+
+        Returns:
+            BuildResult with success status
+        """
+        build_args = [go_executable, "build", "-o", str(output_dir), "./..."]
+
+        env_copy = env.copy()
+        if platform:
+            env_copy["GOOS"], env_copy["GOARCH"] = platform.split("/")
+
+        logger.info("🔨 开始构建...")
+        build_result = run_build(build_args, source_dir, output_dir, env_copy)
+
+        if build_result["success"]:
+            logger.info("✅ 构建成功")
+
+        return build_result
+
+    @staticmethod
+    def tidy(
+        go_executable: str,
+        source_dir: Path,
+        env: dict[str, str],
+        run_build,
+        stream_output: bool = True,
+    ) -> BuildResult:
+        """Run go mod tidy to clean up dependencies.
+
+        Args:
+            go_executable: Path to Go executable
+            source_dir: Source directory
+            env: Environment variables
+            run_build: Callback to execute build
+            stream_output: Whether to stream output
+
+        Returns:
+            BuildResult with success status
+        """
+        logger.info("📦 执行 go mod tidy...")
+        tidy_result = run_build([go_executable, "mod", "tidy"], source_dir, source_dir, env)
+
+        if tidy_result["success"]:
+            logger.info("✅ 依赖整理完成")
+
+        return tidy_result

multi_lang_build/compiler/go_support/tester.py

@@ -0,0 +1,199 @@
+"""Go test utilities."""
+
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Callable
+
+from loguru import logger
+
+from multi_lang_build.compiler.base import BuildResult
+
+
+class GoTester:
+    """Run Go tests."""
+
+    @staticmethod
+    def run(
+        go_executable: str,
+        source_dir: Path,
+        env: dict[str, str],
+        verbose: bool = True,
+        race: bool = False,
+        stream_output: bool = True,
+        run_build: Callable | None = None,
+    ) -> BuildResult:
+        """Run Go tests.
+
+        Args:
+            go_executable: Path to Go executable
+            source_dir: Source directory
+            env: Environment variables
+            verbose: Enable verbose test output
+            race: Enable race detector
+            stream_output: Whether to stream output
+            run_build: Optional custom build runner
+
+        Returns:
+            BuildResult with success status
+        """
+        test_args = [go_executable, "test"]
+
+        if verbose:
+            test_args.append("-v")
+        if race:
+            test_args.append("-race")
+
+        test_args.append("./...")
+
+        logger.info("🧪 开始运行测试...")
+
+        if run_build:
+            result = run_build(test_args, source_dir, source_dir, env)
+        else:
+            result = GoTester._run_test(test_args, source_dir, env, stream_output)
+
+        if result["success"]:
+            logger.info("✅ 测试完成")
+
+        return result
+
+    @staticmethod
+    def run_with_coverage(
+        go_executable: str,
+        source_dir: Path,
+        output_file: Path,
+        env: dict[str, str],
+        stream_output: bool = True,
+    ) -> BuildResult:
+        """Run tests with coverage.
+
+        Args:
+            go_executable: Path to Go executable
+            source_dir: Source directory
+            output_file: Output file for coverage report
+            env: Environment variables
+            stream_output: Whether to stream output
+
+        Returns:
+            BuildResult with success status
+        """
+        test_args = [
+            go_executable, "test",
+            "-v",
+            "-coverprofile", str(output_file),
+            "./...",
+        ]
+
+        return GoTester._run_test(test_args, source_dir, env, stream_output)
+
+    @staticmethod
+    def _run_test(
+        command: list[str],
+        source_dir: Path,
+        environment: dict[str, str],
+        stream_output: bool,
+    ) -> BuildResult:
+        """Execute test command."""
+        start_time = time.perf_counter()
+
+        try:
+            if stream_output:
+                return GoTester._stream_test(
+                    command, source_dir, environment, start_time
+                )
+            else:
+                return GoTester._capture_test(
+                    command, source_dir, environment, start_time
+                )
+        except Exception as e:
+            duration = time.perf_counter() - start_time
+            return BuildResult(
+                success=False,
+                return_code=-2,
+                stdout="",
+                stderr=f"Test error: {str(e)}",
+                output_path=None,
+                duration_seconds=duration,
+            )
+
+    @staticmethod
+    def _stream_test(
+        command: list[str],
+        source_dir: Path,
+        environment: dict[str, str],
+        start_time: float,
+    ) -> BuildResult:
+        """Execute tests with streaming output."""
+        import os
+        import sys
+
+        stdout_buffer = []
+        stderr_buffer = []
+
+        process = subprocess.Popen(
+            command,
+            cwd=source_dir,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            env={**os.environ, **environment},
+        )
+
+        # Read stdout
+        if process.stdout:
+            for line in process.stdout:
+                line = line.rstrip('\n\r')
+                stdout_buffer.append(line)
+                print(line)
+                sys.stdout.flush()
+
+        # Read stderr
+        if process.stderr:
+            for line in process.stderr:
+                line = line.rstrip('\n\r')
+                stderr_buffer.append(line)
+                print(line, file=sys.stderr)
+                sys.stderr.flush()
+
+        return_code = process.wait()
+        duration = time.perf_counter() - start_time
+
+        return BuildResult(
+            success=return_code == 0,
+            return_code=return_code,
+            stdout='\n'.join(stdout_buffer),
+            stderr='\n'.join(stderr_buffer),
+            output_path=source_dir,
+            duration_seconds=duration,
+        )
+
+    @staticmethod
+    def _capture_test(
+        command: list[str],
+        source_dir: Path,
+        environment: dict[str, str],
+        start_time: float,
+    ) -> BuildResult:
+        """Execute tests with captured output."""
+        result = subprocess.run(
+            command,
+            cwd=source_dir,
+            capture_output=True,
+            text=True,
+            timeout=3600,
+            env={**os.environ, **environment},
+        )
+
+        duration = time.perf_counter() - start_time
+
+        return BuildResult(
+            success=result.returncode == 0,
+            return_code=result.returncode,
+            stdout=result.stdout,
+            stderr=result.stderr,
+            output_path=source_dir,
+            duration_seconds=duration,
+        )