0
0
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)
}