0
0
package firecrackervm
import (
"context"
"fmt"
"log/slog"
"sync"
"time"
"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"
)
const (
Name = "firecrackervm"
Export = "computevms"
Workers = 8
)
type Controller struct {
p *firecracker.Provider
host *computevm.Host
placement *Placement
log *slog.Logger
events chan ctlruntime.Request
life context.Context
end context.CancelFunc
mu sync.Mutex
clusters map[string]string
ended map[string]bool
}
func Register(ctx context.Context, m *ctlruntime.Manager, p *firecracker.Provider, host *computevm.Host, placement *Placement) (*Controller, error) {
life, end := context.WithCancel(ctx)
ctl := &Controller{p: p, host: host, placement: placement, log: host.Log().With("controller", Name), events: make(chan ctlruntime.Request, 256),
life: life, end: end, clusters: map[string]string{}, ended: map[string]bool{}}
handle := p.Handle()
if err := ctlruntime.For[*v1alpha1.FirecrackerVM](m, Name, ctl, ctlruntime.Export(Export),
ctlruntime.Finalizer(v1alpha1.FinalizerFirecrackerVM), ctlruntime.Workers(Workers), ctlruntime.Events(ctl.events),
ctlruntime.Only(func(vm *v1alpha1.FirecrackerVM) bool { return vm.Spec.Owner.Handle == handle })); err != nil {
end()
return nil, fmt.Errorf("firecrackervm: registering the FirecrackerVM controller: %w", err)
}
return ctl, nil
}
func (c *Controller) remember(name, cluster string) {
c.mu.Lock()
defer c.mu.Unlock()
c.clusters[name] = cluster
}
func (c *Controller) forget(name string) {
c.mu.Lock()
defer c.mu.Unlock()
delete(c.clusters, name)
}
func (c *Controller) markEnded(uid string, ended bool) bool {
c.mu.Lock()
defer c.mu.Unlock()
if ended {
c.ended[uid] = true
return true
}
return c.ended[uid]
}
func (c *Controller) dropEnded(uid string) {
c.mu.Lock()
defer c.mu.Unlock()
delete(c.ended, uid)
}
func (c *Controller) clusterOf(name string) (string, bool) {
c.mu.Lock()
defer c.mu.Unlock()
cl, ok := c.clusters[name]
return cl, ok
}
func (c *Controller) Run(ctx context.Context) error {
defer close(c.events)
defer c.end()
sweep := time.NewTimer(c.host.Config().Grace())
defer sweep.Stop()
exits := c.p.VMMExits()
for ctx.Err() == nil {
names, err := c.p.Watch(ctx)
var retry <-chan time.Time
if err != nil {
c.log.Warn("watching the VM units; the watch is opened again", "err", err.Error(), "after", computevm.RetryAfter.String())
retry = time.After(computevm.RetryAfter)
}
events:
for {
select {
case <-ctx.Done():
return nil
case <-sweep.C:
c.sweep(ctx)
case <-retry:
break events
case name := <-exits:
if !c.enqueue(ctx, name) {
return nil
}
case name, ok := <-names:
if !ok {
break events
}
if !c.enqueue(ctx, name) {
return nil
}
}
}
}
return nil
}
func (c *Controller) enqueue(ctx context.Context, name string) bool {
cluster, known := c.clusterOf(name)
if !known {
return true
}
select {
case c.events <- ctlruntime.Request{Cluster: cluster, Name: name}:
return true
case <-ctx.Done():
return false
}
}
func (c *Controller) sweep(ctx context.Context) {
for _, l := range c.p.Listed(ctx) {
if ok, err := c.placement.exists(ctx, l.Name); ok || err != nil {
continue
}
c.log.Warn("a VM unit or work dir with no FirecrackerVM of this handle outlived the grace; collecting it", "name", l.Name,
"unit", l.Unit, "loaded", l.Loaded, "state", string(l.Status.State), "workDir", l.WorkDir)
if err := c.p.Collect(ctx, l); err != nil {
c.log.Warn("collecting an orphan VM", "name", l.Name, "err", err.Error())
}
}
c.placement.collectChildren(ctx, c.p.Live)
c.mu.Lock()
none := len(c.clusters) == 0
c.mu.Unlock()
if none {
c.p.DropSlice(ctx)
}
}
func (c *Controller) live(ctx context.Context, req ctlruntime.Request) ([]v1alpha1.FirecrackerVM, error) {
var list v1alpha1.FirecrackerVMList
if err := req.List(ctx, &list); err != nil {
return nil, err
}
out := list.Items[:0]
for _, vm := range list.Items {
if vm.Spec.Owner.Handle == c.p.Handle() && vm.DeletionTimestamp.IsZero() {
out = append(out, vm)
}
}
return out, nil
}
func (c *Controller) collectImages(ctx context.Context, req ctlruntime.Request) {
vms, err := c.live(ctx, req)
if err != nil {
return
}
keep := map[string]string{}
for _, vm := range vms {
if img := vm.Status.Image; img != nil && img.Sha256 != "" {
keep[img.Sha256] = "the FirecrackerVM " + vm.Name + " names it"
}
}
c.p.CollectImages(ctx, keep)
}
func (c *Controller) write(ctx context.Context, req ctlruntime.Request, vm *v1alpha1.FirecrackerVM, st v1alpha1.FirecrackerVMStatus) error {
prev := vm.Status.Phase
vm.Status = firecracker.Finish(st, vm.Generation)
if err := req.ApplyStatus(ctx, vm); err != nil {
return err
}
if prev != vm.Status.Phase {
c.log.Info("phase", "firecrackervm", vm.Name, "from", string(prev), "to", string(vm.Status.Phase),
"lostReason", string(vm.Status.LostReason), "message", vm.Status.Message)
}
return nil
}
func (c *Controller) Reconcile(ctx context.Context, req ctlruntime.Request, vm *v1alpha1.FirecrackerVM) (ctlruntime.Result, error) {
if !vm.DeletionTimestamp.IsZero() {
if vm.Status.Phase != v1alpha1.ComputeVMPhaseReleasing {
st := vm.Status
st.Phase, st.Message = v1alpha1.ComputeVMPhaseReleasing, "graceful stop, then the work dir goes"
if err := c.write(ctx, req, vm, st); err != nil {
return ctlruntime.Result{}, err
}
}
if err := c.p.Teardown(ctx, vm); err != nil {
return ctlruntime.Result{}, err
}
c.forget(vm.Name)
c.dropEnded(string(vm.UID))
c.collectImages(ctx, req)
c.mu.Lock()
none := len(c.clusters) == 0
c.mu.Unlock()
if none {
c.p.DropSlice(ctx)
}
return ctlruntime.Result{}, nil
}
c.remember(vm.Name, req.Cluster)
if c.markEnded(string(vm.UID), false) {
return ctlruntime.Result{}, nil
}
switch vm.Status.Phase {
case v1alpha1.ComputeVMPhaseLost, v1alpha1.ComputeVMPhaseFailed:
return ctlruntime.Result{}, nil
case v1alpha1.ComputeVMPhaseRunning:
err := c.write(ctx, req, vm, c.p.Observe(ctx, vm))
if err == nil && vm.Status.Phase == v1alpha1.ComputeVMPhaseRunning {
err = c.p.Rewire(ctx, vm)
}
c.follow(vm)
return ctlruntime.Result{}, err
}
st, err := c.p.Boot(ctx, vm, func(st v1alpha1.FirecrackerVMStatus) error { return c.write(ctx, req, vm, st) })
werr := c.write(ctx, req, vm, st)
switch st.Phase {
case v1alpha1.ComputeVMPhaseLost, v1alpha1.ComputeVMPhaseFailed:
c.markEnded(string(vm.UID), true)
if err != nil {
c.log.Warn("the boot failed; the FirecrackerVM stays Failed and is not booted again", "firecrackervm", vm.Name, "err", err.Error())
}
return ctlruntime.Result{}, werr
}
if werr != nil && err == nil {
err = werr
}
if err == nil && vm.Status.Phase == v1alpha1.ComputeVMPhaseRunning {
err = c.p.Rewire(ctx, vm)
}
c.follow(vm)
return ctlruntime.Result{}, err
}
func (c *Controller) follow(vm *v1alpha1.FirecrackerVM) {
if vm.Status.Phase == v1alpha1.ComputeVMPhaseRunning {
c.p.Follow(c.life, vm)
}
}