0
0
package componentcore
import (
"context"
"errors"
"strings"
"sync"
tenancyv1alpha1 "github.com/kcp-dev/sdk/apis/tenancy/v1alpha1"
apierrors "k8s.io/apimachinery/pkg/api/errors"
"k8s.io/apimachinery/pkg/api/meta"
kruntime "k8s.io/apimachinery/pkg/runtime"
clientgoscheme "k8s.io/client-go/kubernetes/scheme"
"k8s.io/client-go/rest"
"sigs.k8s.io/controller-runtime/pkg/client"
eventsv1alpha1 "github.com/johnandersen777/socialweb-computer-kcp/api/events/v1alpha1"
exposurev1alpha1 "github.com/johnandersen777/socialweb-computer-kcp/api/exposure/v1alpha1"
pdsv1alpha1 "github.com/johnandersen777/socialweb-computer-kcp/api/pds/v1alpha1"
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/controllers/childapplication"
"github.com/johnandersen777/socialweb-computer-kcp/internal/controllers/marketpresence"
"github.com/johnandersen777/socialweb-computer-kcp/internal/controllers/openbaoserver"
"github.com/johnandersen777/socialweb-computer-kcp/internal/controllers/runtime/kube"
)
var schemes = []func(*kruntime.Scheme) error{v1alpha1.AddToScheme, pdsv1alpha1.AddToScheme, policyv1alpha1.AddToScheme,
eventsv1alpha1.AddToScheme, exposurev1alpha1.AddToScheme}
type workspaceClients struct {
base *rest.Config
scheme *kruntime.Scheme
mu sync.Mutex
clients map[string]client.Client
dynamics map[string]*kube.Client
}
var (
_ childapplication.Lister = (*workspaceClients)(nil)
_ childapplication.Workspaces = workspaceTree{}
_ openbaoserver.Grants = guestGrants{}
_ marketpresence.Bidders = bidders{}
)
func newWorkspaceClients(base *rest.Config) (*workspaceClients, error) {
if base == nil {
return nil, errors.New("componentcore: the workspace clients need a rest config")
}
scheme := kruntime.NewScheme()
for _, add := range append([]func(*kruntime.Scheme) error{clientgoscheme.AddToScheme, tenancyv1alpha1.AddToScheme}, schemes...) {
if err := add(scheme); err != nil {
return nil, err
}
}
return &workspaceClients{base: base, scheme: scheme, clients: map[string]client.Client{}, dynamics: map[string]*kube.Client{}}, nil
}
func (w *workspaceClients) client(workspace string) (client.Client, error) {
workspace = strings.TrimSpace(workspace)
if workspace == "" {
workspace = DefaultWorkspace
}
w.mu.Lock()
defer w.mu.Unlock()
if c, ok := w.clients[workspace]; ok {
return c, nil
}
cfg := rest.CopyConfig(w.base)
host, _, _ := strings.Cut(strings.TrimSuffix(cfg.Host, "/"), "/clusters/")
cfg.Host = host + "/clusters/" + workspace
c, err := client.New(cfg, client.Options{Scheme: w.scheme})
if err != nil {
return nil, err
}
w.clients[workspace] = c
return c, nil
}
func (w *workspaceClients) dynamic(workspace string) (*kube.Client, error) {
workspace = strings.TrimSpace(workspace)
if workspace == "" {
workspace = DefaultWorkspace
}
w.mu.Lock()
defer w.mu.Unlock()
if c, ok := w.dynamics[workspace]; ok {
return c, nil
}
c, err := kube.ForWorkspace(w.base, workspace)
if err != nil {
return nil, err
}
w.dynamics[workspace] = c
return c, nil
}
func (w *workspaceClients) List(ctx context.Context, workspace string, list client.ObjectList) error {
c, err := w.client(workspace)
if err != nil {
return err
}
err = c.List(ctx, list)
if apierrors.IsNotFound(err) || apierrors.IsForbidden(err) || meta.IsNoMatchError(err) {
return nil
}
return err
}
type workspaceTree struct {
clients *workspaceClients
}
func (t workspaceTree) Get(ctx context.Context, parent, name string) (childapplication.Workspace, bool, error) {
c, err := t.clients.client(parent)
if err != nil {
return childapplication.Workspace{}, false, err
}
var ws tenancyv1alpha1.Workspace
if err := c.Get(ctx, client.ObjectKey{Name: name}, &ws); err != nil {
if apierrors.IsNotFound(err) {
return childapplication.Workspace{}, false, nil
}
return childapplication.Workspace{}, false, err
}
return workspaceOf(ws), true, nil
}
func (t workspaceTree) ByLabel(ctx context.Context, parent, key, value string) (childapplication.Workspace, bool, error) {
c, err := t.clients.client(parent)
if err != nil {
return childapplication.Workspace{}, false, err
}
var list tenancyv1alpha1.WorkspaceList
if err := c.List(ctx, &list, client.MatchingLabels{key: value}); err != nil {
if apierrors.IsNotFound(err) {
return childapplication.Workspace{}, false, nil
}
return childapplication.Workspace{}, false, err
}
if len(list.Items) == 0 {
return childapplication.Workspace{}, false, nil
}
return workspaceOf(list.Items[0]), true, nil
}
func workspaceOf(ws tenancyv1alpha1.Workspace) childapplication.Workspace {
return childapplication.Workspace{Name: ws.Name, Phase: string(ws.Status.Phase), Deleting: !ws.DeletionTimestamp.IsZero()}
}
type guestGrants struct {
clients *workspaceClients
}
func (g guestGrants) List(ctx context.Context, workspace string) ([]v1alpha1.GuestIdentityGrant, error) {
var list v1alpha1.GuestIdentityGrantList
if err := g.clients.List(ctx, workspace, &list); err != nil {
return nil, err
}
return list.Items, nil
}
type bidders struct {
clients *workspaceClients
}
func (b bidders) Get(ctx context.Context, workspace, name string) (*v1alpha1.Bidder, error) {
return get[v1alpha1.Bidder](ctx, b.clients, workspace, name)
}
func get[T any, P interface {
*T
client.Object
}](ctx context.Context, clients *workspaceClients, workspace, name string) (*T, error) {
c, err := clients.client(workspace)
if err != nil {
return nil, err
}
out := P(new(T))
if err := c.Get(ctx, client.ObjectKey{Name: name}, out); err != nil {
return nil, err
}
return (*T)(out), nil
}