Implement Registry (#11)

Author: fabriziopandini

internal/runtime/client/client.go

@@ -33,14 +33,12 @@ import (
 
 // Options are creation options for a Client.
 type Options struct {
-	Catalog  *catalog.Catalog
-	Registry registry.Registry
+	Catalog *catalog.Catalog
 }
 
 func New(options Options) Client {
 	return &client{
-		catalog:  options.Catalog,
-		registry: options.Registry,
+		catalog: options.Catalog,
 	}
 }
 
@@ -56,8 +54,7 @@ type Client interface {
 }
 
 type client struct {
-	catalog  *catalog.Catalog
-	registry registry.Registry
+	catalog *catalog.Catalog
 
 	host     string
 	basePath string
@@ -106,12 +103,12 @@ type hookClient struct {
 }
 
 func (h hookClient) Call(ctx context.Context, name string, in, out runtime.Object) error {
-	gvh, err := h.client.catalog.GroupVersionHook(h.hook)
+	_, err := h.client.catalog.GroupVersionHook(h.hook)
 	if err != nil {
 		return err
 	}
 
-	registration := h.client.registry.GetRuntimeExtension(gvh, name)
+	registration, _ := registry.Extensions().Get(name)
 
 	c := createHttpClient(registration)
 
@@ -124,7 +121,7 @@ func (h hookClient) CallAll(ctx context.Context, in, out runtime.Object) error {
 		return err
 	}
 
-	registrations := h.client.registry.GetRuntimeExtensions(gvh)
+	registrations, _ := registry.Extensions().List(gvh)
 	for _, registration := range registrations {
 		c := createHttpClient(registration)
 
@@ -136,7 +133,7 @@ func (h hookClient) CallAll(ctx context.Context, in, out runtime.Object) error {
 	return nil
 }
 
-func createHttpClient(registration registry.RuntimeExtensionRegistration) httpClient {
+func createHttpClient(registration *registry.RuntimeExtensionRegistration) httpClient {
 	return httpClient{}
 }
 

internal/runtime/registry/registry.go

@@ -1,55 +1,224 @@
+/*
+Copyright 2022 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
 package registry
 
 import (
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"sync"
+
+	"github.com/pkg/errors"
+	"k8s.io/apimachinery/pkg/runtime/schema"
 
 	runtimev1 "sigs.k8s.io/cluster-api/exp/runtime/api/v1beta1"
 	"sigs.k8s.io/cluster-api/internal/runtime/catalog"
 )
 
-func New() Registry {
-	return &registry{
-		registrations: map[string]RuntimeExtensionRegistration{},
-	}
-}
+// TODO: handle namespace selector
+
+var (
+	once     sync.Once
+	instance ExtensionRegistry
+)
+
+// ExtensionRegistry defines all the func an extension registry supports.
+type ExtensionRegistry interface {
+	// WarmUp can be used to initialise a "cold" extension registry with all the known extensions at a given time.
+	// After WarmUp completes the extension registry is considered ready.
+	WarmUp(ext *runtimev1.ExtensionList) error
+
+	// IsReady returns true if the extension registry is ready for usage, and this happens
+	// after WarmUp is completed.
+	IsReady() bool
+
+	// Add all the Runtime Extensions served by a registered runtime extension server.
+	// Please note that if the provided registration object already exists, all the registered
+	// RuntimeExtensions gets updated according to the newly provide status.
+	Add(ext *runtimev1.Extension) error
+
+	// Remove all the Runtime Extensions served by a registered runtime extension server.
+	Remove(ext *runtimev1.Extension) error
+
+	// List all the registered Runtime Extensions for a given Group/Hook.
+	List(gh catalog.GroupVersionHook) ([]*RuntimeExtensionRegistration, error)
 
-type registry struct {
-	registrations map[string]RuntimeExtensionRegistration
+	// Get the Runtime Extensions with a given name
+	Get(name string) (*RuntimeExtensionRegistration, error)
 }
 
+// RuntimeExtensionRegistration contain info about a registered Runtime Extension.
 type RuntimeExtensionRegistration struct {
-	Name             string
+	// RegistrationName is the name of the object who originated the registration of this Runtime Extension.
+	RegistrationName string
+
+	// The unique name of the Runtime Extension.
+	Name string
+
+	// The GroupVersionHook the Runtime Extension implements.
 	GroupVersionHook catalog.GroupVersionHook
-	ClientConfig     ClientConfig
+
+	ClientConfig   runtimev1.WebhookClientConfig
+	TimeoutSeconds *int32
+	FailurePolicy  *runtimev1.FailurePolicyType
+}
+
+type extensionRegistry struct {
+	ready bool
+	items map[string]*RuntimeExtensionRegistration
+	lock  sync.RWMutex
+}
+
+// Extensions provide access to all the registered Runtime Extensions.
+func Extensions() ExtensionRegistry {
+	once.Do(func() {
+		instance = extensions()
+	})
+	return instance
+}
+
+func extensions() ExtensionRegistry {
+	return &extensionRegistry{
+		items: map[string]*RuntimeExtensionRegistration{},
+	}
+}
+
+// WarmUp can be used to initialise a "cold" extension registry with all the known extensions at a given time.
+// After WarmUp completes the extension registry is considered ready.
+func (extensions *extensionRegistry) WarmUp(extList *runtimev1.ExtensionList) error {
+	if extList == nil {
+		return errors.New("invalid argument, when calling WarmUp extList must not be nil")
+	}
+
+	extensions.lock.Lock()
+	defer extensions.lock.Unlock()
+
+	for i := range extList.Items {
+		if err := extensions.add(&extList.Items[i]); err != nil { // TODO: consider if to aggregate errors
+			return err
+		}
+	}
+
+	extensions.ready = true
+	return nil
 }
 
-type ClientConfig struct {
-	WebhookClientConfig runtimev1.WebhookClientConfig
-	TimeoutSeconds      *int32
-	FailurePolicy       *runtimev1.FailurePolicyType
-	NamespaceSelector   *metav1.LabelSelector
+// IsReady returns true if the extension registry is ready for usage, and this happens
+// after WarmUp is completed.
+func (extensions *extensionRegistry) IsReady() bool {
+	extensions.lock.RLock()
+	defer extensions.lock.RUnlock()
+
+	return extensions.ready
 }
 
-func (r registry) RegisterRuntimeExtension(ext *runtimev1.Extension) {
-	panic("implement me")
+// Add all the Runtime Extensions served by a registered runtime extension server.
+// Please note that if the provided registration object already exists, all the registered
+// RuntimeExtensions gets updated according to the newly provide status.
+func (extensions *extensionRegistry) Add(ext *runtimev1.Extension) error {
+	if !extensions.ready {
+		return errors.New("invalid operation: Get cannot called on a registry not yet ready")
+	}
+
+	if ext == nil {
+		return errors.New("invalid argument, when calling Add ext must not be nil")
+	}
+
+	extensions.lock.Lock()
+	defer extensions.lock.Unlock()
+	return extensions.add(ext)
 }
 
-func (r registry) RemoveRuntimeExtension(ext *runtimev1.Extension) {
-	panic("implement me")
+// Remove all the Runtime Extensions served by a registered runtime extension server.
+func (extensions *extensionRegistry) Remove(ext *runtimev1.Extension) error {
+	if !extensions.ready {
+		return errors.New("invalid operation: Get cannot called on a registry not yet ready")
+	}
+
+	if ext == nil {
+		return errors.New("invalid argument, when calling Remove ext must not be nil")
+	}
+
+	extensions.lock.Lock()
+	defer extensions.lock.Unlock()
+
+	extensions.remove(ext)
+	return nil
 }
 
-func (r registry) GetRuntimeExtension(gvh catalog.GroupVersionHook, name string) RuntimeExtensionRegistration {
-	panic("implement me")
+func (extensions *extensionRegistry) remove(ext *runtimev1.Extension) {
+	for _, e := range extensions.items {
+		if e.RegistrationName == ext.Name {
+			delete(extensions.items, e.Name)
+		}
+	}
 }
 
-func (r registry) GetRuntimeExtensions(gvh catalog.GroupVersionHook) []RuntimeExtensionRegistration {
-	panic("implement me")
+// List all the registered Runtime Extensions for a given Group/Hook..
+func (extensions *extensionRegistry) List(gh catalog.GroupVersionHook) ([]*RuntimeExtensionRegistration, error) {
+	if !extensions.ready {
+		return nil, errors.New("invalid operation: Get cannot called on a registry not yet ready")
+	}
+
+	extensions.lock.RLock()
+	defer extensions.lock.RUnlock()
+
+	l := make([]*RuntimeExtensionRegistration, 0, 10)
+	for _, r := range extensions.items {
+		if r.GroupVersionHook.Group == gh.Group && r.GroupVersionHook.Hook == gh.Hook {
+			l = append(l, r)
+		}
+	}
+	return l, nil
 }
 
-type Registry interface {
-	RemoveRuntimeExtension(ext *runtimev1.Extension)
-	RegisterRuntimeExtension(ext *runtimev1.Extension)
+// Get the Runtime Extensions with a given name.
+func (extensions *extensionRegistry) Get(name string) (*RuntimeExtensionRegistration, error) {
+	if !extensions.ready {
+		return nil, errors.New("invalid operation: Get cannot called on a registry not yet ready")
+	}
+
+	extensions.lock.RLock()
+	defer extensions.lock.RUnlock()
+
+	r, _ := extensions.items[name]
+	return r, nil
+}
+
+func (extensions *extensionRegistry) add(ext *runtimev1.Extension) error {
+	extensions.remove(ext)
+
+	for _, e := range ext.Status.RuntimeExtensions {
+		gv, err := schema.ParseGroupVersion(e.Hook.APIVersion)
+		if err != nil { // TODO: consider if to aggregate errors
+			return errors.Wrapf(err, "failed to parse GroupVersion from %q", e.Hook.APIVersion)
+		}
+
+		r := &RuntimeExtensionRegistration{
+			RegistrationName: ext.Name,
+			Name:             e.Name,
+			GroupVersionHook: catalog.GroupVersionHook{
+				Group:   gv.Group,
+				Version: gv.Version,
+				Hook:    e.Hook.Name,
+			},
+			ClientConfig:   ext.Spec.ClientConfig,
+			TimeoutSeconds: e.TimeoutSeconds,
+			FailurePolicy:  e.FailurePolicy,
+		}
+		extensions.items[r.Name] = r
+	}
 
-	GetRuntimeExtension(gvh catalog.GroupVersionHook, name string) RuntimeExtensionRegistration
-	GetRuntimeExtensions(gvh catalog.GroupVersionHook) []RuntimeExtensionRegistration
+	return nil
 }