0
0
package main
import (
"context"
"fmt"
"path/filepath"
"strings"
"time"
apierrors "k8s.io/apimachinery/pkg/api/errors"
"k8s.io/apimachinery/pkg/api/meta"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime/schema"
"k8s.io/client-go/rest"
"github.com/johnandersen777/socialweb-computer-kcp/api/v1alpha1"
"github.com/johnandersen777/socialweb-computer-kcp/internal/app/compose"
"github.com/johnandersen777/socialweb-computer-kcp/internal/app/marketnetwork"
"github.com/johnandersen777/socialweb-computer-kcp/internal/bootstrap"
"github.com/johnandersen777/socialweb-computer-kcp/internal/clicfg"
"github.com/johnandersen777/socialweb-computer-kcp/internal/controllers/runtime/kube"
"github.com/johnandersen777/socialweb-computer-kcp/internal/devinstance"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kcpserver"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/fsx"
)
const appStatusTimeout = 10 * time.Second
type rootStatusView struct {
Kind string `json:"kind"`
Name string `json:"name"`
Phase v1alpha1.ApplicationPhase `json:"phase,omitempty"`
Message string `json:"message,omitempty"`
Market *v1alpha1.MarketLoopStatus `json:"market,omitempty"`
Store *v1alpha1.StoreUsage `json:"store,omitempty"`
GC *v1alpha1.GCStatus `json:"gc,omitempty"`
TTL *v1alpha1.TTLStatus `json:"ttl,omitempty"`
Quotas []v1alpha1.QuotaUsage `json:"quotas,omitempty"`
}
type contractStatusView struct {
Name string `json:"name"`
Phase v1alpha1.ComputeContractPhase `json:"phase,omitempty"`
Message string `json:"message,omitempty"`
Execution *v1alpha1.ExecutionStatus `json:"execution,omitempty"`
Winner string `json:"winner,omitempty"`
}
type appStatusView struct {
App string `json:"app"`
Instance string `json:"instance"`
Roots []rootStatusView `json:"roots,omitempty"`
Contracts []contractStatusView `json:"contracts,omitempty"`
BusDenies busDenies `json:"busDenies"`
Error string `json:"error,omitempty"`
}
type busDenies struct {
Instance string `json:"instance"`
Denied uint64 `json:"denied"`
ByCapability map[string]uint64 `json:"byCapability,omitempty"`
Error string `json:"error,omitempty"`
}
func readBusDenies(instance, coreRecord string) busDenies {
var core devinstance.Core
if err := fsx.ReadJSON(coreRecord, &core); err != nil {
return busDenies{Instance: instance, Error: err.Error()}
}
return busDenies{Instance: instance, Denied: core.BusDenied, ByCapability: core.BusDeniedBy}
}
type rootStatusObject struct {
metav1.ObjectMeta `json:"metadata"`
Status v1alpha1.ApplicationStatus `json:"status"`
}
type appKcp struct {
app, instance, kubeconfig, workspace, coreRecord string
}
func runStatus(ctx context.Context, a *app, vals clicfg.Values, rest []string) int {
if len(rest) > 1 {
return a.fail(exitRefused, "status: status [<app>] [--instance <instance>]")
}
want := ""
if len(rest) == 1 {
want = rest[0]
}
l, rec, code := a.record("status", vals)
if code != exitOK {
return code
}
apps, err := appKcps(ctx, l, rec)
if err != nil {
return a.fail(exitFailed, "status: %v", err)
}
var out []appStatusView
var names []string
for _, ak := range apps {
names = append(names, ak.app)
if want != "" && ak.app != want {
continue
}
out = append(out, readAppStatus(ctx, ak))
}
if want != "" && len(out) == 0 {
return a.fail(exitFailed, "status: instance %s has no application %s (it has: %s)", l.ID, want, strings.Join(names, ", "))
}
a.printJSON(out)
for _, v := range out {
if v.Error != "" {
return exitFailed
}
}
return exitOK
}
func appKcps(ctx context.Context, l devinstance.Layout, rec devinstance.Record) ([]appKcp, error) {
if rec.Profile != bootstrap.ProfileMarketNetwork || rec.AdminKubeconfig == "" {
return []appKcp{{app: l.ID, instance: l.ID, kubeconfig: rec.AdminKubeconfig, workspace: baseWorkspace(rec), coreRecord: l.CoreRecord}}, nil
}
n, err := marketnetwork.ReadNetwork(ctx, rec.AdminKubeconfig)
if err != nil {
return nil, fmt.Errorf("reading the MarketNetwork of %s: %w", l.ID, err)
}
var out []appKcp
for _, ap := range n.Status.Apps {
if ap.Instance == "" {
continue
}
cl, err := devinstance.NewLayout(ap.Instance, filepath.Join(l.StateDir, compose.AppsDir), filepath.Join(l.RuntimeDir, compose.AppsDir))
if err != nil {
return nil, err
}
var crec devinstance.Record
if err := fsx.ReadJSON(cl.Record, &crec); err != nil {
continue
}
out = append(out, appKcp{app: ap.Name, instance: ap.Instance, kubeconfig: crec.AdminKubeconfig, workspace: baseWorkspace(crec), coreRecord: cl.CoreRecord})
}
return out, nil
}
func baseWorkspace(rec devinstance.Record) string {
if rec.BaseWorkspace != "" {
return rec.BaseWorkspace
}
return compose.DefaultWorkspace
}
func readAppStatus(ctx context.Context, ak appKcp) appStatusView {
v := appStatusView{App: ak.app, Instance: ak.instance, BusDenies: readBusDenies(ak.instance, ak.coreRecord)}
ctx, cancel := context.WithTimeout(ctx, appStatusTimeout)
defer cancel()
dc, err := workspaceClient(ak.kubeconfig, ak.workspace)
if err != nil {
v.Error = err.Error()
return v
}
for _, r := range []struct {
gvr schema.GroupVersionResource
kind string
}{{compose.MarketBidderGVR, "MarketBidder"}, {compose.MarketRequesterGVR, "MarketRequester"}, {compose.GatewayGVR, "Gateway"}} {
list, err := kube.List[rootStatusObject](ctx, dc.Resource(r.gvr), metav1.ListOptions{})
if absentResource(err) {
continue
}
if err != nil {
v.Error = fmt.Sprintf("listing %s: %v", r.gvr.Resource, err)
return v
}
for _, o := range list {
v.Roots = append(v.Roots, rootStatusView{Kind: r.kind, Name: o.Name, Phase: o.Status.Phase, Message: o.Status.Message,
Market: o.Status.Market, Store: o.Status.Store, GC: o.Status.GC, TTL: o.Status.TTL, Quotas: o.Status.Quotas})
}
}
list, err := kube.List[v1alpha1.ComputeContract](ctx, dc.Resource(compose.ComputeContractGVR), metav1.ListOptions{})
if err != nil && !absentResource(err) {
v.Error = fmt.Sprintf("listing computecontracts: %v", err)
return v
}
for _, c := range list {
cv := contractStatusView{Name: c.Name, Phase: c.Status.Phase, Message: c.Status.Message, Execution: c.Status.Execution}
if ct := c.Status.Contract; ct != nil && ct.Winner != nil {
cv.Winner = ct.Winner.DID
}
v.Contracts = append(v.Contracts, cv)
}
return v
}
func absentResource(err error) bool {
return err != nil && (apierrors.IsNotFound(err) || meta.IsNoMatchError(err))
}
func workspaceClient(kubeconfig, ws string) (*kube.Client, error) {
base, err := kcpserver.FrontRestConfig(kubeconfig)
if err != nil {
return nil, err
}
cfg := rest.CopyConfig(base)
cfg.Timeout = appStatusTimeout
return kube.ForWorkspace(cfg, ws)
}
func appStatuses(ctx context.Context, l devinstance.Layout, rec devinstance.Record) []appStatusView {
apps, err := appKcps(ctx, l, rec)
if err != nil {
return []appStatusView{{App: l.ID, Instance: l.ID, Error: err.Error()}}
}
out := make([]appStatusView, 0, len(apps))
for _, ak := range apps {
out = append(out, readAppStatus(ctx, ak))
}
return out
}