mirror of
https://github.com/coder/coder.git
synced 2026-09-23 22:20:22 +08:00
## What Consolidates the two separate release programs into a single command at `scripts/releaser`: - `scripts/releaser/v1/` — the former interactive releaser (package `v1`). - `scripts/releaser/v2/` — the former `scripts/release-action` CI tool (package `v2`). - `scripts/releaser/main.go` — new entrypoint. Runs the **v2** tooling by default and the **v1** interactive wizard with `--legacy`. ## CLI shape Three documented subcommands, each backed by v2 `prepare-release` with the release type baked in: - `releaser rc` — tag a release candidate - `releaser branch` — cut a new release branch and tag its first RC - `releaser release` — tag a stable release or patch The former release-action verbs (`calculate-version`, `prepare-release`, `generate-notes`, `publish`) are retained as **hidden** top-level commands with identical flags and stdout, so `tag-and-release.yaml` migrates with a path-only change (`scripts/release-action` -> `scripts/releaser`). `--legacy` runs the v1 wizard and is mutually exclusive with the subcommands. `scripts/release.sh` now launches `releaser --legacy`. All file moves are rename-detected by git, so the per-file diff is just the package declaration. ## Testing - `go build ./scripts/...`, `go vet ./scripts/releaser/...`, `go test ./scripts/releaser/...` - `golangci-lint run ./scripts/releaser/...`, `make lint/emdash`, `shellcheck`, `actionlint` - Smoke: `releaser --help` shows only rc/branch/release; hidden verbs still run; `releaser rc --ref main --dry-run` emits the same JSON contract; `--legacy rc` errors cleanly. <details> <summary>Implementation plan</summary> # Plan: Consolidate release tooling into a single `scripts/releaser` command ## Goal Merge the two separate release programs into one binary at `scripts/releaser`: - `scripts/releaser/v1/` — the current interactive releaser (package `v1`). - `scripts/releaser/v2/` — the current CI `scripts/release-action` (package `v2`). - `scripts/releaser/main.go` — new entrypoint (package `main`). - Uses v2 by default, v1 with `--legacy`. - Exposes 3 subcommands: `rc`, `branch` (cut release branch), `release`. ## Design decision (Option A, chosen) The workflow needs `prepare-release`, `generate-notes`, and `publish` invokable separately (a build happens between prepare and publish). The latter two are version-driven and type-agnostic, so they do not map cleanly onto `rc`/`branch`/`release`. - Visible subcommands `rc`, `branch`, `release` run v2 `prepare-release` with the type baked in and print the same JSON. - Hidden verbs `calculate-version`, `prepare-release`, `generate-notes`, `publish` keep byte-identical flags/stdout, so the workflow change is path-only. Lowest risk; honors "3 subcommands" from a UX perspective. ## `--legacy` semantics - `releaser --legacy` runs the v1 interactive wizard (preserves today's behavior; the wizard auto-detects RC vs release from the branch). - `--legacy` is mutually exclusive with the subcommands (clear error if combined), because v1 auto-detects type and cannot cut a branch. ## Work items 1. Create `v1` and `v2` packages via `git mv`, renaming `package main`. Move the `owner`/`repo` consts into each package. Add `v1.Run(inv, dryRun)` (old wizard `main()` body) and v2 command builders (`CICommands`, `TypeCommand`) so internals stay unexported. 2. New `scripts/releaser/main.go`: top-level `releaser` with `--legacy`, the 3 subcommands, and the hidden compat verbs; delegates to `v1.Run` for legacy. 3. Update references: `tag-and-release.yaml` (3 command paths + header comment) and `scripts/release.sh` (`--legacy`). 4. Verify: build, vet, test, `go run` smoke tests, fmt, lint. 5. Open a single PR from a feature branch. ## Risks / notes - stdout contract for rc/branch/release and the hidden verbs must stay identical (workflow parses stdout); logs go to stderr. - Patch releases from pre-existing `release/X.Y` branches run those branches' own (old) workflow + `scripts/release-action`, so they stay self-consistent. New releases cut from branches containing this change get the new workflow + `scripts/releaser`. No forwarding stub needed since code and workflow ship together. </details> --- This PR was created by Coder Agents on behalf of @f0ssel.
92 lines
2.7 KiB
Go
92 lines
2.7 KiB
Go
package v1
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"os/exec"
|
|
"strings"
|
|
|
|
"golang.org/x/xerrors"
|
|
)
|
|
|
|
// ReleaseExecutor handles dangerous write/mutating operations
|
|
// that should be skipped in dry-run mode. Only actions that
|
|
// modify the git repo or trigger external side effects belong
|
|
// here. Safe operations (file writes, fetches, editor) are
|
|
// called directly.
|
|
type ReleaseExecutor interface {
|
|
// CreateTag creates an annotated (optionally signed) git tag.
|
|
CreateTag(ctx context.Context, tag, ref, message string, sign bool) error
|
|
// PushTag pushes a tag to the origin remote.
|
|
PushTag(ctx context.Context, tag string) error
|
|
// TriggerWorkflow dispatches the release.yaml GitHub Actions
|
|
// workflow with the given inputs.
|
|
TriggerWorkflow(ctx context.Context, ref, channel, releaseNotes string) error
|
|
}
|
|
|
|
// liveExecutor performs real operations.
|
|
type liveExecutor struct{}
|
|
|
|
//nolint:revive // sign flag is part of the ReleaseExecutor interface contract.
|
|
func (e *liveExecutor) CreateTag(_ context.Context, tag, ref, message string, sign bool) error {
|
|
args := []string{"tag", "-a"}
|
|
if sign {
|
|
args = append(args, "-s")
|
|
}
|
|
args = append(args, tag, "-m", message, ref)
|
|
return gitRun(args...)
|
|
}
|
|
|
|
func (*liveExecutor) PushTag(_ context.Context, tag string) error {
|
|
return gitRun("push", "origin", tag)
|
|
}
|
|
|
|
func (*liveExecutor) TriggerWorkflow(_ context.Context, ref, channel, releaseNotes string) error {
|
|
payload := map[string]string{
|
|
"dry_run": "false",
|
|
"release_channel": channel,
|
|
"release_notes": releaseNotes,
|
|
}
|
|
payloadJSON, err := json.Marshal(payload)
|
|
if err != nil {
|
|
return xerrors.Errorf("marshaling workflow payload: %w", err)
|
|
}
|
|
cmd := exec.Command("gh", "workflow", "run", "release.yaml",
|
|
"--repo", owner+"/"+repo,
|
|
"--ref", ref,
|
|
"--json",
|
|
)
|
|
cmd.Stdin = strings.NewReader(string(payloadJSON))
|
|
cmd.Stdout = os.Stdout
|
|
cmd.Stderr = os.Stderr
|
|
return cmd.Run()
|
|
}
|
|
|
|
// dryRunExecutor prints what would happen without doing it.
|
|
type dryRunExecutor struct {
|
|
w io.Writer
|
|
}
|
|
|
|
//nolint:revive // sign flag is part of the ReleaseExecutor interface contract.
|
|
func (e *dryRunExecutor) CreateTag(_ context.Context, tag, ref, message string, sign bool) error {
|
|
signFlag := ""
|
|
if sign {
|
|
signFlag = "-s "
|
|
}
|
|
_, _ = fmt.Fprintf(e.w, "[DRYRUN] would run: git tag %s-a %s -m %q %s\n", signFlag, tag, message, ref)
|
|
return nil
|
|
}
|
|
|
|
func (e *dryRunExecutor) PushTag(_ context.Context, tag string) error {
|
|
_, _ = fmt.Fprintf(e.w, "[DRYRUN] would run: git push origin %s\n", tag)
|
|
return nil
|
|
}
|
|
|
|
func (e *dryRunExecutor) TriggerWorkflow(_ context.Context, ref, channel, _ string) error {
|
|
_, _ = fmt.Fprintf(e.w, "[DRYRUN] would trigger release.yaml workflow (ref=%s, channel=%s)\n", ref, channel)
|
|
return nil
|
|
}
|