0
0
package hostprocess
import (
"cmp"
"errors"
"fmt"
"strconv"
"syscall"
"time"
"github.com/johnandersen777/socialweb-computer-kcp/api/v1alpha1"
"github.com/johnandersen777/socialweb-computer-kcp/internal/hostsvc"
)
type OpKind string
const (
OpStart OpKind = "start"
OpStop OpKind = "stop"
)
type Op struct {
Kind OpKind
Spec hostsvc.UnitSpec
Unit string
}
type Observed struct {
Object v1alpha1.HostProcess
Backend hostsvc.Backend
Unit hostsvc.UnitStatus
Inspect error
Check *hostsvc.Observation
Exec string
Prefix string
Deleting bool
Restarted bool
StartedKey string
}
func RestartedInPlace(o v1alpha1.HostProcess, st hostsvc.UnitStatus) bool {
rt := o.Status.Runtime
return rt != nil && rt.InvocationID != "" && o.Spec.RestartPolicy != "" && o.Spec.RestartPolicy != v1alpha1.HostProcessRestartNever &&
(st.State == hostsvc.Activating || st.State == hostsvc.Active && st.MainPID > 0 && st.InvocationID != "" && st.InvocationID != rt.InvocationID)
}
type Result struct {
Phase v1alpha1.HostProcessPhase
LostReason v1alpha1.HostProcessLostReason
Message string
Ops []Op
Identify bool
Unknown bool
}
var ErrNotOurs = errors.New("hostprocess: a supervisor places only the units under its own prefix")
func restart(p v1alpha1.HostProcessRestartPolicy) hostsvc.Restart {
switch p {
case v1alpha1.HostProcessRestartAlways:
return hostsvc.RestartAlways
case v1alpha1.HostProcessRestartOnFailure:
return hostsvc.RestartOnFailure
}
return hostsvc.RestartNo
}
func signal(s string) syscall.Signal {
switch s {
case "SIGINT", "INT":
return syscall.SIGINT
case "SIGKILL", "KILL":
return syscall.SIGKILL
case "SIGQUIT", "QUIT":
return syscall.SIGQUIT
}
return syscall.SIGTERM
}
const DefaultMemoryMax = 2 << 30
func UnitSpec(o v1alpha1.HostProcess, exec string) (hostsvc.UnitSpec, error) {
s := o.Spec
exec = cmp.Or(exec, s.Exec)
if exec == "" {
return hostsvc.UnitSpec{}, fmt.Errorf("hostprocess %s: neither an exec path nor a resolvable asset", o.Name)
}
desc := "HostProcess " + o.Name
if d := s.Description; d != "" {
desc = d
}
spec := hostsvc.UnitSpec{Name: s.Unit, Description: desc, Exec: append([]string{exec}, s.Argv...),
WorkDir: s.WorkDir, Slice: s.Slice, Restart: restart(s.RestartPolicy), After: s.After, Wants: s.Wants,
PrivateHostname: s.PrivateHostname, FDStore: int(s.FdStore), KillSignal: syscall.SIGTERM}
for _, e := range s.Env {
spec.Env = append(spec.Env, e.Name+"="+e.Value)
}
spec.EnvFiles = append([]string(nil), s.EnvFiles...)
if s.Output != nil {
spec.Output = hostsvc.Output{StdoutFile: s.Output.Stdout, StderrFile: s.Output.Stderr}
}
if s.Stop != nil {
spec.KillSignal = signal(s.Stop.Signal)
spec.StopTimeout = time.Duration(s.Stop.GraceSeconds) * time.Second
}
spec.Limits.MemoryMax = DefaultMemoryMax
if s.Limits != nil {
spec.Limits = hostsvc.Limits{MemoryMax: DefaultMemoryMax, CPUWeight: uint64(s.Limits.CpuWeight), CPUQuotaPercent: int(s.Limits.CpuQuotaPercent),
TasksMax: uint64(s.Limits.TasksMax)}
for _, f := range []struct {
name, value string
to *uint64
}{{"memoryMax", s.Limits.MemoryMax, &spec.Limits.MemoryMax}, {"memoryHigh", s.Limits.MemoryHigh, &spec.Limits.MemoryHigh},
{"memorySwapMax", s.Limits.MemorySwapMax, &spec.Limits.MemorySwapMax}} {
if f.value == "" {
continue
}
n, err := strconv.ParseUint(f.value, 10, 64)
if err != nil {
return hostsvc.UnitSpec{}, fmt.Errorf("hostprocess %s: limits.%s %q is not a byte count", o.Name, f.name, f.value)
}
*f.to = n
}
}
return spec, hostsvc.ValidateSpec(spec)
}
func lost(r hostsvc.LostReason) v1alpha1.HostProcessLostReason {
switch r {
case hostsvc.LostHostRebooted:
return v1alpha1.HostProcessLostHostRebooted
case hostsvc.LostUnitFailed, hostsvc.LostUnitExited:
return v1alpha1.HostProcessLostUnitFailed
case hostsvc.LostOOMKilled:
return v1alpha1.HostProcessLostOOMKilled
case hostsvc.LostIdentityMismatch:
return v1alpha1.HostProcessLostIdentityMismatch
}
return v1alpha1.HostProcessLostUnitGone
}
func phaseOf(st hostsvc.UnitStatus) v1alpha1.HostProcessPhase {
switch st.State {
case hostsvc.Active:
return v1alpha1.HostProcessPhaseRunning
case hostsvc.Activating, hostsvc.Reloading:
return v1alpha1.HostProcessPhaseStarting
case hostsvc.Deactivating:
return v1alpha1.HostProcessPhaseStopping
case hostsvc.Failed:
return v1alpha1.HostProcessPhaseFailed
}
return v1alpha1.HostProcessPhaseStopped
}
func Reconcile(o Observed) Result {
obj := o.Object
rt := obj.Status.Runtime
if o.Inspect != nil {
return Result{Phase: obj.Status.Phase, LostReason: obj.Status.LostReason, Unknown: true,
Message: "the service manager is unreachable; Unknown, never Lost: " + o.Inspect.Error()}
}
if rt != nil && rt.Backend != "" && rt.Backend != string(o.Backend) {
return Result{Phase: v1alpha1.HostProcessPhaseLost, LostReason: v1alpha1.HostProcessLostIdentityMismatch,
Message: fmt.Sprintf("placed by the %s backend and this supervisor runs %s: never adopted across backends", rt.Backend, o.Backend)}
}
if obj.Spec.Placement == v1alpha1.HostProcessPlacementBootstrap {
if o.Unit.State == hostsvc.NotFound || o.Unit.State == "" {
return Result{Phase: v1alpha1.HostProcessPhaseLost, LostReason: v1alpha1.HostProcessLostUnitGone,
Message: "the bootstrap unit is not loaded; its supervisor (systemd or devsup) owns it, this is a mirror"}
}
return Result{Phase: phaseOf(o.Unit), Identify: o.Unit.State == hostsvc.Active,
Message: "a read-only mirror of a bootstrap-layer unit"}
}
if o.Prefix != "" && (len(obj.Spec.Unit) < len(o.Prefix) || obj.Spec.Unit[:len(o.Prefix)] != o.Prefix) {
return Result{Phase: v1alpha1.HostProcessPhaseFailed, Message: fmt.Sprintf("%v: %s is not under %s", ErrNotOurs, obj.Spec.Unit, o.Prefix)}
}
if o.Deleting {
if o.Unit.State == hostsvc.Active || o.Unit.State == hostsvc.Activating {
return Result{Phase: v1alpha1.HostProcessPhaseStopping, Ops: []Op{{Kind: OpStop, Unit: obj.Spec.Unit}}}
}
return Result{Phase: v1alpha1.HostProcessPhaseStopped}
}
if rt != nil && rt.InvocationID != "" {
if obj.Status.Phase == v1alpha1.HostProcessPhaseLost {
return Result{Phase: v1alpha1.HostProcessPhaseLost, LostReason: obj.Status.LostReason, Message: obj.Status.Message}
}
if o.Restarted {
message := fmt.Sprintf("restarted in place by its manager (restartPolicy %s, invocation %s, recorded %s)",
obj.Spec.RestartPolicy, o.Unit.InvocationID, rt.InvocationID)
if o.StartedKey != "" && o.StartedKey == obj.Spec.RestartKey {
message = fmt.Sprintf("restarted in place for spec.restartKey %q (invocation %s, recorded %s)",
obj.Spec.RestartKey, o.Unit.InvocationID, rt.InvocationID)
}
return Result{Phase: phaseOf(o.Unit), Identify: o.Unit.State == hostsvc.Active, Message: message}
}
if o.Check == nil {
return Result{Phase: obj.Status.Phase, Unknown: true, Message: "the recorded identity was not checked"}
}
switch o.Check.Verdict {
case hostsvc.VerdictUnknown:
return Result{Phase: obj.Status.Phase, Unknown: true, Message: "Unknown: " + o.Check.Detail}
case hostsvc.VerdictRunning:
if obj.Spec.RestartKey != obj.Status.RestartKey {
spec, err := UnitSpec(obj, o.Exec)
if err != nil {
return Result{Phase: v1alpha1.HostProcessPhaseFailed, Message: err.Error()}
}
return Result{Phase: v1alpha1.HostProcessPhaseStarting, Identify: true,
Ops: []Op{{Kind: OpStop, Unit: obj.Spec.Unit}, {Kind: OpStart, Spec: spec, Unit: spec.Name}},
Message: fmt.Sprintf("restarted in place: spec.restartKey is %q and the running process started under %q",
obj.Spec.RestartKey, obj.Status.RestartKey)}
}
message := "adopted by unit name and InvocationID"
if o.StartedKey != "" && o.StartedKey == obj.Spec.RestartKey {
message = fmt.Sprintf("restarted in place for spec.restartKey %q (invocation %s)", obj.Spec.RestartKey, o.Check.Status.InvocationID)
}
return Result{Phase: v1alpha1.HostProcessPhaseRunning, Identify: o.Check.Status.InvocationID != rt.InvocationID,
Message: message}
}
if o.Check.Reason == hostsvc.LostUnitExited && o.Check.Status.ExecMainStatus == 0 && o.Check.Status.ExecMainCode <= 1 {
return Result{Phase: v1alpha1.HostProcessPhaseStopped, Message: "the process exited 0"}
}
r := Result{Phase: v1alpha1.HostProcessPhaseLost, LostReason: lost(o.Check.Reason), Message: o.Check.Detail}
if o.Check.Reason == hostsvc.LostIdentityMismatch && !o.Check.Stopped && o.Unit.State == hostsvc.Active {
r.Ops = []Op{{Kind: OpStop, Unit: obj.Spec.Unit}}
}
return r
}
switch o.Unit.State {
case hostsvc.Active:
return Result{Phase: v1alpha1.HostProcessPhaseRunning, Identify: true, Message: "an active unit of this name is adopted"}
case hostsvc.Activating:
return Result{Phase: v1alpha1.HostProcessPhaseStarting, Identify: true}
}
if obj.Spec.RestartPolicy == v1alpha1.HostProcessRestartNever && obj.Status.Phase != "" && obj.Status.Phase != v1alpha1.HostProcessPhasePending {
if o.Unit.State == hostsvc.Failed {
return Result{Phase: v1alpha1.HostProcessPhaseLost, LostReason: v1alpha1.HostProcessLostUnitFailed,
Message: fmt.Sprintf("the unit failed (result %s) before it was identified; restartPolicy Never places it once", o.Unit.Result)}
}
return Result{Phase: v1alpha1.HostProcessPhaseStopped, Message: "the unit ended before it was identified; restartPolicy Never places it once"}
}
spec, err := UnitSpec(obj, o.Exec)
if err != nil {
return Result{Phase: v1alpha1.HostProcessPhaseFailed, Message: err.Error()}
}
return Result{Phase: v1alpha1.HostProcessPhaseStarting, Ops: []Op{{Kind: OpStart, Spec: spec, Unit: spec.Name}}, Identify: true}
}