0
0
package kcpclient
import (
"context"
"encoding/json"
"errors"
"fmt"
"strings"
"sync"
corev1 "k8s.io/api/core/v1"
rbacv1 "k8s.io/api/rbac/v1"
apierrors "k8s.io/apimachinery/pkg/api/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/types"
"k8s.io/client-go/rest"
"github.com/johnandersen777/socialweb-computer-kcp/internal/contract/clusterhome"
"github.com/johnandersen777/socialweb-computer-kcp/internal/controllers/runtime/kube"
)
const (
NodeClaimAgentGrant = "socialweb-nodeclaim-agent"
NodeClaimHomeLabel = "socialweb.computer/nodeclaim-home"
NodeClaimHomeKey = "workspace"
foreignAccountPrefix = "system:kcp:serviceaccount:"
agentFieldManager = "kcpclient"
)
type ServiceAccountRef struct {
Workspace string
Namespace string
Name string
}
func ParseServiceAccountRef(s string) (*ServiceAccountRef, error) {
if s == "" {
return nil, nil
}
parts := strings.Split(s, "/")
if len(parts) != 3 || parts[0] == "" || parts[1] == "" || parts[2] == "" {
return nil, fmt.Errorf("kcpclient: %q is not <workspace path>/<namespace>/<name>", s)
}
return &ServiceAccountRef{Workspace: parts[0], Namespace: parts[1], Name: parts[2]}, nil
}
func HomeAgentRules() []rbacv1.PolicyRule {
return []rbacv1.PolicyRule{
{NonResourceURLs: []string{"/"}, Verbs: []string{"access"}},
{APIGroups: []string{socialwebResource.Group}, Resources: []string{"nodeclaims"}, Verbs: []string{"get", "list", "patch"}},
{APIGroups: []string{socialwebResource.Group}, Resources: []string{"nodeclaims/status"}, Verbs: []string{"patch"}},
{APIGroups: []string{socialwebResource.Group}, Resources: []string{"clusterlinks"}, Verbs: []string{"get"}},
}
}
type agent struct {
ref *ServiceAccountRef
mu sync.Mutex
user string
}
func (a *agent) userName(ctx context.Context, c *Client) (string, error) {
a.mu.Lock()
defer a.mu.Unlock()
if a.user != "" {
return a.user, nil
}
i := strings.LastIndex(a.ref.Workspace, ":")
if i < 0 {
return "", fmt.Errorf("kcpclient: the node claim agent's workspace %q has no parent", a.ref.Workspace)
}
ws, err := c.readWorkspace(ctx, a.ref.Workspace[:i], a.ref.Workspace[i+1:])
if err != nil {
return "", fmt.Errorf("kcpclient: the node claim agent's workspace %s: %w", a.ref.Workspace, err)
}
if ws.Spec.Cluster == "" {
return "", fmt.Errorf("kcpclient: the node claim agent's workspace %s has no logical cluster yet", a.ref.Workspace)
}
a.user = foreignAccountPrefix + ws.Spec.Cluster + ":" + a.ref.Namespace + ":" + a.ref.Name
return a.user, nil
}
func apply(ctx context.Context, req *rest.Request, where string, obj any) error {
if err := applyDoc(ctx, req, agentFieldManager, true, obj, false); err != nil {
return fmt.Errorf("kcpclient: the node claim agent's grant in %s: %w", where, err)
}
return nil
}
func applyDoc(ctx context.Context, req *rest.Request, manager string, force bool, obj any, status bool) error {
doc, err := kube.ApplyBody(obj, status)
if err != nil {
return err
}
body, err := json.Marshal(doc)
if err != nil {
return err
}
req = req.Param("fieldManager", manager)
if force {
req = req.Param("force", "true")
}
return req.Body(body).Do(ctx).Error()
}
func (c *Client) grantAgentHome(ctx context.Context, home string) error {
if c.agent == nil {
return nil
}
user, err := c.agent.userName(ctx, c)
if err != nil {
return err
}
r, err := c.bind(home, rbacv1.SchemeGroupVersion, "/apis")
if err != nil {
return err
}
role := rbacv1.ClusterRole{TypeMeta: metav1.TypeMeta{APIVersion: rbacv1.SchemeGroupVersion.String(), Kind: "ClusterRole"},
ObjectMeta: metav1.ObjectMeta{Name: NodeClaimAgentGrant}, Rules: HomeAgentRules()}
if err := apply(ctx, r.Patch(types.ApplyPatchType).Resource("clusterroles").Name(NodeClaimAgentGrant), home, role); err != nil {
return err
}
binding := rbacv1.ClusterRoleBinding{TypeMeta: metav1.TypeMeta{APIVersion: rbacv1.SchemeGroupVersion.String(), Kind: "ClusterRoleBinding"},
ObjectMeta: metav1.ObjectMeta{Name: NodeClaimAgentGrant},
RoleRef: rbacv1.RoleRef{APIGroup: rbacv1.GroupName, Kind: "ClusterRole", Name: NodeClaimAgentGrant},
Subjects: []rbacv1.Subject{{Kind: rbacv1.UserKind, APIGroup: rbacv1.GroupName, Name: user}}}
if err := apply(ctx, r.Patch(types.ApplyPatchType).Resource("clusterrolebindings").Name(NodeClaimAgentGrant), home, binding); err != nil {
return err
}
key, err := clusterhome.Key(home)
if err != nil {
return err
}
core, err := c.coreResource(c.agent.ref.Workspace)
if err != nil {
return err
}
index := corev1.ConfigMap{TypeMeta: metav1.TypeMeta{APIVersion: "v1", Kind: "ConfigMap"},
ObjectMeta: metav1.ObjectMeta{Name: key, Namespace: c.agent.ref.Namespace, Labels: map[string]string{NodeClaimHomeLabel: "true"}},
Data: map[string]string{NodeClaimHomeKey: home}}
return apply(ctx, core.Patch(types.ApplyPatchType).Namespace(c.agent.ref.Namespace).Resource("configmaps").Name(key),
c.agent.ref.Workspace, index)
}
func (c *Client) GrantAgentHome(ctx context.Context, home string) error {
return c.grantAgentHome(ctx, home)
}
func (c *Client) DropAgentHome(ctx context.Context, home string) (bool, error) {
if c == nil || c.agent == nil {
return false, nil
}
key, err := clusterhome.Key(home)
if err != nil {
return false, err
}
i := strings.LastIndex(home, ":")
_, err = c.readWorkspace(ctx, home[:i], home[i+1:])
switch {
case apierrors.IsNotFound(err):
case err != nil:
return false, fmt.Errorf("kcpclient: the home workspace %s: %w", home, err)
default:
cl, err := c.readCluster(ctx, home, home[i+1:])
if err == nil && cl.DeletionTimestamp == nil {
return false, nil
}
if err != nil && !apierrors.IsNotFound(err) {
return false, fmt.Errorf("kcpclient: the cluster of %s: %w", home, err)
}
claims, err := c.ListNodeClaims(ctx, home)
if err != nil && !apierrors.IsNotFound(err) {
return false, err
}
if len(claims) > 0 {
return false, nil
}
}
core, err := c.coreResource(c.agent.ref.Workspace)
if err != nil {
return false, err
}
err = core.Delete().Namespace(c.agent.ref.Namespace).Resource("configmaps").Name(key).Do(ctx).Error()
if err != nil && !apierrors.IsNotFound(err) {
return false, fmt.Errorf("kcpclient: the node claim index entry %s in %s: %w", key, c.agent.ref.Workspace, err)
}
return true, nil
}
func (c *Client) SweepAgentHomes(ctx context.Context, live map[string]bool) ([]string, error) {
if c == nil || c.agent == nil {
return nil, nil
}
core, err := c.coreResource(c.agent.ref.Workspace)
if err != nil {
return nil, err
}
raw, err := core.Get().Namespace(c.agent.ref.Namespace).Resource("configmaps").
Param("labelSelector", NodeClaimHomeLabel+"=true").DoRaw(ctx)
if err != nil {
return nil, fmt.Errorf("kcpclient: list the node claim index in %s: %w", c.agent.ref.Workspace, err)
}
var list corev1.ConfigMapList
if err := json.Unmarshal(raw, &list); err != nil {
return nil, err
}
var dropped []string
var errs []error
for _, cm := range list.Items {
if live[cm.Name] {
continue
}
ok, err := c.DropAgentHome(ctx, cm.Data[NodeClaimHomeKey])
if err != nil {
errs = append(errs, fmt.Errorf("%s: %w", cm.Name, err))
}
if ok {
dropped = append(dropped, cm.Name)
}
}
return dropped, errors.Join(errs...)
}