Skip to content

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

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

package instance

import (
	"context"
	"encoding/json"
	"errors"
	"io/fs"
	"maps"
	"os"
	"path/filepath"
	"slices"

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

const generatedSchema = 3

const LayoutSchema = generatedSchema

var euid = os.Geteuid

func (i *Instance) OldLayout() bool {
	return i.State != nil && i.State.rootLayout
}

func (i *Instance) Generated(name string) string {
	return filepath.Join(stack.FilesDir(i.Dir, i.OldLayout()), filepath.FromSlash(name))
}

func (i *Instance) StackFiles(overlays []stack.Overlay) []string {
	return stack.ComposeFilesAt(i.Dir, overlays, i.OldLayout())
}

func (i *Instance) Render(set *stack.Set, overlays []stack.Overlay, images map[string]string) (*stack.Rendered, error) {
	return stack.RenderAt(set, overlays, images, i.Project(), i.Dir, i.OldLayout())
}

func (i *Instance) Migrate(prepare func() error) error {
	if !i.OldLayout() || i.State.Ejected != nil {
		return nil
	}
	schema, err := savedSchema(i.StatePath())
	if err != nil {
		return err
	}
	if schema >= generatedSchema {
		i.State.rootLayout = false
		return nil
	}
	if prepare != nil {
		if err := prepare(); err != nil {
			return err
		}
	}
	left, err := copyGenerated(i)
	if err != nil {
		return err
	}
	i.State.rootLayout = false
	i.State.LeftInRoot = left
	if err := i.Save(); err != nil {
		i.State.rootLayout, i.State.LeftInRoot = true, nil
		return err
	}
	return i.DropRootCopies(context.Background(), false)
}

func savedSchema(path string) (int, error) {
	data, err := os.ReadFile(path)
	if err != nil {
		return 0, err
	}
	var head struct {
		Schema int `json:"schema"`
	}
	return head.Schema, json.Unmarshal(data, &head)
}

func copyGenerated(i *Instance) (map[string]string, error) {
	gen := stack.GeneratedPath(i.Dir)
	if err := stack.MakeGenerated(gen); err != nil {
		return nil, err
	}
	if err := i.giveToOwner(gen); err != nil {
		return nil, err
	}
	left := map[string]string{}
	for _, name := range stack.FileNames() {
		src := filepath.Join(i.Dir, name)
		info, err := os.Lstat(src)
		if errors.Is(err, fs.ErrNotExist) {
			continue
		}
		if err != nil {
			return nil, err
		}
		if !info.Mode().IsRegular() {
			continue
		}
		data, err := os.ReadFile(src)
		if err != nil {
			return nil, err
		}
		dst := filepath.Join(gen, name)
		if err := envfile.WriteFileAtomic(dst, data, false); err != nil {
			return nil, err
		}
		if err := i.giveToOwner(dst); err != nil {
			return nil, err
		}
		left[name] = stack.Hash(data)
	}
	return left, nil
}

func (i *Instance) DropRootCopies(ctx context.Context, started bool) error {
	if i.State == nil || i.OldLayout() || i.State.Ejected != nil || len(i.State.LeftInRoot) == 0 {
		return nil
	}
	changed := false
	for name, hash := range i.State.LeftInRoot {
		if !slices.Contains(stack.FileNames(), name) {
			delete(i.State.LeftInRoot, name)
			changed = true
			continue
		}
		_, mounted := stack.MountedFiles[name]
		if mounted && (!started || i.rootMounted(ctx, name)) {
			continue
		}
		data, err := os.ReadFile(i.Path(name))
		switch {
		case errors.Is(err, fs.ErrNotExist):
		case err != nil:
			return err
		case stack.Hash(data) == hash:
			if err := os.Remove(i.Path(name)); err != nil {
				return err
			}
		case mounted:
			continue
		}
		delete(i.State.LeftInRoot, name)
		changed = true
	}
	if !changed {
		return nil
	}
	return i.Save()
}

func (i *Instance) UnusedRootFiles(ctx context.Context) []string {
	if i.State == nil || i.OldLayout() || i.State.Ejected != nil {
		return nil
	}
	var out []string
	for _, name := range slices.Sorted(maps.Keys(i.State.LeftInRoot)) {
		if _, mounted := stack.MountedFiles[name]; !mounted {
			continue
		}
		data, err := os.ReadFile(i.Path(name))
		if err != nil || stack.Hash(data) == i.State.LeftInRoot[name] || i.rootMounted(ctx, name) {
			continue
		}
		out = append(out, name)
	}
	return out
}

func (i *Instance) rootMounted(ctx context.Context, name string) bool {
	compose, err := os.ReadFile(i.Generated(stack.ComposeFile))
	if err != nil || !stack.MountsGenerated(compose, name) {
		return true
	}
	custom := i.Path(CustomCompose)
	if _, err := os.Stat(custom); errors.Is(err, fs.ErrNotExist) {
		return false
	}
	env, err := i.Environment()
	if err != nil {
		return true
	}
	sources, err := engine.BindSources(ctx, engine.Spec{Name: i.Project(), Dir: i.Dir, Files: i.ComposeFiles(), Env: env})
	if err != nil {
		return true
	}
	return slices.Contains(sources, filepath.Clean(i.Path(name)))
}