~ knotless Search/
↑↓ move↵ open⇧↵ all results

socialweb.computer/socialweb-computer-kcp

socialweb.computer: a compute market on atproto (kcp)

1 collaborator
0
0
252 lines · 8.8 KB Raw History
package atircnode

import (
	"context"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"log/slog"
	"path/filepath"
	"reflect"
	"regexp"
	"strconv"
	"strings"

	apierrors "k8s.io/apimachinery/pkg/api/errors"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"

	"github.com/johnandersen777/socialweb-computer-kcp/api/v1alpha1"
	ctlruntime "github.com/johnandersen777/socialweb-computer-kcp/internal/controllers/runtime"
	"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/conds"
)

const (
	Name = "atircnode"

	Export = "hostprocesses"

	Finalizer = "socialweb.computer/atircnode"

	LabelAtircNode = "socialweb.computer/atircnode"

	ChildPrefix = "atirc-"

	Asset = "atirc"

	ConditionReady = "Ready"
)

var (
	labelRE   = regexp.MustCompile(`^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$`)
	handleRE  = regexp.MustCompile(`^([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]([a-z0-9-]{0,61}[a-z0-9])?$`)
	peerDIDRE = regexp.MustCompile(`^did:(plc:[a-z2-7]{24}|web:([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]([a-z0-9-]{0,61}[a-z0-9])?)$`)
	channelRE = regexp.MustCompile(`^#[^\s,\x00]{1,63}$`)
)

type Options struct {
	Log *slog.Logger

	Prefix string

	StateDir string

	Scope func(workspace string) bool
}

type Controller struct {
	log *slog.Logger

	opts Options
}

func Register(m *ctlruntime.Manager, opts Options) (*Controller, error) {
	if opts.StateDir == "" {
		return nil, fmt.Errorf("atircnode: a state directory is required")
	}
	log := opts.Log
	if log == nil {
		log = slog.New(slog.DiscardHandler)
	}
	c := &Controller{log: log.With("component", "atircnode-controller"), opts: opts}
	options := []ctlruntime.Option{ctlruntime.Export(Export), ctlruntime.Finalizer(Finalizer), ctlruntime.Owns[*v1alpha1.HostProcess]()}
	if opts.Scope != nil {
		options = append(options, ctlruntime.InWorkspaces(opts.Scope))
	}
	if err := ctlruntime.For[*v1alpha1.AtircNode](m, Name, c, options...); err != nil {
		return nil, err
	}
	return c, nil
}

func Identity(spec v1alpha1.AtircNodeSpec) string {
	handle := strings.ToLower(strings.TrimSpace(spec.Handle))
	if nick := strings.ToLower(strings.TrimSpace(spec.Nick)); nick != "" {
		return nick + "." + handle
	}
	return handle
}

func (c *Controller) configDir(o *v1alpha1.AtircNode) string {
	if o.Spec.ConfigDir != "" {
		return o.Spec.ConfigDir
	}
	return filepath.Join(c.opts.StateDir, "atirc", o.Name)
}

func validate(o *v1alpha1.AtircNode) error {
	s := o.Spec
	switch {
	case !labelRE.MatchString(o.Name) || len(o.Name) > 40:
		return fmt.Errorf("the name %q is not a DNS label of at most 40 characters", o.Name)
	case !handleRE.MatchString(strings.ToLower(strings.TrimSpace(s.Handle))):
		return fmt.Errorf("spec.handle %q is not a handle", s.Handle)
	case s.Nick != "" && !labelRE.MatchString(strings.ToLower(strings.TrimSpace(s.Nick))):
		return fmt.Errorf("spec.nick %q is not a DNS label", s.Nick)
	case s.ConfigDir != "" && !filepath.IsAbs(s.ConfigDir):
		return fmt.Errorf("spec.configDir %q is not an absolute path", s.ConfigDir)
	case s.PasswordEnvFile != "" && !filepath.IsAbs(s.PasswordEnvFile):
		return fmt.Errorf("spec.passwordEnvFile %q is not an absolute path", s.PasswordEnvFile)
	case s.IrcPort != nil && (*s.IrcPort < 0 || *s.IrcPort > 65535):
		return fmt.Errorf("spec.ircPort %d is not a port", *s.IrcPort)
	case s.Jetstream != "" && s.Jetstream != "off" && !strings.HasPrefix(s.Jetstream, "wss://") && !strings.HasPrefix(s.Jetstream, "ws://"):
		return fmt.Errorf("spec.jetstream %q is not a ws(s) URL or off", s.Jetstream)
	}
	for _, ch := range s.Channels {
		if !channelRE.MatchString(ch) {
			return fmt.Errorf("spec.channels: %q is not a channel", ch)
		}
	}
	for _, p := range s.Peers {
		handle, did, withDID := strings.Cut(strings.ToLower(strings.TrimSpace(p)), "@")
		if !handleRE.MatchString(handle) || withDID && !peerDIDRE.MatchString(did) {
			return fmt.Errorf("spec.peers: %q is not a mesh identity", p)
		}
	}
	return nil
}

func (c *Controller) childSpec(o *v1alpha1.AtircNode) v1alpha1.HostProcessSpec {
	s := o.Spec
	argv := []string{"mesh", "run"}
	for _, ch := range s.Channels {
		argv = append(argv, "-c", ch)
	}
	for _, p := range s.Peers {
		argv = append(argv, "--peer", strings.ToLower(strings.TrimSpace(p)))
	}
	if s.Jetstream != "" {
		argv = append(argv, "--jetstream", s.Jetstream)
	}
	if s.IrcPort != nil {
		argv = append(argv, "--irc-port", strconv.Itoa(int(*s.IrcPort)))
	}
	if s.NoPublish {
		argv = append(argv, "--no-publish")
	}
	env := []v1alpha1.HostProcessEnv{{Name: "ATP_USERNAME", Value: strings.ToLower(strings.TrimSpace(s.Handle))},
		{Name: "ATIRC_CONFIG_DIR", Value: c.configDir(o)}}
	if s.Nick != "" {
		env = append(env, v1alpha1.HostProcessEnv{Name: "ATIRC_NICK", Value: strings.ToLower(strings.TrimSpace(s.Nick))})
	}
	spec := v1alpha1.HostProcessSpec{Unit: c.opts.Prefix + ChildPrefix + o.Name + ".service", Description: "atirc mesh run as " + Identity(s),
		Asset: &v1alpha1.HostProcessAsset{Name: Asset}, Argv: argv, Env: env, RestartPolicy: v1alpha1.HostProcessRestartAlways,
		Stop: &v1alpha1.HostProcessStop{Signal: "SIGTERM", GraceSeconds: 10}, Placement: v1alpha1.HostProcessPlacementSupervisor}
	if s.PasswordEnvFile != "" {
		spec.EnvFiles = []string{s.PasswordEnvFile}
	}
	key, _ := json.Marshal([]any{spec.Argv, spec.Env, spec.EnvFiles})
	sum := sha256.Sum256(key)
	spec.RestartKey = hex.EncodeToString(sum[:8])
	return spec
}

func (c *Controller) Reconcile(ctx context.Context, req ctlruntime.Request, o *v1alpha1.AtircNode) (ctlruntime.Result, error) {
	if !o.DeletionTimestamp.IsZero() {
		return c.finalize(ctx, req, o)
	}
	next := o.Status.DeepCopy()
	next.ObservedGeneration = o.Generation
	set := func(phase v1alpha1.AtircNodePhase, msg string) {
		next.Phase, next.Message = phase, msg
		conds.Set(&next.Conditions, o.Generation, ConditionReady, phase == v1alpha1.AtircNodePhaseRunning, string(phase), msg)
	}
	if err := validate(o); err != nil {
		set(v1alpha1.AtircNodePhaseFailed, err.Error())
		return ctlruntime.Result{}, c.apply(ctx, req, o, next)
	}
	next.Identity, next.ConfigDir = Identity(o.Spec), c.configDir(o)
	hp, err := c.child(ctx, req, o, c.childSpec(o))
	if err != nil {
		return ctlruntime.Result{}, err
	}
	next.HostProcess, next.Runtime = hp.Name, hp.Status.Runtime
	switch hp.Status.Phase {
	case v1alpha1.HostProcessPhaseRunning:
		set(v1alpha1.AtircNodePhaseRunning, "atirc mesh run is running as "+next.Identity)
	case v1alpha1.HostProcessPhaseLost:
		c.log.Warn("atircnode_hostprocess_lost", "workspace", req.Workspace, "atircnode", o.Name, "reason", string(hp.Status.LostReason))
		if err := req.Delete(ctx, hp); err != nil {
			return ctlruntime.Result{}, err
		}
		set(v1alpha1.AtircNodePhaseStarting, "its HostProcess "+hp.Name+" is Lost "+string(hp.Status.LostReason)+"; placing a new one")
	case v1alpha1.HostProcessPhaseFailed:
		set(v1alpha1.AtircNodePhaseFailed, "its HostProcess "+hp.Name+" is Failed: "+hp.Status.Message)
	case "":
		set(v1alpha1.AtircNodePhaseStarting, "its HostProcess "+hp.Name+" waits for the supervisor")
	default:
		set(v1alpha1.AtircNodePhaseStarting, "its HostProcess "+hp.Name+" is "+string(hp.Status.Phase))
	}
	return ctlruntime.Result{}, c.apply(ctx, req, o, next)
}

func (c *Controller) child(ctx context.Context, req ctlruntime.Request, o *v1alpha1.AtircNode, spec v1alpha1.HostProcessSpec) (*v1alpha1.HostProcess, error) {
	name := ChildPrefix + o.Name
	var cur v1alpha1.HostProcess
	err := req.Get(ctx, "", name, &cur)
	if err != nil && !apierrors.IsNotFound(err) {
		return nil, err
	}
	if err == nil && reflect.DeepEqual(cur.Spec, spec) {
		return &cur, nil
	}
	controller := true
	want := &v1alpha1.HostProcess{ObjectMeta: metav1.ObjectMeta{Name: name, Labels: map[string]string{LabelAtircNode: o.Name},
		OwnerReferences: []metav1.OwnerReference{{APIVersion: v1alpha1.GroupVersion.String(), Kind: "AtircNode", Name: o.Name,
			UID: o.UID, Controller: &controller}}}, Spec: spec}
	if err := req.Apply(ctx, want); err != nil {
		return nil, err
	}
	c.log.Info("atircnode_hostprocess_applied", "workspace", req.Workspace, "atircnode", o.Name, "hostprocess", name, "unit", spec.Unit)
	if err == nil && cur.Name != "" {
		cur.Spec = spec
		return &cur, nil
	}
	return want, nil
}

func (c *Controller) finalize(ctx context.Context, req ctlruntime.Request, o *v1alpha1.AtircNode) (ctlruntime.Result, error) {
	var hp v1alpha1.HostProcess
	err := req.Get(ctx, "", ChildPrefix+o.Name, &hp)
	switch {
	case apierrors.IsNotFound(err):
		return ctlruntime.Result{}, nil
	case err != nil:
		return ctlruntime.Result{Waiting: true}, err
	}
	if hp.DeletionTimestamp.IsZero() {
		if err := req.Delete(ctx, &hp); err != nil {
			return ctlruntime.Result{Waiting: true}, err
		}
	}
	return ctlruntime.Result{Waiting: true}, nil
}

func (c *Controller) apply(ctx context.Context, req ctlruntime.Request, o *v1alpha1.AtircNode, next *v1alpha1.AtircNodeStatus) error {
	if reflect.DeepEqual(o.Status, *next) {
		return nil
	}
	obj := o.DeepCopy()
	obj.Status = *next
	return req.ApplyStatus(ctx, obj)
}