chore: clear golangci-lint findings and handle the errors they flagged (#5306)

## What this PR does

This clears the golangci-lint findings on main and fixes the errors
several of them pointed at. With the default linter set (errcheck,
govet, ineffassign, staticcheck, unused), main had 197 findings when
this branch started. Rebased on main at 0f169540, the branch leaves 38,
all deprecations that need a design decision rather than a lint fix;
they are listed below.

Most commits are mechanical. They remove unused helpers and constants,
reword error strings, take the staticcheck simplifications, discard
best-effort cleanup errors explicitly, and move to the FieldsV1 and ptr
accessors. A loop in pkg/lineage that always ended in its first pass
becomes a helper, with a regression test for each fallback. These change
behaviour:

- Lost output is now a failure for the commands this PR touches: cozypkg
list, the validation report of validate, push and tap, the push status
line, the tap summary, and check-readiness. The command exits non-zero
and says whether the action it reports on already happened. A closed
pipe ends the process with SIGPIPE, as for other Unix tools.
- backport-batch writes its output before it pushes or publishes. Once a
write to stdout or stderr fails, the run changes nothing more: no push,
no GitHub write, no local branch move, and no new pick. A pick already
in flight still finishes its rollback. The run exits 2, and it catches
SIGPIPE, so a closed pipe is handled the same way. A confirmation
printed after an action is lost only when stderr itself fails, so a lost
confirmation can only be reported by the exit code.
- The SSE server drops a client as soon as a write to it fails. A stream
still open at shutdown no longer panics on a double close, the handler
waits for its pump before returning, and a stream that opens during
shutdown gets 503.
- The kube-ovn plunger now fails its manager when the status server
cannot bind :18080, as a metrics server bind failure does. Before, it
ran without the endpoint and logged nothing.
- A timed-out check-readiness --wait still ends with its verdict, and
the help lists the exit statuses.

The 37 findings left are SA1019 deprecations, kept out of this PR on
purpose:

- GetEventRecorderFor (12, in cmd/*/main.go). The events.k8s.io recorder
has a different interface and needs RBAC for that API group. It changes
what events look like, so it needs its own design.
- client.Apply (12, one more site arrived from main). Moving to
Client.Apply with apply configurations changes how every server-side
apply call is built and how the fake client in tests handles it. It
overlaps the dependency rollup in #4869 and should come after it.
- Result.Requeue (10). Requeue retries with rate-limited backoff,
RequeueAfter with a fixed delay. The interval has to come from whoever
owns each controller.
- scheme.Builder (3, in api/*). Replacing it changes the type of the
exported SchemeBuilder that other repositories import.
- cel.Functions (1, in pkg/reservation). It stays for its late binding,
as the comment next to it explains.

Each behaviour change has tests that failed before the fix. I ran go
test on every changed package (for cmd/backport-batch, the tests around
output and publishing, since the full package takes about ten minutes),
go build ./..., go vet on the changed packages, and a final
golangci-lint run with uncapped output on the rebased tree:
`golangci-lint run --verbose --max-same-issues=0
--max-issues-per-linter=0`, which reports the 38 findings above and
nothing else.

The tests in pkg/lineage, pkg/ovnstatus, pkg/reservation, cmd/cozypkg
and cmd/check-readiness now run in CI: a separate commit adds those
packages to go-unit-tests. Some packages with tests are still in no CI
target: cmd/cozystack-controller, cmd/cozystack-operator,
cmd/observability-proxy, pkg/apiserver, pkg/apis/apps/defaulting,
pkg/apis/apps/install, pkg/apis/apps/presets, pkg/apis/apps/validation,
pkg/apis/core/install, pkg/apis/sdn/install and pkg/version. That
predates this PR.

One known nit: when backport-batch refuses an action after its output
was lost, stderr can show two "output was lost" lines.

### Screenshots

No UI change.

### Downstream repositories

I walked the trigger map against the diff. cozypkg counts as developer
tooling, but only its error paths changed, not a flag, its usage or its
output format, so the development page needs no update. Telemetry metric
names and labels are unchanged.

- [x] No downstream repository is affected by this change
- [ ] [cozystack/website](https://github.com/cozystack/website) -
follow-up:
- [ ]
[cozystack/terraform-provider-cozystack](https://github.com/cozystack/terraform-provider-cozystack)
- follow-up:
- [ ]
[cozystack/ansible-cozystack](https://github.com/cozystack/ansible-cozystack)
- follow-up:
- [ ] [cozystack/ccp](https://github.com/cozystack/ccp) - follow-up:
- [ ] [cozystack/talm](https://github.com/cozystack/talm) - follow-up:
- [ ] [cozystack/cozyhr](https://github.com/cozystack/cozyhr) -
follow-up:
- [ ] [cozystack/cozy-proxy](https://github.com/cozystack/cozy-proxy) -
follow-up:
- [ ]
[cozystack/cozystack-telemetry-server](https://github.com/cozystack/cozystack-telemetry-server)
- follow-up:
- [ ]
[cozystack/external-apps-example](https://github.com/cozystack/external-apps-example)
- follow-up:
- [ ] [cozystack/examples](https://github.com/cozystack/examples) -
follow-up:
- [ ] [cozystack/community](https://github.com/cozystack/community) -
follow-up:

### Release note

```release-note
chore: cozypkg, check-readiness and backport-batch now fail when their output cannot be written, and backport-batch pushes and publishes nothing once that happens. The kube-ovn plunger fails when its status server cannot start, drops status clients whose writes fail, and no longer panics when it shuts down with a client connected.
```


<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
<!-- coderabbit-ai-generated:v1 -->

## Summary by CodeRabbit

* **Bug Fixes**
* Commands now report output failures instead of silently succeeding.
Backport operations stop before further external changes when required
output cannot be written; readiness checks return a failure status when
output writing fails.
* Package listings, validation reports, push status messages, and tap
summaries now report output errors. Tap commands indicate when changes
were applied before a summary could be written.
* Live event streams handle failed writes and shutdown more reliably,
and status-server startup errors are reported.

* **Documentation**
* Readiness-check help now explains exit statuses and closed-pipe
behavior.

* **Improvements**
* Error messages for several backup and inventory operations now provide
clearer context.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
This commit is contained in:
Aleksei Sviridkin authored and GitHub committed 2026-11-13 16:44:32 +03:00
commit f12300943d
72 files changed
+1681 -350

No files matched your search

+10 -10
View File
@@ -139,13 +139,14 @@ rd-presets-check:
migrations-target-check:
hack/check-migrations-target.sh
# Scoped go test over the cozystack-api surface that this repo owns. Kept
# narrow intentionally - running `go test ./...` pulls in generated code
# round-trip suites whose behavior depends on tool versions outside this
# repo's control (kubebuilder, openapi-gen, etc.) and is better exercised
# from their generator workflows.
# Go tests of the cozystack-api surface and of the standalone packages and
# commands listed here, whose tests need no cluster. Kept narrow
# intentionally - running `go test ./...` pulls in generated code round-trip
# suites whose behavior depends on tool versions outside this repo's control
# (kubebuilder, openapi-gen, etc.) and is better exercised from their
# generator workflows.
go-unit-tests:
go test ./pkg/registry/... ./pkg/config/... ./pkg/cmd/server/...
go test ./pkg/registry/... ./pkg/config/... ./pkg/cmd/server/... ./pkg/lineage/... ./pkg/ovnstatus/... ./pkg/reservation/... ./cmd/cozypkg/... ./cmd/check-readiness/...
# The nested Go modules (image sources and the published API types) are
# outside ./... of the root module, so no other target reaches their tests.
@@ -158,9 +159,7 @@ go-module-tests:
done
# Go tests for the controllers and supporting packages under ./internal.
# Excludes ./pkg/... and ./cmd/... — those are run separately by
# go-unit-tests above (pkg subset) and skipped (cmd) until their tests
# stabilise. CI schedules this target in the same four-slot make invocation as
# CI schedules this target in the same four-slot make invocation as
# unit-tests; locally invoke it directly or chain the two targets.
test-controllers:
go test ./internal/... -count=1
@@ -195,7 +194,8 @@ test-controllers-envtest: $(SETUP_ENVTEST)
test-check-readiness:
go test ./test/check-readiness/ -count=1
# ./cmd/... is excluded from go-unit-tests, so the batch tool needs its own target.
# The batch tool's suite drives real git repositories for minutes, so it is
# kept out of go-unit-tests in a target of its own.
test-backport-batch:
go test ./cmd/backport-batch/... -count=1
+2
View File
@@ -27,6 +27,8 @@ Requires `git` and an authenticated `gh` on PATH, and a remote called `origin`.
Build the binary wherever an exit code matters: `go run` turns any non-zero exit into its own `1`, so under it a check that could not be completed looks the same as one that found something missing.
Output is written before a push or a publish. Once a write to stdout or stderr fails, a closed pipe included, the run changes nothing more: no push, no GitHub write, no local branch move, and no new pick; a pick already in flight still finishes its rollback. It exits 2 where it would have exited 0, saying on stderr, while it still can, that the output was lost. A confirmation lost after a push or a publish fails the run the same way.
### run
Switches the current working tree to `backport-batch/<line>-<yyyymmdd>`, created at `origin/<line>`, and picks onto it one original at a time, in the order they merged into `main`, as one unit each on the branch's first-parent line. A pull request merged into `main` with a merge commit `M` goes on as its own commits, `git rev-list --reverse --topo-order --no-merges M^1..M^2`, each picked with `git cherry-pick -x --signoff`, so each keeps its author, message and sign-offs and gains the `(cherry picked from commit …)` line; the merges that brought `main` into its branch are left out, since `main` already has what they brought. A merge commit then joins the picks to the batch: its first parent is the batch before the original, its second the last pick, and its message is `M`'s with a paragraph of its own, `Backported-from: M`. A pull request squash-merged into `main` goes on as one pick. When any commit of an original conflicts, the pick is aborted, the branch goes back to where it was before that original, and the original is recorded with the commit that failed and its files; the run goes on with the next one. A commit the branch already carries is skipped as empty, and an original none of whose commits changes anything is reported as carried. The tree has to be clean. A local branch of that name is reset to where the run starts; when that drops commits only it has, the run first prints its tip and the `git branch` command that restores them, and so does `--defer`. Signing follows your git configuration; hooks are off for the picks and the merge, so each commit carries its message as git writes it.
+1 -1
View File
@@ -99,7 +99,7 @@ func apiSnapshot(commit string) (apigate.Snapshot, error) {
if err != nil {
return nil, err
}
defer os.RemoveAll(dir)
defer func() { _ = os.RemoveAll(dir) }()
for name, blob := range paths {
file := filepath.Join(dir, filepath.FromSlash(name))
if err := os.MkdirAll(filepath.Dir(file), 0o700); err != nil {
+28 -15
View File
@@ -153,7 +153,7 @@ func (a *app) run(args []string) int {
}
// The scheduled job has half an hour for every line; this says where it
// goes.
fmt.Fprintf(a.stderr, "prepared %s in %s, %s of it judging partial units and what originals build on\n", l.branch(), time.Since(started).Round(time.Millisecond), b.detecting.Round(time.Millisecond))
_, _ = fmt.Fprintf(a.stderr, "prepared %s in %s, %s of it judging partial units and what originals build on\n", l.branch(), time.Since(started).Round(time.Millisecond), b.detecting.Round(time.Millisecond))
if drops != nil {
return a.redrop(b, drops, reason, *undropArg != "", *push)
}
@@ -273,7 +273,7 @@ func (a *app) run(args []string) int {
continue
}
}
p, err := pickOriginal(v, func(base, head string) ([]string, error) {
p, err := a.pickUnit(v, func(base, head string) ([]string, error) {
omitted, diag, err := b.omittedEffects(v, base, head)
v.addDiag(diag...)
return omitted, err
@@ -449,20 +449,20 @@ func (a *app) finish(b *batch, r *report, branch string, date time.Time, push, r
}
body, left := r.body(template)
p.body = body
fmt.Fprint(a.stdout, body)
_, _ = fmt.Fprint(a.stdout, body)
skipped := 0
for _, items := range r.skipped {
skipped += len(items)
}
for _, rule := range left {
for _, v := range r.skipped[rule] {
fmt.Fprintf(a.stderr, "skipped by %s: %s %s (%s)\n", ruleName(rule), v.o.url(), terminalSafe(v.o.title), terminalSafe(v.reason))
_, _ = fmt.Fprintf(a.stderr, "skipped by %s: %s %s (%s)\n", ruleName(rule), v.o.url(), terminalSafe(v.o.title), terminalSafe(v.reason))
}
}
for _, p := range r.waiting {
fmt.Fprintf(a.stderr, "waiting for a maintainer: %s %s changes %s\n", p.v.o.url(), terminalSafe(p.v.o.title), terminalSafe(strings.Join(p.files, ", ")))
_, _ = fmt.Fprintf(a.stderr, "waiting for a maintainer: %s %s changes %s\n", p.v.o.url(), terminalSafe(p.v.o.title), terminalSafe(strings.Join(p.files, ", ")))
}
fmt.Fprintf(a.stderr, "%s at %.12s: %d on the branch, %d deferred, %d waiting for a maintainer, %d skipped\ntitle: %s\nreport: %s\n",
_, _ = fmt.Fprintf(a.stderr, "%s at %.12s: %d on the branch, %d deferred, %d waiting for a maintainer, %d skipped\ntitle: %s\nreport: %s\n",
branch, head, len(r.onBranch), len(r.deferred)+len(r.held), len(r.waiting), skipped, p.title, doc.ID)
if !push {
return 0
@@ -471,8 +471,8 @@ func (a *app) finish(b *batch, r *report, branch string, date time.Time, push, r
// Picking nothing is not a failure of the run; check still reports
// whatever the line lacks. Merged and closed batches are never
// written, so there is nowhere to keep what the run found.
fmt.Fprintf(a.stderr, "%s carries nothing beyond %s; nothing to push\n", branch, b.line.branch())
fmt.Fprintf(a.stderr, "no batch pull request is open on %s; this run's classification is not retained\n", b.line.branch())
_, _ = fmt.Fprintf(a.stderr, "%s carries nothing beyond %s; nothing to push\n", branch, b.line.branch())
_, _ = fmt.Fprintf(a.stderr, "no batch pull request is open on %s; this run's classification is not retained\n", b.line.branch())
return 0
}
if err := a.publish(b, p, rebuilt); err != nil {
@@ -529,6 +529,9 @@ func cleanTree() error {
// the move drops commits of and how to get them back: a clean tree says
// nothing about commits only a local branch has.
func (a *app) warnReset(branch, start string) error {
if err := a.mayAct(); err != nil {
return err
}
old, err := lookup("refs/heads/" + branch)
if err != nil || old == "" || old == start {
return err
@@ -537,7 +540,11 @@ func (a *app) warnReset(branch, start string) error {
if err != nil || kept {
return err
}
fmt.Fprintf(a.stderr, "resetting the local %s from %s, dropping commits %.12s does not carry; git branch %s-%.12s %s restores them\n", branch, old, start, branch, old, old)
// The hint is the only way back to the dropped commits, so the reset does
// not run when it could not be written.
if _, err := fmt.Fprintf(a.stderr, "resetting the local %s from %s, dropping commits %.12s does not carry; git branch %s-%.12s %s restores them\n", branch, old, start, branch, old, old); err != nil {
return fmt.Errorf("not resetting the local %s: %w", branch, err)
}
return nil
}
@@ -719,6 +726,9 @@ func (a *app) publish(b *batch, p publication, rebuilt bool) error {
}
}
if pushed != p.head {
if err := a.mayAct(); err != nil {
return err
}
if _, err := git(pushArgs(p.branch, p.head, lease)...); err != nil {
return err
}
@@ -727,13 +737,13 @@ func (a *app) publish(b *batch, p publication, rebuilt bool) error {
if err != nil {
return err
}
defer os.Remove(name)
defer func() { _ = os.Remove(name) }()
if b.pr == nil {
n, url, err := a.gh.createPull(b.line.branch(), p.branch, p.title, name)
if err != nil {
return err
}
fmt.Fprintf(a.stderr, "opened draft %s\n", url)
_, _ = fmt.Fprintf(a.stderr, "opened draft %s\n", url)
if err := a.postReport(n, p.report); err != nil {
return fmt.Errorf("posting report %.12s on #%d: %w; the body keeps it, and the next run --push posts it", p.report.doc.ID, n, err)
}
@@ -745,7 +755,7 @@ func (a *app) publish(b *batch, p publication, rebuilt bool) error {
if err := a.gh.editPull(b.pr.Number, p.title, name); err != nil {
return err
}
fmt.Fprintf(a.stderr, "updated %s\n", pullURL(b.pr))
_, _ = fmt.Fprintf(a.stderr, "updated %s\n", pullURL(b.pr))
return nil
}
@@ -828,7 +838,7 @@ func (a *app) closeBatch(b *batch, p publication) error {
if err != nil {
return err
}
defer os.Remove(name)
defer func() { _ = os.Remove(name) }()
if err := a.stillOpen(c.PR); err != nil {
return err
}
@@ -861,7 +871,7 @@ func (a *app) finishClose(l line, url string, c closing) error {
if err := a.deleteBranch(l, c); err != nil {
return err
}
fmt.Fprintf(a.stderr, "closed %s: without what is deferred it carries nothing beyond %s; the next batch tries them again\n", url, l.branch())
_, _ = fmt.Fprintf(a.stderr, "closed %s: without what is deferred it carries nothing beyond %s; the next batch tries them again\n", url, l.branch())
return nil
}
@@ -878,6 +888,9 @@ func (a *app) deleteBranch(l line, c closing) error {
case h != c.Head:
return movedBranch(c, h)
}
if err := a.mayAct(); err != nil {
return err
}
if _, err := git(deleteArgs(c.Branch, c.Head)...); err != nil {
return fmt.Errorf("deleting %s, left by the close of #%d: %w; backport-batch run --line %s --push deletes it", c.Branch, c.PR, err, l.branch())
}
@@ -933,7 +946,7 @@ func (a *app) resumeClose(b *batch, push, changing bool) (bool, int) {
if err := a.deleteBranch(b.line, c); err != nil {
return false, a.fail(err)
}
fmt.Fprintf(a.stderr, "deleted %s, which the close of #%d left\n", c.Branch, c.PR)
_, _ = fmt.Fprintf(a.stderr, "deleted %s, which the close of #%d left\n", c.Branch, c.PR)
return false, a.finished(c, changing)
}
+8 -8
View File
@@ -73,14 +73,14 @@ func (a *app) check(args []string) int {
case d.kind == outcomeWarning:
a.warn("%s", d.text)
case d.kind == outcomeNote:
fmt.Fprintf(a.stderr, "note: %s\n", d.text)
_, _ = fmt.Fprintf(a.stderr, "note: %s\n", d.text)
}
}
if len(missing)+len(failing) == 0 {
if *cut {
fmt.Fprintf(a.stdout, "%s: no change the policy takes is missing before the cut\n", l.branch())
_, _ = fmt.Fprintf(a.stdout, "%s: no change the policy takes is missing before the cut\n", l.branch())
} else {
fmt.Fprintf(a.stdout, "%s: every change the policy takes is on the line or on the batch\n", l.branch())
_, _ = fmt.Fprintf(a.stdout, "%s: every change the policy takes is on the line or on the batch\n", l.branch())
}
return 0
}
@@ -89,13 +89,13 @@ func (a *app) check(args []string) int {
where = "nor on batch pull request #" + strconv.Itoa(b.pr.Number)
}
if len(missing) > 0 {
fmt.Fprintf(a.stdout, "%s: %d changes the policy takes are not on the line, %s:\n", l.branch(), len(missing), where)
_, _ = fmt.Fprintf(a.stdout, "%s: %d changes the policy takes are not on the line, %s:\n", l.branch(), len(missing), where)
for _, text := range missing {
fmt.Fprintf(a.stdout, " %s\n", text)
_, _ = fmt.Fprintf(a.stdout, " %s\n", text)
}
}
for _, text := range failing {
fmt.Fprintf(a.stdout, "%s: %s\n", l.branch(), text)
_, _ = fmt.Fprintf(a.stdout, "%s: %s\n", l.branch(), text)
}
return 1
}
@@ -326,10 +326,10 @@ func (a *app) fold(args []string) int {
return a.fail(err)
}
if why != "" {
fmt.Fprintf(a.stdout, "refused: %s\n", why)
_, _ = fmt.Fprintf(a.stdout, "refused: %s\n", why)
return 1
}
fmt.Fprintln(a.stdout, "ok")
_, _ = fmt.Fprintln(a.stdout, "ok")
return 0
}
+1 -1
View File
@@ -102,7 +102,7 @@ func (a *app) reassemble(b *batch, out, hold map[int]string, drops []droppedEntr
return a.fail(err)
}
for _, u := range replay {
failed, files, err := replayUnit(u)
failed, files, err := a.replayNext(u)
switch {
case err != nil:
return a.fail(err)
+1 -1
View File
@@ -367,7 +367,7 @@ func (b *batch) alreadyApplied(pre, cur, post string) (applied, unsupported bool
if err != nil {
return false, false, err
}
defer os.RemoveAll(dir)
defer func() { _ = os.RemoveAll(dir) }()
names := map[string]string{}
for _, f := range []struct{ name, oid string }{{"cur", cur}, {"pre", pre}, {"post", post}} {
names[f.name] = filepath.Join(dir, f.name)
+2 -2
View File
@@ -53,7 +53,7 @@ func emptyBatch(f *fixture, gh *fakeGH, body string) *foldWorld {
// and every check of the batch's shape takes the old name as the same file:
// verify, a hand fold, and a rebuild by --defer.
func TestRenamePickThroughFoldAndVerify(t *testing.T) {
f, mc5 := renameWorld(t)
f, _ := renameWorld(t)
f.pr(6, "fix(app): six", "", map[string]string{"app/six.txt": "6\n"})
gh := &fakeGH{}
head := openBatch(t, f, gh)
@@ -74,7 +74,7 @@ func TestRenamePickThroughFoldAndVerify(t *testing.T) {
t.Errorf("verify after the rebuild = %d\n%s\n%s", code, out, stderr)
}
f, mc5 = renameWorld(t)
f, mc5 := renameWorld(t)
w := emptyBatch(f, &fakeGH{}, "")
pick := w.pick(w.head, f.git("rev-parse", mc5+"^2"), map[string]string{"app/old.txt": strings.Replace(appFile, "three", "THREE", 1)})
fold := w.merge(w.head, pick, "fix(app): fix the app file (#5)\n\n"+batchTrailer+": "+mc5)
-9
View File
@@ -522,15 +522,6 @@ func (f *fixture) batchPR(n int, base, branch, body string) pullRequest {
return pr
}
// botBatchPR is batchPR opened by the bot the scheduled batch runs as.
func (f *fixture) botBatchPR(gh *fakeGH, n int, base, branch, body string) pullRequest {
f.t.Helper()
gh.bot = defaultBatchBot
pr := f.batchPR(n, base, branch, body)
pr.User.Login, pr.User.Type, pr.AuthorAssociation = defaultBatchBot, "Bot", "CONTRIBUTOR"
return pr
}
// mergeBatch merges the open batch into release-1.1 with a merge commit, as
// GitHub does, and deletes its branch, as the repository's
// delete_branch_on_merge does. The pull request stays, merged, with its body
+48
View File
@@ -137,6 +137,54 @@ type github interface {
batchBot() string
}
// guardedGitHub refuses every GitHub write once the run's output was lost.
type guardedGitHub struct {
github
a *app
}
func (g guardedGitHub) createPull(base, head, title, bodyFile string) (int, string, error) {
if err := g.a.mayAct(); err != nil {
return 0, "", err
}
return g.github.createPull(base, head, title, bodyFile)
}
func (g guardedGitHub) editPull(number int, title, bodyFile string) error {
if err := g.a.mayAct(); err != nil {
return err
}
return g.github.editPull(number, title, bodyFile)
}
func (g guardedGitHub) editBody(number int, bodyFile string) error {
if err := g.a.mayAct(); err != nil {
return err
}
return g.github.editBody(number, bodyFile)
}
func (g guardedGitHub) closePull(number int) error {
if err := g.a.mayAct(); err != nil {
return err
}
return g.github.closePull(number)
}
func (g guardedGitHub) createComment(number int, bodyFile string) error {
if err := g.a.mayAct(); err != nil {
return err
}
return g.github.createComment(number, bodyFile)
}
func (g guardedGitHub) editComment(id int64, bodyFile string) error {
if err := g.a.mayAct(); err != nil {
return err
}
return g.github.editComment(id, bodyFile)
}
type ghCLI struct{ bot string }
func (g ghCLI) batchBot() string { return g.bot }
+3 -3
View File
@@ -142,11 +142,11 @@ func TestOptionInjection(t *testing.T) {
// no bidi override reorders it and no zero-width character hides in it.
func TestDeferredBlockCleansFileNames(t *testing.T) {
l, _ := parseLine("release-1.6")
files := []string{"app/‮txt.exe", "app/zero​width.yaml"}
files := []string{"app/\u202etxt.exe", "app/zero\u200bwidth.yaml"}
conflict := pick{v: &verdict{o: &original{number: 5}}, files: files, failed: strings.Repeat("a", 40)}
waiting := pick{v: &verdict{o: &original{number: 6}}, files: files}
block := deferredBlock(l, []pick{conflict}, nil, []pick{waiting})
if strings.ContainsAny(block, "‮​") {
if strings.ContainsAny(block, "\u202e\u200b") {
t.Errorf("the block carries format characters: %q", block)
}
want := []string{"app/txt.exe", "app/zerowidth.yaml"}
@@ -154,7 +154,7 @@ func TestDeferredBlockCleansFileNames(t *testing.T) {
if err != nil || !slices.Equal(got[5].Files, want) || !slices.Equal(got[6].Files, want) {
t.Errorf("parseDeferred = %+v, %v; want both originals with %q", got, err, want)
}
if files[0] != "app/‮txt.exe" {
if files[0] != "app/\u202etxt.exe" {
t.Errorf("deferredBlock rewrote the pick's own file names: %q", files)
}
}
+52 -9
View File
@@ -24,7 +24,9 @@ import (
"fmt"
"io"
"os"
"os/signal"
"strings"
"syscall"
"time"
)
@@ -111,18 +113,42 @@ type app struct {
policyRef string
// tool is the commit backport-batch was built from, for the record.
tool string
// unwritten is the first error writing to stdout or stderr. Output goes
// out before a push or a publish, so a run that lost it acts on nothing,
// and one that lost a confirmation afterwards fails.
unwritten error
}
func main() {
catchSIGPIPE()
a := &app{gh: ghCLI{bot: batchBotLogin(os.LookupEnv)}, stdout: os.Stdout, stderr: os.Stderr, now: time.Now, tool: toolVersion()}
os.Exit(a.main(os.Args[1:]))
}
// catchSIGPIPE makes a write to a closed stdout or stderr fail with EPIPE like
// any other write, so the run stops before it pushes or publishes and says
// why, instead of dying silently. signal.Ignore would do the same here but
// would also leave SIGPIPE ignored in the git and gh children, across exec.
func catchSIGPIPE() {
signal.Notify(make(chan os.Signal, 1), syscall.SIGPIPE)
}
func (a *app) main(args []string) int {
a.stdout, a.stderr = textWriter{a.stdout}, textWriter{a.stderr}
a.gh = &permCache{github: a.gh, perms: map[string]string{}}
a.stdout, a.stderr = textWriter{w: a.stdout, failed: &a.unwritten}, textWriter{w: a.stderr, failed: &a.unwritten}
code := a.command(args)
if a.unwritten != nil {
_, _ = fmt.Fprintf(a.stderr, "backport-batch: output was lost: %v\n", a.unwritten)
if code == 0 {
code = 2
}
}
return code
}
func (a *app) command(args []string) int {
a.gh = guardedGitHub{github: &permCache{github: a.gh, perms: map[string]string{}}, a: a}
if len(args) == 0 {
fmt.Fprint(a.stderr, usageText)
_, _ = fmt.Fprint(a.stderr, usageText)
return 2
}
if bot := a.gh.batchBot(); bot != "" && !botLoginRE.MatchString(bot) {
@@ -144,20 +170,26 @@ func (a *app) main(args []string) int {
case "lines":
return a.lines(args[1:])
case "-h", "--help", "help":
fmt.Fprint(a.stdout, usageText)
_, _ = fmt.Fprint(a.stdout, usageText)
return 0
}
fmt.Fprintf(a.stderr, "unknown command %q\n\n%s", args[0], usageText)
_, _ = fmt.Fprintf(a.stderr, "unknown command %q\n\n%s", args[0], usageText)
return 2
}
// textWriter keeps output fit for a terminal. Titles, file names and the
// messages git relays come from other people, and a control sequence among
// them would move the cursor or rewrite what was printed before.
type textWriter struct{ w io.Writer }
type textWriter struct {
w io.Writer
failed *error
}
func (t textWriter) Write(p []byte) (int, error) {
if _, err := io.WriteString(t.w, clean(string(p), true)); err != nil {
if t.failed != nil && *t.failed == nil {
*t.failed = err
}
return 0, err
}
return len(p), nil
@@ -166,7 +198,7 @@ func (t textWriter) Write(p []byte) (int, error) {
func (a *app) flags(name string) *flag.FlagSet {
fs := flag.NewFlagSet(name, flag.ContinueOnError)
fs.SetOutput(a.stderr)
fs.Usage = func() { fmt.Fprint(a.stderr, usageText) }
fs.Usage = func() { _, _ = fmt.Fprint(a.stderr, usageText) }
return fs
}
@@ -188,13 +220,24 @@ func parse(fs *flag.FlagSet, args []string) error {
return nil
}
// mayAct refuses any further change once output was lost: the run would act
// on what it printed while nobody read it. Every push and every move of a
// local batch branch go through it, and every GitHub write through
// guardedGitHub.
func (a *app) mayAct() error {
if a.unwritten != nil {
return fmt.Errorf("output was lost: %w; nothing more is pushed or written to GitHub", a.unwritten)
}
return nil
}
func (a *app) fail(err error) int {
fmt.Fprintf(a.stderr, "backport-batch: %v\n", err)
_, _ = fmt.Fprintf(a.stderr, "backport-batch: %v\n", err)
return 2
}
func (a *app) warn(format string, args ...any) {
fmt.Fprintf(a.stderr, "warning: "+format+"\n", args...)
_, _ = fmt.Fprintf(a.stderr, "warning: "+format+"\n", args...)
}
// verdict is what the policy says about one original for the line.
+16 -16
View File
@@ -102,10 +102,10 @@ func (a *app) notify(args []string) int {
var conflicts, waiting []int
after := map[int][]int{}
for n, e := range deferred {
switch place := placement(deferred, n, map[int]bool{}); {
case place == "workflow":
switch placement(deferred, n, map[int]bool{}) {
case "workflow":
waiting = append(waiting, n)
case place == "conflict":
case "conflict":
conflicts = append(conflicts, n)
}
if len(e.Needs) > 0 {
@@ -135,11 +135,11 @@ func (a *app) notify(args []string) int {
stalled := days >= stalledAfter
var text []string
if stalled {
fmt.Fprintf(a.stdout, "%s: batch pull request #%d has been open since %s, %d days\n", l.branch(), pr.Number, opened.Format(time.DateOnly), days)
_, _ = fmt.Fprintf(a.stdout, "%s: batch pull request #%d has been open since %s, %d days\n", l.branch(), pr.Number, opened.Format(time.DateOnly), days)
text = append(text, fmt.Sprintf("This batch has been open since %s, %d days, through at least one scheduled run. Merge it, or close it and the next run starts a new one; until then each run adds what the rules take to it.", opened.Format(time.DateOnly), days))
}
if len(partial) > 0 {
fmt.Fprintf(a.stdout, "%s: %d units on #%d carry only part of their originals\n", l.branch(), len(partial), pr.Number)
_, _ = fmt.Fprintf(a.stdout, "%s: %d units on #%d carry only part of their originals\n", l.branch(), len(partial), pr.Number)
var b strings.Builder
b.WriteString("These are on the batch but carry only part of their originals on this line; take each out with `backport-batch run --defer` before the cut, and port what applies as a pull request of its own:\n")
for _, n := range partial {
@@ -148,7 +148,7 @@ func (a *app) notify(args []string) int {
text = append(text, b.String())
}
if len(conflicts) > 0 {
fmt.Fprintf(a.stdout, "%s: %d deferred conflicts on #%d wait for a maintainer\n", l.branch(), count(conflicts), pr.Number)
_, _ = fmt.Fprintf(a.stdout, "%s: %d deferred conflicts on #%d wait for a maintainer\n", l.branch(), count(conflicts), pr.Number)
var b strings.Builder
fmt.Fprintf(&b, "These conflicts wait for a maintainer, as [resolving a conflict](%sresolve-conflict.md) describes; unresolved, each goes to the next batch, and so does what waits on one:\n", tasksURL)
for _, n := range conflicts {
@@ -158,9 +158,9 @@ func (a *app) notify(args []string) int {
}
if len(waiting) > 0 {
if count(waiting) == len(waiting) {
fmt.Fprintf(a.stdout, "%s: %d originals on #%d change %s and wait for a maintainer\n", l.branch(), len(waiting), pr.Number, workflowsDir)
_, _ = fmt.Fprintf(a.stdout, "%s: %d originals on #%d change %s and wait for a maintainer\n", l.branch(), len(waiting), pr.Number, workflowsDir)
} else {
fmt.Fprintf(a.stdout, "%s: %d originals on #%d change %s or wait on one that does\n", l.branch(), len(waiting), pr.Number, workflowsDir)
_, _ = fmt.Fprintf(a.stdout, "%s: %d originals on #%d change %s or wait on one that does\n", l.branch(), len(waiting), pr.Number, workflowsDir)
}
var b strings.Builder
fmt.Fprintf(&b, "These change `%s`, which the batch's token may not push, and wait for a maintainer to bring them over, as [changes to workflows](%s#changes-to-workflows) describes, or wait on one that does:\n", workflowsDir, policyURL)
@@ -170,7 +170,7 @@ func (a *app) notify(args []string) int {
text = append(text, b.String())
}
if len(parks) > 0 {
fmt.Fprintf(a.stdout, "%s: %d parked originals on #%d, named once\n", l.branch(), len(parks), pr.Number)
_, _ = fmt.Fprintf(a.stdout, "%s: %d parked originals on #%d, named once\n", l.branch(), len(parks), pr.Number)
var b strings.Builder
fmt.Fprintf(&b, "These cannot land on this line whole, so the batch parked them; each is named here once. A maintainer ports what applies as a pull request of its own, as [fixes that exist only on a release line](%s#fixes-that-exist-only-on-a-release-line) describes, or drops the original with `backport-batch run --drop`:\n", policyURL)
for _, p := range parks {
@@ -229,7 +229,7 @@ func (a *app) announced(pr *pullRequest, rec *lineRecord, parks []parkedEntry) e
if err != nil {
return err
}
defer os.Remove(name)
defer func() { _ = os.Remove(name) }()
return a.gh.editBody(pr.Number, name)
}
@@ -259,10 +259,10 @@ func placement(deferred map[int]deferredEntry, n int, seen map[int]bool) string
seen[n] = true
place := ""
for _, f := range e.Needs {
switch p := placement(deferred, f, seen); {
case p == "workflow":
switch p := placement(deferred, f, seen); p {
case "workflow":
return p
case p == "conflict":
case "conflict":
place = p
}
}
@@ -309,9 +309,9 @@ func (a *app) comment(pr *pullRequest, mention string, today time.Time, text []s
if err != nil {
return a.fail(err)
}
defer os.Remove(f.Name())
defer func() { _ = os.Remove(f.Name()) }()
if _, err := f.WriteString(b.String()); err != nil {
f.Close()
_ = f.Close()
return a.fail(err)
}
if err := f.Close(); err != nil {
@@ -354,7 +354,7 @@ func (a *app) lines(args []string) int {
return a.fail(err)
}
for _, l := range slices.Backward(lines) {
fmt.Fprintln(a.stdout, l.branch())
_, _ = fmt.Fprintln(a.stdout, l.branch())
}
return 0
}
+2 -2
View File
@@ -41,12 +41,12 @@ func TestOntoContinues(t *testing.T) {
f.lines()
head := pushed(t, f)
f.pr(6, "fix(app): six", "", map[string]string{"app/six.txt": "6\n"})
code, stdout, stderr := f.exec(&fakeGH{}, "run", "--line", "release-1.1", "--onto", head, "--date", "2026-10-29")
code, _, stderr := f.exec(&fakeGH{}, "run", "--line", "release-1.1", "--onto", head, "--date", "2026-10-29")
if code != 2 || !strings.Contains(stderr, "not the head of backport-batch/release-1.1-20261029") {
t.Errorf("--onto with another date = %d (%s), want a refusal", code, stderr)
}
f.now = f.now.AddDate(0, 0, 3)
code, stdout, stderr = f.exec(&fakeGH{}, "run", "--line", "release-1.1", "--onto", head)
code, stdout, stderr := f.exec(&fakeGH{}, "run", "--line", "release-1.1", "--onto", head)
if code != 0 {
t.Fatalf("run --onto = %d\n%s", code, stderr)
}
+385
View File
@@ -0,0 +1,385 @@
/*
Copyright 2026 The Cozystack Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package main
import (
"errors"
"io"
"os"
"os/exec"
"reflect"
"strings"
"testing"
"time"
)
type failingWriter struct{}
func (failingWriter) Write([]byte) (int, error) { return 0, errors.New("broken pipe") }
// Output that never reached its reader fails the command, and stderr says why.
func TestUnwritableOutputFailsTheCommand(t *testing.T) {
var stderr strings.Builder
a := &app{gh: &fakeGH{}, stdout: failingWriter{}, stderr: &stderr}
if code := a.main([]string{"help"}); code != 2 {
t.Fatalf("help with an unwritable stdout = %d, want 2", code)
}
if !strings.Contains(stderr.String(), "broken pipe") {
t.Errorf("stderr does not name the write failure:\n%s", stderr.String())
}
}
// A command that already failed keeps its own exit code when its output is
// lost as well: check still says something is missing.
func TestUnwritableOutputKeepsTheCommandsFailure(t *testing.T) {
f := newFixture(t)
f.lines()
f.pr(6, "fix(app): six", "", map[string]string{"app/six.txt": "6\n"})
var stderr strings.Builder
a := &app{gh: &fakeGH{remoteHead: f.remoteHead}, stdout: failingWriter{}, stderr: &stderr, now: func() time.Time { return f.now }, tool: f.tool}
if code := a.main([]string{"check", "--line", "release-1.1"}); code != 1 {
t.Fatalf("check with #6 missing and an unwritable stdout = %d, want 1\n%s", code, stderr.String())
}
if !strings.Contains(stderr.String(), "broken pipe") {
t.Errorf("stderr does not name the write failure:\n%s", stderr.String())
}
}
// A closed pipe on stdout does not kill the run before it can say what
// already happened: the write fails like any other, and the run exits 2.
func TestClosedStdoutPipeIsReported(t *testing.T) {
if os.Getenv("BACKPORT_BATCH_CLOSED_STDOUT_HELPER") == "1" {
os.Args = []string{"backport-batch", "help"}
main()
return
}
r, w, err := os.Pipe()
if err != nil {
t.Fatal(err)
}
_ = r.Close()
t.Cleanup(func() { _ = w.Close() })
cmd := exec.Command(os.Args[0], "-test.run=^TestClosedStdoutPipeIsReported$")
cmd.Env = append(os.Environ(), "BACKPORT_BATCH_CLOSED_STDOUT_HELPER=1")
var stderr strings.Builder
cmd.Stdout, cmd.Stderr = w, &stderr
err = cmd.Run()
var exit *exec.ExitError
if !errors.As(err, &exit) || exit.ExitCode() != 2 {
t.Fatalf("help into a closed pipe = %v, want exit 2\nstderr:\n%s", err, stderr.String())
}
if !strings.Contains(stderr.String(), "output was lost") {
t.Errorf("stderr does not say the output was lost:\n%s", stderr.String())
}
}
// failOn fails every write that contains want, and takes every other one.
type failOn struct {
want string
buf strings.Builder
}
func (w *failOn) Write(p []byte) (int, error) {
if strings.Contains(string(p), w.want) {
return 0, errors.New("broken pipe")
}
return w.buf.Write(p)
}
func runWith(f *fixture, gh *fakeGH, stdout, stderr io.Writer, args ...string) int {
f.t.Helper()
if gh.remoteHead == nil {
gh.remoteHead = f.remoteHead
}
a := &app{gh: gh, stdout: stdout, stderr: stderr, now: func() time.Time { return f.now }, tool: f.tool}
return a.main(args)
}
// Output is written before the push; when it is lost, on either stream,
// nothing is pushed and no pull request is opened.
func TestLostOutputPushesNothing(t *testing.T) {
for _, stream := range []string{"stdout", "stderr"} {
t.Run(stream, func(t *testing.T) {
f := newFixture(t)
f.lines()
f.pr(5, "fix(app): five", "", map[string]string{"app/five.txt": "5\n"})
gh := &fakeGH{}
var stdout, stderr io.Writer = &strings.Builder{}, &strings.Builder{}
if stream == "stdout" {
stdout = failingWriter{}
} else {
stderr = failingWriter{}
}
if code := runWith(f, gh, stdout, stderr, "run", "--line", "release-1.1", "--push"); code != 2 {
t.Fatalf("run --push with a failing %s = %d, want 2", stream, code)
}
if head := f.remoteHead(batchBranch1); head != "" {
t.Errorf("the batch was pushed at %.12s", head)
}
if len(gh.prs) != 0 {
t.Errorf("a pull request was opened: %+v", gh.prs)
}
})
}
}
// A confirmation lost after the push fails the run: the pull request was
// opened, and the run does not exit 0 without having said so.
func TestLostConfirmationFailsTheRun(t *testing.T) {
f := newFixture(t)
f.lines()
f.pr(5, "fix(app): five", "", map[string]string{"app/five.txt": "5\n"})
gh := &fakeGH{}
if code := runWith(f, gh, &strings.Builder{}, &failOn{want: "opened draft"}, "run", "--line", "release-1.1", "--push"); code != 2 {
t.Fatalf("run --push losing its confirmation = %d, want 2", code)
}
if len(gh.prs) != 1 {
t.Errorf("%d pull requests, want the one the run opened", len(gh.prs))
}
if len(gh.issueComments) != 0 {
t.Errorf("the report was posted after the confirmation was lost: %+v", gh.issueComments)
}
}
// notify writes what it found before it comments; when that is lost, it
// does not comment.
func TestLostOutputCommentsNothing(t *testing.T) {
gh := &fakeGH{prs: []pullRequest{notifyPR("20261019", "")}}
var stderr strings.Builder
a := &app{gh: gh, stdout: failingWriter{}, stderr: &stderr, now: func() time.Time { return time.Date(2026, 10, 26, 6, 23, 0, 0, time.UTC) }}
if code := a.main([]string{"notify", "--line", "release-1.1", "--push"}); code != 2 {
t.Fatalf("notify --push with a failing stdout = %d, want 2\n%s", code, stderr.String())
}
if len(gh.issueComments) != 0 {
t.Errorf("notify commented: %+v", gh.issueComments)
}
}
// writesGitHub records the GitHub writes that reach it.
type writesGitHub struct {
github
writes []string
}
func (g *writesGitHub) createPull(string, string, string, string) (int, string, error) {
g.writes = append(g.writes, "createPull")
return 1, "", nil
}
func (g *writesGitHub) editPull(int, string, string) error {
g.writes = append(g.writes, "editPull")
return nil
}
func (g *writesGitHub) editBody(int, string) error {
g.writes = append(g.writes, "editBody")
return nil
}
func (g *writesGitHub) closePull(int) error {
g.writes = append(g.writes, "closePull")
return nil
}
func (g *writesGitHub) createComment(int, string) error {
g.writes = append(g.writes, "createComment")
return nil
}
func (g *writesGitHub) editComment(int64, string) error {
g.writes = append(g.writes, "editComment")
return nil
}
// Every GitHub write is refused once output was lost. Every method of
// github is either a read or in this table, so a write added later without
// a guard fails here.
func TestEveryGitHubWriteIsGuarded(t *testing.T) {
reads := map[string]bool{"openPulls": true, "recentPulls": true, "permission": true, "labelled": true, "pull": true, "comments": true, "batchBot": true}
inner := &writesGitHub{}
g := guardedGitHub{github: inner, a: &app{unwritten: errors.New("broken pipe")}}
writes := map[string]func() error{
"createPull": func() error { _, _, err := g.createPull("b", "h", "t", "f"); return err },
"editPull": func() error { return g.editPull(1, "t", "f") },
"editBody": func() error { return g.editBody(1, "f") },
"closePull": func() error { return g.closePull(1) },
"createComment": func() error { return g.createComment(1, "f") },
"editComment": func() error { return g.editComment(1, "f") },
}
iface := reflect.TypeFor[github]()
for i := range iface.NumMethod() {
name := iface.Method(i).Name
if _, ok := writes[name]; !ok && !reads[name] {
t.Errorf("github.%s is neither a known read nor a guarded write", name)
}
}
for name, write := range writes {
if err := write(); err == nil || !strings.Contains(err.Error(), "output was lost") {
t.Errorf("%s with output lost = %v, want a refusal", name, err)
}
}
if len(inner.writes) != 0 {
t.Errorf("writes reached GitHub after output was lost: %q", inner.writes)
}
}
// A warning lost while the open batch is being updated stops the update:
// nothing is pushed, posted or edited.
func TestLostWarningLeavesTheOpenBatchAlone(t *testing.T) {
f := newFixture(t)
f.lines()
f.pr(5, "fix(app): five", "", map[string]string{"app/five.txt": "5\n"})
gh := &fakeGH{}
mustRun(t, f, gh, "run", "--line", "release-1.1", "--push")
f.pr(6, "fix(app): six", "", map[string]string{"app/six.txt": "6\n"})
bad := issueComment{ID: 8, Body: reportMarker + "names none\n"}
bad.User.Login, bad.User.Type = "maintainer", "User"
gh.issueComments = append(gh.issueComments, bad)
head, comments, body := f.remoteHead(batchBranch1), len(gh.issueComments), gh.find(90).Body
f.now = f.now.AddDate(0, 0, 1)
if code := runWith(f, gh, &strings.Builder{}, &failOn{want: "does not count as a report"}, "run", "--line", "release-1.1", "--continue", "--push"); code != 2 {
t.Fatalf("run --continue --push losing a warning = %d, want 2", code)
}
if got := f.remoteHead(batchBranch1); got != head {
t.Errorf("the batch moved to %.12s", got)
}
if len(gh.issueComments) != comments {
t.Errorf("a comment was posted: %d comments, want %d", len(gh.issueComments), comments)
}
if gh.find(90).Body != body {
t.Error("the batch pull request was edited")
}
}
// A warning lost while a batch is being closed leaves it open, with no
// closing record half written.
func TestLostWarningLeavesTheBatchUnclosed(t *testing.T) {
f := newFixture(t)
f.lines()
f.pr(5, "fix(app): five", "", map[string]string{"app/five.txt": "5\n"})
gh := &fakeGH{}
mustRun(t, f, gh, "run", "--line", "release-1.1", "--push")
bad := issueComment{ID: 8, Body: reportMarker + "names none\n"}
bad.User.Login, bad.User.Type = "maintainer", "User"
gh.issueComments = append(gh.issueComments, bad)
body := gh.find(90).Body
if code := runWith(f, gh, &strings.Builder{}, &failOn{want: "does not count as a report"}, "run", "--line", "release-1.1", "--defer", "5", "--reason", "x", "--push"); code != 2 {
t.Fatalf("run --defer losing a warning = %d, want 2", code)
}
if gh.find(90).Body != body {
t.Error("the batch pull request was edited")
}
if !gh.isOpen(90) {
t.Error("the batch pull request was closed")
}
}
// The git and gh children keep the default SIGPIPE: catching it here must not
// leave it ignored in them, as signal.Ignore would through exec.
func TestChildrenKeepTheDefaultSIGPIPE(t *testing.T) {
catchSIGPIPE()
out, err := exec.Command("sh", "-c", "kill -PIPE $$; echo survived").Output()
if err == nil || strings.Contains(string(out), "survived") {
t.Fatalf("a child survived SIGPIPE: %q, %v", out, err)
}
}
// The branch a close left is not deleted once output was lost: a deletion
// is a push like any other.
func TestLostOutputDeletesNoBranch(t *testing.T) {
f, gh, h1 := closeWorld(t)
f.git("switch", "-q", "main")
l, err := parseLine("release-1.1")
if err != nil {
t.Fatal(err)
}
a := &app{gh: gh, unwritten: errors.New("broken pipe")}
if err := a.deleteBranch(l, closing{PR: 90, Branch: batchBranch1, Head: h1}); err == nil || !strings.Contains(err.Error(), "output was lost") {
t.Fatalf("deleteBranch with output lost = %v, want a refusal", err)
}
if got := f.remoteHead(batchBranch1); got != h1 {
t.Errorf("the branch is at %q, want it left at %.12s", got, h1)
}
}
// A park line lost on stdout stops notify before it writes: no comment, and
// the record is not marked as announced.
func TestLostParkLineWritesNothing(t *testing.T) {
park := parkedEntry{Original: 5, Merge: strings.Repeat("c", 40), Kind: parkDependency, Needs: []int{3}}
gh := &fakeGH{prs: []pullRequest{notifyPR("20261026", parkedBody(park))}}
body := gh.prs[0].Body
var stderr strings.Builder
a := &app{gh: gh, stdout: &failOn{want: "parked originals"}, stderr: &stderr, now: func() time.Time { return time.Date(2026, 10, 26, 6, 23, 0, 0, time.UTC) }}
if code := a.main([]string{"notify", "--line", "release-1.1", "--push"}); code != 2 {
t.Fatalf("notify --push losing the park line = %d, want 2\n%s", code, stderr.String())
}
if len(gh.issueComments) != 0 {
t.Errorf("notify commented: %+v", gh.issueComments)
}
if gh.prs[0].Body != body {
t.Error("notify marked the park as announced")
}
}
// The hint naming the commits a reset drops is the only way back to them, so
// the local branch is not reset when the hint is lost.
func TestLostResetHintKeepsTheBranch(t *testing.T) {
f := newFixture(t)
f.lines()
f.pr(5, "fix(app): five", "", map[string]string{"app/five.txt": "5\n"})
f.git("switch", "-q", "-C", batchBranch1, "origin/release-1.1")
f.write("app/mine.txt", "unpushed\n")
f.git("add", "-A")
f.git("commit", "-q", "-m", "an unpushed resolution")
tip := f.git("rev-parse", "HEAD")
f.git("switch", "-q", "main")
if code := runWith(f, &fakeGH{}, &strings.Builder{}, &failOn{want: "resetting the local"}, "run", "--line", "release-1.1"); code != 2 {
t.Fatalf("run losing the reset hint = %d, want 2", code)
}
if got := f.git("rev-parse", batchBranch1); got != tip {
t.Errorf("the local %s moved to %.12s, want it kept at %.12s", batchBranch1, got, tip)
}
}
// Once output is lost the run moves no local branch, even one a reset would
// only fast-forward.
func TestLostOutputMovesNoLocalBranch(t *testing.T) {
f := newFixture(t)
f.lines()
f.pr(5, "fix(app): five", "", map[string]string{"app/five.txt": "5\n"})
f.git("branch", "-f", batchBranch1, "origin/release-1.1^")
before := f.git("rev-parse", batchBranch1)
if code := runWith(f, &fakeGH{}, &strings.Builder{}, &failOn{want: "prepared"}, "run", "--line", "release-1.1"); code != 2 {
t.Fatalf("run losing an early line = %d, want 2", code)
}
if got := f.git("rev-parse", batchBranch1); got != before {
t.Errorf("the local %s moved to %.12s, want it kept at %.12s", batchBranch1, got, before)
}
}
// No new unit starts once output is lost: neither a pick nor a replay touches
// the branch.
func TestLostOutputStartsNoUnit(t *testing.T) {
f := newFixture(t)
f.lines()
before := f.git("rev-parse", "HEAD")
a := &app{unwritten: errors.New("broken pipe")}
if _, err := a.pickUnit(&verdict{}, nil); err == nil || !strings.Contains(err.Error(), "output was lost") {
t.Errorf("pickUnit with output lost = %v, want a refusal", err)
}
if _, _, err := a.replayNext(unit{}); err == nil || !strings.Contains(err.Error(), "output was lost") {
t.Errorf("replayNext with output lost = %v, want a refusal", err)
}
if got := f.git("rev-parse", "HEAD"); got != before {
t.Errorf("HEAD moved to %.12s", got)
}
}
+2 -2
View File
@@ -176,7 +176,7 @@ func TestPolicyPageMatchesCode(t *testing.T) {
t.Errorf("the page's block gives %d released lines, want 2 written out", pol.released)
}
rule2 := regexp.MustCompile("(?m)^2\\. Its title type is (.*)$").FindStringSubmatch(page)
rule2 := regexp.MustCompile(`(?m)^2\. Its title type is (.*)$`).FindStringSubmatch(page)
if rule2 == nil {
t.Fatal("the page has no rule 2")
}
@@ -187,7 +187,7 @@ func TestPolicyPageMatchesCode(t *testing.T) {
if !slices.Equal(types, takenTypes) {
t.Errorf("rule 2 on the page takes %v, the code %v", types, takenTypes)
}
never := regexp.MustCompile("(?m)^### What waits for the next minor\\n\\n(.*)$").FindStringSubmatch(page)
never := regexp.MustCompile(`(?m)^### What waits for the next minor\n\n(.*)$`).FindStringSubmatch(page)
if never == nil {
t.Fatal("the page has no list of what never goes into a patch release")
}
+21 -21
View File
@@ -708,7 +708,7 @@ func (a *app) report(args []string) int {
return a.fail(fmt.Errorf("batch pull request #%d keeps no report %.12s", pr.Number, *id))
}
if *asJSON {
fmt.Fprintln(a.stdout, s.raw)
_, _ = fmt.Fprintln(a.stdout, s.raw)
return 0
}
a.printReport(&pr, s, inBody, inComment)
@@ -721,29 +721,29 @@ func (a *app) report(args []string) int {
func (a *app) printReport(pr *pullRequest, s storedReport, inBody *storedReport, inComment bool) {
d, b := s.doc, s.doc.Built
safe := terminalSafe
fmt.Fprintf(a.stdout, "report %s for %s, made %s by a %s run", safe(d.ID), safe(d.Line), safe(b.At), safe(b.Options.Mode))
_, _ = fmt.Fprintf(a.stdout, "report %s for %s, made %s by a %s run", safe(d.ID), safe(d.Line), safe(b.At), safe(b.Options.Mode))
if b.Options.NoWorkflowFiles {
fmt.Fprint(a.stdout, " with --no-workflow-files")
_, _ = fmt.Fprint(a.stdout, " with --no-workflow-files")
}
fmt.Fprintln(a.stdout)
fmt.Fprintf(a.stdout, " main %s, line %s, newer line %s, policy %s\n batch %s, tool %s, run %s\n", safe(b.Main), safe(b.Line), safe(or(b.Newer, "none")), safe(b.Policy), safe(b.Batch), safe(or(b.Tool, "unknown")), safe(or(b.Run, "none")))
_, _ = fmt.Fprintln(a.stdout)
_, _ = fmt.Fprintf(a.stdout, " main %s, line %s, newer line %s, policy %s\n batch %s, tool %s, run %s\n", safe(b.Main), safe(b.Line), safe(or(b.Newer, "none")), safe(b.Policy), safe(b.Batch), safe(or(b.Tool, "unknown")), safe(or(b.Run, "none")))
current := "none"
if inBody != nil {
current = safe(inBody.doc.ID)
}
switch {
case inBody != nil && inBody.doc.ID == d.ID:
fmt.Fprintf(a.stdout, " #%d's body carries this report\n", pr.Number)
_, _ = fmt.Fprintf(a.stdout, " #%d's body carries this report\n", pr.Number)
case pr.Head.SHA == b.Batch:
fmt.Fprintf(a.stdout, " #%d's head is %.12s, the batch this report describes, but its body carries report %.12s\n", pr.Number, safe(b.Batch), current)
_, _ = fmt.Fprintf(a.stdout, " #%d's head is %.12s, the batch this report describes, but its body carries report %.12s\n", pr.Number, safe(b.Batch), current)
default:
fmt.Fprintf(a.stdout, " publication unconfirmed: #%d's head is %.12s, not %.12s, and its body carries report %.12s\n", pr.Number, safe(pr.Head.SHA), safe(b.Batch), current)
_, _ = fmt.Fprintf(a.stdout, " publication unconfirmed: #%d's head is %.12s, not %.12s, and its body carries report %.12s\n", pr.Number, safe(pr.Head.SHA), safe(b.Batch), current)
}
if !inComment {
if prState(pr) == "open" {
fmt.Fprintln(a.stdout, " comment not posted; the next backport-batch run --push posts it")
_, _ = fmt.Fprintln(a.stdout, " comment not posted; the next backport-batch run --push posts it")
} else {
fmt.Fprintf(a.stdout, " comment not posted; kept in the body only, since nothing is written to a %s pull request\n", prState(pr))
_, _ = fmt.Fprintf(a.stdout, " comment not posted; kept in the body only, since nothing is written to a %s pull request\n", prState(pr))
}
}
type line struct {
@@ -780,8 +780,8 @@ func (a *app) printReport(pr *pullRequest, s storedReport, inBody *storedReport,
}
for _, e := range d.Primary.Parked {
text := "parked: "
switch {
case e.Kind == parkPartial:
switch e.Kind {
case parkPartial:
text += "only part of it applies, it would leave " + strings.Join(e.Files, ", ") + " without effect"
default:
var needs []string
@@ -802,22 +802,22 @@ func (a *app) printReport(pr *pullRequest, s storedReport, inBody *storedReport,
}
slices.SortFunc(lines, func(x, y line) int { return cmp.Compare(x.n, y.n) })
for _, l := range lines {
fmt.Fprintf(a.stdout, "#%d %s\n", l.n, terminalSafe(l.text))
_, _ = fmt.Fprintf(a.stdout, "#%d %s\n", l.n, terminalSafe(l.text))
}
overlay := func(name string, list []int) {
if len(list) > 0 {
fmt.Fprintf(a.stdout, "%s: %s\n", name, strings.Trim(fmt.Sprint(list), "[]"))
_, _ = fmt.Fprintf(a.stdout, "%s: %s\n", name, strings.Trim(fmt.Sprint(list), "[]"))
}
}
overlay("stale, still on the batch", d.Overlays.Stale)
overlay("only part of it applies, still on the batch", d.Overlays.Partial)
for _, e := range d.Overlays.Dropped {
fmt.Fprintf(a.stdout, "dropped: #%d, merged as %.12s, on #%d: %s\n", e.Original, terminalSafe(e.Merge), e.On, terminalSafe(e.Reason))
_, _ = fmt.Fprintf(a.stdout, "dropped: #%d, merged as %.12s, on #%d: %s\n", e.Original, terminalSafe(e.Merge), e.On, terminalSafe(e.Reason))
}
overlay("changed in the pick", d.Overlays.Changed)
for _, n := range slices.Sorted(maps.Keys(d.Diag)) {
for _, ln := range d.Diag[n] {
fmt.Fprintf(a.stdout, "#%s: %s\n", terminalSafe(n), terminalSafe(ln))
_, _ = fmt.Fprintf(a.stdout, "#%s: %s\n", terminalSafe(n), terminalSafe(ln))
}
}
if len(d.Other) > 0 {
@@ -825,7 +825,7 @@ func (a *app) printReport(pr *pullRequest, s storedReport, inBody *storedReport,
for i, sha := range d.Other {
other[i] = safe(sha)
}
fmt.Fprintf(a.stdout, "commits on main that merged no pull request: %s\n", strings.Join(other, ", "))
_, _ = fmt.Fprintf(a.stdout, "commits on main that merged no pull request: %s\n", strings.Join(other, ", "))
}
}
@@ -850,7 +850,7 @@ func (a *app) postReport(n int, s storedReport) error {
if err != nil {
return err
}
defer os.Remove(name)
defer func() { _ = os.Remove(name) }()
return a.gh.createComment(n, name)
}
@@ -873,12 +873,12 @@ func writeTemp(pattern, content string) (string, error) {
return "", err
}
if _, err := f.WriteString(content); err != nil {
f.Close()
os.Remove(f.Name())
_ = f.Close()
_ = os.Remove(f.Name())
return "", err
}
if err := f.Close(); err != nil {
os.Remove(f.Name())
_ = os.Remove(f.Name())
return "", err
}
return f.Name(), nil
+3 -1
View File
@@ -224,7 +224,9 @@ func TestReportPartition(t *testing.T) {
}
t.Setenv("GIT_COMMITTER_DATE", "2026-01-01T00:00:00Z")
f.pr(4, "fix(app): four, before the start", "", map[string]string{"app/four.txt": "4\n"})
os.Unsetenv("GIT_COMMITTER_DATE")
if err := os.Unsetenv("GIT_COMMITTER_DATE"); err != nil {
t.Fatal(err)
}
f.setPolicy("release-1.0: 2026-06-01\n")
f.onLine("release-1.0", "fix(app): a line-only eleven", map[string]string{"app/eleven.txt": "line\n"})
pr(5, "fix(app): five", map[string]string{"app/five.txt": "5\n"}, true)
+19 -2
View File
@@ -114,6 +114,23 @@ func mergeMessage(message, merge string) string {
return strings.TrimRight(message, " \t\r\n") + "\n\n" + batchTrailer + ": " + merge + "\n"
}
// pickUnit and replayNext start the next unit only while the run's output is
// intact: once it was lost no new unit starts, and a unit already in flight
// still finishes its rollback.
func (a *app) pickUnit(v *verdict, validate func(base, head string) ([]string, error)) (pick, error) {
if err := a.mayAct(); err != nil {
return pick{}, err
}
return pickOriginal(v, validate)
}
func (a *app) replayNext(u unit) (string, []string, error) {
if err := a.mayAct(); err != nil {
return "", nil, err
}
return replayUnit(u)
}
// commitMerge makes the merge of tip onto base, whose tree is tip's since tip
// descends from base, and moves the current branch from tip to it.
func commitMerge(base, tip, message string) (string, error) {
@@ -121,9 +138,9 @@ func commitMerge(base, tip, message string) (string, error) {
if err != nil {
return "", err
}
defer os.Remove(f.Name())
defer func() { _ = os.Remove(f.Name()) }()
if _, err := f.WriteString(message); err != nil {
f.Close()
_ = f.Close()
return "", err
}
if err := f.Close(); err != nil {
+5 -5
View File
@@ -66,7 +66,7 @@ func (a *app) verify(args []string) int {
return a.fail(err)
}
if pr == nil {
fmt.Fprintf(a.stdout, "%s: no batch pull request is open; nothing to verify\n", l.branch())
_, _ = fmt.Fprintf(a.stdout, "%s: no batch pull request is open; nothing to verify\n", l.branch())
return 0
}
if head, err = batchHead(pr); err != nil {
@@ -102,7 +102,7 @@ func (a *app) verify(args []string) int {
}
if why != "" {
refused = append(refused, why)
fmt.Fprintf(a.stdout, "refused %.12s: %s\n", u.commit, why)
_, _ = fmt.Fprintf(a.stdout, "refused %.12s: %s\n", u.commit, why)
continue
}
seen[v] = u.commit
@@ -110,13 +110,13 @@ func (a *app) verify(args []string) int {
if !u.merge() {
n = 1
}
fmt.Fprintf(a.stdout, "ok %.12s #%d, %d %s\n", u.commit, v.o.number, n, plural(n, "commit"))
_, _ = fmt.Fprintf(a.stdout, "ok %.12s #%d, %d %s\n", u.commit, v.o.number, n, plural(n, "commit"))
}
if len(refused) > 0 {
fmt.Fprintf(a.stdout, "%s: %d of %d units at %.12s are not originals in the batch's shape\n", l.branch(), len(refused), len(units), head)
_, _ = fmt.Fprintf(a.stdout, "%s: %d of %d units at %.12s are not originals in the batch's shape\n", l.branch(), len(refused), len(units), head)
return 1
}
fmt.Fprintf(a.stdout, "%s: %d %s at %.12s, each one original in the batch's shape\n", l.branch(), len(units), plural(len(units), "unit"), head)
_, _ = fmt.Fprintf(a.stdout, "%s: %d %s at %.12s, each one original in the batch's shape\n", l.branch(), len(units), plural(len(units), "unit"), head)
return 0
}
+40 -15
View File
@@ -22,6 +22,7 @@ package main
import (
"fmt"
"io"
"os"
"os/exec"
"strconv"
@@ -58,6 +59,10 @@ Options:
--no-color Disable color output (auto-disabled on non-TTY)
-h, --help Show this help
Exit status: 0 when everything is ready, 1 when something is not ready or a
write to stdout fails, 2 on invalid arguments. A closed pipe ends the process
with SIGPIPE, like other Unix tools.
`
// entry is a resource catalog item.
@@ -181,10 +186,16 @@ func run(args []string) int {
cfg.coreOnly = true
i++
case "-h", "--help":
fmt.Fprint(os.Stdout, usageText)
if _, err := fmt.Fprint(os.Stdout, usageText); err != nil {
fmt.Fprintf(os.Stderr, "writing usage: %v\n", err)
return 1
}
return 0
case "--version":
fmt.Fprintln(os.Stdout, Version)
if _, err := fmt.Fprintln(os.Stdout, Version); err != nil {
fmt.Fprintf(os.Stderr, "writing version: %v\n", err)
return 1
}
return 0
default:
fmt.Fprintf(os.Stderr, "Unknown argument: %s\n", a)
@@ -213,14 +224,14 @@ func run(args []string) int {
cfg.timeoutS = sec
if cfg.waitMode {
return cfg.runWait()
return cfg.runWait(os.Stdout)
}
if cfg.watch {
cfg.runWatch()
return 0
return cfg.runWatch(os.Stdout)
}
if writeOutput(os.Stdout, cfg.runOnce()) != nil {
return 1
}
out := cfg.runOnce()
fmt.Print(out)
if cfg.foundIssues {
return 1
}
@@ -281,18 +292,31 @@ func parseTimeout(raw string) (int, bool) {
return 0, false
}
func (cfg *config) runWait() int {
// writeOutput prints a result. A result its reader never got fails the run,
// whatever the resources' state, since the exit code alone would vouch for it.
func writeOutput(w io.Writer, parts ...string) error {
for _, part := range parts {
if _, err := io.WriteString(w, part); err != nil {
fmt.Fprintf(os.Stderr, "writing output: %v\n", err)
return err
}
}
return nil
}
func (cfg *config) runWait(w io.Writer) int {
start := time.Now()
for {
output := cfg.runOnce()
elapsed := int(time.Since(start).Seconds())
if strings.Contains(output, "All resources are ready.") {
fmt.Print(output)
fmt.Printf("%sReady after %ds.%s\n", cfg.green, elapsed, cfg.reset)
if writeOutput(w, output, fmt.Sprintf("%sReady after %ds.%s\n", cfg.green, elapsed, cfg.reset)) != nil {
return 1
}
return 0
}
if elapsed >= cfg.timeoutS {
fmt.Print(output)
_ = writeOutput(w, output)
fmt.Fprintf(os.Stderr, "%s%sTimeout after %ds — resources still not ready.%s\n", cfg.red, cfg.bold, cfg.timeoutS, cfg.reset)
return 1
}
@@ -300,13 +324,14 @@ func (cfg *config) runWait() int {
}
}
func (cfg *config) runWatch() {
func (cfg *config) runWatch(w io.Writer) int {
for {
output := cfg.runOnce()
// Smooth clear is cosmetic and untested; just reprint.
fmt.Printf("%sLast updated: %s (refreshing every %ds, Ctrl+C to stop)%s\n", cfg.bold, time.Now().Format(time.UnixDate), cfg.interval, cfg.reset)
fmt.Println()
fmt.Print(output)
header := fmt.Sprintf("%sLast updated: %s (refreshing every %ds, Ctrl+C to stop)%s\n\n", cfg.bold, time.Now().Format(time.UnixDate), cfg.interval, cfg.reset)
if writeOutput(w, header, output) != nil {
return 1
}
time.Sleep(time.Duration(cfg.interval) * time.Second)
}
}
+68
View File
@@ -0,0 +1,68 @@
/*
Copyright 2026 The Cozystack Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package main
import (
"io"
"os"
"strings"
"testing"
)
func TestHelpAndVersionSucceedOnWritableStdout(t *testing.T) {
r, w, err := os.Pipe()
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = r.Close() })
stdout := os.Stdout
os.Stdout = w
t.Cleanup(func() { os.Stdout = stdout })
read := make(chan string, 1)
go func() {
b, _ := io.ReadAll(r)
read <- string(b)
}()
for _, arg := range []string{"--help", "--version"} {
if code := run([]string{arg}); code != 0 {
t.Errorf("run(%s) = %d, want 0", arg, code)
}
}
_ = w.Close()
if out := <-read; !strings.Contains(out, "Usage:") || !strings.Contains(out, Version) {
t.Errorf("stdout = %q, want the usage text and the version", out)
}
}
func TestHelpAndVersionFailOnUnwritableStdout(t *testing.T) {
r, w, err := os.Pipe()
if err != nil {
t.Fatal(err)
}
_ = r.Close()
_ = w.Close()
stdout := os.Stdout
os.Stdout = w
t.Cleanup(func() { os.Stdout = stdout })
for _, arg := range []string{"--help", "--version"} {
if code := run([]string{arg}); code == 0 {
t.Errorf("run(%s) with an unwritable stdout = 0, want a failure", arg)
}
}
}
+1 -1
View File
@@ -390,7 +390,7 @@ func createPackageFromFile(ctx context.Context, k8sClient client.Client, filePat
}
}
return fmt.Errorf("Package %s not found in file", packageName)
return fmt.Errorf("no Package %s in file", packageName)
}
func installPackage(ctx context.Context, k8sClient client.Client, packageSourceName string) error {
+27 -21
View File
@@ -19,7 +19,7 @@ package cmd
import (
"context"
"fmt"
"os"
"io"
"strings"
"text/tabwriter"
@@ -78,24 +78,25 @@ Use --components flag to show components on separate lines.`,
}
if listCmdFlags.installed {
return listPackages(ctx, k8sClient, listCmdFlags.components)
return listPackages(ctx, k8sClient, cmd.OutOrStdout(), listCmdFlags.components)
}
return listPackageSources(ctx, k8sClient, listCmdFlags.components)
return listPackageSources(ctx, k8sClient, cmd.OutOrStdout(), listCmdFlags.components)
},
}
func listPackageSources(ctx context.Context, k8sClient client.Client, showComponents bool) error {
func listPackageSources(ctx context.Context, k8sClient client.Client, out io.Writer, showComponents bool) error {
var psList cozyv1alpha1.PackageSourceList
if err := k8sClient.List(ctx, &psList); err != nil {
return fmt.Errorf("failed to list PackageSources: %w", err)
}
// Use tabwriter for better column alignment
w := tabwriter.NewWriter(os.Stdout, 0, 0, 3, ' ', 0)
defer w.Flush()
w := tabwriter.NewWriter(out, 0, 0, 3, ' ', 0)
// Print header
fmt.Fprintln(w, "NAME\tVARIANTS\tREADY\tSTATUS")
if _, err := fmt.Fprintln(w, "NAME\tVARIANTS\tREADY\tSTATUS"); err != nil {
return err
}
// Print rows
for _, ps := range psList.Items {
@@ -123,24 +124,26 @@ func listPackageSources(ctx context.Context, k8sClient client.Client, showCompon
}
}
fmt.Fprintf(w, "%s\t%s\t%s\t%s\n", ps.Name, variantsStr, ready, status)
if _, err := fmt.Fprintf(w, "%s\t%s\t%s\t%s\n", ps.Name, variantsStr, ready, status); err != nil {
return err
}
// Show components if requested
if showComponents {
for _, variant := range ps.Spec.Variants {
for _, component := range variant.Components {
fmt.Fprintf(w, " %s\t%s\t\t\n",
fmt.Sprintf("%s.%s", ps.Name, component.Name),
variant.Name)
if _, err := fmt.Fprintf(w, " %s.%s\t%s\t\t\n", ps.Name, component.Name, variant.Name); err != nil {
return err
}
}
}
}
}
return nil
return w.Flush()
}
func listPackages(ctx context.Context, k8sClient client.Client, showComponents bool) error {
func listPackages(ctx context.Context, k8sClient client.Client, out io.Writer, showComponents bool) error {
var pkgList cozyv1alpha1.PackageList
if err := k8sClient.List(ctx, &pkgList); err != nil {
return fmt.Errorf("failed to list Packages: %w", err)
@@ -160,11 +163,12 @@ func listPackages(ctx context.Context, k8sClient client.Client, showComponents b
}
// Use tabwriter for better column alignment
w := tabwriter.NewWriter(os.Stdout, 0, 0, 3, ' ', 0)
defer w.Flush()
w := tabwriter.NewWriter(out, 0, 0, 3, ' ', 0)
// Print header
fmt.Fprintln(w, "NAME\tVARIANT\tREADY\tSTATUS")
if _, err := fmt.Fprintln(w, "NAME\tVARIANT\tREADY\tSTATUS"); err != nil {
return err
}
// Print rows
for _, pkg := range pkgList.Items {
@@ -187,7 +191,9 @@ func listPackages(ctx context.Context, k8sClient client.Client, showComponents b
}
}
fmt.Fprintf(w, "%s\t%s\t%s\t%s\n", pkg.Name, variant, ready, status)
if _, err := fmt.Fprintf(w, "%s\t%s\t%s\t%s\n", pkg.Name, variant, ready, status); err != nil {
return err
}
// Show components if requested
if showComponents {
@@ -197,9 +203,9 @@ func listPackages(ctx context.Context, k8sClient client.Client, showComponents b
for _, v := range ps.Spec.Variants {
if v.Name == variant {
for _, component := range v.Components {
fmt.Fprintf(w, " %s\t%s\t\t\n",
fmt.Sprintf("%s.%s", pkg.Name, component.Name),
variant)
if _, err := fmt.Fprintf(w, " %s.%s\t%s\t\t\n", pkg.Name, component.Name, variant); err != nil {
return err
}
}
break
}
@@ -208,7 +214,7 @@ func listPackages(ctx context.Context, k8sClient client.Client, showComponents b
}
}
return nil
return w.Flush()
}
func init() {
+185
View File
@@ -0,0 +1,185 @@
/*
Copyright 2026 The Cozystack Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package cmd
import (
"context"
"errors"
"fmt"
"io"
"os"
"path/filepath"
"strings"
"testing"
cozyv1alpha1 "github.com/cozystack/cozystack/api/v1alpha1"
"github.com/spf13/cobra"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
utilruntime "k8s.io/apimachinery/pkg/util/runtime"
"sigs.k8s.io/controller-runtime/pkg/client/fake"
)
type failingWriter struct{}
func (failingWriter) Write([]byte) (int, error) { return 0, errors.New("broken pipe") }
func TestPrintReportReturnsWriteError(t *testing.T) {
r := &Report{Findings: []Finding{{Severity: SeverityError, Code: "X", Message: "m"}}}
if err := printReport(r, failingWriter{}); err == nil {
t.Fatal("printReport to an unwritable writer returned nil")
}
}
// The table is buffered until the tabwriter flushes, so a failing reader shows
// up only as a Flush error, which list has to return.
func TestListReturnsWriteError(t *testing.T) {
s := runtime.NewScheme()
utilruntime.Must(cozyv1alpha1.AddToScheme(s))
ps := &cozyv1alpha1.PackageSource{ObjectMeta: metav1.ObjectMeta{Name: "acme.app"}}
pkg := &cozyv1alpha1.Package{ObjectMeta: metav1.ObjectMeta{Name: "acme.app"}}
cl := fake.NewClientBuilder().WithScheme(s).WithObjects(ps, pkg).Build()
for name, list := range map[string]func(io.Writer) error{
"sources": func(w io.Writer) error { return listPackageSources(context.Background(), cl, w, true) },
"packages": func(w io.Writer) error { return listPackages(context.Background(), cl, w, true) },
} {
t.Run(name, func(t *testing.T) {
if err := list(failingWriter{}); err == nil {
t.Fatal("list to an unwritable writer returned nil")
}
var out strings.Builder
if err := list(&out); err != nil || !strings.Contains(out.String(), "acme.app") {
t.Fatalf("list = %v, output %q; want the row", err, out.String())
}
})
}
}
// A command that cannot print its validation report still fails, and a
// refusal keeps validation as its reason with the write error joined to it.
func TestValidationCommandsReportUnwritableReport(t *testing.T) {
fakeFlux := t.TempDir()
if err := os.WriteFile(filepath.Join(fakeFlux, "flux"), []byte("#!/bin/sh\nexit 0\n"), 0o755); err != nil {
t.Fatal(err)
}
t.Setenv("PATH", fakeFlux+string(os.PathListSeparator)+os.Getenv("PATH"))
emptyRepo := func(t *testing.T) string {
root := t.TempDir()
if err := os.Mkdir(filepath.Join(root, "packages"), 0o755); err != nil {
t.Fatal(err)
}
return root
}
run := func(c *cobra.Command, args ...string) error {
c.SetOut(failingWriter{})
t.Cleanup(func() { c.SetOut(nil) })
return c.RunE(c, args)
}
push := func(root string) error {
pushCmdFlags.path = root
t.Cleanup(func() { pushCmdFlags.path = "." })
return run(pushCmd, "oci://registry.example/acme/apps:v1")
}
for _, tc := range []struct {
name string
run func(t *testing.T) error
refusal string
}{
{name: "validate, valid", run: func(t *testing.T) error { return run(validateCmd, validRepo(t)) }},
{name: "validate, invalid", run: func(t *testing.T) error { return run(validateCmd, emptyRepo(t)) }, refusal: "validation failed"},
{name: "push, valid", run: func(t *testing.T) error { return push(validRepo(t)) }, refusal: "nothing was pushed"},
{name: "push, invalid", run: func(t *testing.T) error { return push(emptyRepo(t)) }, refusal: "refusing to push"},
{name: "tap, invalid", run: func(t *testing.T) error { return run(tapCmd, "oci://registry.example/acme/apps:v1") }, refusal: "refusing to tap"},
} {
t.Run(tc.name, func(t *testing.T) {
err := tc.run(t)
if err == nil || !strings.Contains(err.Error(), "broken pipe") {
t.Fatalf("err = %v, want the write error", err)
}
if tc.refusal != "" && !strings.Contains(err.Error(), tc.refusal) {
t.Errorf("err = %v, want the refusal %q kept", err, tc.refusal)
}
})
}
}
// A tap that applied is reported as applied even when its summary is lost,
// and the lost summary still fails the command.
func TestTapSummaryReportsUnwritableOutput(t *testing.T) {
err := writeTapSummary(failingWriter{}, "oci://registry.example/acme/apps:v1", "tap-acme", []string{"acme.app"})
if err == nil || !strings.Contains(err.Error(), "tap applied") || !strings.Contains(err.Error(), "broken pipe") {
t.Fatalf("err = %v, want the write error with the tap reported as applied", err)
}
var out strings.Builder
if err := writeTapSummary(&out, "oci://registry.example/acme/apps:v1", "tap-acme", []string{"acme.app"}); err != nil || !strings.Contains(out.String(), "cozypkg add acme.app") {
t.Fatalf("writeTapSummary = %v, output %q", err, out.String())
}
}
// A clean report has no finding lines, so its summary is its only write and
// alone decides the result.
func TestPrintReportReturnsSummaryWriteError(t *testing.T) {
if err := printReport(&Report{}, failingWriter{}); err == nil {
t.Fatal("printReport of a clean report to an unwritable writer returned nil")
}
}
// push runs flux only after its status line was written, with validation
// skipped and after a report that was written.
func TestPushStopsBeforeFluxWhenItsStatusIsLost(t *testing.T) {
fakeFlux := t.TempDir()
ran := filepath.Join(t.TempDir(), "flux-ran")
if err := os.WriteFile(filepath.Join(fakeFlux, "flux"), []byte("#!/bin/sh\ntouch "+ran+"\n"), 0o755); err != nil {
t.Fatal(err)
}
t.Setenv("PATH", fakeFlux+string(os.PathListSeparator)+os.Getenv("PATH"))
for _, skip := range []bool{true, false} {
t.Run(fmt.Sprintf("skip-validate=%v", skip), func(t *testing.T) {
pushCmdFlags.path, pushCmdFlags.skipValidate = validRepo(t), skip
pushCmdFlags.source, pushCmdFlags.revision = "https://example.com/acme.git", "v1"
t.Cleanup(func() {
pushCmdFlags.path, pushCmdFlags.skipValidate = ".", false
pushCmdFlags.source, pushCmdFlags.revision = "", ""
})
pushCmd.SetOut(&failOn{want: "Pushing"})
t.Cleanup(func() { pushCmd.SetOut(nil) })
err := pushCmd.RunE(pushCmd, []string{"oci://registry.example/acme/apps:v1"})
if err == nil || !strings.Contains(err.Error(), "nothing was pushed") {
t.Fatalf("push losing its status = %v, want nothing pushed", err)
}
if _, statErr := os.Stat(ran); statErr == nil {
t.Fatal("flux ran after the status line was lost")
}
})
}
}
// failOn fails every write that contains want, and takes every other one.
type failOn struct {
want string
buf strings.Builder
}
func (w *failOn) Write(p []byte) (int, error) {
if strings.Contains(string(p), w.want) {
return 0, errors.New("broken pipe")
}
return w.buf.Write(p)
}
+9 -3
View File
@@ -17,6 +17,7 @@ limitations under the License.
package cmd
import (
"errors"
"fmt"
"os"
"os/exec"
@@ -106,10 +107,13 @@ published. Source URL and revision are derived from git when not given.`,
if err != nil {
return err
}
printReport(rep, cmd.OutOrStdout())
printErr := printReport(rep, cmd.OutOrStdout())
if rep.HasErrors() {
errs, _, _ := rep.Counts()
return fmt.Errorf("refusing to push: validation failed with %d error(s) (use --skip-validate to override)", errs)
return errors.Join(fmt.Errorf("refusing to push: validation failed with %d error(s) (use --skip-validate to override)", errs), printErr)
}
if printErr != nil {
return fmt.Errorf("nothing was pushed: writing the validation report failed: %w", printErr)
}
}
@@ -129,7 +133,9 @@ published. Source URL and revision are derived from git when not given.`,
}
fluxArgs := buildFluxPushArgs(ref, packagesDir, source, revision, pushCmdFlags.reproducible)
fmt.Fprintf(cmd.OutOrStdout(), "Pushing %s (source=%s revision=%s)\n", ref, source, revision)
if _, err := fmt.Fprintf(cmd.OutOrStdout(), "Pushing %s (source=%s revision=%s)\n", ref, source, revision); err != nil {
return fmt.Errorf("nothing was pushed: writing the push status failed: %w", err)
}
flux := exec.Command("flux", fluxArgs...)
flux.Stdout = cmd.OutOrStdout()
flux.Stderr = cmd.ErrOrStderr()
+22 -12
View File
@@ -18,6 +18,7 @@ package cmd
import (
"context"
"errors"
"fmt"
"io"
"regexp"
@@ -402,9 +403,8 @@ runs its charts in your management cluster: tap only sources you trust.`,
return err
}
if rep.HasErrors() {
printReport(rep, cmd.OutOrStdout())
errs, _, _ := rep.Counts()
return fmt.Errorf("refusing to tap: artifact failed validation with %d error(s) (use --skip-validate to override)", errs)
return errors.Join(fmt.Errorf("refusing to tap: artifact failed validation with %d error(s) (use --skip-validate to override)", errs), printReport(rep, cmd.OutOrStdout()))
}
}
@@ -487,19 +487,29 @@ runs its charts in your management cluster: tap only sources you trust.`,
_, _ = fmt.Fprintf(cmd.ErrOrStderr(), "warning: could not reset materialization state on OCIRepository/%s: %v\n", srcName, err)
}
fmt.Fprintf(cmd.OutOrStdout(), "Tapped %s\n OCIRepository/%s\n", fullRef, srcName)
for _, n := range names {
fmt.Fprintf(cmd.OutOrStdout(), " PackageSource/%s\n", n)
}
_, _ = fmt.Fprintf(cmd.OutOrStdout(), "Tapping installs nothing. Install an app with:\n")
for _, n := range names {
fmt.Fprintf(cmd.OutOrStdout(), " cozypkg add %s\n", n)
}
_, _ = fmt.Fprintf(cmd.OutOrStdout(), "A privileged install component is not installed until you confirm it with 'cozypkg add --allow-privileged'.\n")
return nil
return writeTapSummary(cmd.OutOrStdout(), fullRef, srcName, names)
},
}
// writeTapSummary reports what a tap created. The tap is applied by then, so a
// summary that cannot be written fails the command while saying so.
func writeTapSummary(w io.Writer, fullRef, srcName string, names []string) error {
var b strings.Builder
fmt.Fprintf(&b, "Tapped %s\n OCIRepository/%s\n", fullRef, srcName)
for _, n := range names {
fmt.Fprintf(&b, " PackageSource/%s\n", n)
}
b.WriteString("Tapping installs nothing. Install an app with:\n")
for _, n := range names {
fmt.Fprintf(&b, " cozypkg add %s\n", n)
}
b.WriteString("A privileged install component is not installed until you confirm it with 'cozypkg add --allow-privileged'.\n")
if _, err := io.WriteString(w, b.String()); err != nil {
return fmt.Errorf("tap applied, but writing its summary failed: %w", err)
}
return nil
}
var untapCmd = &cobra.Command{
Use: "untap <packagesource-name>",
Short: "Remove a tapped repository",
+12 -5
View File
@@ -21,6 +21,7 @@ import (
"bytes"
"context"
"encoding/json"
"errors"
"fmt"
"io"
"io/fs"
@@ -535,16 +536,19 @@ func pullOCIArtifact(ref string) (string, func(), error) {
return dir, cleanup, nil
}
func printReport(r *Report, w io.Writer) {
func printReport(r *Report, w io.Writer) error {
for _, f := range r.Findings {
loc := f.Location
if loc == "" {
loc = "-"
}
fmt.Fprintf(w, "[%s] %s (%s): %s\n", f.Severity, loc, f.Code, f.Message)
if _, err := fmt.Fprintf(w, "[%s] %s (%s): %s\n", f.Severity, loc, f.Code, f.Message); err != nil {
return err
}
}
errs, warns, infos := r.Counts()
fmt.Fprintf(w, "\nSummary: %d error(s), %d warning(s), %d info\n", errs, warns, infos)
_, err := fmt.Fprintf(w, "\nSummary: %d error(s), %d warning(s), %d info\n", errs, warns, infos)
return err
}
var validateCmdFlags struct {
@@ -663,10 +667,13 @@ runs "helm lint" on every component chart.`,
if err != nil {
return err
}
printReport(rep, cmd.OutOrStdout())
printErr := printReport(rep, cmd.OutOrStdout())
if rep.HasErrors() {
errs, _, _ := rep.Counts()
return fmt.Errorf("validation failed: %d error(s)", errs)
return errors.Join(fmt.Errorf("validation failed: %d error(s)", errs), printErr)
}
if printErr != nil {
return fmt.Errorf("writing the validation report failed: %w", printErr)
}
return nil
},
+1 -1
View File
@@ -663,7 +663,7 @@ func validateGitRef(refMap map[string]string) error {
return fmt.Errorf("commit SHA should be at least 7 characters, got: %s", commit)
}
for _, c := range commit {
if !((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')) {
if (c < '0' || c > '9') && (c < 'a' || c > 'f') && (c < 'A' || c > 'F') {
return fmt.Errorf("commit SHA should be a hexadecimal string, got: %s", commit)
}
}
@@ -631,7 +631,7 @@ func (r *BackupJobReconciler) createAltinityBackupArtifact(
// used name meets the earlier run's Backup here. Only one recording
// this run's archive was created by an earlier reconcile of this run.
if got := existing.Spec.DriverMetadata[altinityArchiveMetaKey]; got != archive {
return nil, fmt.Errorf("Backup %s/%s already exists and records archive %q, not %q that this run wrote",
return nil, fmt.Errorf("existing Backup %s/%s records archive %q, not %q that this run wrote",
backup.Namespace, backup.Name, got, archive)
}
return existing, nil
@@ -222,13 +222,13 @@ func cnpgListStub(prefix string, seen func(*http.Request)) http.HandlerFunc {
return func(w http.ResponseWriter, req *http.Request) {
w.Header().Set("Content-Type", "application/xml")
if _, ok := req.URL.Query()["location"]; ok {
fmt.Fprint(w, `<?xml version="1.0" encoding="UTF-8"?><LocationConstraint xmlns="http://s3.amazonaws.com/doc/2006-03-01/"></LocationConstraint>`)
_, _ = fmt.Fprint(w, `<?xml version="1.0" encoding="UTF-8"?><LocationConstraint xmlns="http://s3.amazonaws.com/doc/2006-03-01/"></LocationConstraint>`)
return
}
if seen != nil {
seen(req)
}
fmt.Fprintf(w, `<?xml version="1.0" encoding="UTF-8"?>
_, _ = fmt.Fprintf(w, `<?xml version="1.0" encoding="UTF-8"?>
<ListBucketResult xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
<Name>bkt</Name><Prefix>%[1]s</Prefix><KeyCount>2</KeyCount><MaxKeys>1000</MaxKeys><IsTruncated>false</IsTruncated>
<Contents><Key>%[1]sbackup.info</Key><Size>7</Size><ETag>"a"</ETag><LastModified>2026-10-21T10:01:00.000Z</LastModified></Contents>
@@ -2833,7 +2833,7 @@ func TestReconcileCNPG_ObjectStoreApplyRecovers(t *testing.T) {
}
failing = false
j, _ = f.pass()
_, _ = f.pass()
f.settleDestination()
j, backups := f.pass()
if len(backups) != 1 {
@@ -134,14 +134,14 @@ var etcdClusterGVR = schema.GroupVersionResource{
// the wrong CRD via the typed client.
func validateEtcdApplicationRef(ref corev1.TypedLocalObjectReference) error {
if ref.Kind != etcdAppKind {
return fmt.Errorf("Etcd strategy supports applicationRef.kind=%q, got %q", etcdAppKind, ref.Kind)
return fmt.Errorf("the Etcd strategy supports applicationRef.kind=%q, got %q", etcdAppKind, ref.Kind)
}
apiGroup := ""
if ref.APIGroup != nil {
apiGroup = *ref.APIGroup
}
if apiGroup != "" && apiGroup != etcdapp.GroupName {
return fmt.Errorf("Etcd strategy supports applicationRef.apiGroup=%q, got %q", etcdapp.GroupName, apiGroup)
return fmt.Errorf("the Etcd strategy supports applicationRef.apiGroup=%q, got %q", etcdapp.GroupName, apiGroup)
}
return nil
}
@@ -104,10 +104,10 @@ func kafkaClusterName(appName string) string {
// apps.cozystack.io/Kafka application.
func validateKafkaApplicationRef(ref corev1.TypedLocalObjectReference) error {
if ref.Kind != kafkaApplicationKind {
return fmt.Errorf("Kafka strategy only supports applicationRef.kind=%q, got %q", kafkaApplicationKind, ref.Kind)
return fmt.Errorf("the Kafka strategy only supports applicationRef.kind=%q, got %q", kafkaApplicationKind, ref.Kind)
}
if ref.APIGroup != nil && *ref.APIGroup != "" && *ref.APIGroup != backupsv1alpha1.DefaultApplicationAPIGroup {
return fmt.Errorf("Kafka strategy only supports applicationRef.apiGroup=%q, got %q", backupsv1alpha1.DefaultApplicationAPIGroup, *ref.APIGroup)
return fmt.Errorf("the Kafka strategy only supports applicationRef.apiGroup=%q, got %q", backupsv1alpha1.DefaultApplicationAPIGroup, *ref.APIGroup)
}
return nil
}
@@ -528,7 +528,7 @@ func (r *BackupJobReconciler) createKafkaBackupArtifact(
// RabbitMQ driver's guard).
if existing.Spec.ApplicationRef.Kind != backup.Spec.ApplicationRef.Kind ||
existing.Spec.ApplicationRef.Name != backup.Spec.ApplicationRef.Name {
return nil, fmt.Errorf("Backup %s/%s already exists for a different application (%s/%s, not %s/%s)",
return nil, fmt.Errorf("existing Backup %s/%s belongs to a different application (%s/%s, not %s/%s)",
backup.Namespace, backup.Name,
existing.Spec.ApplicationRef.Kind, existing.Spec.ApplicationRef.Name,
backup.Spec.ApplicationRef.Kind, backup.Spec.ApplicationRef.Name)
@@ -464,7 +464,7 @@ func TestMariaDBArtifactSizeBytes_MinioClient(t *testing.T) {
gotPath, gotPrefix, gotAuth = req.URL.Path, req.URL.Query().Get("prefix"), req.Header.Get("Authorization")
gotDelimiter = req.URL.Query().Get("delimiter")
w.Header().Set("Content-Type", "application/xml")
fmt.Fprintf(w, `<?xml version="1.0" encoding="UTF-8"?>
_, _ = fmt.Fprintf(w, `<?xml version="1.0" encoding="UTF-8"?>
<ListBucketResult xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
<Name>bkt</Name><Prefix>tenant/db/</Prefix><KeyCount>1</KeyCount><MaxKeys>1000</MaxKeys><IsTruncated>false</IsTruncated>
<Contents><Key>%s</Key><Size>31337</Size><ETag>"x"</ETag><LastModified>2026-10-21T10:01:00.000Z</LastModified></Contents>
@@ -30,8 +30,6 @@ import (
// ---------------------------------------------------------------------------
const (
mariadbFieldManager = "cozystack-mariadb-backup-driver"
// mariadb-operator's MariaDB ApplicationDefinition (release.prefix). The
// cozystack mariadb-rd renders the HelmRelease with releaseName =
// "mariadb-" + appName (see packages/system/mariadb-rd/cozyrds/mariadb.yaml,
@@ -528,8 +528,8 @@ func (r *BackupJobReconciler) reconcileMongoDB(ctx context.Context, j *backupsv1
}
}
switch state := mdbBackup.Status.State; {
case state == psmdbtypes.StateReady:
switch state := mdbBackup.Status.State; state {
case psmdbtypes.StateReady:
// Backup completed successfully. Materialise the Cozystack artifact and
// finalise the BackupJob. Idempotent: reuse the existing artifact if a
// previous reconcile created it and then raced on the status update.
@@ -570,7 +570,7 @@ func (r *BackupJobReconciler) reconcileMongoDB(ctx context.Context, j *backupsv1
}
return ctrl.Result{}, nil
case state == psmdbtypes.StateError || state == psmdbtypes.StateRejected:
case psmdbtypes.StateError, psmdbtypes.StateRejected:
message := mdbBackup.Status.Error
// The residual half of the injection race: on the useSystemBucket flow the
// operator can latch state=error because it resolved the injected storage
@@ -1740,8 +1740,8 @@ func (r *RestoreJobReconciler) reconcileMongoDBRestore(ctx context.Context, rest
return r.markRestoreJobFailed(ctx, restoreJob, fmt.Sprintf("failed to ensure psmdb.percona.com/PerconaServerMongoDBRestore: %v", err))
}
switch state := mdbRestore.Status.State; {
case state == psmdbtypes.StateReady:
switch state := mdbRestore.Status.State; state {
case psmdbtypes.StateReady:
now := metav1.Now()
restoreJob.Status.CompletedAt = &now
restoreJob.Status.Phase = backupsv1alpha1.RestoreJobPhaseSucceeded
@@ -1756,7 +1756,7 @@ func (r *RestoreJobReconciler) reconcileMongoDBRestore(ctx context.Context, rest
}
return ctrl.Result{}, nil
case state == psmdbtypes.StateError || state == psmdbtypes.StateRejected:
case psmdbtypes.StateError, psmdbtypes.StateRejected:
message := mdbRestore.Status.Error
if message == "" {
message = fmt.Sprintf("psmdb.percona.com/PerconaServerMongoDBRestore %s/%s reported state=%s", mdbRestore.Namespace, mdbRestore.Name, state)
@@ -1855,7 +1855,7 @@ func (r *RestoreJobReconciler) resolveMongoDBBackupSource(ctx context.Context, b
}
if destination == "" {
return nil, fmt.Errorf(
"Backup has no restorable destination (the operator PerconaServerMongoDBBackup was reaped and no snapshot destination is persisted); re-run the BackupJob")
"no restorable destination for the Backup (the operator PerconaServerMongoDBBackup was reaped and no snapshot destination is persisted); re-run the BackupJob")
}
src := &psmdbtypes.BackupSource{
Type: psmdbtypes.BackupTypeLogical,
@@ -513,7 +513,7 @@ func (r *BackupJobReconciler) createRabbitmqBackupArtifact(
// this run's success while describing something else.
if existing.Spec.ApplicationRef.Kind != backup.Spec.ApplicationRef.Kind ||
existing.Spec.ApplicationRef.Name != backup.Spec.ApplicationRef.Name {
return nil, fmt.Errorf("Backup %s/%s already exists for a different application (%s/%s, not %s/%s)",
return nil, fmt.Errorf("existing Backup %s/%s belongs to a different application (%s/%s, not %s/%s)",
backup.Namespace, backup.Name,
existing.Spec.ApplicationRef.Kind, existing.Spec.ApplicationRef.Name,
backup.Spec.ApplicationRef.Kind, backup.Spec.ApplicationRef.Name)
@@ -65,12 +65,14 @@ func (s captureSink) WithName(string) logr.LogSink { return s }
func TestRunThenDrain_FencesLeftBehindAreAnErrorNamingThem(t *testing.T) {
logger, entries := newCaptureLogger()
ctx := log.IntoContext(context.Background(), logger)
RunThenDrain(ctx,
if err := RunThenDrain(ctx,
func(context.Context) error { return nil },
func(context.Context) (int, error) {
return 1, errors.Join(context.DeadlineExceeded, errors.New("still fenced: tenant-root/vm-disk-0"))
},
time.Minute)
time.Minute); err != nil {
t.Fatalf("RunThenDrain = %v, want the run's nil error", err)
}
for _, e := range *entries {
if e.err != nil && strings.Contains(e.err.Error(), "tenant-root/vm-disk-0") {
return
@@ -84,10 +86,12 @@ func TestRunThenDrain_FencesLeftBehindAreAnErrorNamingThem(t *testing.T) {
func TestRunThenDrain_AnUnansweredListingIsNotACountOfMinusOne(t *testing.T) {
logger, entries := newCaptureLogger()
ctx := log.IntoContext(context.Background(), logger)
RunThenDrain(ctx,
if err := RunThenDrain(ctx,
func(context.Context) error { return nil },
func(context.Context) (int, error) { return -1, context.DeadlineExceeded },
time.Minute)
time.Minute); err != nil {
t.Fatalf("RunThenDrain = %v, want the run's nil error", err)
}
found := false
for _, e := range *entries {
for i := 0; i+1 < len(e.kv); i += 2 {
@@ -108,10 +112,12 @@ func TestRunThenDrain_AnUnansweredListingIsNotACountOfMinusOne(t *testing.T) {
func TestRunThenDrain_ACompleteDrainSaysSo(t *testing.T) {
logger, entries := newCaptureLogger()
ctx := log.IntoContext(context.Background(), logger)
RunThenDrain(ctx,
if err := RunThenDrain(ctx,
func(context.Context) error { return nil },
func(context.Context) (int, error) { return 0, nil },
time.Minute)
time.Minute); err != nil {
t.Fatalf("RunThenDrain = %v, want the run's nil error", err)
}
for _, e := range *entries {
if e.err == nil && strings.Contains(e.msg, "Released every uninstall fence") {
return
@@ -486,11 +486,12 @@ func ownsSuspensionManagedFields(hr *helmv2.HelmRelease) bool {
// fieldsManageSuspend reports whether a managed-fields set includes spec.suspend,
// encoded by the apiserver as {"f:spec":{"f:suspend":{}}}.
func fieldsManageSuspend(fs *metav1.FieldsV1) bool {
if fs == nil || len(fs.Raw) == 0 {
raw := fs.GetRawBytes()
if len(raw) == 0 {
return false
}
var top map[string]json.RawMessage
if err := json.Unmarshal(fs.Raw, &top); err != nil {
if err := json.Unmarshal(raw, &top); err != nil {
return false
}
specRaw, ok := top["f:spec"]
@@ -83,7 +83,7 @@ func suspendManagedFields(manager string, op metav1.ManagedFieldsOperationType)
Operation: op,
APIVersion: helmv2.GroupVersion.String(),
FieldsType: "FieldsV1",
FieldsV1: &metav1.FieldsV1{Raw: []byte(`{"f:spec":{"f:suspend":{}}}`)},
FieldsV1: metav1.NewFieldsV1(`{"f:spec":{"f:suspend":{}}}`),
}}
}
@@ -286,7 +286,7 @@ func TestOwnsSuspensionManagedFields(t *testing.T) {
{"no managed fields", nil, false},
{"plunger apply of other fields", []metav1.ManagedFieldsEntry{{
Manager: suspendFieldManager, Operation: metav1.ManagedFieldsOperationApply,
FieldsType: "FieldsV1", FieldsV1: &metav1.FieldsV1{Raw: []byte(`{"f:spec":{"f:chart":{}}}`)},
FieldsType: "FieldsV1", FieldsV1: metav1.NewFieldsV1(`{"f:spec":{"f:chart":{}}}`),
}}, false},
}
for _, tc := range cases {
@@ -3,8 +3,10 @@ package kubeovnplunger
import (
"bytes"
"context"
"errors"
"fmt"
"io"
"net/http"
"strings"
"time"
@@ -153,12 +155,9 @@ func (r *KubeOVNPlunger) SetupWithManager(mgr ctrl.Manager, kubeOVNNamespace, ap
Complete(r); err != nil {
return err
}
_ = mgr.Add(manager.RunnableFunc(func(ctx context.Context) error {
go srv.ListenAndServe()
<-ctx.Done()
_ = srv.Shutdown(context.Background())
return nil
}))
if err := mgr.Add(serveStatus(srv)); err != nil {
return err
}
return mgr.Add(manager.RunnableFunc(func(ctx context.Context) error {
ticker := time.NewTicker(rescanInterval)
defer ticker.Stop()
@@ -180,6 +179,25 @@ func (r *KubeOVNPlunger) SetupWithManager(mgr ctrl.Manager, kubeOVNNamespace, ap
}))
}
// serveStatus runs the status stream for as long as the manager does. A server
// that cannot start fails the manager, as the metrics server does.
func serveStatus(s *sse.Server) manager.RunnableFunc {
return func(ctx context.Context) error {
served := make(chan error, 1)
go func() { served <- s.ListenAndServe() }()
select {
case err := <-served:
return err
case <-ctx.Done():
}
_ = s.Shutdown(context.Background())
if err := <-served; !errors.Is(err, http.ErrServerClosed) {
return err
}
return nil
}
}
type ExecOptions struct {
Namespace string
Pod string
@@ -219,7 +219,7 @@ func (r *KubeOVNPlunger) WriteClusterMetrics(db string, snaps []ovnstatus.Health
r.metrics.allAgree.WithLabelValues(db, cid).Set(b2f(ecv.AllAgree))
r.metrics.membersExpected.WithLabelValues(db, cid).Set(float64(expectedReplicas))
r.metrics.membersObserved.WithLabelValues(db, cid).Set(float64(ecv.MembersCount))
r.metrics.ipsExpected.WithLabelValues(db, cid).Set(float64(len(ecv.ConsensusResult.TruthView.Members))) // optional; or len(hints.ExpectedIPs)
r.metrics.ipsExpected.WithLabelValues(db, cid).Set(float64(len(ecv.TruthView.Members))) // optional; or len(hints.ExpectedIPs)
r.metrics.ipsObserved.WithLabelValues(db, cid).Set(float64(ecv.DistinctIPCount))
r.metrics.excessMembers.WithLabelValues(db, cid).Set(float64(ecv.ExpectedExcess))
r.metrics.missingMembers.WithLabelValues(db, cid).Set(float64(ecv.ExpectedShortfall))
@@ -0,0 +1,51 @@
package kubeovnplunger
import (
"context"
"io"
"log"
"net"
"testing"
"time"
"github.com/cozystack/cozystack/internal/sse"
)
func runStatusServer(ctx context.Context, t *testing.T, addr string) (bool, error) {
t.Helper()
ctx, cancel := context.WithCancel(ctx)
t.Cleanup(cancel)
s := sse.New(sse.Options{Addr: addr, Logger: log.New(io.Discard, "", 0)})
done := make(chan error, 1)
go func() { done <- serveStatus(s)(ctx) }()
select {
case err := <-done:
return true, err
case <-time.After(2 * time.Second):
return false, nil
}
}
// A status server that cannot listen fails its runnable, and with it the
// manager, rather than leaving the plunger running without it.
func TestStatusServerReportsListenFailure(t *testing.T) {
taken, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = taken.Close() })
returned, err := runStatusServer(context.Background(), t, taken.Addr().String())
if !returned || err == nil {
t.Fatalf("serveStatus on an occupied address = %v (returned %v), want an error", err, returned)
}
}
// Stopping the manager stops the server, and that is not an error.
func TestStatusServerStopsWithoutError(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
time.AfterFunc(100*time.Millisecond, cancel)
returned, err := runStatusServer(ctx, t, "127.0.0.1:0")
if !returned || err != nil {
t.Fatalf("serveStatus after cancel = %v (returned %v), want nil", err, returned)
}
}
@@ -3,7 +3,6 @@ package controller
import (
"context"
"strings"
"time"
corev1 "k8s.io/api/core/v1"
apierrors "k8s.io/apimachinery/pkg/api/errors"
@@ -15,10 +14,6 @@ import (
cozyv1alpha1 "github.com/cozystack/cozystack/api/v1alpha1"
)
const (
deletionRequeueDelay = 30 * time.Second
)
// WorkloadMonitorReconciler reconciles a WorkloadMonitor object
type WorkloadReconciler struct {
client.Client
@@ -28,7 +28,7 @@ import (
"k8s.io/client-go/tools/record"
"k8s.io/client-go/util/retry"
"k8s.io/client-go/util/workqueue"
"k8s.io/utils/pointer"
"k8s.io/utils/ptr"
ctrl "sigs.k8s.io/controller-runtime"
"sigs.k8s.io/controller-runtime/pkg/cache"
"sigs.k8s.io/controller-runtime/pkg/client"
@@ -423,8 +423,8 @@ func updateOwnerReferences(obj metav1.Object, monitor client.Object) {
Name: monitor.GetName(),
UID: monitor.GetUID(),
// Set Controller to false to avoid conflict as multiple controllers are not allowed
Controller: pointer.BoolPtr(false),
BlockOwnerDeletion: pointer.BoolPtr(true),
Controller: ptr.To(false),
BlockOwnerDeletion: ptr.To(true),
}
owners = append(owners, newOwnerRef)
}
@@ -525,10 +525,10 @@ func (r *WorkloadMonitorReconciler) queryAllBucketMetrics(ctx context.Context, p
if err != nil {
return nil, fmt.Errorf("querying Prometheus: %w", err)
}
defer resp.Body.Close()
defer func() { _ = resp.Body.Close() }()
if resp.StatusCode != http.StatusOK {
return nil, fmt.Errorf("Prometheus returned status %d", resp.StatusCode)
return nil, fmt.Errorf("unexpected status %d from Prometheus", resp.StatusCode)
}
body, err := io.ReadAll(io.LimitReader(resp.Body, 4<<20))
@@ -549,7 +549,7 @@ func (r *WorkloadMonitorReconciler) queryAllBucketMetrics(ctx context.Context, p
return nil, fmt.Errorf("parsing Prometheus response: %w", err)
}
if promResp.Status != "success" {
return nil, fmt.Errorf("Prometheus query finished with status %q", promResp.Status)
return nil, fmt.Errorf("the Prometheus query finished with status %q", promResp.Status)
}
for _, r := range promResp.Data.Result {
@@ -1174,9 +1174,9 @@ func (r *WorkloadMonitorReconciler) Reconcile(ctx context.Context, req ctrl.Requ
// Default to operational = true, but check MinReplicas if set.
// Use fresh.Spec to avoid making decisions based on a stale cached copy
// when the spec was updated between the initial read and this retry.
fresh.Status.Operational = pointer.Bool(true)
fresh.Status.Operational = ptr.To(true)
if fresh.Spec.MinReplicas != nil && availableReplicas < *fresh.Spec.MinReplicas {
fresh.Status.Operational = pointer.Bool(false)
fresh.Status.Operational = ptr.To(false)
}
// Only the DataVolume check writes Message and Reason, so the stored ones
// are the last DataVolume verdict: kept while no reader is installed yet, so a
@@ -1189,7 +1189,7 @@ func (r *WorkloadMonitorReconciler) Reconcile(ctx context.Context, req ctrl.Requ
}
}
if fresh.Status.Message != "" {
fresh.Status.Operational = pointer.Bool(false)
fresh.Status.Operational = ptr.To(false)
}
if equality.Semantic.DeepEqual(stored, &fresh.Status) {
return nil
@@ -870,7 +870,7 @@ func TestReconcileNoBucketClaimSkips(t *testing.T) {
func TestQueryAllBucketMetrics(t *testing.T) {
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
fmt.Fprint(w, `{"status":"success","data":{"resultType":"vector","result":[
_, _ = fmt.Fprint(w, `{"status":"success","data":{"resultType":"vector","result":[
{"metric":{"__name__":"SeaweedFS_s3_bucket_size_bytes","bucket":"bucket-aaa"},"value":[1713000000,"10485864"]},
{"metric":{"__name__":"SeaweedFS_s3_bucket_physical_size_bytes","bucket":"bucket-aaa"},"value":[1713000000,"20971728"]},
{"metric":{"__name__":"SeaweedFS_s3_bucket_size_bytes","bucket":"bucket-bbb"},"value":[1713000000,"0"]}
@@ -909,7 +909,7 @@ func TestQueryAllBucketMetrics(t *testing.T) {
func TestQueryAllBucketMetricsEmpty(t *testing.T) {
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
fmt.Fprint(w, `{"status":"success","data":{"resultType":"vector","result":[]}}`)
_, _ = fmt.Fprint(w, `{"status":"success","data":{"resultType":"vector","result":[]}}`)
}))
defer srv.Close()
@@ -953,7 +953,7 @@ func TestQueryAllBucketMetricsPathPrefixAndUserinfo(t *testing.T) {
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
gotPath = r.URL.Path
gotUser, gotPass, gotOK = r.BasicAuth()
fmt.Fprint(w, `{"status":"success","data":{"resultType":"vector","result":[]}}`)
_, _ = fmt.Fprint(w, `{"status":"success","data":{"resultType":"vector","result":[]}}`)
}))
defer srv.Close()
@@ -1219,7 +1219,7 @@ func TestReconcileBucketMetricsFromEndpointOverride(t *testing.T) {
if r.URL.Path != "/vm/select/0/prometheus/api/v1/query" {
t.Errorf("unexpected query path %q", r.URL.Path)
}
fmt.Fprint(w, `{"status":"success","data":{"resultType":"vector","result":[
_, _ = fmt.Fprint(w, `{"status":"success","data":{"resultType":"vector","result":[
{"metric":{"__name__":"SeaweedFS_s3_bucket_size_bytes","bucket":"cosi-abc123"},"value":[1713000000,"4096"]}
]}}`)
}))
@@ -1331,7 +1331,7 @@ func TestReconcileRetainsLastKnownSizesOnQueryFailure(t *testing.T) {
func TestReconcileRetainsLastKnownSizesWhenBucketMissingFromResult(t *testing.T) {
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
fmt.Fprint(w, `{"status":"success","data":{"resultType":"vector","result":[]}}`)
_, _ = fmt.Fprint(w, `{"status":"success","data":{"resultType":"vector","result":[]}}`)
}))
defer srv.Close()
+1 -1
View File
@@ -40,7 +40,7 @@ func Install(ctx context.Context, k8sClient client.Client, writeEmbeddedManifest
if err != nil {
return fmt.Errorf("failed to create temp directory: %w", err)
}
defer os.RemoveAll(tmpDir)
defer func() { _ = os.RemoveAll(tmpDir) }()
manifestsDir := filepath.Join(tmpDir, "manifests")
if err := os.MkdirAll(manifestsDir, 0755); err != nil {
+2 -2
View File
@@ -41,7 +41,7 @@ func Install(ctx context.Context, k8sClient client.Client, writeEmbeddedManifest
if err != nil {
return fmt.Errorf("failed to create temp directory: %w", err)
}
defer os.RemoveAll(tmpDir)
defer func() { _ = os.RemoveAll(tmpDir) }()
// Extract embedded manifests (generated by cozypkg)
manifestsDir := filepath.Join(tmpDir, "manifests")
@@ -171,7 +171,7 @@ func extractNamespace(objects []*unstructured.Unstructured) (string, error) {
if obj.GetKind() == "Namespace" {
namespace := obj.GetName()
if namespace == "" {
return "", fmt.Errorf("Namespace object has no name")
return "", fmt.Errorf("the Namespace object has no name")
}
return namespace, nil
}
+7 -7
View File
@@ -30,8 +30,8 @@ import (
)
var (
NoAncestors = errors.New("no managed apps found in lineage")
AncestryAmbiguous = errors.New("object ancestry is ambiguous")
ErrNoAncestors = errors.New("no managed apps found in lineage")
ErrAncestryAmbiguous = errors.New("object ancestry is ambiguous")
)
const (
@@ -115,9 +115,9 @@ func (h *LineageControllerWebhook) Handle(ctx context.Context, req admission.Req
owner, err := h.getOwner(ctx, obj)
switch {
case err != nil && errors.Is(err, AncestryAmbiguous):
case err != nil && errors.Is(err, ErrAncestryAmbiguous):
warn = append(warn, "object ancestry ambiguous, using first ancestor found")
case err != nil && errors.Is(err, NoAncestors):
case err != nil && errors.Is(err, ErrNoAncestors):
// not a problem, mark object as unmanaged
case err != nil:
logger.Error(err, "error computing lineage labels")
@@ -147,14 +147,14 @@ func (h *LineageControllerWebhook) Handle(ctx context.Context, req admission.Req
func (h *LineageControllerWebhook) getOwner(ctx context.Context, o *unstructured.Unstructured) (*unstructured.Unstructured, error) {
owners := lineage.WalkOwnershipGraphWithCache(ctx, h.dynClient, h.mapper, h, h.ownerCache, o)
if len(owners) == 0 {
return nil, NoAncestors
return nil, ErrNoAncestors
}
obj, err := owners[0].GetUnstructuredCached(ctx, h.dynClient, h.mapper, h.ownerCache)
if err != nil {
return nil, err
}
if len(owners) > 1 {
err = AncestryAmbiguous
err = ErrAncestryAmbiguous
}
return obj, err
}
@@ -176,7 +176,7 @@ func (h *LineageControllerWebhook) computeLabels(ctx context.Context, obj *unstr
return s
}
s = s[:63]
for b := s[62]; !((b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z') || (b >= '0' && b <= '9')); s = s[:len(s)-1] {
for b := s[62]; (b < 'a' || b > 'z') && (b < 'A' || b > 'Z') && (b < '0' || b > '9'); s = s[:len(s)-1] {
b = s[len(s)-1]
}
return s
+2 -2
View File
@@ -146,7 +146,7 @@ func (c *inventoryClient) VMs(ctx context.Context, providerUID string) ([]invent
defer func() { _ = resp.Body.Close() }()
if resp.StatusCode != http.StatusOK {
return nil, fmt.Errorf("Forklift inventory returned %s listing VMs", resp.Status)
return nil, fmt.Errorf("listing VMs: the Forklift inventory returned %s", resp.Status)
}
var vms []inventoryVMRef
@@ -195,7 +195,7 @@ func (c *inventoryClient) VM(ctx context.Context, providerUID, vmID string) (*in
case http.StatusNotFound:
return nil, &notFoundError{vmID: vmID}
default:
return nil, fmt.Errorf("Forklift inventory returned %s for VM %q", resp.Status, vmID)
return nil, fmt.Errorf("VM %q: the Forklift inventory returned %s", vmID, resp.Status)
}
vm := &inventoryVM{}
+7 -1
View File
@@ -18,6 +18,7 @@ package observabilityproxy
import (
"bufio"
"errors"
"io"
"net/http"
"net/http/httptest"
@@ -422,7 +423,12 @@ func TestServerTailCapsAndIdle(t *testing.T) {
closed <- err
}()
select {
case <-closed:
case err := <-closed:
// The server cuts an idle tail off mid-stream rather than ending the
// response, so the client reads an unexpected EOF; a clean end is fine too.
if err != nil && !errors.Is(err, io.ErrUnexpectedEOF) {
t.Fatalf("idle tail ended with %v, want the stream to end or be cut", err)
}
case <-time.After(3 * time.Second):
t.Fatal("idle tail not closed")
}
@@ -790,15 +790,6 @@ func scanRecordingClient(scheme *runtime.Scheme, listed *[]string, writes *int,
}).Build()
}
func listedKind(listed []string, kind string) bool {
for _, l := range listed {
if strings.Contains(l, kind) {
return true
}
}
return false
}
// The comparison guarding that write has to be semantic rather than structural, or a
// LimitRange written in a different but equivalent notation would re-apply on every
// reconcile — invisible in a test that only looked at the resulting object, since every one
+53 -18
View File
@@ -51,6 +51,9 @@ type Server struct {
clientsMu sync.RWMutex
clients map[*client]struct{}
// closing is set by Shutdown under clientsMu, so no stream registers
// after the clients it stops.
closing bool
// latest holds the most recent payload (sent to new clients on connect).
latestMu sync.RWMutex
@@ -60,6 +63,7 @@ type Server struct {
type client struct {
ch chan string
closeCh chan struct{}
closeOnce sync.Once
flusher http.Flusher
w http.ResponseWriter
req *http.Request
@@ -121,8 +125,9 @@ func (s *Server) ListenAndServe() error {
// Shutdown gracefully stops the server.
func (s *Server) Shutdown(ctx context.Context) error {
s.clientsMu.Lock()
s.closing = true
for c := range s.clients {
close(c.closeCh)
c.stop()
}
s.clientsMu.Unlock()
return s.http.Shutdown(ctx)
@@ -183,11 +188,24 @@ func (s *Server) handleStream(w http.ResponseWriter, r *http.Request) {
// Register client
s.clientsMu.Lock()
if s.closing {
s.clientsMu.Unlock()
http.Error(w, "server is shutting down", http.StatusServiceUnavailable)
return
}
s.clients[c] = struct{}{}
s.clientsMu.Unlock()
defer func() {
s.clientsMu.Lock()
delete(s.clients, c)
s.clientsMu.Unlock()
}()
// Initial comment to open the stream for some proxies
fmt.Fprintf(w, ": connected %s\n\n", time.Now().Format(time.RFC3339))
if _, err := fmt.Fprintf(w, ": connected %s\n\n", time.Now().Format(time.RFC3339)); err != nil {
return
}
flusher.Flush()
// Send latest if any
@@ -195,21 +213,31 @@ func (s *Server) handleStream(w http.ResponseWriter, r *http.Request) {
latest := s.latest
s.latestMu.RUnlock()
if latest != "" {
writeSSE(w, latest)
if err := writeSSE(w, latest); err != nil {
return
}
flusher.Flush()
}
// Start pump
go c.pump()
// A write the client no longer takes ends the pump; the handler then
// gives the client up without waiting for the request to end.
pumped := make(chan struct{})
go func() {
c.pump()
close(pumped)
}()
select {
case <-r.Context().Done():
case <-pumped:
}
c.stop()
<-pumped
}
// Block until client disconnects
<-r.Context().Done()
// Unregister client
close(c.closeCh)
s.clientsMu.Lock()
delete(s.clients, c)
s.clientsMu.Unlock()
// stop ends the client's pump. Shutdown and the client's own handler both
// stop it, in either order.
func (c *client) stop() {
c.closeOnce.Do(func() { close(c.closeCh) })
}
func (c *client) pump() {
@@ -220,23 +248,30 @@ func (c *client) pump() {
case <-c.closeCh:
return
case msg := <-c.ch:
writeSSE(c.w, msg)
if err := writeSSE(c.w, msg); err != nil {
return
}
c.flusher.Flush()
case <-t.C:
// heartbeat comment (keeps connections alive through proxies)
fmt.Fprint(c.w, ": hb\n\n")
if _, err := fmt.Fprint(c.w, ": hb\n\n"); err != nil {
return
}
c.flusher.Flush()
}
}
}
func writeSSE(w http.ResponseWriter, msg string) {
func writeSSE(w http.ResponseWriter, msg string) error {
// Split on lines; each needs its own "data:" field per the SSE spec
lines := strings.SplitSeq(strings.TrimRight(msg, "\n"), "\n")
for ln := range lines {
fmt.Fprintf(w, "data: %s\n", ln)
if _, err := fmt.Fprintf(w, "data: %s\n", ln); err != nil {
return err
}
}
fmt.Fprint(w, "\n")
_, err := fmt.Fprint(w, "\n")
return err
}
// Minimal index page with live updates
+275
View File
@@ -0,0 +1,275 @@
/*
Copyright 2026 The Cozystack Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package sse
import (
"context"
"errors"
"io"
"log"
"net/http"
"net/http/httptest"
"strings"
"sync"
"testing"
"time"
)
// streamWriter accepts the first okWrites writes and fails every one after.
type streamWriter struct {
mu sync.Mutex
header http.Header
okWrites int
body strings.Builder
}
func (w *streamWriter) Header() http.Header { return w.header }
func (w *streamWriter) WriteHeader(int) {}
func (w *streamWriter) Flush() {}
func (w *streamWriter) Write(p []byte) (int, error) {
w.mu.Lock()
defer w.mu.Unlock()
if w.okWrites == 0 {
return 0, errors.New("connection reset")
}
w.okWrites--
return w.body.Write(p)
}
func (w *streamWriter) String() string {
w.mu.Lock()
defer w.mu.Unlock()
return w.body.String()
}
// serve runs the stream handler for a client that never disconnects and
// reports whether the handler gave the client up within a second.
func serve(t *testing.T, s *Server, w *streamWriter, publish string) bool {
t.Helper()
ctx, cancel := context.WithCancel(context.Background())
t.Cleanup(cancel)
r := httptest.NewRequest(http.MethodGet, "/stream", nil).WithContext(ctx)
done := make(chan struct{})
go func() {
s.handleStream(w, r)
close(done)
}()
if publish != "" {
deadline := time.Now().Add(time.Second)
for len(s.snapshotClients()) == 0 && time.Now().Before(deadline) {
time.Sleep(time.Millisecond)
}
// Onto the client's queue, which only the pump reads, so the failing
// write is the pump's and not the handler's write of latest.
for _, c := range s.snapshotClients() {
c.ch <- publish
}
}
select {
case <-done:
return len(s.snapshotClients()) == 0
case <-time.After(time.Second):
return false
}
}
func (s *Server) snapshotClients() []*client {
s.clientsMu.RLock()
defer s.clientsMu.RUnlock()
var out []*client
for c := range s.clients {
out = append(out, c)
}
return out
}
func newTestServer(heartbeat time.Duration) *Server {
return New(Options{Heartbeat: heartbeat, Logger: log.New(io.Discard, "", 0)})
}
// A client whose connection stops taking writes is dropped at once, at
// whichever write first fails, instead of holding its handler until the
// request context ends.
func TestStreamDropsClientOnWriteFailure(t *testing.T) {
for _, tc := range []struct {
name string
okWrites int
latest string
publish string
heartbeat time.Duration
}{
{name: "connect comment", okWrites: 0, heartbeat: time.Hour},
{name: "latest payload", okWrites: 1, latest: "state", heartbeat: time.Hour},
{name: "published event", okWrites: 1, publish: "event", heartbeat: time.Hour},
{name: "heartbeat", okWrites: 1, heartbeat: 10 * time.Millisecond},
} {
t.Run(tc.name, func(t *testing.T) {
s := newTestServer(tc.heartbeat)
if tc.latest != "" {
s.Publish(tc.latest)
}
if !serve(t, s, &streamWriter{header: http.Header{}, okWrites: tc.okWrites}, tc.publish) {
t.Fatal("the handler kept a client whose writes fail")
}
})
}
}
// Each line of a payload is its own data field, and the event ends with an
// empty line.
func TestStreamFramesMultilinePayload(t *testing.T) {
s := newTestServer(time.Hour)
s.Publish("one\ntwo\n")
w := &streamWriter{header: http.Header{}, okWrites: 100}
ctx, cancel := context.WithCancel(context.Background())
r := httptest.NewRequest(http.MethodGet, "/stream", nil).WithContext(ctx)
done := make(chan struct{})
go func() {
s.handleStream(w, r)
close(done)
}()
deadline := time.Now().Add(time.Second)
for !strings.Contains(w.String(), "data: two\n\n") && time.Now().Before(deadline) {
time.Sleep(time.Millisecond)
}
cancel()
<-done
if got := w.String(); !strings.Contains(got, "data: one\ndata: two\n\n") {
t.Fatalf("stream = %q, want both lines framed as one event", got)
}
if len(s.snapshotClients()) != 0 {
t.Fatal("a disconnected client stayed registered")
}
}
// Shutdown ends every open stream, and the handler that then returns does
// not close the client a second time.
func TestShutdownEndsOpenStreams(t *testing.T) {
s := newTestServer(time.Hour)
w := &streamWriter{header: http.Header{}, okWrites: 100}
r := httptest.NewRequest(http.MethodGet, "/stream", nil)
done := make(chan struct{})
go func() {
s.handleStream(w, r)
close(done)
}()
deadline := time.Now().Add(time.Second)
for len(s.snapshotClients()) == 0 && time.Now().Before(deadline) {
time.Sleep(time.Millisecond)
}
if err := s.Shutdown(context.Background()); err != nil {
t.Fatal(err)
}
select {
case <-done:
case <-time.After(time.Second):
t.Fatal("Shutdown left the stream open")
}
}
// blockingWriter holds every write after the first until release is closed.
type blockingWriter struct {
streamWriter
writing chan struct{}
release chan struct{}
returned chan struct{}
}
func (w *blockingWriter) Write(p []byte) (int, error) {
if w.String() == "" {
return w.streamWriter.Write(p)
}
select {
case w.writing <- struct{}{}:
default:
}
<-w.release
return w.streamWriter.Write(p)
}
// The handler does not return while its pump is still writing: net/http does
// not allow a write to a response after ServeHTTP has returned.
func TestStreamWaitsForPumpBeforeReturning(t *testing.T) {
s := newTestServer(time.Hour)
w := &blockingWriter{
streamWriter: streamWriter{header: http.Header{}, okWrites: 100},
writing: make(chan struct{}, 1),
release: make(chan struct{}),
returned: make(chan struct{}),
}
ctx, cancel := context.WithCancel(context.Background())
r := httptest.NewRequest(http.MethodGet, "/stream", nil).WithContext(ctx)
go func() {
s.handleStream(w, r)
close(w.returned)
}()
deadline := time.Now().Add(time.Second)
for len(s.snapshotClients()) == 0 && time.Now().Before(deadline) {
time.Sleep(time.Millisecond)
}
// Straight onto the client's queue, which only the pump reads: Publish
// would also set latest, which the handler itself may still write.
s.snapshotClients()[0].ch <- "event"
select {
case <-w.writing:
case <-time.After(time.Second):
t.Fatal("the pump never wrote the event")
}
cancel()
select {
case <-w.returned:
close(w.release)
t.Fatal("the handler returned while its pump was writing")
case <-time.After(100 * time.Millisecond):
}
close(w.release)
select {
case <-w.returned:
case <-time.After(time.Second):
t.Fatal("the handler did not return once its pump finished")
}
}
// A stream that opens once Shutdown has run is refused instead of being
// registered after the clients were stopped, where nothing would end it.
func TestStreamOpenedDuringShutdownIsRefused(t *testing.T) {
s := newTestServer(time.Hour)
if err := s.Shutdown(context.Background()); err != nil {
t.Fatal(err)
}
ctx, cancel := context.WithCancel(context.Background())
t.Cleanup(cancel)
rec := httptest.NewRecorder()
r := httptest.NewRequest(http.MethodGet, "/stream", nil).WithContext(ctx)
done := make(chan struct{})
go func() {
s.handleStream(rec, r)
close(done)
}()
select {
case <-done:
case <-time.After(time.Second):
t.Fatal("a stream opened after Shutdown stayed open")
}
if rec.Code != http.StatusServiceUnavailable {
t.Errorf("status = %d, want %d", rec.Code, http.StatusServiceUnavailable)
}
if len(s.snapshotClients()) != 0 {
t.Error("a stream opened after Shutdown was registered")
}
}
+3 -3
View File
@@ -118,11 +118,11 @@ func (c *Collector) collect(ctx context.Context) {
// Write application count metrics
for kind, count := range appKindCounts {
metrics.WriteString(fmt.Sprintf(
fmt.Fprintf(&metrics,
"cozy_application_count{kind=\"%s\"} %d\n",
kind,
count,
))
)
}
// Send metrics only if there's something to send
@@ -147,7 +147,7 @@ func (c *Collector) sendMetrics(clusterID, metrics string) error {
if err != nil {
return fmt.Errorf("failed to send request: %w", err)
}
defer resp.Body.Close()
defer func() { _ = resp.Body.Close() }()
if resp.StatusCode != http.StatusOK {
return fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+12 -12
View File
@@ -133,11 +133,11 @@ func (c *OperatorCollector) collect(ctx context.Context) {
var metrics strings.Builder
// Add cluster info metric
metrics.WriteString(fmt.Sprintf(
fmt.Fprintf(&metrics,
"cozy_cluster_info{cozystack_version=\"%s\",kubernetes_version=\"%s\"} 1\n",
version.Version,
k8sVersion.GitVersion,
))
)
// Collect node metrics grouped by OS and kernel
nodeOSCount := make(map[string]map[string]int) // os -> kernel -> count
@@ -153,12 +153,12 @@ func (c *OperatorCollector) collect(ctx context.Context) {
for osKey, kernels := range nodeOSCount {
for kernel, count := range kernels {
metrics.WriteString(fmt.Sprintf(
fmt.Fprintf(&metrics,
"cozy_nodes_count{os=\"%s\",kernel=\"%s\"} %d\n",
osKey,
kernel,
count,
))
)
}
}
@@ -174,11 +174,11 @@ func (c *OperatorCollector) collect(ctx context.Context) {
}
for resourceName, total := range capacityTotals {
metrics.WriteString(fmt.Sprintf(
fmt.Fprintf(&metrics,
"cozy_cluster_capacity{resource=\"%s\"} %d\n",
resourceName,
total,
))
)
}
// Collect LoadBalancer services metrics
@@ -192,7 +192,7 @@ func (c *OperatorCollector) collect(ctx context.Context) {
lbCount++
}
}
metrics.WriteString(fmt.Sprintf("cozy_loadbalancers_count %d\n", lbCount))
fmt.Fprintf(&metrics, "cozy_loadbalancers_count %d\n", lbCount)
}
// Collect PV metrics grouped by driver and size
@@ -224,12 +224,12 @@ func (c *OperatorCollector) collect(ctx context.Context) {
for size, drivers := range pvMetrics {
for driver, count := range drivers {
metrics.WriteString(fmt.Sprintf(
fmt.Fprintf(&metrics,
"cozy_pvs_count{driver=\"%s\",size=\"%s\"} %d\n",
driver,
size,
count,
))
)
}
}
}
@@ -244,11 +244,11 @@ func (c *OperatorCollector) collect(ctx context.Context) {
if variant == "" {
variant = "default"
}
metrics.WriteString(fmt.Sprintf(
fmt.Fprintf(&metrics,
"cozy_package_info{name=\"%s\",variant=\"%s\"} 1\n",
pkg.Name,
variant,
))
)
}
}
@@ -272,7 +272,7 @@ func (c *OperatorCollector) sendMetrics(clusterID, metrics string) error {
if err != nil {
return fmt.Errorf("failed to send request: %w", err)
}
defer resp.Body.Close()
defer func() { _ = resp.Body.Close() }()
if resp.StatusCode != http.StatusOK {
return fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+3 -3
View File
@@ -78,7 +78,7 @@ func init() {
// Register HelmRelease types.
if err := helmv2.AddToScheme(mgrScheme); err != nil {
panic(fmt.Errorf("Failed to add HelmRelease types to scheme: %w", err))
panic(fmt.Errorf("failed to add HelmRelease types to scheme: %w", err))
}
// Register the in-tree CiliumNetworkPolicy mirror backing SecurityGroup.
@@ -87,10 +87,10 @@ func init() {
}
if err := corev1.AddToScheme(mgrScheme); err != nil {
panic(fmt.Errorf("Failed to add core types to scheme: %w", err))
panic(fmt.Errorf("failed to add core types to scheme: %w", err))
}
if err := rbacv1.AddToScheme(mgrScheme); err != nil {
panic(fmt.Errorf("Failed to add RBAC types to scheme: %w", err))
panic(fmt.Errorf("failed to add RBAC types to scheme: %w", err))
}
// Register Cozystack types for WorkloadMonitor queries.
+2 -2
View File
@@ -319,7 +319,7 @@ func BuildPostProcessV3(kindSchemas map[string]string) func(*spec3.OpenAPI) (*sp
base, ok1 := doc.Components.Schemas[baseRef]
list, ok2 := doc.Components.Schemas[baseListRef]
stat, ok3 := doc.Components.Schemas[baseStatusRef]
if !(ok1 && ok2 && ok3) {
if !ok1 || !ok2 || !ok3 {
return doc, nil // not the apps GV — nothing to patch
}
@@ -463,7 +463,7 @@ func BuildPostProcessV2(kindSchemas map[string]string) func(*spec.Swagger) (*spe
base, ok1 := defs[baseRef]
list, ok2 := defs[baseListRef]
stat, ok3 := defs[baseStatusRef]
if !(ok1 && ok2 && ok3) {
if !ok1 || !ok2 || !ok3 {
return sw, nil // not the apps GV — nothing to patch
}
+1 -1
View File
@@ -104,7 +104,7 @@ func watchStream(t *testing.T, ts *httptest.Server, cli client.Client, query str
if err != nil {
t.Fatalf("watch: %v", err)
}
defer resp.Body.Close()
defer func() { _ = resp.Body.Close() }()
if resp.StatusCode != http.StatusOK {
t.Fatalf("watch: status %d", resp.StatusCode)
}
+70
View File
@@ -0,0 +1,70 @@
package lineage
import (
"context"
"fmt"
"strings"
"testing"
helmv2 "github.com/fluxcd/helm-controller/api/v2"
"k8s.io/apimachinery/pkg/api/meta"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/runtime"
dynamicfake "k8s.io/client-go/dynamic/fake"
)
// namedAppMapper maps a HelmRelease to the Kubernetes application it names;
// a HelmRelease missing from the map fails to map.
type namedAppMapper map[string]string
func (m namedAppMapper) Map(hr *helmv2.HelmRelease) (string, string, string, error) {
app, ok := m[hr.Name]
if !ok {
return "", "", "", fmt.Errorf("no application for HelmRelease %s", hr.Name)
}
return "apps.cozystack.io/v1alpha1", "Kubernetes", strings.TrimSuffix(hr.Name, app), nil
}
// A HelmRelease that cannot be resolved to its application hands the walk to
// the HelmRelease its label names; one that resolves ends the walk there.
func TestWalkHelmReleaseFallsBackToItsLabel(t *testing.T) {
parent := map[string]string{HRLabel: "kubernetes-b"}
unconvertible := capkObject(HRAPIVersion, HRKind, "kubernetes-a", parent, nil)
unconvertible.Object["spec"] = "not an object"
for _, tc := range []struct {
name string
hr *unstructured.Unstructured
mapped namedAppMapper
want []string
}{
{name: "mapped", hr: capkObject(HRAPIVersion, HRKind, "kubernetes-a", parent, nil), mapped: namedAppMapper{"kubernetes-a": "a", "kubernetes-b": "b"}, want: []string{"a"}},
{name: "unmappable", hr: capkObject(HRAPIVersion, HRKind, "kubernetes-a", parent, nil), mapped: namedAppMapper{"kubernetes-b": "b"}, want: []string{"b"}},
{name: "application missing", hr: capkObject(HRAPIVersion, HRKind, "kubernetes-a", parent, nil), mapped: namedAppMapper{"kubernetes-a": "absent", "kubernetes-b": "b"}, want: []string{"b"}},
{name: "unconvertible", hr: unconvertible, mapped: namedAppMapper{"kubernetes-a": "a", "kubernetes-b": "b"}, want: []string{"b"}},
{name: "unmappable without a label", hr: capkObject(HRAPIVersion, HRKind, "kubernetes-a", nil, nil), mapped: namedAppMapper{"kubernetes-b": "b"}, want: nil},
} {
t.Run(tc.name, func(t *testing.T) {
objs := []runtime.Object{
capkObject("apps.cozystack.io/v1alpha1", "Kubernetes", "a", nil, nil),
capkObject("apps.cozystack.io/v1alpha1", "Kubernetes", "b", nil, nil),
capkObject(HRAPIVersion, HRKind, "kubernetes-b", nil, nil),
}
mapper := meta.NewDefaultRESTMapper(nil)
for _, o := range objs {
mapper.Add(o.GetObjectKind().GroupVersionKind(), meta.RESTScopeNamespace)
}
dyn := dynamicfake.NewSimpleDynamicClient(runtime.NewScheme(), objs...)
var got []string
for _, id := range WalkOwnershipGraph(context.Background(), dyn, mapper, tc.mapped, tc.hr) {
got = append(got, id.Kind+"/"+id.Name)
}
var want []string
for _, name := range tc.want {
want = append(want, "Kubernetes/"+name)
}
if strings.Join(got, ",") != strings.Join(want, ",") {
t.Fatalf("WalkOwnershipGraph(%s) = %v, want %v", tc.name, got, want)
}
})
}
}
+29 -30
View File
@@ -113,36 +113,8 @@ func WalkOwnershipGraph(
return
}
// I want "if err1 != nil go to next block, if err2 != nil, go to next block, etc semantics",
// like an early return from a function, but if all checks succeed, I don't want to do the rest
// of the function, so it's a `for { if err { break } if othererr { break } if allgood { return }
for {
if obj.GetAPIVersion() != HRAPIVersion || obj.GetKind() != HRKind {
break
}
hr := helmReleaseFromUnstructured(obj)
if hr == nil {
break
}
a, k, p, err := appMapper.Map(hr)
if err != nil {
l.Error(err, "failed to map HelmRelease to app")
break
}
ownerObj, err := getUnstructuredObject(ctx, client, mapper, state.cache, a, k, obj.GetNamespace(), strings.TrimPrefix(obj.GetName(), p))
if err != nil {
l.Error(err, "couldn't get unstructured object", "APIVersion", a, "Kind", k, "Name", strings.TrimPrefix(obj.GetName(), p))
break
}
// successfully mapped a HelmRelease to a custom app, no need to continue
out = append(out,
ObjectID{
APIVersion: ownerObj.GetAPIVersion(),
Kind: ownerObj.GetKind(),
Namespace: ownerObj.GetNamespace(),
Name: ownerObj.GetName(),
},
)
if app, ok := helmReleaseApp(ctx, client, mapper, appMapper, state.cache, obj); ok {
out = append(out, app)
return
}
@@ -160,6 +132,33 @@ func WalkOwnershipGraph(
return
}
// helmReleaseApp resolves a HelmRelease to the application it deploys. When
// it cannot, the walk goes on through the HelmRelease's own label instead.
func helmReleaseApp(ctx context.Context, client dynamic.Interface, mapper meta.RESTMapper, appMapper AppMapper, cache *ObjectCache, obj *unstructured.Unstructured) (ObjectID, bool) {
hr := helmReleaseFromUnstructured(obj)
if hr == nil {
return ObjectID{}, false
}
l := log.FromContext(ctx)
a, k, p, err := appMapper.Map(hr)
if err != nil {
l.Error(err, "failed to map HelmRelease to app")
return ObjectID{}, false
}
name := strings.TrimPrefix(obj.GetName(), p)
app, err := getUnstructuredObject(ctx, client, mapper, cache, a, k, obj.GetNamespace(), name)
if err != nil {
l.Error(err, "couldn't get unstructured object", "APIVersion", a, "Kind", k, "Name", name)
return ObjectID{}, false
}
return ObjectID{
APIVersion: app.GetAPIVersion(),
Kind: app.GetKind(),
Namespace: app.GetNamespace(),
Name: app.GetName(),
}, true
}
// kubevirtMachineName returns the KubevirtMachine a CAPK-created
// VirtualMachine belongs to. It only follows a KubevirtMachine in the VM's own
// namespace: CAPK can also run against an external infrastructure cluster,
-27
View File
@@ -277,33 +277,6 @@ func defaultRunner(ctx context.Context, bin string, args ...string) (string, err
return out, nil
}
/************** Helpers **************/
func parseClusterStatusJSON(out string) (ClusterStatus, bool) {
var cs ClusterStatus
if json.Unmarshal([]byte(out), &cs) == nil && len(cs.Servers) > 0 {
return cs, true
}
var wrap struct {
Data ClusterStatus `json:"data"`
}
if json.Unmarshal([]byte(out), &wrap) == nil && len(wrap.Data.Servers) > 0 {
return wrap.Data, true
}
return ClusterStatus{}, false
}
func portOf(db DB) string {
switch db {
case DBNorthbound:
return "6641"
case DBSouthbound:
return "6642"
default:
return "0"
}
}
/************** Minimal text fallback for "Servers" **************/
// Accepts variants like:
+1 -3
View File
@@ -28,9 +28,7 @@ var expectedServersBlock = `` +
func TestExtractServersBlock(t *testing.T) {
if actual := extractServersBlock(testStdout); actual != expectedServersBlock {
fmt.Println([]byte(actual))
fmt.Println([]byte(expectedServersBlock))
t.Errorf("error extracting servers block from following string:\n%s\nexpected:\n%s\ngot:\n%s\n", testStdout, expectedServersBlock, actual)
t.Errorf("error extracting servers block from following string:\n%s\nexpected:\n%q\ngot:\n%q\n", testStdout, expectedServersBlock, actual)
}
}
+13 -3
View File
@@ -17,7 +17,9 @@ limitations under the License.
package registry
import (
"encoding/json"
"reflect"
"strings"
"testing"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -26,7 +28,6 @@ import (
func TestClientWriteOptionsPreserveAPISemantics(t *testing.T) {
grace := int64(7)
orphan := true
propagation := metav1.DeletePropagationForeground
uid := types.UID("expected-uid")
rv := "42"
@@ -74,11 +75,20 @@ func TestClientWriteOptionsPreserveAPISemantics(t *testing.T) {
t.Fatalf("conversion mutated API options: create=%#v update=%#v delete=%#v", create, update, deleteOptions)
}
orphanDelete := &metav1.DeleteOptions{OrphanDependents: &orphan, DryRun: []string{metav1.DryRunAll}}
// orphanDependents is deprecated in Go but still accepted on the wire,
// which is how a raw-only option reaches the registry.
orphanDelete := &metav1.DeleteOptions{}
if err := json.Unmarshal([]byte(`{"orphanDependents":true,"dryRun":["All"]}`), orphanDelete); err != nil {
t.Fatal(err)
}
orphanExpected := orphanDelete.DeepCopy()
if got := ClientDeleteOptions(orphanDelete).AsDeleteOptions(); !reflect.DeepEqual(got, orphanExpected) {
got := ClientDeleteOptions(orphanDelete).AsDeleteOptions()
if !reflect.DeepEqual(got, orphanExpected) {
t.Fatalf("raw-only delete option lost: got %#v, want %#v", got, orphanExpected)
}
if wire, err := json.Marshal(got); err != nil || !strings.Contains(string(wire), `"orphanDependents":true`) {
t.Fatalf("converted delete options = %s (%v), want orphanDependents kept", wire, err)
}
if !reflect.DeepEqual(orphanDelete, orphanExpected) {
t.Fatalf("raw-only delete conversion mutated input: got %#v, want %#v", orphanDelete, orphanExpected)
}
+3 -3
View File
@@ -284,9 +284,9 @@ func mulQuantity(q, n ref.Val) ref.Val {
if !ok {
return types.MaybeNoSuchOverloadErr(n)
}
out := qq.Quantity.DeepCopy()
out := qq.DeepCopy()
if !out.Mul(int64(nn)) {
return types.NewErr("quantity %s * %d overflows", qq.Quantity.String(), int64(nn))
return types.NewErr("quantity %s * %d overflows", qq.String(), int64(nn))
}
return apiservercel.Quantity{Quantity: &out}
}
@@ -294,7 +294,7 @@ func mulQuantity(q, n ref.Val) ref.Val {
func toQuantity(v ref.Val) (resource.Quantity, error) {
switch t := v.(type) {
case apiservercel.Quantity:
return t.Quantity.DeepCopy(), nil
return t.DeepCopy(), nil
case types.Int:
return *resource.NewQuantity(int64(t), resource.DecimalSI), nil
case types.Uint:
+3 -1
View File
@@ -56,7 +56,9 @@ func shippedInstancetypes(t *testing.T) []map[string]any {
out = append(out, obj)
}
}
fh.Close()
if err := fh.Close(); err != nil {
t.Fatalf("%s: %v", f, err)
}
}
return out
}
+79
View File
@@ -13,6 +13,7 @@ package checkreadiness_test
import (
"bytes"
"context"
"errors"
"flag"
"fmt"
@@ -23,6 +24,7 @@ import (
"runtime"
"strings"
"testing"
"time"
)
var update = flag.Bool("update", false, "regenerate golden files")
@@ -335,3 +337,80 @@ func repoRoot(t *testing.T) string {
}
return root
}
// A result that never reaches stdout fails the run, whatever the cluster's
// state, and the watch loop stops instead of refreshing into the void. stdout
// is a read-only descriptor, so every write fails without a SIGPIPE.
func TestUnwritableStdoutFails(t *testing.T) {
root := repoRoot(t)
fakeBin := filepath.Join(root, "test", "check-readiness", "fakekubectl")
base := filepath.Join(root, "test", "check-readiness", "testdata", "fixtures", "_base")
for _, tc := range []struct {
name string
args []string
}{
{name: "once", args: []string{"--no-color"}},
{name: "wait", args: []string{"--wait", "--no-color"}},
{name: "watch", args: []string{"-w", "1", "--no-color"}},
} {
t.Run(tc.name, func(t *testing.T) {
stdout, err := os.Open(os.DevNull)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = stdout.Close() })
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
t.Cleanup(cancel)
argv := subjectArgv(tc.args)
cmd := exec.CommandContext(ctx, argv[0], argv[1:]...)
cmd.Env = testEnv(fakeBin, base, base, filepath.Join(t.TempDir(), "kubectl.log"))
var stderr bytes.Buffer
cmd.Stdout, cmd.Stderr = stdout, &stderr
runErr := cmd.Run()
if ctx.Err() != nil {
t.Fatalf("still running after its output failed\nstderr:\n%s", stderr.String())
}
if code := exitCode(t, runErr); code != 1 {
t.Errorf("exit code = %d, want 1\nstderr:\n%s", code, stderr.String())
}
if !strings.Contains(stderr.String(), "writing output") {
t.Errorf("stderr does not say the output was lost:\n%s", stderr.String())
}
})
}
}
// A wait that times out ends with its verdict: the table comes first and the
// timeout line last, also when the table could not be written.
func TestWaitTimeoutVerdictComesLast(t *testing.T) {
root := repoRoot(t)
fakeBin := filepath.Join(root, "test", "check-readiness", "fakekubectl")
fixtures := filepath.Join(root, "test", "check-readiness", "testdata", "fixtures")
args := []string{"-w", "1", "--wait", "--timeout", "1s", "--no-color"}
for _, unwritable := range []bool{false, true} {
t.Run(fmt.Sprintf("unwritable=%v", unwritable), func(t *testing.T) {
cmd := scriptCommand(args)
cmd.Env = testEnv(fakeBin, filepath.Join(fixtures, "helmrelease-not-ready"), filepath.Join(fixtures, "_base"), filepath.Join(t.TempDir(), "kubectl.log"))
var combined bytes.Buffer
cmd.Stdout, cmd.Stderr = &combined, &combined
if unwritable {
stdout, err := os.Open(os.DevNull)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = stdout.Close() })
cmd.Stdout = stdout
}
if code := exitCode(t, cmd.Run()); code != 1 {
t.Errorf("exit code = %d, want 1\n%s", code, combined.String())
}
lines := strings.Split(strings.TrimRight(combined.String(), "\n"), "\n")
if last := lines[len(lines)-1]; !strings.HasPrefix(last, "Timeout after") {
t.Errorf("last line = %q, want the timeout verdict\n%s", last, combined.String())
}
if unwritable && !strings.Contains(combined.String(), "writing output") {
t.Errorf("stderr does not say the table was lost:\n%s", combined.String())
}
})
}
}
+4
View File
@@ -21,3 +21,7 @@ Options:
--no-color Disable color output (auto-disabled on non-TTY)
-h, --help Show this help
Exit status: 0 when everything is ready, 1 when something is not ready or a
write to stdout fails, 2 on invalid arguments. A closed pipe ends the process
with SIGPIPE, like other Unix tools.
@@ -21,3 +21,7 @@ Options:
--no-color Disable color output (auto-disabled on non-TTY)
-h, --help Show this help
Exit status: 0 when everything is ready, 1 when something is not ready or a
write to stdout fails, 2 on invalid arguments. A closed pipe ends the process
with SIGPIPE, like other Unix tools.
@@ -22,3 +22,7 @@ Options:
--no-color Disable color output (auto-disabled on non-TTY)
-h, --help Show this help
Exit status: 0 when everything is ready, 1 when something is not ready or a
write to stdout fails, 2 on invalid arguments. A closed pipe ends the process
with SIGPIPE, like other Unix tools.
@@ -22,3 +22,7 @@ Options:
--no-color Disable color output (auto-disabled on non-TTY)
-h, --help Show this help
Exit status: 0 when everything is ready, 1 when something is not ready or a
write to stdout fails, 2 on invalid arguments. A closed pipe ends the process
with SIGPIPE, like other Unix tools.