0
0
package hostsvc
import (
"cmp"
"context"
"errors"
"fmt"
"strings"
"time"
"github.com/johnandersen777/socialweb-computer-kcp/internal/contract/host"
)
const NamePrefix = "socialweb-"
const ServiceSuffix = ".service"
const DefaultSlice = "socialweb.slice"
const MinSystemdVersion = 253
const DefaultCallTimeout = 10 * time.Second
var ErrUnsupported = errors.New("hostsvc: no service manager backend on this OS")
var ErrUnreachable = errors.New("hostsvc: service manager unreachable")
var ErrNoBackend = errors.New("hostsvc: no placement backend chosen: set the host-backend option (systemd-user | proc, env SOCIALWEB_HOST_BACKEND); there is no default and nothing is probed")
var ErrSystemdTooOld = fmt.Errorf("hostsvc: systemd older than %d (GetUnitByPIDFD is required)", MinSystemdVersion)
type (
Backend = host.Backend
Capabilities = host.Capabilities
Restart = host.Restart
UnitEvent = host.UnitEvent
ActiveState = host.ActiveState
Output = host.Output
Limits = host.Limits
UnitSpec = host.UnitSpec
UnitStatus = host.UnitStatus
Verdict = host.Verdict
LostReason = host.LostReason
Identity = host.Identity
Observation = host.Observation
Manager = host.Units
)
const (
BackendSystemdUser = host.BackendSystemdUser
BackendProc = host.BackendProc
)
func ParseBackend(s string) (Backend, error) {
switch Backend(s) {
case BackendSystemdUser, BackendProc:
return Backend(s), nil
case "":
return "", ErrNoBackend
}
return "", fmt.Errorf("hostsvc: unknown placement backend %q: want %s or %s", s, BackendSystemdUser, BackendProc)
}
type Config struct {
Backend Backend
UnitPrefix string
SystemdPrivateSocket string
ProcSocket string
InstalledDir string
}
func (c Config) Prefix() string {
if c.UnitPrefix == "" {
return NamePrefix
}
return c.UnitPrefix
}
func (c Config) Validate() error {
if c.Backend == "" {
return ErrNoBackend
}
if _, err := ParseBackend(string(c.Backend)); err != nil {
return err
}
if !strings.HasPrefix(c.Prefix(), NamePrefix) {
return fmt.Errorf("hostsvc: unit prefix %q must start with %s", c.UnitPrefix, NamePrefix)
}
if c.Backend == BackendProc && c.ProcSocket == "" {
return fmt.Errorf("hostsvc: the proc backend needs the devsup socket path")
}
return nil
}
const (
RestartNo = host.RestartNo
RestartOnFailure = host.RestartOnFailure
RestartAlways = host.RestartAlways
)
const (
Active = host.Active
Activating = host.Activating
Deactivating = host.Deactivating
Reloading = host.Reloading
Inactive = host.Inactive
Failed = host.Failed
NotFound = host.NotFound
)
const (
VerdictUnknown = host.VerdictUnknown
VerdictRunning = host.VerdictRunning
VerdictLost = host.VerdictLost
)
const (
LostHostRebooted = host.LostHostRebooted
LostUnitGone = host.LostUnitGone
LostUnitExited = host.LostUnitExited
LostUnitFailed = host.LostUnitFailed
LostOOMKilled = host.LostOOMKilled
LostIdentityMismatch = host.LostIdentityMismatch
)
func Live(st UnitStatus) bool {
return st.State == Active || st.State == Activating || st.State == Deactivating
}
func Await(ctx context.Context, m Manager, unit string, done func(UnitStatus) bool) (UnitStatus, error) {
if err := ValidateName(unit); err != nil {
return UnitStatus{}, err
}
wctx, cancel := context.WithCancel(ctx)
defer cancel()
events, err := m.Watch(wctx, unit)
if err != nil {
return UnitStatus{}, err
}
st, err := m.Inspect(ctx, unit)
if err != nil {
return st, err
}
for !done(st) {
select {
case <-ctx.Done():
return st, ctx.Err()
case ev, ok := <-events:
if !ok {
if err := ctx.Err(); err != nil {
return st, err
}
return st, fmt.Errorf("%w: the watch of %s ended", ErrUnreachable, unit)
}
if ev.Name == unit {
st = ev.Status
}
}
}
return st, nil
}
func ValidateName(name string) error {
if !strings.HasPrefix(name, NamePrefix) || !strings.HasSuffix(name, ServiceSuffix) {
return fmt.Errorf("hostsvc: unit %q is not ours: every unit this package starts is named %s<kind>-<owner>-<name>%s",
name, NamePrefix, ServiceSuffix)
}
if strings.ContainsAny(name, "*?[]/\\ ") {
return fmt.Errorf("hostsvc: unit %q carries a glob or path character", name)
}
return nil
}
func ValidatePrefix(prefix string) error {
if !strings.HasPrefix(prefix, NamePrefix) || len(prefix) <= len(NamePrefix) {
return fmt.Errorf("hostsvc: list prefix %q must start with %s and name a kind", prefix, NamePrefix)
}
if strings.ContainsAny(prefix, "*?[]/\\ ") {
return fmt.Errorf("hostsvc: list prefix %q carries a glob or path character", prefix)
}
return nil
}
func ValidateSpec(spec UnitSpec) error {
if err := ValidateName(spec.Name); err != nil {
return err
}
if len(spec.Exec) == 0 || !strings.HasPrefix(spec.Exec[0], "/") {
return fmt.Errorf("hostsvc: unit %s needs an absolute executable path, got %q", spec.Name, spec.Exec)
}
if spec.Slice == "app.slice" || strings.HasPrefix(spec.Slice, "app-") {
return fmt.Errorf("hostsvc: unit %s may not run in %s: systemd-oomd kills by memory pressure there",
spec.Name, spec.Slice)
}
if spec.Slice != "" && !strings.HasSuffix(spec.Slice, ".slice") {
return fmt.Errorf("hostsvc: unit %s names slice %q, which is not a .slice", spec.Name, spec.Slice)
}
switch spec.Restart {
case "", RestartNo, RestartOnFailure, RestartAlways:
default:
return fmt.Errorf("hostsvc: unit %s asks for Restart=%q: want no, on-failure or always", spec.Name, spec.Restart)
}
if spec.FDStore < 0 {
return fmt.Errorf("hostsvc: unit %s asks for a negative fd store", spec.Name)
}
if spec.Limits.CPUQuotaPercent < 0 {
return fmt.Errorf("hostsvc: unit %s asks for a negative CPU quota", spec.Name)
}
return nil
}
func ValidateSlice(slice string) error {
if !strings.HasPrefix(slice, "socialweb") || !strings.HasSuffix(slice, ".slice") {
return fmt.Errorf("hostsvc: slice %q is not ours: every slice this package stops is named socialweb[-<key>].slice", slice)
}
if strings.ContainsAny(slice, "*?[]/\\ ") {
return fmt.Errorf("hostsvc: slice %q carries a glob or path character", slice)
}
return nil
}
func SliceContains(slice, unitSlice string) bool {
unitSlice = cmp.Or(unitSlice, DefaultSlice)
if unitSlice == slice {
return true
}
return strings.HasPrefix(unitSlice, strings.TrimSuffix(slice, ".slice")+"-")
}
func RefuseUnsupported(c Capabilities, spec UnitSpec) error {
if spec.FDStore > 0 && !c.FDStore {
return fmt.Errorf("%w: unit %s asks for an fd store, which the %s backend does not offer in this build",
ErrUnsupported, spec.Name, c.Backend)
}
if spec.PrivateHostname != "" && !c.PrivateHostname {
return fmt.Errorf("%w: unit %s asks for a private hostname, which the %s backend does not offer in this build",
ErrUnsupported, spec.Name, c.Backend)
}
return nil
}
func ForeignIdentity(c Capabilities, want Identity) (Observation, bool) {
if want.Backend == "" || want.Backend == c.Backend {
return Observation{}, false
}
return Observation{Verdict: VerdictLost, Reason: LostIdentityMismatch,
Detail: fmt.Sprintf("%s was placed by the %s backend and this manager is %s: never adopted across backends",
want.Unit, want.Backend, c.Backend)}, true
}
var _ host.Clock = SystemClock{}
type SystemClock struct{}
func (SystemClock) Now() time.Time { return time.Now() }
func (SystemClock) After(d time.Duration) <-chan time.Time { return time.After(d) }
var _ host.Processes = Processes{}
type Processes struct{}