Jaypore CI

git.go (5159B)

---

 package jci
 
 import (
 	"bytes"
 	"errors"
 	"fmt"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"strings"
 )
 
 // gitError is returned whenever a git sub-process exits with a non-zero status.
 // It carries the original exit code together with the raw stdout and stderr so
 // callers (and users) can see exactly what git printed.
 type gitError struct {
 	Args     []string
 	ExitCode int
 	Stdout   string
 	Stderr   string
 }
 
 func (e *gitError) Error() string {
 	return fmt.Sprintf("git %s: exit %d\nstdout: %s\nstderr: %s",
 		strings.Join(e.Args, " "), e.ExitCode, e.Stdout, e.Stderr)
 }
 
 // gitCmd runs a git command (optionally with a pre-configured *exec.Cmd so the
 // caller can set Dir/Env/Stdin) and returns trimmed stdout.  On failure it
 // always returns a *gitError with exit code + both streams.
 func gitCmd(cmd *exec.Cmd) (string, error) {
 	var stdout, stderr bytes.Buffer
 	cmd.Stdout = &stdout
 	cmd.Stderr = &stderr
 	err := cmd.Run()
 	args := cmd.Args[1:] // strip the leading "git"
 	if err != nil {
 		exitCode := -1
 		var exitErr *exec.ExitError
 		if errors.As(err, &exitErr) {
 			exitCode = exitErr.ExitCode()
 		}
 		return "", &gitError{
 			Args:     args,
 			ExitCode: exitCode,
 			Stdout:   stdout.String(),
 			Stderr:   stderr.String(),
 		}
 	}
 	return strings.TrimSpace(stdout.String()), nil
 }
 
 // git runs a plain git command and returns stdout.
 func git(args ...string) (string, error) {
 	return gitCmd(exec.Command("git", args...))
 }
 
 // GetCurrentCommit returns the current HEAD commit hash
 func GetCurrentCommit() (string, error) {
 	return git("rev-parse", "HEAD")
 }
 
 // GetRepoRoot returns the root directory of the git repository
 func GetRepoRoot() (string, error) {
 	return git("rev-parse", "--show-toplevel")
 }
 
 // RefExists checks if a ref exists
 func RefExists(ref string) bool {
 	_, err := git("rev-parse", "--verify", ref)
 	return err == nil
 }
 
 // StoreTree stores a directory as a tree object and creates a commit under refs/jci-runs/<commit>/<runID>
 func StoreTree(dir string, commit string, message string, runID string) error {
 	repoRoot, err := GetRepoRoot()
 	if err != nil {
 		return err
 	}
 
 	// We need to use git hash-object and mktree to build a tree
 	// from files outside the repo
 	treeID, err := hashDir(dir, repoRoot)
 	if err != nil {
 		return fmt.Errorf("failed to hash directory: %w", err)
 	}
 
 	// Create commit from tree.
 	// git commit-tree requires author/committer identity. In CI environments
 	// (especially shallow clones) git config may be absent, so we inject
 	// fallback env vars while still honouring any values already set.
 	commitTreeCmd := exec.Command("git", "commit-tree", treeID, "-m", message)
 	commitTreeCmd.Dir = repoRoot
 	commitTreeCmd.Env = append(os.Environ(), gitIdentityEnv()...)
 	commitID, err := gitCmd(commitTreeCmd)
 	if err != nil {
 		return err
 	}
 
 	// Update ref: refs/jci-runs/<commit>/<runid>
 	ref := "refs/jci-runs/" + commit + "/" + runID
 	if _, err := git("update-ref", ref, commitID); err != nil {
 		return err
 	}
 
 	return nil
 }
 
 // hashDir recursively hashes a directory and returns its tree ID
 func hashDir(dir string, repoRoot string) (string, error) {
 	entries, err := os.ReadDir(dir)
 	if err != nil {
 		return "", err
 	}
 
 	var treeEntries []string
 
 	for _, entry := range entries {
 		path := filepath.Join(dir, entry.Name())
 
 		if entry.IsDir() {
 			// Recursively hash subdirectory
 			subTreeID, err := hashDir(path, repoRoot)
 			if err != nil {
 				return "", err
 			}
 			treeEntries = append(treeEntries, fmt.Sprintf("040000 tree %s\t%s", subTreeID, entry.Name()))
 		} else {
 			// Hash file
 			cmd := exec.Command("git", "hash-object", "-w", path)
 			cmd.Dir = repoRoot
 			blobID, err := gitCmd(cmd)
 			if err != nil {
 				return "", err
 			}
 
 			// Get file mode
 			info, err := entry.Info()
 			if err != nil {
 				return "", err
 			}
 			mode := "100644"
 			if info.Mode()&0111 != 0 {
 				mode = "100755"
 			}
 			treeEntries = append(treeEntries, fmt.Sprintf("%s blob %s\t%s", mode, blobID, entry.Name()))
 		}
 	}
 
 	// Create tree from entries
 	treeInput := strings.Join(treeEntries, "\n")
 	if treeInput != "" {
 		treeInput += "\n"
 	}
 
 	cmd := exec.Command("git", "mktree")
 	cmd.Dir = repoRoot
 	cmd.Stdin = strings.NewReader(treeInput)
 	return gitCmd(cmd)
 }
 
 // gitIdentityEnv returns GIT_AUTHOR_* / GIT_COMMITTER_* env vars with safe
 // fallback values so that git commit-tree works even when git config has no
 // user identity set (common in CI shallow-clone environments).
 func gitIdentityEnv() []string {
 	getOrDefault := func(envKey, fallback string) string {
 		if v := os.Getenv(envKey); v != "" {
 			return v
 		}
 		return fallback
 	}
 	name := getOrDefault("GIT_AUTHOR_NAME", "jci")
 	email := getOrDefault("GIT_AUTHOR_EMAIL", "jci@localhost")
 	return []string{
 		"GIT_AUTHOR_NAME=" + name,
 		"GIT_AUTHOR_EMAIL=" + email,
 		"GIT_COMMITTER_NAME=" + name,
 		"GIT_COMMITTER_EMAIL=" + email,
 	}
 }
 
 // ListJCIRunRefs returns all refs under refs/jci-runs/
 func ListJCIRunRefs() ([]string, error) {
 	out, err := git("for-each-ref", "--format=%(refname)", "refs/jci-runs/")
 	if err != nil {
 		return nil, err
 	}
 	if out == "" {
 		return nil, nil
 	}
 	return strings.Split(out, "\n"), nil
 }