Extract pkg/sharding/key package

Author: timebertt

pkg/apis/sharding/v1alpha1/types_controllerring.go

@@ -130,8 +130,3 @@ func (c *ControllerRing) LabelShard() string {
 func (c *ControllerRing) LabelDrain() string {
 	return LabelDrain(c.Name)
 }
-
-// RingResources returns the list of resources that are distributed across shards in this ControllerRing.
-func (c *ControllerRing) RingResources() []RingResource {
-	return c.Spec.Resources
-}

pkg/apis/sharding/v1alpha1/types_controllerring_test.go

@@ -64,10 +64,4 @@ var _ = Describe("ControllerRing", func() {
 			Expect(ring.LabelDrain()).To(Equal("drain.alpha.sharding.timebertt.dev/operator"))
 		})
 	})
-
-	Describe("#RingResources", func() {
-		It("should return the specified resources", func() {
-			Expect(ring.RingResources()).To(Equal(ring.Spec.Resources))
-		})
-	})
 })

pkg/controller/sharder/reconciler.go

@@ -35,8 +35,8 @@ import (
 
 	configv1alpha1 "github.com/timebertt/kubernetes-controller-sharding/pkg/apis/config/v1alpha1"
 	shardingv1alpha1 "github.com/timebertt/kubernetes-controller-sharding/pkg/apis/sharding/v1alpha1"
-	"github.com/timebertt/kubernetes-controller-sharding/pkg/sharding"
 	"github.com/timebertt/kubernetes-controller-sharding/pkg/sharding/consistenthash"
+	"github.com/timebertt/kubernetes-controller-sharding/pkg/sharding/key"
 	"github.com/timebertt/kubernetes-controller-sharding/pkg/sharding/leases"
 	shardingmetrics "github.com/timebertt/kubernetes-controller-sharding/pkg/sharding/metrics"
 	"github.com/timebertt/kubernetes-controller-sharding/pkg/sharding/ring"
@@ -201,22 +201,22 @@ func (r *Reconciler) resyncObject(
 ) error {
 	log = log.WithValues("object", client.ObjectKeyFromObject(obj))
 
-	keyFunc := sharding.KeyForObject
+	keyFunc := key.ForObject
 	if controlled {
-		keyFunc = sharding.KeyForController
+		keyFunc = key.ForController
 	}
 
-	key, err := keyFunc(obj)
+	hashKey, err := keyFunc(obj)
 	if err != nil {
 		return err
 	}
-	if key == "" {
+	if hashKey == "" {
 		// object should not be assigned
 		return nil
 	}
 
 	var (
-		desiredShard = hashRing.Hash(key)
+		desiredShard = hashRing.Hash(hashKey)
 		currentShard = obj.Labels[ring.LabelShard()]
 	)
 

pkg/sharding/key.go renamed to pkg/sharding/key/key.go

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package sharding
+package key
 
 import (
 	"fmt"
@@ -26,13 +26,13 @@ import (
 	shardingv1alpha1 "github.com/timebertt/kubernetes-controller-sharding/pkg/apis/sharding/v1alpha1"
 )
 
-// KeyFuncForResource returns the key function that maps the given resource or its controller depending on whether
+// FuncForResource returns the key function that maps the given resource or its controller depending on whether
 // the resource is listed as a resource or controlled resource in the given ring.
-func KeyFuncForResource(gr metav1.GroupResource, ring *shardingv1alpha1.ControllerRing) (KeyFunc, error) {
+func FuncForResource(gr metav1.GroupResource, ring *shardingv1alpha1.ControllerRing) (Func, error) {
 	ringResources := sets.New[metav1.GroupResource]()
 	controlledResources := sets.New[metav1.GroupResource]()
 
-	for _, ringResource := range ring.RingResources() {
+	for _, ringResource := range ring.Spec.Resources {
 		ringResources.Insert(ringResource.GroupResource)
 
 		for _, controlledResource := range ringResource.ControlledResources {
@@ -42,24 +42,24 @@ func KeyFuncForResource(gr metav1.GroupResource, ring *shardingv1alpha1.Controll
 
 	switch {
 	case ringResources.Has(gr):
-		return KeyForObject, nil
+		return ForObject, nil
 	case controlledResources.Has(gr):
-		return KeyForController, nil
+		return ForController, nil
 	}
 
-	return nil, fmt.Errorf("object's resource %q was not found in Ring", gr.String())
+	return nil, fmt.Errorf("object's resource %q was not found in ControllerRing", gr.String())
 }
 
-// KeyFunc maps objects to hash keys.
-// It returns an error if the prequisities for sharding the given object are not fulfilled.
+// Func maps objects to hash keys.
+// It returns an error if the prerequisites for sharding the given object are not fulfilled.
 // If the returned key is empty, the object should not be assigned.
-type KeyFunc func(client.Object) (string, error)
+type Func func(client.Object) (string, error)
 
-// KeyForObject returns a ring key for the given object itself.
+// ForObject returns a ring key for the given object itself.
 // It needs the TypeMeta (GVK) to be set, which is not set on objects after decoding by default.
-func KeyForObject(obj client.Object) (string, error) {
+func ForObject(obj client.Object) (string, error) {
 	// We can't use the object's UID, as it is unset during admission for CREATE requests.
-	// Instead, we need to calculate a unique ID ourselves. The ID has this pattern (see keyForMetadata):
+	// Instead, we need to calculate a unique ID ourselves. The ID has this pattern (see forMetadata):
 	//  group/version/kind/namespace/name
 	// With this, different object instances with the same name will use the same hash key, which sounds acceptable.
 	// We can only use fields that are also present in owner references as we need to assign owners and ownees to the same
@@ -77,7 +77,7 @@ func KeyForObject(obj client.Object) (string, error) {
 			// object ID that we can also reconstruct later on for owned objects just by looking at the object itself.
 			// We could use a cache lookup though, but this would restrict scalability of the sharding solution again.
 			// Generally, this tradeoff seems acceptable, as generateName is mostly used on owned objects, but rarely the
-			// owner itself. In such case, KeyForController will be used instead, which doesn't care about the object's own
+			// owner itself. In such case, ForController will be used instead, which doesn't care about the object's own
 			// name but only that of the owner.
 			// If generateName is used nevertheless, respond with a proper error.
 			// We could assign the object after creation, however we can't use a watch cache because of the mentioned
@@ -90,12 +90,12 @@ func KeyForObject(obj client.Object) (string, error) {
 
 	// Namespace can be empty for cluster-scoped resources. Only check the name field as an optimistic check for
 	// preventing wrong usage of the function.
-	return keyForMetadata(gvk.GroupVersion().String(), gvk.Kind, obj.GetNamespace(), obj.GetName()), nil
+	return forMetadata(gvk.GroupVersion().String(), gvk.Kind, obj.GetNamespace(), obj.GetName()), nil
 }
 
-// KeyForController returns a ring key for the controller of the given object.
+// ForController returns a ring key for the controller of the given object.
 // It returns an empty key if the object doesn't have an ownerReference with controller=true".
-func KeyForController(obj client.Object) (string, error) {
+func ForController(obj client.Object) (string, error) {
 	ref := metav1.GetControllerOf(obj)
 	if ref == nil {
 		return "", nil
@@ -113,9 +113,9 @@ func KeyForController(obj client.Object) (string, error) {
 
 	// Namespace can be empty for cluster-scoped resources. Only check the other fields as an optimistic check for
 	// preventing wrong usage of the function.
-	return keyForMetadata(ref.APIVersion, ref.Kind, obj.GetNamespace(), ref.Name), nil
+	return forMetadata(ref.APIVersion, ref.Kind, obj.GetNamespace(), ref.Name), nil
 }
 
-func keyForMetadata(apiVersion, kind, namespace, name string) string {
+func forMetadata(apiVersion, kind, namespace, name string) string {
 	return apiVersion + "/" + kind + "/" + namespace + "/" + name
 }

pkg/webhook/sharder/handler.go

@@ -33,7 +33,7 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
 
 	shardingv1alpha1 "github.com/timebertt/kubernetes-controller-sharding/pkg/apis/sharding/v1alpha1"
-	"github.com/timebertt/kubernetes-controller-sharding/pkg/sharding"
+	"github.com/timebertt/kubernetes-controller-sharding/pkg/sharding/key"
 	shardingmetrics "github.com/timebertt/kubernetes-controller-sharding/pkg/sharding/metrics"
 	"github.com/timebertt/kubernetes-controller-sharding/pkg/sharding/ring"
 )
@@ -67,19 +67,19 @@ func (h *Handler) Handle(ctx context.Context, req admission.Request) admission.R
 		return admission.Allowed("object is already assigned")
 	}
 
-	keyFunc, err := sharding.KeyFuncForResource(metav1.GroupResource{
+	keyFunc, err := key.FuncForResource(metav1.GroupResource{
 		Group:    req.Resource.Group,
 		Resource: req.Resource.Resource,
 	}, controllerRing)
 	if err != nil {
 		return admission.Errored(http.StatusBadRequest, fmt.Errorf("error deteriming hash key func for object: %w", err))
 	}
 
-	key, err := keyFunc(obj)
+	hashKey, err := keyFunc(obj)
 	if err != nil {
 		return admission.Errored(http.StatusBadRequest, fmt.Errorf("error calculating hash key for object: %w", err))
 	}
-	if key == "" {
+	if hashKey == "" {
 		return admission.Allowed("object should not be assigned")
 	}
 
@@ -91,7 +91,7 @@ func (h *Handler) Handle(ctx context.Context, req admission.Request) admission.R
 
 	// get ring from cache and hash the object onto the ring
 	hashRing, _ := ring.FromLeases(controllerRing, leaseList, h.Clock.Now())
-	shard := hashRing.Hash(key)
+	shard := hashRing.Hash(hashKey)
 
 	log.V(1).Info("Assigning object for ControllerRing", "controllerRing", client.ObjectKeyFromObject(controllerRing), "shard", shard)