Skip to content

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

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

package instance

import (
	"errors"
	"fmt"
	"io/fs"
	"net"
	"os"
	"os/user"
	"path/filepath"
	"regexp"
	"slices"
	"strings"
	"time"

	"github.com/compose-spec/compose-go/v2/template"

	"github.com/fluxerapp/fluxer/fluxer_rexctl/internal/envfile"
	"github.com/fluxerapp/fluxer/fluxer_rexctl/internal/settings"
	"github.com/fluxerapp/fluxer/fluxer_rexctl/internal/stack"
)

var (
	ErrNotFound     = errors.New("instance: not found")
	ErrLegacy       = errors.New("instance: made by the old installer")
	ErrExists       = errors.New("instance: already exists")
	ErrBadProject   = errors.New("instance: project names use lowercase letters, digits, dashes and underscores")
	ErrNoReleaseSet = errors.New("instance: the files for this release are missing")
)

const (
	EnvFileName    = ".env"
	CustomCompose  = settings.CustomFile
	StateDirName   = ".rexctl"
	StateFileName  = "state.json"
	LockFileName   = "lock"
	ReleasesDir    = "releases"
	StackDir       = "stack"
	BackupsDir     = "backups"
	CertsDir       = "certs"
	CADir          = "ca"
	CaddyDropInDir = "caddy.d"
	CaddySitesDir  = "caddy.d/sites"

	DefaultKeepBackups = 3
	KeepAllBackups     = -1
)

var legacyComposeNames = []string{"compose.yaml", "compose.yml", "docker-compose.yml", "docker-compose.yaml"}

var projectName = regexp.MustCompile(`^[a-z0-9][a-z0-9_-]*$`)

type Instance struct {
	Dir   string
	State *State
}

var rootHome = func() (string, error) {
	u, err := user.LookupId("0")
	if err != nil {
		return "", err
	}
	return u.HomeDir, nil
}

func DefaultDir() (string, error) {
	if asRoot() {
		return "/opt/fluxer", nil
	}
	home, err := os.UserHomeDir()
	if err != nil {
		return "", err
	}
	return filepath.Join(home, "fluxer"), nil
}

func Fallback() (string, error) {
	dir, err := DefaultDir()
	if err != nil || present(dir) || !asRoot() {
		return dir, err
	}
	if home, err := rootHome(); err == nil && filepath.IsAbs(home) && present(filepath.Join(home, "fluxer")) {
		return filepath.Join(home, "fluxer"), nil
	}
	return dir, nil
}

func present(dir string) bool {
	return exists(filepath.Join(dir, StateDirName, StateFileName)) || isLegacy(dir)
}

func Find(dir string) (*Instance, error) {
	return FindRepairing(dir, nil)
}

func FindRepairing(dir string, keys []string) (*Instance, error) {
	dir, err := filepath.Abs(dir)
	if err != nil {
		return nil, err
	}
	i := &Instance{Dir: dir}
	state, err := loadState(i.StatePath(), keys)
	if errors.Is(err, fs.ErrNotExist) {
		if isLegacy(dir) {
			return nil, ErrLegacy
		}
		return nil, ErrNotFound
	}
	if err != nil {
		return nil, err
	}
	i.State = state
	return i, nil
}

func isLegacy(dir string) bool {
	if exists(filepath.Join(dir, StateDirName, StateFileName)) || !exists(filepath.Join(dir, EnvFileName)) {
		return false
	}
	for _, name := range legacyComposeNames {
		if exists(filepath.Join(dir, name)) {
			return true
		}
	}
	env, _ := envfile.Load(filepath.Join(dir, EnvFileName))
	return env != nil && env.Value("COMPOSE_FILE") != ""
}

func exists(path string) bool {
	_, err := os.Stat(path)
	return err == nil
}

func Create(dir, project string) (*Instance, error) {
	if !projectName.MatchString(project) {
		return nil, ErrBadProject
	}
	dir, err := filepath.Abs(dir)
	if err != nil {
		return nil, err
	}
	i := &Instance{Dir: dir}
	if exists(i.StatePath()) {
		return nil, ErrExists
	}
	if isLegacy(dir) {
		return nil, ErrLegacy
	}
	if exists(i.Path(EnvFileName)) {
		return nil, ErrExists
	}
	if err := os.MkdirAll(dir, 0o755); err != nil {
		return nil, err
	}
	for _, d := range []string{StateDirName, BackupsDir} {
		if err := os.MkdirAll(i.Path(d), 0o700); err != nil {
			return nil, err
		}
		if err := envfile.RestrictToOwner(i.Path(d)); err != nil {
			return nil, err
		}
	}
	for _, d := range []string{CertsDir, CADir, CaddyDropInDir, CaddySitesDir} {
		if err := os.MkdirAll(i.Path(d), 0o755); err != nil {
			return nil, err
		}
	}
	now := time.Now().UTC().Truncate(time.Second)
	i.State = &State{Schema: StateSchema, Project: project, InstalledAt: now, UpdatedAt: now}
	i.State.normalize()
	return i, nil
}

func (i *Instance) Path(elem ...string) string {
	return filepath.Join(append([]string{i.Dir}, elem...)...)
}

func (i *Instance) StateDir() string { return i.Path(StateDirName) }

func (i *Instance) StatePath() string { return i.Path(StateDirName, StateFileName) }

func (i *Instance) ReleaseDir(version string) string {
	return i.Path(StateDirName, ReleasesDir, version)
}

func (i *Instance) SetDir(version string) string {
	return filepath.Join(i.ReleaseDir(version), StackDir)
}

func (i *Instance) BackupDir() string {
	if i.State != nil && i.State.BackupDir != "" {
		return i.State.BackupDir
	}
	return i.Path(BackupsDir)
}

func (i *Instance) KeepBackups() int {
	if i.State == nil || i.State.KeepBackups == 0 {
		return DefaultKeepBackups
	}
	return i.State.KeepBackups
}

func (i *Instance) Project() string {
	if i.State != nil {
		return i.State.Project
	}
	return ""
}

func (i *Instance) Set() (*stack.Set, error) {
	release := i.State.Release
	set, err := stack.LoadSet(i.SetDir(release))
	if err == nil {
		return set, nil
	}
	if !errors.Is(err, fs.ErrNotExist) {
		return nil, err
	}
	if embedded := stack.Embedded(); release == "" || release == embedded.Release {
		return embedded, nil
	}
	return nil, fmt.Errorf("%w: %s", ErrNoReleaseSet, release)
}

func (i *Instance) Custom() ([]byte, error) {
	data, err := os.ReadFile(i.Path(CustomCompose))
	if errors.Is(err, fs.ErrNotExist) {
		return nil, nil
	}
	return data, err
}

func (i *Instance) Environment() (map[string]string, error) {
	set, err := i.Set()
	if err != nil {
		return nil, err
	}
	return effectiveFor(set, i.State)
}

func effectiveFor(set *stack.Set, s *State) (map[string]string, error) {
	var admin map[string]string
	if s.AdminImport != nil {
		admin = s.AdminImport.Values
	}
	return settings.Effective(set, s.Settings, s.Secrets, admin)
}

func (i *Instance) Setting(name string) string {
	if i.State == nil {
		return ""
	}
	set, err := i.Set()
	if err != nil {
		return i.State.Settings[name]
	}
	env, err := effectiveFor(set, i.State)
	if err != nil {
		return i.State.Settings[name]
	}
	if v, ok := env[name]; ok {
		return v
	}
	custom, _ := i.Custom()
	return composeDefault(set, custom, env, name)
}

func composeDefault(set *stack.Set, custom []byte, env map[string]string, name string) string {
	defs := composeDefaults(setFiles(set, custom))[name]
	if len(defs) == 0 {
		return ""
	}
	v, ok := interpolate(defs[0], env)
	if !ok {
		return ""
	}
	return v
}

func interpolate(s string, env map[string]string) (string, bool) {
	out, err := template.Substitute(s, func(k string) (string, bool) {
		v, ok := env[k]
		return v, ok
	})
	return out, err == nil
}

func setFiles(set *stack.Set, custom []byte) [][]byte {
	var out [][]byte
	if names, err := stack.ComposeFileNames(set.Files); err == nil {
		for _, name := range names {
			if data, err := fs.ReadFile(set.Files, name); err == nil {
				out = append(out, data)
			}
		}
	}
	if len(custom) > 0 {
		out = append(out, custom)
	}
	return out
}

func (i *Instance) Domain() string {
	return i.Setting("FLUXER_DOMAIN")
}

func (i *Instance) Origin() string {
	if o := strings.TrimSpace(i.Setting("FLUXER_PUBLIC_ORIGIN")); o != "" && !strings.Contains(o, "${") {
		return strings.TrimRight(o, "/")
	}
	domain := i.Domain()
	if domain == "" {
		return ""
	}
	scheme := i.Setting("FLUXER_PUBLIC_SCHEME")
	if scheme == "" {
		scheme = "https"
	}
	port := i.Setting("FLUXER_PUBLIC_PORT")
	if port == "" || (scheme == "https" && port == "443") || (scheme == "http" && port == "80") {
		return scheme + "://" + domain
	}
	return scheme + "://" + net.JoinHostPort(domain, port)
}

func (i *Instance) Overlays() []stack.Overlay {
	if i.State == nil {
		return nil
	}
	return stack.OverlaysFor(i.State.Settings)
}

func (i *Instance) ComposeFiles() []string {
	files := i.StackFiles(i.Overlays())
	if exists(i.Path(CustomCompose)) {
		files = append(files, i.Path(CustomCompose))
	}
	return files
}

func (i *Instance) MissingFiles() []string {
	files := i.StackFiles(i.Overlays())
	for name := range stack.MountedFiles {
		files = append(files, i.Generated(name))
	}
	var out []string
	for _, f := range files {
		if exists(f) {
			continue
		}
		if rel, err := filepath.Rel(i.Dir, f); err == nil {
			f = rel
		}
		out = append(out, f)
	}
	slices.Sort(out)
	return out
}

func (i *Instance) Save() error {
	if i.State == nil {
		return fmt.Errorf("instance: nothing to save in %s", i.Dir)
	}
	i.State.UpdatedAt = time.Now().UTC().Truncate(time.Second)
	return i.State.Save(i.StatePath())
}

func removeIfExists(path string) error {
	if err := os.Remove(path); err != nil && !errors.Is(err, fs.ErrNotExist) {
		return err
	}
	return nil
}

func ReleaseDefault(set *stack.Set, name string) string {
	return composeDefault(set, nil, nil, name)
}