Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
package podman
import (
"cmp"
"context"
"errors"
"fmt"
"os"
"strconv"
"strings"
"github.com/coreos/go-systemd/v22/dbus"
podmantypes "github.com/getarcaneapp/arcane/types/v2/podman"
godbus "github.com/godbus/dbus/v5"
kit "go.getarcane.app/kit/pkg"
"github.com/getarcaneapp/arcane/backend/v2/internal/common"
)
const defaultSystemBusAddress = "unix:path=/run/dbus/system_bus_socket"
type Systemd interface {
Availability(ctx context.Context) podmantypes.SystemdAvailability
Start(ctx context.Context, unit string) error
Stop(ctx context.Context, unit string) error
Restart(ctx context.Context, unit string) error
UnitStatus(ctx context.Context, unit string) (podmantypes.UnitStatus, error)
}
type dbusSystemd struct {
address string
scope podmantypes.SystemdScope
reason string
}
func NewSystemd(host string, rootless bool, getenv func(string) string) Systemd {
scope := kit.Ternary(rootless, podmantypes.SystemdScopeUser, podmantypes.SystemdScopeSystem)
busVariable := kit.Ternary(rootless, "DBUS_SESSION_BUS_ADDRESS", "DBUS_SYSTEM_BUS_ADDRESS")
address := getenv(busVariable)
scheme, _, _ := strings.Cut(host, "://")
switch {
case address == "" && host != "" && scheme != "unix" && scheme != "npipe":
return &dbusSystemd{
scope: scope,
reason: fmt.Sprintf("the Podman engine at %s is remote; set %s to that host's bus to manage its systemd units", host, busVariable),
}
case address == "" && rootless:
return &dbusSystemd{
scope: scope,
reason: "DBUS_SESSION_BUS_ADDRESS is not set; rootless Podman needs the user's session bus mounted and the variable set",
}
default:
return &dbusSystemd{
address: cmp.Or(address, defaultSystemBusAddress),
scope: scope,
}
}
}
func (s *dbusSystemd) Availability(ctx context.Context) podmantypes.SystemdAvailability {
conn, err := s.connect(ctx)
if err != nil {
return podmantypes.SystemdAvailability{
Scope: s.scope,
Reason: err.Error(),
}
}
conn.Close()
return podmantypes.SystemdAvailability{
Available: true,
Scope: s.scope,
}
}
func (s *dbusSystemd) Start(ctx context.Context, unit string) error {
return s.runJob(ctx, unit, "start", func(conn *dbus.Conn, ch chan<- string) (int, error) {
return conn.StartUnitContext(ctx, unit, "replace", ch)
})
}
func (s *dbusSystemd) Stop(ctx context.Context, unit string) error {
return s.runJob(ctx, unit, "stop", func(conn *dbus.Conn, ch chan<- string) (int, error) {
return conn.StopUnitContext(ctx, unit, "replace", ch)
})
}
func (s *dbusSystemd) Restart(ctx context.Context, unit string) error {
return s.runJob(ctx, unit, "restart", func(conn *dbus.Conn, ch chan<- string) (int, error) {
return conn.RestartUnitContext(ctx, unit, "replace", ch)
})
}
func (s *dbusSystemd) UnitStatus(ctx context.Context, unit string) (podmantypes.UnitStatus, error) {
conn, err := s.connect(ctx)
if err != nil {
return podmantypes.UnitStatus{}, err
}
defer conn.Close()
units, err := conn.ListUnitsByNamesContext(ctx, []string{unit})
if err != nil {
return podmantypes.UnitStatus{}, fmt.Errorf("read systemd unit %s: %w", unit, err)
}
if len(units) == 0 {
return podmantypes.UnitStatus{}, common.Classify(common.ErrNotFound, fmt.Errorf("systemd unit %s not found", unit))
}
return podmantypes.UnitStatus{
Name: units[0].Name,
Description: units[0].Description,
LoadState: units[0].LoadState,
ActiveState: units[0].ActiveState,
SubState: units[0].SubState,
}, nil
}
func (s *dbusSystemd) connect(ctx context.Context) (*dbus.Conn, error) {
if s.address == "" {
return nil, common.Classify(common.ErrUnavailable, errors.New(s.reason))
}
conn, err := dbus.NewConnection(func() (*godbus.Conn, error) {
busConn, dialErr := godbus.Dial(s.address, godbus.WithContext(ctx))
if dialErr != nil {
return nil, dialErr
}
if authErr := busConn.Auth([]godbus.Auth{godbus.AuthExternal(strconv.Itoa(os.Getuid()))}); authErr != nil {
_ = busConn.Close()
return nil, authErr
}
if helloErr := busConn.Hello(); helloErr != nil {
_ = busConn.Close()
return nil, helloErr
}
return busConn, nil
})
if err != nil {
return nil, common.Classify(common.ErrUnavailable, fmt.Errorf("connect to systemd %s bus at %s: %w", s.scope, s.address, err))
}
return conn, nil
}
func (s *dbusSystemd) runJob(ctx context.Context, unit, action string, start func(*dbus.Conn, chan<- string) (int, error)) error {
conn, err := s.connect(ctx)
if err != nil {
return err
}
defer conn.Close()
done := make(chan string, 1)
if _, startErr := start(conn, done); startErr != nil {
return fmt.Errorf("%s systemd unit %s: %w", action, unit, startErr)
}
select {
case <-ctx.Done():
return fmt.Errorf("%s systemd unit %s: %w", action, unit, ctx.Err())
case result := <-done:
if result != "done" {
return common.Classify(common.ErrConflict, fmt.Errorf("%s systemd unit %s: job %s", action, unit, result))
}
return nil
}
}