A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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)+}