tenseleyflow/shithub / 740d0b4

+// cancellation, re-runs, and retention as the S41g slices land.

+// SPDX-License-Identifier: AGPL-3.0-or-later

+

+package lifecycle

+

+import (

+	"log/slog"

+

+	"github.com/jackc/pgx/v5/pgxpool"

+

+	"github.com/tenseleyFlow/shithub/internal/infra/storage"

+)

+

+// Deps wires lifecycle operations to postgres and optional runtime services.

+type Deps struct {

+	Pool   *pgxpool.Pool

+	RepoFS *storage.RepoFS

+	Logger *slog.Logger

+}

+// SPDX-License-Identifier: AGPL-3.0-or-later

+

+package lifecycle

+

+import (

+	"context"

+	"crypto/rand"

+	"encoding/hex"

+	"encoding/json"

+	"errors"

+	"fmt"

+	"io"

+	"log/slog"

+

+	actionsdb "github.com/tenseleyFlow/shithub/internal/actions/sqlc"

+	"github.com/tenseleyFlow/shithub/internal/actions/trigger"

+	"github.com/tenseleyFlow/shithub/internal/actions/workflow"

+	orgsdb "github.com/tenseleyFlow/shithub/internal/orgs/sqlc"

+	repogit "github.com/tenseleyFlow/shithub/internal/repos/git"

+	reposdb "github.com/tenseleyFlow/shithub/internal/repos/sqlc"

+	usersdb "github.com/tenseleyFlow/shithub/internal/users/sqlc"

+)

+

+var (

+	ErrActorRequired              = errors.New("actions lifecycle: actor required")

+	ErrRunNotRerunnable           = errors.New("actions lifecycle: run is not rerunnable")

+	ErrWorkflowSourceUnavailable  = errors.New("actions lifecycle: workflow source unavailable")

+	ErrWorkflowSourceInvalid      = errors.New("actions lifecycle: workflow source invalid")

+	errWorkflowPayloadNotJSON     = errors.New("actions lifecycle: event payload is not a JSON object")

+	errWorkflowSourceEmpty        = errors.New("actions lifecycle: workflow source is empty")

+	errWorkflowSourceHasDiagError = errors.New("actions lifecycle: workflow source has error diagnostics")

+)

+

+// RerunResult summarizes the newly queued run produced from a terminal source

+// run.

+type RerunResult struct {

+	ParentRunID int64

+	RunID       int64

+	RunIndex    int64

+	CheckRunIDs []int64

+}

+

+// RerunRun queues a fresh workflow run from a terminal source run. It reads the

+// workflow YAML from the source run's original head_sha, not from the current

+// default branch, so reruns are reproducible even after workflow edits.

+func RerunRun(ctx context.Context, deps Deps, runID, actorUserID int64) (RerunResult, error) {

+	if deps.Pool == nil {

+		return RerunResult{}, errors.New("actions lifecycle: nil Pool")

+	}

+	if deps.RepoFS == nil {

+		return RerunResult{}, errors.New("actions lifecycle: nil RepoFS")

+	}

+	if actorUserID == 0 {

+		return RerunResult{}, ErrActorRequired

+	}

+	logger := deps.Logger

+	if logger == nil {

+		logger = slog.New(slog.NewTextHandler(io.Discard, nil))

+	}

+

+	q := actionsdb.New()

+	run, err := q.GetWorkflowRunByID(ctx, deps.Pool, runID)

+	if err != nil {

+		return RerunResult{}, err

+	}

+	if !workflowRunRerunnable(run.Status) {

+		return RerunResult{}, ErrRunNotRerunnable

+	}

+	payload, err := decodeRunEventPayload(run.EventPayload)

+	if err != nil {

+		return RerunResult{}, fmt.Errorf("%w: %w", ErrWorkflowSourceInvalid, err)

+	}

+	repo, err := reposdb.New().GetRepoByID(ctx, deps.Pool, run.RepoID)

+	if err != nil {

+		return RerunResult{}, err

+	}

+	owner, err := lifecycleRepoOwnerLogin(ctx, deps.Pool, repo)

+	if err != nil {

+		return RerunResult{}, err

+	}

+	gitDir, err := deps.RepoFS.RepoPath(owner, repo.Name)

+	if err != nil {

+		return RerunResult{}, err

+	}

+	body, err := repogit.ReadBlobBytes(ctx, gitDir, run.HeadSha, run.WorkflowFile, int64(workflow.MaxWorkflowFileBytes))

+	if err != nil {

+		return RerunResult{}, fmt.Errorf("%w: %w", ErrWorkflowSourceUnavailable, err)

+	}

+	if len(body) == 0 {

+		return RerunResult{}, fmt.Errorf("%w: %w", ErrWorkflowSourceInvalid, errWorkflowSourceEmpty)

+	}

+	wf, diags, err := workflow.Parse(body)

+	if err != nil {

+		return RerunResult{}, fmt.Errorf("%w: %w", ErrWorkflowSourceInvalid, err)

+	}

+	if workflowHasErrorDiagnostics(diags) {

+		return RerunResult{}, fmt.Errorf("%w: %w", ErrWorkflowSourceInvalid, errWorkflowSourceHasDiagError)

+	}

+	triggerID, err := rerunTriggerEventID(run.ID)

+	if err != nil {

+		return RerunResult{}, err

+	}

+	res, err := trigger.Enqueue(ctx, trigger.Deps{Pool: deps.Pool, Logger: logger}, trigger.EnqueueParams{

+		RepoID:         run.RepoID,

+		WorkflowFile:   run.WorkflowFile,

+		HeadSHA:        run.HeadSha,

+		HeadRef:        run.HeadRef,

+		EventKind:      trigger.EventKind(run.Event),

+		EventPayload:   payload,

+		ActorUserID:    actorUserID,

+		ParentRunID:    run.ID,

+		TriggerEventID: triggerID,

+		Workflow:       wf,

+	})

+	if err != nil {

+		return RerunResult{}, err

+	}

+	return RerunResult{

+		ParentRunID: run.ID,

+		RunID:       res.RunID,

+		RunIndex:    res.RunIndex,

+		CheckRunIDs: res.CheckRunIDs,

+	}, nil

+}

+

+func workflowRunRerunnable(status actionsdb.WorkflowRunStatus) bool {

+	return status == actionsdb.WorkflowRunStatusCompleted ||

+		status == actionsdb.WorkflowRunStatusCancelled

+}

+

+func decodeRunEventPayload(raw []byte) (map[string]any, error) {

+	if len(raw) == 0 {

+		return map[string]any{}, nil

+	}

+	var out map[string]any

+	if err := json.Unmarshal(raw, &out); err != nil {

+		return nil, err

+	}

+	if out == nil {

+		return nil, errWorkflowPayloadNotJSON

+	}

+	return out, nil

+}

+

+func workflowHasErrorDiagnostics(diags []workflow.Diagnostic) bool {

+	for _, d := range diags {

+		if d.Severity == workflow.Error {

+			return true

+		}

+	}

+	return false

+}

+

+func rerunTriggerEventID(parentRunID int64) (string, error) {

+	b := make([]byte, 8)

+	if _, err := rand.Read(b); err != nil {

+		return "", fmt.Errorf("actions lifecycle: rerun id entropy: %w", err)

+	}

+	return fmt.Sprintf("rerun:%d:%s", parentRunID, hex.EncodeToString(b)), nil

+}

+

+func lifecycleRepoOwnerLogin(ctx context.Context, db interface {

+	usersdb.DBTX

+	orgsdb.DBTX

+}, repo reposdb.Repo) (string, error) {

+	if repo.OwnerUserID.Valid {

+		u, err := usersdb.New().GetUserByID(ctx, db, repo.OwnerUserID.Int64)

+		if err != nil {

+			return "", err

+		}

+		return u.Username, nil

+	}

+	if repo.OwnerOrgID.Valid {

+		o, err := orgsdb.New().GetOrgByID(ctx, db, repo.OwnerOrgID.Int64)

+		if err != nil {

+			return "", err

+		}

+		return o.Slug, nil

+	}

+	return "", errors.New("repo has neither owner_user_id nor owner_org_id")

+}

+// SPDX-License-Identifier: AGPL-3.0-or-later

+

+package lifecycle

+

+import (

+	"context"

+	"errors"

+	"io"

+	"log/slog"

+	"strings"

+	"testing"

+	"time"

+

+	"github.com/jackc/pgx/v5/pgxpool"

+

+	actionsdb "github.com/tenseleyFlow/shithub/internal/actions/sqlc"

+	"github.com/tenseleyFlow/shithub/internal/actions/trigger"

+	"github.com/tenseleyFlow/shithub/internal/actions/workflow"

+	"github.com/tenseleyFlow/shithub/internal/infra/storage"

+	repogit "github.com/tenseleyFlow/shithub/internal/repos/git"

+	"github.com/tenseleyFlow/shithub/internal/testing/dbtest"

+)

+

+const oldWorkflow = `name: CI

+on: push

+jobs:

+  old_job:

+    name: Old job

+    runs-on: ubuntu-latest

+    steps:

+      - run: echo old

+`

+

+const newWorkflow = `name: CI

+on: push

+jobs:

+  new_job:

+    name: New job

+    runs-on: ubuntu-latest

+    steps:

+      - run: echo new

+`

+

+func TestRerunRunUsesOriginalCommitWorkflowAndParentsNewRun(t *testing.T) {

+	ctx := context.Background()

+	pool := dbtestPool(t)

+	repoID, userID := setupLifecycleRepo(t, pool)

+	rfs := lifecycleRepoFS(t)

+	gitDir := lifecycleGitDir(t, rfs)

+	oldSHA := lifecycleCommitWorkflow(t, gitDir, oldWorkflow, time.Date(2026, 5, 11, 12, 0, 0, 0, time.UTC))

+	wf := parseLifecycleWorkflow(t, oldWorkflow)

+

+	logger := slog.New(slog.NewTextHandler(io.Discard, nil))

+	original, err := trigger.Enqueue(ctx, trigger.Deps{Pool: pool, Logger: logger}, trigger.EnqueueParams{

+		RepoID:         repoID,

+		WorkflowFile:   ".shithub/workflows/ci.yml",

+		HeadSHA:        oldSHA,

+		HeadRef:        "refs/heads/trunk",

+		EventKind:      trigger.EventPush,

+		EventPayload:   map[string]any{"ref": "refs/heads/trunk"},

+		ActorUserID:    userID,

+		TriggerEventID: "push:original",

+		Workflow:       wf,

+	})

+	if err != nil {

+		t.Fatalf("trigger.Enqueue original: %v", err)

+	}

+	if _, err := actionsdb.New().CompleteWorkflowRun(ctx, pool, actionsdb.CompleteWorkflowRunParams{

+		ID:         original.RunID,

+		Conclusion: actionsdb.CheckConclusionFailure,

+	}); err != nil {

+		t.Fatalf("CompleteWorkflowRun: %v", err)

+	}

+	_ = lifecycleCommitWorkflow(t, gitDir, newWorkflow, time.Date(2026, 5, 11, 12, 5, 0, 0, time.UTC))

+

+	result, err := RerunRun(ctx, Deps{Pool: pool, RepoFS: rfs, Logger: logger}, original.RunID, userID)

+	if err != nil {

+		t.Fatalf("RerunRun: %v", err)

+	}

+	if result.ParentRunID != original.RunID || result.RunID == 0 || result.RunID == original.RunID {

+		t.Fatalf("unexpected result: %+v", result)

+	}

+

+	q := actionsdb.New()

+	rerun, err := q.GetWorkflowRunByID(ctx, pool, result.RunID)

+	if err != nil {

+		t.Fatalf("GetWorkflowRunByID rerun: %v", err)

+	}

+	if !rerun.ParentRunID.Valid || rerun.ParentRunID.Int64 != original.RunID {

+		t.Fatalf("parent_run_id: %+v want %d", rerun.ParentRunID, original.RunID)

+	}

+	if rerun.HeadSha != oldSHA {

+		t.Fatalf("rerun head_sha = %q want original %q", rerun.HeadSha, oldSHA)

+	}

+	if !strings.HasPrefix(rerun.TriggerEventID, "rerun:") {

+		t.Fatalf("rerun trigger_event_id = %q", rerun.TriggerEventID)

+	}

+	if !rerun.ActorUserID.Valid || rerun.ActorUserID.Int64 != userID {

+		t.Fatalf("rerun actor_user_id: %+v want %d", rerun.ActorUserID, userID)

+	}

+	jobs, err := q.ListJobsForRun(ctx, pool, result.RunID)

+	if err != nil {

+		t.Fatalf("ListJobsForRun: %v", err)

+	}

+	if len(jobs) != 1 || jobs[0].JobKey != "old_job" || jobs[0].JobName != "Old job" {

+		t.Fatalf("rerun used wrong workflow jobs: %+v", jobs)

+	}

+}

+

+func TestRerunRunRejectsNonTerminalRun(t *testing.T) {

+	ctx := context.Background()

+	pool := dbtestPool(t)

+	repoID, userID := setupLifecycleRepo(t, pool)

+	rfs := lifecycleRepoFS(t)

+	run := insertLifecycleRun(t, pool, repoID, userID, 1)

+

+	_, err := RerunRun(ctx, Deps{Pool: pool, RepoFS: rfs}, run.ID, userID)

+	if !errors.Is(err, ErrRunNotRerunnable) {

+		t.Fatalf("RerunRun error = %v, want ErrRunNotRerunnable", err)

+	}

+}

+

+func dbtestPool(t *testing.T) *pgxpool.Pool {

+	t.Helper()

+	return dbtest.NewTestDB(t)

+}

+

+func lifecycleRepoFS(t *testing.T) *storage.RepoFS {

+	t.Helper()

+	rfs, err := storage.NewRepoFS(t.TempDir())

+	if err != nil {

+		t.Fatalf("NewRepoFS: %v", err)

+	}

+	return rfs

+}

+

+func lifecycleGitDir(t *testing.T, rfs *storage.RepoFS) string {

+	t.Helper()

+	gitDir, err := rfs.RepoPath("alice", "demo")

+	if err != nil {

+		t.Fatalf("RepoPath: %v", err)

+	}

+	if err := rfs.InitBare(context.Background(), gitDir); err != nil {

+		t.Fatalf("InitBare: %v", err)

+	}

+	return gitDir

+}

+

+func lifecycleCommitWorkflow(t *testing.T, gitDir, body string, when time.Time) string {

+	t.Helper()

+	commit, err := (repogit.InitialCommit{

+		GitDir:      gitDir,

+		AuthorName:  "Alice",

+		AuthorEmail: "alice@example.test",

+		Branch:      "trunk",

+		Message:     "Update workflow",

+		When:        when,

+		Files: []repogit.FileEntry{

+			{Path: ".shithub/workflows/ci.yml", Body: []byte(body)},

+		},

+	}).Build(context.Background())

+	if err != nil {

+		t.Fatalf("InitialCommit.Build: %v", err)

+	}

+	return commit

+}

+

+func parseLifecycleWorkflow(t *testing.T, body string) *workflow.Workflow {

+	t.Helper()

+	wf, diags, err := workflow.Parse([]byte(body))

+	if err != nil {

+		t.Fatalf("workflow.Parse: %v", err)

+	}

+	for _, d := range diags {

+		if d.Severity == workflow.Error {

+			t.Fatalf("workflow diagnostic: %v", d)

+		}

+	}

+	return wf

+}