Skip to content

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

TypeScript fluxerfluxerapp

feat(rexctl): load compose projects and plan container changes

Hampusc76f2837ad4e
diff --git a/fluxer_rexctl/internal/engine/api.go b/fluxer_rexctl/internal/engine/api.go
new file mode 100644
index 000000000..d194bf040
--- /dev/null
+++ b/fluxer_rexctl/internal/engine/api.go
@@ -0,0 +1,223 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+package engine
+
+import (
+ "io"
+ "strings"
+ "time"
+
+ "github.com/compose-spec/compose-go/v2/types"
+)
+
+type Kind string
+
+const (
+ Docker Kind = "docker"
+ Podman Kind = "podman"
+)
+
+const (
+ MinPodman = "5.4.0"
+ MinDocker = "24.0.0"
+)
+
+const DefaultReadyTimeout = 10 * time.Minute
+
+type Engine struct {
+ Kind Kind
+ Host string
+ ID string
+ Name string
+ Version string
+ APIVersion string
+ OSType string
+ Rootless bool
+ Desktop string
+ TooOld bool
+}
+
+type ConnectOptions struct {
+ Host string
+ ID string
+ Prefer Kind
+ AllowOld bool
+}
+
+type Proxies struct {
+ HTTP, HTTPS, No string
+}
+
+type Spec struct {
+ Name string
+ Dir string
+ Files []string
+ Env map[string]string
+}
+
+type Project struct {
+ Engine *Engine
+ Name string
+ Dir string
+ Model *types.Project
+}
+
+type Plan struct {
+ Create []string
+ Recreate []string
+ Remove []string
+ Networks []string
+ LabelOnly []string
+ Volumes []string
+}
+
+type UpOptions struct {
+ Services []string
+ NoDeps bool
+ Recreate Recreate
+ RemoveOrphans bool
+ Wait bool
+ WaitTimeout time.Duration
+ OnEvent func(Event)
+}
+
+type Recreate int
+
+const (
+ RecreateChanged Recreate = iota
+ RecreateAlways
+ RecreateNever
+)
+
+type ExecOptions struct {
+ User string
+ Env []string
+ Stdin io.Reader
+ Stdout io.Writer
+ Stderr io.Writer
+ KillOnCancel bool
+}
+
+type HelperOptions struct {
+ Image string
+ Entrypoint []string
+ Command []string
+ Mounts []Mount
+ Stdin io.Reader
+ Stdout io.Writer
+ Stderr io.Writer
+}
+
+type Mount struct {
+ Volume string
+ Target string
+ ReadOnly bool
+}
+
+type EventStatus string
+
+const (
+ EventWorking EventStatus = "working"
+ EventDone EventStatus = "done"
+ EventWarning EventStatus = "warning"
+ EventError EventStatus = "error"
+)
+
+type Event struct {
+ ID string
+ Parent string
+ Kind string
+ Service string
+ Text string
+ Status EventStatus
+ Current int64
+ Total int64
+}
+
+type Container struct {
+ ID, Name, Service, State, Health, Image, ImageID string
+ Number, ExitCode, RestartCount int
+ Labels map[string]string
+ Created time.Time
+}
+
+type Volume struct {
+ Name string
+ Project string
+ Labels map[string]string
+}
+
+type ProjectInfo struct {
+ Name string
+ Status string
+ ConfigFiles string
+}
+
+type Readiness struct {
+ Ready []string
+ NotReady []string
+ Failed []string
+}
+
+type NotReadyError struct {
+ Readiness Readiness
+ Fatal bool
+ Crashing []string
+}
+
+func (e *NotReadyError) Error() string {
+ parts := append(append([]string{}, e.Readiness.Failed...), e.Readiness.NotReady...)
+ return "engine: not ready: " + strings.Join(parts, ", ")
+}
+
+type LogsOptions struct {
+ Follow bool
+ Since string
+ Tail int
+ Stdout io.Writer
+}
+
+type Error struct {
+ Op string
+ Class Class
+ Images []string
+ Other string
+ Replaced bool
+ Err error
+}
+
+func (e *Error) Error() string {
+ if e.Err == nil {
+ return "engine: " + e.Op
+ }
+ return "engine: " + e.Op + ": " + e.Err.Error()
+}
+
+func (e *Error) Unwrap() error { return e.Err }
+
+type Class int
+
+const (
+ ClassOther Class = iota
+ ClassUnreachable
+ ClassDenied
+ ClassWindowsContainers
+ ClassPodmanTooOld
+ ClassEngineChanged
+ ClassRateLimit
+ ClassCredentials
+ ClassAuth
+ ClassImageNotFound
+ ClassDNS
+ ClassTLS
+ ClassProxy
+ ClassTimeout
+ ClassDiskFull
+ ClassPortInUse
+ ClassAddressPools
+ ClassSubIDs
+ ClassDependencyFailed
+ ClassVolumeChanged
+ ClassInvalidConfig
+ ClassForeignProject
+)
diff --git a/fluxer_rexctl/internal/engine/load.go b/fluxer_rexctl/internal/engine/load.go
new file mode 100644
index 000000000..be1406e7e
--- /dev/null
+++ b/fluxer_rexctl/internal/engine/load.go
@@ -0,0 +1,199 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+package engine
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "maps"
+ "os"
+ "path/filepath"
+ "slices"
+ "sort"
+ "strings"
+
+ "github.com/compose-spec/compose-go/v2/cli"
+ "github.com/compose-spec/compose-go/v2/template"
+ "github.com/compose-spec/compose-go/v2/types"
+ "github.com/docker/compose/v5/pkg/api"
+ "github.com/docker/compose/v5/pkg/compose"
+ "go.yaml.in/yaml/v4"
+)
+
+func (e *Engine) Named(name, dir string) *Project {
+ return &Project{Engine: e, Name: name, Dir: dir}
+}
+
+func (e *Engine) Load(ctx context.Context, s Spec) (*Project, error) {
+ files := make([]string, 0, len(s.Files))
+ for _, f := range s.Files {
+ if !filepath.IsAbs(f) {
+ f = filepath.Join(s.Dir, f)
+ }
+ files = append(files, f)
+ }
+ for _, f := range files {
+ if err := refuseUnsupported(f); err != nil {
+ return nil, err
+ }
+ }
+ env := make([]string, 0, len(s.Env))
+ for k, v := range s.Env {
+ env = append(env, k+"="+v)
+ }
+ sort.Strings(env)
+ opts, err := cli.NewProjectOptions(files,
+ cli.WithWorkingDirectory(s.Dir),
+ cli.WithEnv(env),
+ cli.WithName(s.Name),
+ cli.WithDefaultProfiles(),
+ )
+ if err != nil {
+ return nil, &Error{Op: "load", Class: ClassInvalidConfig, Err: err}
+ }
+ model, err := opts.LoadProject(ctx)
+ if err != nil {
+ return nil, loadError(err)
+ }
+ for name, svc := range model.Services {
+ if svc.Build != nil {
+ return nil, &Error{Op: "load", Class: ClassInvalidConfig, Err: fmt.Errorf("service %s has a build section, which rexctl can't run", name)}
+ }
+ if len(svc.EnvFiles) > 0 {
+ return nil, &Error{Op: "load", Class: ClassInvalidConfig, Err: fmt.Errorf("service %s reads an env_file, which rexctl doesn't support", name)}
+ }
+ svc.CustomLabels = map[string]string{
+ api.ProjectLabel: model.Name,
+ api.ServiceLabel: name,
+ api.VersionLabel: api.ComposeVersion,
+ api.WorkingDirLabel: model.WorkingDir,
+ api.ConfigFilesLabel: strings.Join(model.ComposeFiles, ","),
+ api.OneoffLabel: "False",
+ }
+ model.Services[name] = svc
+ }
+ model = model.WithoutUnnecessaryResources()
+ return &Project{Engine: e, Name: model.Name, Dir: s.Dir, Model: model}, nil
+}
+
+func loadError(err error) error {
+ var missing *template.MissingRequiredError
+ if errors.As(err, &missing) {
+ detailf("engine: required variable %s is missing", missing.Variable)
+ return &Error{Op: "load", Class: ClassInvalidConfig, Err: errors.New("a setting Fluxer needs is missing")}
+ }
+ return &Error{Op: "load", Class: ClassInvalidConfig, Err: err}
+}
+
+type rawFile struct {
+ Include any `yaml:"include"`
+ Services map[string]struct {
+ Build any `yaml:"build"`
+ EnvFile any `yaml:"env_file"`
+ Extends any `yaml:"extends"`
+ } `yaml:"services"`
+}
+
+func refuseUnsupported(path string) error {
+ data, err := os.ReadFile(path)
+ if err != nil {
+ return &Error{Op: "load", Class: ClassInvalidConfig, Err: err}
+ }
+ var raw rawFile
+ if err := yaml.Unmarshal(data, &raw); err != nil {
+ return &Error{Op: "load", Class: ClassInvalidConfig, Err: fmt.Errorf("%s: %w", filepath.Base(path), err)}
+ }
+ name := filepath.Base(path)
+ if raw.Include != nil {
+ return &Error{Op: "load", Class: ClassInvalidConfig, Err: fmt.Errorf("%s uses include, which rexctl doesn't support", name)}
+ }
+ for svc, s := range raw.Services {
+ switch {
+ case s.Build != nil:
+ return &Error{Op: "load", Class: ClassInvalidConfig, Err: fmt.Errorf("%s: service %s has a build section, which rexctl can't run", name, svc)}
+ case s.EnvFile != nil:
+ return &Error{Op: "load", Class: ClassInvalidConfig, Err: fmt.Errorf("%s: service %s reads an env_file, which rexctl doesn't support", name, svc)}
+ case extendsFile(s.Extends):
+ return &Error{Op: "load", Class: ClassInvalidConfig, Err: fmt.Errorf("%s: service %s extends another file, which rexctl doesn't support", name, svc)}
+ }
+ }
+ return nil
+}
+
+func extendsFile(v any) bool {
+ m, ok := v.(map[string]any)
+ if !ok {
+ return false
+ }
+ f, ok := m["file"]
+ return ok && f != nil && f != ""
+}
+
+func (p *Project) needModel(op string) error {
+ if p.Model == nil {
+ return &Error{Op: op, Class: ClassInvalidConfig, Err: errors.New("the project was opened by name only")}
+ }
+ return nil
+}
+
+func (p *Project) Services() []string {
+ if p.Model == nil {
+ return nil
+ }
+ names := p.Model.ServiceNames()
+ slices.Sort(names)
+ return names
+}
+
+func (p *Project) Images() []string {
+ if p.Model == nil {
+ return nil
+ }
+ seen := map[string]bool{}
+ var out []string
+ for _, name := range p.Services() {
+ img := p.Model.Services[name].Image
+ if img != "" && !seen[img] {
+ seen[img] = true
+ out = append(out, img)
+ }
+ }
+ return out
+}
+
+func (p *Project) Image(service string) string {
+ if p.Model == nil {
+ return ""
+ }
+ return p.Model.Services[service].Image
+}
+
+func (p *Project) Hashes() (map[string]string, error) {
+ if err := p.needModel("hash"); err != nil {
+ return nil, err
+ }
+ out := make(map[string]string, len(p.Model.Services))
+ for name, svc := range p.Model.Services {
+ h, err := compose.ServiceHash(svc)
+ if err != nil {
+ return nil, &Error{Op: "hash", Class: ClassInvalidConfig, Err: err}
+ }
+ out[name] = h
+ }
+ return out, nil
+}
+
+func copyModel(m *types.Project) *types.Project {
+ c := *m
+ c.Services = make(types.Services, len(m.Services))
+ for k, v := range m.Services {
+ v.CustomLabels = maps.Clone(v.CustomLabels)
+ c.Services[k] = v
+ }
+ c.Networks = make(types.Networks, len(m.Networks))
+ for k, v := range m.Networks {
+ c.Networks[k] = v
+ }
+ return &c
+}
diff --git a/fluxer_rexctl/internal/engine/plan.go b/fluxer_rexctl/internal/engine/plan.go
new file mode 100644
index 000000000..a696da042
--- /dev/null
+++ b/fluxer_rexctl/internal/engine/plan.go
@@ -0,0 +1,196 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+package engine
+
+import (
+ "context"
+ "fmt"
+ "maps"
+ "slices"
+ "strings"
+
+ "github.com/compose-spec/compose-go/v2/types"
+ "github.com/docker/compose/v5/pkg/api"
+ "github.com/docker/compose/v5/pkg/compose"
+ "github.com/moby/moby/api/types/network"
+ "github.com/moby/moby/client"
+)
+
+func (p *Project) Plan(ctx context.Context) (*Plan, error) {
+ if err := p.needModel("plan"); err != nil {
+ return nil, err
+ }
+ if err := p.Engine.refuseTooOld("plan"); err != nil {
+ return nil, err
+ }
+ containers, err := p.PS(ctx)
+ if err != nil {
+ return nil, err
+ }
+ plan := &Plan{Create: []string{}, Recreate: []string{}, Remove: []string{}, Networks: []string{}, LabelOnly: []string{}, Volumes: []string{}}
+ byService := map[string][]Container{}
+ for _, c := range containers {
+ byService[c.Service] = append(byService[c.Service], c)
+ }
+ images := map[string]string{}
+ for _, name := range p.Services() {
+ svc := p.Model.Services[name]
+ cs := byService[name]
+ if len(cs) == 0 {
+ plan.Create = append(plan.Create, name)
+ continue
+ }
+ want, err := compose.ServiceHash(svc)
+ if err != nil {
+ return nil, &Error{Op: "plan", Class: ClassInvalidConfig, Err: err}
+ }
+ id, ok := images[svc.Image]
+ if !ok {
+ found := false
+ id, found, err = p.Engine.LocalImage(ctx, svc.Image)
+ if err != nil {
+ return nil, err
+ }
+ if !found {
+ id = ""
+ }
+ images[svc.Image] = id
+ }
+ for _, c := range cs {
+ if c.Labels[api.ConfigHashLabel] != want || id == "" || c.ImageID != id {
+ plan.Recreate = append(plan.Recreate, name)
+ break
+ }
+ }
+ }
+ for service := range byService {
+ if _, ok := p.Model.Services[service]; !ok {
+ plan.Remove = append(plan.Remove, service)
+ }
+ }
+ slices.Sort(plan.Remove)
+ if err := p.planNetworks(ctx, plan); err != nil {
+ return nil, err
+ }
+ if err := p.planVolumes(ctx, plan); err != nil {
+ return nil, err
+ }
+ if len(plan.Volumes) > 0 {
+ return plan, &Error{Op: "plan", Class: ClassVolumeChanged, Err: fmt.Errorf("volume %s has another driver or other options than the compose file asks for", strings.Join(plan.Volumes, ", "))}
+ }
+ return plan, nil
+}
+
+func (p *Project) planNetworks(ctx context.Context, plan *Plan) error {
+ c, err := p.Engine.api()
+ if err != nil {
+ return err
+ }
+ res, err := c.NetworkList(ctx, client.NetworkListOptions{Filters: projectFilter(p.Name)})
+ if err != nil {
+ return &Error{Op: "plan", Class: ClassOf(err), Err: err}
+ }
+ for _, key := range slices.Sorted(maps.Keys(p.Model.Networks)) {
+ want := p.Model.Networks[key]
+ if want.External {
+ continue
+ }
+ var live *network.Summary
+ for i, n := range res.Items {
+ if n.Labels[api.NetworkLabel] == key || n.Name == want.Name {
+ live = &res.Items[i]
+ break
+ }
+ }
+ if live == nil {
+ continue
+ }
+ in, err := c.NetworkInspect(ctx, live.ID, client.NetworkInspectOptions{})
+ if err != nil {
+ return &Error{Op: "plan", Class: ClassOf(err), Err: err}
+ }
+ if !sameNetwork(want, in.Network.Network) {
+ plan.Networks = append(plan.Networks, key)
+ continue
+ }
+ hash, err := compose.NetworkHash(&want)
+ if err != nil {
+ return &Error{Op: "plan", Class: ClassInvalidConfig, Err: err}
+ }
+ if live.Labels[api.ConfigHashLabel] != hash {
+ plan.LabelOnly = append(plan.LabelOnly, key)
+ }
+ }
+ return nil
+}
+
+func sameNetwork(want types.NetworkConfig, live network.Network) bool {
+ driver := want.Driver
+ if driver == "" {
+ driver = "bridge"
+ }
+ if driver != live.Driver {
+ return false
+ }
+ if (want.EnableIPv6 != nil && *want.EnableIPv6) != live.EnableIPv6 {
+ return false
+ }
+ if want.Internal != live.Internal {
+ return false
+ }
+ var wantSubnets, liveSubnets []string
+ for _, pool := range want.Ipam.Config {
+ if pool != nil && pool.Subnet != "" {
+ wantSubnets = append(wantSubnets, pool.Subnet)
+ }
+ }
+ if len(wantSubnets) == 0 {
+ return true
+ }
+ for _, cfg := range live.IPAM.Config {
+ if cfg.Subnet.IsValid() {
+ liveSubnets = append(liveSubnets, cfg.Subnet.String())
+ }
+ }
+ slices.Sort(wantSubnets)
+ slices.Sort(liveSubnets)
+ return slices.Equal(wantSubnets, liveSubnets)
+}
+
+func (p *Project) planVolumes(ctx context.Context, plan *Plan) error {
+ c, err := p.Engine.api()
+ if err != nil {
+ return err
+ }
+ res, err := c.VolumeList(ctx, client.VolumeListOptions{Filters: projectFilter(p.Name)})
+ if err != nil {
+ return &Error{Op: "plan", Class: ClassOf(err), Err: err}
+ }
+ for _, key := range slices.Sorted(maps.Keys(p.Model.Volumes)) {
+ want := p.Model.Volumes[key]
+ if want.External {
+ continue
+ }
+ for _, v := range res.Items {
+ if v.Labels[api.VolumeLabel] != key && v.Name != want.Name {
+ continue
+ }
+ driver := want.Driver
+ if driver == "" {
+ driver = "local"
+ }
+ if driver != v.Driver || !sameOptions(want.DriverOpts, v.Options) {
+ plan.Volumes = append(plan.Volumes, key)
+ }
+ break
+ }
+ }
+ return nil
+}
+
+func sameOptions(want map[string]string, live map[string]string) bool {
+ if len(want) == 0 && len(live) == 0 {
+ return true
+ }
+ return maps.Equal(want, live)
+}
diff --git a/fluxer_rexctl/internal/engine/pods.go b/fluxer_rexctl/internal/engine/pods.go
new file mode 100644
index 000000000..3d7e0223a
--- /dev/null
+++ b/fluxer_rexctl/internal/engine/pods.go
@@ -0,0 +1,156 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+package engine
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+ "io"
+ "net"
+ "net/http"
+ "net/url"
+ "slices"
+ "strings"
+
+ cerrdefs "github.com/containerd/errdefs"
+ "github.com/docker/compose/v5/pkg/api"
+ "github.com/moby/moby/client"
+)
+
+const PodmanComposeLabel = "io.podman.compose.project"
+
+func (p *Project) podmanCompose(ctx context.Context, services []string) ([]Container, error) {
+ if p.Engine.Kind != Podman {
+ return nil, nil
+ }
+ all, err := p.PS(ctx)
+ if err != nil {
+ return nil, err
+ }
+ var out []Container
+ for _, c := range all {
+ if c.Labels[PodmanComposeLabel] != "" && (len(services) == 0 || slices.Contains(services, c.Service)) {
+ out = append(out, c)
+ }
+ }
+ return out, nil
+}
+
+func (p *Project) stopPodmanCompose(ctx context.Context, services []string) error {
+ cs, err := p.podmanCompose(ctx, services)
+ if err != nil || len(cs) == 0 {
+ return err
+ }
+ c, err := p.Engine.api()
+ if err != nil {
+ return err
+ }
+ for _, ct := range cs {
+ if ct.State != "running" {
+ continue
+ }
+ if _, err := c.ContainerStop(ctx, ct.ID, client.ContainerStopOptions{}); err != nil && !cerrdefs.IsNotFound(err) {
+ return &Error{Op: "stop", Class: ClassOf(err), Err: err}
+ }
+ }
+ return nil
+}
+
+func (p *Project) RemovePodmanCompose(ctx context.Context) error {
+ cs, err := p.podmanCompose(ctx, nil)
+ if err != nil || len(cs) == 0 {
+ return err
+ }
+ c, err := p.Engine.api()
+ if err != nil {
+ return err
+ }
+ dial := c.Dialer()
+ hc := &http.Client{Transport: &http.Transport{
+ DialContext: func(ctx context.Context, _, _ string) (net.Conn, error) { return dial(ctx) },
+ }}
+ var pods []string
+ for _, ct := range cs {
+ var in struct {
+ Pod string `json:"Pod"`
+ }
+ if err := libpod(ctx, hc, http.MethodGet, "/libpod/containers/"+url.PathEscape(ct.ID)+"/json", &in); err != nil {
+ return &Error{Op: "down", Class: ClassOf(err), Err: err}
+ }
+ if in.Pod != "" && !slices.Contains(pods, in.Pod) {
+ pods = append(pods, in.Pod)
+ }
+ }
+ for _, pod := range pods {
+ if err := libpod(ctx, hc, http.MethodDelete, "/libpod/pods/"+url.PathEscape(pod)+"?force=true", nil); err != nil {
+ return &Error{Op: "down", Class: ClassOf(err), Err: err}
+ }
+ }
+ for _, ct := range cs {
+ if _, err := c.ContainerRemove(ctx, ct.ID, client.ContainerRemoveOptions{Force: true}); err != nil && !cerrdefs.IsNotFound(err) {
+ return &Error{Op: "down", Class: ClassOf(err), Err: err}
+ }
+ }
+ return nil
+}
+
+func (p *Project) RemoveReplacements(ctx context.Context) error {
+ c, err := p.Engine.api()
+ if err != nil {
+ return err
+ }
+ f := projectFilter(p.Name).Add("label", api.ContainerReplaceLabel).Add("status", "created")
+ res, err := c.ContainerList(ctx, client.ContainerListOptions{All: true, Filters: f})
+ if err != nil {
+ return &Error{Op: "ps", Class: ClassOf(err), Err: err}
+ }
+ for _, ct := range res.Items {
+ if len(ct.Names) == 0 || !isReplacementName(ct.Names[0]) {
+ continue
+ }
+ if _, err := c.ContainerRemove(ctx, ct.ID, client.ContainerRemoveOptions{Force: true}); err != nil && !cerrdefs.IsNotFound(err) {
+ return &Error{Op: "rm", Class: ClassOf(err), Err: err}
+ }
+ }
+ return nil
+}
+
+func isReplacementName(name string) bool {
+ prefix, _, ok := strings.Cut(strings.TrimPrefix(name, "/"), "_")
+ if !ok || len(prefix) != 12 {
+ return false
+ }
+ for _, r := range prefix {
+ if !strings.ContainsRune("0123456789abcdef", r) {
+ return false
+ }
+ }
+ return true
+}
+
+func libpod(ctx context.Context, hc *http.Client, method, path string, out any) error {
+ req, err := http.NewRequestWithContext(ctx, method, "http://d"+path, nil)
+ if err != nil {
+ return err
+ }
+ res, err := hc.Do(req)
+ if err != nil {
+ return err
+ }
+ defer res.Body.Close()
+ body, err := io.ReadAll(io.LimitReader(res.Body, 4<<20))
+ if err != nil {
+ return err
+ }
+ if res.StatusCode == http.StatusNotFound && method == http.MethodDelete {
+ return nil
+ }
+ if res.StatusCode >= 300 {
+ return fmt.Errorf("podman %s %s: %s: %s", method, path, res.Status, body)
+ }
+ if out == nil {
+ return nil
+ }
+ return json.Unmarshal(body, out)
+}