package server import ( "context" "crypto/rand" "encoding/hex" "fmt" "os" "os/exec" "path/filepath" "regexp" "strings" "time" ) // runWorktreeBranchPrefix names the branch of every worktree the server creates // for a run, so cleanup can tell its own trees from an operator's. const runWorktreeBranchPrefix = "pipelines/run-" // runWorktreesDirSuffix is appended to a repository's directory name for the // sibling directory that holds its run worktrees: /repos/app -> /repos/app-runs. const runWorktreesDirSuffix = "-runs" // isolateRunWorkspace gives a new run its own Git worktree when it was started // from a repository's main checkout, so concurrent runs never share a tree and a // run never sees (or commits) the operator's uncommitted work. A workspace that // is not in a Git repository, or is already a linked worktree (an item's tree, // or a retry reusing its run's tree), is returned unchanged. A subdirectory of // the main checkout maps to the same subdirectory of the new worktree. // // The worktree starts at the checkout's current HEAD on a new branch // pipelines/run- and lives in -runs/ next to the repository. func isolateRunWorkspace(ctx context.Context, workspace, title string) (string, error) { top, err := gitOutput(workspace, "rev-parse", "--show-toplevel") if err != nil { return workspace, nil // Not a Git checkout: nothing to isolate. } gitDir, err := gitOutput(workspace, "rev-parse", "--path-format=absolute", "--git-dir") if err != nil { return "", fmt.Errorf("run worktree: %w", err) } commonDir, err := gitOutput(workspace, "rev-parse", "--path-format=absolute", "--git-common-dir") if err != nil { return "", fmt.Errorf("run worktree: %w", err) } if filepath.Clean(gitDir) != filepath.Clean(commonDir) { return workspace, nil // Already a linked worktree. } if _, err := gitOutput(workspace, "rev-parse", "--verify", "HEAD"); err != nil { return workspace, nil // No commit to branch from yet. } top, err = filepath.EvalSymlinks(top) if err != nil { return "", fmt.Errorf("run worktree: %w", err) } rel, err := filepath.Rel(top, workspace) if err != nil || rel == ".." || strings.HasPrefix(rel, ".."+string(os.PathSeparator)) { return "", fmt.Errorf("run worktree: workspace %s is outside its repository %s", workspace, top) } slug := runWorktreeSlug(time.Now(), title) root := filepath.Join(filepath.Dir(top), filepath.Base(top)+runWorktreesDirSuffix) if err := os.MkdirAll(root, 0o755); err != nil { return "", fmt.Errorf("run worktree: %w", err) } tree := filepath.Join(root, slug) branch := runWorktreeBranchPrefix + slug cmd := exec.CommandContext(ctx, "git", "-C", top, "worktree", "add", "-b", branch, tree, "HEAD") if output, err := cmd.CombinedOutput(); err != nil { return "", fmt.Errorf("run worktree: git worktree add %s: %w: %s", tree, err, strings.TrimSpace(string(output))) } resolved, err := filepath.EvalSymlinks(tree) if err != nil { return "", fmt.Errorf("run worktree: %w", err) } return filepath.Join(resolved, rel), nil } var runSlugUnsafe = regexp.MustCompile(`[^a-z0-9]+`) // runWorktreeSlug is a sortable, readable and unique directory/branch name: // 20261110-1530-short-title-ab12. func runWorktreeSlug(now time.Time, title string) string { words := strings.Trim(runSlugUnsafe.ReplaceAllString(strings.ToLower(title), "-"), "-") if len(words) > 40 { words = strings.TrimRight(words[:40], "-") } random := make([]byte, 2) _, _ = rand.Read(random) parts := []string{now.UTC().Format("20060102-1504")} if words != "" { parts = append(parts, words) } parts = append(parts, hex.EncodeToString(random)) return strings.Join(parts, "-") } // removeLandedRunWorktree deletes a run worktree the server created once its // work is safe: the tree is clean and its branch is already in the main // main branch (landed, or no commits at all). Anything else — an // operator's tree, uncommitted files, unlanded commits — is kept, so a failed // or unfinished run never loses work. It reports whether the tree was removed. func removeLandedRunWorktree(workspace string) bool { if !isRunWorktree(workspace) { return false } top, err := gitOutput(workspace, "rev-parse", "--show-toplevel") if err != nil { return false } branch, err := gitOutput(top, "symbolic-ref", "--quiet", "--short", "HEAD") if err != nil { return false } if status, err := gitOutput(top, "status", "--porcelain=v1", "--untracked-files=all"); err != nil || status != "" { return false } main, err := firstWorktree(top) if err != nil { return false } // Landed means reachable from the repository's main branch. if exec.Command("git", "-C", top, "merge-base", "--is-ancestor", "HEAD", "refs/heads/main").Run() != nil { return false } if exec.Command("git", "-C", main, "worktree", "remove", top).Run() != nil { return false } _ = exec.Command("git", "-C", main, "branch", "-d", branch).Run() return true } // firstWorktree is the repository's main (first-listed) worktree, the one // linked worktrees are managed from. func firstWorktree(directory string) (string, error) { list, err := gitOutput(directory, "worktree", "list", "--porcelain") if err != nil { return "", err } first, _, _ := strings.Cut(list, "\n") if !strings.HasPrefix(first, "worktree ") { return "", fmt.Errorf("no main worktree") } return strings.TrimPrefix(first, "worktree "), nil } // discardRunWorktree removes a run worktree that was created for a run that // never started (refused or a duplicate request), with its branch. It only // touches trees the server created. func discardRunWorktree(workspace string) { if !isRunWorktree(workspace) { return } top, err := gitOutput(workspace, "rev-parse", "--show-toplevel") if err != nil { return } branch, err := gitOutput(top, "symbolic-ref", "--quiet", "--short", "HEAD") if err != nil { return } main, err := firstWorktree(top) if err != nil { return } _ = exec.Command("git", "-C", main, "worktree", "remove", "--force", top).Run() _ = exec.Command("git", "-C", main, "branch", "-D", branch).Run() } // deliveryCommitMessage is the message for the work a land stage left // uncommitted: the run's title and id. Only a run in a server-created run // worktree gets one; elsewhere the tree may hold someone else's work, so the // gate keeps refusing an unclean checkout there. func (r *runner) deliveryCommitMessage(id int64) string { c, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() detail, err := r.store.GetRun(c, id) if err != nil || detail == nil || !isRunWorktree(detail.Workspace) { return "" } title := strings.TrimSpace(detail.Title) if title == "" { title = detail.Name } return fmt.Sprintf("%s\n\nPipelines run %d.", title, id) } // isRunWorktree reports whether directory is inside a worktree the server // created for a run. func isRunWorktree(directory string) bool { top, err := gitOutput(directory, "rev-parse", "--show-toplevel") if err != nil { return false } branch, err := gitOutput(top, "symbolic-ref", "--quiet", "--short", "HEAD") return err == nil && strings.HasPrefix(branch, runWorktreeBranchPrefix) && strings.HasSuffix(filepath.Base(filepath.Dir(top)), runWorktreesDirSuffix) }