0
0
package computevm
import (
"context"
"fmt"
"log/slog"
"reflect"
"time"
apierrors "k8s.io/apimachinery/pkg/api/errors"
apimeta "k8s.io/apimachinery/pkg/api/meta"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"github.com/johnandersen777/socialweb-computer-kcp/api/v1alpha1"
"github.com/johnandersen777/socialweb-computer-kcp/internal/compute/firecracker"
"github.com/johnandersen777/socialweb-computer-kcp/internal/computevm"
ctlruntime "github.com/johnandersen777/socialweb-computer-kcp/internal/controllers/runtime"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/conds"
commonv1 "github.com/johnandersen777/socialweb-computer-kcp/api/common/v1alpha1"
)
const (
Name = "computevm"
Export = "computevms"
Workers = 4
)
type Controller struct {
host *computevm.Host
handle string
log *slog.Logger
}
func Register(m *ctlruntime.Manager, host *computevm.Host) (*Controller, error) {
handle := host.Config().Handle
ctl := &Controller{host: host, handle: handle, log: host.Log().With("controller", Name)}
if err := ctlruntime.For[*v1alpha1.ComputeVM](m, Name, ctl, ctlruntime.Export(Export),
ctlruntime.FieldManager(v1alpha1.FieldManagerComputeVMController), ctlruntime.Finalizer(v1alpha1.FinalizerComputeVM),
ctlruntime.SharedStatus(), ctlruntime.Workers(Workers), ctlruntime.Owns[*v1alpha1.FirecrackerVM](),
ctlruntime.Only(func(vm *v1alpha1.ComputeVM) bool { return vm.Spec.Owner.Handle == handle })); err != nil {
return nil, fmt.Errorf("computevm: registering the ComputeVM controller: %w", err)
}
return ctl, nil
}
func setCondition(st *v1alpha1.ComputeVMStatus, gen int64, t string, ok bool, reason, msg string) {
conds.Set(&st.Conditions, gen, t, ok, reason, computevm.CapMessage(msg))
}
func (c *Controller) backend(ctx context.Context, req ctlruntime.Request, vm *v1alpha1.ComputeVM) (*v1alpha1.FirecrackerVM, error) {
var fvm v1alpha1.FirecrackerVM
err := req.Get(ctx, "", vm.Spec.BackendRef.Name, &fvm)
if apierrors.IsNotFound(err) {
return nil, nil
}
if err != nil {
return nil, err
}
return &fvm, nil
}
func isSandbox(vm *v1alpha1.ComputeVM) bool {
ref := vm.Spec.BackendRef
return ref.Kind == v1alpha1.BackendKindDenoSandbox && (ref.Group == "" || ref.Group == v1alpha1.GroupName) && ref.Name != ""
}
func (c *Controller) reconcileSandbox(ctx context.Context, req ctlruntime.Request, vm *v1alpha1.ComputeVM) (ctlruntime.Result, error) {
if !vm.DeletionTimestamp.IsZero() {
return c.release(ctx, req, vm)
}
if computevm.ReleaseRequested(vm) {
return c.deleteOnRequest(ctx, req, vm)
}
st := vm.Status
st.Conditions = append([]metav1.Condition(nil), st.Conditions...)
st.Phase, st.Message = v1alpha1.ComputeVMPhaseRunning, "the deno sandbox runs on the bidder"
setCondition(&st, vm.Generation, v1alpha1.ComputeVMConditionBackendBound, true, "DenoSandbox", "the bidder runs the sandbox itself")
setCondition(&st, vm.Generation, v1alpha1.ComputeVMConditionReady, true, "Ready", st.Message)
return ctlruntime.Result{}, c.write(ctx, req, vm, st)
}
func backendSupported(vm *v1alpha1.ComputeVM) bool {
ref := vm.Spec.BackendRef
return ref.Kind == v1alpha1.BackendKindFirecrackerVM && (ref.Group == "" || ref.Group == v1alpha1.GroupName) && ref.Name != ""
}
func (c *Controller) bind(ctx context.Context, req ctlruntime.Request, vm *v1alpha1.ComputeVM, have *v1alpha1.FirecrackerVM) (*v1alpha1.FirecrackerVM, error) {
spec := firecracker.SpecFor(c.handle, vm.Spec)
if have != nil && reflect.DeepEqual(have.Spec, spec) && hasOwner(have, vm) {
return have, nil
}
if have != nil && !have.DeletionTimestamp.IsZero() {
return have, nil
}
ctrl := true
fvm := &v1alpha1.FirecrackerVM{
TypeMeta: metav1.TypeMeta{APIVersion: v1alpha1.GroupVersion.String(), Kind: v1alpha1.BackendKindFirecrackerVM},
ObjectMeta: metav1.ObjectMeta{Name: vm.Spec.BackendRef.Name, Labels: commonv1.ContractLabels(commonv1.ContractComputeVMs),
OwnerReferences: []metav1.OwnerReference{{APIVersion: v1alpha1.GroupVersion.String(), Kind: "ComputeVM", Name: vm.Name, UID: vm.UID,
Controller: &ctrl, BlockOwnerDeletion: &ctrl}}},
Spec: spec,
}
if err := req.Apply(ctx, fvm); err != nil {
return nil, err
}
if have == nil {
c.log.Info("the FirecrackerVM backend is created", "computevm", vm.Name, "firecrackervm", fvm.Name)
}
return c.backend(ctx, req, vm)
}
func hasOwner(fvm *v1alpha1.FirecrackerVM, vm *v1alpha1.ComputeVM) bool {
for _, o := range fvm.OwnerReferences {
if o.UID == vm.UID && o.Controller != nil && *o.Controller {
return true
}
}
return false
}
func mirror(st v1alpha1.ComputeVMStatus, gen int64, fvm *v1alpha1.FirecrackerVM) v1alpha1.ComputeVMStatus {
st.Conditions = append([]metav1.Condition(nil), st.Conditions...)
st.ObservedGeneration = gen
if fvm == nil {
st.Phase, st.LostReason, st.Addresses, st.BootedAt = v1alpha1.ComputeVMPhasePending, "", nil, ""
setCondition(&st, gen, v1alpha1.ComputeVMConditionReady, false, "BackendPending", "the backend is not created yet")
return st
}
b := fvm.Status
st.Phase, st.LostReason, st.BootedAt, st.Message = b.Phase, b.LostReason, b.BootedAt, b.Message
if st.Phase == "" {
st.Phase = v1alpha1.ComputeVMPhasePending
}
st.Addresses = nil
if n := b.Network; n != nil && (n.GuestIP != "" || n.HostAddress != "") {
st.Addresses = &v1alpha1.ComputeVMAddresses{Guest: n.GuestIP, Host: n.HostAddress}
}
ready := false
reason, msg := "BackendNotReady", "the FirecrackerVM "+fvm.Name+" is not Ready"
if c := apimeta.FindStatusCondition(b.Conditions, v1alpha1.FirecrackerVMConditionReady); c != nil && b.ObservedGeneration == fvm.Generation {
ready = c.Status == metav1.ConditionTrue
reason, msg = c.Reason, c.Message
}
setCondition(&st, gen, v1alpha1.ComputeVMConditionReady, ready, reason, msg)
return st
}
func (c *Controller) write(ctx context.Context, req ctlruntime.Request, vm *v1alpha1.ComputeVM, st v1alpha1.ComputeVMStatus) error {
st.Message = computevm.CapMessage(st.Message)
prev := vm.Status.Phase
if reflect.DeepEqual(vm.Status, st) {
return nil
}
next := vm.DeepCopy()
next.Status = st
next.Status.Market = nil
if err := req.ApplyStatus(ctx, next); err != nil {
return err
}
if prev != st.Phase {
c.log.Info("phase", "computevm", vm.Name, "from", string(prev), "to", string(st.Phase), "lostReason", string(st.LostReason),
"message", st.Message)
}
return nil
}
func now() string { return time.Now().UTC().Format(time.RFC3339) }
func (c *Controller) declare(ctx context.Context, req ctlruntime.Request, drop string) {
var list v1alpha1.ComputeVMList
if err := req.List(ctx, &list); err != nil {
c.log.Warn("listing the ComputeVMs to declare their guest material", "err", err.Error())
return
}
names := make([]string, 0, len(list.Items))
for _, vm := range list.Items {
if isSandbox(&vm) {
continue
}
if vm.Spec.Owner.Handle == c.handle && vm.Name != drop {
names = append(names, vm.Name)
}
}
if err := c.host.DeclareGuests(ctx, names); err != nil {
c.log.Warn("declaring the live guests' material in the bidder's vault", "err", err.Error())
}
}
func (c *Controller) Reconcile(ctx context.Context, req ctlruntime.Request, vm *v1alpha1.ComputeVM) (ctlruntime.Result, error) {
c.declare(ctx, req, "")
if !vm.DeletionTimestamp.IsZero() {
return c.release(ctx, req, vm)
}
st := vm.Status
st.Conditions = append([]metav1.Condition(nil), st.Conditions...)
if isSandbox(vm) {
return c.reconcileSandbox(ctx, req, vm)
}
if !backendSupported(vm) {
setCondition(&st, vm.Generation, v1alpha1.ComputeVMConditionBackendBound, false, "UnsupportedBackend",
fmt.Sprintf("spec.backendRef names %s/%s; this host runs FirecrackerVM", vm.Spec.BackendRef.Kind, vm.Spec.BackendRef.Name))
setCondition(&st, vm.Generation, v1alpha1.ComputeVMConditionReady, false, "UnsupportedBackend", "no backend is bound")
return ctlruntime.Result{}, c.write(ctx, req, vm, st)
}
if computevm.ReleaseRequested(vm) {
return c.deleteOnRequest(ctx, req, vm)
}
have, err := c.backend(ctx, req, vm)
if err != nil {
return ctlruntime.Result{}, err
}
if have == nil {
if err := c.host.EnsureGuestLogin(ctx, *vm); err != nil {
if computevm.RefusedLogin(err) {
st.Phase, st.Message = v1alpha1.ComputeVMPhaseFailed, err.Error()
setCondition(&st, vm.Generation, v1alpha1.ComputeVMConditionReady, false, "GuestLoginRefused", err.Error())
return ctlruntime.Result{}, c.write(ctx, req, vm, st)
}
st.Phase, st.Message = v1alpha1.ComputeVMPhasePending, "waiting for the guest login role: "+err.Error()
if werr := c.write(ctx, req, vm, st); werr != nil {
return ctlruntime.Result{}, werr
}
return ctlruntime.Result{}, err
}
}
fvm, err := c.bind(ctx, req, vm, have)
if err != nil {
setCondition(&st, vm.Generation, v1alpha1.ComputeVMConditionBackendBound, false, "BindFailed", err.Error())
if werr := c.write(ctx, req, vm, st); werr != nil {
return ctlruntime.Result{}, werr
}
return ctlruntime.Result{}, err
}
st = mirror(st, vm.Generation, fvm)
if fvm != nil {
setCondition(&st, vm.Generation, v1alpha1.ComputeVMConditionBackendBound, true, "Bound", "FirecrackerVM "+fvm.Name)
} else {
setCondition(&st, vm.Generation, v1alpha1.ComputeVMConditionBackendBound, false, "BackendMissing", "FirecrackerVM "+vm.Spec.BackendRef.Name+" does not exist")
}
if computevm.Ended(&v1alpha1.ComputeVM{Status: st}) {
if err := c.host.EnsureTerminationSync(ctx, *vm, computevm.GoneReason(st.LostReason), now(), nil); err != nil {
c.log.Warn("creating the termination StateSync of an ended ComputeVM failed", "computevm", vm.Name, "err", err.Error())
}
}
return ctlruntime.Result{}, c.write(ctx, req, vm, st)
}
func (c *Controller) deleteOnRequest(ctx context.Context, req ctlruntime.Request, vm *v1alpha1.ComputeVM) (ctlruntime.Result, error) {
observedAt := computevm.ReleaseRequestedAt(vm)
if observedAt == "" {
observedAt = now()
}
if err := c.host.EnsureTerminationSync(ctx, *vm, computevm.ReleaseReason(vm), observedAt, computevm.ReleaseRequestRef(vm)); err != nil {
return ctlruntime.Result{}, err
}
c.log.Info("the creator asks for the release; the ComputeVM is deleted and its finalizer releases the backend", "computevm", vm.Name, "backend", vm.Spec.BackendRef.Kind)
return ctlruntime.Result{}, req.Delete(ctx, vm)
}
func (c *Controller) release(ctx context.Context, req ctlruntime.Request, vm *v1alpha1.ComputeVM) (ctlruntime.Result, error) {
observedAt := computevm.ReleaseRequestedAt(vm)
if observedAt == "" {
observedAt = vm.DeletionTimestamp.UTC().Format(time.RFC3339)
}
if err := c.host.EnsureTerminationSync(ctx, *vm, computevm.ReleaseReason(vm), observedAt, computevm.ReleaseRequestRef(vm)); err != nil {
return ctlruntime.Result{}, err
}
fvm, err := c.backend(ctx, req, vm)
if err != nil {
return ctlruntime.Result{}, err
}
st := mirror(vm.Status, vm.Generation, fvm)
if fvm != nil {
if st.Phase != v1alpha1.ComputeVMPhaseReleasing {
st.Phase, st.Message = v1alpha1.ComputeVMPhaseReleasing, "the backend "+fvm.Name+" is released"
}
if err := c.write(ctx, req, vm, st); err != nil {
return ctlruntime.Result{}, err
}
if fvm.DeletionTimestamp.IsZero() {
if err := req.Delete(ctx, fvm); err != nil {
return ctlruntime.Result{}, err
}
c.log.Info("the FirecrackerVM backend is deleted; its controller stops the VM", "computevm", vm.Name, "firecrackervm", fvm.Name)
}
return ctlruntime.Result{Waiting: true}, nil
}
c.host.DropGuestLogin(ctx, *vm)
c.host.DropGuestGrants(ctx, vm.Name)
c.declare(ctx, req, vm.Name)
c.log.Info("released: the backend is gone and the finalizer is dropped", "computevm", vm.Name)
return ctlruntime.Result{}, nil
}