mirror of
https://github.com/cozystack/cozystack.git
synced 2026-11-21 12:13:55 +09:00
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:
72 files changed
+1681
-350
No files matched your search
@@ -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
|
||||
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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 }
|
||||
|
||||
@@ -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/zerowidth.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)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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")
|
||||
}
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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
@@ -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)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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
@@ -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() {
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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
@@ -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",
|
||||
|
||||
@@ -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
|
||||
},
|
||||
|
||||
@@ -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()
|
||||
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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, ¬FoundError{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{}
|
||||
|
||||
@@ -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
@@ -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
|
||||
|
||||
@@ -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")
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
|
||||
@@ -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
@@ -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,
|
||||
|
||||
@@ -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:
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
|
||||
@@ -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:
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
@@ -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())
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -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.
|
||||
|
||||
Reference in new issue
Block a user