sotw: rlp workflow

api/v1/merge_strategies.go

@@ -0,0 +1,200 @@
+/*
+Copyright 2024.
+
+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 v1
+
+import (
+ "sort"
+ "strings"
+
+ "github.com/kuadrant/policy-machinery/controller"
+ "github.com/kuadrant/policy-machinery/machinery"
+ "github.com/samber/lo"
+ "k8s.io/apimachinery/pkg/runtime"
+ k8stypes "k8s.io/apimachinery/pkg/types"
+)
+
+const (
+ AtomicMergeStrategy = "atomic"
+ PolicyRuleMergeStrategy = "merge"
+)
+
+type MergeableRule struct {
+ Spec any
+ Source string
+}
+
+// +kubebuilder:object:generate=false
+type MergeablePolicy interface {
+ machinery.Policy
+
+ Rules() map[string]MergeableRule
+ SetRules(map[string]MergeableRule)
+ Empty() bool
+
+ DeepCopyObject() runtime.Object
+}
+
+// AtomicDefaultsMergeStrategy implements a merge strategy that returns the target Policy if it exists,
+// otherwise it returns the source Policy.
+func AtomicDefaultsMergeStrategy(source, target machinery.Policy) machinery.Policy {
+ if source == nil {
+ return target
+ }
+ if target == nil {
+ return source
+ }
+
+ mergeableTargetPolicy := target.(MergeablePolicy)
+
+ if !mergeableTargetPolicy.Empty() {
+ return mergeableTargetPolicy.DeepCopyObject().(machinery.Policy)
+ }
+
+ return source.(MergeablePolicy).DeepCopyObject().(machinery.Policy)
+}
+
+var _ machinery.MergeStrategy = AtomicDefaultsMergeStrategy
+
+// AtomicOverridesMergeStrategy implements a merge strategy that overrides a target Policy with
+// a source one.
+func AtomicOverridesMergeStrategy(source, _ machinery.Policy) machinery.Policy {
+ if source == nil {
+ return nil
+ }
+ return source.(MergeablePolicy).DeepCopyObject().(machinery.Policy)
+}
+
+var _ machinery.MergeStrategy = AtomicOverridesMergeStrategy
+
+// PolicyRuleDefaultsMergeStrategy implements a merge strategy that merges a source Policy into a target one
+// by keeping the policy rules from the target and adding the ones from the source that do not exist in the target.
+func PolicyRuleDefaultsMergeStrategy(source, target machinery.Policy) machinery.Policy {
+ if source == nil {
+ return target
+ }
+ if target == nil {
+ return source
+ }
+
+ sourceMergeablePolicy := source.(MergeablePolicy)
+ targetMergeablePolicy := target.(MergeablePolicy)
+
+ // copy rules from the target
+ rules := targetMergeablePolicy.Rules()
+
+ // add extra rules from the source
+ for ruleID, rule := range sourceMergeablePolicy.Rules() {
+ if _, ok := targetMergeablePolicy.Rules()[ruleID]; !ok {
+ rules[ruleID] = MergeableRule{
+ Spec: rule.Spec,
+ Source: source.GetLocator(),
+ }
+ }
+ }
+
+ mergedPolicy := targetMergeablePolicy.DeepCopyObject().(MergeablePolicy)
+ mergedPolicy.SetRules(rules)
+ return mergedPolicy
+}
+
+var _ machinery.MergeStrategy = PolicyRuleDefaultsMergeStrategy
+
+// PolicyRuleOverridesMergeStrategy implements a merge strategy that merges a source Policy into a target one
+// by using the policy rules from the source and keeping from the target only the policy rules that do not exist in
+// the source.
+func PolicyRuleOverridesMergeStrategy(source, target machinery.Policy) machinery.Policy {
+ sourceMergeablePolicy := source.(MergeablePolicy)
+ targetMergeablePolicy := target.(MergeablePolicy)
+
+ // copy rules from the source
+ rules := sourceMergeablePolicy.Rules()
+
+ // add extra rules from the target
+ for ruleID, rule := range targetMergeablePolicy.Rules() {
+ if _, ok := sourceMergeablePolicy.Rules()[ruleID]; !ok {
+ rules[ruleID] = rule
+ }
+ }
+
+ mergedPolicy := targetMergeablePolicy.DeepCopyObject().(MergeablePolicy)
+ mergedPolicy.SetRules(rules)
+ return mergedPolicy
+}
+
+var _ machinery.MergeStrategy = PolicyRuleOverridesMergeStrategy
+
+func DefaultsMergeStrategy(strategy string) machinery.MergeStrategy {
+ switch strategy {
+ case AtomicMergeStrategy:
+ return AtomicDefaultsMergeStrategy
+ case PolicyRuleMergeStrategy:
+ return PolicyRuleDefaultsMergeStrategy
+ default:
+ return AtomicDefaultsMergeStrategy
+ }
+}
+
+func OverridesMergeStrategy(strategy string) machinery.MergeStrategy {
+ switch strategy {
+ case AtomicMergeStrategy:
+ return AtomicOverridesMergeStrategy
+ case PolicyRuleMergeStrategy:
+ return PolicyRuleOverridesMergeStrategy
+ default:
+ return AtomicOverridesMergeStrategy
+ }
+}
+
+// EffectivePolicyForPath returns the effective policy for a given path, merging all policies in the path.
+// The policies in the path are sorted from the least specific to the most specific.
+// Only policies whose predicate returns true are considered.
+func EffectivePolicyForPath[T machinery.Policy](path []machinery.Targetable, predicate func(machinery.Policy) bool) *T {
+ policies := PoliciesInPath(path, predicate)
+ if len(policies) == 0 {
+ return nil
+ }
+
+ // map reduces the policies from most specific to least specific, merging them into one effective policy
+ effectivePolicy := lo.ReduceRight(policies, func(effectivePolicy machinery.Policy, policy machinery.Policy, _ int) machinery.Policy {
+ return effectivePolicy.Merge(policy)
+ }, policies[len(policies)-1])
+
+ concreteEffectivePolicy, _ := effectivePolicy.(T)
+ return &concreteEffectivePolicy
+}
+
+// OrderedPoliciesForPath gathers all policies in a path sorted from the least specific to the most specific.
+// Only policies whose predicate returns true are considered.
+func PoliciesInPath(path []machinery.Targetable, predicate func(machinery.Policy) bool) []machinery.Policy {
+ return lo.FlatMap(path, func(targetable machinery.Targetable, _ int) []machinery.Policy {
+ policies := lo.FilterMap(targetable.Policies(), func(policy machinery.Policy, _ int) (controller.Object, bool) {
+ o, object := policy.(controller.Object)
+ return o, object && predicate(policy)
+ })
+ sort.Sort(controller.ObjectsByCreationTimestamp(policies))
+ return lo.Map(policies, func(policy controller.Object, _ int) machinery.Policy {
+ p, _ := policy.(machinery.Policy)
+ return p
+ })
+ })
+}
+
+func PathID(path []machinery.Targetable) string {
+ return strings.Join(lo.Map(path, func(t machinery.Targetable, _ int) string {
+ return strings.TrimPrefix(k8stypes.NamespacedName{Namespace: t.GetNamespace(), Name: t.GetName()}.String(), string(k8stypes.Separator))
+ }), "|")
+}

api/v1beta3/groupversion_info.go

@@ -1,5 +1,5 @@
 /*
-Copyright 2021.
+Copyright 2024.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -14,23 +14,33 @@
 limitations under the License.
 */
 
-// Package v1beta3 contains API Schema definitions for the kuadrant v1beta3 API group
+// API schema definitions for the Kuadrant v1beta3 API group
 // +kubebuilder:object:generate=true
 // +groupName=kuadrant.io
 package v1beta3
 
 import (
  "k8s.io/apimachinery/pkg/runtime/schema"
- "sigs.k8s.io/controller-runtime/pkg/scheme"
+ ctrl "sigs.k8s.io/controller-runtime/pkg/scheme"
 )
 
-var (
- // GroupVersion is group version used to register these objects
- GroupVersion = schema.GroupVersion{Group: "kuadrant.io", Version: "v1beta3"}
+// GroupName specifies the group name used to register the objects.
+const GroupName = "kuadrant.io"
 
- // SchemeBuilder is used to add go types to the GroupVersionKind scheme
- SchemeBuilder = &scheme.Builder{GroupVersion: GroupVersion}
+// GroupVersion specifies the group and the version used to register the objects.
+var GroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1beta3"}
 
- // AddToScheme adds the types in this group-version to the given scheme.
- AddToScheme = SchemeBuilder.AddToScheme
-)
+// SchemeGroupVersion is group version used to register these objects
+// Deprecated: use GroupVersion instead.
+var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1beta3"}
+
+// SchemeBuilder is used to add go types to the GroupVersionKind scheme
+var SchemeBuilder = &ctrl.Builder{GroupVersion: GroupVersion}
+
+// AddToScheme adds the types in this group-version to the given scheme.
+var AddToScheme = SchemeBuilder.AddToScheme
+
+// Resource takes an unqualified resource and returns a Group qualified GroupResource
+func Resource(resource string) schema.GroupResource {
+ return SchemeGroupVersion.WithResource(resource).GroupResource()
+}