Skip to content

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

TypeScript fluxerfluxerapp
5.6 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-or-later

package deploy

import (
	"context"
	"crypto/sha256"
	"encoding/hex"
	"errors"
	"fmt"
	"io/fs"
	"os"
	"path/filepath"
	"slices"
	"strings"
	"time"

	"github.com/fluxerapp/fluxer/fluxer_rexctl/internal/engine"
	"github.com/fluxerapp/fluxer/fluxer_rexctl/internal/instance"
	"github.com/fluxerapp/fluxer/fluxer_rexctl/internal/release"
	"github.com/fluxerapp/fluxer/fluxer_rexctl/internal/settings"
	"github.com/fluxerapp/fluxer/fluxer_rexctl/internal/stack"
	"github.com/fluxerapp/fluxer/fluxer_rexctl/internal/ui"
)

const upgradeFix = "Run rexctl upgrade to put this instance on the release this rexctl knows."

func ReleaseSet(inst *instance.Instance) (*stack.Set, error) {
	set, err := inst.Set()
	if errors.Is(err, instance.ErrNoReleaseSet) {
		return nil, &ui.ExitError{Code: ui.ExitRefused, Err: err,
			Msg: fmt.Sprintf("rexctl can't find the files of Fluxer %s on this machine.", inst.State.Release),
			Fix: upgradeFix}
	}
	if err != nil {
		return nil, ui.Wrap(err, fmt.Sprintf("rexctl can't read the files of Fluxer %s.", inst.State.Release), upgradeFix)
	}
	return set, nil
}

func CustomFile(inst *instance.Instance) ([]byte, error) {
	data, err := inst.Custom()
	if err != nil {
		return nil, ui.Wrap(err, fmt.Sprintf("rexctl can't read %s.", instance.CustomCompose), "Check that you can read it, then try again.")
	}
	return data, nil
}

func adminImportValues(s *instance.State) map[string]string {
	if s.AdminImport == nil {
		return nil
	}
	return s.AdminImport.Values
}

func Environment(set *stack.Set, s *instance.State, chosen map[string]string) (map[string]string, error) {
	env, err := settings.Effective(set, chosen, s.Secrets, adminImportValues(s))
	if err != nil {
		var se *settings.Error
		if errors.As(err, &se) {
			return nil, &ui.ExitError{Code: ui.ExitRefused, Msg: se.Problem, Fix: se.Fix, Err: err}
		}
		return nil, err
	}
	return env, nil
}

func composeFiles(inst *instance.Instance, chosen map[string]string) []string {
	files := inst.StackFiles(stack.OverlaysFor(chosen))
	if _, err := os.Stat(inst.Path(instance.CustomCompose)); err == nil {
		files = append(files, inst.Path(instance.CustomCompose))
	}
	return files
}

func specFor(inst *instance.Instance, set *stack.Set, chosen map[string]string) (engine.Spec, error) {
	env, err := Environment(set, inst.State, chosen)
	if err != nil {
		return engine.Spec{}, err
	}
	return engine.Spec{Name: inst.Project(), Dir: inst.Dir, Files: composeFiles(inst, chosen), Env: env}, nil
}

func Spec(inst *instance.Instance) (engine.Spec, error) {
	set, err := ReleaseSet(inst)
	if err != nil {
		return engine.Spec{}, err
	}
	return specFor(inst, set, inst.State.Settings)
}

func Load(ctx context.Context, inst *instance.Instance, e *engine.Engine) (*engine.Project, error) {
	s, err := Spec(inst)
	if err != nil {
		return nil, err
	}
	return e.Load(ctx, s)
}

func render(inst *instance.Instance, set *stack.Set, chosen map[string]string) (*stack.Rendered, error) {
	r, err := inst.Render(set, stack.OverlaysFor(chosen), inst.State.Images.Refs)
	if err != nil {
		return nil, ui.Wrap(err, "Couldn't write Fluxer's files.", "Check that you can write to "+inst.Dir+", then try again.")
	}
	inst.State.Rendered = r.Hashes
	return r, nil
}

func save(inst *instance.Instance) error {
	if err := inst.Save(); err != nil {
		return ui.Wrap(err, "Couldn't save your settings.", "Check that you can write to "+inst.Dir+", then try again.")
	}
	return nil
}

func mountedHashes(inst *instance.Instance) (map[string]string, error) {
	out := map[string]string{}
	for dir := range stack.MountedDirs {
		h := sha256.New()
		root := inst.Path(dir)
		err := filepath.WalkDir(root, func(path string, d fs.DirEntry, err error) error {
			if err != nil {
				if errors.Is(err, fs.ErrNotExist) && path == root {
					return fs.SkipAll
				}
				return err
			}
			if d.IsDir() {
				return nil
			}
			data, err := os.ReadFile(path)
			if err != nil {
				return err
			}
			rel, _ := filepath.Rel(root, path)
			fmt.Fprintf(h, "%s\x00%d\x00", filepath.ToSlash(rel), len(data))
			h.Write(data)
			return nil
		})
		if err != nil {
			return nil, err
		}
		out[dir] = "sha256:" + hex.EncodeToString(h.Sum(nil))
	}
	return out, nil
}

func checkDrift(inst *instance.Instance, withEnv bool) error {
	if _, err := instance.KeepEdits(inst); err != nil {
		return ui.Wrap(err, "rexctl can't keep a copy of the files you changed.", "Check that you can write to "+inst.Dir+", then try again.")
	}
	r, err := instance.Drift(inst)
	if err != nil {
		return ui.Wrap(err, "rexctl can't check Fluxer's files.", "Check that you can read "+inst.Dir+", then try again.")
	}
	if !withEnv {
		r.Env = nil
	}
	var de *instance.DriftError
	if err := r.Err(); errors.As(err, &de) {
		fix := de.Fix
		if len(de.Lines) > 0 {
			fix += "\n" + strings.Join(de.Lines, "\n")
		}
		return &ui.ExitError{Code: ui.ExitRefused, Msg: de.Msg, Fix: fix, Err: err}
	} else if err != nil {
		return err
	}
	return nil
}

func refuseEjected(inst *instance.Instance) error {
	var ee *instance.EjectedError
	if err := inst.Managed(); errors.As(err, &ee) {
		return &ui.ExitError{Code: ui.ExitRefused, Msg: ee.Error(), Fix: ee.Fix(), Err: err}
	}
	return nil
}

func refuseUpgrade(inst *instance.Instance) error {
	if inst.State.Upgrade == nil || upgradeNotPulled(inst) {
		return nil
	}
	return ui.Refused("An upgrade of this instance hasn't finished.", "Run rexctl upgrade to finish it, then try again.")
}

func upgradeNotPulled(inst *instance.Instance) bool {
	u := inst.State.Upgrade
	i := slices.Index(release.Phases, u.Phase)
	return i >= 0 && i < slices.Index(release.Phases, release.PhasePulled)
}

func now() time.Time { return time.Now().UTC().Truncate(time.Second) }