Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp

fix(rexctl): load whole sites from caddy.d/sites (#3713)

Hampus2da58f01ffb6
diff --git a/deploy/helm/fluxer/files/Caddyfile b/deploy/helm/fluxer/files/Caddyfile
index 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/*.caddy
diff --git a/fluxer_docs/src/content/docs/operator/running.mdx b/fluxer_docs/src/content/docs/operator/running.mdx
index 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 `rexc
rexctl 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 wrong
diff --git a/fluxer_rexctl/cmd/restore.go b/fluxer_rexctl/cmd/restore.go
index 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 stri
s.Progress(ev.Current, ev.Total)
}
},
+ Adopted: matchRestoredSites(app),
})
if err != nil {
return err
diff --git a/fluxer_rexctl/cmd/rollback.go b/fluxer_rexctl/cmd/rollback.go
index 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.go
new file mode 100644
index 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.go
index 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 *eng
return 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 *eng
if 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 *engi
return 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 *engi
return 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.Error
if errors.As(err, &ee) && ee.Err != nil {
@@ -1150,8 +1240,11 @@ func failedStart(ctx context.Context, app *App, inst *instance.Instance, e *engi
func 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 []string
for _, 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 == 0
if !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 *e
func 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 *e
return put, err
}
}
+ if err := matchSites(app, inst); err != nil {
+ return put, err
+ }
pull := false
for _, 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 *en
inst.State.AdminImport = nil
}
inst.State.FailedRelease = ""
+ inst.State.MovedSites = nil
inst.State.Upgrade = nil
if 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.go
index 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 Resto
if 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.State
if 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 err
diff --git a/fluxer_rexctl/internal/backup/scope_test.go b/fluxer_rexctl/internal/backup/scope_test.go
index 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.go
index 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 App
if 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 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, changes
if 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 = nil
diff --git a/fluxer_rexctl/internal/engine/api.go b/fluxer_rexctl/internal/engine/api.go
index 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 string
Entrypoint []string
Command []string
+ Env []string
Mounts []Mount
Stdin io.Reader
Stdout io.Writer
diff --git a/fluxer_rexctl/internal/engine/exec.go b/fluxer_rexctl/internal/engine/exec.go
index 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 strin
Image: 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.go
index 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, err
diff --git a/fluxer_rexctl/internal/instance/adopt.go b/fluxer_rexctl/internal/instance/adopt.go
index 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 = 0o700
diff --git a/fluxer_rexctl/internal/instance/instance.go b/fluxer_rexctl/internal/instance/instance.go
index 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 = 3
KeepAllBackups = -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.json
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 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, e
var 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.go
index 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/Caddyfile
index 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/*.caddy
diff --git a/fluxer_rexctl/internal/stack/stack.go b/fluxer_rexctl/internal/stack/stack.go
index 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, d
if 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
}