0
0
package firecrackervm
import (
"context"
"fmt"
"log/slog"
"strconv"
apierrors "k8s.io/apimachinery/pkg/api/errors"
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"
"github.com/johnandersen777/socialweb-computer-kcp/internal/contract/host"
"github.com/johnandersen777/socialweb-computer-kcp/internal/controllers/runtime/kube"
"github.com/johnandersen777/socialweb-computer-kcp/internal/hostprocess"
)
var _ firecracker.Placement = (*Placement)(nil)
type Placement struct {
hps kube.Resource
backends kube.Resource
log *slog.Logger
}
func NewPlacement(h *computevm.Host) *Placement {
return &Placement{hps: h.HostProcesses, backends: h.Backends, log: h.Log().With("placement", "hostprocess")}
}
func (p *Placement) child(ctx context.Context, name string) (*v1alpha1.HostProcess, error) {
hp, err := kube.Get[v1alpha1.HostProcess](ctx, p.hps, computevm.ChildName(name))
if apierrors.IsNotFound(err) {
return nil, nil
}
return hp, err
}
func (p *Placement) Place(ctx context.Context, vm *v1alpha1.FirecrackerVM, slot int, spec host.UnitSpec) error {
ctrl := true
hp := v1alpha1.HostProcess{ObjectMeta: metav1.ObjectMeta{Name: computevm.ChildName(vm.Name),
Labels: map[string]string{computevm.LabelComputeVM: vm.Name, computevm.LabelSlot: strconv.Itoa(slot)},
Finalizers: []string{v1alpha1.FinalizerFirecrackerVM},
OwnerReferences: []metav1.OwnerReference{{APIVersion: v1alpha1.GroupVersion.String(), Kind: v1alpha1.BackendKindFirecrackerVM,
Name: vm.Name, UID: vm.UID, Controller: &ctrl}}},
Spec: hostprocess.SpecOf(spec)}
hp.Spec.Description = spec.Description
if _, err := kube.Create[v1alpha1.HostProcess](ctx, p.hps, &hp, metav1.CreateOptions{}); err != nil {
return fmt.Errorf("firecrackervm: creating the HostProcess child %s: %w", hp.Name, err)
}
p.log.Info("HostProcess child created", "firecrackervm", vm.Name, "hostprocess", hp.Name, "unit", spec.Name, "slot", slot)
return nil
}
func (p *Placement) Placed(ctx context.Context, name string) (int, bool, error) {
hp, err := p.child(ctx, name)
if err != nil || hp == nil {
return 0, false, err
}
k, err := strconv.Atoi(hp.Labels[computevm.LabelSlot])
if err != nil || k < 0 {
return 0, true, nil
}
return k, true, nil
}
func (p *Placement) Unplace(ctx context.Context, name string) error {
hp, err := p.child(ctx, name)
if err != nil || hp == nil || hp.DeletionTimestamp != nil {
return err
}
if err := p.hps.Delete(ctx, computevm.ChildName(name), metav1.DeleteOptions{}); err != nil && !apierrors.IsNotFound(err) {
return err
}
p.log.Info("HostProcess child deleted; its supervisor stops the unit", "firecrackervm", name)
return nil
}
func (p *Placement) Settle(ctx context.Context, name string) error {
hp, err := p.child(ctx, name)
if err != nil || hp == nil {
return err
}
return p.dropFinalizer(ctx, hp)
}
func (p *Placement) dropFinalizer(ctx context.Context, cu *v1alpha1.HostProcess) error {
fin := cu.Finalizers
keep := fin[:0:0]
for _, f := range fin {
if f != v1alpha1.FinalizerFirecrackerVM && f != v1alpha1.FinalizerComputeVM {
keep = append(keep, f)
}
}
if len(keep) == len(fin) {
return nil
}
next := cu.DeepCopy()
next.Finalizers = keep
_, err := kube.Update[v1alpha1.HostProcess](ctx, p.hps, next, metav1.UpdateOptions{})
if apierrors.IsNotFound(err) {
return nil
}
return err
}
func (p *Placement) exists(ctx context.Context, name string) (bool, error) {
_, err := kube.Get[v1alpha1.FirecrackerVM](ctx, p.backends, name)
if apierrors.IsNotFound(err) {
return false, nil
}
return err == nil, err
}
func (p *Placement) collectChildren(ctx context.Context, live func(ctx context.Context, name string) (bool, error)) {
children, err := kube.List[v1alpha1.HostProcess](ctx, p.hps, metav1.ListOptions{LabelSelector: computevm.LabelComputeVM})
if err != nil {
return
}
for i := range children {
c := &children[i]
owner := c.Labels[computevm.LabelComputeVM]
if ok, err := p.exists(ctx, owner); ok || err != nil {
continue
}
if c.DeletionTimestamp == nil {
p.hps.Delete(ctx, c.Name, metav1.DeleteOptions{})
}
if running, err := live(ctx, owner); err == nil && !running {
p.dropFinalizer(ctx, c)
p.log.Info("a HostProcess child with no FirecrackerVM is removed", "hostprocess", c.Name)
}
}
}