0
0
package componentcore
import (
"context"
"errors"
"fmt"
"log/slog"
"strings"
"sync"
"github.com/johnandersen777/socialweb-computer-kcp/internal/component"
"github.com/johnandersen777/socialweb-computer-kcp/internal/exposure"
)
const ingressProxyKind = "IngressProxy"
type ingressRegistrarProvider interface {
IngressRegistrar() exposure.IngressRegistrar
}
type ingressProviderNamer interface {
IngressProvider() string
}
type ingressDispatcher struct {
registry *component.Registry
fallback exposure.IngressRegistrar
fallbackName string
log *slog.Logger
mu sync.Mutex
served map[string]string
}
func newIngressDispatcher(registry *component.Registry, fallback exposure.IngressRegistrar, fallbackName string, log *slog.Logger) *ingressDispatcher {
if log == nil {
log = slog.New(slog.DiscardHandler)
}
return &ingressDispatcher{
registry: registry,
fallback: fallback,
fallbackName: fallbackName,
log: log.With("component", "exposure-ingress"),
served: map[string]string{},
}
}
func (d *ingressDispatcher) Register(ctx context.Context, spec exposure.IngressSpec) (exposure.IngressRegistration, error) {
ref := strings.TrimSpace(spec.IngressRef)
if ref != "" {
if entry, ok := d.resolve(spec.Workspace, ref); ok {
service := entry.Service
if service == nil {
return nil, fmt.Errorf("the IngressProxy component %s/%s exposes no ingress registrar", entry.Key.Workspace, entry.Key.Name)
}
provider, ok := service.(ingressRegistrarProvider)
if !ok || provider.IngressRegistrar() == nil {
return nil, fmt.Errorf("the IngressProxy component %s/%s exposes no ingress registrar", entry.Key.Workspace, entry.Key.Name)
}
name := "component"
if named, ok := service.(ingressProviderNamer); ok {
if value := strings.TrimSpace(named.IngressProvider()); value != "" {
name = value
}
}
registration, err := provider.IngressRegistrar().Register(ctx, spec)
if err != nil {
return nil, err
}
d.logServed(spec, entry.Key.Name, name)
return registration, nil
}
if strings.TrimSpace(spec.IngressAddress) == "" {
return nil, fmt.Errorf("%w: %s", exposure.ErrIngressNotReady, ref)
}
}
if d.fallback == nil {
return nil, errors.New("no ingress registrar is configured")
}
name := d.fallbackName
if named, ok := d.fallback.(ingressProviderNamer); ok {
if value := strings.TrimSpace(named.IngressProvider()); value != "" {
name = value
}
}
registration, err := d.fallback.Register(ctx, spec)
if err != nil {
return nil, err
}
d.logServed(spec, ref, name)
return registration, nil
}
func (d *ingressDispatcher) IngressInstance(workspace, ingressRef string) string {
ref := strings.TrimSpace(ingressRef)
if ref == "" {
return ""
}
entry, ok := d.resolve(workspace, ref)
if !ok {
return ""
}
if _, ok := entry.Service.(ingressRegistrarProvider); !ok {
return ""
}
return fmt.Sprintf("%s/%s/%s/%d", entry.Key.Workspace, entry.Key.Name, entry.UID, entry.Attempt)
}
func (d *ingressDispatcher) resolve(workspace, name string) (component.Entry, bool) {
if d.registry == nil {
return component.Entry{}, false
}
if entry, ok := d.registry.Lookup(workspace, ingressProxyKind, name); ok {
return entry, true
}
for _, entry := range d.registry.List("") {
if entry.Key.Kind == ingressProxyKind && entry.Key.Name == name {
return entry, true
}
}
return component.Entry{}, false
}
func (d *ingressDispatcher) logServed(spec exposure.IngressSpec, ingress, provider string) {
key := spec.Workspace + "/" + spec.Exposure
d.mu.Lock()
if _, ok := d.served[key]; ok {
d.mu.Unlock()
return
}
d.served[key] = provider
d.mu.Unlock()
d.log.Info("the exposure is served by an ingress provider", "workspace", spec.Workspace,
"exposure", spec.Exposure, "ingress", ingress, "provider", provider)
}