package opsread import ( "context" "errors" "fmt" "strings" "time" apierrors "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime/schema" "sigs.k8s.io/controller-runtime/pkg/client" commonv1 "github.com/johnandersen777/socialweb-computer-kcp/api/common/v1alpha1" "github.com/johnandersen777/socialweb-computer-kcp/api/v1alpha1" "github.com/johnandersen777/socialweb-computer-kcp/internal/bus" contract "github.com/johnandersen777/socialweb-computer-kcp/internal/contract/opsread" ) const ( KindBidder = "Bidder" KindMarketIdentity = "MarketIdentity" KindMarketBidder = "MarketBidder" ) type Options struct { Bus *bus.Bus Clients func(workspace string) (client.Client, error) } type reader struct { clients func(workspace string) (client.Client, error) owner commonv1.ObjectRef } var _ contract.Objects = (*reader)(nil) func Register(opts Options) error { if opts.Bus == nil { return errors.New("opsread: the bus is required") } if opts.Clients == nil { return errors.New("opsread: the workspace clients are required") } bus.Provide[contract.Objects](opts.Bus, schema.GroupKind{Group: v1alpha1.GroupName, Kind: KindBidder}, contract.CapabilityObjects, func(_ context.Context, to commonv1.ObjectRef, _ []string) (contract.Objects, error) { if strings.TrimSpace(to.Workspace) == "" || strings.TrimSpace(to.Name) == "" { return nil, fmt.Errorf("opsread: %s names no component", to.String()) } return &reader{clients: opts.Clients, owner: to}, nil }) return nil } func meta(o metav1.Object) contract.Meta { out := contract.Meta{Name: o.GetName()} if t := o.GetDeletionTimestamp(); t != nil && !t.IsZero() { out.DeletionTimestamp = t.UTC().Format(time.RFC3339) } return out } func vmOf(o *v1alpha1.ComputeVM) contract.VM { out := contract.VM{Metadata: meta(o), Status: contract.VMStatus{Phase: string(o.Status.Phase), LostReason: string(o.Status.LostReason)}} out.Spec.VM.Cpus = o.Spec.VM.Cpus out.Spec.Requester.Did = o.Spec.Requester.Did if o.Spec.Contract != nil { out.Spec.Contract = &contract.VMContract{Receipt: contract.VMReceipt{URI: o.Spec.Contract.Receipt.URI}} } return out } func identityStatus(in v1alpha1.MarketIdentityStatus) contract.IdentityStatus { out := contract.IdentityStatus{Phase: string(in.Phase)} if action := in.PendingAction; action != nil { out.PendingAction = &contract.PendingAction{Kind: string(action.Kind), Reason: action.Reason} } for _, c := range in.Conditions { out.Conditions = append(out.Conditions, contract.Condition{Type: c.Type, Status: string(c.Status), Reason: c.Reason}) } return out } func (r *reader) client() (client.Client, error) { return r.clients(r.owner.Workspace) } func (r *reader) VMs(ctx context.Context) ([]contract.VM, error) { cl, err := r.client() if err != nil { return nil, err } list := &v1alpha1.ComputeVMList{} if err := cl.List(ctx, list); err != nil { return nil, err } out := make([]contract.VM, 0, len(list.Items)) for i := range list.Items { out = append(out, vmOf(&list.Items[i])) } return out, nil } func found(err error) (bool, error) { if err == nil { return true, nil } if apierrors.IsNotFound(err) { return false, nil } return false, err } func (r *reader) VM(ctx context.Context, name string) (contract.VMDetail, error) { var out contract.VMDetail if !contract.ValidVMName(name) { return out, contract.ErrInvalid } cl, err := r.client() if err != nil { return out, err } vm := &v1alpha1.ComputeVM{} if ok, err := found(cl.Get(ctx, client.ObjectKey{Name: name}, vm)); err != nil { return out, err } else if ok { v := vmOf(vm) out.ComputeVM = &v } fc := &v1alpha1.FirecrackerVM{} if ok, err := found(cl.Get(ctx, client.ObjectKey{Name: name}, fc)); err != nil { return out, err } else if ok { status := contract.FirecrackerVMStatus{Phase: string(fc.Status.Phase), LostReason: string(fc.Status.LostReason)} if image := fc.Status.Image; image != nil { status.Image = &contract.VMImage{Sha256: image.Sha256, Fetched: image.Fetched} } out.FirecrackerVM = &contract.FirecrackerVM{Metadata: meta(fc), Status: status} } return out, nil } func (r *reader) Bidder(ctx context.Context) (contract.BidderState, error) { var out contract.BidderState cl, err := r.client() if err != nil { return out, err } bidder := &v1alpha1.Bidder{} if ok, err := found(cl.Get(ctx, client.ObjectKey{Name: r.owner.Name}, bidder)); err != nil { return out, err } else if !ok { return out, nil } out.Bidder = &contract.BidderComponent{Metadata: meta(bidder), Spec: contract.BidderSpec{Policy: bidder.Spec.Policy}} if id := bidder.Spec.Identity; id != nil && id.MarketIdentityRef != nil && id.MarketIdentityRef.Kind == KindMarketIdentity { identity := &v1alpha1.MarketIdentity{} if ok, err := found(cl.Get(ctx, client.ObjectKey{Name: id.MarketIdentityRef.Name}, identity)); err != nil { return out, err } else if ok { out.Identity = &contract.Identity{Metadata: meta(identity), Status: identityStatus(identity.Status)} } } for _, ref := range bidder.GetOwnerReferences() { if ref.Kind != KindMarketBidder { continue } root := &v1alpha1.MarketBidder{} if ok, err := found(cl.Get(ctx, client.ObjectKey{Name: ref.Name}, root)); err != nil { return out, err } else if ok { out.MarketBidder = &contract.MarketBidder{Metadata: meta(root), Status: contract.MarketBidderStatus{Phase: string(root.Status.Phase), Did: root.Status.Did}} } } return out, nil }