Skip to content

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

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

package stack

import (
	"bytes"
	"crypto/sha256"
	"encoding/hex"
	"errors"
	"fmt"
	"io/fs"
	"maps"
	"os"
	"path/filepath"
	"regexp"
	"slices"
	"strconv"
	"strings"
)

const defaultProject = "fluxer"

var defaultName = regexp.MustCompile(`(?m)^name: ` + defaultProject + `$`)

const (
	ComposeFile  = "docker-compose.yml"
	Caddyfile    = "Caddyfile"
	GeneratedDir = ".rexctl/generated"
)

type Overlay string

const (
	OverlayProxy               Overlay = "proxy"
	OverlayTunnel              Overlay = "tunnel"
	OverlayExternalObjectStore Overlay = "external-object-store"
	OverlayIPv6                Overlay = "ipv6"
	OverlayExternalVoice       Overlay = "external-voice"
)

var OverlayFiles = map[Overlay]string{
	OverlayProxy:               "docker-compose.proxy.yml",
	OverlayTunnel:              "tunnel.compose.yml",
	OverlayExternalObjectStore: "external-object-store.compose.yml",
	OverlayIPv6:                "ipv6.compose.yml",
	OverlayExternalVoice:       "external-voice.compose.yml",
}

var overlayOrder = []Overlay{OverlayProxy, OverlayTunnel, OverlayExternalObjectStore, OverlayIPv6, OverlayExternalVoice}

var MountedFiles = map[string][]string{
	Caddyfile: {"edge"},
}

const NodeCADir = "/etc/fluxer/ca"

var MountedDirs = map[string][]string{
	"ca":      {"api", "worker"},
	"caddy.d": {"edge"},
	"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")
	ErrMissingFile     = errors.New("stack: the release has no such file")
)

type Rendered struct {
	Dir           string
	Hashes        map[string]string
	ComposeFiles  []string
	Changed       []string
	RestartNeeded []string
}

func NormalizeOverlays(overlays []Overlay) ([]Overlay, error) {
	seen := make(map[Overlay]bool, len(overlays))
	for _, o := range overlays {
		if _, ok := OverlayFiles[o]; !ok {
			return nil, fmt.Errorf("%w: %s", ErrUnknownOverlay, o)
		}
		seen[o] = true
	}
	if seen[OverlayProxy] && seen[OverlayTunnel] {
		return nil, ErrOverlayConflict
	}
	out := make([]Overlay, 0, len(seen))
	for _, o := range overlayOrder {
		if seen[o] {
			out = append(out, o)
		}
	}
	return out, nil
}

func OverlaysFor(settings map[string]string) []Overlay {
	var out []Overlay
	switch strings.TrimSpace(settings["edge.mode"]) {
	case string(OverlayProxy):
		out = append(out, OverlayProxy)
	case string(OverlayTunnel):
		out = append(out, OverlayTunnel)
	}
	if strings.TrimSpace(settings["storage.endpoint"]) != "" {
		out = append(out, OverlayExternalObjectStore)
	}
	if on, err := strconv.ParseBool(strings.TrimSpace(settings["network.ipv6"])); err == nil && on {
		out = append(out, OverlayIPv6)
	}
	if !VoiceBundled(settings["voice.bundled"]) {
		out = append(out, OverlayExternalVoice)
	}
	return out
}

func VoiceBundled(value string) bool {
	on, err := strconv.ParseBool(strings.TrimSpace(value))
	return err != nil || on
}

func FileNames() []string {
	names := []string{ComposeFile, Caddyfile}
	for _, o := range overlayOrder {
		names = append(names, OverlayFiles[o])
	}
	return names
}

func GeneratedPath(dir string, name ...string) string {
	return filepath.Join(append([]string{dir, filepath.FromSlash(GeneratedDir)}, name...)...)
}

func ProjectDir(composeFile string) string {
	dir := filepath.Dir(composeFile)
	if trimmed, ok := strings.CutSuffix(dir, string(filepath.Separator)+filepath.FromSlash(GeneratedDir)); ok {
		return trimmed
	}
	return dir
}

func FilesDir(dir string, root bool) string {
	if abs, err := filepath.Abs(dir); err == nil {
		dir = abs
	}
	if root {
		return dir
	}
	return GeneratedPath(dir)
}

func ComposeFiles(dir string, overlays []Overlay) []string {
	return ComposeFilesAt(dir, overlays, false)
}

func ComposeFilesAt(dir string, overlays []Overlay, root bool) []string {
	files := FilesDir(dir, root)
	out := []string{filepath.Join(files, ComposeFile)}
	for _, o := range overlayOrder {
		if slices.Contains(overlays, o) {
			out = append(out, filepath.Join(files, OverlayFiles[o]))
		}
	}
	return out
}

func header(name string) []byte {
	how := "To change it, run rexctl config edit."
	if name == Caddyfile {
		how = "To add Caddy directives, put a .caddy file in caddy.d in your instance folder."
	}
	return []byte("# rexctl writes this file and puts its own version back when it changes Fluxer.\n# " + how + "\n\n")
}

func mountRefs(name string) (plain, managed []byte) {
	return []byte("./" + name + ":"), []byte("./" + GeneratedDir + "/" + name + ":")
}

func Managed(name string, data []byte) []byte {
	if name != Caddyfile {
		for mounted := range MountedFiles {
			plain, managed := mountRefs(mounted)
			data = bytes.ReplaceAll(data, plain, managed)
		}
	}
	return append(header(name), data...)
}

func Plain(name string, data []byte) []byte {
	data = bytes.TrimPrefix(data, header(name))
	if name != Caddyfile {
		for mounted := range MountedFiles {
			plain, managed := mountRefs(mounted)
			data = bytes.ReplaceAll(data, managed, plain)
		}
	}
	return data
}

func MountsGenerated(compose []byte, name string) bool {
	_, managed := mountRefs(name)
	return bytes.Contains(compose, managed)
}

type renderedFile struct {
	name string
	data []byte
}

func renderFiles(set *Set, selected []Overlay, images map[string]string, project string) ([]renderedFile, []Overlay, error) {
	overlays, err := NormalizeOverlays(selected)
	if err != nil {
		return nil, nil, err
	}
	compose, err := RenderCompose(set, images, project)
	if err != nil {
		return nil, nil, err
	}
	caddy, err := ReadFile(set, Caddyfile)
	if err != nil {
		return nil, nil, err
	}
	out := []renderedFile{{ComposeFile, compose}, {Caddyfile, caddy}}
	for _, o := range overlays {
		data, err := ReadFile(set, OverlayFiles[o])
		if err != nil {
			return nil, nil, err
		}
		out = append(out, renderedFile{OverlayFiles[o], data})
	}
	return out, overlays, nil
}

func RenderCompose(set *Set, images map[string]string, project string) ([]byte, error) {
	compose, err := ReadFile(set, ComposeFile)
	if err != nil {
		return nil, err
	}
	if set.Release != LegacyRelease {
		if compose, err = pinImages(compose, set.Release, images); err != nil {
			return nil, err
		}
	}
	return nameProject(compose, project), nil
}

func Hashes(set *Set, selected []Overlay, images map[string]string, project string) (map[string]string, error) {
	files, _, err := renderFiles(set, selected, images, project)
	if err != nil {
		return nil, err
	}
	out := make(map[string]string, len(files))
	for _, f := range files {
		out[f.name] = Hash(f.data)
	}
	return out, nil
}

func ReadFile(set *Set, name string) ([]byte, error) {
	if set == nil || set.Files == nil {
		return nil, fmt.Errorf("%w: %s", ErrMissingFile, name)
	}
	data, err := fs.ReadFile(set.Files, name)
	if errors.Is(err, fs.ErrNotExist) {
		return nil, fmt.Errorf("%w: %s in %s", ErrMissingFile, name, set.Release)
	}
	if err != nil {
		return nil, err
	}
	return bytes.ReplaceAll(data, []byte("\r\n"), []byte("\n")), nil
}

func Hash(data []byte) string {
	sum := sha256.Sum256(data)
	return "sha256:" + hex.EncodeToString(sum[:])
}

func plan(dir string, files []renderedFile, overlays []Overlay) (changed, stale []string, err error) {
	for _, f := range files {
		current, err := os.ReadFile(filepath.Join(dir, f.name))
		switch {
		case errors.Is(err, fs.ErrNotExist):
			changed = append(changed, f.name)
		case err != nil:
			return nil, nil, err
		case !bytes.Equal(current, f.data):
			changed = append(changed, f.name)
		}
	}
	for _, o := range overlayOrder {
		if slices.Contains(overlays, o) {
			continue
		}
		name := OverlayFiles[o]
		if _, err := os.Lstat(filepath.Join(dir, name)); err == nil {
			stale = append(stale, name)
		} else if !errors.Is(err, fs.ErrNotExist) {
			return nil, nil, err
		}
	}
	return changed, stale, nil
}

func nameProject(compose []byte, project string) []byte {
	if project == "" || project == defaultProject {
		return compose
	}
	compose = defaultName.ReplaceAll(compose, []byte(`name: "`+project+`"`))
	return bytes.ReplaceAll(compose, []byte("compose -p "+defaultProject+" "), []byte("compose -p "+project+" "))
}

func Files(set *Set, selected []Overlay, images map[string]string, project string) (map[string][]byte, error) {
	files, _, err := renderFiles(set, selected, images, project)
	if err != nil {
		return nil, err
	}
	out := make(map[string][]byte, len(files))
	for _, f := range files {
		out[f.name] = Managed(f.name, f.data)
	}
	return out, nil
}

func Render(set *Set, selected []Overlay, images map[string]string, project, dir string) (*Rendered, error) {
	return RenderAt(set, selected, images, project, dir, false)
}

func RenderAt(set *Set, selected []Overlay, images map[string]string, project, dir string, root bool) (*Rendered, error) {
	files, overlays, err := renderFiles(set, selected, images, project)
	if err != nil {
		return nil, err
	}
	for _, d := range madeDirs {
		if err := os.MkdirAll(filepath.Join(dir, d), 0o755); err != nil {
			return nil, err
		}
	}
	if !root {
		for i, f := range files {
			files[i].data = Managed(f.name, f.data)
		}
	}
	gen := FilesDir(dir, root)
	if root {
		if err := os.MkdirAll(gen, 0o755); err != nil {
			return nil, err
		}
	} else if err := MakeGenerated(gen); err != nil {
		return nil, err
	}
	changed, stale, err := plan(gen, files, overlays)
	if err != nil {
		return nil, err
	}
	var write []renderedFile
	for _, f := range files {
		if slices.Contains(changed, f.name) {
			write = append(write, f)
		}
	}
	if err := writeAll(gen, write); err != nil {
		return nil, err
	}
	for _, name := range stale {
		if err := os.Remove(filepath.Join(gen, name)); err != nil && !errors.Is(err, fs.ErrNotExist) {
			return nil, err
		}
	}
	r := &Rendered{Dir: dir, Hashes: make(map[string]string, len(files)), ComposeFiles: ComposeFilesAt(dir, overlays, root)}
	for _, f := range files {
		r.Hashes[f.name] = Hash(f.data)
	}
	r.Changed = append(changed, stale...)
	r.RestartNeeded = restartNeeded(r.Changed)
	return r, nil
}

func restartNeeded(changed []string) []string {
	var out []string
	for _, name := range changed {
		for _, svc := range MountedFiles[name] {
			if !slices.Contains(out, svc) {
				out = append(out, svc)
			}
		}
	}
	slices.Sort(out)
	return out
}

func MakeGenerated(path string) error {
	if err := os.MkdirAll(path, 0o755); err != nil {
		return err
	}
	info, err := os.Lstat(path)
	if err != nil {
		return err
	}
	if !info.IsDir() {
		return fmt.Errorf("stack: %s is not a directory", path)
	}
	return nil
}

func writeAll(dir string, files []renderedFile) error {
	var staged []string
	cleanup := func() {
		for _, p := range staged {
			os.Remove(p)
		}
	}
	for _, f := range files {
		tmp, err := stage(dir, f.name, f.data)
		if err != nil {
			cleanup()
			return err
		}
		staged = append(staged, tmp)
	}
	type previous struct {
		path   string
		data   []byte
		exists bool
	}
	var done []previous
	restore := func() {
		for _, p := range done {
			if !p.exists {
				os.Remove(p.path)
				continue
			}
			if tmp, err := stage(filepath.Dir(p.path), filepath.Base(p.path), p.data); err == nil {
				if os.Rename(tmp, p.path) != nil {
					os.Remove(tmp)
				}
			}
		}
	}
	for i, f := range files {
		target := filepath.Join(dir, f.name)
		old, err := os.ReadFile(target)
		exists := err == nil
		if err != nil && !errors.Is(err, fs.ErrNotExist) {
			restore()
			cleanup()
			return err
		}
		if err := os.Rename(staged[i], target); err != nil {
			restore()
			cleanup()
			return err
		}
		done = append(done, previous{path: target, data: old, exists: exists})
	}
	return nil
}

func stage(dir, name string, data []byte) (string, error) {
	f, err := os.CreateTemp(dir, "."+name+".rexctl-tmp-*")
	if err != nil {
		return "", err
	}
	path := f.Name()
	err = f.Chmod(0o644)
	if err == nil {
		_, err = f.Write(data)
	}
	if err == nil {
		err = f.Sync()
	}
	if closeErr := f.Close(); err == nil {
		err = closeErr
	}
	if err != nil {
		os.Remove(path)
		return "", err
	}
	return path, nil
}