Add downloaders for uv, go and jq (#3444)

## Why
We'll package the CLI repo and binaries for uv, go and jq into a tar.gz
archive before uploading it to a serverless cluster for execution. This
PR adds the downloader for those tools. A follow-up PR will be sent for
actually building the archives.

## Tests
Unit tests. The tests have a "dbr_only" build tag added, so they'll not
run during normal execution. I plan to run them only from the CI
integration run job for DBR.

Author: shreyas-goenka

internal/testarchive/downloader_test.go

@@ -0,0 +1,62 @@
+//go:build dbr_only
+
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestUvDownloader(t *testing.T) {
+	tmpDir := t.TempDir()
+
+	for _, arch := range []string{"arm64", "amd64"} {
+		err := uvDownloader{arch: arch, binDir: tmpDir}.Download()
+		require.NoError(t, err)
+
+		files, err := os.ReadDir(filepath.Join(tmpDir, arch))
+		require.NoError(t, err)
+
+		assert.Equal(t, 1, len(files))
+		assert.Equal(t, "uv", files[0].Name())
+	}
+}
+
+func TestJqDownloader(t *testing.T) {
+	tmpDir := t.TempDir()
+
+	for _, arch := range []string{"arm64", "amd64"} {
+		err := jqDownloader{arch: arch, binDir: tmpDir}.Download()
+		require.NoError(t, err)
+
+		files, err := os.ReadDir(filepath.Join(tmpDir, arch))
+		require.NoError(t, err)
+
+		assert.Equal(t, 1, len(files))
+		assert.Equal(t, "jq", files[0].Name())
+	}
+}
+
+func TestGoDownloader(t *testing.T) {
+	tmpDir := t.TempDir()
+
+	for _, arch := range []string{"arm64", "amd64"} {
+		err := goDownloader{arch: arch, binDir: tmpDir}.Download()
+		require.NoError(t, err)
+
+		entries, err := os.ReadDir(filepath.Join(tmpDir, arch))
+		require.NoError(t, err)
+
+		assert.Equal(t, 1, len(entries))
+		assert.Equal(t, "go", entries[0].Name())
+		assert.True(t, entries[0].IsDir())
+
+		binaryPath := filepath.Join(tmpDir, arch, "go", "bin", "go")
+		_, err = os.Stat(binaryPath)
+		require.NoError(t, err)
+	}
+}

internal/testarchive/go.go

@@ -0,0 +1,85 @@
+package main
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+)
+
+// Initialize these to prevent linter from complaining about unused types.
+// This can be removed once we actually use these downloaders.
+var (
+	_ = goDownloader{}
+	_ = uvDownloader{}
+	_ = jqDownloader{}
+)
+
+type goDownloader struct {
+	binDir string
+	arch   string
+}
+
+func (g goDownloader) readGoVersionFromMod() (string, error) {
+	goModPath := filepath.Join("..", "..", "go.mod")
+
+	file, err := os.Open(goModPath)
+	if err != nil {
+		return "", err
+	}
+	defer file.Close()
+
+	scanner := bufio.NewScanner(file)
+
+	// Get regex version from toolchain go version specified. Eg: toolchain go1.24.6
+	goVersionRegex := regexp.MustCompile(`^toolchain go(\d+\.\d+\.\d+)$`)
+
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		matches := goVersionRegex.FindStringSubmatch(line)
+		if matches != nil {
+			return matches[1], nil
+		}
+	}
+
+	if err := scanner.Err(); err != nil {
+		return "", err
+	}
+
+	return "", errors.New("go version not found in go.mod")
+}
+
+// Download downloads and extracts Go for Linux
+func (g goDownloader) Download() error {
+	goVersion, err := g.readGoVersionFromMod()
+	if err != nil {
+		return fmt.Errorf("failed to read Go version from go.mod: %w", err)
+	}
+
+	// Create the directory for the download if it doesn't exist
+	dir := filepath.Join(g.binDir, g.arch)
+	err = os.MkdirAll(dir, 0o755)
+	if err != nil {
+		return err
+	}
+
+	// Download the tar archive.
+	fileName := fmt.Sprintf("go%s.linux-%s.tar.gz", goVersion, g.arch)
+	url := "https://go.dev/dl/" + fileName
+
+	tempFile := filepath.Join(dir, fileName)
+	err = downloadFile(url, tempFile)
+	if err != nil {
+		return err
+	}
+
+	err = extractTarGz(tempFile, dir)
+	if err != nil {
+		return err
+	}
+
+	return os.Remove(tempFile)
+}

internal/testarchive/jq.go

@@ -0,0 +1,38 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+)
+
+// jqDownloader handles downloading and extracting jq releases
+type jqDownloader struct {
+	binDir string
+	arch   string
+}
+
+// Download downloads and extracts jq for Linux
+func (j jqDownloader) Download() error {
+	// create the directory for the download if it doesn't exist
+	dir := filepath.Join(j.binDir, j.arch)
+	err := os.MkdirAll(dir, 0o755)
+	if err != nil {
+		return err
+	}
+
+	// Construct the download URL for the latest release
+	url := "https://github.com/jqlang/jq/releases/latest/download/jq-linux-" + j.arch
+
+	binaryPath := filepath.Join(dir, "jq")
+	if err := downloadFile(url, binaryPath); err != nil {
+		return err
+	}
+
+	// Make the binary executable
+	if err := os.Chmod(binaryPath, 0o755); err != nil {
+		return fmt.Errorf("failed to make jq executable: %w", err)
+	}
+
+	return nil
+}

internal/testarchive/utils.go

@@ -0,0 +1,97 @@
+package main
+
+import (
+	"archive/tar"
+	"compress/gzip"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+)
+
+func downloadFile(url, outputPath string) error {
+	resp, err := http.Get(url)
+	if err != nil {
+		return fmt.Errorf("failed to download: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("download failed with status: %s", resp.Status)
+	}
+
+	outFile, err := os.Create(outputPath)
+	if err != nil {
+		return fmt.Errorf("failed to create output file: %w", err)
+	}
+	defer outFile.Close()
+
+	fmt.Printf("Downloading %s to %s\n", url, outputPath)
+	_, err = io.Copy(outFile, resp.Body)
+	if err != nil {
+		return fmt.Errorf("failed to save file: %w", err)
+	}
+
+	return nil
+}
+
+// extractTarGz extracts a tar.gz file to the specified directory
+func extractTarGz(archivePath, destDir string) error {
+	fmt.Printf("Extracting %s to %s\n", archivePath, destDir)
+
+	file, err := os.Open(archivePath)
+	if err != nil {
+		return fmt.Errorf("failed to open archive: %w", err)
+	}
+	defer file.Close()
+
+	gzReader, err := gzip.NewReader(file)
+	if err != nil {
+		return fmt.Errorf("failed to create gzip reader: %w", err)
+	}
+	defer gzReader.Close()
+
+	tarReader := tar.NewReader(gzReader)
+
+	for {
+		header, err := tarReader.Next()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return fmt.Errorf("failed to read tar header: %w", err)
+		}
+
+		targetPath := filepath.Join(destDir, header.Name)
+
+		switch header.Typeflag {
+		case tar.TypeDir:
+			if err := os.MkdirAll(targetPath, 0o755); err != nil {
+				return fmt.Errorf("failed to create directory %s: %w", targetPath, err)
+			}
+		case tar.TypeReg:
+			if err := os.MkdirAll(filepath.Dir(targetPath), 0o755); err != nil {
+				return fmt.Errorf("failed to create parent directory: %w", err)
+			}
+
+			outFile, err := os.Create(targetPath)
+			if err != nil {
+				return fmt.Errorf("failed to create file %s: %w", targetPath, err)
+			}
+
+			_, err = io.Copy(outFile, tarReader)
+			outFile.Close()
+			if err != nil {
+				return fmt.Errorf("failed to extract file %s: %w", targetPath, err)
+			}
+
+			// Set file permissions
+			if err := os.Chmod(targetPath, os.FileMode(header.Mode)); err != nil {
+				fmt.Printf("Warning: failed to set permissions for %s: %v\n", targetPath, err)
+			}
+		}
+	}
+
+	return nil
+}

internal/testarchive/uv.go

@@ -0,0 +1,76 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+)
+
+// uvDownloader handles downloading and extracting UV releases
+type uvDownloader struct {
+	binDir string
+	arch   string
+}
+
+// uvDownloader creates a new UV downloader
+
+// mapArchitecture maps our architecture names to UV's naming convention
+func (u uvDownloader) mapArchitecture(arch string) (string, error) {
+	switch arch {
+	case "arm64":
+		return "aarch64", nil
+	case "amd64":
+		return "x86_64", nil
+	default:
+		return "", fmt.Errorf("unsupported architecture: %s (supported: arm64, amd64)", arch)
+	}
+}
+
+// Download downloads and extracts UV for Linux
+func (u uvDownloader) Download() error {
+	// Map architecture names to UV's naming convention
+	uvArch, err := u.mapArchitecture(u.arch)
+	if err != nil {
+		return err
+	}
+
+	// create the directory for the download if it doesn't exist
+	dir := filepath.Join(u.binDir, u.arch)
+	err = os.MkdirAll(dir, 0o755)
+	if err != nil {
+		return err
+	}
+
+	// Construct the download URL for the latest release
+	uvTarName := fmt.Sprintf("uv-%s-unknown-linux-gnu", uvArch)
+	url := fmt.Sprintf("https://github.com/astral-sh/uv/releases/latest/download/%s.tar.gz", uvTarName)
+
+	// Download the file using shared utility
+	tempFile := filepath.Join(dir, "uv.tar.gz")
+	if err := downloadFile(url, tempFile); err != nil {
+		return err
+	}
+
+	// Extract the archive to the directory
+	if err := extractTarGz(tempFile, dir); err != nil {
+		return err
+	}
+
+	err = os.Remove(tempFile)
+	if err != nil {
+		return err
+	}
+
+	// The uv binary is extracted into a directory called something like
+	// uv-aarch64-unknown-linux-gnu. We remove that additional directory here
+	// and move the uv binary one level above to keep the directory structure clean.
+	err = os.Rename(filepath.Join(dir, uvTarName, "uv"), filepath.Join(dir, "uv"))
+	if err != nil {
+		return err
+	}
+	err = os.RemoveAll(filepath.Join(dir, uvTarName))
+	if err != nil {
+		return err
+	}
+	return nil
+}