Skip to content

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

TypeScript fluxerfluxerapp

feat(rexctl): download and stage release stack files

Hampuse15b363b1e34
diff --git a/fluxer_rexctl/internal/release/files.go b/fluxer_rexctl/internal/release/files.go
new file mode 100644
index 000000000..f6c77ecf6
--- /dev/null
+++ b/fluxer_rexctl/internal/release/files.go
@@ -0,0 +1,479 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+package release
+
+import (
+ "context"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "io/fs"
+ "maps"
+ "os"
+ "path/filepath"
+ "slices"
+ "sort"
+
+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/engine"
+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/envfile"
+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/instance"
+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/stack"
+)
+
+const (
+ StackDirName = "stack"
+ snapshotState = "state.json"
+ imagesFile = "images.json"
+ unknownName = "before-rexctl"
+)
+
+var (
+ ErrNoSnapshot = errors.New("release: no saved files for this release")
+ ErrPostgresMajor = errors.New("release: the database major version changes")
+)
+
+type PostgresMajorError struct {
+ From int
+ To int
+}
+
+func (e *PostgresMajorError) Error() string {
+ return fmt.Sprintf("release: database major version changes from %d to %d", e.From, e.To)
+}
+
+func (e *PostgresMajorError) Is(target error) bool { return target == ErrPostgresMajor }
+
+type imageList struct {
+ Release string `json:"release"`
+ Images []string `json:"images"`
+}
+
+func DirName(version string) string {
+ if version == "" {
+ return unknownName
+ }
+ return version
+}
+
+func Dir(inst *instance.Instance, version string) string {
+ return inst.ReleaseDir(DirName(version))
+}
+
+func StackDir(inst *instance.Instance, version string) string {
+ return filepath.Join(Dir(inst, version), StackDirName)
+}
+
+func private(version string) bool {
+ return DirName(version) == stack.LegacyRelease
+}
+
+func writeFile(path string, data []byte, private bool) error {
+ if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
+ return err
+ }
+ return envfile.WriteFileAtomic(path, data, private)
+}
+
+func exists(path string) bool {
+ _, err := os.Stat(path)
+ return err == nil
+}
+
+func WriteRelease(inst *instance.Instance, set *stack.Set) error {
+ if set == nil || set.Release == "" {
+ return errors.New("release: the release set has no name")
+ }
+ dir := StackDir(inst, set.Release)
+ if exists(filepath.Join(dir, stack.ProfilesFile)) {
+ return nil
+ }
+ return stack.WriteSet(dir, set)
+}
+
+func Snapshot(inst *instance.Instance, version string, images []string) error {
+ dir := Dir(inst, version)
+ state, err := json.MarshalIndent(inst.State, "", " ")
+ if err != nil {
+ return err
+ }
+ if err := writeFile(filepath.Join(dir, snapshotState), append(state, '\n'), true); err != nil {
+ return err
+ }
+ if images != nil || !exists(filepath.Join(dir, imagesFile)) {
+ return writeImages(dir, version, images)
+ }
+ return nil
+}
+
+func HasSnapshot(inst *instance.Instance, version string) bool {
+ dir := Dir(inst, version)
+ if !exists(filepath.Join(dir, snapshotState)) {
+ return false
+ }
+ return exists(filepath.Join(dir, StackDirName, stack.ProfilesFile)) || exists(filepath.Join(dir, oldEnvFile))
+}
+
+func SnapshotState(inst *instance.Instance, version string) (*instance.State, error) {
+ dir := Dir(inst, version)
+ data, err := os.ReadFile(filepath.Join(dir, snapshotState))
+ if errors.Is(err, fs.ErrNotExist) {
+ return nil, ErrNoSnapshot
+ }
+ if err != nil {
+ return nil, err
+ }
+ return instance.ParseState(data, inst.Dir, filepath.Join(dir, oldEnvFile))
+}
+
+func LoadSet(inst *instance.Instance, version string) (*stack.Set, error) {
+ set, err := stack.LoadSet(StackDir(inst, version))
+ if err == nil {
+ return set, nil
+ }
+ if !errors.Is(err, fs.ErrNotExist) {
+ return nil, err
+ }
+ dir := Dir(inst, version)
+ if !exists(filepath.Join(dir, oldEnvFile)) || !exists(filepath.Join(dir, stack.ComposeFile)) {
+ return nil, ErrNoSnapshot
+ }
+ files := os.DirFS(dir)
+ vars, err := stack.FilesVars(files)
+ if err != nil {
+ return nil, err
+ }
+ return &stack.Set{Release: version, Files: files, Profiles: maps.Clone(stack.Embedded().Profiles), Vars: vars}, nil
+}
+
+type Restored struct {
+ Files []string
+ Settings []string
+ Restart []string
+}
+
+func Restore(inst *instance.Instance, version string) (*Restored, error) {
+ if !HasSnapshot(inst, version) {
+ return nil, ErrNoSnapshot
+ }
+ saved, err := SnapshotState(inst, version)
+ if err != nil {
+ return nil, err
+ }
+ set, err := LoadSet(inst, version)
+ if err != nil {
+ return nil, err
+ }
+ if len(saved.Images.Refs) == 0 && Valid(version) && exists(StackDir(inst, version)) {
+ return nil, fmt.Errorf("release: the snapshot of %s records no images", version)
+ }
+ r, err := stack.Render(set, stack.OverlaysFor(saved.Settings), saved.Images.Refs, inst.Project(), inst.Dir)
+ if err != nil {
+ return nil, err
+ }
+ out := &Restored{Files: r.Changed, Restart: r.RestartNeeded, Settings: changedKeys(inst.State.Settings, saved.Settings)}
+ for k, v := range inst.State.Secrets {
+ if _, ok := saved.Secrets[k]; !ok {
+ saved.Secrets[k] = v
+ }
+ }
+ inst.State.Release = saved.Release
+ inst.State.Images = saved.Images
+ inst.State.Settings = saved.Settings
+ inst.State.Secrets = saved.Secrets
+ inst.State.Rendered = r.Hashes
+ return out, nil
+}
+
+func changedKeys(a, b map[string]string) []string {
+ var out []string
+ for k, v := range a {
+ if w, ok := b[k]; !ok || w != v {
+ out = append(out, k)
+ }
+ }
+ for k := range b {
+ if _, ok := a[k]; !ok {
+ out = append(out, k)
+ }
+ }
+ sort.Strings(out)
+ return out
+}
+
+type MissingProblem struct {
+ Files []string
+ Message string
+ Fix string
+ Restorable bool
+}
+
+func expectedFiles(inst *instance.Instance) []string {
+ if len(inst.State.Rendered) > 0 {
+ return slices.Sorted(maps.Keys(inst.State.Rendered))
+ }
+ out := []string{stack.ComposeFile, stack.Caddyfile}
+ for _, o := range stack.OverlaysFor(inst.State.Settings) {
+ out = append(out, stack.OverlayFiles[o])
+ }
+ return out
+}
+
+func MissingFiles(inst *instance.Instance) []string {
+ if inst.State == nil {
+ return nil
+ }
+ var out []string
+ for _, name := range expectedFiles(inst) {
+ if _, err := os.Lstat(filepath.Join(inst.Dir, name)); errors.Is(err, fs.ErrNotExist) {
+ out = append(out, name)
+ }
+ }
+ return out
+}
+
+func Missing(inst *instance.Instance) *MissingProblem {
+ files := MissingFiles(inst)
+ if len(files) == 0 {
+ return nil
+ }
+ p := &MissingProblem{Files: files, Message: "Some of Fluxer's files are missing from " + inst.Dir + "."}
+ if len(files) == 1 {
+ p.Message = files[0] + " is missing from " + inst.Dir + "."
+ }
+ p.Restorable = canRestoreMissing(inst, files)
+ switch {
+ case !p.Restorable:
+ p.Fix = "Restore your instance from a backup with rexctl restore."
+ case len(files) == 1:
+ p.Fix = "Run rexctl doctor --fix to put it back."
+ default:
+ p.Fix = "Run rexctl doctor --fix to put them back."
+ }
+ return p
+}
+
+func canRestoreMissing(inst *instance.Instance, files []string) bool {
+ set, err := LoadSet(inst, inst.State.Release)
+ if err != nil {
+ return false
+ }
+ for _, name := range files {
+ if _, err := fs.Stat(set.Files, name); err != nil {
+ return false
+ }
+ }
+ return true
+}
+
+func RestoreMissing(inst *instance.Instance) ([]string, error) {
+ missing := MissingFiles(inst)
+ if len(missing) == 0 {
+ return nil, nil
+ }
+ set, err := LoadSet(inst, inst.State.Release)
+ if err != nil {
+ return nil, err
+ }
+ source := set.Files
+ if set.Release != stack.LegacyRelease {
+ tmp, err := os.MkdirTemp(inst.StateDir(), "render-")
+ if err != nil {
+ return nil, err
+ }
+ defer os.RemoveAll(tmp)
+ if _, err := stack.Render(set, stack.OverlaysFor(inst.State.Settings), inst.State.Images.Refs, inst.Project(), tmp); err != nil {
+ return nil, err
+ }
+ source = os.DirFS(tmp)
+ }
+ var restored []string
+ for _, name := range missing {
+ data, err := fs.ReadFile(source, name)
+ if err != nil || len(data) == 0 {
+ continue
+ }
+ if err := writeFile(filepath.Join(inst.Dir, name), data, false); err != nil {
+ return restored, err
+ }
+ if inst.State.Rendered == nil {
+ inst.State.Rendered = map[string]string{}
+ }
+ inst.State.Rendered[name] = stack.Hash(data)
+ restored = append(restored, name)
+ }
+ if len(restored) < len(missing) {
+ return restored, ErrNoSnapshot
+ }
+ return restored, nil
+}
+
+func RestartFor(changed []string) []string {
+ set := map[string]bool{}
+ for _, rel := range changed {
+ for file, services := range stack.MountedFiles {
+ if filepath.Clean(rel) == filepath.Clean(file) {
+ for _, s := range services {
+ set[s] = true
+ }
+ }
+ }
+ }
+ return slices.Sorted(maps.Keys(set))
+}
+
+func writeImages(dir, version string, refs []string) error {
+ uniq := map[string]bool{}
+ list := imageList{Release: version, Images: []string{}}
+ for _, r := range refs {
+ if r != "" && !uniq[r] {
+ uniq[r] = true
+ list.Images = append(list.Images, r)
+ }
+ }
+ sort.Strings(list.Images)
+ data, err := json.MarshalIndent(list, "", " ")
+ if err != nil {
+ return err
+ }
+ return writeFile(filepath.Join(dir, imagesFile), append(data, '\n'), private(version))
+}
+
+func Images(inst *instance.Instance, version string) ([]string, error) {
+ data, err := os.ReadFile(filepath.Join(Dir(inst, version), imagesFile))
+ if err != nil {
+ return nil, err
+ }
+ var list imageList
+ if err := json.Unmarshal(data, &list); err != nil {
+ return nil, err
+ }
+ return list.Images, nil
+}
+
+func KeptImages(inst *instance.Instance) []string {
+ entries, _ := os.ReadDir(inst.Path(instance.StateDirName, instance.ReleasesDir))
+ var out []string
+ for _, d := range entries {
+ if !d.IsDir() {
+ continue
+ }
+ refs, _ := Images(inst, d.Name())
+ for _, r := range refs {
+ if !slices.Contains(out, r) {
+ out = append(out, r)
+ }
+ }
+ }
+ return out
+}
+
+func CheckPostgres(fromRef, toRef string) error {
+ if fromRef == "" || toRef == "" {
+ return nil
+ }
+ from, err := stack.PostgresMajor(fromRef)
+ if err != nil {
+ return nil
+ }
+ to, err := stack.PostgresMajor(toRef)
+ if err != nil {
+ return err
+ }
+ if to != from {
+ return &PostgresMajorError{From: from, To: to}
+ }
+ return nil
+}
+
+func Prune(ctx context.Context, inst *instance.Instance, e *engine.Engine) error {
+ root := inst.Path(instance.StateDirName, instance.ReleasesDir)
+ entries, err := os.ReadDir(root)
+ if errors.Is(err, fs.ErrNotExist) {
+ return nil
+ }
+ if err != nil {
+ return err
+ }
+ keep := map[string]bool{
+ stack.LegacyRelease: true,
+ DirName(inst.State.Release): true,
+ DirName(inst.State.PreviousRelease): true,
+ }
+ if u := inst.State.Upgrade; u != nil {
+ keep[DirName(u.From)] = true
+ keep[DirName(u.To)] = true
+ }
+ var versions []string
+ for _, d := range entries {
+ if d.IsDir() && d.Name() != stack.LegacyRelease {
+ versions = append(versions, d.Name())
+ }
+ }
+ sort.Slice(versions, func(i, j int) bool { return Compare(versions[i], versions[j]) > 0 })
+ for i, v := range versions {
+ if i < instance.KeepReleases {
+ keep[v] = true
+ }
+ }
+ kept := map[string]bool{}
+ for _, r := range inst.State.Images.Refs {
+ kept[r] = true
+ }
+ var drop []string
+ for _, v := range append(versions, stack.LegacyRelease) {
+ refs, _ := Images(inst, v)
+ if keep[v] {
+ for _, r := range refs {
+ kept[r] = true
+ }
+ continue
+ }
+ drop = append(drop, refs...)
+ if err := removeAll(filepath.Join(root, v)); err != nil {
+ return err
+ }
+ }
+ var remove []string
+ seen := map[string]bool{}
+ for _, r := range drop {
+ if !kept[r] && !seen[r] {
+ seen[r] = true
+ remove = append(remove, r)
+ }
+ }
+ if len(remove) == 0 || e == nil {
+ return nil
+ }
+ return e.RemoveImages(ctx, remove)
+}
+
+func removeAll(dir string) error {
+ _ = filepath.WalkDir(dir, func(p string, d fs.DirEntry, err error) error {
+ if err != nil {
+ return nil
+ }
+ if d.IsDir() {
+ _ = os.Chmod(p, 0o700)
+ } else if d.Type().IsRegular() {
+ _ = os.Chmod(p, 0o600)
+ }
+ return nil
+ })
+ return os.RemoveAll(dir)
+}
+
+func Switched(u *instance.Upgrade) bool {
+ return slices.Index(Phases, u.Phase) >= slices.Index(Phases, PhaseRecreated)
+}
+
+func UnfinishedFix(u *instance.Upgrade) string {
+ switch {
+ case u.BackFailed && u.Backup != "":
+ return fmt.Sprintf("Run rexctl upgrade to start Fluxer %s again, or rexctl rollback --restore-database to restore the backup from before the upgrade.", u.To)
+ case u.BackFailed:
+ return fmt.Sprintf("Run rexctl upgrade to start Fluxer %s again.", u.To)
+ case !Switched(u):
+ return fmt.Sprintf("Run rexctl upgrade to finish it, or rexctl rollback to stop it and stay on Fluxer %s.", u.From)
+ }
+ return "Run rexctl upgrade to finish it, or rexctl rollback to go back."
+}