0
0
package policyaction
import (
"bytes"
"context"
"encoding/json"
"errors"
"fmt"
"io"
"strings"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
policyv1alpha1 "github.com/johnandersen777/socialweb-computer-kcp/api/policy/v1alpha1"
"github.com/johnandersen777/socialweb-computer-kcp/api/v1alpha1"
"github.com/johnandersen777/socialweb-computer-kcp/internal/computevm"
commonv1 "github.com/johnandersen777/socialweb-computer-kcp/api/common/v1alpha1"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kcplibs/common/ref"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kcplibs/impl/kcpstore"
"github.com/johnandersen777/socialweb-computer-kcp/internal/policyengine/controller"
)
const ContractFieldManager = "socialweb.computer/policyaction/contract"
var (
ErrNoStore = errors.New("policyaction: a kcp store is required")
ErrNoSpec = errors.New("policyaction: the ComputeVM action spec is required")
)
type ComputeVMSpec struct {
Workspace string `json:"workspace,omitempty"`
Name string `json:"name"`
Owner string `json:"owner"`
Contract *v1alpha1.ComputeVMContract `json:"contract,omitempty"`
VM v1alpha1.ComputeVMShape `json:"vm"`
Requester v1alpha1.ComputeVMRequester `json:"requester"`
Vault ComputeVMVaultRef `json:"vault"`
ReuseStale bool `json:"reuseStale,omitempty"`
StopGraceSeconds int32 `json:"stopGraceSeconds,omitempty"`
GuestLogin *v1alpha1.ComputeVMGuestLogin `json:"guestLogin,omitempty"`
Accept *ComputeVMAcceptRef `json:"accept,omitempty"`
}
type ComputeVMVaultRef struct {
Server string `json:"server"`
Mount string `json:"mount"`
}
type ComputeVMAcceptRef struct {
Uri string `json:"uri"`
Cid string `json:"cid"`
}
type ComputeVMHandler struct {
Store *kcpstore.Store
Workspace string
}
func NewComputeVMHandler(store *kcpstore.Store, workspace string) (*ComputeVMHandler, error) {
if store == nil {
return nil, ErrNoStore
}
return &ComputeVMHandler{Store: store, Workspace: strings.TrimSpace(workspace)}, nil
}
func (h *ComputeVMHandler) Kind() string {
return controller.TriggerActionComputeVM
}
func (h *ComputeVMHandler) Dispatch(ctx context.Context, spec json.RawMessage, _ controller.Outcome) error {
if h == nil || h.Store == nil {
return ErrNoStore
}
decoded, err := decodeComputeVMSpec(spec)
if err != nil {
return err
}
workspace := strings.TrimSpace(decoded.Workspace)
if workspace == "" {
workspace = strings.TrimSpace(h.Workspace)
}
if err := validateWorkspace(workspace); err != nil {
return err
}
name := strings.TrimSpace(decoded.Name)
if name == "" {
return errors.New("policyaction: the ComputeVM action spec names no name")
}
owner := strings.TrimSpace(decoded.Owner)
if owner == "" {
return errors.New("policyaction: the ComputeVM action spec names no owner")
}
input := computevm.VMInput{
Name: name,
Handle: owner,
VM: decoded.VM,
RequesterDID: strings.TrimSpace(decoded.Requester.Did),
Vault: computevm.GuestVaultRef{Server: strings.TrimSpace(decoded.Vault.Server), Mount: strings.TrimSpace(decoded.Vault.Mount)},
ReuseStale: decoded.ReuseStale,
StopGraceSeconds: decoded.StopGraceSeconds,
GuestLogin: decoded.GuestLogin,
Contract: decoded.Contract,
}
if decoded.Accept != nil {
input.Accept = &computevm.AcceptRef{URI: strings.TrimSpace(decoded.Accept.Uri), CID: strings.TrimSpace(decoded.Accept.Cid)}
}
if err := computevm.ValidateVMInput(input); err != nil {
return fmt.Errorf("policyaction: the ComputeVM action spec: %w", err)
}
vm := &v1alpha1.ComputeVM{
TypeMeta: metav1.TypeMeta{APIVersion: v1alpha1.GroupVersion.String(), Kind: "ComputeVM"},
ObjectMeta: metav1.ObjectMeta{Name: input.Name},
Spec: v1alpha1.ComputeVMSpec{
BackendRef: computevm.BackendRef(input.Name),
VM: input.VM,
Owner: v1alpha1.ComputeVMOwner{Handle: input.Handle},
UserData: v1alpha1.ComputeVMUserData{Vault: computevm.UserDataRef(input.Name, input.Vault)},
Requester: v1alpha1.ComputeVMRequester{Did: input.RequesterDID, Plc: strings.TrimSpace(decoded.Requester.Plc)},
},
}
if input.Accept != nil && input.Accept.Key() != "" {
vm.Spec.Accept = &commonv1.StrongRef{URI: input.Accept.URI, CID: input.Accept.CID}
}
if input.Contract != nil {
contract := *input.Contract
vm.Spec.Contract = &contract
}
if input.ReuseStale {
vm.Spec.Image = &v1alpha1.ComputeVMImageRequest{ReuseStale: true}
}
if input.StopGraceSeconds > 0 {
vm.Spec.StopGraceSeconds = input.StopGraceSeconds
}
if input.GuestLogin != nil {
login := *input.GuestLogin
vm.Spec.GuestLogin = &login
}
return h.ensure(ctx, workspace, vm)
}
func (h *ComputeVMHandler) DispatchComputeVM(ctx context.Context, action policyv1alpha1.PolicyAction, outcome controller.Outcome) error {
return h.Dispatch(ctx, action.Spec, outcome)
}
func (h *ComputeVMHandler) ensure(ctx context.Context, workspace string, vm *v1alpha1.ComputeVM) error {
resource := kcpstore.OfClusterScoped[v1alpha1.ComputeVM](h.Store, computevm.GVR)
target := ref.New(workspace, "", vm.Name)
existing, err := resource.Get(ctx, target)
if err == nil {
return ensureExisting(ctx, resource, target, existing, vm)
}
if !kcpstore.IsNotFound(err) {
return fmt.Errorf("policyaction: read ComputeVM %s in %s: %w", vm.Name, workspace, err)
}
if err := resource.Create(ctx, workspace, vm); err != nil {
return fmt.Errorf("policyaction: create ComputeVM %s in %s: %w", vm.Name, workspace, err)
}
return nil
}
func ensureExisting(ctx context.Context, resource *kcpstore.Resource[v1alpha1.ComputeVM], target ref.Ref, existing, wanted *v1alpha1.ComputeVM) error {
if existing.DeletionTimestamp != nil {
return fmt.Errorf("policyaction: ComputeVM %s in %s is terminating", existing.Name, target.LogicalCluster)
}
if existing.Spec.Owner.Handle != wanted.Spec.Owner.Handle {
return fmt.Errorf("policyaction: ComputeVM %s in %s belongs to owner %q, not %q",
existing.Name, target.LogicalCluster, existing.Spec.Owner.Handle, wanted.Spec.Owner.Handle)
}
if wanted.Spec.Contract == nil {
return nil
}
if existing.Spec.Contract != nil {
if *existing.Spec.Contract == *wanted.Spec.Contract {
return nil
}
return fmt.Errorf("policyaction: ComputeVM %s in %s already carries a different contract", existing.Name, target.LogicalCluster)
}
body, err := json.Marshal(map[string]any{"apiVersion": v1alpha1.GroupVersion.String(), "kind": "ComputeVM",
"metadata": map[string]any{"name": existing.Name, "uid": string(existing.UID)}, "spec": map[string]any{"contract": wanted.Spec.Contract}})
if err != nil {
return fmt.Errorf("policyaction: encode the contract of ComputeVM %s: %w", existing.Name, err)
}
if err := resource.Apply(ctx, target, body, ContractFieldManager); err != nil {
return fmt.Errorf("policyaction: set the contract of ComputeVM %s in %s: %w", existing.Name, target.LogicalCluster, err)
}
return nil
}
func decodeComputeVMSpec(raw json.RawMessage) (ComputeVMSpec, error) {
if len(bytes.TrimSpace(raw)) == 0 {
return ComputeVMSpec{}, ErrNoSpec
}
if bytes.Equal(bytes.TrimSpace(raw), []byte("null")) {
return ComputeVMSpec{}, ErrNoSpec
}
decoder := json.NewDecoder(bytes.NewReader(raw))
decoder.DisallowUnknownFields()
var spec ComputeVMSpec
if err := decoder.Decode(&spec); err != nil {
return ComputeVMSpec{}, fmt.Errorf("policyaction: decode the ComputeVM action spec: %w", err)
}
var extra any
if err := decoder.Decode(&extra); err != io.EOF {
if err == nil {
return ComputeVMSpec{}, errors.New("policyaction: the ComputeVM action spec holds more than one JSON value")
}
return ComputeVMSpec{}, fmt.Errorf("policyaction: decode the ComputeVM action spec: %w", err)
}
return spec, nil
}
func validateWorkspace(workspace string) error {
switch {
case workspace == "":
return errors.New("policyaction: the ComputeVM action names no target workspace")
case workspace == "." || workspace == "..":
return fmt.Errorf("policyaction: %q is not a target workspace", workspace)
case strings.ContainsAny(workspace, "/\\"):
return fmt.Errorf("policyaction: %q is not a target workspace", workspace)
}
for _, r := range workspace {
if r <= ' ' || r == 127 {
return fmt.Errorf("policyaction: %q is not a target workspace", workspace)
}
}
return nil
}