0
0
//go:build linux
package hostsvc
import (
"cmp"
"context"
"encoding/hex"
"errors"
"fmt"
"io"
"net"
"slices"
"sort"
"strings"
"sync"
"syscall"
"time"
sd "github.com/coreos/go-systemd/v22/dbus"
"github.com/godbus/dbus/v5"
"github.com/johnandersen777/socialweb-computer-kcp/internal/contract/host"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/strs"
)
const (
errUnitExists = "org.freedesktop.systemd1.UnitExists"
errNoSuchUnit = "org.freedesktop.systemd1.NoSuchUnit"
errNoUnitForPID = "org.freedesktop.systemd1.NoUnitForPID"
errNoSuchProcess = "org.freedesktop.systemd1.NoSuchProcess"
errUnixProcessIDUnknown = "org.freedesktop.DBus.Error.UnixProcessIdUnknown"
)
var _ host.Units = (*systemd)(nil)
type systemd struct {
dial func(ctx context.Context) (bus, error)
procs procs
timeout time.Duration
prefix string
mu sync.Mutex
b bus
}
func openSystemd(ctx context.Context, cfg Config) (Manager, error) {
path := cfg.SystemdPrivateSocket
if path == "" {
path = PrivateSocketPath()
}
m, err := OpenPrivate(ctx, path)
if err != nil {
return nil, err
}
m.(*systemd).prefix = cfg.Prefix()
return m, nil
}
func OpenPrivate(ctx context.Context, path string) (Manager, error) {
m := newManager(dialPrivate(path), linuxProcs{}, DefaultCallTimeout)
if err := m.checkVersion(ctx); err != nil {
m.Close()
return nil, err
}
return m, nil
}
func newManager(dial func(ctx context.Context) (bus, error), p procs, timeout time.Duration) *systemd {
return &systemd{dial: dial, procs: p, timeout: timeout, prefix: NamePrefix}
}
func (m *systemd) Capabilities() Capabilities {
return Capabilities{Backend: BackendSystemdUser, EnforcesLimits: true, OOMKillReported: true, FDStore: true}
}
func (m *systemd) owns(name string) error {
if !strings.HasPrefix(name, m.prefix) {
return fmt.Errorf("hostsvc: unit %s is outside this manager's prefix %s", name, m.prefix)
}
return nil
}
func (m *systemd) managerID(ctx context.Context) (string, error) {
var started uint64
err := m.do(ctx, func(ctx context.Context, b bus) (err error) {
started, err = b.ManagerStarted(ctx)
return err
})
if err != nil {
return "", err
}
boot, err := m.procs.BootID()
if err != nil {
return "", err
}
return fmt.Sprintf("systemd-user:%s:%d", boot, started), nil
}
func (m *systemd) StopSlice(ctx context.Context, slice string) error {
if err := ValidateSlice(slice); err != nil {
return err
}
ctx, cancel := withDeadline(ctx, m.timeout)
defer cancel()
ch := make(chan string, 1)
err := m.do(ctx, func(ctx context.Context, b bus) error { return b.StopUnit(ctx, slice, ch) })
if dbusErrorName(err) == errNoSuchUnit {
return nil
}
if err != nil {
return fmt.Errorf("hostsvc: stopping %s: %w", slice, err)
}
result, err := waitJob(ctx, ch)
if err != nil {
return fmt.Errorf("hostsvc: stopping %s: %w", slice, err)
}
if result != "done" {
return fmt.Errorf("hostsvc: the stop job of %s ended %q", slice, result)
}
return nil
}
const unitPathPrefix = "/org/freedesktop/systemd1/unit/"
func unitKey(st UnitStatus) string {
return string(st.State) + "|" + st.SubState + "|" + st.InvocationID + "|" + st.Result
}
func unescapeUnitPath(p dbus.ObjectPath) string {
s, ok := strings.CutPrefix(string(p), unitPathPrefix)
if !ok || strings.Contains(s, "/") {
return ""
}
var out []byte
for i := 0; i < len(s); i++ {
if s[i] == '_' && i+2 < len(s) {
if b, err := hex.DecodeString(s[i+1 : i+3]); err == nil {
out = append(out, b[0])
i += 2
continue
}
}
out = append(out, s[i])
}
return string(out)
}
func signalUnit(sig *dbus.Signal) string {
switch sig.Name {
case managerIfc + ".UnitNew", managerIfc + ".UnitRemoved":
if len(sig.Body) > 0 {
name, _ := sig.Body[0].(string)
return name
}
case managerIfc + ".JobRemoved":
if len(sig.Body) > 2 {
name, _ := sig.Body[2].(string)
return name
}
case "org.freedesktop.DBus.Properties.PropertiesChanged":
if len(sig.Body) > 0 {
if ifc, _ := sig.Body[0].(string); ifc == systemdDest+".Unit" || ifc == systemdDest+".Service" {
return unescapeUnitPath(sig.Path)
}
}
}
return ""
}
func (m *systemd) current(ctx context.Context, name string) (UnitStatus, error) {
var units []sd.UnitStatus
err := m.do(ctx, func(ctx context.Context, b bus) (err error) {
units, err = b.ListUnitsByPatterns(ctx, []string{name})
return err
})
if err != nil {
return UnitStatus{}, fmt.Errorf("hostsvc: looking up %s: %w", name, err)
}
for _, u := range units {
if u.Name == name && u.LoadState != "not-found" {
return m.Inspect(ctx, name)
}
}
return UnitStatus{Name: name, State: NotFound}, nil
}
func (m *systemd) Watch(ctx context.Context, prefix string) (<-chan UnitEvent, error) {
if err := ValidatePrefix(prefix); err != nil {
return nil, err
}
dctx, cancel := withDeadline(ctx, m.timeout)
b, err := m.dial(dctx)
cancel()
if err != nil {
return nil, fmt.Errorf("%w: %w", ErrUnreachable, err)
}
sigs := make(chan *dbus.Signal, 256)
sctx, cancel := withDeadline(ctx, m.timeout)
err = b.Subscribe(sctx, sigs)
cancel()
if err != nil {
b.Close()
if unreachable(err) {
return nil, fmt.Errorf("%w: subscribing to unit signals: %w", ErrUnreachable, err)
}
return nil, fmt.Errorf("hostsvc: subscribing to unit signals: %w", err)
}
first, err := m.List(ctx, prefix)
if err != nil {
b.Close()
return nil, err
}
seen := map[string]string{}
for _, st := range first {
seen[st.Name] = unitKey(st)
}
ch := make(chan UnitEvent, 64)
stop := context.AfterFunc(ctx, b.Close)
go func() {
defer close(ch)
defer stop()
defer b.Close()
for sig := range sigs {
name := signalUnit(sig)
if !strings.HasPrefix(name, prefix) || ValidateName(name) != nil {
continue
}
st, err := m.current(ctx, name)
if errors.Is(err, ErrUnreachable) || ctx.Err() != nil {
return
}
if err != nil {
continue
}
if st.State == NotFound {
if _, ok := seen[name]; !ok {
continue
}
delete(seen, name)
} else {
k := unitKey(st)
if seen[name] == k {
continue
}
seen[name] = k
}
select {
case ch <- UnitEvent{Name: name, Status: st}:
case <-ctx.Done():
return
}
}
}()
return ch, nil
}
func withDeadline(ctx context.Context, d time.Duration) (context.Context, context.CancelFunc) {
if _, ok := ctx.Deadline(); ok {
return context.WithCancel(ctx)
}
return context.WithTimeout(ctx, d)
}
func (m *systemd) conn(ctx context.Context) (bus, error) {
m.mu.Lock()
defer m.mu.Unlock()
if m.b != nil {
return m.b, nil
}
b, err := m.dial(ctx)
if err != nil {
return nil, fmt.Errorf("%w: %w", ErrUnreachable, err)
}
m.b = b
return b, nil
}
func (m *systemd) drop(b bus) {
m.mu.Lock()
defer m.mu.Unlock()
if m.b == b {
m.b = nil
}
b.Close()
}
func (m *systemd) do(ctx context.Context, f func(ctx context.Context, b bus) error) error {
ctx, cancel := withDeadline(ctx, m.timeout)
defer cancel()
for retried := false; ; retried = true {
b, err := m.conn(ctx)
if err != nil {
return err
}
err = f(ctx, b)
if err == nil || !unreachable(err) {
return err
}
if ctx.Err() != nil {
return fmt.Errorf("%w: %w", ErrUnreachable, err)
}
m.drop(b)
if retried {
return fmt.Errorf("%w: %w", ErrUnreachable, err)
}
}
}
func unreachable(err error) bool {
if err == nil {
return false
}
var de dbus.Error
if errors.As(err, &de) {
return false
}
var dl dialError
if errors.As(err, &dl) {
return true
}
for _, target := range []error{context.DeadlineExceeded, context.Canceled, dbus.ErrClosed, net.ErrClosed,
io.EOF, io.ErrUnexpectedEOF, syscall.ECONNRESET, syscall.EPIPE, syscall.ENOTCONN, syscall.ECONNREFUSED} {
if errors.Is(err, target) {
return true
}
}
var op *net.OpError
return errors.As(err, &op)
}
func dbusErrorName(err error) string {
var de dbus.Error
if errors.As(err, &de) {
return de.Name
}
return ""
}
type envFile struct {
Path string
IgnoreMissing bool
}
func unitProperties(spec UnitSpec) []sd.Property {
desc := spec.Description
desc = cmp.Or(desc, spec.Name)
slice := spec.Slice
slice = cmp.Or(slice, DefaultSlice)
oom := spec.OOMPolicy
oom = cmp.Or(oom, "stop")
str := func(name, v string) sd.Property { return sd.Property{Name: name, Value: dbus.MakeVariant(v)} }
u64 := func(name string, v uint64) sd.Property { return sd.Property{Name: name, Value: dbus.MakeVariant(v)} }
props := []sd.Property{
sd.PropDescription(desc),
sd.PropExecStart(spec.Exec, false),
str("Type", "exec"),
str("CollectMode", "inactive"),
str("KillMode", "control-group"),
str("OOMPolicy", oom),
sd.PropSlice(slice),
}
restart := spec.Restart
restart = cmp.Or(restart, RestartNo)
props = append(props, str("Restart", string(restart)))
if spec.KillSignal != 0 {
props = append(props, sd.Property{Name: "KillSignal", Value: dbus.MakeVariant(int32(spec.KillSignal))})
}
if spec.StopTimeout > 0 {
props = append(props, u64("TimeoutStopUSec", uint64(spec.StopTimeout/time.Microsecond)))
}
if spec.Limits.MemoryMax > 0 {
props = append(props, u64("MemoryMax", spec.Limits.MemoryMax), u64("MemorySwapMax", spec.Limits.MemorySwapMax))
if spec.Limits.MemoryHigh > 0 {
props = append(props, u64("MemoryHigh", spec.Limits.MemoryHigh))
}
}
if spec.Delegate {
props = append(props, sd.Property{Name: "Delegate", Value: dbus.MakeVariant(true)})
}
if spec.Limits.TasksMax > 0 {
props = append(props, u64("TasksMax", spec.Limits.TasksMax))
}
if spec.Limits.CPUWeight > 0 {
props = append(props, u64("CPUWeight", spec.Limits.CPUWeight))
}
if spec.Limits.CPUQuotaPercent > 0 {
props = append(props, u64("CPUQuotaPerSecUSec", uint64(spec.Limits.CPUQuotaPercent)*10_000))
}
if len(spec.Env) > 0 {
props = append(props, sd.Property{Name: "Environment", Value: dbus.MakeVariant(spec.Env)})
}
if len(spec.EnvFiles) > 0 {
files := make([]envFile, 0, len(spec.EnvFiles))
for _, f := range spec.EnvFiles {
files = append(files, envFile{Path: f})
}
props = append(props, sd.Property{Name: "EnvironmentFiles", Value: dbus.MakeVariant(files)})
}
if spec.WorkDir != "" {
props = append(props, str("WorkingDirectory", spec.WorkDir))
}
if spec.Output.StdoutFile != "" {
props = append(props, str("StandardOutputFileToAppend", spec.Output.StdoutFile))
}
if spec.Output.StderrFile != "" {
props = append(props, str("StandardErrorFileToAppend", spec.Output.StderrFile))
}
if len(spec.After) > 0 {
props = append(props, sd.PropAfter(spec.After...))
}
if len(spec.Wants) > 0 {
props = append(props, sd.PropWants(spec.Wants...))
}
if spec.FDStore > 0 {
props = append(props, sd.Property{Name: "FileDescriptorStoreMax", Value: dbus.MakeVariant(uint32(spec.FDStore))},
str("NotifyAccess", "main"))
}
return props
}
func (m *systemd) checkVersion(ctx context.Context) error {
var v string
err := m.do(ctx, func(ctx context.Context, b bus) (err error) {
v, err = b.Version(ctx)
return err
})
if err != nil {
return fmt.Errorf("hostsvc: reading the manager version: %w", err)
}
n, err := strs.LeadingInt(v)
if err != nil {
return fmt.Errorf("%w: the manager reports version %q", ErrSystemdTooOld, v)
}
if n < MinSystemdVersion {
return fmt.Errorf("%w: the manager reports %q", ErrSystemdTooOld, v)
}
return nil
}
func waitJob(ctx context.Context, ch <-chan string) (string, error) {
select {
case r := <-ch:
return r, nil
case <-ctx.Done():
return "", fmt.Errorf("%w: waiting for the job: %w", ErrUnreachable, ctx.Err())
}
}
func (m *systemd) Start(ctx context.Context, spec UnitSpec) (UnitStatus, error) {
if err := ValidateSpec(spec); err != nil {
return UnitStatus{}, err
}
if err := m.owns(spec.Name); err != nil {
return UnitStatus{}, err
}
if err := RefuseUnsupported(m.Capabilities(), spec); err != nil {
return UnitStatus{}, err
}
ctx, cancel := withDeadline(ctx, m.timeout)
defer cancel()
props := unitProperties(spec)
ch := make(chan string, 1)
err := m.do(ctx, func(ctx context.Context, b bus) error {
return b.StartTransientUnit(ctx, spec.Name, props, ch)
})
if dbusErrorName(err) == errUnitExists {
st, err := m.Inspect(ctx, spec.Name)
st.Adopted = true
return st, err
}
if err != nil {
return UnitStatus{}, fmt.Errorf("hostsvc: starting %s: %w", spec.Name, err)
}
result, err := waitJob(ctx, ch)
if err != nil {
return UnitStatus{}, fmt.Errorf("hostsvc: starting %s: %w", spec.Name, err)
}
st, err := m.Inspect(ctx, spec.Name)
if err != nil {
return st, err
}
if result != "done" {
return st, fmt.Errorf("hostsvc: the start job of %s ended %q (state %s, result %s, exec main code %d status %d)",
spec.Name, result, st.State, st.Result, st.ExecMainCode, st.ExecMainStatus)
}
return st, nil
}
type unitStarter interface {
StartUnit(ctx context.Context, name string, ch chan<- string) error
}
type bootFiles interface {
EnableUnitFiles(ctx context.Context, names []string) error
DisableUnitFiles(ctx context.Context, names []string) error
}
func (m *systemd) SetBoot(ctx context.Context, enable, disable []string) error {
for _, n := range append(slices.Clone(enable), disable...) {
if err := ValidateName(n); err != nil {
return err
}
if err := m.owns(n); err != nil {
return err
}
}
ctx, cancel := withDeadline(ctx, m.timeout)
defer cancel()
return m.do(ctx, func(ctx context.Context, b bus) error {
s, ok := b.(bootFiles)
if !ok {
return fmt.Errorf("%w: this bus enables no unit file", ErrUnsupported)
}
if len(disable) > 0 {
if err := s.DisableUnitFiles(ctx, disable); err != nil {
return fmt.Errorf("hostsvc: disabling %v: %w", disable, err)
}
}
if len(enable) > 0 {
if err := s.EnableUnitFiles(ctx, enable); err != nil {
return fmt.Errorf("hostsvc: enabling %v: %w", enable, err)
}
}
return nil
})
}
func (m *systemd) StartInstalled(ctx context.Context, name string) (UnitStatus, error) {
if err := ValidateName(name); err != nil {
return UnitStatus{}, err
}
if err := m.owns(name); err != nil {
return UnitStatus{}, err
}
ctx, cancel := withDeadline(ctx, m.timeout)
defer cancel()
if st, err := m.Inspect(ctx, name); err == nil && st.State == Active {
st.Adopted = true
return st, nil
}
ch := make(chan string, 1)
err := m.do(ctx, func(ctx context.Context, b bus) error {
s, ok := b.(unitStarter)
if !ok {
return fmt.Errorf("%w: this bus starts no installed unit", ErrUnsupported)
}
return s.StartUnit(ctx, name, ch)
})
if err != nil {
return UnitStatus{}, fmt.Errorf("hostsvc: starting the installed unit %s: %w", name, err)
}
result, err := waitJob(ctx, ch)
if err != nil {
return UnitStatus{}, fmt.Errorf("hostsvc: starting the installed unit %s: %w", name, err)
}
st, err := m.Inspect(ctx, name)
if err != nil {
return st, err
}
if result != "done" {
return st, fmt.Errorf("hostsvc: the start job of the installed unit %s ended %q (state %s, result %s)", name, result, st.State, st.Result)
}
return st, nil
}
func (m *systemd) Inspect(ctx context.Context, name string) (UnitStatus, error) {
if err := ValidateName(name); err != nil {
return UnitStatus{}, err
}
var up, sp map[string]any
err := m.do(ctx, func(ctx context.Context, b bus) (err error) {
if up, err = b.UnitProperties(ctx, name); err != nil {
return err
}
sp, err = b.ServiceProperties(ctx, name)
return err
})
if err != nil {
return UnitStatus{}, fmt.Errorf("hostsvc: inspecting %s: %w", name, err)
}
return statusFrom(name, up, sp), nil
}
func statusFrom(name string, up, sp map[string]any) UnitStatus {
st := UnitStatus{Name: name, Backend: BackendSystemdUser}
str := func(m map[string]any, k string) string { s, _ := m[k].(string); return s }
if str(up, "LoadState") == "not-found" {
st.State = NotFound
return st
}
st.State = ActiveState(str(up, "ActiveState"))
st.SubState = str(up, "SubState")
st.Description = str(up, "Description")
st.Result = str(sp, "Result")
if inv, ok := up["InvocationID"].([]byte); ok {
st.InvocationID = hex.EncodeToString(inv)
}
if ts, ok := up["ActiveEnterTimestamp"].(uint64); ok && ts > 0 {
st.ActiveSince = time.UnixMicro(int64(ts)).UTC()
}
if pid, ok := sp["MainPID"].(uint32); ok {
st.MainPID = int(pid)
}
st.ExecMainCode, _ = sp["ExecMainCode"].(int32)
st.ExecMainStatus, _ = sp["ExecMainStatus"].(int32)
return st
}
func (m *systemd) Stop(ctx context.Context, name string) error {
if err := ValidateName(name); err != nil {
return err
}
ctx, cancel := withDeadline(ctx, m.timeout)
defer cancel()
ch := make(chan string, 1)
err := m.do(ctx, func(ctx context.Context, b bus) error { return b.StopUnit(ctx, name, ch) })
if dbusErrorName(err) == errNoSuchUnit {
return nil
}
if err != nil {
return fmt.Errorf("hostsvc: stopping %s: %w", name, err)
}
result, err := waitJob(ctx, ch)
if err != nil {
return fmt.Errorf("hostsvc: stopping %s: %w", name, err)
}
if result != "done" {
return fmt.Errorf("hostsvc: the stop job of %s ended %q", name, result)
}
return nil
}
func (m *systemd) ResetFailed(ctx context.Context, name string) error {
if err := ValidateName(name); err != nil {
return err
}
err := m.do(ctx, func(ctx context.Context, b bus) error { return b.ResetFailedUnit(ctx, name) })
if dbusErrorName(err) == errNoSuchUnit {
return nil
}
if err != nil {
return fmt.Errorf("hostsvc: resetting %s: %w", name, err)
}
return nil
}
func (m *systemd) List(ctx context.Context, prefix string) ([]UnitStatus, error) {
if err := ValidatePrefix(prefix); err != nil {
return nil, err
}
var units []sd.UnitStatus
err := m.do(ctx, func(ctx context.Context, b bus) (err error) {
units, err = b.ListUnitsByPatterns(ctx, []string{prefix + "*"})
return err
})
if err != nil {
return nil, fmt.Errorf("hostsvc: listing %s*: %w", prefix, err)
}
var out []UnitStatus
for _, u := range units {
if !strings.HasPrefix(u.Name, prefix) || !strings.HasSuffix(u.Name, ServiceSuffix) || u.LoadState == "not-found" {
continue
}
st, err := m.Inspect(ctx, u.Name)
if err != nil {
return nil, err
}
if st.State != NotFound {
out = append(out, st)
}
}
sort.Slice(out, func(i, j int) bool { return out[i].Name < out[j].Name })
return out, nil
}
func (m *systemd) unitByPIDFD(ctx context.Context, fd int) (string, string, error) {
var unit, inv string
err := m.do(ctx, func(ctx context.Context, b bus) (err error) {
unit, inv, err = b.UnitByPIDFD(ctx, fd)
return err
})
return unit, inv, err
}
func (m *systemd) Identify(ctx context.Context, name string, pid int) (Identity, error) {
st, err := m.Inspect(ctx, name)
if err != nil {
return Identity{}, err
}
if st.State != Active {
return Identity{}, fmt.Errorf("hostsvc: %s is %s, not active, and has no identity to record", name, st.State)
}
pid = cmp.Or(pid, st.MainPID)
boot, err := m.procs.BootID()
if err != nil {
return Identity{}, err
}
p, err := m.procs.Pin(pid)
if err != nil {
return Identity{}, fmt.Errorf("hostsvc: pinning pid %d of %s: %w", pid, name, err)
}
defer p.Close()
unit, inv, err := m.unitByPIDFD(ctx, p.FD())
if err != nil {
return Identity{}, fmt.Errorf("hostsvc: GetUnitByPIDFD for pid %d of %s: %w", pid, name, err)
}
if unit != name || inv != st.InvocationID {
return Identity{}, fmt.Errorf("hostsvc: pid %d belongs to %s invocation %s, not %s invocation %s",
pid, unit, inv, name, st.InvocationID)
}
mgr, err := m.managerID(ctx)
if err != nil {
return Identity{}, fmt.Errorf("hostsvc: reading the manager identity: %w", err)
}
return Identity{Unit: name, InvocationID: inv, PID: pid, StartTicks: p.StartTicks(), BootID: boot,
Backend: BackendSystemdUser, Manager: mgr}, nil
}
func (m *systemd) Check(ctx context.Context, want Identity) (Observation, error) {
if err := ValidateName(want.Unit); err != nil {
return Observation{}, err
}
boot, err := m.procs.BootID()
if err != nil {
return Observation{Detail: err.Error()}, err
}
if boot != want.BootID {
return Observation{Verdict: VerdictLost, Reason: LostHostRebooted,
Detail: fmt.Sprintf("boot id %s, recorded %s", boot, want.BootID)}, nil
}
if obs, foreign := ForeignIdentity(m.Capabilities(), want); foreign {
return obs, nil
}
if want.Manager != "" {
mgr, err := m.managerID(ctx)
if errors.Is(err, ErrUnreachable) {
return Observation{Verdict: VerdictUnknown, Detail: err.Error()}, nil
}
if err != nil {
return Observation{Detail: err.Error()}, err
}
if mgr != want.Manager {
return Observation{Verdict: VerdictLost, Reason: LostUnitGone,
Detail: fmt.Sprintf("the user manager restarted (%s, recorded %s): every unit it held is gone", mgr, want.Manager)}, nil
}
}
st, err := m.Inspect(ctx, want.Unit)
if errors.Is(err, ErrUnreachable) {
return Observation{Verdict: VerdictUnknown, Detail: err.Error()}, nil
}
if err != nil {
return Observation{Detail: err.Error()}, err
}
lost := func(r LostReason, format string, args ...any) (Observation, error) {
return Observation{Verdict: VerdictLost, Reason: r, Detail: fmt.Sprintf(format, args...), Status: st}, nil
}
switch st.State {
case NotFound:
return lost(LostUnitGone, "%s is not loaded", want.Unit)
case Failed:
if st.Result == "oom-kill" {
return lost(LostOOMKilled, "%s failed: result %s", want.Unit, st.Result)
}
return lost(LostUnitFailed, "%s failed: result %s, exec main code %d status %d",
want.Unit, st.Result, st.ExecMainCode, st.ExecMainStatus)
case Inactive:
return lost(LostUnitExited, "%s is inactive: result %s", want.Unit, st.Result)
}
if st.InvocationID != want.InvocationID {
return m.mismatch(ctx, st, "%s runs invocation %s, recorded %s", want.Unit, st.InvocationID, want.InvocationID)
}
p, err := m.procs.Pin(want.PID)
if errors.Is(err, errProcessGone) {
return m.mismatch(ctx, st, "recorded pid %d of %s: %v", want.PID, want.Unit, err)
}
if err != nil {
return Observation{Detail: err.Error(), Status: st}, err
}
defer p.Close()
if p.StartTicks() != want.StartTicks {
return m.mismatch(ctx, st, "pid %d started at tick %d, recorded %d: the pid was reused",
want.PID, p.StartTicks(), want.StartTicks)
}
unit, inv, err := m.unitByPIDFD(ctx, p.FD())
switch {
case errors.Is(err, ErrUnreachable):
return Observation{Verdict: VerdictUnknown, Detail: err.Error(), Status: st}, nil
case dbusErrorName(err) == errUnixProcessIDUnknown || dbusErrorName(err) == errNoUnitForPID ||
dbusErrorName(err) == errNoSuchProcess:
return m.mismatch(ctx, st, "GetUnitByPIDFD for pid %d: %v", want.PID, err)
case err != nil:
return Observation{Detail: err.Error(), Status: st}, fmt.Errorf("hostsvc: GetUnitByPIDFD for pid %d: %w", want.PID, err)
}
if unit != want.Unit || inv != want.InvocationID {
return m.mismatch(ctx, st, "pid %d belongs to %s invocation %s, recorded %s invocation %s",
want.PID, unit, inv, want.Unit, want.InvocationID)
}
if st.State != Active {
return Observation{Verdict: VerdictUnknown, Detail: fmt.Sprintf("%s is %s", want.Unit, st.State), Status: st}, nil
}
return Observation{Verdict: VerdictRunning, Status: st}, nil
}
func (m *systemd) mismatch(ctx context.Context, st UnitStatus, format string, args ...any) (Observation, error) {
obs := Observation{Verdict: VerdictLost, Reason: LostIdentityMismatch, Detail: fmt.Sprintf(format, args...), Status: st}
if err := m.Stop(ctx, st.Name); err != nil {
return obs, fmt.Errorf("hostsvc: %s does not match its record and stopping it failed: %w", st.Name, err)
}
obs.Stopped = true
return obs, nil
}
func (m *systemd) Close() error {
m.mu.Lock()
defer m.mu.Unlock()
if m.b != nil {
m.b.Close()
m.b = nil
}
return nil
}