0
0
package bus
import (
"context"
"errors"
"fmt"
"reflect"
"strings"
"k8s.io/apimachinery/pkg/runtime/schema"
commonv1 "github.com/johnandersen777/socialweb-computer-kcp/api/common/v1alpha1"
)
var ErrNoProvider = errors.New("bus: no provider serves this kind and capability")
type providerKey struct {
kind string
capability string
typ reflect.Type
}
type provider struct {
group string
open any
}
func Provide[T any](b *Bus, gk schema.GroupKind, capability string, open func(ctx context.Context, to commonv1.ObjectRef, scope []string) (T, error)) {
if b == nil || open == nil || strings.TrimSpace(gk.Kind) == "" || strings.TrimSpace(capability) == "" {
return
}
key := providerKey{kind: strings.ToLower(strings.TrimSpace(gk.Kind)), capability: strings.ToLower(strings.TrimSpace(capability)), typ: reflect.TypeFor[T]()}
b.mu.Lock()
if b.providers == nil {
b.providers = map[providerKey]provider{}
}
b.providers[key] = provider{group: strings.TrimSpace(gk.Group), open: open}
b.mu.Unlock()
}
func (b *Bus) Provides(group, kind string) bool {
if b == nil {
return false
}
kind = strings.ToLower(strings.TrimSpace(kind))
b.mu.RLock()
defer b.mu.RUnlock()
for key, p := range b.providers {
if key.kind == kind && groupMatches(p.group, group) {
return true
}
}
return false
}
func callerOf(ctx context.Context, from commonv1.ObjectRef) Caller {
caller := Caller{Ref: from}
if current, ok := CallerFrom(ctx); ok && current.Ref == from {
caller.Labels = current.Labels
}
return caller
}
func AwaitLink(ctx context.Context, b *Bus, from commonv1.ObjectRef, to commonv1.ObjectRef, c Capability) bool {
if b == nil {
return false
}
return b.awaitAllowed(ctx, callerOf(ctx, from), to, c, nil)
}
func Resolve[T any](ctx context.Context, b *Bus, from commonv1.ObjectRef, to commonv1.ObjectRef, c Capability) (T, error) {
var zero T
if b == nil {
return zero, ErrHandlersStopped
}
if err := b.Ready(ctx); err != nil {
return zero, err
}
caller := callerOf(ctx, from)
if err := b.authorizeCaller(ctx, caller, to, c); err != nil {
return zero, err
}
key := providerKey{kind: strings.ToLower(strings.TrimSpace(to.Kind)), capability: strings.ToLower(strings.TrimSpace(c.Name)), typ: reflect.TypeFor[T]()}
b.mu.RLock()
p, ok := b.providers[key]
b.mu.RUnlock()
if !ok || !groupMatches(p.group, to.Group) {
return zero, fmt.Errorf("%w: %s for %s as %v", ErrNoProvider, c.Name, refString(to), key.typ)
}
open, ok := p.open.(func(context.Context, commonv1.ObjectRef, []string) (T, error))
if !ok {
return zero, fmt.Errorf("%w: %s for %s as %v", ErrNoProvider, c.Name, refString(to), key.typ)
}
return open(context.WithValue(ctx, callerKey{}, caller), to, append([]string(nil), c.Scope...))
}