A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
fix(rexctl): load whole sites from caddy.d/sites (#3713)
Hampus2da58f01ffb6
diff --git a/deploy/helm/fluxer/files/Caddyfile b/deploy/helm/fluxer/files/Caddyfileindex 3fe3623cd..1245e358a 100644--- a/deploy/helm/fluxer/files/Caddyfile+++ b/deploy/helm/fluxer/files/Caddyfile@@ -86,3 +86,5 @@respond "{system.hostname}" 200}}++import /etc/caddy/conf.d/sites/*.caddydiff --git a/fluxer_docs/src/content/docs/operator/running.mdx b/fluxer_docs/src/content/docs/operator/running.mdxindex 1806394fd..820017460 100644--- a/fluxer_docs/src/content/docs/operator/running.mdx+++ b/fluxer_docs/src/content/docs/operator/running.mdx@@ -182,7 +182,7 @@ To change the Compose setup, such as labels, images, ports or volumes, run `rexcrexctl config edit```-To add your own Caddy directives, such as extra routes or headers, put them in a `.caddy` file in the `caddy.d` folder of your instance. Fluxer's Caddyfile loads every file there inside your site, and upgrades keep them. To use your own Caddyfile instead, mount it over `/etc/caddy/Caddyfile` on the `edge` service in `custom.compose.yml`.+To add your own Caddy directives, such as extra routes or headers, put them in a `.caddy` file in the `caddy.d` folder of your instance. Fluxer's Caddyfile loads every file there inside your site, and upgrades keep them. To serve a whole extra site, such as another domain on the same machine, put its `.caddy` file in `caddy.d/sites`. Fluxer loads those files next to its own site, and `rexctl upgrade` moves a file of whole sites from `caddy.d` to `caddy.d/sites` for you. To use your own Caddyfile instead, mount it over `/etc/caddy/Caddyfile` on the `edge` service in `custom.compose.yml`.## When something is wrongdiff --git a/fluxer_rexctl/cmd/restore.go b/fluxer_rexctl/cmd/restore.goindex ed7ff4354..78718b166 100644--- a/fluxer_rexctl/cmd/restore.go+++ b/fluxer_rexctl/cmd/restore.go@@ -197,6 +197,7 @@ func restoreInto(ctx context.Context, app *App, e *engine.Engine, path, dir stris.Progress(ev.Current, ev.Total)}},+ Adopted: matchRestoredSites(app),})if err != nil {return errdiff --git a/fluxer_rexctl/cmd/rollback.go b/fluxer_rexctl/cmd/rollback.goindex 9a408b31c..79e285b48 100644--- a/fluxer_rexctl/cmd/rollback.go+++ b/fluxer_rexctl/cmd/rollback.go@@ -244,11 +244,14 @@ func rollbackWithBackup(ctx context.Context, app *App, inst *instance.Instance,return err}return app.UI.Step(ctx, "Restoring the backup from "+when, func(ctx context.Context, s *ui.Step) error {- restored, err := backup.Restore(ctx, info.Path, inst.Dir, e, backup.RestoreOptions{Progress: func(stage string) {- if t := restoreStageTitle(stage); t != "" {- s.Title(t)- }- }})+ restored, err := backup.Restore(ctx, info.Path, inst.Dir, e, backup.RestoreOptions{+ Progress: func(stage string) {+ if t := restoreStageTitle(stage); t != "" {+ s.Title(t)+ }+ },+ Adopted: matchRestoredSites(app),+ })if err != nil {if errors.Is(err, backup.ErrUploadsNotHere) {return uploadsNotHere(inst, info.Domain, info.Project, err)diff --git a/fluxer_rexctl/cmd/sites_test.go b/fluxer_rexctl/cmd/sites_test.gonew file mode 100644index 000000000..c47dba491--- /dev/null+++ b/fluxer_rexctl/cmd/sites_test.go@@ -0,0 +1,189 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++package cmd++import (+ "bytes"+ "os"+ "path/filepath"+ "slices"+ "strings"+ "testing"++ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/instance"+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/stack"+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/ui"+)++const (+ legacyCaddyfile = "{\n\temail [email protected]\n}\n\nimport /etc/caddy/conf.d/*.caddy\n\n{$FLUXER_DOMAIN} {\n\treverse_proxy app:8080\n}\n"+ mastodonSite = "mastodon.tails.ch {\n\treverse_proxy 10.0.4.22:3000\n}\n"+ importingSite = "import common\nwiki.tails.ch {\n\trespond ok\n}\n"+)++func sitesInstance(t *testing.T, release string, caddyfile []byte) (*App, *instance.Instance, *bytes.Buffer) {+ t.Helper()+ inst, err := instance.Create(t.TempDir(), "fluxer")+ if err != nil {+ t.Fatal(err)+ }+ inst.State.Release = release+ if caddyfile != nil {+ compose, err := stack.ReadFile(stack.Embedded(), stack.ComposeFile)+ if err != nil {+ t.Fatal(err)+ }+ writeFile(t, filepath.Join(inst.SetDir(release), stack.ComposeFile), compose)+ writeFile(t, filepath.Join(inst.SetDir(release), stack.Caddyfile), caddyfile)+ }+ if err := inst.Save(); err != nil {+ t.Fatal(err)+ }+ out := &bytes.Buffer{}+ app := &App{UI: ui.New(ui.Options{Stdin: strings.NewReader(""), Stdout: out, Stderr: out})}+ return app, inst, out+}++func writeFile(t *testing.T, path string, data []byte) {+ t.Helper()+ if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {+ t.Fatal(err)+ }+ if err := os.WriteFile(path, data, 0o644); err != nil {+ t.Fatal(err)+ }+}++func caddyFilesIn(t *testing.T, dir string) []string {+ t.Helper()+ matches, err := filepath.Glob(filepath.Join(dir, "*.caddy"))+ if err != nil {+ t.Fatal(err)+ }+ var out []string+ for _, m := range matches {+ out = append(out, filepath.Base(m))+ }+ return out+}++func TestRollbackToLegacyMovesSitesBackAndUpgradeMovesThemAgain(t *testing.T) {+ app, inst, out := sitesInstance(t, stack.LegacyRelease, []byte(legacyCaddyfile))+ writeFile(t, inst.Path(instance.CaddySitesDir, "Mastodon.caddy"), []byte(mastodonSite))+ writeFile(t, inst.Path(instance.CaddySitesDir, "wiki.caddy"), []byte(importingSite))+ if err := matchSites(app, inst); err != nil {+ t.Fatal(err)+ }+ want := []string{"Mastodon.caddy", "wiki.caddy"}+ if got := caddyFilesIn(t, inst.Path(instance.CaddyDropInDir)); !slices.Equal(got, want) {+ t.Fatalf("caddy.d has %v, want %v", got, want)+ }+ if got := caddyFilesIn(t, inst.Path(instance.CaddySitesDir)); len(got) > 0 {+ t.Fatalf("caddy.d/sites still has %v", got)+ }+ if !slices.Equal(inst.State.MovedSites, want) {+ t.Fatalf("recorded %v, want %v", inst.State.MovedSites, want)+ }+ if !strings.Contains(out.String(), "Moved caddy.d/sites/Mastodon.caddy to caddy.d/Mastodon.caddy.") {+ t.Fatalf("output %q", out.String())+ }+ saved, err := instance.Find(inst.Dir)+ if err != nil {+ t.Fatal(err)+ }+ if !slices.Equal(saved.State.MovedSites, want) {+ t.Fatalf("saved record %v, want %v", saved.State.MovedSites, want)+ }++ inst.State.Release = stack.Embedded().Release+ inst.State.Upgrade = &instance.Upgrade{From: stack.LegacyRelease, To: inst.State.Release}+ if err := moveSites(app, inst); err != nil {+ t.Fatal(err)+ }+ if got := caddyFilesIn(t, inst.Path(instance.CaddySitesDir)); !slices.Equal(got, want) {+ t.Fatalf("caddy.d/sites has %v after the upgrade, want %v", got, want)+ }+ if !slices.Equal(inst.State.Upgrade.Sites, want) {+ t.Fatalf("upgrade record %v, want %v", inst.State.Upgrade.Sites, want)+ }++ clearUpgrade(inst)+ if got := caddyFilesIn(t, inst.Path(instance.CaddyDropInDir)); !slices.Equal(got, want) {+ t.Fatalf("caddy.d has %v after a stopped upgrade, want %v", got, want)+ }+ if !slices.Equal(inst.State.MovedSites, want) {+ t.Fatalf("record after a stopped upgrade %v, want %v", inst.State.MovedSites, want)+ }+}++func TestRollbackToReleaseWithSitesLeavesThemPut(t *testing.T) {+ app, inst, out := sitesInstance(t, stack.Embedded().Release, nil)+ writeFile(t, inst.Path(instance.CaddySitesDir, "Mastodon.caddy"), []byte(mastodonSite))+ if err := matchSites(app, inst); err != nil {+ t.Fatal(err)+ }+ if got := caddyFilesIn(t, inst.Path(instance.CaddySitesDir)); !slices.Equal(got, []string{"Mastodon.caddy"}) {+ t.Fatalf("caddy.d/sites has %v", got)+ }+ if got := caddyFilesIn(t, inst.Path(instance.CaddyDropInDir)); len(got) > 0 {+ t.Fatalf("caddy.d has %v", got)+ }+ if len(inst.State.MovedSites) > 0 || out.Len() > 0 {+ t.Fatalf("recorded %v, output %q", inst.State.MovedSites, out.String())+ }+}++func TestGoingForwardToReleaseWithSitesRestoresRecordedFiles(t *testing.T) {+ app, inst, _ := sitesInstance(t, stack.Embedded().Release, nil)+ writeFile(t, inst.Path(instance.CaddyDropInDir, "wiki.caddy"), []byte(importingSite))+ inst.State.MovedSites = []string{"wiki.caddy"}+ if err := matchSites(app, inst); err != nil {+ t.Fatal(err)+ }+ if got := caddyFilesIn(t, inst.Path(instance.CaddySitesDir)); !slices.Equal(got, []string{"wiki.caddy"}) {+ t.Fatalf("caddy.d/sites has %v", got)+ }+ if inst.State.MovedSites != nil {+ t.Fatalf("record %v left", inst.State.MovedSites)+ }+}++func TestRollbackToReleaseWithoutSitesImportLeavesThemPut(t *testing.T) {+ data, err := stack.ReadFile(stack.Embedded(), stack.Caddyfile)+ if err != nil {+ t.Fatal(err)+ }+ older := bytes.Replace(data, []byte("\nimport /etc/caddy/conf.d/sites/*.caddy\n"), nil, 1)+ if bytes.Equal(older, data) {+ t.Fatal("the shipped Caddyfile has no sites import to take out")+ }+ app, inst, out := sitesInstance(t, "2026.1029.100000", older)+ writeFile(t, inst.Path(instance.CaddySitesDir, "Mastodon.caddy"), []byte(mastodonSite))+ if err := matchSites(app, inst); err != nil {+ t.Fatal(err)+ }+ if got := caddyFilesIn(t, inst.Path(instance.CaddySitesDir)); !slices.Equal(got, []string{"Mastodon.caddy"}) {+ t.Fatalf("caddy.d/sites has %v", got)+ }+ if len(inst.State.MovedSites) > 0 {+ t.Fatalf("recorded %v", inst.State.MovedSites)+ }+ if !strings.Contains(out.String(), "doesn't load caddy.d/sites") {+ t.Fatalf("output %q", out.String())+ }+}++func TestRestoredLegacyBackupLoadsSitesFromCaddyDropIns(t *testing.T) {+ app, inst, _ := sitesInstance(t, stack.LegacyRelease, []byte(legacyCaddyfile))+ writeFile(t, inst.Path(instance.CaddySitesDir, "Mastodon.caddy"), []byte(mastodonSite))+ matchRestoredSites(app)(inst)+ if got := caddyFilesIn(t, inst.Path(instance.CaddyDropInDir)); !slices.Equal(got, []string{"Mastodon.caddy"}) {+ t.Fatalf("caddy.d has %v", got)+ }+ if got := caddyFilesIn(t, inst.Path(instance.CaddySitesDir)); len(got) > 0 {+ t.Fatalf("caddy.d/sites still has %v", got)+ }+ if !slices.Equal(inst.State.MovedSites, []string{"Mastodon.caddy"}) {+ t.Fatalf("recorded %v", inst.State.MovedSites)+ }+}diff --git a/fluxer_rexctl/cmd/upgrade.go b/fluxer_rexctl/cmd/upgrade.goindex 9f33a4f9e..cbd7dc56b 100644--- a/fluxer_rexctl/cmd/upgrade.go+++ b/fluxer_rexctl/cmd/upgrade.go@@ -720,7 +720,13 @@ func upgradeStack(ctx context.Context, app *App, inst *instance.Instance, e *engreturn ui.Refused(spaceLine(sp, toShort)+" "+capitalise(fluxerName(fromShort))+" is still running.", spaceFix(e, sp))}}- if err := pullRelease(ctx, app, inst, e, set, next, toShort); err != nil {+ if !f.Prefetch {+ if err := moveSites(app, inst); err != nil {+ clearUpgrade(inst)+ return ui.Wrap(err, fmt.Sprintf("Couldn't move your sites in %s to %s.", instance.CaddyDropInDir, instance.CaddySitesDir), "Check that you can write to "+inst.Path(instance.CaddyDropInDir)+", then run rexctl upgrade again.")+ }+ }+ if err := pullRelease(ctx, app, inst, e, set, next, toShort, f.Prefetch); err != nil {clearUpgrade(inst)if ctx.Err() != nil {app.UI.Info("Stopped the upgrade. %s is still running.", capitalise(fluxerName(fromShort)))@@ -911,6 +917,12 @@ func retryUpgrade(ctx context.Context, app *App, inst *instance.Instance, e *engif err != nil {return engineFailure(err)}+ if err := moveSites(app, inst); err != nil {+ return ui.Wrap(err, fmt.Sprintf("Couldn't move your sites in %s to %s.", instance.CaddyDropInDir, instance.CaddySitesDir), release.UnfinishedFix(pend))+ }+ if err := checkEdge(ctx, inst, p, "", toShort, release.UnfinishedFix(pend)); err != nil {+ return err+ }waiting, err := startRelease(ctx, app, target, e, p, toShort)if err != nil {if ctx.Err() != nil {@@ -1012,7 +1024,7 @@ func refList(refs map[string]string) []string {return slices.Sorted(maps.Values(refs))}-func pullRelease(ctx context.Context, app *App, inst *instance.Instance, e *engine.Engine, set *stack.Set, next *instance.State, toShort string) error {+func pullRelease(ctx context.Context, app *App, inst *instance.Instance, e *engine.Engine, set *stack.Set, next *instance.State, toShort string, prefetch bool) error {scratch := filepath.Join(release.Dir(inst, next.Release), scratchDir)defer os.RemoveAll(scratch)r, err := stack.RenderAt(set, stack.OverlaysFor(next.Settings), next.Images.Refs, inst.Project(), scratch, inst.OldLayout())@@ -1075,7 +1087,10 @@ func pullRelease(ctx context.Context, app *App, inst *instance.Instance, e *engireturn nil})if err == nil {- return nil+ if prefetch {+ return nil+ }+ return checkEdge(ctx, inst, p, filepath.Join(filepath.Dir(base[0]), stack.Caddyfile), toShort, still)}if ctx.Err() != nil {return ctx.Err()@@ -1089,6 +1104,81 @@ func pullRelease(ctx context.Context, app *App, inst *instance.Instance, e *engireturn ui.Wrap(err, fmt.Sprintf("Couldn't download Fluxer %s. %s", toShort, still), "Check this machine's internet connection, then run rexctl upgrade again.")}+func moveSites(app *App, inst *instance.Instance) error {+ moved, err := inst.RestoreSites(inst.State.MovedSites)+ if err == nil {+ var found []string+ found, err = inst.MoveSites()+ moved = append(moved, found...)+ }+ if pend := inst.State.Upgrade; pend != nil && len(moved) > 0 {+ pend.Sites = slices.Compact(slices.Sorted(slices.Values(append(pend.Sites, moved...))))+ if serr := inst.Save(); err == nil {+ err = serr+ }+ }+ for _, f := range moved {+ app.UI.Info("Moved %s/%s to %s/%s. It defines its own site.", instance.CaddyDropInDir, f, instance.CaddySitesDir, f)+ }+ return err+}++func matchSites(app *App, inst *instance.Instance) error {+ set, err := inst.Set()+ if err != nil {+ return nil+ }+ data, err := stack.ReadFile(set, stack.Caddyfile)+ if err != nil {+ return nil+ }+ switch sites, dropIns := instance.TopLevelImports(data); {+ case sites:+ back, err := inst.RestoreSites(inst.State.MovedSites)+ for _, f := range back {+ app.UI.Info("Moved %s/%s to %s/%s.", instance.CaddyDropInDir, f, instance.CaddySitesDir, f)+ }+ if err != nil || len(inst.State.MovedSites) == 0 {+ return err+ }+ inst.State.MovedSites = nil+ return inst.Save()+ case dropIns:+ moved, err := inst.UnloadSites()+ for _, f := range moved {+ app.UI.Info("Moved %s/%s to %s/%s. The release you went back to loads sites from there.", instance.CaddySitesDir, f, instance.CaddyDropInDir, f)+ }+ if len(moved) > 0 {+ inst.State.MovedSites = slices.Compact(slices.Sorted(slices.Values(append(inst.State.MovedSites, moved...))))+ if serr := inst.Save(); err == nil {+ err = serr+ }+ }+ return err+ }+ if files, err := inst.SiteFiles(); err == nil && len(files) > 0 {+ app.UI.Warn(fmt.Sprintf("The release you went back to doesn't load %s. The sites there stay off until you upgrade.", instance.CaddySitesDir), "")+ }+ return nil+}++func matchRestoredSites(app *App) func(*instance.Instance) {+ return func(inst *instance.Instance) {+ if err := matchSites(app, inst); err != nil {+ app.UI.Warn(fmt.Sprintf("Couldn't move the Caddy sites to where Fluxer %s loads them (%v).", release.Short(inst.State.Release), err), "Check "+instance.CaddyDropInDir+" and "+instance.CaddySitesDir+" before you reload Caddy.")+ }+ }+}++func checkEdge(ctx context.Context, inst *instance.Instance, p *engine.Project, caddyfile, toShort, still string) error {+ err := deploy.CheckEdge(ctx, inst, p, caddyfile)+ var edge *deploy.EdgeError+ if !errors.As(err, &edge) {+ return err+ }+ return ui.Refused(fmt.Sprintf("Fluxer %s can't start with your Caddy files.\n%s", toShort, edge.Caddy), edge.Fix("run rexctl upgrade again")+" "+still)+}+func composeProblem(err error) string {var ee *engine.Errorif errors.As(err, &ee) && ee.Err != nil {@@ -1150,8 +1240,11 @@ func failedStart(ctx context.Context, app *App, inst *instance.Instance, e *engifunc writeFailureLog(ctx context.Context, inst *instance.Instance, p *engine.Project, name string, cause error, waiting []string) string {ctx = context.WithoutCancel(ctx)- if len(waiting) == 0 {- waiting = notRunning(ctx, p)+ waiting = slices.Clone(waiting)+ for _, svc := range notRunning(ctx, p) {+ if !slices.Contains(waiting, svc) {+ waiting = append(waiting, svc)+ }}path := inst.Path(instance.StateDirName, name)f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0o600)@@ -1192,7 +1285,7 @@ func notRunning(ctx context.Context, p *engine.Project) []string {}var out []stringfor _, c := range containers {- ok := c.State == "running" && c.Health != "unhealthy" || stack.OneShot[c.Service] && c.State == "exited" && c.ExitCode == 0+ ok := c.State == "running" && c.Health != "unhealthy" && c.RestartCount == 0 || stack.OneShot[c.Service] && c.State == "exited" && c.ExitCode == 0if !ok && !slices.Contains(out, c.Service) {out = append(out, c.Service)}@@ -1239,6 +1332,11 @@ func abandonUpgrade(ctx context.Context, app *App, inst *instance.Instance, e *efunc goBack(ctx context.Context, app *App, inst *instance.Instance, e *engine.Engine, version string) error {pend := inst.State.Upgrade+ if pend != nil {+ if err := inst.PutBackSites(pend.Sites); err != nil {+ app.UI.Detail("%v", err)+ }+ }cctx, cancel := context.WithTimeout(context.WithoutCancel(ctx), recoveryTimeout)defer cancel()if _, err := restoreRelease(cctx, app, inst, e, version); err != nil {@@ -1285,6 +1383,9 @@ func restoreRelease(ctx context.Context, app *App, inst *instance.Instance, e *ereturn put, err}}+ if err := matchSites(app, inst); err != nil {+ return put, err+ }pull := falsefor _, ref := range inst.State.Images.Refs {if _, found, err := e.LocalImage(ctx, ref); err != nil || !found {@@ -1347,6 +1448,7 @@ func finishUpgrade(ctx context.Context, app *App, inst *instance.Instance, e *eninst.State.AdminImport = nil}inst.State.FailedRelease = ""+ inst.State.MovedSites = nilinst.State.Upgrade = nilif err := inst.Save(); err != nil {return ui.Wrap(err, "Couldn't save your instance's state.", "Run rexctl doctor to see what's wrong.")@@ -1490,6 +1592,9 @@ func setPhase(inst *instance.Instance, from, to, phase string) error {}func clearUpgrade(inst *instance.Instance) {+ if pend := inst.State.Upgrade; pend != nil {+ _ = inst.PutBackSites(pend.Sites)+ }inst.State.Upgrade = nil_ = inst.Save()}diff --git a/fluxer_rexctl/internal/backup/restore.go b/fluxer_rexctl/internal/backup/restore.goindex 97f448197..1372395de 100644--- a/fluxer_rexctl/internal/backup/restore.go+++ b/fluxer_rexctl/internal/backup/restore.go@@ -42,6 +42,7 @@ func (e *UploadsNotHereError) Unwrap() error { return ErrUploadsNotHere }type RestoreOptions struct {Progress func(stage string)OnEvent func(engine.Event)+ Adopted func(*instance.Instance)}type ProjectInUseError struct {@@ -122,7 +123,7 @@ func Restore(ctx context.Context, path, dir string, e *engine.Engine, opts Restoif err != nil {return nil, err}- if err := adoptRestored(inst, e); err != nil {+ if err := adoptRestored(inst, e, opts.Adopted); err != nil {return nil, err}for _, d := range []string{inst.StateDir(), inst.BackupDir()} {@@ -347,7 +348,7 @@ func movesEngine(was instance.EngineRef, e *engine.Engine) bool {return was.ID != "" && e.ID != "" && was.ID != e.ID}-func adoptRestored(inst *instance.Instance, e *engine.Engine) error {+func adoptRestored(inst *instance.Instance, e *engine.Engine, adopted func(*instance.Instance)) error {st := inst.Stateif st == nil {return fmt.Errorf("%w: no state in the backup", ErrDamaged)@@ -368,6 +369,9 @@ func adoptRestored(inst *instance.Instance, e *engine.Engine) error {st.PreviousBackup = ""}}+ if adopted != nil {+ adopted(inst)+ }rendered, err := renderRestored(inst)if err != nil {return errdiff --git a/fluxer_rexctl/internal/backup/scope_test.go b/fluxer_rexctl/internal/backup/scope_test.goindex b67ddd5a5..11167de44 100644--- a/fluxer_rexctl/internal/backup/scope_test.go+++ b/fluxer_rexctl/internal/backup/scope_test.go@@ -492,7 +492,7 @@ func TestRestoreForgetsBackupOfAMissingRelease(t *testing.T) {t.Fatal(err)}inst.State.PreviousRelease, inst.State.PreviousBackup = "2026.1001.100000", kept- if err := adoptRestored(inst, dockerEngine); err != nil {+ if err := adoptRestored(inst, dockerEngine, nil); err != nil {t.Fatal(err)}if inst.State.PreviousRelease != "" || inst.State.PreviousBackup != "" {@@ -500,6 +500,23 @@ func TestRestoreForgetsBackupOfAMissingRelease(t *testing.T) {}}+func TestRestoreLetsTheCallerFixFilesBeforeRendering(t *testing.T) {+ inst := leanInstance(t)+ inst.State.Upgrade = &instance.Upgrade{From: "2026.1001.100000", To: "2026.1029.100000", Sites: []string{"Mastodon.caddy"}}+ var seen *instance.Upgrade+ calls := 0+ err := adoptRestored(inst, dockerEngine, func(got *instance.Instance) {+ calls+++ seen = got.State.Upgrade+ })+ if err != nil {+ t.Fatal(err)+ }+ if calls != 1 || seen != nil {+ t.Fatalf("hook ran %d times and saw upgrade %+v", calls, seen)+ }+}+func TestLeftoverRestoreMarkerKeepsUploadsServiceCheck(t *testing.T) {inst := leanInstance(t)images, err := stack.EmbeddedImages()diff --git a/fluxer_rexctl/internal/deploy/apply.go b/fluxer_rexctl/internal/deploy/apply.goindex 0c3ce4d18..482b18c65 100644--- a/fluxer_rexctl/internal/deploy/apply.go+++ b/fluxer_rexctl/internal/deploy/apply.go@@ -11,6 +11,8 @@ import ("github.com/fluxerapp/fluxer/fluxer_rexctl/internal/stack")+const edgeService = "edge"+func Apply(ctx context.Context, inst *instance.Instance, e *engine.Engine, o ApplyOptions) (*Change, error) {if err := refuseEjected(inst); err != nil {return nil, err@@ -51,6 +53,11 @@ func Apply(ctx context.Context, inst *instance.Instance, e *engine.Engine, o Appif err != nil {return nil, err}+ if slices.Contains(restart, edgeService) || slices.Contains(restarted(plan), edgeService) {+ if err := CheckEdge(ctx, inst, p, ""); err != nil {+ return nil, err+ }+ }if err := up(ctx, p, o.Wait, o.OnEvent); err != nil {return nil, err}diff --git a/fluxer_rexctl/internal/deploy/edge.go b/fluxer_rexctl/internal/deploy/edge.gonew file mode 100644index 000000000..e0806e0a6--- /dev/null+++ b/fluxer_rexctl/internal/deploy/edge.go@@ -0,0 +1,115 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++package deploy++import (+ "context"+ "encoding/json"+ "errors"+ "fmt"+ "os"+ "path/filepath"+ "regexp"+ "slices"+ "strings"++ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/engine"+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/instance"+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/ui"+)++const (+ caddyfileTarget = "/etc/caddy/Caddyfile"+ dropInTarget = "/etc/caddy/conf.d/"+)++var dropInFile = regexp.MustCompile(regexp.QuoteMeta(dropInTarget) + `([^:\s/]+\.caddy)`)++type EdgeError struct {+ Caddy string+ Site string+}++func (e *EdgeError) Error() string { return "caddy: " + e.Caddy }++func (e *EdgeError) Fix(then string) string {+ if e.Site != "" {+ return fmt.Sprintf("%s defines its own site. Move it to %s, then %s.", e.Site, instance.CaddySitesDir, then)+ }+ return fmt.Sprintf("Fix the file Caddy reports, then %s.", then)+}++func CheckEdge(ctx context.Context, inst *instance.Instance, p *engine.Project, caddyfile string) error {+ if !slices.Contains(p.Services(), edgeService) {+ return nil+ }+ o := p.HelperFor(edgeService)+ if o.Image == "" {+ return nil+ }+ if _, found, err := p.Engine.LocalImage(ctx, o.Image); err != nil || !found {+ return nil+ }+ if caddyfile != "" {+ for i, m := range o.Mounts {+ if m.Target == caddyfileTarget {+ o.Mounts[i].Bind = caddyfile+ }+ }+ }+ o.Entrypoint = []string{"caddy"}+ o.Command = []string{"adapt", "--config", caddyfileTarget, "--adapter", "caddyfile"}+ err := p.Helper(ctx, o)+ var exit *engine.ExitError+ if !errors.As(err, &exit) {+ return ctx.Err()+ }+ edge := edgeProblem(inst.Dir, exit.Stderr)+ if edge.Caddy == "" {+ edge.Caddy = exit.Error()+ }+ return &ui.ExitError{Code: ui.ExitRefused, Msg: "Caddy can't load the edge config.\n" + edge.Caddy, Fix: edge.Fix("try again"), Err: edge}+}++func edgeProblem(dir, stderr string) *EdgeError {+ msg := caddyMessage(stderr)+ e := &EdgeError{Caddy: strings.ReplaceAll(strings.ReplaceAll(msg, dropInTarget, instance.CaddyDropInDir+"/"), caddyfileTarget, "Caddyfile")}+ var files []string+ if m := dropInFile.FindStringSubmatch(msg); m != nil {+ files = []string{m[1]}+ } else if all, err := filepath.Glob(filepath.Join(dir, instance.CaddyDropInDir, "*.caddy")); err == nil {+ for _, f := range all {+ files = append(files, filepath.Base(f))+ }+ }+ for _, f := range files {+ data, err := os.ReadFile(filepath.Join(dir, instance.CaddyDropInDir, f))+ if err == nil && instance.DefinesSite(data) {+ e.Site = instance.CaddyDropInDir + "/" + f+ break+ }+ }+ return e+}++func caddyMessage(stderr string) string {+ var last string+ for _, line := range strings.Split(strings.TrimSpace(stderr), "\n") {+ line = strings.TrimSpace(line)+ if line == "" {+ continue+ }+ var entry struct {+ Level string `json:"level"`+ Msg string `json:"msg"`+ }+ if json.Unmarshal([]byte(line), &entry) == nil {+ if entry.Level == "error" || entry.Level == "fatal" {+ last = entry.Msg+ }+ continue+ }+ last = strings.TrimPrefix(line, "Error: ")+ }+ return strings.TrimPrefix(last, "adapting config using caddyfile: ")+}diff --git a/fluxer_rexctl/internal/deploy/edge_test.go b/fluxer_rexctl/internal/deploy/edge_test.gonew file mode 100644index 000000000..de30cdd31--- /dev/null+++ b/fluxer_rexctl/internal/deploy/edge_test.go@@ -0,0 +1,82 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++package deploy++import (+ "os"+ "path/filepath"+ "strings"+ "testing"++ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/instance"+)++const nestedSiteStderr = `{"level":"info","ts":1793328334.3,"msg":"using config from file","file":"/etc/caddy/Caddyfile"}+{"level":"error","ts":1793328334.371964,"msg":"/etc/caddy/conf.d/Mastodon.caddy:1: unrecognized directive: mastodon.tails.ch"}+`++func writeDropIn(t *testing.T, dir, file, data string) {+ t.Helper()+ path := filepath.Join(dir, instance.CaddyDropInDir, file)+ if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {+ t.Fatal(err)+ }+ if err := os.WriteFile(path, []byte(data), 0o644); err != nil {+ t.Fatal(err)+ }+}++func TestCaddyMessage(t *testing.T) {+ for _, tc := range []struct {+ stderr, want string+ }{+ {nestedSiteStderr, "/etc/caddy/conf.d/Mastodon.caddy:1: unrecognized directive: mastodon.tails.ch"},+ {"Error: adapting config using caddyfile: /etc/caddy/Caddyfile:3: unknown directive\n", "/etc/caddy/Caddyfile:3: unknown directive"},+ {"", ""},+ } {+ if got := caddyMessage(tc.stderr); got != tc.want {+ t.Errorf("caddyMessage(%q) = %q, want %q", tc.stderr, got, tc.want)+ }+ }+}++func TestEdgeProblemPointsAtSiteFile(t *testing.T) {+ dir := t.TempDir()+ writeDropIn(t, dir, "Mastodon.caddy", "mastodon.tails.ch {\n\treverse_proxy 10.0.4.22:3000\n}\n")+ e := edgeProblem(dir, nestedSiteStderr)+ if e.Caddy != "caddy.d/Mastodon.caddy:1: unrecognized directive: mastodon.tails.ch" {+ t.Fatalf("caddy error %q", e.Caddy)+ }+ if e.Site != "caddy.d/Mastodon.caddy" {+ t.Fatalf("site file %q", e.Site)+ }+ if fix := e.Fix("try again"); fix != "caddy.d/Mastodon.caddy defines its own site. Move it to caddy.d/sites, then try again." {+ t.Fatalf("fix %q", fix)+ }+}++func TestEdgeProblemLooksForSitesWhenCaddyBlamesTheCaddyfile(t *testing.T) {+ dir := t.TempDir()+ writeDropIn(t, dir, "headers.caddy", "header X-Mine yes\n")+ writeDropIn(t, dir, "tails.caddy", "header X-Mine yes\ntails.ch {\n\trespond ok\n}\n")+ e := edgeProblem(dir, "Error: adapting config using caddyfile: /etc/caddy/Caddyfile:20: unrecognized directive: tails.ch\n")+ if e.Site != "caddy.d/tails.caddy" {+ t.Fatalf("site file %q", e.Site)+ }+ if !strings.HasPrefix(e.Caddy, "Caddyfile:20:") {+ t.Fatalf("caddy error %q", e.Caddy)+ }+}++func TestEdgeProblemWithoutSiteFile(t *testing.T) {+ dir := t.TempDir()+ writeDropIn(t, dir, "headers.caddy", "header X-Mine yes\nbogus\n")+ writeDropIn(t, dir, "sites/tails.caddy", "tails.ch {\n\tbogus\n}\n")+ e := edgeProblem(dir, `{"level":"error","msg":"/etc/caddy/conf.d/sites/tails.caddy:2: unrecognized directive: bogus"}`)+ if e.Site != "" {+ t.Fatalf("site file %q", e.Site)+ }+ if fix := e.Fix("try again"); fix != "Fix the file Caddy reports, then try again." {+ t.Fatalf("fix %q", fix)+ }+}diff --git a/fluxer_rexctl/internal/deploy/set.go b/fluxer_rexctl/internal/deploy/set.goindex 057208750..848fc3afa 100644--- a/fluxer_rexctl/internal/deploy/set.go+++ b/fluxer_rexctl/internal/deploy/set.go@@ -234,6 +234,11 @@ func Set(ctx context.Context, inst *instance.Instance, e *engine.Engine, changesif err := newP.Pull(ctx, o.OnEvent); err != nil {return nil, err}+ if slices.Contains(preview.Restarts, edgeService) {+ if err := CheckEdge(ctx, inst, newP, ""); err != nil {+ return nil, err+ }+ }st.Pending = &instance.Pending{Settings: next, Keys: changed, StartedAt: now()}if err := save(inst); err != nil {st.Pending = nildiff --git a/fluxer_rexctl/internal/engine/api.go b/fluxer_rexctl/internal/engine/api.goindex eb7ef27e5..ed1bc0306 100644--- a/fluxer_rexctl/internal/engine/api.go+++ b/fluxer_rexctl/internal/engine/api.go@@ -103,6 +103,7 @@ type HelperOptions struct {Image stringEntrypoint []stringCommand []string+ Env []stringMounts []MountStdin io.ReaderStdout io.Writerdiff --git a/fluxer_rexctl/internal/engine/exec.go b/fluxer_rexctl/internal/engine/exec.goindex 18453d91f..5376b3c48 100644--- a/fluxer_rexctl/internal/engine/exec.go+++ b/fluxer_rexctl/internal/engine/exec.go@@ -270,6 +270,7 @@ func (p *Project) runHelper(ctx context.Context, c client.APIClient, image strinImage: image,Entrypoint: append([]string{"sh", "-c", heartbeatScript, "rexctl"}, o.Entrypoint...),Cmd: o.Command,+ Env: o.Env,AttachStdin: o.Stdin != nil,AttachStdout: true,AttachStderr: true,diff --git a/fluxer_rexctl/internal/engine/load.go b/fluxer_rexctl/internal/engine/load.goindex 344ca5091..c545b0c34 100644--- a/fluxer_rexctl/internal/engine/load.go+++ b/fluxer_rexctl/internal/engine/load.go@@ -197,6 +197,28 @@ func (p *Project) Image(service string) string {return p.Model.Services[service].Image}+func (p *Project) HelperFor(service string) HelperOptions {+ if p.Model == nil {+ return HelperOptions{}+ }+ svc, ok := p.Model.Services[service]+ if !ok {+ return HelperOptions{}+ }+ o := HelperOptions{Image: svc.Image}+ for _, k := range slices.Sorted(maps.Keys(svc.Environment)) {+ if v := svc.Environment[k]; v != nil {+ o.Env = append(o.Env, k+"="+*v)+ }+ }+ for _, v := range svc.Volumes {+ if v.Type == types.VolumeTypeBind && v.Source != "" {+ o.Mounts = append(o.Mounts, Mount{Bind: v.Source, Target: v.Target, ReadOnly: v.ReadOnly})+ }+ }+ return o+}+func (p *Project) Hashes() (map[string]string, error) {if err := p.needModel("hash"); err != nil {return nil, errdiff --git a/fluxer_rexctl/internal/instance/adopt.go b/fluxer_rexctl/internal/instance/adopt.goindex 78092ca54..dabeab8d0 100644--- a/fluxer_rexctl/internal/instance/adopt.go+++ b/fluxer_rexctl/internal/instance/adopt.go@@ -301,7 +301,7 @@ func adoptFiles(ctx context.Context, p *AdoptPlan) error {if err := p.keepRunning(); err != nil {return err}- for _, d := range []string{BackupsDir, CertsDir, CADir, CaddyDropInDir} {+ for _, d := range []string{BackupsDir, CertsDir, CADir, CaddyDropInDir, CaddySitesDir} {mode := os.FileMode(0o755)if d == BackupsDir {mode = 0o700diff --git a/fluxer_rexctl/internal/instance/instance.go b/fluxer_rexctl/internal/instance/instance.goindex 86b0126d9..58660e33e 100644--- a/fluxer_rexctl/internal/instance/instance.go+++ b/fluxer_rexctl/internal/instance/instance.go@@ -42,6 +42,7 @@ const (CertsDir = "certs"CADir = "ca"CaddyDropInDir = "caddy.d"+ CaddySitesDir = "caddy.d/sites"DefaultKeepBackups = 3KeepAllBackups = -1@@ -161,7 +162,7 @@ func Create(dir, project string) (*Instance, error) {return nil, err}}- for _, d := range []string{CertsDir, CADir, CaddyDropInDir} {+ for _, d := range []string{CertsDir, CADir, CaddyDropInDir, CaddySitesDir} {if err := os.MkdirAll(i.Path(d), 0o755); err != nil {return nil, err}diff --git a/fluxer_rexctl/internal/instance/shipped.json b/fluxer_rexctl/internal/instance/shipped.jsonindex c20604e87..c52d19697 100644--- a/fluxer_rexctl/internal/instance/shipped.json+++ b/fluxer_rexctl/internal/instance/shipped.json@@ -105,6 +105,7 @@"7fd66a72a740258ed71fcaebce927bdc9b2528177cfeb5ca9e0c0ee778dd8769","8b1e007032b4c5fd2e36f3bfa9435609cb626b0aec10c3e07dc8bee6887ccc33","cb68f62d48bc54bc908840c6dce85843ac5580e6196e5a9b978dd14ffb3d5280",+ "cc3cb39a52b2ca423854e3ba479df251afa73e2bf396da6aaee2df931bfab25c","e9ab1a7ad99211172f68cfa2728beeb86dd4ed220635cab5f8461bb2b49cb023","f02d23b1c650c157ab53ee7cc2057c0d6dec7b93f5dbd99982c594cdd6c766d1"],diff --git a/fluxer_rexctl/internal/instance/sites.go b/fluxer_rexctl/internal/instance/sites.gonew file mode 100644index 000000000..841df5526--- /dev/null+++ b/fluxer_rexctl/internal/instance/sites.go@@ -0,0 +1,340 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++package instance++import (+ "errors"+ "io/fs"+ "os"+ "path/filepath"+ "regexp"+ "strings"+ "unicode"+)++type caddyToken struct {+ text string+ line int+ quoted bool+}++type caddyEntry struct {+ keys []caddyToken+ block bool+}++type entryKind int++const (+ entryOther entryKind = iota+ entrySite+ entrySnippet+ entryGlobal+)++var (+ dottedHost = regexp.MustCompile(`^(?:\*\.)?(?:[A-Za-z0-9_-]+\.)+[A-Za-z0-9_-]+\.?$`)+ plainHost = regexp.MustCompile(`^[A-Za-z0-9_-]+$`)+ bracketHost = regexp.MustCompile(`^\[[0-9A-Fa-f:.]+\]$`)+ portSuffix = regexp.MustCompile(`:[0-9]+$`)+ snippetKey = regexp.MustCompile(`^\([^()\s]+\)$`)+)++func caddyTokens(data []byte) ([]caddyToken, bool) {+ var out []caddyToken+ src := []rune(strings.ReplaceAll(string(data), "\r\n", "\n"))+ line := 1+ for i := 0; i < len(src); {+ ch := src[i]+ switch {+ case ch == '\n':+ line+++ i+++ case unicode.IsSpace(ch):+ i+++ case ch == '#':+ for i < len(src) && src[i] != '\n' {+ i+++ }+ case ch == '"' || ch == '`':+ start := line+ var b strings.Builder+ i+++ closed := false+ for i < len(src) {+ c := src[i]+ if c == '\\' && ch == '"' && i+1 < len(src) && (src[i+1] == '"' || src[i+1] == '\\') {+ b.WriteRune(src[i+1])+ i += 2+ continue+ }+ if c == ch {+ closed = true+ i+++ break+ }+ if c == '\n' {+ line+++ }+ b.WriteRune(c)+ i+++ }+ if !closed {+ return nil, false+ }+ out = append(out, caddyToken{text: b.String(), line: start, quoted: true})+ default:+ start := i+ for i < len(src) && !unicode.IsSpace(src[i]) {+ i+++ }+ text := string(src[start:i])+ if strings.HasPrefix(text, "<<") {+ return nil, false+ }+ out = append(out, caddyToken{text: text, line: line})+ }+ }+ return out, true+}++func caddyEntries(data []byte) ([]caddyEntry, bool) {+ tokens, ok := caddyTokens(data)+ if !ok {+ return nil, false+ }+ var out []caddyEntry+ var keys []caddyToken+ flush := func() {+ if len(keys) > 0 {+ out = append(out, caddyEntry{keys: keys})+ keys = nil+ }+ }+ depth := 0+ for _, t := range tokens {+ opens, closes := !t.quoted && t.text == "{", !t.quoted && t.text == "}"+ if depth > 0 {+ switch {+ case opens:+ depth+++ case closes:+ depth--+ }+ continue+ }+ if len(keys) > 0 {+ last := keys[len(keys)-1]+ if last.line != t.line && !strings.HasSuffix(last.text, ",") {+ flush()+ }+ }+ switch {+ case opens:+ out = append(out, caddyEntry{keys: keys, block: true})+ keys = nil+ depth = 1+ case closes:+ return nil, false+ default:+ keys = append(keys, t)+ }+ }+ if depth != 0 {+ return nil, false+ }+ flush()+ return out, true+}++func (e caddyEntry) kind() entryKind {+ if !e.block {+ return entryOther+ }+ if len(e.keys) == 0 {+ return entryGlobal+ }+ if len(e.keys) == 1 && !e.keys[0].quoted && snippetKey.MatchString(e.keys[0].text) {+ return entrySnippet+ }+ n := 0+ for _, k := range e.keys {+ if k.quoted {+ return entryOther+ }+ for _, addr := range strings.Split(k.text, ",") {+ if addr == "" {+ continue+ }+ if !siteAddress(addr) {+ return entryOther+ }+ n+++ }+ }+ if n == 0 {+ return entryOther+ }+ return entrySite+}++func siteAddress(s string) bool {+ if strings.ContainsAny(s, "{}@") {+ return false+ }+ rest, scheme := strings.CutPrefix(s, "https://")+ if !scheme {+ rest, scheme = strings.CutPrefix(s, "http://")+ }+ host, _, _ := strings.Cut(rest, "/")+ if host == "" {+ return false+ }+ port := portSuffix.FindString(host)+ host = strings.TrimSuffix(host, port)+ switch {+ case host == "":+ return port != ""+ case host == "localhost", bracketHost.MatchString(host), dottedHost.MatchString(host):+ return true+ }+ return (scheme || port != "") && plainHost.MatchString(host)+}++func DefinesSite(data []byte) bool {+ entries, ok := caddyEntries(data)+ if !ok {+ return false+ }+ for _, e := range entries {+ if e.kind() == entrySite {+ return true+ }+ }+ return false+}++func onlySites(data []byte) bool {+ entries, ok := caddyEntries(data)+ if !ok {+ return false+ }+ sites := 0+ for _, e := range entries {+ switch e.kind() {+ case entrySite:+ sites+++ case entrySnippet:+ default:+ return false+ }+ }+ return sites > 0+}++func (i *Instance) MoveSites() ([]string, error) {+ entries, err := os.ReadDir(i.Path(CaddyDropInDir))+ if errors.Is(err, fs.ErrNotExist) {+ return nil, nil+ }+ if err != nil {+ return nil, err+ }+ var moved []string+ for _, e := range entries {+ if !e.Type().IsRegular() || filepath.Ext(e.Name()) != ".caddy" {+ continue+ }+ src := i.Path(CaddyDropInDir, e.Name())+ data, err := os.ReadFile(src)+ if err != nil {+ return moved, err+ }+ if !onlySites(data) {+ continue+ }+ dst := i.Path(CaddySitesDir, e.Name())+ if exists(dst) {+ continue+ }+ if err := os.MkdirAll(i.Path(CaddySitesDir), 0o755); err != nil {+ return moved, err+ }+ if err := os.Rename(src, dst); err != nil {+ return moved, err+ }+ moved = append(moved, e.Name())+ }+ return moved, nil+}++func TopLevelImports(caddyfile []byte) (sites, dropIns bool) {+ entries, ok := caddyEntries(caddyfile)+ if !ok {+ return false, false+ }+ for _, e := range entries {+ if e.block || len(e.keys) < 2 || e.keys[0].text != "import" {+ continue+ }+ switch arg := e.keys[1].text; {+ case strings.HasSuffix(arg, "/sites/*.caddy"):+ sites = true+ case strings.HasSuffix(arg, "/*.caddy"):+ dropIns = true+ }+ }+ return sites, dropIns+}++func (i *Instance) SiteFiles() ([]string, error) {+ entries, err := os.ReadDir(i.Path(CaddySitesDir))+ if errors.Is(err, fs.ErrNotExist) {+ return nil, nil+ }+ if err != nil {+ return nil, err+ }+ var files []string+ for _, e := range entries {+ if e.Type().IsRegular() && filepath.Ext(e.Name()) == ".caddy" {+ files = append(files, e.Name())+ }+ }+ return files, nil+}++func (i *Instance) UnloadSites() ([]string, error) {+ files, err := i.SiteFiles()+ if err != nil {+ return nil, err+ }+ return i.moveCaddyFiles(files, CaddySitesDir, CaddyDropInDir)+}++func (i *Instance) RestoreSites(files []string) ([]string, error) {+ return i.moveCaddyFiles(files, CaddyDropInDir, CaddySitesDir)+}++func (i *Instance) PutBackSites(files []string) error {+ _, err := i.moveCaddyFiles(files, CaddySitesDir, CaddyDropInDir)+ return err+}++func (i *Instance) moveCaddyFiles(files []string, from, to string) ([]string, error) {+ var moved []string+ for _, f := range files {+ src, dst := i.Path(from, f), i.Path(to, f)+ if !isFile(src) || exists(dst) {+ continue+ }+ if err := os.MkdirAll(i.Path(to), 0o755); err != nil {+ return moved, err+ }+ if err := os.Rename(src, dst); err != nil {+ return moved, err+ }+ moved = append(moved, f)+ }+ return moved, nil+}diff --git a/fluxer_rexctl/internal/instance/sites_test.go b/fluxer_rexctl/internal/instance/sites_test.gonew file mode 100644index 000000000..6e3bd058e--- /dev/null+++ b/fluxer_rexctl/internal/instance/sites_test.go@@ -0,0 +1,271 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++package instance++import (+ "context"+ "os"+ "path/filepath"+ "slices"+ "strings"+ "testing"++ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/engine"+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/secrets"+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/settings"+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/stack"+)++const mastodonSites = `mastodon.tails.ch {+ tls internal+ reverse_proxy 10.0.4.22:3000+}++tails.ch {+ tls internal+ respond "hello {http.request.host}"+}+`++func TestDefinesSite(t *testing.T) {+ for _, tc := range []struct {+ label string+ file string+ want bool+ }{+ {"two site blocks", mastodonSites, true},+ {"site list with commas", "a.example.com, b.example.com {\n\trespond ok\n}\n", true},+ {"site list over two lines", "a.example.com,\nb.example.com {\n\trespond ok\n}\n", true},+ {"port only", ":8443 {\n\trespond ok\n}\n", true},+ {"scheme and localhost", "http://localhost {\n\trespond ok\n}\n", true},+ {"single label with port", "intranet:8080 {\n\trespond ok\n}\n", true},+ {"ipv6 address", "[::1]:8080 {\n\trespond ok\n}\n", true},+ {"wildcard host", "*.example.com {\n\trespond ok\n}\n", true},+ {"snippet", "(cors) {\n\theader Access-Control-Allow-Origin *\n}\n", false},+ {"global options", "{\n\temail [email protected]\n}\n", false},+ {"plain directives", "header X-Mine yes\nencode gzip\n", false},+ {"directive blocks", "handle /extra/* {\n\trespond ok\n}\nreverse_proxy 10.0.4.22:3000 {\n\theader_up Host {host}\n}\nroute {\n\trespond ok\n}\n", false},+ {"matcher block", "@blocked {\n\tpath /secret/*\n}\nrespond @blocked 403\n", false},+ {"comment with a site", "# mastodon.tails.ch {\n# }\nheader X-Mine yes\n", false},+ {"brace inside a string", "respond \"example.com {\"\nheader X-Mine yes\n", false},+ {"backtick string", "respond `a.example.com {\n}`\n", false},+ {"import line", "import /etc/caddy/extra/*.caddy\n", false},+ {"env placeholder key", "{$MASTODON_HOST} {\n\treverse_proxy 10.0.4.22:3000\n}\n", false},+ {"env placeholder in host", "{$SUB}.example.com {\n\trespond ok\n}\n", false},+ {"placeholder inside a directive", "respond \"{system.hostname}\" 200\n", false},+ {"heredoc", "respond <<EOF\n\texample.com {\n\tEOF\n", false},+ {"unbalanced braces", "example.com {\n\trespond ok\n", false},+ } {+ if got := DefinesSite([]byte(tc.file)); got != tc.want {+ t.Errorf("%s: DefinesSite = %v, want %v", tc.label, got, tc.want)+ }+ }+}++func TestOnlySites(t *testing.T) {+ for _, tc := range []struct {+ label string+ file string+ want bool+ }{+ {"two site blocks", mastodonSites, true},+ {"sites and a snippet", "(common) {\n\tencode gzip\n}\n" + mastodonSites, true},+ {"sites with comments", "# my sites\n" + mastodonSites + "# end\n", true},+ {"site and global options", "{\n\temail [email protected]\n}\n" + mastodonSites, false},+ {"site and import line", "import common.caddy\n" + mastodonSites, false},+ {"site and directive", "header X-Mine yes\n" + mastodonSites, false},+ {"snippet only", "(cors) {\n\theader Access-Control-Allow-Origin *\n}\n", false},+ {"env placeholder key", "{$MASTODON_HOST} {\n\treverse_proxy 10.0.4.22:3000\n}\n", false},+ {"empty file", "", false},+ } {+ if got := onlySites([]byte(tc.file)); got != tc.want {+ t.Errorf("%s: onlySites = %v, want %v", tc.label, got, tc.want)+ }+ }+}++func TestMoveSitesMovesOnlySiteFiles(t *testing.T) {+ inst, err := Create(t.TempDir(), "fluxer")+ if err != nil {+ t.Fatal(err)+ }+ files := map[string]string{+ "Mastodon.caddy": mastodonSites,+ "headers.caddy": "header X-Mine yes\n",+ "mixed.caddy": "header X-Mine yes\n" + mastodonSites,+ "env.caddy": "{$MASTODON_HOST} {\n\treverse_proxy 10.0.4.22:3000\n}\n",+ "notes.txt": mastodonSites,+ "taken.caddy": mastodonSites,+ }+ for f, data := range files {+ writeTestFile(t, inst.Path(CaddyDropInDir, f), []byte(data))+ }+ writeTestFile(t, inst.Path(CaddySitesDir, "taken.caddy"), []byte("other.example.com {\n}\n"))+ moved, err := inst.MoveSites()+ if err != nil {+ t.Fatal(err)+ }+ if !slices.Equal(moved, []string{"Mastodon.caddy"}) {+ t.Fatalf("moved %v, want [Mastodon.caddy]", moved)+ }+ if got := string(readTestFile(t, inst.Path(CaddySitesDir, "Mastodon.caddy"))); got != mastodonSites {+ t.Fatalf("moved file %q", got)+ }+ for f := range files {+ _, err := os.Stat(inst.Path(CaddyDropInDir, f))+ if gone := os.IsNotExist(err); gone != (f == "Mastodon.caddy") {+ t.Errorf("%s left in caddy.d = %v", f, !gone)+ }+ }+ if again, err := inst.MoveSites(); err != nil || len(again) > 0 {+ t.Fatalf("second run moved %v, %v", again, err)+ }+ if err := inst.PutBackSites(moved); err != nil {+ t.Fatal(err)+ }+ if got := string(readTestFile(t, inst.Path(CaddyDropInDir, "Mastodon.caddy"))); got != mastodonSites {+ t.Fatalf("put back %q", got)+ }+ if _, err := os.Stat(inst.Path(CaddySitesDir, "Mastodon.caddy")); !os.IsNotExist(err) {+ t.Fatal("the site file is still in caddy.d/sites")+ }+}++func TestMoveSitesWithoutDropInFolder(t *testing.T) {+ inst := &Instance{Dir: filepath.Join(t.TempDir(), "missing")}+ moved, err := inst.MoveSites()+ if err != nil || moved != nil {+ t.Fatalf("got %v, %v", moved, err)+ }+}++func TestShippedCaddyfileImportsSitesAtTopLevel(t *testing.T) {+ data, err := stack.ReadFile(stack.Embedded(), stack.Caddyfile)+ if err != nil {+ t.Fatal(err)+ }+ entries, ok := caddyEntries(data)+ if !ok {+ t.Fatal("the shipped Caddyfile doesn't parse")+ }+ var top []string+ for _, e := range entries {+ if !e.block {+ var keys []string+ for _, k := range e.keys {+ keys = append(keys, k.text)+ }+ top = append(top, strings.Join(keys, " "))+ }+ }+ if !slices.Contains(top, "import /etc/caddy/conf.d/sites/*.caddy") {+ t.Fatalf("top level lines %q, want the sites import", top)+ }+ if slices.Contains(top, "import /etc/caddy/conf.d/*.caddy") {+ t.Fatal("caddy.d directives load at the top level")+ }+ if !strings.Contains(string(data), "\timport /etc/caddy/conf.d/*.caddy\n") {+ t.Fatal("caddy.d directives no longer load inside the site")+ }+}++func TestEdgeMountsCoverSitesFolder(t *testing.T) {+ for _, mode := range []string{"", "proxy", "tunnel"} {+ inst, err := Create(t.TempDir(), "fluxer")+ if err != nil {+ t.Fatal(err)+ }+ if _, err := os.Stat(inst.Path(CaddySitesDir)); err != nil {+ t.Fatalf("Create made no %s: %v", CaddySitesDir, err)+ }+ set := stack.Embedded()+ inst.State.Release = set.Release+ inst.State.Images = Images{Release: set.Release, Refs: fluxerRefs("a")}+ inst.State.Settings[settings.Domain] = "chat.example.com"+ if mode != "" {+ inst.State.Settings[settings.EdgeMode] = mode+ }+ if _, err := secrets.Mint(inst.State.Secrets, false); err != nil {+ t.Fatal(err)+ }+ if _, err := inst.Render(set, stack.OverlaysFor(inst.State.Settings), inst.State.Images.Refs); err != nil {+ t.Fatal(err)+ }+ env, err := inst.Environment()+ if err != nil {+ t.Fatal(err)+ }+ var none engine.Engine+ p, err := none.Load(context.Background(), engine.Spec{Name: "fluxer", Dir: inst.Dir, Files: inst.ComposeFiles(), Env: env})+ if err != nil {+ t.Fatalf("%q: %v", mode, err)+ }+ o := p.HelperFor("edge")+ if o.Image == "" {+ t.Fatalf("%q: no edge image", mode)+ }+ want := map[string]string{"/etc/caddy/Caddyfile": inst.Generated(stack.Caddyfile), "/etc/caddy/conf.d": inst.Path(CaddyDropInDir)}+ for _, m := range o.Mounts {+ if src, ok := want[m.Target]; ok && m.Bind == src {+ delete(want, m.Target)+ }+ }+ if len(want) > 0 {+ t.Fatalf("%q: edge mounts %v, missing %v", mode, o.Mounts, want)+ }+ if !slices.ContainsFunc(o.Env, func(kv string) bool { return strings.HasPrefix(kv, "FLUXER_EDGE_SITE_ADDRESS=") }) {+ t.Fatalf("%q: edge env %v", mode, o.Env)+ }+ }+}++func TestTopLevelImports(t *testing.T) {+ shipped, err := stack.ReadFile(stack.Embedded(), stack.Caddyfile)+ if err != nil {+ t.Fatal(err)+ }+ for _, tc := range []struct {+ label string+ file string+ sites, dropIns bool+ }{+ {"shipped Caddyfile", string(shipped), true, false},+ {"legacy Caddyfile", "{\n\temail [email protected]\n}\nimport /etc/caddy/conf.d/*.caddy\n{$FLUXER_DOMAIN} {\n\treverse_proxy app:8080\n}\n", false, true},+ {"nested drop-ins only", "example.com {\n\timport /etc/caddy/conf.d/*.caddy\n}\n", false, false},+ {"commented sites import", "# import /etc/caddy/conf.d/sites/*.caddy\nexample.com {\n}\n", false, false},+ {"snippet import", "(x) {\n}\nimport x\n", false, false},+ } {+ sites, dropIns := TopLevelImports([]byte(tc.file))+ if sites != tc.sites || dropIns != tc.dropIns {+ t.Errorf("%s: TopLevelImports = %v, %v, want %v, %v", tc.label, sites, dropIns, tc.sites, tc.dropIns)+ }+ }+}++func TestUnloadAndRestoreSites(t *testing.T) {+ inst, err := Create(t.TempDir(), "fluxer")+ if err != nil {+ t.Fatal(err)+ }+ writeTestFile(t, inst.Path(CaddySitesDir, "a.caddy"), []byte(mastodonSites))+ writeTestFile(t, inst.Path(CaddySitesDir, "b.caddy"), []byte(mastodonSites))+ writeTestFile(t, inst.Path(CaddySitesDir, "notes.txt"), []byte("x\n"))+ writeTestFile(t, inst.Path(CaddyDropInDir, "b.caddy"), []byte("header X-Mine yes\n"))+ moved, err := inst.UnloadSites()+ if err != nil {+ t.Fatal(err)+ }+ if !slices.Equal(moved, []string{"a.caddy"}) {+ t.Fatalf("unloaded %v, want [a.caddy]", moved)+ }+ back, err := inst.RestoreSites([]string{"a.caddy", "missing.caddy"})+ if err != nil {+ t.Fatal(err)+ }+ if !slices.Equal(back, []string{"a.caddy"}) {+ t.Fatalf("restored %v, want [a.caddy]", back)+ }+ if got := string(readTestFile(t, inst.Path(CaddySitesDir, "a.caddy"))); got != mastodonSites {+ t.Fatalf("restored file %q", got)+ }+}diff --git a/fluxer_rexctl/internal/instance/state.go b/fluxer_rexctl/internal/instance/state.goindex ae538848f..7fc07fa33 100644--- a/fluxer_rexctl/internal/instance/state.go+++ b/fluxer_rexctl/internal/instance/state.go@@ -42,6 +42,7 @@ type State struct {Rendered map[string]string `json:"rendered"`Mounted map[string]string `json:"mounted"`LeftInRoot map[string]string `json:"left_in_root,omitempty"`+ MovedSites []string `json:"moved_sites,omitempty"`Ejected *Ejected `json:"ejected"`BackupDir string `json:"backup_dir,omitempty"`KeepBackups int `json:"keep_backups,omitempty"`@@ -65,6 +66,7 @@ type Upgrade struct {Phase string `json:"phase"`Backup string `json:"backup,omitempty"`BackFailed bool `json:"back_failed,omitempty"`+ Sites []string `json:"sites,omitempty"`StartedAt time.Time `json:"started_at"`}@@ -147,7 +149,7 @@ func parseStateRepairing(data []byte, dir string, repairing []string) (*State, evar stateFields = map[string]bool{"schema": true, "project": true, "engine": true, "release": true, "previous_release": true, "previous_backup": true, "failed_release": true,"upgrade": true, "pending": true, "images": true, "settings": true, "secrets": true, "admin_import": true,- "setup_done": true, "installing": true, "stopped": true, "rendered": true, "mounted": true, "left_in_root": true, "ejected": true,+ "setup_done": true, "installing": true, "stopped": true, "rendered": true, "mounted": true, "left_in_root": true, "moved_sites": true, "ejected": true,"installed_at": true, "updated_at": true, "backup_dir": true, "keep_backups": true, "notify_url": true,}diff --git a/fluxer_rexctl/internal/stack/bundle.go b/fluxer_rexctl/internal/stack/bundle.goindex e5ad56ea6..b8b74a139 100644--- a/fluxer_rexctl/internal/stack/bundle.go+++ b/fluxer_rexctl/internal/stack/bundle.go@@ -22,7 +22,7 @@ func Bundle(dir string, images map[string]string) error {}files = append(files, renderedFile{OverlayFiles[o], data})}- for d := range MountedDirs {+ for _, d := range madeDirs {if err := os.MkdirAll(filepath.Join(dir, d), 0o755); err != nil {return err}diff --git a/fluxer_rexctl/internal/stack/files/Caddyfile b/fluxer_rexctl/internal/stack/files/Caddyfileindex 3fe3623cd..1245e358a 100644--- a/fluxer_rexctl/internal/stack/files/Caddyfile+++ b/fluxer_rexctl/internal/stack/files/Caddyfile@@ -86,3 +86,5 @@respond "{system.hostname}" 200}}++import /etc/caddy/conf.d/sites/*.caddydiff --git a/fluxer_rexctl/internal/stack/stack.go b/fluxer_rexctl/internal/stack/stack.goindex e6a32ba30..044f47b2b 100644--- a/fluxer_rexctl/internal/stack/stack.go+++ b/fluxer_rexctl/internal/stack/stack.go@@ -9,6 +9,7 @@ import ("errors""fmt""io/fs"+ "maps""os""path/filepath""regexp"@@ -57,6 +58,8 @@ var MountedDirs = map[string][]string{"certs": {"edge"},}+var madeDirs = append(slices.Sorted(maps.Keys(MountedDirs)), "caddy.d/sites")+var (ErrUnknownOverlay = errors.New("stack: unknown overlay")ErrOverlayConflict = errors.New("stack: the proxy and tunnel overlays can't be used together")@@ -319,7 +322,7 @@ func RenderAt(set *Set, selected []Overlay, images map[string]string, project, dif err != nil {return nil, err}- for d := range MountedDirs {+ for _, d := range madeDirs {if err := os.MkdirAll(filepath.Join(dir, d), 0o755); err != nil {return nil, err}