Skip to content

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

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

package engine

import (
	"context"
	"errors"
	"os"
	"path/filepath"
	"slices"
	"strings"
	"time"

	"github.com/compose-spec/compose-go/v2/types"
	cerrdefs "github.com/containerd/errdefs"
	"github.com/docker/compose/v5/pkg/api"
	"github.com/moby/moby/client"
)

func recreatePolicy(r Recreate) string {
	switch r {
	case RecreateAlways:
		return api.RecreateForce
	case RecreateNever:
		return api.RecreateNever
	}
	return api.RecreateDiverged
}

func (p *Project) Up(ctx context.Context, o UpOptions) error {
	if err := p.needModel("up"); err != nil {
		return err
	}
	if err := p.Engine.refuseTooOld("up"); err != nil {
		return err
	}
	c, err := p.Engine.conn()
	if err != nil {
		return err
	}
	keep := context.WithoutCancel(ctx)
	if err := p.finishStop(keep, c); err != nil {
		return err
	}
	plan, err := p.Plan(keep)
	if err != nil {
		return err
	}
	if err := p.pullMissing(keep, o.OnEvent); err != nil {
		return err
	}
	stop := c.bus.listen(p.Name, o.OnEvent)
	defer stop()
	model := copyModel(p.Model)
	if len(o.Services) == 0 {
		if len(plan.Remove) > 0 {
			if err := p.removeServices(keep, c, plan.Remove); err != nil {
				return err
			}
		}
		if hashless, err := p.hashlessNetworks(keep, plan.Networks); err != nil {
			return err
		} else if len(hashless) > 0 {
			detailf("engine: network %v has no config hash, taking the project down to recreate it", hashless)
			if err := c.svc.Down(keep, p.Name, api.DownOptions{Project: model}); err != nil {
				return p.wrap("up", err)
			}
		}
		for _, key := range plan.LabelOnly {
			n := model.Networks[key]
			n.External = true
			model.Networks[key] = n
		}
	} else {
		var opts []types.DependencyOption
		if o.NoDeps {
			opts = append(opts, types.IgnoreDependencies)
		}
		model, err = model.WithSelectedServices(o.Services, opts...)
		if err != nil {
			return &Error{Op: "up", Class: ClassInvalidConfig, Err: err}
		}
	}
	policy := recreatePolicy(o.Recreate)
	create := api.CreateOptions{
		Recreate:             policy,
		RecreateDependencies: policy,
		RemoveOrphans:        o.RemoveOrphans,
		Inherit:              true,
		QuietPull:            true,
	}
	err = c.svc.Create(keep, model, create)
	if imageGone(err) {
		if err := p.pullMissing(keep, o.OnEvent); err != nil {
			return err
		}
		err = c.svc.Create(keep, model, create)
	}
	if err != nil {
		return p.wrap("up", err)
	}
	return p.wrap("up", c.svc.Start(ctx, p.Name, api.StartOptions{Project: model, Wait: o.Wait, WaitTimeout: o.WaitTimeout}))
}

func (p *Project) hashlessNetworks(ctx context.Context, keys []string) ([]string, error) {
	if len(keys) == 0 {
		return nil, nil
	}
	c, err := p.Engine.api()
	if err != nil {
		return nil, err
	}
	res, err := c.NetworkList(ctx, client.NetworkListOptions{Filters: projectFilter(p.Name)})
	if err != nil {
		return nil, p.wrap("up", err)
	}
	var out []string
	for _, n := range res.Items {
		if slices.Contains(keys, n.Labels[api.NetworkLabel]) && n.Labels[api.ConfigHashLabel] == "" {
			out = append(out, n.Labels[api.NetworkLabel])
		}
	}
	return out, nil
}

func (p *Project) removeServices(ctx context.Context, c *conn, services []string) error {
	err := c.svc.Remove(ctx, p.Name, api.RemoveOptions{Services: services, Stop: true, Force: true})
	if err != nil && !errors.Is(err, api.ErrNoResources) {
		return p.wrap("remove", err)
	}
	return nil
}

func (p *Project) Create(ctx context.Context) error {
	if err := p.needModel("create"); err != nil {
		return err
	}
	if err := p.Engine.refuseTooOld("create"); err != nil {
		return err
	}
	c, err := p.Engine.conn()
	if err != nil {
		return err
	}
	if err := p.pullMissing(ctx, nil); err != nil {
		return err
	}
	opts := api.CreateOptions{
		Recreate:             api.RecreateDiverged,
		RecreateDependencies: api.RecreateDiverged,
		RemoveOrphans:        true,
		Inherit:              true,
		QuietPull:            true,
	}
	err = c.svc.Create(ctx, copyModel(p.Model), opts)
	if imageGone(err) {
		if err := p.pullMissing(ctx, nil); err != nil {
			return err
		}
		err = c.svc.Create(ctx, copyModel(p.Model), opts)
	}
	return p.wrap("create", err)
}

func (p *Project) StartWatched(ctx context.Context, onEvent func(Event), services ...string) error {
	c, err := p.Engine.conn()
	if err != nil {
		return err
	}
	stop := c.bus.listen(p.Name, onEvent)
	defer stop()
	return p.Start(ctx, services...)
}

func (p *Project) Start(ctx context.Context, services ...string) error {
	c, err := p.Engine.conn()
	if err != nil {
		return err
	}
	if err := p.finishStop(ctx, c); err != nil {
		return err
	}
	if p.Model == nil && len(services) > 0 {
		return p.startNamed(ctx, c, services)
	}
	var model *types.Project
	if p.Model != nil {
		model = copyModel(p.Model)
		if len(services) > 0 {
			if model, err = model.WithSelectedServices(services); err != nil {
				return &Error{Op: "start", Class: ClassInvalidConfig, Err: err}
			}
		}
	}
	return p.wrap("start", c.svc.Start(ctx, p.Name, api.StartOptions{Project: model}))
}

func (p *Project) startNamed(ctx context.Context, c *conn, services []string) error {
	containers, err := p.PS(ctx)
	if err != nil {
		return err
	}
	if composeCanStart(containers, services) {
		return p.wrap("start", c.svc.Start(ctx, p.Name, api.StartOptions{AttachTo: services}))
	}
	cli := c.cli.Client()
	for _, ct := range containers {
		if !slices.Contains(services, ct.Service) || ct.State == "running" {
			continue
		}
		if _, err := cli.ContainerStart(ctx, ct.ID, client.ContainerStartOptions{}); err != nil {
			return p.wrap("start", err)
		}
	}
	return nil
}

func composeCanStart(containers []Container, services []string) bool {
	byService := make(map[string]Container, len(containers))
	for _, ct := range containers {
		byService[ct.Service] = ct
	}
	pending := slices.Clone(services)
	seen := map[string]bool{}
	for len(pending) > 0 {
		name := pending[len(pending)-1]
		pending = pending[:len(pending)-1]
		if seen[name] {
			continue
		}
		seen[name] = true
		ct, ok := byService[name]
		if !ok || ct.Labels[api.ConfigHashLabel] == "" {
			return false
		}
		for dep := range strings.SplitSeq(ct.Labels[api.DependenciesLabel], ",") {
			if dep, _, _ = strings.Cut(dep, ":"); dep != "" {
				pending = append(pending, dep)
			}
		}
	}
	return true
}

func (p *Project) present(ctx context.Context, op string, services []string) error {
	containers, err := p.PS(ctx)
	if err != nil {
		return err
	}
	for _, c := range containers {
		if len(services) == 0 || slices.Contains(services, c.Service) {
			return nil
		}
	}
	return &Error{Op: op, Class: ClassOther, Err: ErrNoContainers}
}

func (p *Project) Stop(ctx context.Context, services ...string) error {
	return p.stop(ctx, nil, services)
}

func (p *Project) StopWithin(ctx context.Context, timeout time.Duration) error {
	return p.stop(ctx, &timeout, nil)
}

func (p *Project) stop(ctx context.Context, timeout *time.Duration, services []string) error {
	c, err := p.Engine.conn()
	if err != nil {
		return err
	}
	if err := p.present(ctx, "stop", services); errors.Is(err, ErrNoContainers) {
		return nil
	} else if err != nil {
		return err
	}
	if marker := p.stopMarker(); marker != "" && p.writeStopMarker(services) == nil {
		defer os.Remove(marker)
	}
	if err := c.svc.Stop(ctx, p.Name, api.StopOptions{Project: p.modelOrNil(), Services: services, Timeout: timeout}); err != nil {
		return p.wrap("stop", err)
	}
	return p.stopPodmanCompose(ctx, services)
}

const staleStopMarker = 5 * time.Minute

func (p *Project) stopMarker() string {
	if p.Dir == "" {
		return ""
	}
	dir := filepath.Join(p.Dir, ".rexctl")
	if info, err := os.Stat(dir); err != nil || !info.IsDir() {
		return ""
	}
	return filepath.Join(dir, "stopping")
}

func (p *Project) writeStopMarker(services []string) error {
	root, err := os.OpenRoot(p.Dir)
	if err != nil {
		return err
	}
	defer root.Close()
	f, err := root.OpenFile(filepath.Join(".rexctl", "stopping"), os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0o600)
	if err != nil {
		return err
	}
	_, err = f.WriteString(strings.Join(services, "\n"))
	if cerr := f.Close(); err == nil {
		err = cerr
	}
	return err
}

func (p *Project) finishStop(ctx context.Context, c *conn) error {
	marker := p.stopMarker()
	if marker == "" {
		return nil
	}
	info, err := os.Stat(marker)
	if err != nil {
		return nil
	}
	if time.Since(info.ModTime()) < staleStopMarker {
		data, err := os.ReadFile(marker)
		if err != nil {
			return nil
		}
		services := strings.Fields(string(data))
		detailf("engine: an earlier stop of %v was interrupted, finishing it", services)
		if err := p.present(ctx, "stop", services); errors.Is(err, ErrNoContainers) {
			_ = os.Remove(marker)
			return nil
		} else if err != nil {
			return err
		}
		if err := c.svc.Stop(ctx, p.Name, api.StopOptions{Project: p.modelOrNil(), Services: services}); err != nil {
			return p.wrap("stop", err)
		}
	}
	_ = os.Remove(marker)
	return nil
}

func (p *Project) Restart(ctx context.Context, services ...string) error {
	return p.RestartWatched(ctx, nil, services...)
}

func (p *Project) RestartWatched(ctx context.Context, onEvent func(Event), services ...string) error {
	if err := p.Engine.refuseTooOld("restart"); err != nil {
		return err
	}
	c, err := p.Engine.conn()
	if err != nil {
		return err
	}
	if err := p.present(ctx, "restart", services); err != nil {
		return err
	}
	stop := c.bus.listen(p.Name, onEvent)
	defer stop()
	return p.wrap("restart", c.svc.Restart(ctx, p.Name, api.RestartOptions{Project: p.modelOrNil(), Services: services}))
}

func (p *Project) Remove(ctx context.Context, services ...string) error {
	c, err := p.Engine.conn()
	if err != nil {
		return err
	}
	return p.removeServices(ctx, c, services)
}

func (p *Project) Down(ctx context.Context, volumes bool) error {
	return p.down(ctx, volumes, nil)
}

func (p *Project) DownWithin(ctx context.Context, volumes bool, timeout time.Duration) error {
	return p.down(ctx, volumes, &timeout)
}

func (p *Project) down(ctx context.Context, volumes bool, timeout *time.Duration) error {
	c, err := p.Engine.conn()
	if err != nil {
		return err
	}
	a, err := p.Engine.api()
	if err != nil {
		return err
	}
	if err := p.removeHelpers(ctx, a); err != nil {
		return err
	}
	return p.wrap("down", c.svc.Down(ctx, p.Name, api.DownOptions{Project: p.modelOrNil(), RemoveOrphans: true, Volumes: volumes, Timeout: timeout}))
}

func (p *Project) DownKeeping(ctx context.Context, keep ...string) error {
	if err := p.Down(ctx, false); err != nil {
		return err
	}
	vols, err := p.Engine.Volumes(ctx, p.Name)
	if err != nil {
		return err
	}
	a, err := p.Engine.api()
	if err != nil {
		return err
	}
	for _, name := range volumesToDrop(p.Model, vols, p.Name, keep) {
		if _, err := a.VolumeRemove(ctx, name, client.VolumeRemoveOptions{}); err != nil && !cerrdefs.IsNotFound(err) {
			return p.wrap("down", err)
		}
	}
	return nil
}

func volumesToDrop(model *types.Project, vols []Volume, project string, keep []string) []string {
	var kept, out []string
	if model != nil {
		for short, v := range model.Volumes {
			if slices.Contains(keep, short) {
				kept = append(kept, v.Name)
			}
		}
		for short, v := range model.Volumes {
			if !bool(v.External) && v.Name != "" && !slices.Contains(keep, short) && !slices.Contains(kept, v.Name) {
				out = append(out, v.Name)
			}
		}
	}
	for _, v := range vols {
		if v.Project != project || slices.Contains(kept, v.Name) {
			continue
		}
		short := v.Labels[api.VolumeLabel]
		if short == "" {
			short = strings.TrimPrefix(v.Name, project+"_")
		}
		if !slices.Contains(keep, short) {
			out = append(out, v.Name)
		}
	}
	slices.Sort(out)
	return slices.Compact(out)
}

func (p *Project) modelOrNil() *types.Project {
	if p.Model == nil {
		return nil
	}
	return copyModel(p.Model)
}

func imageGone(err error) bool {
	return err != nil && strings.Contains(err.Error(), "No such image")
}

func (p *Project) wrap(op string, err error) error {
	if err == nil {
		return nil
	}
	var e *Error
	if errors.As(err, &e) {
		return err
	}
	if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
		return err
	}
	return &Error{Op: op, Class: ClassOf(err), Err: err}
}

func (e *Engine) EnsureNetwork(ctx context.Context, name, project, key string, ipv6 bool) error {
	c, err := e.api()
	if err != nil {
		return err
	}
	if _, err := c.NetworkInspect(ctx, name, client.NetworkInspectOptions{}); err == nil {
		return nil
	} else if !cerrdefs.IsNotFound(err) {
		return err
	}
	opts := client.NetworkCreateOptions{
		Driver: "bridge",
		Labels: map[string]string{api.ProjectLabel: project, api.NetworkLabel: key},
	}
	if ipv6 {
		opts.EnableIPv6 = &ipv6
	}
	_, err = c.NetworkCreate(ctx, name, opts)
	if cerrdefs.IsConflict(err) {
		return nil
	}
	return err
}

func (e *Engine) NetworkIPv6(ctx context.Context, name string) (bool, bool, error) {
	c, err := e.api()
	if err != nil {
		return false, false, err
	}
	res, err := c.NetworkInspect(ctx, name, client.NetworkInspectOptions{})
	if cerrdefs.IsNotFound(err) {
		return false, false, nil
	}
	if err != nil {
		return false, false, err
	}
	return true, res.Network.EnableIPv6, nil
}

func (e *Engine) IPv6Voice() bool {
	return e.Kind == Docker && !e.Rootless && AtLeast(e.Version, MinDockerIPv6)
}