A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
feat(rexctl): run compose commands and stream engine events
Hampuse09b334bf938
diff --git a/fluxer_rexctl/internal/engine/events.go b/fluxer_rexctl/internal/engine/events.gonew file mode 100644index 000000000..819637a70--- /dev/null+++ b/fluxer_rexctl/internal/engine/events.go@@ -0,0 +1,107 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++package engine++import (+ "context"+ "strings"+ "sync"++ "github.com/docker/compose/v5/pkg/api"+)++type bus struct {+ mu sync.Mutex+ project string+ onEvent func(Event)+ last map[string]Event+}++func (b *bus) listen(project string, onEvent func(Event)) func() {+ b.mu.Lock()+ b.project = project+ b.onEvent = onEvent+ b.last = map[string]Event{}+ b.mu.Unlock()+ return func() {+ b.mu.Lock()+ b.onEvent = nil+ b.last = nil+ b.mu.Unlock()+ }+}++func (b *bus) Start(context.Context, string) {}++func (b *bus) Done(string, bool) {}++func (b *bus) On(events ...api.Resource) {+ b.mu.Lock()+ defer b.mu.Unlock()+ for _, r := range events {+ ev := toEvent(b.project, r)+ if b.onEvent == nil {+ continue+ }+ if prev, ok := b.last[ev.ID]; ok && prev == ev {+ continue+ }+ b.last[ev.ID] = ev+ b.onEvent(ev)+ }+}++func toEvent(project string, r api.Resource) Event {+ kind, name, _ := strings.Cut(r.ID, " ")+ ev := Event{+ ID: r.ID,+ Parent: r.ParentID,+ Kind: strings.ToLower(kind),+ Text: r.Text,+ Status: eventStatus(r.Status),+ Current: r.Current,+ Total: r.Total,+ }+ if r.Status == api.Error && r.Details != "" {+ ev.Text = r.Details+ }+ if ev.Kind == "container" {+ ev.Service = serviceOf(project, name)+ }+ return ev+}++func serviceOf(project, container string) string {+ s := strings.TrimPrefix(container, "/")+ if project != "" {+ s = strings.TrimPrefix(s, project+"-")+ }+ if i := strings.LastIndexByte(s, '-'); i > 0 && isDigits(s[i+1:]) {+ s = s[:i]+ }+ return s+}++func isDigits(s string) bool {+ if s == "" {+ return false+ }+ for _, r := range s {+ if r < '0' || r > '9' {+ return false+ }+ }+ return true+}++func eventStatus(s api.EventStatus) EventStatus {+ switch s {+ case api.Done:+ return EventDone+ case api.Warning:+ return EventWarning+ case api.Error:+ return EventError+ }+ return EventWorking+}diff --git a/fluxer_rexctl/internal/engine/exec.go b/fluxer_rexctl/internal/engine/exec.gonew file mode 100644index 000000000..00ff03ddf--- /dev/null+++ b/fluxer_rexctl/internal/engine/exec.go@@ -0,0 +1,424 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++package engine++import (+ "context"+ "crypto/rand"+ "encoding/hex"+ "errors"+ "fmt"+ "io"+ "strings"+ "sync"+ "sync/atomic"+ "time"++ cerrdefs "github.com/containerd/errdefs"+ "github.com/docker/compose/v5/pkg/api"+ "github.com/moby/moby/api/pkg/stdcopy"+ "github.com/moby/moby/api/types/container"+ "github.com/moby/moby/api/types/mount"+ "github.com/moby/moby/client"+)++const killGrace = 10 * time.Second++type ExitError struct {+ Code int+ Stderr string+}++func (e *ExitError) Error() string {+ if line := lastLine(e.Stderr); line != "" {+ return fmt.Sprintf("exit status %d: %s", e.Code, line)+ }+ return fmt.Sprintf("exit status %d", e.Code)+}++func lastLine(s string) string {+ lines := strings.Split(strings.TrimSpace(s), "\n")+ return strings.TrimSpace(lines[len(lines)-1])+}++const stderrTail = 64 << 10++type tailBuffer struct{ buf []byte }++func (t *tailBuffer) Write(p []byte) (int, error) {+ t.buf = append(t.buf, p...)+ if len(t.buf) > stderrTail {+ t.buf = t.buf[len(t.buf)-stderrTail:]+ }+ return len(p), nil+}++func (t *tailBuffer) String() string { return string(t.buf) }++func orDiscard(w io.Writer) io.Writer {+ if w == nil {+ return io.Discard+ }+ return w+}++func (p *Project) target(ctx context.Context, c client.APIClient, service string) (string, error) {+ f := projectFilter(p.Name).+ Add("label", api.ServiceLabel+"="+service).+ Add("label", api.OneoffLabel+"=False").+ Add("label", api.ContainerNumberLabel+"=1").+ Add("status", "running")+ res, err := c.ContainerList(ctx, client.ContainerListOptions{Filters: f})+ if err != nil {+ return "", &Error{Op: "exec", Class: ClassOf(err), Err: err}+ }+ want := p.Name + "-" + service + "-1"+ for _, s := range res.Items {+ for _, n := range s.Names {+ if strings.TrimPrefix(n, "/") == want {+ return s.ID, nil+ }+ }+ }+ return "", &Error{Op: "exec", Class: ClassOther, Err: fmt.Errorf("%s is not running", service)}+}++func (p *Project) Exec(ctx context.Context, service string, o ExecOptions, command ...string) error {+ c, err := p.Engine.api()+ if err != nil {+ return err+ }+ id, err := p.target(ctx, c, service)+ if err != nil {+ return err+ }+ cmd := command+ pidFile := ""+ if o.KillOnCancel {+ pidFile = "/tmp/rexctl-" + randomID() + ".pid"+ cmd = append([]string{"sh", "-c", `echo $$ > ` + pidFile + ` && exec "$@"`, "--"}, command...)+ }+ created, err := c.ExecCreate(ctx, id, client.ExecCreateOptions{+ User: o.User,+ Env: o.Env,+ Cmd: cmd,+ AttachStdin: o.Stdin != nil,+ AttachStdout: true,+ AttachStderr: true,+ })+ if err != nil {+ return &Error{Op: "exec", Class: ClassOf(err), Err: err}+ }+ att, err := c.ExecAttach(ctx, created.ID, client.ExecAttachOptions{})+ if err != nil {+ return &Error{Op: "exec", Class: ClassOf(err), Err: err}+ }+ defer att.Close()+ tail := &tailBuffer{}+ done := stream(att.HijackedResponse, o.Stdin, orDiscard(o.Stdout), io.MultiWriter(tail, orDiscard(o.Stderr)))+ select {+ case err = <-done:+ case <-ctx.Done():+ if pidFile != "" {+ killExec(context.WithoutCancel(ctx), c, id, pidFile)+ }+ att.Close()+ <-done+ return ctx.Err()+ }+ if err != nil {+ return &Error{Op: "exec", Class: ClassOf(err), Err: err}+ }+ insp, err := inspectExec(ctx, c, created.ID)+ if err != nil {+ return &Error{Op: "exec", Class: ClassOf(err), Err: err}+ }+ if pidFile != "" {+ cleanup(context.WithoutCancel(ctx), c, id, pidFile)+ }+ if insp.ExitCode != 0 {+ return &ExitError{Code: insp.ExitCode, Stderr: tail.String()}+ }+ return nil+}++func inspectExec(ctx context.Context, c client.APIClient, id string) (client.ExecInspectResult, error) {+ for i := 0; ; i++ {+ insp, err := c.ExecInspect(ctx, id, client.ExecInspectOptions{})+ if err != nil || !insp.Running || i >= 50 {+ return insp, err+ }+ select {+ case <-ctx.Done():+ return insp, ctx.Err()+ case <-time.After(100 * time.Millisecond):+ }+ }+}++func stream(h client.HijackedResponse, stdin io.Reader, stdout, stderr io.Writer) <-chan error {+ done := make(chan error, 1)+ if stdin != nil {+ go func() {+ _, _ = io.Copy(h.Conn, stdin)+ _ = h.CloseWrite()+ }()+ }+ go func() {+ _, err := stdcopy.StdCopy(stdout, stderr, h.Reader)+ done <- err+ }()+ return done+}++func randomID() string {+ b := make([]byte, 8)+ _, _ = rand.Read(b)+ return hex.EncodeToString(b)+}++func killExec(ctx context.Context, c client.APIClient, id, pidFile string) {+ script := fmt.Sprintf(`pid=$(cat %[1]s 2>/dev/null) || exit 0; kill -TERM "$pid" 2>/dev/null || { rm -f %[1]s; exit 0; }; i=0; while [ $i -lt %[2]d ]; do kill -0 "$pid" 2>/dev/null || { rm -f %[1]s; exit 0; }; sleep 1; i=$((i+1)); done; kill -KILL "$pid" 2>/dev/null; rm -f %[1]s`, pidFile, int(killGrace/time.Second))+ runQuiet(ctx, c, id, script)+}++func cleanup(ctx context.Context, c client.APIClient, id, pidFile string) {+ runQuiet(ctx, c, id, "rm -f "+pidFile)+}++func runQuiet(ctx context.Context, c client.APIClient, id, script string) {+ ctx, cancel := context.WithTimeout(ctx, killGrace+20*time.Second)+ defer cancel()+ created, err := c.ExecCreate(ctx, id, client.ExecCreateOptions{Cmd: []string{"sh", "-c", script}, AttachStdout: true, AttachStderr: true})+ if err != nil {+ detailf("engine: %v", err)+ return+ }+ att, err := c.ExecAttach(ctx, created.ID, client.ExecAttachOptions{})+ if err != nil {+ detailf("engine: %v", err)+ return+ }+ defer att.Close()+ _, _ = stdcopy.StdCopy(io.Discard, io.Discard, att.Reader)+}++func (p *Project) Helper(ctx context.Context, o HelperOptions) error {+ c, err := p.Engine.api()+ if err != nil {+ return err+ }+ image := o.Image+ if image == "" {+ image = p.Image("postgres")+ }+ if image == "" {+ return &Error{Op: "helper", Class: ClassInvalidConfig, Err: errors.New("no image for the helper container")}+ }+ mounts := make([]mount.Mount, 0, len(o.Mounts))+ for _, m := range o.Mounts {+ mounts = append(mounts, mount.Mount{Type: mount.TypeVolume, Source: p.volumeName(ctx, c, m.Volume), Target: m.Target, ReadOnly: m.ReadOnly})+ }+ for attempt := 1; ; attempt++ {+ out := &deliveredWriter{}+ err := p.runHelper(ctx, c, image, mounts, o, out)+ if attempt == 1 && out.n.Load() == 0 && o.Stdin == nil && errors.Is(err, ErrHelperStalled) {+ detailf("engine: helper stalled before it sent any output, starting it again")+ continue+ }+ if attempt > 1 && errors.Is(err, ErrHelperStalled) {+ return &Error{Op: "helper", Class: ClassOther, Err: fmt.Errorf("%w, also after rexctl started a fresh one", ErrHelperStalled)}+ }+ return err+ }+}++type deliveredWriter struct {+ mu sync.Mutex+ w io.Writer+ n atomic.Int64+ closed bool+}++func (d *deliveredWriter) Write(b []byte) (int, error) {+ d.mu.Lock()+ defer d.mu.Unlock()+ if d.closed {+ return 0, ErrHelperStalled+ }+ n, err := d.w.Write(b)+ d.n.Add(int64(n))+ return n, err+}++func (d *deliveredWriter) close() {+ d.mu.Lock()+ d.closed = true+ d.mu.Unlock()+}++func (p *Project) runHelper(ctx context.Context, c client.APIClient, image string, mounts []mount.Mount, o HelperOptions, out *deliveredWriter) error {+ if err := p.removeHelpers(ctx, c); err != nil {+ return err+ }+ created, err := c.ContainerCreate(context.WithoutCancel(ctx), client.ContainerCreateOptions{+ Config: &container.Config{+ Image: image,+ Entrypoint: append([]string{"sh", "-c", heartbeatScript, "rexctl"}, o.Entrypoint...),+ Cmd: o.Command,+ AttachStdin: o.Stdin != nil,+ AttachStdout: true,+ AttachStderr: true,+ OpenStdin: o.Stdin != nil,+ StdinOnce: o.Stdin != nil,+ Labels: map[string]string{+ api.ProjectLabel: p.Name,+ api.ServiceLabel: "rexctl-helper",+ api.OneoffLabel: "True",+ },+ },+ HostConfig: &container.HostConfig{Mounts: mounts, NetworkMode: "none"},+ Name: p.Name + "-rexctl-helper-" + randomID(),+ })+ if err != nil {+ return &Error{Op: "helper", Class: ClassOf(err), Images: []string{image}, Err: err}+ }+ id := created.ID+ defer func() {+ rctx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 30*time.Second)+ defer cancel()+ if _, err := c.ContainerRemove(rctx, id, client.ContainerRemoveOptions{Force: true, RemoveVolumes: true}); err != nil {+ detailf("engine: removing helper %s: %v", id, err)+ }+ }()+ if err := ctx.Err(); err != nil {+ return err+ }+ ctx, stop := context.WithCancelCause(ctx)+ defer stop(nil)+ att, err := c.ContainerAttach(ctx, id, client.ContainerAttachOptions{Stream: true, Stdin: o.Stdin != nil, Stdout: true, Stderr: true})+ if err != nil {+ return &Error{Op: "helper", Class: ClassOf(err), Err: err}+ }+ defer att.Close()+ if _, err := c.ContainerStart(ctx, id, client.ContainerStartOptions{}); err != nil {+ return &Error{Op: "helper", Class: ClassOf(err), Err: err}+ }+ tail := &tailBuffer{}+ errOut := &deliveredWriter{w: io.MultiWriter(tail, orDiscard(o.Stderr))}+ out.w = orDiscard(o.Stdout)+ now := time.Now()+ act := &activity{start: now, last: now}+ go act.watch(ctx, func(cause error) {+ out.close()+ errOut.close()+ stop(cause)+ })+ wait := c.ContainerWait(ctx, id, client.ContainerWaitOptions{Condition: container.WaitConditionNotRunning})+ stderr := &heartbeatFilter{w: errOut}+ defer func() { out.n.Add(errOut.n.Load()) }()+ done := stream(att.HijackedResponse, o.Stdin, act.writer(out), act.writer(stderr))+ exited := pollExit(ctx, c, id)+ var code int64+ select {+ case code = <-exited:+ case res := <-wait.Result:+ if res.Error != nil && res.Error.Message != "" {+ return &Error{Op: "helper", Class: ClassOther, Err: errors.New(res.Error.Message)}+ }+ code = res.StatusCode+ case err := <-wait.Error:+ if ctx.Err() != nil {+ return p.stopHelper(ctx, c, id)+ }+ return &Error{Op: "helper", Class: ClassOf(err), Err: err}+ case <-ctx.Done():+ return p.stopHelper(ctx, c, id)+ }+ drainStream(done, act, stderr)+ if code != 0 {+ return &ExitError{Code: int(code), Stderr: tail.String()}+ }+ return nil+}++func drainStream(done <-chan error, act *activity, stderr *heartbeatFilter) {+ t := time.NewTicker(time.Second)+ defer t.Stop()+ for {+ select {+ case <-done:+ stderr.flush()+ return+ case <-t.C:+ if act.stalled(5 * time.Second) {+ return+ }+ }+ }+}++func pollExit(ctx context.Context, c client.APIClient, id string) <-chan int64 {+ out := make(chan int64, 1)+ go func() {+ t := time.NewTicker(10 * time.Second)+ defer t.Stop()+ for {+ select {+ case <-ctx.Done():+ return+ case <-t.C:+ }+ in, err := c.ContainerInspect(ctx, id, client.ContainerInspectOptions{})+ if err != nil || in.Container.State == nil {+ continue+ }+ if st := in.Container.State; st.Status == container.StateExited || st.Status == container.StateDead {+ detailf("engine: helper %s exited but the engine never reported it, using its exit code", id)+ out <- int64(st.ExitCode)+ return+ }+ }+ }()+ return out+}++func (p *Project) removeHelpers(ctx context.Context, c client.APIClient) error {+ f := projectFilter(p.Name).Add("label", api.ServiceLabel+"=rexctl-helper")+ res, err := c.ContainerList(ctx, client.ContainerListOptions{All: true, Filters: f})+ if err != nil {+ return &Error{Op: "helper", Class: ClassOf(err), Err: err}+ }+ for _, ct := range res.Items {+ if _, err := c.ContainerRemove(ctx, ct.ID, client.ContainerRemoveOptions{Force: true, RemoveVolumes: true}); err != nil && !cerrdefs.IsNotFound(err) {+ return &Error{Op: "helper", Class: ClassOf(err), Err: err}+ }+ }+ return nil+}++func (p *Project) stopHelper(ctx context.Context, c client.APIClient, id string) error {+ kctx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 30*time.Second)+ defer cancel()+ if _, err := c.ContainerKill(kctx, id, client.ContainerKillOptions{}); err != nil {+ detailf("engine: killing helper %s: %v", id, err)+ }+ if cause := context.Cause(ctx); errors.Is(cause, ErrHelperStalled) {+ return &Error{Op: "helper", Class: ClassOther, Err: cause}+ }+ return ctx.Err()+}++func (p *Project) volumeName(ctx context.Context, c client.APIClient, name string) string {+ if p.Model != nil {+ if v, ok := p.Model.Volumes[name]; ok && v.Name != "" {+ return v.Name+ }+ return name+ }+ res, err := c.VolumeList(ctx, client.VolumeListOptions{Filters: projectFilter(p.Name).Add("label", api.VolumeLabel+"="+name)})+ if err == nil && len(res.Items) == 1 {+ return res.Items[0].Name+ }+ return name+}diff --git a/fluxer_rexctl/internal/engine/logs.go b/fluxer_rexctl/internal/engine/logs.gonew file mode 100644index 000000000..e5ac9c0f3--- /dev/null+++ b/fluxer_rexctl/internal/engine/logs.go@@ -0,0 +1,46 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++package engine++import (+ "context"+ "fmt"+ "io"+ "strconv"+ "sync"++ "github.com/docker/compose/v5/pkg/api"+)++type logWriter struct {+ mu sync.Mutex+ w io.Writer+}++func (l *logWriter) write(container, msg string) {+ l.mu.Lock()+ defer l.mu.Unlock()+ fmt.Fprintf(l.w, "%s | %s\n", serviceOf("", container), msg)+}++func (l *logWriter) Log(container, msg string) { l.write(container, msg) }++func (l *logWriter) Err(container, msg string) { l.write(container, msg) }++func (l *logWriter) Status(string, string) {}++func (p *Project) Logs(ctx context.Context, o LogsOptions, services ...string) error {+ c, err := p.Engine.conn()+ if err != nil {+ return err+ }+ opts := api.LogOptions{Services: services, Follow: o.Follow, Since: o.Since}+ if o.Tail > 0 {+ opts.Tail = strconv.Itoa(o.Tail)+ }+ err = c.svc.Logs(ctx, p.Name, &logWriter{w: orDiscard(o.Stdout)}, opts)+ if err != nil && ctx.Err() != nil {+ return ctx.Err()+ }+ return p.wrap("logs", err)+}