0
0
//go:build linux || darwin
package hostsvc
import (
"bufio"
"context"
"encoding/json"
"errors"
"fmt"
"net"
"strings"
"time"
"github.com/johnandersen777/socialweb-computer-kcp/internal/contract/host"
)
var _ host.Units = (*proc)(nil)
type proc struct {
socket string
prefix string
installed string
}
func (p *proc) StartInstalled(ctx context.Context, name string) (UnitStatus, error) {
spec, err := ReadInstalledSpec(p.installed, name)
if err != nil {
return UnitStatus{}, err
}
return p.Start(ctx, spec)
}
func openProc(ctx context.Context, cfg Config) (Manager, error) {
p := &proc{socket: cfg.ProcSocket, prefix: cfg.Prefix(), installed: cfg.InstalledDir}
if _, err := p.Hello(ctx); err != nil {
return nil, err
}
return p, nil
}
func (p *proc) dial(ctx context.Context, timeout time.Duration) (net.Conn, error) {
if _, ok := ctx.Deadline(); !ok {
var cancel context.CancelFunc
ctx, cancel = context.WithTimeout(ctx, timeout)
defer cancel()
}
var d net.Dialer
c, err := d.DialContext(ctx, "unix", p.socket)
if err != nil {
return nil, fmt.Errorf("%w: dialing devsup at %s: %w", ErrUnreachable, p.socket, err)
}
if dl, ok := ctx.Deadline(); ok {
c.SetDeadline(dl)
}
return c, nil
}
func (p *proc) call(ctx context.Context, req ProcRequest) (ProcResponse, error) {
timeout := DefaultCallTimeout
if req.Op == ProcOpStop || req.Op == ProcOpStopSlice || req.Op == ProcOpShutdown || req.Op == ProcOpCheck {
timeout = ProcStopCallTimeout
}
if _, ok := ctx.Deadline(); !ok {
var cancel context.CancelFunc
ctx, cancel = context.WithTimeout(ctx, timeout)
defer cancel()
}
c, err := p.dial(ctx, timeout)
if err != nil {
return ProcResponse{}, err
}
defer c.Close()
stop := context.AfterFunc(ctx, func() { c.SetDeadline(time.Unix(1, 0)) })
defer stop()
if err := json.NewEncoder(c).Encode(req); err != nil {
return ProcResponse{}, fmt.Errorf("%w: writing %s to devsup: %w", ErrUnreachable, req.Op, err)
}
line, err := bufio.NewReader(c).ReadBytes('\n')
if err != nil {
return ProcResponse{}, fmt.Errorf("%w: reading the %s answer from devsup: %w", ErrUnreachable, req.Op, err)
}
var resp ProcResponse
if err := json.Unmarshal(line, &resp); err != nil {
return ProcResponse{}, fmt.Errorf("hostsvc: devsup answered %s with %q: %w", req.Op, line, err)
}
return resp, resp.Error()
}
func (p *proc) owns(name string) error {
if !strings.HasPrefix(name, p.prefix) {
return fmt.Errorf("hostsvc: unit %s is outside this manager's prefix %s", name, p.prefix)
}
return nil
}
func (p *proc) Hello(ctx context.Context) (ProcHello, error) {
resp, err := p.call(ctx, ProcRequest{Op: ProcOpHello})
if err != nil {
return ProcHello{}, err
}
if resp.Hello == nil {
return ProcHello{}, fmt.Errorf("hostsvc: devsup at %s answered hello without its identity", p.socket)
}
return *resp.Hello, nil
}
func (p *proc) Capabilities() Capabilities { return ProcCapabilities() }
func (p *proc) Start(ctx context.Context, spec UnitSpec) (UnitStatus, error) {
if err := ValidateSpec(spec); err != nil {
return UnitStatus{}, err
}
if err := p.owns(spec.Name); err != nil {
return UnitStatus{}, err
}
if err := RefuseUnsupported(p.Capabilities(), spec); err != nil {
return UnitStatus{}, err
}
resp, err := p.call(ctx, ProcRequest{Op: ProcOpStart, Spec: &spec})
if err != nil {
return UnitStatus{}, fmt.Errorf("hostsvc: starting %s: %w", spec.Name, err)
}
return *resp.Status, nil
}
func (p *proc) Inspect(ctx context.Context, name string) (UnitStatus, error) {
if err := ValidateName(name); err != nil {
return UnitStatus{}, err
}
resp, err := p.call(ctx, ProcRequest{Op: ProcOpInspect, Name: name})
if err != nil {
return UnitStatus{}, fmt.Errorf("hostsvc: inspecting %s: %w", name, err)
}
return *resp.Status, nil
}
func (p *proc) Stop(ctx context.Context, name string) error {
if err := ValidateName(name); err != nil {
return err
}
if _, err := p.call(ctx, ProcRequest{Op: ProcOpStop, Name: name}); err != nil {
return fmt.Errorf("hostsvc: stopping %s: %w", name, err)
}
return nil
}
func (p *proc) StopSlice(ctx context.Context, slice string) error {
if err := ValidateSlice(slice); err != nil {
return err
}
if _, err := p.call(ctx, ProcRequest{Op: ProcOpStopSlice, Slice: slice}); err != nil {
return fmt.Errorf("hostsvc: stopping %s: %w", slice, err)
}
return nil
}
func (p *proc) ResetFailed(ctx context.Context, name string) error {
if err := ValidateName(name); err != nil {
return err
}
if _, err := p.call(ctx, ProcRequest{Op: ProcOpResetFailed, Name: name}); err != nil {
return fmt.Errorf("hostsvc: resetting %s: %w", name, err)
}
return nil
}
func (p *proc) List(ctx context.Context, prefix string) ([]UnitStatus, error) {
if err := ValidatePrefix(prefix); err != nil {
return nil, err
}
resp, err := p.call(ctx, ProcRequest{Op: ProcOpList, Prefix: prefix})
if err != nil {
return nil, fmt.Errorf("hostsvc: listing %s*: %w", prefix, err)
}
return resp.Statuses, nil
}
func (p *proc) Identify(ctx context.Context, name string, pid int) (Identity, error) {
if err := ValidateName(name); err != nil {
return Identity{}, err
}
resp, err := p.call(ctx, ProcRequest{Op: ProcOpIdentify, Name: name, PID: pid})
if err != nil {
return Identity{}, err
}
return *resp.Identity, nil
}
func (p *proc) Check(ctx context.Context, want Identity) (Observation, error) {
if err := ValidateName(want.Unit); err != nil {
return Observation{}, err
}
if obs, foreign := ForeignIdentity(p.Capabilities(), want); foreign {
return obs, nil
}
resp, err := p.call(ctx, ProcRequest{Op: ProcOpCheck, Identity: &want})
if errors.Is(err, ErrUnreachable) {
return Observation{Verdict: VerdictUnknown, Detail: err.Error()}, nil
}
if err != nil {
return Observation{Detail: err.Error()}, err
}
return *resp.Observation, nil
}
func (p *proc) Watch(ctx context.Context, prefix string) (<-chan UnitEvent, error) {
if err := ValidatePrefix(prefix); err != nil {
return nil, err
}
var d net.Dialer
dctx, cancel := context.WithTimeout(ctx, DefaultCallTimeout)
c, err := d.DialContext(dctx, "unix", p.socket)
cancel()
if err != nil {
return nil, fmt.Errorf("%w: dialing devsup at %s: %w", ErrUnreachable, p.socket, err)
}
if err := json.NewEncoder(c).Encode(ProcRequest{Op: ProcOpWatch, Prefix: prefix}); err != nil {
c.Close()
return nil, fmt.Errorf("%w: writing watch to devsup: %w", ErrUnreachable, err)
}
r := bufio.NewReader(c)
line, err := r.ReadBytes('\n')
if err != nil {
c.Close()
return nil, fmt.Errorf("%w: reading the watch answer from devsup: %w", ErrUnreachable, err)
}
var first ProcResponse
if err := json.Unmarshal(line, &first); err != nil || first.Error() != nil {
c.Close()
return nil, fmt.Errorf("hostsvc: devsup refused watch: %v %v", err, first.Error())
}
ch := make(chan UnitEvent, 64)
stop := context.AfterFunc(ctx, func() { c.Close() })
go func() {
defer close(ch)
defer stop()
defer c.Close()
for {
line, err := r.ReadBytes('\n')
if err != nil {
return
}
var resp ProcResponse
if json.Unmarshal(line, &resp) != nil || resp.Event == nil {
continue
}
select {
case ch <- *resp.Event:
case <-ctx.Done():
return
}
}
}()
return ch, nil
}
func (p *proc) Shutdown(ctx context.Context) error {
_, err := p.call(ctx, ProcRequest{Op: ProcOpShutdown})
return err
}
func (p *proc) Close() error { return nil }
func OpenProcClient(ctx context.Context, cfg Config) (ProcClient, error) {
cfg.Backend = BackendProc
if err := cfg.Validate(); err != nil {
return nil, err
}
m, err := openProc(ctx, cfg)
if err != nil {
return nil, err
}
return m.(*proc), nil
}