diff --git a/.github/.copilot/breadcrumbs/2025-01-15-1400-crp-delete-policy.md b/.github/.copilot/breadcrumbs/2025-01-15-1400-crp-delete-policy.md new file mode 100644 index 000000000..176391f94 --- /dev/null +++ b/.github/.copilot/breadcrumbs/2025-01-15-1400-crp-delete-policy.md @@ -0,0 +1,77 @@ +# CRP Delete Policy Implementation + +## Problem Analysis + +The issue requests adding API options to allow customers to choose whether to delete placed resources when a CRP (ClusterResourcePlacement) is deleted. + +### Current Deletion Behavior +1. When a CRP is deleted, it has two finalizers: + - `ClusterResourcePlacementCleanupFinalizer` - handled by CRP controller to delete snapshots + - `SchedulerCleanupFinalizer` - handled by scheduler to delete bindings + +2. The deletion flow: + - CRP controller removes snapshots (ClusterSchedulingPolicySnapshot, ClusterResourceSnapshot) + - Scheduler removes bindings (ClusterResourceBinding) which triggers cleanup of placed resources + - Currently there's no option for users to control whether placed resources are deleted + +### References +- Kubernetes DeleteOptions has `PropagationPolicy` with values: `Orphan`, `Background`, `Foreground` +- AKS API has `DeletePolicy` pattern (couldn't fetch exact details but following similar pattern) + +## Implementation Plan + +### Phase 1: API Design +- [x] Add `DeleteStrategy` struct to `RolloutStrategy` in beta API +- [x] Define `PropagationPolicy` field with enum values: `Delete` (default), `Abandon` +- [x] Update API documentation and validation +- [x] Move DeleteStrategy inside RolloutStrategy after ApplyStrategy for consistency + +### Phase 2: Implementation Details +TODO: @Arvindthiru to fill out the details for controller logic implementation. + +### Phase 3: Testing +- [ ] Add unit tests for new deletion policy options +- [ ] Add integration tests to verify behavior +- [ ] Test both `Delete` and `Abandon` scenarios + +### Phase 4: Documentation & Examples +- [ ] Update CRD documentation +- [ ] Add example configurations +- [ ] Update any user-facing documentation + +## Success Criteria +- [x] CRP API has `deleteStrategy` field with `Delete`/`Abandon` options inside RolloutStrategy +- [x] Default behavior (`Delete`) preserves current functionality +- [ ] `Abandon` policy leaves placed resources intact when CRP is deleted +- [ ] All tests pass including new deletion policy tests +- [x] Changes are minimal and backwards compatible + +## Current API Structure + +The DeleteStrategy is now part of RolloutStrategy: + +```go +type RolloutStrategy struct { + // ... other fields ... + ApplyStrategy *ApplyStrategy `json:"applyStrategy,omitempty"` + DeleteStrategy *DeleteStrategy `json:"deleteStrategy,omitempty"` +} + +type DeleteStrategy struct { + PropagationPolicy DeletePropagationPolicy `json:"propagationPolicy,omitempty"` +} + +type DeletePropagationPolicy string + +const ( + DeletePropagationPolicyDelete DeletePropagationPolicy = "Delete" // default + DeletePropagationPolicyAbandon DeletePropagationPolicy = "Abandon" +) +``` + +## Behavior Summary + +- **Default (`Delete`)**: When CRP is deleted, all placed resources are removed from member clusters (current behavior) +- **Abandon**: When CRP is deleted, placed resources remain on member clusters but are no longer managed by Fleet + +This provides customers with the flexibility to choose between complete cleanup or leaving resources in place when deleting a CRP. \ No newline at end of file diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md index 61341088e..bf8867f7a 100644 --- a/.github/copilot-instructions.md +++ b/.github/copilot-instructions.md @@ -11,6 +11,7 @@ The main idea is that we are creating a multi-cluster application management sol - Follow the [Uber Go Style Guide](https://github.com/uber-go/guide/blob/master/style.md) if possible. - Favor using the standard library over third-party libraries. - Run "make reviewable" before submitting a pull request to ensure the code is formatted correctly and all dependencies are up to date. +- The title of a PR must use one of the following prefixes: "[WIP] ", "feat: ", "test: ", "fix: ", "docs: ", "style: ", "interface: ", "util: ", "chore: ", "ci: ", "perf: ", "refactor: ", "revert: ". Please pick one that matches the PR content the most. ## Terminology - **Fleet**: A conceptual term referring to a collection of clusters. @@ -216,4 +217,4 @@ This practice creates a trail of decision points that document our thought proce **User**: This looks good. -**Agent**: I've updated the breadcrumb with the latest understanding. \ No newline at end of file +**Agent**: I've updated the breadcrumb with the latest understanding. diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index a14a0ab2c..d2f899c22 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -89,12 +89,16 @@ jobs: strategy: fail-fast: false matrix: - customized-settings: [default, custom] + customized-settings: [default, joinleave, custom] include: - customized-settings: default # to shorten the test duration, set the resource snapshot creation interval to 0 resource-snapshot-creation-minimum-interval: 0m resource-changes-collection-duration: 0m + - customized-settings: joinleave + # to shorten the test duration, set the resource snapshot creation interval to 0 + resource-snapshot-creation-minimum-interval: 0m + resource-changes-collection-duration: 0m - customized-settings: custom resource-snapshot-creation-minimum-interval: 30s resource-changes-collection-duration: 15s @@ -132,7 +136,9 @@ jobs: - name: Run e2e tests run: | if [ "${{ matrix.customized-settings }}" = "default" ]; then - make e2e-tests + make e2e-tests LABEL_FILTER="!custom && !joinleave" + elif [ "${{ matrix.customized-settings }}" = "joinleave" ]; then + make e2e-tests LABEL_FILTER="!custom && joinleave" else make e2e-tests-custom fi diff --git a/.github/workflows/codespell.yml b/.github/workflows/codespell.yml index 19b75e933..df3664f5e 100644 --- a/.github/workflows/codespell.yml +++ b/.github/workflows/codespell.yml @@ -12,7 +12,7 @@ jobs: runs-on: ubuntu-latest steps: - name: Harden Runner - uses: step-security/harden-runner@6c439dc8bdf85cadbbce9ed30d1c7b959517bc49 # v2.12.2 + uses: step-security/harden-runner@ec9f2d5744a09debf3a187a3f4f675c53b671911 # v2.13.0 with: egress-policy: audit diff --git a/CLAUDE.md b/CLAUDE.md index feaf7bd7b..08d0f7787 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -60,6 +60,8 @@ make setup-clusters # Run E2E tests with custom cluster count make setup-clusters MEMBER_CLUSTER_COUNT=5 + +# Run parallel E2E tests (default - excludes custom tests) make e2e-tests # Clean up test clusters diff --git a/Makefile b/Makefile index 658cf7b8f..ff4ade2e9 100644 --- a/Makefile +++ b/Makefile @@ -215,9 +215,12 @@ install-helm: load-hub-docker-image load-member-docker-image install-member-agen .PHONY: e2e-tests-v1alpha1 e2e-tests-v1alpha1: create-kind-cluster run-e2e-v1alpha1 +# E2E test label filter (can be overridden) +LABEL_FILTER ?= !custom + .PHONY: e2e-tests e2e-tests: setup-clusters - cd ./test/e2e && ginkgo --timeout=70m --label-filter="!custom" -v -p . + cd ./test/e2e && ginkgo --timeout=70m --label-filter="$(LABEL_FILTER)" -v -p . e2e-tests-custom: setup-clusters cd ./test/e2e && ginkgo --label-filter="custom" -v -p . diff --git a/apis/placement/v1alpha1/common.go b/apis/placement/v1alpha1/common.go deleted file mode 100644 index 2d5f36284..000000000 --- a/apis/placement/v1alpha1/common.go +++ /dev/null @@ -1,29 +0,0 @@ -package v1alpha1 - -const ( - fleetPrefix = "kubernetes-fleet.io/" - - // ClusterResourceOverrideKind is the kind of the ClusterResourceOverride. - ClusterResourceOverrideKind = "ClusterResourceOverride" - - // ClusterResourceOverrideSnapshotKind is the kind of the ClusterResourceOverrideSnapshot. - ClusterResourceOverrideSnapshotKind = "ClusterResourceOverrideSnapshot" - - // ResourceOverrideKind is the kind of the ResourceOverride. - ResourceOverrideKind = "ResourceOverride" - - // ResourceOverrideSnapshotKind is the kind of the ResourceOverrideSnapshot. - ResourceOverrideSnapshotKind = "ResourceOverrideSnapshot" - - // OverrideClusterNameVariable is the reserved variable in the override value that will be replaced by the actual cluster name. - OverrideClusterNameVariable = "${MEMBER-CLUSTER-NAME}" - - // OverrideClusterLabelKeyVariablePrefix is a reserved variable in the override expression. - // We use this variable to find the associated the key following the prefix. - // The key name ends with a "}" character (but not include it). - // The key name must be a valid Kubernetes label name and case-sensitive. - // The content of the string containing this variable will be replaced by the actual label value on the member cluster. - // For example, if the string is "${MEMBER-CLUSTER-LABEL-KEY-kube-fleet.io/region}" then the key name is "kube-fleet.io/region". - // If there is a label "kube-fleet.io/region": "us-west-1" on the member cluster, this string will be replaced by "us-west-1". - OverrideClusterLabelKeyVariablePrefix = "${MEMBER-CLUSTER-LABEL-KEY-" -) diff --git a/apis/placement/v1alpha1/overridesnapshot_types.go b/apis/placement/v1alpha1/overridesnapshot_types.go index 041a5b62d..94e2f8725 100644 --- a/apis/placement/v1alpha1/overridesnapshot_types.go +++ b/apis/placement/v1alpha1/overridesnapshot_types.go @@ -18,22 +18,6 @@ package v1alpha1 import metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" -const ( - - // OverrideIndexLabel is the label that indicate the policy snapshot index of a cluster policy. - OverrideIndexLabel = fleetPrefix + "override-index" - - // OverrideSnapshotNameFmt is clusterResourceOverrideSnapshot name format: {CROName}-{OverrideSnapshotIndex}. - OverrideSnapshotNameFmt = "%s-%d" - - // OverrideTrackingLabel is the label that points to the cluster resource override that creates a resource snapshot. - OverrideTrackingLabel = fleetPrefix + "parent-resource-override" - - // OverrideFinalizer is a finalizer added by the override controllers to all override, to make sure - // that the override controller can react to override deletions if necessary. - OverrideFinalizer = fleetPrefix + "override-cleanup" -) - // +genclient // +genclient:nonNamespaced // +kubebuilder:object:root=true diff --git a/apis/placement/v1beta1/clusterresourceplacement_types.go b/apis/placement/v1beta1/clusterresourceplacement_types.go index eeef2c443..e17ff7648 100644 --- a/apis/placement/v1beta1/clusterresourceplacement_types.go +++ b/apis/placement/v1beta1/clusterresourceplacement_types.go @@ -488,6 +488,10 @@ type RolloutStrategy struct { // ApplyStrategy describes when and how to apply the selected resources to the target cluster. // +kubebuilder:validation:Optional ApplyStrategy *ApplyStrategy `json:"applyStrategy,omitempty"` + + // DeleteStrategy configures the deletion behavior when the ClusterResourcePlacement is deleted. + // +kubebuilder:validation:Optional + DeleteStrategy *DeleteStrategy `json:"deleteStrategy,omitempty"` } // ApplyStrategy describes when and how to apply the selected resource to the target cluster. @@ -1319,6 +1323,38 @@ const ( PickFixedPlacementType PlacementType = "PickFixed" ) +// DeleteStrategy configures the deletion behavior when a placement is deleted. +type DeleteStrategy struct { + // PropagationPolicy controls whether to delete placed resources when placement is deleted. + // + // Available options: + // + // * Delete: all placed resources on member clusters will be deleted when + // the placement is deleted. This is the default behavior. + // + // * Abandon: all placed resources on member clusters will be left intact (abandoned) + // when the placement is deleted. + // + // +kubebuilder:validation:Enum=Abandon;Delete + // +kubebuilder:default=Delete + // +kubebuilder:validation:Optional + PropagationPolicy DeletePropagationPolicy `json:"propagationPolicy,omitempty"` +} + +// DeletePropagationPolicy identifies the propagation policy when a placement is deleted. +// +enum +type DeletePropagationPolicy string + +const ( + // DeletePropagationPolicyAbandon instructs Fleet to leave (abandon) all placed resources on member + // clusters when the placement is deleted. + DeletePropagationPolicyAbandon DeletePropagationPolicy = "Abandon" + + // DeletePropagationPolicyDelete instructs Fleet to delete all placed resources on member clusters + // when the placement is deleted. This is the default behavior. + DeletePropagationPolicyDelete DeletePropagationPolicy = "Delete" +) + // ClusterResourcePlacementList contains a list of ClusterResourcePlacement. // +kubebuilder:resource:scope="Cluster" // +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object diff --git a/apis/placement/v1beta1/commons.go b/apis/placement/v1beta1/commons.go index 74a0d09e0..199aac228 100644 --- a/apis/placement/v1beta1/commons.go +++ b/apis/placement/v1beta1/commons.go @@ -148,6 +148,32 @@ const ( ApprovalTaskNameFmt = "%s-%s" ) +var ( + // ClusterResourceOverrideKind is the kind of the ClusterResourceOverride. + ClusterResourceOverrideKind = "ClusterResourceOverride" + + // ClusterResourceOverrideSnapshotKind is the kind of the ClusterResourceOverrideSnapshot. + ClusterResourceOverrideSnapshotKind = "ClusterResourceOverrideSnapshot" + + // ResourceOverrideKind is the kind of the ResourceOverride. + ResourceOverrideKind = "ResourceOverride" + + // ResourceOverrideSnapshotKind is the kind of the ResourceOverrideSnapshot. + ResourceOverrideSnapshotKind = "ResourceOverrideSnapshot" + + // OverrideClusterNameVariable is the reserved variable in the override value that will be replaced by the actual cluster name. + OverrideClusterNameVariable = "${MEMBER-CLUSTER-NAME}" + + // OverrideClusterLabelKeyVariablePrefix is a reserved variable in the override expression. + // We use this variable to find the associated the key following the prefix. + // The key name ends with a "}" character (but not include it). + // The key name must be a valid Kubernetes label name and case-sensitive. + // The content of the string containing this variable will be replaced by the actual label value on the member cluster. + // For example, if the string is "${MEMBER-CLUSTER-LABEL-KEY-kube-fleet.io/region}" then the key name is "kube-fleet.io/region". + // If there is a label "kube-fleet.io/region": "us-west-1" on the member cluster, this string will be replaced by "us-west-1". + OverrideClusterLabelKeyVariablePrefix = "${MEMBER-CLUSTER-LABEL-KEY-" +) + // NamespacedName comprises a resource name, with a mandatory namespace. type NamespacedName struct { // Name is the name of the namespaced scope resource. diff --git a/apis/placement/v1beta1/override_types.go b/apis/placement/v1beta1/override_types.go new file mode 100644 index 000000000..058daf200 --- /dev/null +++ b/apis/placement/v1beta1/override_types.go @@ -0,0 +1,294 @@ +/* +Copyright 2025 The KubeFleet 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 v1beta1 + +import ( + apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +// +genclient +// +genclient:nonNamespaced +// +kubebuilder:object:root=true +// +kubebuilder:storageversion +// +kubebuilder:resource:scope="Cluster",categories={fleet,fleet-placement} +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// ClusterResourceOverride defines a group of override policies about how to override the selected cluster scope resources +// to target clusters. +type ClusterResourceOverride struct { + metav1.TypeMeta `json:",inline"` + metav1.ObjectMeta `json:"metadata,omitempty"` + + // The desired state of ClusterResourceOverrideSpec. + // +required + Spec ClusterResourceOverrideSpec `json:"spec"` +} + +// ClusterResourceOverrideSpec defines the desired state of the Override. +// The ClusterResourceOverride create or update will fail when the resource has been selected by the existing ClusterResourceOverride. +// If the resource is selected by both ClusterResourceOverride and ResourceOverride, ResourceOverride will win when resolving +// conflicts. +type ClusterResourceOverrideSpec struct { + // Placement defines whether the override is applied to a specific placement or not. + // If set, the override will trigger the placement rollout immediately when the rollout strategy type is RollingUpdate. + // Otherwise, it will be applied to the next rollout. + // The recommended way is to set the placement so that the override can be rolled out immediately. + // +optional + Placement *PlacementRef `json:"placement,omitempty"` + + // ClusterResourceSelectors is an array of selectors used to select cluster scoped resources. The selectors are `ORed`. + // If a namespace is selected, ALL the resources under the namespace are selected automatically. + // LabelSelector is not supported. + // You can have 1-20 selectors. + // We only support Name selector for now. + // +kubebuilder:validation:Required + // +kubebuilder:validation:MinItems=1 + // +kubebuilder:validation:MaxItems=20 + // +required + ClusterResourceSelectors []ClusterResourceSelector `json:"clusterResourceSelectors"` + + // Policy defines how to override the selected resources on the target clusters. + // +required + Policy *OverridePolicy `json:"policy"` +} + +// PlacementRef is the reference to a placement. +// For now, we only support ClusterResourcePlacement. +type PlacementRef struct { + // Name is the reference to the name of placement. + // +required + Name string `json:"name"` +} + +// OverridePolicy defines how to override the selected resources on the target clusters. +// More is to be added. +type OverridePolicy struct { + // OverrideRules defines an array of override rules to be applied on the selected resources. + // The order of the rules determines the override order. + // When there are two rules selecting the same fields on the target cluster, the last one will win. + // You can have 1-20 rules. + // +kubebuilder:validation:Required + // +kubebuilder:validation:MinItems=1 + // +kubebuilder:validation:MaxItems=20 + // +required + OverrideRules []OverrideRule `json:"overrideRules"` +} + +// OverrideRule defines how to override the selected resources on the target clusters. +type OverrideRule struct { + // ClusterSelectors selects the target clusters. + // The resources will be overridden before applying to the matching clusters. + // An empty clusterSelector selects ALL the member clusters. + // A nil clusterSelector selects NO member clusters. + // For now, only labelSelector is supported. + // +optional + ClusterSelector *ClusterSelector `json:"clusterSelector,omitempty"` + + // OverrideType defines the type of the override rules. + // +kubebuilder:validation:Enum=JSONPatch;Delete + // +kubebuilder:default=JSONPatch + // +optional + OverrideType OverrideType `json:"overrideType,omitempty"` + + // JSONPatchOverrides defines a list of JSON patch override rules. + // This field is only allowed when OverrideType is JSONPatch. + // +kubebuilder:validation:MinItems=1 + // +kubebuilder:validation:MaxItems=20 + // +optional + JSONPatchOverrides []JSONPatchOverride `json:"jsonPatchOverrides,omitempty"` +} + +// OverrideType defines the type of Override +type OverrideType string + +const ( + // JSONPatchOverrideType applies a JSON patch on the selected resources following [RFC 6902](https://datatracker.ietf.org/doc/html/rfc6902). + JSONPatchOverrideType OverrideType = "JSONPatch" + + // DeleteOverrideType deletes the selected resources on the target clusters. + DeleteOverrideType OverrideType = "Delete" +) + +// +genclient +// +genclient:Namespaced +// +kubebuilder:object:root=true +// +kubebuilder:storageversion +// +kubebuilder:resource:scope="Namespaced",categories={fleet,fleet-placement} +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// ResourceOverride defines a group of override policies about how to override the selected namespaced scope resources +// to target clusters. +type ResourceOverride struct { + metav1.TypeMeta `json:",inline"` + metav1.ObjectMeta `json:"metadata,omitempty"` + + // The desired state of ResourceOverrideSpec. + // +required + Spec ResourceOverrideSpec `json:"spec"` +} + +// ResourceOverrideSpec defines the desired state of the Override. +// The ResourceOverride create or update will fail when the resource has been selected by the existing ResourceOverride. +// If the resource is selected by both ClusterResourceOverride and ResourceOverride, ResourceOverride will win when resolving +// conflicts. +type ResourceOverrideSpec struct { + // Placement defines whether the override is applied to a specific placement or not. + // If set, the override will trigger the placement rollout immediately when the rollout strategy type is RollingUpdate. + // Otherwise, it will be applied to the next rollout. + // The recommended way is to set the placement so that the override can be rolled out immediately. + // +optional + Placement *PlacementRef `json:"placement,omitempty"` + + // ResourceSelectors is an array of selectors used to select namespace scoped resources. The selectors are `ORed`. + // You can have 1-20 selectors. + // +kubebuilder:validation:Required + // +kubebuilder:validation:MinItems=1 + // +kubebuilder:validation:MaxItems=20 + // +required + ResourceSelectors []ResourceSelector `json:"resourceSelectors"` + + // Policy defines how to override the selected resources on the target clusters. + // +required + Policy *OverridePolicy `json:"policy"` +} + +// ResourceSelector is used to select namespace scoped resources as the target resources to be placed. +// All the fields are `ANDed`. In other words, a resource must match all the fields to be selected. +// The resource namespace will inherit from the parent object scope. +type ResourceSelector struct { + // Group name of the namespace-scoped resource. + // Use an empty string to select resources under the core API group (e.g., services). + // +required + Group string `json:"group"` + + // Version of the namespace-scoped resource. + // +required + Version string `json:"version"` + + // Kind of the namespace-scoped resource. + // +required + Kind string `json:"kind"` + + // Name of the namespace-scoped resource. + // +required + Name string `json:"name"` +} + +// JSONPatchOverride applies a JSON patch on the selected resources following [RFC 6902](https://datatracker.ietf.org/doc/html/rfc6902). +type JSONPatchOverride struct { + // Operator defines the operation on the target field. + // +kubebuilder:validation:Enum=add;remove;replace + // +required + Operator JSONPatchOverrideOperator `json:"op"` + // Path defines the target location. + // Note: override will fail if the resource path does not exist. + // +required + Path string `json:"path"` + // Value defines the content to be applied on the target location. + // Value should be empty when operator is `remove`. + // We have reserved a few variables in this field that will be replaced by the actual values. + // Those variables all start with `$` and are case sensitive. + // Here is the list of currently supported variables: + // `${MEMBER-CLUSTER-NAME}`: this will be replaced by the name of the memberCluster CR that represents this cluster. + // +optional + Value apiextensionsv1.JSON `json:"value,omitempty"` +} + +// JSONPatchOverrideOperator defines the supported JSON patch operator. +type JSONPatchOverrideOperator string + +const ( + // JSONPatchOverrideOpAdd adds the value to the target location. + // An example target JSON document: + // + // { "foo": [ "bar", "baz" ] } + // + // A JSON Patch override: + // + // [ + // { "op": "add", "path": "/foo/1", "value": "qux" } + // ] + // + // The resulting JSON document: + // + // { "foo": [ "bar", "qux", "baz" ] } + JSONPatchOverrideOpAdd JSONPatchOverrideOperator = "add" + // JSONPatchOverrideOpRemove removes the value from the target location. + // An example target JSON document: + // + // { + // "baz": "qux", + // "foo": "bar" + // } + // A JSON Patch override: + // + // [ + // { "op": "remove", "path": "/baz" } + // ] + // + // The resulting JSON document: + // + // { "foo": "bar" } + JSONPatchOverrideOpRemove JSONPatchOverrideOperator = "remove" + // JSONPatchOverrideOpReplace replaces the value at the target location with a new value. + // An example target JSON document: + // + // { + // "baz": "qux", + // "foo": "bar" + // } + // + // A JSON Patch override: + // + // [ + // { "op": "replace", "path": "/baz", "value": "boo" } + // ] + // + // The resulting JSON document: + // + // { + // "baz": "boo", + // "foo": "bar" + // } + JSONPatchOverrideOpReplace JSONPatchOverrideOperator = "replace" +) + +// ClusterResourceOverrideList contains a list of ClusterResourceOverride. +// +kubebuilder:resource:scope="Cluster" +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +type ClusterResourceOverrideList struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata,omitempty"` + Items []ClusterResourceOverride `json:"items"` +} + +// ResourceOverrideList contains a list of ResourceOverride. +// +kubebuilder:resource:scope="Namespaced" +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +type ResourceOverrideList struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata,omitempty"` + Items []ResourceOverride `json:"items"` +} + +func init() { + SchemeBuilder.Register( + &ClusterResourceOverride{}, &ClusterResourceOverrideList{}, + &ResourceOverride{}, &ResourceOverrideList{}, + ) +} diff --git a/apis/placement/v1beta1/overridesnapshot_types.go b/apis/placement/v1beta1/overridesnapshot_types.go new file mode 100644 index 000000000..aec163412 --- /dev/null +++ b/apis/placement/v1beta1/overridesnapshot_types.go @@ -0,0 +1,130 @@ +/* +Copyright 2025 The KubeFleet 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 v1beta1 + +import metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + +const ( + + // OverrideIndexLabel is the label that indicate the policy snapshot index of a cluster policy. + OverrideIndexLabel = fleetPrefix + "override-index" + + // OverrideSnapshotNameFmt is clusterResourceOverrideSnapshot name format: {CROName}-{OverrideSnapshotIndex}. + OverrideSnapshotNameFmt = "%s-%d" + + // OverrideTrackingLabel is the label that points to the cluster resource override that creates a resource snapshot. + OverrideTrackingLabel = fleetPrefix + "parent-resource-override" + + // OverrideFinalizer is a finalizer added by the override controllers to all override, to make sure + // that the override controller can react to override deletions if necessary. + OverrideFinalizer = fleetPrefix + "override-cleanup" +) + +// +genclient +// +genclient:nonNamespaced +// +kubebuilder:object:root=true +// +kubebuilder:storageversion +// +kubebuilder:resource:scope="Cluster",categories={fleet,fleet-placement} +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// ClusterResourceOverrideSnapshot is used to store a snapshot of ClusterResourceOverride. +// Its spec is immutable. +// We assign an ever-increasing index for snapshots. +// The naming convention of a ClusterResourceOverrideSnapshot is {ClusterResourceOverride}-{resourceIndex}. +// resourceIndex will begin with 0. +// Each snapshot MUST have the following labels: +// - `OverrideTrackingLabel` which points to its owner ClusterResourceOverride. +// - `IsLatestSnapshotLabel` which indicates whether the snapshot is the latest one. +type ClusterResourceOverrideSnapshot struct { + metav1.TypeMeta `json:",inline"` + metav1.ObjectMeta `json:"metadata,omitempty"` + + // The desired state of ClusterResourceOverrideSnapshotSpec. + // +required + Spec ClusterResourceOverrideSnapshotSpec `json:"spec"` + + // TODO: Add status fields for the controller to surface errors during reconciliation. +} + +// ClusterResourceOverrideSnapshotSpec defines the desired state of ClusterResourceOverride. +type ClusterResourceOverrideSnapshotSpec struct { + // OverrideSpec stores the spec of ClusterResourceOverride. + OverrideSpec ClusterResourceOverrideSpec `json:"overrideSpec"` + + // OverrideHash is the sha-256 hash value of the OverrideSpec field. + // +required + OverrideHash []byte `json:"overrideHash"` +} + +// +genclient +// +genclient:Namespaced +// +kubebuilder:object:root=true +// +kubebuilder:storageversion +// +kubebuilder:resource:scope="Namespaced",categories={fleet,fleet-placement} +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// ResourceOverrideSnapshot is used to store a snapshot of ResourceOverride. +// Its spec is immutable. +// We assign an ever-increasing index for snapshots. +// The naming convention of a ResourceOverrideSnapshot is {ResourceOverride}-{resourceIndex}. +// resourceIndex will begin with 0. +// Each snapshot MUST have the following labels: +// - `OverrideTrackingLabel` which points to its owner ResourceOverride. +// - `IsLatestSnapshotLabel` which indicates whether the snapshot is the latest one. +type ResourceOverrideSnapshot struct { + metav1.TypeMeta `json:",inline"` + metav1.ObjectMeta `json:"metadata,omitempty"` + + // The desired state of ResourceOverrideSnapshot. + // +required + Spec ResourceOverrideSnapshotSpec `json:"spec"` +} + +// ResourceOverrideSnapshotSpec defines the desired state of ResourceOverride. +type ResourceOverrideSnapshotSpec struct { + // OverrideSpec stores the spec of ResourceOverride. + OverrideSpec ResourceOverrideSpec `json:"overrideSpec"` + + // OverrideHash is the sha-256 hash value of the OverrideSpec field. + // +required + OverrideHash []byte `json:"overrideHash"` +} + +// ClusterResourceOverrideSnapshotList contains a list of ClusterResourceOverrideSnapshot. +// +kubebuilder:resource:scope="Cluster" +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +type ClusterResourceOverrideSnapshotList struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata,omitempty"` + Items []ClusterResourceOverrideSnapshot `json:"items"` +} + +// ResourceOverrideSnapshotList contains a list of ResourceOverrideSnapshot. +// +kubebuilder:resource:scope="Namespaced" +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +type ResourceOverrideSnapshotList struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata,omitempty"` + Items []ResourceOverrideSnapshot `json:"items"` +} + +func init() { + SchemeBuilder.Register( + &ClusterResourceOverrideSnapshot{}, &ClusterResourceOverrideSnapshotList{}, + &ResourceOverrideSnapshot{}, &ResourceOverrideSnapshotList{}, + ) +} diff --git a/apis/placement/v1beta1/zz_generated.deepcopy.go b/apis/placement/v1beta1/zz_generated.deepcopy.go index 1324bfb87..851e87d9b 100644 --- a/apis/placement/v1beta1/zz_generated.deepcopy.go +++ b/apis/placement/v1beta1/zz_generated.deepcopy.go @@ -484,6 +484,175 @@ func (in *ClusterResourceEnvelopeList) DeepCopyObject() runtime.Object { return nil } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ClusterResourceOverride) DeepCopyInto(out *ClusterResourceOverride) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + in.Spec.DeepCopyInto(&out.Spec) +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterResourceOverride. +func (in *ClusterResourceOverride) DeepCopy() *ClusterResourceOverride { + if in == nil { + return nil + } + out := new(ClusterResourceOverride) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *ClusterResourceOverride) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ClusterResourceOverrideList) DeepCopyInto(out *ClusterResourceOverrideList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]ClusterResourceOverride, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterResourceOverrideList. +func (in *ClusterResourceOverrideList) DeepCopy() *ClusterResourceOverrideList { + if in == nil { + return nil + } + out := new(ClusterResourceOverrideList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *ClusterResourceOverrideList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ClusterResourceOverrideSnapshot) DeepCopyInto(out *ClusterResourceOverrideSnapshot) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + in.Spec.DeepCopyInto(&out.Spec) +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterResourceOverrideSnapshot. +func (in *ClusterResourceOverrideSnapshot) DeepCopy() *ClusterResourceOverrideSnapshot { + if in == nil { + return nil + } + out := new(ClusterResourceOverrideSnapshot) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *ClusterResourceOverrideSnapshot) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ClusterResourceOverrideSnapshotList) DeepCopyInto(out *ClusterResourceOverrideSnapshotList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]ClusterResourceOverrideSnapshot, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterResourceOverrideSnapshotList. +func (in *ClusterResourceOverrideSnapshotList) DeepCopy() *ClusterResourceOverrideSnapshotList { + if in == nil { + return nil + } + out := new(ClusterResourceOverrideSnapshotList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *ClusterResourceOverrideSnapshotList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ClusterResourceOverrideSnapshotSpec) DeepCopyInto(out *ClusterResourceOverrideSnapshotSpec) { + *out = *in + in.OverrideSpec.DeepCopyInto(&out.OverrideSpec) + if in.OverrideHash != nil { + in, out := &in.OverrideHash, &out.OverrideHash + *out = make([]byte, len(*in)) + copy(*out, *in) + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterResourceOverrideSnapshotSpec. +func (in *ClusterResourceOverrideSnapshotSpec) DeepCopy() *ClusterResourceOverrideSnapshotSpec { + if in == nil { + return nil + } + out := new(ClusterResourceOverrideSnapshotSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ClusterResourceOverrideSpec) DeepCopyInto(out *ClusterResourceOverrideSpec) { + *out = *in + if in.Placement != nil { + in, out := &in.Placement, &out.Placement + *out = new(PlacementRef) + **out = **in + } + if in.ClusterResourceSelectors != nil { + in, out := &in.ClusterResourceSelectors, &out.ClusterResourceSelectors + *out = make([]ClusterResourceSelector, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.Policy != nil { + in, out := &in.Policy, &out.Policy + *out = new(OverridePolicy) + (*in).DeepCopyInto(*out) + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterResourceOverrideSpec. +func (in *ClusterResourceOverrideSpec) DeepCopy() *ClusterResourceOverrideSpec { + if in == nil { + return nil + } + out := new(ClusterResourceOverrideSpec) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *ClusterResourcePlacement) DeepCopyInto(out *ClusterResourcePlacement) { *out = *in @@ -1024,6 +1193,21 @@ func (in *ClusterUpdatingStatus) DeepCopy() *ClusterUpdatingStatus { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *DeleteStrategy) DeepCopyInto(out *DeleteStrategy) { + *out = *in +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DeleteStrategy. +func (in *DeleteStrategy) DeepCopy() *DeleteStrategy { + if in == nil { + return nil + } + out := new(DeleteStrategy) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *DiffDetails) DeepCopyInto(out *DiffDetails) { *out = *in @@ -1156,6 +1340,22 @@ func (in *FailedResourcePlacement) DeepCopy() *FailedResourcePlacement { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *JSONPatchOverride) DeepCopyInto(out *JSONPatchOverride) { + *out = *in + in.Value.DeepCopyInto(&out.Value) +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JSONPatchOverride. +func (in *JSONPatchOverride) DeepCopy() *JSONPatchOverride { + if in == nil { + return nil + } + out := new(JSONPatchOverride) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *Manifest) DeepCopyInto(out *Manifest) { *out = *in @@ -1220,6 +1420,55 @@ func (in *NamespacedName) DeepCopy() *NamespacedName { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *OverridePolicy) DeepCopyInto(out *OverridePolicy) { + *out = *in + if in.OverrideRules != nil { + in, out := &in.OverrideRules, &out.OverrideRules + *out = make([]OverrideRule, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OverridePolicy. +func (in *OverridePolicy) DeepCopy() *OverridePolicy { + if in == nil { + return nil + } + out := new(OverridePolicy) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *OverrideRule) DeepCopyInto(out *OverrideRule) { + *out = *in + if in.ClusterSelector != nil { + in, out := &in.ClusterSelector, &out.ClusterSelector + *out = new(ClusterSelector) + (*in).DeepCopyInto(*out) + } + if in.JSONPatchOverrides != nil { + in, out := &in.JSONPatchOverrides, &out.JSONPatchOverrides + *out = make([]JSONPatchOverride, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OverrideRule. +func (in *OverrideRule) DeepCopy() *OverrideRule { + if in == nil { + return nil + } + out := new(OverrideRule) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *PatchDetail) DeepCopyInto(out *PatchDetail) { *out = *in @@ -1339,6 +1588,21 @@ func (in *PlacementPolicy) DeepCopy() *PlacementPolicy { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *PlacementRef) DeepCopyInto(out *PlacementRef) { + *out = *in +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PlacementRef. +func (in *PlacementRef) DeepCopy() *PlacementRef { + if in == nil { + return nil + } + out := new(PlacementRef) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *PlacementSpec) DeepCopyInto(out *PlacementSpec) { *out = *in @@ -1714,6 +1978,173 @@ func (in *ResourceIdentifier) DeepCopy() *ResourceIdentifier { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ResourceOverride) DeepCopyInto(out *ResourceOverride) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + in.Spec.DeepCopyInto(&out.Spec) +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ResourceOverride. +func (in *ResourceOverride) DeepCopy() *ResourceOverride { + if in == nil { + return nil + } + out := new(ResourceOverride) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *ResourceOverride) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ResourceOverrideList) DeepCopyInto(out *ResourceOverrideList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]ResourceOverride, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ResourceOverrideList. +func (in *ResourceOverrideList) DeepCopy() *ResourceOverrideList { + if in == nil { + return nil + } + out := new(ResourceOverrideList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *ResourceOverrideList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ResourceOverrideSnapshot) DeepCopyInto(out *ResourceOverrideSnapshot) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + in.Spec.DeepCopyInto(&out.Spec) +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ResourceOverrideSnapshot. +func (in *ResourceOverrideSnapshot) DeepCopy() *ResourceOverrideSnapshot { + if in == nil { + return nil + } + out := new(ResourceOverrideSnapshot) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *ResourceOverrideSnapshot) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ResourceOverrideSnapshotList) DeepCopyInto(out *ResourceOverrideSnapshotList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]ResourceOverrideSnapshot, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ResourceOverrideSnapshotList. +func (in *ResourceOverrideSnapshotList) DeepCopy() *ResourceOverrideSnapshotList { + if in == nil { + return nil + } + out := new(ResourceOverrideSnapshotList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *ResourceOverrideSnapshotList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ResourceOverrideSnapshotSpec) DeepCopyInto(out *ResourceOverrideSnapshotSpec) { + *out = *in + in.OverrideSpec.DeepCopyInto(&out.OverrideSpec) + if in.OverrideHash != nil { + in, out := &in.OverrideHash, &out.OverrideHash + *out = make([]byte, len(*in)) + copy(*out, *in) + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ResourceOverrideSnapshotSpec. +func (in *ResourceOverrideSnapshotSpec) DeepCopy() *ResourceOverrideSnapshotSpec { + if in == nil { + return nil + } + out := new(ResourceOverrideSnapshotSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ResourceOverrideSpec) DeepCopyInto(out *ResourceOverrideSpec) { + *out = *in + if in.Placement != nil { + in, out := &in.Placement, &out.Placement + *out = new(PlacementRef) + **out = **in + } + if in.ResourceSelectors != nil { + in, out := &in.ResourceSelectors, &out.ResourceSelectors + *out = make([]ResourceSelector, len(*in)) + copy(*out, *in) + } + if in.Policy != nil { + in, out := &in.Policy, &out.Policy + *out = new(OverridePolicy) + (*in).DeepCopyInto(*out) + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ResourceOverrideSpec. +func (in *ResourceOverrideSpec) DeepCopy() *ResourceOverrideSpec { + if in == nil { + return nil + } + out := new(ResourceOverrideSpec) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *ResourcePlacement) DeepCopyInto(out *ResourcePlacement) { *out = *in @@ -1826,6 +2257,21 @@ func (in *ResourcePlacementStatus) DeepCopy() *ResourcePlacementStatus { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ResourceSelector) DeepCopyInto(out *ResourceSelector) { + *out = *in +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ResourceSelector. +func (in *ResourceSelector) DeepCopy() *ResourceSelector { + if in == nil { + return nil + } + out := new(ResourceSelector) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *ResourceSnapshot) DeepCopyInto(out *ResourceSnapshot) { *out = *in @@ -1972,6 +2418,11 @@ func (in *RolloutStrategy) DeepCopyInto(out *RolloutStrategy) { *out = new(ApplyStrategy) (*in).DeepCopyInto(*out) } + if in.DeleteStrategy != nil { + in, out := &in.DeleteStrategy, &out.DeleteStrategy + *out = new(DeleteStrategy) + **out = **in + } } // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RolloutStrategy. diff --git a/cmd/hubagent/workload/setup.go b/cmd/hubagent/workload/setup.go index c1c22f60b..ce0715fe7 100644 --- a/cmd/hubagent/workload/setup.go +++ b/cmd/hubagent/workload/setup.go @@ -32,7 +32,6 @@ import ( workv1alpha1 "sigs.k8s.io/work-api/pkg/apis/v1alpha1" clusterv1beta1 "go.goms.io/fleet/apis/cluster/v1beta1" - placementv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" fleetv1alpha1 "go.goms.io/fleet/apis/v1alpha1" "go.goms.io/fleet/cmd/hubagent/options" @@ -91,10 +90,10 @@ var ( placementv1beta1.GroupVersion.WithKind(placementv1beta1.ClusterResourceSnapshotKind), placementv1beta1.GroupVersion.WithKind(placementv1beta1.ClusterSchedulingPolicySnapshotKind), placementv1beta1.GroupVersion.WithKind(placementv1beta1.WorkKind), - placementv1alpha1.GroupVersion.WithKind(placementv1alpha1.ClusterResourceOverrideKind), - placementv1alpha1.GroupVersion.WithKind(placementv1alpha1.ClusterResourceOverrideSnapshotKind), - placementv1alpha1.GroupVersion.WithKind(placementv1alpha1.ResourceOverrideKind), - placementv1alpha1.GroupVersion.WithKind(placementv1alpha1.ResourceOverrideSnapshotKind), + placementv1beta1.GroupVersion.WithKind(placementv1beta1.ClusterResourceOverrideKind), + placementv1beta1.GroupVersion.WithKind(placementv1beta1.ClusterResourceOverrideSnapshotKind), + placementv1beta1.GroupVersion.WithKind(placementv1beta1.ResourceOverrideKind), + placementv1beta1.GroupVersion.WithKind(placementv1beta1.ResourceOverrideSnapshotKind), } clusterStagedUpdateRunGVKs = []schema.GroupVersionKind{ diff --git a/config/crd/bases/placement.kubernetes-fleet.io_clusterresourcebindings.yaml b/config/crd/bases/placement.kubernetes-fleet.io_clusterresourcebindings.yaml index 25e47d643..56a8608fb 100644 --- a/config/crd/bases/placement.kubernetes-fleet.io_clusterresourcebindings.yaml +++ b/config/crd/bases/placement.kubernetes-fleet.io_clusterresourcebindings.yaml @@ -542,8 +542,8 @@ spec: managed by Fleet (i.e., specified in the hub cluster manifest). This is the default option. - Note that this option would revert any ad-hoc changes made on the member cluster side in - the managed fields; if you would like to make temporary edits on the member cluster side + Note that this option would revert any ad-hoc changes made on the member cluster side in the + managed fields; if you would like to make temporary edits on the member cluster side in the managed fields, switch to IfNotDrifted option. Note that changes in unmanaged fields will be left alone; if you use the FullDiff compare option, such changes will be reported as drifts. diff --git a/config/crd/bases/placement.kubernetes-fleet.io_clusterresourceoverrides.yaml b/config/crd/bases/placement.kubernetes-fleet.io_clusterresourceoverrides.yaml index 96593c0b3..8601fa218 100644 --- a/config/crd/bases/placement.kubernetes-fleet.io_clusterresourceoverrides.yaml +++ b/config/crd/bases/placement.kubernetes-fleet.io_clusterresourceoverrides.yaml @@ -366,4 +366,354 @@ spec: - spec type: object served: true + storage: false + - name: v1beta1 + schema: + openAPIV3Schema: + description: |- + ClusterResourceOverride defines a group of override policies about how to override the selected cluster scope resources + to target clusters. + properties: + apiVersion: + description: |- + APIVersion defines the versioned schema of this representation of an object. + Servers should convert recognized schemas to the latest internal value, and + may reject unrecognized values. + More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources + type: string + kind: + description: |- + Kind is a string value representing the REST resource this object represents. + Servers may infer this from the endpoint the client submits requests to. + Cannot be updated. + In CamelCase. + More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds + type: string + metadata: + type: object + spec: + description: The desired state of ClusterResourceOverrideSpec. + properties: + clusterResourceSelectors: + description: |- + ClusterResourceSelectors is an array of selectors used to select cluster scoped resources. The selectors are `ORed`. + If a namespace is selected, ALL the resources under the namespace are selected automatically. + LabelSelector is not supported. + You can have 1-20 selectors. + We only support Name selector for now. + items: + description: |- + ClusterResourceSelector is used to select cluster scoped resources as the target resources to be placed. + All the fields are `ANDed`. In other words, a resource must match all the fields to be selected. + properties: + group: + description: |- + Group name of the cluster-scoped resource. + Use an empty string to select resources under the core API group (e.g., namespaces). + type: string + kind: + description: |- + Kind of the cluster-scoped resource. + Note: When `Kind` is `namespace`, ALL the resources under the selected namespaces are selected. + type: string + labelSelector: + description: |- + A label query over all the cluster-scoped resources. Resources matching the query are selected. + Note that namespace-scoped resources can't be selected even if they match the query. + properties: + matchExpressions: + description: matchExpressions is a list of label selector + requirements. The requirements are ANDed. + items: + description: |- + A label selector requirement is a selector that contains values, a key, and an operator that + relates the key and values. + properties: + key: + description: key is the label key that the selector + applies to. + type: string + operator: + description: |- + operator represents a key's relationship to a set of values. + Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: |- + values is an array of string values. If the operator is In or NotIn, + the values array must be non-empty. If the operator is Exists or DoesNotExist, + the values array must be empty. This array is replaced during a strategic + merge patch. + items: + type: string + type: array + x-kubernetes-list-type: atomic + required: + - key + - operator + type: object + type: array + x-kubernetes-list-type: atomic + matchLabels: + additionalProperties: + type: string + description: |- + matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels + map is equivalent to an element of matchExpressions, whose key field is "key", the + operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + type: object + x-kubernetes-map-type: atomic + name: + description: Name of the cluster-scoped resource. + type: string + version: + description: Version of the cluster-scoped resource. + type: string + required: + - group + - kind + - version + type: object + maxItems: 20 + minItems: 1 + type: array + placement: + description: |- + Placement defines whether the override is applied to a specific placement or not. + If set, the override will trigger the placement rollout immediately when the rollout strategy type is RollingUpdate. + Otherwise, it will be applied to the next rollout. + The recommended way is to set the placement so that the override can be rolled out immediately. + properties: + name: + description: Name is the reference to the name of placement. + type: string + required: + - name + type: object + policy: + description: Policy defines how to override the selected resources + on the target clusters. + properties: + overrideRules: + description: |- + OverrideRules defines an array of override rules to be applied on the selected resources. + The order of the rules determines the override order. + When there are two rules selecting the same fields on the target cluster, the last one will win. + You can have 1-20 rules. + items: + description: OverrideRule defines how to override the selected + resources on the target clusters. + properties: + clusterSelector: + description: |- + ClusterSelectors selects the target clusters. + The resources will be overridden before applying to the matching clusters. + An empty clusterSelector selects ALL the member clusters. + A nil clusterSelector selects NO member clusters. + For now, only labelSelector is supported. + properties: + clusterSelectorTerms: + description: ClusterSelectorTerms is a list of cluster + selector terms. The terms are `ORed`. + items: + properties: + labelSelector: + description: |- + LabelSelector is a label query over all the joined member clusters. Clusters matching + the query are selected. + + If you specify both label and property selectors in the same term, the results are AND'd. + properties: + matchExpressions: + description: matchExpressions is a list of + label selector requirements. The requirements + are ANDed. + items: + description: |- + A label selector requirement is a selector that contains values, a key, and an operator that + relates the key and values. + properties: + key: + description: key is the label key that + the selector applies to. + type: string + operator: + description: |- + operator represents a key's relationship to a set of values. + Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: |- + values is an array of string values. If the operator is In or NotIn, + the values array must be non-empty. If the operator is Exists or DoesNotExist, + the values array must be empty. This array is replaced during a strategic + merge patch. + items: + type: string + type: array + x-kubernetes-list-type: atomic + required: + - key + - operator + type: object + type: array + x-kubernetes-list-type: atomic + matchLabels: + additionalProperties: + type: string + description: |- + matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels + map is equivalent to an element of matchExpressions, whose key field is "key", the + operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + type: object + x-kubernetes-map-type: atomic + propertySelector: + description: |- + PropertySelector is a property query over all joined member clusters. Clusters matching + the query are selected. + + If you specify both label and property selectors in the same term, the results are AND'd. + + At this moment, PropertySelector can only be used with + `RequiredDuringSchedulingIgnoredDuringExecution` affinity terms. + + This field is beta-level; it is for the property-based scheduling feature and is only + functional when a property provider is enabled in the deployment. + properties: + matchExpressions: + description: MatchExpressions is an array + of PropertySelectorRequirements. The requirements + are AND'd. + items: + description: |- + PropertySelectorRequirement is a specific property requirement when picking clusters for + resource placement. + properties: + name: + description: Name is the name of the + property; it should be a Kubernetes + label name. + type: string + operator: + description: |- + Operator specifies the relationship between a cluster's observed value of the specified + property and the values given in the requirement. + type: string + values: + description: |- + Values are a list of values of the specified property which Fleet will compare against + the observed values of individual member clusters in accordance with the given + operator. + + At this moment, each value should be a Kubernetes quantity. For more information, see + https://pkg.go.dev/k8s.io/apimachinery/pkg/api/resource#Quantity. + + If the operator is Gt (greater than), Ge (greater than or equal to), Lt (less than), + or `Le` (less than or equal to), Eq (equal to), or Ne (ne), exactly one value must be + specified in the list. + items: + type: string + maxItems: 1 + type: array + required: + - name + - operator + - values + type: object + type: array + required: + - matchExpressions + type: object + propertySorter: + description: |- + PropertySorter sorts all matching clusters by a specific property and assigns different weights + to each cluster based on their observed property values. + + At this moment, PropertySorter can only be used with + `PreferredDuringSchedulingIgnoredDuringExecution` affinity terms. + + This field is beta-level; it is for the property-based scheduling feature and is only + functional when a property provider is enabled in the deployment. + properties: + name: + description: Name is the name of the property + which Fleet sorts clusters by. + type: string + sortOrder: + description: |- + SortOrder explains how Fleet should perform the sort; specifically, whether Fleet should + sort in ascending or descending order. + type: string + required: + - name + - sortOrder + type: object + type: object + maxItems: 10 + type: array + required: + - clusterSelectorTerms + type: object + jsonPatchOverrides: + description: |- + JSONPatchOverrides defines a list of JSON patch override rules. + This field is only allowed when OverrideType is JSONPatch. + items: + description: JSONPatchOverride applies a JSON patch on + the selected resources following [RFC 6902](https://datatracker.ietf.org/doc/html/rfc6902). + properties: + op: + description: Operator defines the operation on the + target field. + enum: + - add + - remove + - replace + type: string + path: + description: |- + Path defines the target location. + Note: override will fail if the resource path does not exist. + type: string + value: + description: |- + Value defines the content to be applied on the target location. + Value should be empty when operator is `remove`. + We have reserved a few variables in this field that will be replaced by the actual values. + Those variables all start with `$` and are case sensitive. + Here is the list of currently supported variables: + `${MEMBER-CLUSTER-NAME}`: this will be replaced by the name of the memberCluster CR that represents this cluster. + x-kubernetes-preserve-unknown-fields: true + required: + - op + - path + type: object + maxItems: 20 + minItems: 1 + type: array + overrideType: + default: JSONPatch + description: OverrideType defines the type of the override + rules. + enum: + - JSONPatch + - Delete + type: string + type: object + maxItems: 20 + minItems: 1 + type: array + required: + - overrideRules + type: object + required: + - clusterResourceSelectors + - policy + type: object + required: + - spec + type: object + served: true storage: true diff --git a/config/crd/bases/placement.kubernetes-fleet.io_clusterresourceoverridesnapshots.yaml b/config/crd/bases/placement.kubernetes-fleet.io_clusterresourceoverridesnapshots.yaml index 77d3e4d50..f8ad5cbfa 100644 --- a/config/crd/bases/placement.kubernetes-fleet.io_clusterresourceoverridesnapshots.yaml +++ b/config/crd/bases/placement.kubernetes-fleet.io_clusterresourceoverridesnapshots.yaml @@ -384,4 +384,372 @@ spec: - spec type: object served: true + storage: false + - name: v1beta1 + schema: + openAPIV3Schema: + description: |- + ClusterResourceOverrideSnapshot is used to store a snapshot of ClusterResourceOverride. + Its spec is immutable. + We assign an ever-increasing index for snapshots. + The naming convention of a ClusterResourceOverrideSnapshot is {ClusterResourceOverride}-{resourceIndex}. + resourceIndex will begin with 0. + Each snapshot MUST have the following labels: + - `OverrideTrackingLabel` which points to its owner ClusterResourceOverride. + - `IsLatestSnapshotLabel` which indicates whether the snapshot is the latest one. + properties: + apiVersion: + description: |- + APIVersion defines the versioned schema of this representation of an object. + Servers should convert recognized schemas to the latest internal value, and + may reject unrecognized values. + More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources + type: string + kind: + description: |- + Kind is a string value representing the REST resource this object represents. + Servers may infer this from the endpoint the client submits requests to. + Cannot be updated. + In CamelCase. + More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds + type: string + metadata: + type: object + spec: + description: The desired state of ClusterResourceOverrideSnapshotSpec. + properties: + overrideHash: + description: OverrideHash is the sha-256 hash value of the OverrideSpec + field. + format: byte + type: string + overrideSpec: + description: OverrideSpec stores the spec of ClusterResourceOverride. + properties: + clusterResourceSelectors: + description: |- + ClusterResourceSelectors is an array of selectors used to select cluster scoped resources. The selectors are `ORed`. + If a namespace is selected, ALL the resources under the namespace are selected automatically. + LabelSelector is not supported. + You can have 1-20 selectors. + We only support Name selector for now. + items: + description: |- + ClusterResourceSelector is used to select cluster scoped resources as the target resources to be placed. + All the fields are `ANDed`. In other words, a resource must match all the fields to be selected. + properties: + group: + description: |- + Group name of the cluster-scoped resource. + Use an empty string to select resources under the core API group (e.g., namespaces). + type: string + kind: + description: |- + Kind of the cluster-scoped resource. + Note: When `Kind` is `namespace`, ALL the resources under the selected namespaces are selected. + type: string + labelSelector: + description: |- + A label query over all the cluster-scoped resources. Resources matching the query are selected. + Note that namespace-scoped resources can't be selected even if they match the query. + properties: + matchExpressions: + description: matchExpressions is a list of label selector + requirements. The requirements are ANDed. + items: + description: |- + A label selector requirement is a selector that contains values, a key, and an operator that + relates the key and values. + properties: + key: + description: key is the label key that the selector + applies to. + type: string + operator: + description: |- + operator represents a key's relationship to a set of values. + Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: |- + values is an array of string values. If the operator is In or NotIn, + the values array must be non-empty. If the operator is Exists or DoesNotExist, + the values array must be empty. This array is replaced during a strategic + merge patch. + items: + type: string + type: array + x-kubernetes-list-type: atomic + required: + - key + - operator + type: object + type: array + x-kubernetes-list-type: atomic + matchLabels: + additionalProperties: + type: string + description: |- + matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels + map is equivalent to an element of matchExpressions, whose key field is "key", the + operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + type: object + x-kubernetes-map-type: atomic + name: + description: Name of the cluster-scoped resource. + type: string + version: + description: Version of the cluster-scoped resource. + type: string + required: + - group + - kind + - version + type: object + maxItems: 20 + minItems: 1 + type: array + placement: + description: |- + Placement defines whether the override is applied to a specific placement or not. + If set, the override will trigger the placement rollout immediately when the rollout strategy type is RollingUpdate. + Otherwise, it will be applied to the next rollout. + The recommended way is to set the placement so that the override can be rolled out immediately. + properties: + name: + description: Name is the reference to the name of placement. + type: string + required: + - name + type: object + policy: + description: Policy defines how to override the selected resources + on the target clusters. + properties: + overrideRules: + description: |- + OverrideRules defines an array of override rules to be applied on the selected resources. + The order of the rules determines the override order. + When there are two rules selecting the same fields on the target cluster, the last one will win. + You can have 1-20 rules. + items: + description: OverrideRule defines how to override the selected + resources on the target clusters. + properties: + clusterSelector: + description: |- + ClusterSelectors selects the target clusters. + The resources will be overridden before applying to the matching clusters. + An empty clusterSelector selects ALL the member clusters. + A nil clusterSelector selects NO member clusters. + For now, only labelSelector is supported. + properties: + clusterSelectorTerms: + description: ClusterSelectorTerms is a list of cluster + selector terms. The terms are `ORed`. + items: + properties: + labelSelector: + description: |- + LabelSelector is a label query over all the joined member clusters. Clusters matching + the query are selected. + + If you specify both label and property selectors in the same term, the results are AND'd. + properties: + matchExpressions: + description: matchExpressions is a list + of label selector requirements. The + requirements are ANDed. + items: + description: |- + A label selector requirement is a selector that contains values, a key, and an operator that + relates the key and values. + properties: + key: + description: key is the label key + that the selector applies to. + type: string + operator: + description: |- + operator represents a key's relationship to a set of values. + Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: |- + values is an array of string values. If the operator is In or NotIn, + the values array must be non-empty. If the operator is Exists or DoesNotExist, + the values array must be empty. This array is replaced during a strategic + merge patch. + items: + type: string + type: array + x-kubernetes-list-type: atomic + required: + - key + - operator + type: object + type: array + x-kubernetes-list-type: atomic + matchLabels: + additionalProperties: + type: string + description: |- + matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels + map is equivalent to an element of matchExpressions, whose key field is "key", the + operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + type: object + x-kubernetes-map-type: atomic + propertySelector: + description: |- + PropertySelector is a property query over all joined member clusters. Clusters matching + the query are selected. + + If you specify both label and property selectors in the same term, the results are AND'd. + + At this moment, PropertySelector can only be used with + `RequiredDuringSchedulingIgnoredDuringExecution` affinity terms. + + This field is beta-level; it is for the property-based scheduling feature and is only + functional when a property provider is enabled in the deployment. + properties: + matchExpressions: + description: MatchExpressions is an array + of PropertySelectorRequirements. The + requirements are AND'd. + items: + description: |- + PropertySelectorRequirement is a specific property requirement when picking clusters for + resource placement. + properties: + name: + description: Name is the name of + the property; it should be a Kubernetes + label name. + type: string + operator: + description: |- + Operator specifies the relationship between a cluster's observed value of the specified + property and the values given in the requirement. + type: string + values: + description: |- + Values are a list of values of the specified property which Fleet will compare against + the observed values of individual member clusters in accordance with the given + operator. + + At this moment, each value should be a Kubernetes quantity. For more information, see + https://pkg.go.dev/k8s.io/apimachinery/pkg/api/resource#Quantity. + + If the operator is Gt (greater than), Ge (greater than or equal to), Lt (less than), + or `Le` (less than or equal to), Eq (equal to), or Ne (ne), exactly one value must be + specified in the list. + items: + type: string + maxItems: 1 + type: array + required: + - name + - operator + - values + type: object + type: array + required: + - matchExpressions + type: object + propertySorter: + description: |- + PropertySorter sorts all matching clusters by a specific property and assigns different weights + to each cluster based on their observed property values. + + At this moment, PropertySorter can only be used with + `PreferredDuringSchedulingIgnoredDuringExecution` affinity terms. + + This field is beta-level; it is for the property-based scheduling feature and is only + functional when a property provider is enabled in the deployment. + properties: + name: + description: Name is the name of the property + which Fleet sorts clusters by. + type: string + sortOrder: + description: |- + SortOrder explains how Fleet should perform the sort; specifically, whether Fleet should + sort in ascending or descending order. + type: string + required: + - name + - sortOrder + type: object + type: object + maxItems: 10 + type: array + required: + - clusterSelectorTerms + type: object + jsonPatchOverrides: + description: |- + JSONPatchOverrides defines a list of JSON patch override rules. + This field is only allowed when OverrideType is JSONPatch. + items: + description: JSONPatchOverride applies a JSON patch + on the selected resources following [RFC 6902](https://datatracker.ietf.org/doc/html/rfc6902). + properties: + op: + description: Operator defines the operation on + the target field. + enum: + - add + - remove + - replace + type: string + path: + description: |- + Path defines the target location. + Note: override will fail if the resource path does not exist. + type: string + value: + description: |- + Value defines the content to be applied on the target location. + Value should be empty when operator is `remove`. + We have reserved a few variables in this field that will be replaced by the actual values. + Those variables all start with `$` and are case sensitive. + Here is the list of currently supported variables: + `${MEMBER-CLUSTER-NAME}`: this will be replaced by the name of the memberCluster CR that represents this cluster. + x-kubernetes-preserve-unknown-fields: true + required: + - op + - path + type: object + maxItems: 20 + minItems: 1 + type: array + overrideType: + default: JSONPatch + description: OverrideType defines the type of the override + rules. + enum: + - JSONPatch + - Delete + type: string + type: object + maxItems: 20 + minItems: 1 + type: array + required: + - overrideRules + type: object + required: + - clusterResourceSelectors + - policy + type: object + required: + - overrideHash + - overrideSpec + type: object + required: + - spec + type: object + served: true storage: true diff --git a/config/crd/bases/placement.kubernetes-fleet.io_clusterresourceplacements.yaml b/config/crd/bases/placement.kubernetes-fleet.io_clusterresourceplacements.yaml index 608ec863b..6d4c10c65 100644 --- a/config/crd/bases/placement.kubernetes-fleet.io_clusterresourceplacements.yaml +++ b/config/crd/bases/placement.kubernetes-fleet.io_clusterresourceplacements.yaml @@ -1807,8 +1807,8 @@ spec: managed by Fleet (i.e., specified in the hub cluster manifest). This is the default option. - Note that this option would revert any ad-hoc changes made on the member cluster side in - the managed fields; if you would like to make temporary edits on the member cluster side + Note that this option would revert any ad-hoc changes made on the member cluster side in the + managed fields; if you would like to make temporary edits on the member cluster side in the managed fields, switch to IfNotDrifted option. Note that changes in unmanaged fields will be left alone; if you use the FullDiff compare option, such changes will be reported as drifts. @@ -1905,6 +1905,27 @@ spec: - Never type: string type: object + deleteStrategy: + description: DeleteStrategy configures the deletion behavior when + the ClusterResourcePlacement is deleted. + properties: + propagationPolicy: + default: Delete + description: |- + PropagationPolicy controls whether to delete placed resources when placement is deleted. + + Available options: + + * Delete: all placed resources on member clusters will be deleted when + the placement is deleted. This is the default behavior. + + * Abandon: all placed resources on member clusters will be left intact (abandoned) + when the placement is deleted. + enum: + - Abandon + - Delete + type: string + type: object rollingUpdate: description: Rolling update config params. Present only if RolloutStrategyType = RollingUpdate. diff --git a/config/crd/bases/placement.kubernetes-fleet.io_clusterresourcesnapshots.yaml b/config/crd/bases/placement.kubernetes-fleet.io_clusterresourcesnapshots.yaml index ee22b7d1e..72a3ef8a6 100644 --- a/config/crd/bases/placement.kubernetes-fleet.io_clusterresourcesnapshots.yaml +++ b/config/crd/bases/placement.kubernetes-fleet.io_clusterresourcesnapshots.yaml @@ -40,6 +40,8 @@ spec: Each snapshot MUST have the following labels: - `CRPTrackingLabel` which points to its owner CRP. - `ResourceIndexLabel` which is the index of the snapshot group. + + The first snapshot of the index group MAY have the following labels: - `IsLatestSnapshotLabel` which indicates whether the snapshot is the latest one. All the snapshots within the same index group must have the same ResourceIndexLabel. @@ -50,6 +52,9 @@ spec: Each snapshot (excluding the first snapshot) MUST have the following annotations: - `SubindexOfResourceSnapshotAnnotation` to store the subindex of resource snapshot in the group. + + Snapshot may have the following annotations to indicate the time of next resourceSnapshot candidate detected by the controller: + - `NextResourceSnapshotCandidateDetectionTimeAnnotation` to store the time of next resourceSnapshot candidate detected by the controller. properties: apiVersion: description: |- @@ -186,6 +191,9 @@ spec: Each snapshot (excluding the first snapshot) MUST have the following annotations: - `SubindexOfResourceSnapshotAnnotation` to store the subindex of resource snapshot in the group. + + Snapshot may have the following annotations to indicate the time of next resourceSnapshot candidate detected by the controller: + - `NextResourceSnapshotCandidateDetectionTimeAnnotation` to store the time of next resourceSnapshot candidate detected by the controller. properties: apiVersion: description: |- diff --git a/config/crd/bases/placement.kubernetes-fleet.io_clusterstagedupdateruns.yaml b/config/crd/bases/placement.kubernetes-fleet.io_clusterstagedupdateruns.yaml index e7c6ec68c..251a37ff5 100644 --- a/config/crd/bases/placement.kubernetes-fleet.io_clusterstagedupdateruns.yaml +++ b/config/crd/bases/placement.kubernetes-fleet.io_clusterstagedupdateruns.yaml @@ -235,8 +235,8 @@ spec: managed by Fleet (i.e., specified in the hub cluster manifest). This is the default option. - Note that this option would revert any ad-hoc changes made on the member cluster side in - the managed fields; if you would like to make temporary edits on the member cluster side + Note that this option would revert any ad-hoc changes made on the member cluster side in the + managed fields; if you would like to make temporary edits on the member cluster side in the managed fields, switch to IfNotDrifted option. Note that changes in unmanaged fields will be left alone; if you use the FullDiff compare option, such changes will be reported as drifts. @@ -1315,8 +1315,8 @@ spec: managed by Fleet (i.e., specified in the hub cluster manifest). This is the default option. - Note that this option would revert any ad-hoc changes made on the member cluster side in - the managed fields; if you would like to make temporary edits on the member cluster side + Note that this option would revert any ad-hoc changes made on the member cluster side in the + managed fields; if you would like to make temporary edits on the member cluster side in the managed fields, switch to IfNotDrifted option. Note that changes in unmanaged fields will be left alone; if you use the FullDiff compare option, such changes will be reported as drifts. diff --git a/config/crd/bases/placement.kubernetes-fleet.io_resourcebindings.yaml b/config/crd/bases/placement.kubernetes-fleet.io_resourcebindings.yaml index e9bf763de..046ce7ece 100644 --- a/config/crd/bases/placement.kubernetes-fleet.io_resourcebindings.yaml +++ b/config/crd/bases/placement.kubernetes-fleet.io_resourcebindings.yaml @@ -190,8 +190,8 @@ spec: managed by Fleet (i.e., specified in the hub cluster manifest). This is the default option. - Note that this option would revert any ad-hoc changes made on the member cluster side in - the managed fields; if you would like to make temporary edits on the member cluster side + Note that this option would revert any ad-hoc changes made on the member cluster side in the + managed fields; if you would like to make temporary edits on the member cluster side in the managed fields, switch to IfNotDrifted option. Note that changes in unmanaged fields will be left alone; if you use the FullDiff compare option, such changes will be reported as drifts. diff --git a/config/crd/bases/placement.kubernetes-fleet.io_resourceoverrides.yaml b/config/crd/bases/placement.kubernetes-fleet.io_resourceoverrides.yaml index e7a1a7018..7216898c1 100644 --- a/config/crd/bases/placement.kubernetes-fleet.io_resourceoverrides.yaml +++ b/config/crd/bases/placement.kubernetes-fleet.io_resourceoverrides.yaml @@ -315,4 +315,303 @@ spec: - spec type: object served: true + storage: false + - name: v1beta1 + schema: + openAPIV3Schema: + description: |- + ResourceOverride defines a group of override policies about how to override the selected namespaced scope resources + to target clusters. + properties: + apiVersion: + description: |- + APIVersion defines the versioned schema of this representation of an object. + Servers should convert recognized schemas to the latest internal value, and + may reject unrecognized values. + More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources + type: string + kind: + description: |- + Kind is a string value representing the REST resource this object represents. + Servers may infer this from the endpoint the client submits requests to. + Cannot be updated. + In CamelCase. + More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds + type: string + metadata: + type: object + spec: + description: The desired state of ResourceOverrideSpec. + properties: + placement: + description: |- + Placement defines whether the override is applied to a specific placement or not. + If set, the override will trigger the placement rollout immediately when the rollout strategy type is RollingUpdate. + Otherwise, it will be applied to the next rollout. + The recommended way is to set the placement so that the override can be rolled out immediately. + properties: + name: + description: Name is the reference to the name of placement. + type: string + required: + - name + type: object + policy: + description: Policy defines how to override the selected resources + on the target clusters. + properties: + overrideRules: + description: |- + OverrideRules defines an array of override rules to be applied on the selected resources. + The order of the rules determines the override order. + When there are two rules selecting the same fields on the target cluster, the last one will win. + You can have 1-20 rules. + items: + description: OverrideRule defines how to override the selected + resources on the target clusters. + properties: + clusterSelector: + description: |- + ClusterSelectors selects the target clusters. + The resources will be overridden before applying to the matching clusters. + An empty clusterSelector selects ALL the member clusters. + A nil clusterSelector selects NO member clusters. + For now, only labelSelector is supported. + properties: + clusterSelectorTerms: + description: ClusterSelectorTerms is a list of cluster + selector terms. The terms are `ORed`. + items: + properties: + labelSelector: + description: |- + LabelSelector is a label query over all the joined member clusters. Clusters matching + the query are selected. + + If you specify both label and property selectors in the same term, the results are AND'd. + properties: + matchExpressions: + description: matchExpressions is a list of + label selector requirements. The requirements + are ANDed. + items: + description: |- + A label selector requirement is a selector that contains values, a key, and an operator that + relates the key and values. + properties: + key: + description: key is the label key that + the selector applies to. + type: string + operator: + description: |- + operator represents a key's relationship to a set of values. + Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: |- + values is an array of string values. If the operator is In or NotIn, + the values array must be non-empty. If the operator is Exists or DoesNotExist, + the values array must be empty. This array is replaced during a strategic + merge patch. + items: + type: string + type: array + x-kubernetes-list-type: atomic + required: + - key + - operator + type: object + type: array + x-kubernetes-list-type: atomic + matchLabels: + additionalProperties: + type: string + description: |- + matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels + map is equivalent to an element of matchExpressions, whose key field is "key", the + operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + type: object + x-kubernetes-map-type: atomic + propertySelector: + description: |- + PropertySelector is a property query over all joined member clusters. Clusters matching + the query are selected. + + If you specify both label and property selectors in the same term, the results are AND'd. + + At this moment, PropertySelector can only be used with + `RequiredDuringSchedulingIgnoredDuringExecution` affinity terms. + + This field is beta-level; it is for the property-based scheduling feature and is only + functional when a property provider is enabled in the deployment. + properties: + matchExpressions: + description: MatchExpressions is an array + of PropertySelectorRequirements. The requirements + are AND'd. + items: + description: |- + PropertySelectorRequirement is a specific property requirement when picking clusters for + resource placement. + properties: + name: + description: Name is the name of the + property; it should be a Kubernetes + label name. + type: string + operator: + description: |- + Operator specifies the relationship between a cluster's observed value of the specified + property and the values given in the requirement. + type: string + values: + description: |- + Values are a list of values of the specified property which Fleet will compare against + the observed values of individual member clusters in accordance with the given + operator. + + At this moment, each value should be a Kubernetes quantity. For more information, see + https://pkg.go.dev/k8s.io/apimachinery/pkg/api/resource#Quantity. + + If the operator is Gt (greater than), Ge (greater than or equal to), Lt (less than), + or `Le` (less than or equal to), Eq (equal to), or Ne (ne), exactly one value must be + specified in the list. + items: + type: string + maxItems: 1 + type: array + required: + - name + - operator + - values + type: object + type: array + required: + - matchExpressions + type: object + propertySorter: + description: |- + PropertySorter sorts all matching clusters by a specific property and assigns different weights + to each cluster based on their observed property values. + + At this moment, PropertySorter can only be used with + `PreferredDuringSchedulingIgnoredDuringExecution` affinity terms. + + This field is beta-level; it is for the property-based scheduling feature and is only + functional when a property provider is enabled in the deployment. + properties: + name: + description: Name is the name of the property + which Fleet sorts clusters by. + type: string + sortOrder: + description: |- + SortOrder explains how Fleet should perform the sort; specifically, whether Fleet should + sort in ascending or descending order. + type: string + required: + - name + - sortOrder + type: object + type: object + maxItems: 10 + type: array + required: + - clusterSelectorTerms + type: object + jsonPatchOverrides: + description: |- + JSONPatchOverrides defines a list of JSON patch override rules. + This field is only allowed when OverrideType is JSONPatch. + items: + description: JSONPatchOverride applies a JSON patch on + the selected resources following [RFC 6902](https://datatracker.ietf.org/doc/html/rfc6902). + properties: + op: + description: Operator defines the operation on the + target field. + enum: + - add + - remove + - replace + type: string + path: + description: |- + Path defines the target location. + Note: override will fail if the resource path does not exist. + type: string + value: + description: |- + Value defines the content to be applied on the target location. + Value should be empty when operator is `remove`. + We have reserved a few variables in this field that will be replaced by the actual values. + Those variables all start with `$` and are case sensitive. + Here is the list of currently supported variables: + `${MEMBER-CLUSTER-NAME}`: this will be replaced by the name of the memberCluster CR that represents this cluster. + x-kubernetes-preserve-unknown-fields: true + required: + - op + - path + type: object + maxItems: 20 + minItems: 1 + type: array + overrideType: + default: JSONPatch + description: OverrideType defines the type of the override + rules. + enum: + - JSONPatch + - Delete + type: string + type: object + maxItems: 20 + minItems: 1 + type: array + required: + - overrideRules + type: object + resourceSelectors: + description: |- + ResourceSelectors is an array of selectors used to select namespace scoped resources. The selectors are `ORed`. + You can have 1-20 selectors. + items: + description: |- + ResourceSelector is used to select namespace scoped resources as the target resources to be placed. + All the fields are `ANDed`. In other words, a resource must match all the fields to be selected. + The resource namespace will inherit from the parent object scope. + properties: + group: + description: |- + Group name of the namespace-scoped resource. + Use an empty string to select resources under the core API group (e.g., services). + type: string + kind: + description: Kind of the namespace-scoped resource. + type: string + name: + description: Name of the namespace-scoped resource. + type: string + version: + description: Version of the namespace-scoped resource. + type: string + required: + - group + - kind + - name + - version + type: object + maxItems: 20 + minItems: 1 + type: array + required: + - policy + - resourceSelectors + type: object + required: + - spec + type: object + served: true storage: true diff --git a/config/crd/bases/placement.kubernetes-fleet.io_resourceoverridesnapshots.yaml b/config/crd/bases/placement.kubernetes-fleet.io_resourceoverridesnapshots.yaml index e0e901dfb..f1246918c 100644 --- a/config/crd/bases/placement.kubernetes-fleet.io_resourceoverridesnapshots.yaml +++ b/config/crd/bases/placement.kubernetes-fleet.io_resourceoverridesnapshots.yaml @@ -333,4 +333,321 @@ spec: - spec type: object served: true + storage: false + - name: v1beta1 + schema: + openAPIV3Schema: + description: |- + ResourceOverrideSnapshot is used to store a snapshot of ResourceOverride. + Its spec is immutable. + We assign an ever-increasing index for snapshots. + The naming convention of a ResourceOverrideSnapshot is {ResourceOverride}-{resourceIndex}. + resourceIndex will begin with 0. + Each snapshot MUST have the following labels: + - `OverrideTrackingLabel` which points to its owner ResourceOverride. + - `IsLatestSnapshotLabel` which indicates whether the snapshot is the latest one. + properties: + apiVersion: + description: |- + APIVersion defines the versioned schema of this representation of an object. + Servers should convert recognized schemas to the latest internal value, and + may reject unrecognized values. + More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources + type: string + kind: + description: |- + Kind is a string value representing the REST resource this object represents. + Servers may infer this from the endpoint the client submits requests to. + Cannot be updated. + In CamelCase. + More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds + type: string + metadata: + type: object + spec: + description: The desired state of ResourceOverrideSnapshot. + properties: + overrideHash: + description: OverrideHash is the sha-256 hash value of the OverrideSpec + field. + format: byte + type: string + overrideSpec: + description: OverrideSpec stores the spec of ResourceOverride. + properties: + placement: + description: |- + Placement defines whether the override is applied to a specific placement or not. + If set, the override will trigger the placement rollout immediately when the rollout strategy type is RollingUpdate. + Otherwise, it will be applied to the next rollout. + The recommended way is to set the placement so that the override can be rolled out immediately. + properties: + name: + description: Name is the reference to the name of placement. + type: string + required: + - name + type: object + policy: + description: Policy defines how to override the selected resources + on the target clusters. + properties: + overrideRules: + description: |- + OverrideRules defines an array of override rules to be applied on the selected resources. + The order of the rules determines the override order. + When there are two rules selecting the same fields on the target cluster, the last one will win. + You can have 1-20 rules. + items: + description: OverrideRule defines how to override the selected + resources on the target clusters. + properties: + clusterSelector: + description: |- + ClusterSelectors selects the target clusters. + The resources will be overridden before applying to the matching clusters. + An empty clusterSelector selects ALL the member clusters. + A nil clusterSelector selects NO member clusters. + For now, only labelSelector is supported. + properties: + clusterSelectorTerms: + description: ClusterSelectorTerms is a list of cluster + selector terms. The terms are `ORed`. + items: + properties: + labelSelector: + description: |- + LabelSelector is a label query over all the joined member clusters. Clusters matching + the query are selected. + + If you specify both label and property selectors in the same term, the results are AND'd. + properties: + matchExpressions: + description: matchExpressions is a list + of label selector requirements. The + requirements are ANDed. + items: + description: |- + A label selector requirement is a selector that contains values, a key, and an operator that + relates the key and values. + properties: + key: + description: key is the label key + that the selector applies to. + type: string + operator: + description: |- + operator represents a key's relationship to a set of values. + Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: |- + values is an array of string values. If the operator is In or NotIn, + the values array must be non-empty. If the operator is Exists or DoesNotExist, + the values array must be empty. This array is replaced during a strategic + merge patch. + items: + type: string + type: array + x-kubernetes-list-type: atomic + required: + - key + - operator + type: object + type: array + x-kubernetes-list-type: atomic + matchLabels: + additionalProperties: + type: string + description: |- + matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels + map is equivalent to an element of matchExpressions, whose key field is "key", the + operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + type: object + x-kubernetes-map-type: atomic + propertySelector: + description: |- + PropertySelector is a property query over all joined member clusters. Clusters matching + the query are selected. + + If you specify both label and property selectors in the same term, the results are AND'd. + + At this moment, PropertySelector can only be used with + `RequiredDuringSchedulingIgnoredDuringExecution` affinity terms. + + This field is beta-level; it is for the property-based scheduling feature and is only + functional when a property provider is enabled in the deployment. + properties: + matchExpressions: + description: MatchExpressions is an array + of PropertySelectorRequirements. The + requirements are AND'd. + items: + description: |- + PropertySelectorRequirement is a specific property requirement when picking clusters for + resource placement. + properties: + name: + description: Name is the name of + the property; it should be a Kubernetes + label name. + type: string + operator: + description: |- + Operator specifies the relationship between a cluster's observed value of the specified + property and the values given in the requirement. + type: string + values: + description: |- + Values are a list of values of the specified property which Fleet will compare against + the observed values of individual member clusters in accordance with the given + operator. + + At this moment, each value should be a Kubernetes quantity. For more information, see + https://pkg.go.dev/k8s.io/apimachinery/pkg/api/resource#Quantity. + + If the operator is Gt (greater than), Ge (greater than or equal to), Lt (less than), + or `Le` (less than or equal to), Eq (equal to), or Ne (ne), exactly one value must be + specified in the list. + items: + type: string + maxItems: 1 + type: array + required: + - name + - operator + - values + type: object + type: array + required: + - matchExpressions + type: object + propertySorter: + description: |- + PropertySorter sorts all matching clusters by a specific property and assigns different weights + to each cluster based on their observed property values. + + At this moment, PropertySorter can only be used with + `PreferredDuringSchedulingIgnoredDuringExecution` affinity terms. + + This field is beta-level; it is for the property-based scheduling feature and is only + functional when a property provider is enabled in the deployment. + properties: + name: + description: Name is the name of the property + which Fleet sorts clusters by. + type: string + sortOrder: + description: |- + SortOrder explains how Fleet should perform the sort; specifically, whether Fleet should + sort in ascending or descending order. + type: string + required: + - name + - sortOrder + type: object + type: object + maxItems: 10 + type: array + required: + - clusterSelectorTerms + type: object + jsonPatchOverrides: + description: |- + JSONPatchOverrides defines a list of JSON patch override rules. + This field is only allowed when OverrideType is JSONPatch. + items: + description: JSONPatchOverride applies a JSON patch + on the selected resources following [RFC 6902](https://datatracker.ietf.org/doc/html/rfc6902). + properties: + op: + description: Operator defines the operation on + the target field. + enum: + - add + - remove + - replace + type: string + path: + description: |- + Path defines the target location. + Note: override will fail if the resource path does not exist. + type: string + value: + description: |- + Value defines the content to be applied on the target location. + Value should be empty when operator is `remove`. + We have reserved a few variables in this field that will be replaced by the actual values. + Those variables all start with `$` and are case sensitive. + Here is the list of currently supported variables: + `${MEMBER-CLUSTER-NAME}`: this will be replaced by the name of the memberCluster CR that represents this cluster. + x-kubernetes-preserve-unknown-fields: true + required: + - op + - path + type: object + maxItems: 20 + minItems: 1 + type: array + overrideType: + default: JSONPatch + description: OverrideType defines the type of the override + rules. + enum: + - JSONPatch + - Delete + type: string + type: object + maxItems: 20 + minItems: 1 + type: array + required: + - overrideRules + type: object + resourceSelectors: + description: |- + ResourceSelectors is an array of selectors used to select namespace scoped resources. The selectors are `ORed`. + You can have 1-20 selectors. + items: + description: |- + ResourceSelector is used to select namespace scoped resources as the target resources to be placed. + All the fields are `ANDed`. In other words, a resource must match all the fields to be selected. + The resource namespace will inherit from the parent object scope. + properties: + group: + description: |- + Group name of the namespace-scoped resource. + Use an empty string to select resources under the core API group (e.g., services). + type: string + kind: + description: Kind of the namespace-scoped resource. + type: string + name: + description: Name of the namespace-scoped resource. + type: string + version: + description: Version of the namespace-scoped resource. + type: string + required: + - group + - kind + - name + - version + type: object + maxItems: 20 + minItems: 1 + type: array + required: + - policy + - resourceSelectors + type: object + required: + - overrideHash + - overrideSpec + type: object + required: + - spec + type: object + served: true storage: true diff --git a/config/crd/bases/placement.kubernetes-fleet.io_resourceplacements.yaml b/config/crd/bases/placement.kubernetes-fleet.io_resourceplacements.yaml index 5bf28370e..1671e786d 100644 --- a/config/crd/bases/placement.kubernetes-fleet.io_resourceplacements.yaml +++ b/config/crd/bases/placement.kubernetes-fleet.io_resourceplacements.yaml @@ -742,8 +742,8 @@ spec: managed by Fleet (i.e., specified in the hub cluster manifest). This is the default option. - Note that this option would revert any ad-hoc changes made on the member cluster side in - the managed fields; if you would like to make temporary edits on the member cluster side + Note that this option would revert any ad-hoc changes made on the member cluster side in the + managed fields; if you would like to make temporary edits on the member cluster side in the managed fields, switch to IfNotDrifted option. Note that changes in unmanaged fields will be left alone; if you use the FullDiff compare option, such changes will be reported as drifts. @@ -840,6 +840,27 @@ spec: - Never type: string type: object + deleteStrategy: + description: DeleteStrategy configures the deletion behavior when + the ClusterResourcePlacement is deleted. + properties: + propagationPolicy: + default: Delete + description: |- + PropagationPolicy controls whether to delete placed resources when placement is deleted. + + Available options: + + * Delete: all placed resources on member clusters will be deleted when + the placement is deleted. This is the default behavior. + + * Abandon: all placed resources on member clusters will be left intact (abandoned) + when the placement is deleted. + enum: + - Abandon + - Delete + type: string + type: object rollingUpdate: description: Rolling update config params. Present only if RolloutStrategyType = RollingUpdate. diff --git a/config/crd/bases/placement.kubernetes-fleet.io_resourcesnapshots.yaml b/config/crd/bases/placement.kubernetes-fleet.io_resourcesnapshots.yaml index 3a05bd032..1d6265e1c 100644 --- a/config/crd/bases/placement.kubernetes-fleet.io_resourcesnapshots.yaml +++ b/config/crd/bases/placement.kubernetes-fleet.io_resourcesnapshots.yaml @@ -40,6 +40,8 @@ spec: Each snapshot MUST have the following labels: - `CRPTrackingLabel` which points to its owner resource placement. - `ResourceIndexLabel` which is the index of the snapshot group. + + The first snapshot of the index group MAY have the following labels: - `IsLatestSnapshotLabel` which indicates whether the snapshot is the latest one. All the snapshots within the same index group must have the same ResourceIndexLabel. diff --git a/config/crd/bases/placement.kubernetes-fleet.io_works.yaml b/config/crd/bases/placement.kubernetes-fleet.io_works.yaml index 13ca42a4a..66cec7ac2 100644 --- a/config/crd/bases/placement.kubernetes-fleet.io_works.yaml +++ b/config/crd/bases/placement.kubernetes-fleet.io_works.yaml @@ -433,8 +433,8 @@ spec: managed by Fleet (i.e., specified in the hub cluster manifest). This is the default option. - Note that this option would revert any ad-hoc changes made on the member cluster side in - the managed fields; if you would like to make temporary edits on the member cluster side + Note that this option would revert any ad-hoc changes made on the member cluster side in the + managed fields; if you would like to make temporary edits on the member cluster side in the managed fields, switch to IfNotDrifted option. Note that changes in unmanaged fields will be left alone; if you use the FullDiff compare option, such changes will be reported as drifts. diff --git a/go.mod b/go.mod index b4151af75..7834a19a3 100644 --- a/go.mod +++ b/go.mod @@ -106,7 +106,7 @@ require ( go.uber.org/multierr v1.11.0 // indirect golang.org/x/crypto v0.38.0 // indirect golang.org/x/net v0.40.0 // indirect - golang.org/x/oauth2 v0.24.0 // indirect + golang.org/x/oauth2 v0.27.0 // indirect golang.org/x/sys v0.33.0 // indirect golang.org/x/term v0.32.0 // indirect golang.org/x/text v0.25.0 // indirect diff --git a/go.sum b/go.sum index ff8c454ee..711e9a79b 100644 --- a/go.sum +++ b/go.sum @@ -325,8 +325,8 @@ golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLL golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY= golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds= -golang.org/x/oauth2 v0.24.0 h1:KTBBxWqUa0ykRPLtV69rRto9TLXcqYkeswu48x/gvNE= -golang.org/x/oauth2 v0.24.0/go.mod h1:XYTD2NtWslqkgxebSiOHnXEap4TF09sJSc7H1sXbhtI= +golang.org/x/oauth2 v0.27.0 h1:da9Vo7/tDv5RH/7nZDz1eMGS/q1Vv1N/7FCrBhI9I3M= +golang.org/x/oauth2 v0.27.0/go.mod h1:onh5ek6nERTohokkhCD/y2cV4Do3fxFHFuAejCkRWT8= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= diff --git a/pkg/controllers/overrider/clusterresource_controller.go b/pkg/controllers/overrider/clusterresource_controller.go index 8e6bd186f..470f0333d 100644 --- a/pkg/controllers/overrider/clusterresource_controller.go +++ b/pkg/controllers/overrider/clusterresource_controller.go @@ -31,7 +31,6 @@ import ( "sigs.k8s.io/controller-runtime/pkg/builder" "sigs.k8s.io/controller-runtime/pkg/predicate" - placementv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" "go.goms.io/fleet/pkg/utils/controller" "go.goms.io/fleet/pkg/utils/labels" @@ -46,7 +45,7 @@ type ClusterResourceReconciler struct { // Reconcile triggers a single reconcile round when scheduling policy has changed. func (r *ClusterResourceReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) { name := req.NamespacedName - clusterOverride := placementv1alpha1.ClusterResourceOverride{} + clusterOverride := placementv1beta1.ClusterResourceOverride{} overrideRef := klog.KRef(name.Namespace, name.Name) startTime := time.Now() @@ -68,7 +67,7 @@ func (r *ClusterResourceReconciler) Reconcile(ctx context.Context, req ctrl.Requ // Check if the clusterResourceOverride is being deleted if clusterOverride.DeletionTimestamp != nil { klog.V(4).InfoS("The clusterResourceOverride is being deleted", "clusterResourceOverride", overrideRef) - return ctrl.Result{}, r.handleOverrideDeleting(ctx, &placementv1alpha1.ClusterResourceOverrideSnapshot{}, &clusterOverride) + return ctrl.Result{}, r.handleOverrideDeleting(ctx, &placementv1beta1.ClusterResourceOverrideSnapshot{}, &clusterOverride) } // Ensure that we have the finalizer so we can delete all the related snapshots on cleanup @@ -81,7 +80,7 @@ func (r *ClusterResourceReconciler) Reconcile(ctx context.Context, req ctrl.Requ return ctrl.Result{}, r.ensureClusterResourceOverrideSnapshot(ctx, &clusterOverride, 10) } -func (r *ClusterResourceReconciler) ensureClusterResourceOverrideSnapshot(ctx context.Context, cro *placementv1alpha1.ClusterResourceOverride, revisionHistoryLimit int) error { +func (r *ClusterResourceReconciler) ensureClusterResourceOverrideSnapshot(ctx context.Context, cro *placementv1beta1.ClusterResourceOverride, revisionHistoryLimit int) error { croKObj := klog.KObj(cro) overridePolicy := cro.Spec overrideSpecHash, err := resource.HashOf(overridePolicy) @@ -103,7 +102,7 @@ func (r *ClusterResourceReconciler) ensureClusterResourceOverrideSnapshot(ctx co latestSnapshotIndex := -1 //so index start at 0 if len(snapshotList.Items) != 0 { // convert the last unstructured snapshot to the typed object - latestSnapshot := &placementv1alpha1.ClusterResourceOverrideSnapshot{} + latestSnapshot := &placementv1beta1.ClusterResourceOverrideSnapshot{} if err = runtime.DefaultUnstructuredConverter.FromUnstructured(snapshotList.Items[len(snapshotList.Items)-1].Object, latestSnapshot); err != nil { klog.ErrorS(err, "Invalid overrideSnapshot", "clusterResourceOverride", croKObj, "overrideSnapshot", klog.KObj(&snapshotList.Items[len(snapshotList.Items)-1])) return controller.NewUnexpectedBehaviorError(err) @@ -123,7 +122,7 @@ func (r *ClusterResourceReconciler) ensureClusterResourceOverrideSnapshot(ctx co klog.V(2).InfoS("Marked the latest overrideSnapshot as inactive", "clusterResourceOverride", croKObj, "overrideSnapshot", klog.KObj(latestSnapshot)) } // we need to figure out the last snapshot index. - latestSnapshotIndex, err = labels.ExtractIndex(latestSnapshot, placementv1alpha1.OverrideIndexLabel) + latestSnapshotIndex, err = labels.ExtractIndex(latestSnapshot, placementv1beta1.OverrideIndexLabel) if err != nil { klog.ErrorS(err, "Failed to parse the override index label", "clusterResourceOverride", croKObj, "overrideSnapshot", klog.KObj(latestSnapshot)) return controller.NewUnexpectedBehaviorError(err) @@ -132,19 +131,19 @@ func (r *ClusterResourceReconciler) ensureClusterResourceOverrideSnapshot(ctx co // Need to create new snapshot when 1) there is no snapshots or 2) the latest snapshot hash != current one. latestSnapshotIndex++ - newSnapshot := &placementv1alpha1.ClusterResourceOverrideSnapshot{ + newSnapshot := &placementv1beta1.ClusterResourceOverrideSnapshot{ ObjectMeta: metav1.ObjectMeta{ - Name: fmt.Sprintf(placementv1alpha1.OverrideSnapshotNameFmt, cro.Name, latestSnapshotIndex), + Name: fmt.Sprintf(placementv1beta1.OverrideSnapshotNameFmt, cro.Name, latestSnapshotIndex), Labels: map[string]string{ - placementv1alpha1.OverrideTrackingLabel: cro.Name, - placementv1beta1.IsLatestSnapshotLabel: strconv.FormatBool(true), - placementv1alpha1.OverrideIndexLabel: strconv.Itoa(latestSnapshotIndex), + placementv1beta1.OverrideTrackingLabel: cro.Name, + placementv1beta1.IsLatestSnapshotLabel: strconv.FormatBool(true), + placementv1beta1.OverrideIndexLabel: strconv.Itoa(latestSnapshotIndex), }, OwnerReferences: []metav1.OwnerReference{ - *metav1.NewControllerRef(cro, placementv1alpha1.GroupVersion.WithKind(placementv1alpha1.ClusterResourceOverrideKind)), + *metav1.NewControllerRef(cro, placementv1beta1.GroupVersion.WithKind(placementv1beta1.ClusterResourceOverrideKind)), }, }, - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ OverrideSpec: overridePolicy, OverrideHash: []byte(overrideSpecHash), }, @@ -161,6 +160,6 @@ func (r *ClusterResourceReconciler) ensureClusterResourceOverrideSnapshot(ctx co func (r *ClusterResourceReconciler) SetupWithManager(mgr ctrl.Manager) error { return ctrl.NewControllerManagedBy(mgr). Named("clusterresourceoverride-controller"). - For(&placementv1alpha1.ClusterResourceOverride{}, builder.WithPredicates(predicate.GenerationChangedPredicate{})). + For(&placementv1beta1.ClusterResourceOverride{}, builder.WithPredicates(predicate.GenerationChangedPredicate{})). Complete(r) } diff --git a/pkg/controllers/overrider/clusterresource_controller_integration_test.go b/pkg/controllers/overrider/clusterresource_controller_integration_test.go index 5b2335589..5f1cdccb9 100644 --- a/pkg/controllers/overrider/clusterresource_controller_integration_test.go +++ b/pkg/controllers/overrider/clusterresource_controller_integration_test.go @@ -29,26 +29,25 @@ import ( "k8s.io/apimachinery/pkg/types" "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil" - fleetv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" - fleetv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" + placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" "go.goms.io/fleet/pkg/utils" ) -func getClusterResourceOverrideSpec() fleetv1alpha1.ClusterResourceOverrideSpec { - return fleetv1alpha1.ClusterResourceOverrideSpec{ - ClusterResourceSelectors: []fleetv1beta1.ClusterResourceSelector{ +func getClusterResourceOverrideSpec() placementv1beta1.ClusterResourceOverrideSpec { + return placementv1beta1.ClusterResourceOverrideSpec{ + ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "", Version: "v1", Kind: "Namespace", }, }, - Policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - JSONPatchOverrides: []fleetv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: fleetv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "spec.replica", Value: apiextensionsv1.JSON{Raw: []byte("3")}, }, @@ -59,11 +58,11 @@ func getClusterResourceOverrideSpec() fleetv1alpha1.ClusterResourceOverrideSpec } } -func getClusterResourceOverride(testOverrideName string) *fleetv1alpha1.ClusterResourceOverride { - return &fleetv1alpha1.ClusterResourceOverride{ +func getClusterResourceOverride(testOverrideName string) *placementv1beta1.ClusterResourceOverride { + return &placementv1beta1.ClusterResourceOverride{ TypeMeta: metav1.TypeMeta{ - APIVersion: fleetv1alpha1.GroupVersion.String(), - Kind: fleetv1alpha1.ClusterResourceOverrideKind, + APIVersion: placementv1beta1.GroupVersion.String(), + Kind: placementv1beta1.ClusterResourceOverrideKind, }, ObjectMeta: metav1.ObjectMeta{ Name: testOverrideName, @@ -72,17 +71,17 @@ func getClusterResourceOverride(testOverrideName string) *fleetv1alpha1.ClusterR } } -func getClusterResourceOverrideSnapshot(testOverrideName string, index int) *fleetv1alpha1.ClusterResourceOverrideSnapshot { - return &fleetv1alpha1.ClusterResourceOverrideSnapshot{ +func getClusterResourceOverrideSnapshot(testOverrideName string, index int) *placementv1beta1.ClusterResourceOverrideSnapshot { + return &placementv1beta1.ClusterResourceOverrideSnapshot{ ObjectMeta: metav1.ObjectMeta{ - Name: fmt.Sprintf(fleetv1alpha1.OverrideSnapshotNameFmt, testOverrideName, index), + Name: fmt.Sprintf(placementv1beta1.OverrideSnapshotNameFmt, testOverrideName, index), Labels: map[string]string{ - fleetv1alpha1.OverrideIndexLabel: strconv.Itoa(index), - fleetv1beta1.IsLatestSnapshotLabel: "true", - fleetv1alpha1.OverrideTrackingLabel: testOverrideName, + placementv1beta1.OverrideIndexLabel: strconv.Itoa(index), + placementv1beta1.IsLatestSnapshotLabel: "true", + placementv1beta1.OverrideTrackingLabel: testOverrideName, }, }, - Spec: fleetv1alpha1.ClusterResourceOverrideSnapshotSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ OverrideHash: []byte("hash"), OverrideSpec: getClusterResourceOverrideSpec(), }, @@ -90,7 +89,7 @@ func getClusterResourceOverrideSnapshot(testOverrideName string, index int) *fle } var _ = Describe("Test ClusterResourceOverride controller logic", func() { - var cro *fleetv1alpha1.ClusterResourceOverride + var cro *placementv1beta1.ClusterResourceOverride var testCROName string BeforeEach(func() { @@ -112,7 +111,7 @@ var _ = Describe("Test ClusterResourceOverride controller logic", func() { if err != nil { return err } - if !controllerutil.ContainsFinalizer(cro, fleetv1alpha1.OverrideFinalizer) { + if !controllerutil.ContainsFinalizer(cro, placementv1beta1.OverrideFinalizer) { return fmt.Errorf("finalizer not added") } return nil @@ -125,9 +124,9 @@ var _ = Describe("Test ClusterResourceOverride controller logic", func() { }, eventuallyTimeout, interval).Should(Succeed(), "snapshot should exist") By("Checking if the label is correct") diff := cmp.Diff(map[string]string{ - fleetv1alpha1.OverrideIndexLabel: strconv.Itoa(0), - fleetv1beta1.IsLatestSnapshotLabel: "true", - fleetv1alpha1.OverrideTrackingLabel: testCROName, + placementv1beta1.OverrideIndexLabel: strconv.Itoa(0), + placementv1beta1.IsLatestSnapshotLabel: "true", + placementv1beta1.OverrideTrackingLabel: testCROName, }, snapshot.GetLabels()) Expect(diff).Should(BeEmpty(), "Snapshot label mismatch (-want, +got)") By("Checking if the spec is correct") @@ -152,12 +151,12 @@ var _ = Describe("Test ClusterResourceOverride controller logic", func() { By("Updating an existing CRO") Expect(k8sClient.Get(ctx, types.NamespacedName{Name: cro.Name}, cro)).Should(Succeed()) - cro.Spec.Policy = &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + cro.Spec.Policy = &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - JSONPatchOverrides: []fleetv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: fleetv1alpha1.JSONPatchOverrideOpRemove, + Operator: placementv1beta1.JSONPatchOverrideOpRemove, Path: "spec.replica", }, }, @@ -172,9 +171,9 @@ var _ = Describe("Test ClusterResourceOverride controller logic", func() { }, eventuallyTimeout, interval).Should(Succeed(), "snapshot should exist") By("Checking if the label is correct") diff := cmp.Diff(map[string]string{ - fleetv1alpha1.OverrideIndexLabel: strconv.Itoa(1), - fleetv1beta1.IsLatestSnapshotLabel: "true", - fleetv1alpha1.OverrideTrackingLabel: testCROName, + placementv1beta1.OverrideIndexLabel: strconv.Itoa(1), + placementv1beta1.IsLatestSnapshotLabel: "true", + placementv1beta1.OverrideTrackingLabel: testCROName, }, snapshot.GetLabels()) Expect(diff).Should(BeEmpty(), diff, "Snapshot label mismatch (-want, +got)") By("Checking if the spec is correct") @@ -185,9 +184,9 @@ var _ = Describe("Test ClusterResourceOverride controller logic", func() { Expect(k8sClient.Get(ctx, types.NamespacedName{Name: snapshot.Name}, snapshot)).Should(Succeed()) By("Make sure the old snapshot is correctly marked as not latest") diff = cmp.Diff(map[string]string{ - fleetv1alpha1.OverrideIndexLabel: strconv.Itoa(0), - fleetv1beta1.IsLatestSnapshotLabel: "false", - fleetv1alpha1.OverrideTrackingLabel: testCROName, + placementv1beta1.OverrideIndexLabel: strconv.Itoa(0), + placementv1beta1.IsLatestSnapshotLabel: "false", + placementv1beta1.OverrideTrackingLabel: testCROName, }, snapshot.GetLabels()) Expect(diff).Should(BeEmpty(), diff, "Snapshot label mismatch (-want, +got)") By("Make sure the old snapshot spec is not the same as the current CRO") @@ -205,12 +204,12 @@ var _ = Describe("Test ClusterResourceOverride controller logic", func() { }, eventuallyTimeout, interval).Should(Succeed(), "snapshot should exist") By("Updating an existing CRO") Expect(k8sClient.Get(ctx, types.NamespacedName{Name: cro.Name}, cro)).Should(Succeed()) - cro.Spec.Policy = &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + cro.Spec.Policy = &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - JSONPatchOverrides: []fleetv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: fleetv1alpha1.JSONPatchOverrideOpRemove, + Operator: placementv1beta1.JSONPatchOverrideOpRemove, Path: "spec.replica", }, }, diff --git a/pkg/controllers/overrider/common.go b/pkg/controllers/overrider/common.go index c55f7c906..0cdea47ca 100644 --- a/pkg/controllers/overrider/common.go +++ b/pkg/controllers/overrider/common.go @@ -30,7 +30,6 @@ import ( "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil" - placementv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" "go.goms.io/fleet/pkg/utils" "go.goms.io/fleet/pkg/utils/controller" @@ -46,18 +45,18 @@ type Reconciler struct { // handleOverrideDeleting handles the delete event of an override object. We need to delete all the related override Snapshot. func (r *Reconciler) handleOverrideDeleting(ctx context.Context, overrideSnapshotObj, parentOverrideObj client.Object) error { overrideRef := klog.KObj(parentOverrideObj) - if !controllerutil.ContainsFinalizer(parentOverrideObj, placementv1alpha1.OverrideFinalizer) { + if !controllerutil.ContainsFinalizer(parentOverrideObj, placementv1beta1.OverrideFinalizer) { klog.V(2).InfoS("No need to do anything for the deleting override without a finalizer", "override", overrideRef) return nil } // delete all the associated snapshots - if err := r.Client.DeleteAllOf(ctx, overrideSnapshotObj, client.InNamespace(parentOverrideObj.GetNamespace()), client.MatchingLabels{placementv1alpha1.OverrideTrackingLabel: parentOverrideObj.GetName()}); err != nil { + if err := r.Client.DeleteAllOf(ctx, overrideSnapshotObj, client.InNamespace(parentOverrideObj.GetNamespace()), client.MatchingLabels{placementv1beta1.OverrideTrackingLabel: parentOverrideObj.GetName()}); err != nil { klog.ErrorS(err, "Failed to delete all associated overrideSnapshot", "override", overrideRef) return controller.NewAPIServerError(false, err) } klog.V(2).InfoS("Deleted all overrideSnapshot associated with the override", "overrideSnapshot", klog.KObj(overrideSnapshotObj), "override", overrideRef) - controllerutil.RemoveFinalizer(parentOverrideObj, placementv1alpha1.OverrideFinalizer) + controllerutil.RemoveFinalizer(parentOverrideObj, placementv1beta1.OverrideFinalizer) if err := r.Client.Update(ctx, parentOverrideObj); err != nil { klog.ErrorS(err, "Failed to remove crp finalizer", "override", overrideRef) return controller.NewUpdateIgnoreConflictError(err) @@ -67,9 +66,9 @@ func (r *Reconciler) handleOverrideDeleting(ctx context.Context, overrideSnapsho // ensureFinalizer ensures that the finalizer is added to the override object. func (r *Reconciler) ensureFinalizer(ctx context.Context, parentOverrideObj client.Object) error { - if !controllerutil.ContainsFinalizer(parentOverrideObj, placementv1alpha1.OverrideFinalizer) { + if !controllerutil.ContainsFinalizer(parentOverrideObj, placementv1beta1.OverrideFinalizer) { klog.V(4).InfoS("add the override finalizer", "override", klog.KObj(parentOverrideObj)) - controllerutil.AddFinalizer(parentOverrideObj, placementv1alpha1.OverrideFinalizer) + controllerutil.AddFinalizer(parentOverrideObj, placementv1beta1.OverrideFinalizer) return controller.NewUpdateIgnoreConflictError(r.Update(ctx, parentOverrideObj, client.FieldOwner(utils.OverrideControllerFieldManagerName))) } return nil @@ -80,24 +79,24 @@ func (r *Reconciler) listSortedOverrideSnapshots(ctx context.Context, parentOver parentOverrideRef := klog.KObj(parentOverrideObj) snapshotList := &unstructured.UnstructuredList{} var snapshotListGVK schema.GroupVersionKind - if parentOverrideObj.GetObjectKind().GroupVersionKind().Kind == placementv1alpha1.ClusterResourceOverrideKind { + if parentOverrideObj.GetObjectKind().GroupVersionKind().Kind == placementv1beta1.ClusterResourceOverrideKind { snapshotListGVK = utils.ClusterResourceOverrideSnapshotKind } else { snapshotListGVK = utils.ResourceOverrideSnapshotKind } snapshotList.SetGroupVersionKind(snapshotListGVK) - if err := r.Client.List(ctx, snapshotList, client.InNamespace(parentOverrideObj.GetNamespace()), client.MatchingLabels{placementv1alpha1.OverrideTrackingLabel: parentOverrideObj.GetName()}); err != nil { + if err := r.Client.List(ctx, snapshotList, client.InNamespace(parentOverrideObj.GetNamespace()), client.MatchingLabels{placementv1beta1.OverrideTrackingLabel: parentOverrideObj.GetName()}); err != nil { klog.ErrorS(err, "Failed to list all overrideSnapshot", "snapshotListGVK", snapshotListGVK, "parentOverride", parentOverrideRef) return nil, controller.NewAPIServerError(false, err) } var errs []error sort.Slice(snapshotList.Items, func(i, j int) bool { - ii, err := labels.ExtractIndex(&snapshotList.Items[i], placementv1alpha1.OverrideIndexLabel) + ii, err := labels.ExtractIndex(&snapshotList.Items[i], placementv1beta1.OverrideIndexLabel) if err != nil { klog.ErrorS(err, "Failed to parse the override index label", "snapshotListGVK", snapshotListGVK, "parentOverride", parentOverrideRef, "overrideSnapshot", klog.KObj(&snapshotList.Items[i])) errs = append(errs, err) } - ji, err := labels.ExtractIndex(&snapshotList.Items[j], placementv1alpha1.OverrideIndexLabel) + ji, err := labels.ExtractIndex(&snapshotList.Items[j], placementv1beta1.OverrideIndexLabel) if err != nil { klog.ErrorS(err, "Failed to parse the override index label", "snapshotListGVK", snapshotListGVK, "parentOverride", parentOverrideRef, "overrideSnapshot", klog.KObj(&snapshotList.Items[j])) errs = append(errs, err) diff --git a/pkg/controllers/overrider/common_test.go b/pkg/controllers/overrider/common_test.go index 66da7c9df..b1214223e 100644 --- a/pkg/controllers/overrider/common_test.go +++ b/pkg/controllers/overrider/common_test.go @@ -33,8 +33,7 @@ import ( "k8s.io/apimachinery/pkg/types" "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil" - fleetv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" - fleetv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" + placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" "go.goms.io/fleet/pkg/utils" "go.goms.io/fleet/pkg/utils/controller" "go.goms.io/fleet/pkg/utils/labels" @@ -49,7 +48,7 @@ const ( ) var _ = Describe("Test ClusterResourceOverride common logic", func() { - var cro *fleetv1alpha1.ClusterResourceOverride + var cro *placementv1beta1.ClusterResourceOverride croNameBase := "test-cro-common" var testCROName string @@ -79,7 +78,7 @@ var _ = Describe("Test ClusterResourceOverride common logic", func() { It("Should not fail if there is no snapshots associated with the cro yet", func() { By("Adding the overrideFinalizer") - controllerutil.AddFinalizer(cro, fleetv1alpha1.OverrideFinalizer) + controllerutil.AddFinalizer(cro, placementv1beta1.OverrideFinalizer) By("verifying that it handles no snapshot cases") cro.Name = "another-cro" //there is no snapshot associated with this CRO @@ -96,7 +95,7 @@ var _ = Describe("Test ClusterResourceOverride common logic", func() { It("Should delete all the snapshots if there is finalizer", func() { By("Adding the overrideFinalizer") - controllerutil.AddFinalizer(cro, fleetv1alpha1.OverrideFinalizer) + controllerutil.AddFinalizer(cro, placementv1beta1.OverrideFinalizer) By("verifying that all snapshots are deleted") // we cannot apply the CRO to the cluster as it will trigger the real reconcile loop so the update can only return APIServerError Expect(errors.Is(commonReconciler.handleOverrideDeleting(context.Background(), getClusterResourceOverrideSnapshot(testCROName, 0), cro), controller.ErrAPIServerError)).Should(BeTrue()) @@ -118,7 +117,7 @@ var _ = Describe("Test ClusterResourceOverride common logic", func() { index := -1 for i := 0; i < 5; i++ { snapshot := snapshotList.Items[i] - newIndex, err := labels.ExtractIndex(&snapshot, fleetv1alpha1.OverrideIndexLabel) + newIndex, err := labels.ExtractIndex(&snapshot, placementv1beta1.OverrideIndexLabel) Expect(err).Should(Succeed()) Expect(newIndex == index+1).Should(BeTrue()) index = newIndex @@ -199,9 +198,9 @@ var _ = Describe("Test ClusterResourceOverride common logic", func() { Expect(commonReconciler.ensureSnapshotLatest(ctx, snapshot)).Should(Succeed()) Expect(k8sClient.Get(ctx, types.NamespacedName{Name: snapshot.GetName()}, snapshot)).Should(Succeed()) diff := cmp.Diff(map[string]string{ - fleetv1alpha1.OverrideIndexLabel: strconv.Itoa(0), - fleetv1beta1.IsLatestSnapshotLabel: "true", - fleetv1alpha1.OverrideTrackingLabel: testCROName, + placementv1beta1.OverrideIndexLabel: strconv.Itoa(0), + placementv1beta1.IsLatestSnapshotLabel: "true", + placementv1beta1.OverrideTrackingLabel: testCROName, }, snapshot.GetLabels()) Expect(diff).Should(BeEmpty(), diff) }) @@ -211,17 +210,17 @@ var _ = Describe("Test ClusterResourceOverride common logic", func() { snapshot := getClusterResourceOverrideSnapshot(testCROName, 0) Expect(k8sClient.Get(ctx, types.NamespacedName{Name: snapshot.GetName()}, snapshot)).Should(Succeed()) snapshot.SetLabels(map[string]string{ - fleetv1alpha1.OverrideIndexLabel: strconv.Itoa(0), - fleetv1beta1.IsLatestSnapshotLabel: "false", - fleetv1alpha1.OverrideTrackingLabel: testCROName, + placementv1beta1.OverrideIndexLabel: strconv.Itoa(0), + placementv1beta1.IsLatestSnapshotLabel: "false", + placementv1beta1.OverrideTrackingLabel: testCROName, }) Expect(k8sClient.Update(ctx, snapshot)).Should(Succeed()) Expect(commonReconciler.ensureSnapshotLatest(ctx, snapshot)).Should(Succeed()) Expect(k8sClient.Get(ctx, types.NamespacedName{Name: snapshot.GetName()}, snapshot)).Should(Succeed()) diff := cmp.Diff(map[string]string{ - fleetv1alpha1.OverrideIndexLabel: strconv.Itoa(0), - fleetv1beta1.IsLatestSnapshotLabel: "true", - fleetv1alpha1.OverrideTrackingLabel: testCROName, + placementv1beta1.OverrideIndexLabel: strconv.Itoa(0), + placementv1beta1.IsLatestSnapshotLabel: "true", + placementv1beta1.OverrideTrackingLabel: testCROName, }, snapshot.GetLabels()) Expect(diff).Should(BeEmpty(), diff) }) @@ -229,7 +228,7 @@ var _ = Describe("Test ClusterResourceOverride common logic", func() { }) var _ = Describe("Test ResourceOverride common logic", func() { - var ro *fleetv1alpha1.ResourceOverride + var ro *placementv1beta1.ResourceOverride totalSnapshots := 7 testROName := "test-ro-common" var namespaceName string @@ -273,7 +272,7 @@ var _ = Describe("Test ResourceOverride common logic", func() { It("Should not fail if there is no snapshots associated with the ro yet", func() { By("Adding the overrideFinalizer") - controllerutil.AddFinalizer(ro, fleetv1alpha1.OverrideFinalizer) + controllerutil.AddFinalizer(ro, placementv1beta1.OverrideFinalizer) By("verifying that it handles no snapshot cases") ro.Name = "another-ro" //there is no snapshot associated with this RO @@ -290,7 +289,7 @@ var _ = Describe("Test ResourceOverride common logic", func() { It("Should delete all the snapshots if there is finalizer", func() { By("Adding the overrideFinalizer") - controllerutil.AddFinalizer(ro, fleetv1alpha1.OverrideFinalizer) + controllerutil.AddFinalizer(ro, placementv1beta1.OverrideFinalizer) By("verifying that all snapshots are deleted") // we cannot apply the RO to the cluster as it will trigger the real reconcile loop so the update can only return APIServerError Expect(errors.Is(commonReconciler.handleOverrideDeleting(context.Background(), getResourceOverrideSnapshot(testROName, namespaceName, 0), ro), controller.ErrAPIServerError)).Should(BeTrue()) @@ -312,7 +311,7 @@ var _ = Describe("Test ResourceOverride common logic", func() { index := -1 for i := 0; i < totalSnapshots; i++ { snapshot := snapshotList.Items[i] - newIndex, err := labels.ExtractIndex(&snapshot, fleetv1alpha1.OverrideIndexLabel) + newIndex, err := labels.ExtractIndex(&snapshot, placementv1beta1.OverrideIndexLabel) Expect(err).Should(Succeed()) Expect(newIndex == index+1).Should(BeTrue()) index = newIndex @@ -393,9 +392,9 @@ var _ = Describe("Test ResourceOverride common logic", func() { Expect(commonReconciler.ensureSnapshotLatest(ctx, snapshot)).Should(Succeed()) Expect(k8sClient.Get(ctx, types.NamespacedName{Name: snapshot.GetName(), Namespace: snapshot.Namespace}, snapshot)).Should(Succeed()) diff := cmp.Diff(map[string]string{ - fleetv1alpha1.OverrideIndexLabel: strconv.Itoa(0), - fleetv1beta1.IsLatestSnapshotLabel: "true", - fleetv1alpha1.OverrideTrackingLabel: testROName, + placementv1beta1.OverrideIndexLabel: strconv.Itoa(0), + placementv1beta1.IsLatestSnapshotLabel: "true", + placementv1beta1.OverrideTrackingLabel: testROName, }, snapshot.GetLabels()) Expect(diff).Should(BeEmpty(), diff) }) @@ -405,17 +404,17 @@ var _ = Describe("Test ResourceOverride common logic", func() { snapshot := getResourceOverrideSnapshot(testROName, ro.Namespace, 0) Expect(k8sClient.Get(ctx, types.NamespacedName{Name: snapshot.GetName(), Namespace: snapshot.Namespace}, snapshot)).Should(Succeed()) snapshot.SetLabels(map[string]string{ - fleetv1alpha1.OverrideIndexLabel: strconv.Itoa(0), - fleetv1beta1.IsLatestSnapshotLabel: "false", - fleetv1alpha1.OverrideTrackingLabel: testROName, + placementv1beta1.OverrideIndexLabel: strconv.Itoa(0), + placementv1beta1.IsLatestSnapshotLabel: "false", + placementv1beta1.OverrideTrackingLabel: testROName, }) Expect(k8sClient.Update(ctx, snapshot)).Should(Succeed()) Expect(commonReconciler.ensureSnapshotLatest(ctx, snapshot)).Should(Succeed()) Expect(k8sClient.Get(ctx, types.NamespacedName{Name: snapshot.GetName(), Namespace: snapshot.Namespace}, snapshot)).Should(Succeed()) diff := cmp.Diff(map[string]string{ - fleetv1alpha1.OverrideIndexLabel: strconv.Itoa(0), - fleetv1beta1.IsLatestSnapshotLabel: "true", - fleetv1alpha1.OverrideTrackingLabel: testROName, + placementv1beta1.OverrideIndexLabel: strconv.Itoa(0), + placementv1beta1.IsLatestSnapshotLabel: "true", + placementv1beta1.OverrideTrackingLabel: testROName, }, snapshot.GetLabels()) Expect(diff).Should(BeEmpty(), diff) }) diff --git a/pkg/controllers/overrider/resource_controller.go b/pkg/controllers/overrider/resource_controller.go index 81ff494e1..84b1ef4eb 100644 --- a/pkg/controllers/overrider/resource_controller.go +++ b/pkg/controllers/overrider/resource_controller.go @@ -31,7 +31,6 @@ import ( "sigs.k8s.io/controller-runtime/pkg/builder" "sigs.k8s.io/controller-runtime/pkg/predicate" - placementv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" "go.goms.io/fleet/pkg/utils/controller" "go.goms.io/fleet/pkg/utils/labels" @@ -46,7 +45,7 @@ type ResourceReconciler struct { // Reconcile triggers a single reconcile round when scheduling policy has changed. func (r *ResourceReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) { name := req.NamespacedName - resourceOverride := placementv1alpha1.ResourceOverride{} + resourceOverride := placementv1beta1.ResourceOverride{} overrideRef := klog.KRef(name.Namespace, name.Name) startTime := time.Now() @@ -68,7 +67,7 @@ func (r *ResourceReconciler) Reconcile(ctx context.Context, req ctrl.Request) (c // Check if the resourceOverride is being deleted if resourceOverride.DeletionTimestamp != nil { klog.V(4).InfoS("The resourceOverride is being deleted", "resourceOverride", overrideRef) - return ctrl.Result{}, r.handleOverrideDeleting(ctx, &placementv1alpha1.ResourceOverrideSnapshot{}, &resourceOverride) + return ctrl.Result{}, r.handleOverrideDeleting(ctx, &placementv1beta1.ResourceOverrideSnapshot{}, &resourceOverride) } // Ensure that we have the finalizer so we can delete all the related snapshots on cleanup @@ -82,7 +81,7 @@ func (r *ResourceReconciler) Reconcile(ctx context.Context, req ctrl.Request) (c return ctrl.Result{}, r.ensureResourceOverrideSnapshot(ctx, &resourceOverride, 10) } -func (r *ResourceReconciler) ensureResourceOverrideSnapshot(ctx context.Context, ro *placementv1alpha1.ResourceOverride, revisionHistoryLimit int) error { +func (r *ResourceReconciler) ensureResourceOverrideSnapshot(ctx context.Context, ro *placementv1beta1.ResourceOverride, revisionHistoryLimit int) error { croKObj := klog.KObj(ro) overridePolicy := ro.Spec overrideSpecHash, err := resource.HashOf(overridePolicy) @@ -103,7 +102,7 @@ func (r *ResourceReconciler) ensureResourceOverrideSnapshot(ctx context.Context, latestSnapshotIndex := -1 if len(snapshotList.Items) != 0 { // convert the last unstructured snapshot to the typed object - latestSnapshot := &placementv1alpha1.ResourceOverrideSnapshot{} + latestSnapshot := &placementv1beta1.ResourceOverrideSnapshot{} if err = runtime.DefaultUnstructuredConverter.FromUnstructured(snapshotList.Items[len(snapshotList.Items)-1].Object, latestSnapshot); err != nil { klog.ErrorS(err, "Invalid overrideSnapshot", "ResourceOverride", croKObj, "overrideSnapshot", klog.KObj(&snapshotList.Items[len(snapshotList.Items)-1])) return controller.NewUnexpectedBehaviorError(err) @@ -123,7 +122,7 @@ func (r *ResourceReconciler) ensureResourceOverrideSnapshot(ctx context.Context, klog.V(2).InfoS("Marked the latest overrideSnapshot as inactive", "ResourceOverride", croKObj, "overrideSnapshot", klog.KObj(latestSnapshot)) } // we need to figure out the last snapshot index. - latestSnapshotIndex, err = labels.ExtractIndex(latestSnapshot, placementv1alpha1.OverrideIndexLabel) + latestSnapshotIndex, err = labels.ExtractIndex(latestSnapshot, placementv1beta1.OverrideIndexLabel) if err != nil { klog.ErrorS(err, "Failed to parse the override index label", "ResourceOverride", croKObj, "overrideSnapshot", klog.KObj(latestSnapshot)) return controller.NewUnexpectedBehaviorError(err) @@ -132,20 +131,20 @@ func (r *ResourceReconciler) ensureResourceOverrideSnapshot(ctx context.Context, // Need to create new snapshot when 1) there is no snapshots or 2) the latest snapshot hash != current one. latestSnapshotIndex++ - newSnapshot := &placementv1alpha1.ResourceOverrideSnapshot{ + newSnapshot := &placementv1beta1.ResourceOverrideSnapshot{ ObjectMeta: metav1.ObjectMeta{ - Name: fmt.Sprintf(placementv1alpha1.OverrideSnapshotNameFmt, ro.Name, latestSnapshotIndex), + Name: fmt.Sprintf(placementv1beta1.OverrideSnapshotNameFmt, ro.Name, latestSnapshotIndex), Namespace: ro.Namespace, Labels: map[string]string{ - placementv1alpha1.OverrideTrackingLabel: ro.Name, - placementv1beta1.IsLatestSnapshotLabel: strconv.FormatBool(true), - placementv1alpha1.OverrideIndexLabel: strconv.Itoa(latestSnapshotIndex), + placementv1beta1.OverrideTrackingLabel: ro.Name, + placementv1beta1.IsLatestSnapshotLabel: strconv.FormatBool(true), + placementv1beta1.OverrideIndexLabel: strconv.Itoa(latestSnapshotIndex), }, OwnerReferences: []metav1.OwnerReference{ - *metav1.NewControllerRef(ro, placementv1alpha1.GroupVersion.WithKind(placementv1alpha1.ResourceOverrideKind)), + *metav1.NewControllerRef(ro, placementv1beta1.GroupVersion.WithKind(placementv1beta1.ResourceOverrideKind)), }, }, - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ OverrideSpec: overridePolicy, OverrideHash: []byte(overrideSpecHash), }, @@ -162,6 +161,6 @@ func (r *ResourceReconciler) ensureResourceOverrideSnapshot(ctx context.Context, func (r *ResourceReconciler) SetupWithManager(mgr ctrl.Manager) error { return ctrl.NewControllerManagedBy(mgr). Named("resourceoverride-controller"). - For(&placementv1alpha1.ResourceOverride{}, builder.WithPredicates(predicate.GenerationChangedPredicate{})). + For(&placementv1beta1.ResourceOverride{}, builder.WithPredicates(predicate.GenerationChangedPredicate{})). Complete(r) } diff --git a/pkg/controllers/overrider/resource_controller_integration_test.go b/pkg/controllers/overrider/resource_controller_integration_test.go index dcb662a01..7e5c513cd 100644 --- a/pkg/controllers/overrider/resource_controller_integration_test.go +++ b/pkg/controllers/overrider/resource_controller_integration_test.go @@ -31,26 +31,25 @@ import ( "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil" - fleetv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" - fleetv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" + placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" "go.goms.io/fleet/pkg/utils" ) -func getResourceOverrideSpec() fleetv1alpha1.ResourceOverrideSpec { - return fleetv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []fleetv1alpha1.ResourceSelector{ +func getResourceOverrideSpec() placementv1beta1.ResourceOverrideSpec { + return placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "", Version: "v1", Kind: "Pod", }, }, - Policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - JSONPatchOverrides: []fleetv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: fleetv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "spec.replica", Value: apiextensionsv1.JSON{Raw: []byte("3")}, }, @@ -61,11 +60,11 @@ func getResourceOverrideSpec() fleetv1alpha1.ResourceOverrideSpec { } } -func getResourceOverride(testOverrideName, namespaceName string) *fleetv1alpha1.ResourceOverride { - return &fleetv1alpha1.ResourceOverride{ +func getResourceOverride(testOverrideName, namespaceName string) *placementv1beta1.ResourceOverride { + return &placementv1beta1.ResourceOverride{ TypeMeta: metav1.TypeMeta{ - APIVersion: fleetv1alpha1.GroupVersion.String(), - Kind: fleetv1alpha1.ResourceOverrideKind, + APIVersion: placementv1beta1.GroupVersion.String(), + Kind: placementv1beta1.ResourceOverrideKind, }, ObjectMeta: metav1.ObjectMeta{ Name: testOverrideName, @@ -75,18 +74,18 @@ func getResourceOverride(testOverrideName, namespaceName string) *fleetv1alpha1. } } -func getResourceOverrideSnapshot(testOverrideName, namespaceName string, index int) *fleetv1alpha1.ResourceOverrideSnapshot { - return &fleetv1alpha1.ResourceOverrideSnapshot{ +func getResourceOverrideSnapshot(testOverrideName, namespaceName string, index int) *placementv1beta1.ResourceOverrideSnapshot { + return &placementv1beta1.ResourceOverrideSnapshot{ ObjectMeta: metav1.ObjectMeta{ - Name: fmt.Sprintf(fleetv1alpha1.OverrideSnapshotNameFmt, testOverrideName, index), + Name: fmt.Sprintf(placementv1beta1.OverrideSnapshotNameFmt, testOverrideName, index), Namespace: namespaceName, Labels: map[string]string{ - fleetv1alpha1.OverrideIndexLabel: strconv.Itoa(index), - fleetv1beta1.IsLatestSnapshotLabel: "true", - fleetv1alpha1.OverrideTrackingLabel: testOverrideName, + placementv1beta1.OverrideIndexLabel: strconv.Itoa(index), + placementv1beta1.IsLatestSnapshotLabel: "true", + placementv1beta1.OverrideTrackingLabel: testOverrideName, }, }, - Spec: fleetv1alpha1.ResourceOverrideSnapshotSpec{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ OverrideHash: []byte("hash"), OverrideSpec: getResourceOverrideSpec(), }, @@ -94,7 +93,7 @@ func getResourceOverrideSnapshot(testOverrideName, namespaceName string, index i } var _ = Describe("Test ResourceOverride controller logic", func() { - var ro *fleetv1alpha1.ResourceOverride + var ro *placementv1beta1.ResourceOverride var testROName string var namespaceName string @@ -130,7 +129,7 @@ var _ = Describe("Test ResourceOverride controller logic", func() { if err := k8sClient.Get(ctx, types.NamespacedName{Name: ro.Name, Namespace: ro.Namespace}, ro); err != nil { return err } - if !controllerutil.ContainsFinalizer(ro, fleetv1alpha1.OverrideFinalizer) { + if !controllerutil.ContainsFinalizer(ro, placementv1beta1.OverrideFinalizer) { return fmt.Errorf("finalizer not added") } return nil @@ -143,9 +142,9 @@ var _ = Describe("Test ResourceOverride controller logic", func() { }, eventuallyTimeout, interval).Should(Succeed(), "snapshot should exist") By("Checking if the label is correct") diff := cmp.Diff(map[string]string{ - fleetv1alpha1.OverrideIndexLabel: strconv.Itoa(0), - fleetv1beta1.IsLatestSnapshotLabel: "true", - fleetv1alpha1.OverrideTrackingLabel: testROName, + placementv1beta1.OverrideIndexLabel: strconv.Itoa(0), + placementv1beta1.IsLatestSnapshotLabel: "true", + placementv1beta1.OverrideTrackingLabel: testROName, }, snapshot.GetLabels()) Expect(diff).Should(BeEmpty(), "Snapshot label mismatch (-want, +got)") By("Checking if the spec is correct") @@ -170,12 +169,12 @@ var _ = Describe("Test ResourceOverride controller logic", func() { By("Updating an existing RO") Expect(k8sClient.Get(ctx, types.NamespacedName{Name: ro.Name, Namespace: ro.Namespace}, ro)).Should(Succeed()) - ro.Spec.Policy = &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + ro.Spec.Policy = &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - JSONPatchOverrides: []fleetv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: fleetv1alpha1.JSONPatchOverrideOpRemove, + Operator: placementv1beta1.JSONPatchOverrideOpRemove, Path: "spec.replica", }, }, @@ -190,9 +189,9 @@ var _ = Describe("Test ResourceOverride controller logic", func() { }, eventuallyTimeout, interval).Should(Succeed(), "snapshot should exist") By("Checking if the label is correct") diff := cmp.Diff(map[string]string{ - fleetv1alpha1.OverrideIndexLabel: strconv.Itoa(1), - fleetv1beta1.IsLatestSnapshotLabel: "true", - fleetv1alpha1.OverrideTrackingLabel: testROName, + placementv1beta1.OverrideIndexLabel: strconv.Itoa(1), + placementv1beta1.IsLatestSnapshotLabel: "true", + placementv1beta1.OverrideTrackingLabel: testROName, }, snapshot.GetLabels()) Expect(diff).Should(BeEmpty(), diff, "Snapshot label mismatch (-want, +got)") By("Checking if the spec is correct") @@ -203,9 +202,9 @@ var _ = Describe("Test ResourceOverride controller logic", func() { Expect(k8sClient.Get(ctx, types.NamespacedName{Name: snapshot.Name, Namespace: snapshot.Namespace}, snapshot)).Should(Succeed()) By("Make sure the old snapshot is correctly marked as not latest") diff = cmp.Diff(map[string]string{ - fleetv1alpha1.OverrideIndexLabel: strconv.Itoa(0), - fleetv1beta1.IsLatestSnapshotLabel: "false", - fleetv1alpha1.OverrideTrackingLabel: testROName, + placementv1beta1.OverrideIndexLabel: strconv.Itoa(0), + placementv1beta1.IsLatestSnapshotLabel: "false", + placementv1beta1.OverrideTrackingLabel: testROName, }, snapshot.GetLabels()) Expect(diff).Should(BeEmpty(), diff, "Snapshot label mismatch (-want, +got)") By("Make sure the old snapshot spec is not the same as the current RO") @@ -223,12 +222,12 @@ var _ = Describe("Test ResourceOverride controller logic", func() { }, eventuallyTimeout, interval).Should(Succeed(), "snapshot should exist") By("Updating an existing RO") Expect(k8sClient.Get(ctx, types.NamespacedName{Name: ro.Name, Namespace: ro.Namespace}, ro)).Should(Succeed()) - ro.Spec.Policy = &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + ro.Spec.Policy = &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - JSONPatchOverrides: []fleetv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: fleetv1alpha1.JSONPatchOverrideOpRemove, + Operator: placementv1beta1.JSONPatchOverrideOpRemove, Path: "spec.replica", }, }, @@ -249,8 +248,8 @@ var _ = Describe("Test ResourceOverride controller logic", func() { }, eventuallyTimeout, interval).Should(BeTrue(), "ro should be deleted") By("Make sure all snapshots are deleted") Consistently(func() bool { - snapshots := &fleetv1alpha1.ResourceOverrideSnapshotList{} - err := k8sClient.List(ctx, snapshots, client.InNamespace(snapshot.Namespace), client.MatchingLabels{fleetv1alpha1.OverrideTrackingLabel: testROName}) + snapshots := &placementv1beta1.ResourceOverrideSnapshotList{} + err := k8sClient.List(ctx, snapshots, client.InNamespace(snapshot.Namespace), client.MatchingLabels{placementv1beta1.OverrideTrackingLabel: testROName}) return err == nil && len(snapshots.Items) == 0 }, consistentlyDuration, interval).Should(BeTrue(), "snapshot should be deleted") }) diff --git a/pkg/controllers/overrider/suite_test.go b/pkg/controllers/overrider/suite_test.go index 6b8d9aefc..8cf5c2eba 100644 --- a/pkg/controllers/overrider/suite_test.go +++ b/pkg/controllers/overrider/suite_test.go @@ -25,18 +25,17 @@ import ( . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" "k8s.io/client-go/kubernetes/scheme" - "k8s.io/klog/v2/textlogger" - metricsserver "sigs.k8s.io/controller-runtime/pkg/metrics/server" - "k8s.io/client-go/rest" "k8s.io/klog/v2" + "k8s.io/klog/v2/textlogger" ctrl "sigs.k8s.io/controller-runtime" "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/envtest" "sigs.k8s.io/controller-runtime/pkg/log/zap" "sigs.k8s.io/controller-runtime/pkg/manager" + metricsserver "sigs.k8s.io/controller-runtime/pkg/metrics/server" - placementv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" + placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" ) var ( @@ -75,7 +74,7 @@ var _ = BeforeSuite(func() { Expect(err).Should(Succeed()) Expect(cfg).NotTo(BeNil()) - err = placementv1alpha1.AddToScheme(scheme.Scheme) + err = placementv1beta1.AddToScheme(scheme.Scheme) Expect(err).NotTo(HaveOccurred()) //+kubebuilder:scaffold:scheme diff --git a/pkg/controllers/rollout/controller.go b/pkg/controllers/rollout/controller.go index d05d03889..ec0923d34 100644 --- a/pkg/controllers/rollout/controller.go +++ b/pkg/controllers/rollout/controller.go @@ -39,8 +39,7 @@ import ( "sigs.k8s.io/controller-runtime/pkg/handler" "sigs.k8s.io/controller-runtime/pkg/reconcile" - fleetv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" - fleetv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" + placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" bindingutils "go.goms.io/fleet/pkg/utils/binding" "go.goms.io/fleet/pkg/utils/condition" "go.goms.io/fleet/pkg/utils/controller" @@ -95,7 +94,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req runtime.Request) (runtim placementSpec := placementObj.GetPlacementSpec() // check that it's actually rollingUpdate strategy - if placementSpec.Strategy.Type != fleetv1beta1.RollingUpdateRolloutStrategyType { + if placementSpec.Strategy.Type != placementv1beta1.RollingUpdateRolloutStrategyType { klog.V(2).InfoS("Ignoring placement with non-rolling-update strategy", "placement", placementObjRef) return runtime.Result{}, nil } @@ -220,7 +219,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req runtime.Request) (runtim return runtime.Result{Requeue: true, RequeueAfter: waitTime}, r.updateBindings(ctx, toBeUpdatedBindings) } -func (r *Reconciler) checkAndUpdateStaleBindingsStatus(ctx context.Context, bindings []fleetv1beta1.BindingObj) error { +func (r *Reconciler) checkAndUpdateStaleBindingsStatus(ctx context.Context, bindings []placementv1beta1.BindingObj) error { if len(bindings) == 0 { return nil } @@ -229,11 +228,11 @@ func (r *Reconciler) checkAndUpdateStaleBindingsStatus(ctx context.Context, bind for i := 0; i < len(bindings); i++ { binding := bindings[i] bindingSpec := binding.GetBindingSpec() - if bindingSpec.State != fleetv1beta1.BindingStateScheduled && bindingSpec.State != fleetv1beta1.BindingStateBound { + if bindingSpec.State != placementv1beta1.BindingStateScheduled && bindingSpec.State != placementv1beta1.BindingStateBound { continue } - rolloutStartedCondition := binding.GetCondition(string(fleetv1beta1.ResourceBindingRolloutStarted)) + rolloutStartedCondition := binding.GetCondition(string(placementv1beta1.ResourceBindingRolloutStarted)) if condition.IsConditionStatusTrue(rolloutStartedCondition, binding.GetGeneration()) { continue } @@ -248,10 +247,10 @@ func (r *Reconciler) checkAndUpdateStaleBindingsStatus(ctx context.Context, bind // waitForResourcesToCleanUp checks if there are any cluster that has a binding that is both being deleted and another one that needs rollout. // We currently just wait for those cluster to be cleanup so that we can have a clean slate to start compute the rollout plan. // TODO (rzhang): group all bindings pointing to the same cluster together when we calculate the rollout plan so that we can avoid this. -func waitForResourcesToCleanUp(allBindings []fleetv1beta1.BindingObj, placementObj fleetv1beta1.PlacementObj) (bool, error) { +func waitForResourcesToCleanUp(allBindings []placementv1beta1.BindingObj, placementObj placementv1beta1.PlacementObj) (bool, error) { placementObjRef := klog.KObj(placementObj) deletingBinding := make(map[string]bool) - bindingMap := make(map[string]fleetv1beta1.BindingObj) + bindingMap := make(map[string]placementv1beta1.BindingObj) // separate deleting bindings from the rest of the bindings for _, binding := range allBindings { bindingSpec := binding.GetBindingSpec() @@ -273,15 +272,15 @@ func waitForResourcesToCleanUp(allBindings []fleetv1beta1.BindingObj, placementO if deletingBinding[cluster] { klog.V(2).InfoS("Find a binding assigned to a cluster with another deleting binding", "placement", placementObjRef, "binding", binding) bindingSpec := binding.GetBindingSpec() - if bindingSpec.State == fleetv1beta1.BindingStateBound { + if bindingSpec.State == placementv1beta1.BindingStateBound { // the rollout controller won't move a binding from scheduled state to bound if there is a deleting binding on the same cluster. return false, controller.NewUnexpectedBehaviorError(fmt.Errorf( "find a cluster `%s` that has a bound binding `%s` and a deleting binding point to it", bindingSpec.TargetCluster, binding.GetName())) } - if bindingSpec.State == fleetv1beta1.BindingStateUnscheduled { + if bindingSpec.State == placementv1beta1.BindingStateUnscheduled { // this is a very rare case that the resource was in the middle of being removed from a member cluster after it is unselected. // then the cluster get selected and unselected in two scheduling before the member agent is able to clean up all the resources. - if binding.GetAnnotations()[fleetv1beta1.PreviousBindingStateAnnotation] == string(fleetv1beta1.BindingStateBound) { + if binding.GetAnnotations()[placementv1beta1.PreviousBindingStateAnnotation] == string(placementv1beta1.BindingStateBound) { // its previous state can not be bound as rollout won't roll a binding with a deleting binding pointing to the same cluster. return false, controller.NewUnexpectedBehaviorError(fmt.Errorf( "find a cluster `%s` that has a unscheduled binding `%s` with previous state is `bound` and a deleting binding point to it", bindingSpec.TargetCluster, binding.GetName())) @@ -299,19 +298,19 @@ func waitForResourcesToCleanUp(allBindings []fleetv1beta1.BindingObj, placementO // If the binding is selected, it will be updated to the desired state. // Otherwise, its status will be updated. type toBeUpdatedBinding struct { - currentBinding fleetv1beta1.BindingObj - desiredBinding fleetv1beta1.BindingObj // only valid for scheduled or bound binding + currentBinding placementv1beta1.BindingObj + desiredBinding placementv1beta1.BindingObj // only valid for scheduled or bound binding } -func createUpdateInfo(binding fleetv1beta1.BindingObj, - masterResourceSnapshot fleetv1beta1.ResourceSnapshotObj, cro []string, ro []fleetv1beta1.NamespacedName) toBeUpdatedBinding { - desiredBinding := binding.DeepCopyObject().(fleetv1beta1.BindingObj) +func createUpdateInfo(binding placementv1beta1.BindingObj, + masterResourceSnapshot placementv1beta1.ResourceSnapshotObj, cro []string, ro []placementv1beta1.NamespacedName) toBeUpdatedBinding { + desiredBinding := binding.DeepCopyObject().(placementv1beta1.BindingObj) // Apply strategy is updated separately for all bindings. // Get current spec and update it desiredSpec := desiredBinding.GetBindingSpec() - desiredSpec.State = fleetv1beta1.BindingStateBound + desiredSpec.State = placementv1beta1.BindingStateBound desiredSpec.ResourceSnapshotName = masterResourceSnapshot.GetName() // TODO: check the size of the cro and ro to not exceed the limit desiredSpec.ClusterResourceOverrideSnapshots = cro @@ -332,26 +331,26 @@ func createUpdateInfo(binding fleetv1beta1.BindingObj, // two cases. func (r *Reconciler) pickBindingsToRoll( ctx context.Context, - allBindings []fleetv1beta1.BindingObj, - masterResourceSnapshot fleetv1beta1.ResourceSnapshotObj, - placementObj fleetv1beta1.PlacementObj, - matchedCROs []*fleetv1alpha1.ClusterResourceOverrideSnapshot, - matchedROs []*fleetv1alpha1.ResourceOverrideSnapshot, + allBindings []placementv1beta1.BindingObj, + masterResourceSnapshot placementv1beta1.ResourceSnapshotObj, + placementObj placementv1beta1.PlacementObj, + matchedCROs []*placementv1beta1.ClusterResourceOverrideSnapshot, + matchedROs []*placementv1beta1.ResourceOverrideSnapshot, ) ([]toBeUpdatedBinding, []toBeUpdatedBinding, []toBeUpdatedBinding, bool, time.Duration, error) { // Those are the bindings that are chosen by the scheduler to be applied to selected clusters. // They include the bindings that are already applied to the clusters and the bindings that are newly selected by the scheduler. - schedulerTargetedBinds := make([]fleetv1beta1.BindingObj, 0) + schedulerTargetedBinds := make([]placementv1beta1.BindingObj, 0) // The content of those bindings that are considered to be already running on the targeted clusters. - readyBindings := make([]fleetv1beta1.BindingObj, 0) + readyBindings := make([]placementv1beta1.BindingObj, 0) // Those are the bindings that have the potential to be ready during the rolling phase. // It includes all bindings that have been applied to the clusters and not deleted yet so that they can still be ready at any time. - canBeReadyBindings := make([]fleetv1beta1.BindingObj, 0) + canBeReadyBindings := make([]placementv1beta1.BindingObj, 0) // Those are the bindings that have the potential to be unavailable during the rolling phase which // includes the bindings that are being deleted. It depends on work generator and member agent for the timing of the removal from the cluster. - canBeUnavailableBindings := make([]fleetv1beta1.BindingObj, 0) + canBeUnavailableBindings := make([]placementv1beta1.BindingObj, 0) // Those are the bindings that are candidates to be updated to be bound during the rolling phase. boundingCandidates := make([]toBeUpdatedBinding, 0) @@ -386,7 +385,7 @@ func (r *Reconciler) pickBindingsToRoll( bindingKObj := klog.KObj(binding) bindingSpec := binding.GetBindingSpec() switch bindingSpec.State { - case fleetv1beta1.BindingStateUnscheduled: + case placementv1beta1.BindingStateUnscheduled: // Use updated interface-based bindingutils functions if bindingutils.HasBindingFailed(binding) { klog.V(2).InfoS("Found a failed to be ready unscheduled binding", "placement", placementKObj, "binding", bindingKObj) @@ -412,7 +411,7 @@ func (r *Reconciler) pickBindingsToRoll( // it is being deleted, it can be removed from the cluster at any time, so it can be unavailable at any time canBeUnavailableBindings = append(canBeUnavailableBindings, binding) } - case fleetv1beta1.BindingStateScheduled: + case placementv1beta1.BindingStateScheduled: // the scheduler has picked a cluster for this binding schedulerTargetedBinds = append(schedulerTargetedBinds, binding) // this binding has not been bound yet, so it is an update candidate @@ -422,7 +421,7 @@ func (r *Reconciler) pickBindingsToRoll( return nil, nil, nil, false, minWaitTime, err } boundingCandidates = append(boundingCandidates, createUpdateInfo(binding, masterResourceSnapshot, cro, ro)) - case fleetv1beta1.BindingStateBound: + case placementv1beta1.BindingStateBound: bindingFailed := false schedulerTargetedBinds = append(schedulerTargetedBinds, binding) waitTime, bindingReady := isBindingReady(binding, readyTimeCutOff) @@ -496,10 +495,10 @@ func (r *Reconciler) pickBindingsToRoll( // determineBindingsToUpdate determines which bindings to update func determineBindingsToUpdate( - placementObj fleetv1beta1.PlacementObj, + placementObj placementv1beta1.PlacementObj, removeCandidates, updateCandidates, boundingCandidates, applyFailedUpdateCandidates []toBeUpdatedBinding, targetNumber int, - readyBindings, canBeReadyBindings, canBeUnavailableBindings []fleetv1beta1.BindingObj, + readyBindings, canBeReadyBindings, canBeUnavailableBindings []placementv1beta1.BindingObj, ) ([]toBeUpdatedBinding, []toBeUpdatedBinding) { toBeUpdatedBindingList := make([]toBeUpdatedBinding, 0) // calculate the max number of bindings that can be unavailable according to user specified maxUnavailable @@ -544,7 +543,7 @@ func determineBindingsToUpdate( return toBeUpdatedBindingList, staleUnselectedBinding } -func calculateMaxToRemove(placementObj fleetv1beta1.PlacementObj, targetNumber int, readyBindings, canBeUnavailableBindings []fleetv1beta1.BindingObj) int { +func calculateMaxToRemove(placementObj placementv1beta1.PlacementObj, targetNumber int, readyBindings, canBeUnavailableBindings []placementv1beta1.BindingObj) int { placementSpec := placementObj.GetPlacementSpec() maxUnavailableNumber, _ := intstr.GetScaledValueFromIntOrPercent(placementSpec.Strategy.RollingUpdate.MaxUnavailable, targetNumber, true) minAvailableNumber := targetNumber - maxUnavailableNumber @@ -558,7 +557,7 @@ func calculateMaxToRemove(placementObj fleetv1beta1.PlacementObj, targetNumber i return maxNumberToRemove } -func calculateMaxToAdd(placementObj fleetv1beta1.PlacementObj, targetNumber int, canBeReadyBindings []fleetv1beta1.BindingObj) int { +func calculateMaxToAdd(placementObj placementv1beta1.PlacementObj, targetNumber int, canBeReadyBindings []placementv1beta1.BindingObj) int { placementSpec := placementObj.GetPlacementSpec() maxSurgeNumber, _ := intstr.GetScaledValueFromIntOrPercent(placementSpec.Strategy.RollingUpdate.MaxSurge, targetNumber, true) maxReadyNumber := targetNumber + maxSurgeNumber @@ -573,7 +572,7 @@ func calculateMaxToAdd(placementObj fleetv1beta1.PlacementObj, targetNumber int, return maxNumberToAdd } -func (r *Reconciler) calculateRealTarget(placementObj fleetv1beta1.PlacementObj, schedulerTargetedBinds []fleetv1beta1.BindingObj) int { +func (r *Reconciler) calculateRealTarget(placementObj placementv1beta1.PlacementObj, schedulerTargetedBinds []placementv1beta1.BindingObj) int { placementObjRef := klog.KObj(placementObj) // calculate the target number of bindings targetNumber := 0 @@ -581,13 +580,13 @@ func (r *Reconciler) calculateRealTarget(placementObj fleetv1beta1.PlacementObj, placementSpec := placementObj.GetPlacementSpec() // note that if the policy will be overwritten if it is nil in this controller. switch placementSpec.Policy.PlacementType { - case fleetv1beta1.PickAllPlacementType: + case placementv1beta1.PickAllPlacementType: // we use the scheduler picked bindings as the target number since there is no target in the CRP targetNumber = len(schedulerTargetedBinds) - case fleetv1beta1.PickFixedPlacementType: + case placementv1beta1.PickFixedPlacementType: // we use the length of the given cluster names are targets targetNumber = len(placementSpec.Policy.ClusterNames) - case fleetv1beta1.PickNPlacementType: + case placementv1beta1.PickNPlacementType: // we use the given number as the target targetNumber = int(*placementSpec.Policy.NumberOfClusters) default: @@ -602,15 +601,15 @@ func (r *Reconciler) calculateRealTarget(placementObj fleetv1beta1.PlacementObj, // isBindingReady checks if a binding is considered ready. // A binding with not trackable resources is considered ready if the binding's current spec has been available before // the ready cutoff time. -func isBindingReady(binding fleetv1beta1.BindingObj, readyTimeCutOff time.Time) (time.Duration, bool) { +func isBindingReady(binding placementv1beta1.BindingObj, readyTimeCutOff time.Time) (time.Duration, bool) { // the binding is ready if the diff report has been reported - diffReportCondition := binding.GetCondition(string(fleetv1beta1.ResourceBindingDiffReported)) + diffReportCondition := binding.GetCondition(string(placementv1beta1.ResourceBindingDiffReported)) if condition.IsConditionStatusTrue(diffReportCondition, binding.GetGeneration()) { // we can move to the next binding return 0, true } // find the latest applied condition that has the same generation as the binding - availableCondition := binding.GetCondition(string(fleetv1beta1.ResourceBindingAvailable)) + availableCondition := binding.GetCondition(string(placementv1beta1.ResourceBindingAvailable)) if condition.IsConditionStatusTrue(availableCondition, binding.GetGeneration()) { // TO-DO (chenyu1): currently it checks for both the new and the old reason // (as set previously by the work generator) to avoid compatibility issues. @@ -643,7 +642,7 @@ func (r *Reconciler) updateBindings(ctx context.Context, bindings []toBeUpdatedB bindObj := klog.KObj(binding.currentBinding) switch binding.currentBinding.GetBindingSpec().State { // The only thing we can do on a bound binding is to update its resource resourceBinding - case fleetv1beta1.BindingStateBound: + case placementv1beta1.BindingStateBound: errs.Go(func() error { if err := r.Client.Update(cctx, binding.desiredBinding); err != nil { klog.ErrorS(err, "Failed to update a binding to the latest resource", "binding", bindObj) @@ -653,7 +652,7 @@ func (r *Reconciler) updateBindings(ctx context.Context, bindings []toBeUpdatedB return r.updateBindingStatus(ctx, binding.desiredBinding, true) }) // We need to bound the scheduled binding to the latest resource snapshot, scheduler doesn't set the resource snapshot name - case fleetv1beta1.BindingStateScheduled: + case placementv1beta1.BindingStateScheduled: errs.Go(func() error { if err := r.Client.Update(cctx, binding.desiredBinding); err != nil { klog.ErrorS(err, "Failed to mark a binding bound", "binding", bindObj) @@ -663,7 +662,7 @@ func (r *Reconciler) updateBindings(ctx context.Context, bindings []toBeUpdatedB return r.updateBindingStatus(ctx, binding.desiredBinding, true) }) // The only thing we can do on an unscheduled binding is to delete it - case fleetv1beta1.BindingStateUnscheduled: + case placementv1beta1.BindingStateUnscheduled: errs.Go(func() error { if err := r.Client.Delete(cctx, binding.currentBinding); err != nil { if !errors.IsNotFound(err) { @@ -686,7 +685,7 @@ func (r *Reconciler) SetupWithManager(mgr runtime.Manager) error { r.recorder = mgr.GetEventRecorderFor("rollout-controller") return runtime.NewControllerManagedBy(mgr).Named("rollout-controller"). WithOptions(ctrl.Options{MaxConcurrentReconciles: r.MaxConcurrentReconciles}). // set the max number of concurrent reconciles - Watches(&fleetv1beta1.ClusterResourceSnapshot{}, handler.Funcs{ + Watches(&placementv1beta1.ClusterResourceSnapshot{}, handler.Funcs{ CreateFunc: func(ctx context.Context, e event.CreateEvent, q workqueue.TypedRateLimitingInterface[reconcile.Request]) { klog.V(2).InfoS("Handling a cluster resource snapshot create event", "resourceSnapshot", klog.KObj(e.Object)) handleResourceSnapshot(e.Object, q) @@ -696,7 +695,7 @@ func (r *Reconciler) SetupWithManager(mgr runtime.Manager) error { handleResourceSnapshot(e.Object, q) }, }). - Watches(&fleetv1alpha1.ClusterResourceOverrideSnapshot{}, handler.Funcs{ + Watches(&placementv1beta1.ClusterResourceOverrideSnapshot{}, handler.Funcs{ CreateFunc: func(ctx context.Context, e event.CreateEvent, q workqueue.TypedRateLimitingInterface[reconcile.Request]) { klog.V(2).InfoS("Handling a clusterResourceOverrideSnapshot create event", "clusterResourceOverrideSnapshot", klog.KObj(e.Object)) handleClusterResourceOverrideSnapshot(e.Object, q) @@ -706,7 +705,7 @@ func (r *Reconciler) SetupWithManager(mgr runtime.Manager) error { handleClusterResourceOverrideSnapshot(e.Object, q) }, }). - Watches(&fleetv1alpha1.ResourceOverrideSnapshot{}, handler.Funcs{ + Watches(&placementv1beta1.ResourceOverrideSnapshot{}, handler.Funcs{ CreateFunc: func(ctx context.Context, e event.CreateEvent, q workqueue.TypedRateLimitingInterface[reconcile.Request]) { klog.V(2).InfoS("Handling a resourceOverrideSnapshot create event", "resourceOverrideSnapshot", klog.KObj(e.Object)) handleResourceOverrideSnapshot(e.Object, q) @@ -716,9 +715,9 @@ func (r *Reconciler) SetupWithManager(mgr runtime.Manager) error { handleResourceOverrideSnapshot(e.Object, q) }, }). - Watches(&fleetv1alpha1.ClusterResourceOverride{}, handler.Funcs{ + Watches(&placementv1beta1.ClusterResourceOverride{}, handler.Funcs{ DeleteFunc: func(ctx context.Context, e event.DeleteEvent, q workqueue.TypedRateLimitingInterface[reconcile.Request]) { - cro, ok := e.Object.(*fleetv1alpha1.ClusterResourceOverride) + cro, ok := e.Object.(*placementv1beta1.ClusterResourceOverride) if !ok { klog.ErrorS(controller.NewUnexpectedBehaviorError(fmt.Errorf("non ClusterResourceOverride type resource: %+v", e.Object)), "Rollout controller received invalid ClusterResourceOverride event", "object", klog.KObj(e.Object)) @@ -733,9 +732,9 @@ func (r *Reconciler) SetupWithManager(mgr runtime.Manager) error { }) }, }). - Watches(&fleetv1alpha1.ResourceOverride{}, handler.Funcs{ + Watches(&placementv1beta1.ResourceOverride{}, handler.Funcs{ DeleteFunc: func(ctx context.Context, e event.DeleteEvent, q workqueue.TypedRateLimitingInterface[reconcile.Request]) { - ro, ok := e.Object.(*fleetv1alpha1.ResourceOverride) + ro, ok := e.Object.(*placementv1beta1.ResourceOverride) if !ok { klog.ErrorS(controller.NewUnexpectedBehaviorError(fmt.Errorf("non ResourceOverride type resource: %+v", e.Object)), "Rollout controller received invalid ResourceOverride event", "object", klog.KObj(e.Object)) @@ -750,7 +749,7 @@ func (r *Reconciler) SetupWithManager(mgr runtime.Manager) error { }) }, }). - Watches(&fleetv1beta1.ClusterResourceBinding{}, handler.Funcs{ + Watches(&placementv1beta1.ClusterResourceBinding{}, handler.Funcs{ CreateFunc: func(ctx context.Context, e event.CreateEvent, q workqueue.TypedRateLimitingInterface[reconcile.Request]) { klog.V(2).InfoS("Handling a cluster resourceBinding create event", "resourceBinding", klog.KObj(e.Object)) enqueueResourceBinding(e.Object, q) @@ -766,7 +765,7 @@ func (r *Reconciler) SetupWithManager(mgr runtime.Manager) error { // Aside from resource snapshot and binding objects, the rollout // controller also watches placement objects (ClusterResourcePlacement and ResourcePlacement), // so that it can push apply strategy updates to all bindings right away. - Watches(&fleetv1beta1.ClusterResourcePlacement{}, handler.Funcs{ + Watches(&placementv1beta1.ClusterResourcePlacement{}, handler.Funcs{ // Ignore all Create, Delete, and Generic events; these do not concern the rollout controller. UpdateFunc: func(ctx context.Context, e event.UpdateEvent, q workqueue.TypedRateLimitingInterface[reconcile.Request]) { handlePlacement(e.ObjectNew, e.ObjectOld, q) @@ -778,7 +777,7 @@ func (r *Reconciler) SetupWithManager(mgr runtime.Manager) error { // handleClusterResourceOverrideSnapshot parse the clusterResourceOverrideSnapshot label and enqueue the CRP name associated // with the clusterResourceOverrideSnapshot if set. func handleClusterResourceOverrideSnapshot(o client.Object, q workqueue.TypedRateLimitingInterface[reconcile.Request]) { - snapshot, ok := o.(*fleetv1alpha1.ClusterResourceOverrideSnapshot) + snapshot, ok := o.(*placementv1beta1.ClusterResourceOverrideSnapshot) if !ok { klog.ErrorS(controller.NewUnexpectedBehaviorError(fmt.Errorf("non ClusterResourceOverrideSnapshot type resource: %+v", o)), "Rollout controller received invalid ClusterResourceOverrideSnapshot event", "object", klog.KObj(o)) @@ -787,9 +786,9 @@ func handleClusterResourceOverrideSnapshot(o client.Object, q workqueue.TypedRat snapshotKRef := klog.KObj(snapshot) // check if it is the latest resource resourceBinding - isLatest, err := strconv.ParseBool(snapshot.GetLabels()[fleetv1beta1.IsLatestSnapshotLabel]) + isLatest, err := strconv.ParseBool(snapshot.GetLabels()[placementv1beta1.IsLatestSnapshotLabel]) if err != nil { - klog.ErrorS(controller.NewUnexpectedBehaviorError(fmt.Errorf("invalid label value %s : %w", fleetv1beta1.IsLatestSnapshotLabel, err)), + klog.ErrorS(controller.NewUnexpectedBehaviorError(fmt.Errorf("invalid label value %s : %w", placementv1beta1.IsLatestSnapshotLabel, err)), "Resource clusterResourceOverrideSnapshot has does not have a valid islatest label", "clusterResourceOverrideSnapshot", snapshotKRef) return } @@ -811,7 +810,7 @@ func handleClusterResourceOverrideSnapshot(o client.Object, q workqueue.TypedRat // handleResourceOverrideSnapshot parse the resourceOverrideSnapshot label and enqueue the CRP name associated with the // resourceOverrideSnapshot if set. func handleResourceOverrideSnapshot(o client.Object, q workqueue.TypedRateLimitingInterface[reconcile.Request]) { - snapshot, ok := o.(*fleetv1alpha1.ResourceOverrideSnapshot) + snapshot, ok := o.(*placementv1beta1.ResourceOverrideSnapshot) if !ok { klog.ErrorS(controller.NewUnexpectedBehaviorError(fmt.Errorf("non ResourceOverrideSnapshot type resource: %+v", o)), "Rollout controller received invalid ResourceOverrideSnapshot event", "object", klog.KObj(o)) @@ -820,9 +819,9 @@ func handleResourceOverrideSnapshot(o client.Object, q workqueue.TypedRateLimiti snapshotKRef := klog.KObj(snapshot) // check if it is the latest resource resourceBinding - isLatest, err := strconv.ParseBool(snapshot.GetLabels()[fleetv1beta1.IsLatestSnapshotLabel]) + isLatest, err := strconv.ParseBool(snapshot.GetLabels()[placementv1beta1.IsLatestSnapshotLabel]) if err != nil { - klog.ErrorS(controller.NewUnexpectedBehaviorError(fmt.Errorf("invalid label value %s : %w", fleetv1beta1.IsLatestSnapshotLabel, err)), + klog.ErrorS(controller.NewUnexpectedBehaviorError(fmt.Errorf("invalid label value %s : %w", placementv1beta1.IsLatestSnapshotLabel, err)), "Resource resourceOverrideSnapshot has does not have a valid islatest annotation", "resourceOverrideSnapshot", snapshotKRef) return } @@ -845,16 +844,16 @@ func handleResourceOverrideSnapshot(o client.Object, q workqueue.TypedRateLimiti func handleResourceSnapshot(snapshot client.Object, q workqueue.TypedRateLimitingInterface[reconcile.Request]) { snapshotKRef := klog.KObj(snapshot) // check if it is the first resource resourceBinding which is supposed to have NumberOfResourceSnapshotsAnnotation - _, exist := snapshot.GetAnnotations()[fleetv1beta1.ResourceGroupHashAnnotation] + _, exist := snapshot.GetAnnotations()[placementv1beta1.ResourceGroupHashAnnotation] if !exist { // we only care about when a new resource resourceBinding index is created klog.V(2).InfoS("Ignore the subsequent sub resource snapshots", "clusterResourceSnapshot", snapshotKRef) return } // check if it is the latest resource resourceBinding - isLatest, err := strconv.ParseBool(snapshot.GetLabels()[fleetv1beta1.IsLatestSnapshotLabel]) + isLatest, err := strconv.ParseBool(snapshot.GetLabels()[placementv1beta1.IsLatestSnapshotLabel]) if err != nil { - klog.ErrorS(controller.NewUnexpectedBehaviorError(fmt.Errorf("invalid label value %s : %w", fleetv1beta1.IsLatestSnapshotLabel, err)), + klog.ErrorS(controller.NewUnexpectedBehaviorError(fmt.Errorf("invalid label value %s : %w", placementv1beta1.IsLatestSnapshotLabel, err)), "Resource snapshot has does not have a valid islatest annotation", "resourceSnapshot", snapshotKRef) return } @@ -865,7 +864,7 @@ func handleResourceSnapshot(snapshot client.Object, q workqueue.TypedRateLimitin return } // get the placement name from the label - placementName := snapshot.GetLabels()[fleetv1beta1.PlacementTrackingLabel] + placementName := snapshot.GetLabels()[placementv1beta1.PlacementTrackingLabel] if len(placementName) == 0 { // should never happen, we might be able to alert on this error klog.ErrorS(controller.NewUnexpectedBehaviorError(fmt.Errorf("cannot find CRPTrackingLabel label value")), @@ -882,7 +881,7 @@ func handleResourceSnapshot(snapshot client.Object, q workqueue.TypedRateLimitin func enqueueResourceBinding(binding client.Object, q workqueue.TypedRateLimitingInterface[reconcile.Request]) { bindingRef := klog.KObj(binding) // get the placement name from the label - placementName := binding.GetLabels()[fleetv1beta1.PlacementTrackingLabel] + placementName := binding.GetLabels()[placementv1beta1.PlacementTrackingLabel] if len(placementName) == 0 { // should never happen klog.ErrorS(controller.NewUnexpectedBehaviorError(fmt.Errorf("cannot find CRPTrackingLabel label value")), @@ -905,8 +904,8 @@ func handleResourceBindingUpdated(objectOld, objectNew client.Object, q workqueu } // Try to cast to BindingObj interface - oldBinding, oldOk := objectOld.(fleetv1beta1.BindingObj) - newBinding, newOk := objectNew.(fleetv1beta1.BindingObj) + oldBinding, oldOk := objectOld.(placementv1beta1.BindingObj) + newBinding, newOk := objectNew.(placementv1beta1.BindingObj) if !oldOk || !newOk { klog.ErrorS(controller.NewUnexpectedBehaviorError(fmt.Errorf("failed to cast runtime objects in update event to binding objects")), "Failed to process update event") return @@ -919,7 +918,7 @@ func handleResourceBindingUpdated(objectOld, objectNew client.Object, q workqueu } // these are the conditions we care about - conditionsToMonitor := []string{string(fleetv1beta1.ResourceBindingDiffReported), string(fleetv1beta1.ResourceBindingAvailable)} + conditionsToMonitor := []string{string(placementv1beta1.ResourceBindingDiffReported), string(placementv1beta1.ResourceBindingAvailable)} for _, conditionType := range conditionsToMonitor { oldCond := oldBinding.GetCondition(conditionType) newCond := newBinding.GetCondition(conditionType) @@ -944,7 +943,7 @@ func (r *Reconciler) updateStaleBindingsStatus(ctx context.Context, staleBinding for i := 0; i < len(staleBindings); i++ { binding := staleBindings[i] currentBindingSpec := binding.currentBinding.GetBindingSpec() - if currentBindingSpec.State != fleetv1beta1.BindingStateScheduled && currentBindingSpec.State != fleetv1beta1.BindingStateBound { + if currentBindingSpec.State != placementv1beta1.BindingStateScheduled && currentBindingSpec.State != placementv1beta1.BindingStateBound { klog.ErrorS(controller.NewUnexpectedBehaviorError(fmt.Errorf("invalid stale binding state %s", currentBindingSpec.State)), "Found a stale binding with unexpected state", "binding", klog.KObj(binding.currentBinding)) continue @@ -974,9 +973,9 @@ func (r *Reconciler) refreshUpToDateBindingStatus(ctx context.Context, upToDateB // updateBindingStatus updates the status of a BindingObj. // This function operates purely on the interface without type conversions. -func (r *Reconciler) updateBindingStatus(ctx context.Context, binding fleetv1beta1.BindingObj, rolloutStarted bool) error { +func (r *Reconciler) updateBindingStatus(ctx context.Context, binding placementv1beta1.BindingObj, rolloutStarted bool) error { cond := metav1.Condition{ - Type: string(fleetv1beta1.ResourceBindingRolloutStarted), + Type: string(placementv1beta1.ResourceBindingRolloutStarted), Status: metav1.ConditionFalse, ObservedGeneration: binding.GetGeneration(), Reason: condition.RolloutNotStartedYetReason, @@ -984,7 +983,7 @@ func (r *Reconciler) updateBindingStatus(ctx context.Context, binding fleetv1bet } if rolloutStarted { cond = metav1.Condition{ - Type: string(fleetv1beta1.ResourceBindingRolloutStarted), + Type: string(placementv1beta1.ResourceBindingRolloutStarted), Status: metav1.ConditionTrue, ObservedGeneration: binding.GetGeneration(), Reason: condition.RolloutStartedReason, @@ -1004,8 +1003,8 @@ func (r *Reconciler) updateBindingStatus(ctx context.Context, binding fleetv1bet // it will push the update to all applicable bindings. func (r *Reconciler) processApplyStrategyUpdates( ctx context.Context, - placementObj fleetv1beta1.PlacementObj, - allBindings []fleetv1beta1.BindingObj, + placementObj placementv1beta1.PlacementObj, + allBindings []placementv1beta1.BindingObj, ) (applyStrategyUpdated bool, err error) { applyStrategy := placementObj.GetPlacementSpec().Strategy.ApplyStrategy if applyStrategy == nil { @@ -1016,7 +1015,7 @@ func (r *Reconciler) processApplyStrategyUpdates( // APIs at the same time with Kubernetes favoring the v1 API by default, should the // user chooses to use the v1 API, default values for v1beta1 exclusive fields // might not be handled correctly, hence the default value resetting logic added here. - applyStrategy = &fleetv1beta1.ApplyStrategy{} + applyStrategy = &placementv1beta1.ApplyStrategy{} defaulter.SetDefaultsApplyStrategy(applyStrategy) } @@ -1040,7 +1039,7 @@ func (r *Reconciler) processApplyStrategyUpdates( // // The ApplyStrategy field on binding objects are managed exclusively by the rollout // controller; to avoid unnecessary conflicts, Fleet will patch the field directly. - updatedBinding := binding.DeepCopyObject().(fleetv1beta1.BindingObj) + updatedBinding := binding.DeepCopyObject().(placementv1beta1.BindingObj) updatedSpec := updatedBinding.GetBindingSpec() updatedSpec.ApplyStrategy = applyStrategy applyStrategyUpdated = true @@ -1070,8 +1069,8 @@ func handlePlacement(newPlacementObj, oldPlacementObj client.Object, q workqueue } // Try to cast to PlacementObj interface - newPlacement, newOK := newPlacementObj.(fleetv1beta1.PlacementObj) - oldPlacement, oldOK := oldPlacementObj.(fleetv1beta1.PlacementObj) + newPlacement, newOK := newPlacementObj.(placementv1beta1.PlacementObj) + oldPlacement, oldOK := oldPlacementObj.(placementv1beta1.PlacementObj) if !newOK || !oldOK { klog.ErrorS(controller.NewUnexpectedBehaviorError(fmt.Errorf("object is not a placement object")), "Failed to cast the object in the placement Update event to a placement object", "placement (new)", klog.KObj(newPlacementObj), "placement (old)", klog.KObj(oldPlacementObj), "canCastNewObj", newOK, "canCastOldObj", oldOK) return diff --git a/pkg/controllers/rollout/controller_integration_test.go b/pkg/controllers/rollout/controller_integration_test.go index 96df4f20f..7abe80f54 100644 --- a/pkg/controllers/rollout/controller_integration_test.go +++ b/pkg/controllers/rollout/controller_integration_test.go @@ -32,7 +32,7 @@ import ( "k8s.io/apimachinery/pkg/util/intstr" "k8s.io/utils/ptr" - fleetv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" + placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" "go.goms.io/fleet/pkg/utils" "go.goms.io/fleet/pkg/utils/condition" ) @@ -46,7 +46,7 @@ const ( ) var ( - ignoreCRBTypeMetaAndStatusFields = cmpopts.IgnoreFields(fleetv1beta1.ClusterResourceBinding{}, "TypeMeta", "Status") + ignoreCRBTypeMetaAndStatusFields = cmpopts.IgnoreFields(placementv1beta1.ClusterResourceBinding{}, "TypeMeta", "Status") ignoreObjectMetaAutoGenFields = cmpopts.IgnoreFields(metav1.ObjectMeta{}, "CreationTimestamp", "Generation", "ResourceVersion", "SelfLink", "UID", "ManagedFields") ignoreCondLTTAndMessageFields = cmpopts.IgnoreFields(metav1.Condition{}, "LastTransitionTime", "Message") ) @@ -55,14 +55,14 @@ var testCRPName string var _ = Describe("Test the rollout Controller", func() { - var bindings []*fleetv1beta1.ClusterResourceBinding - var resourceSnapshots []*fleetv1beta1.ClusterResourceSnapshot - var rolloutCRP *fleetv1beta1.ClusterResourcePlacement + var bindings []*placementv1beta1.ClusterResourceBinding + var resourceSnapshots []*placementv1beta1.ClusterResourceSnapshot + var rolloutCRP *placementv1beta1.ClusterResourcePlacement BeforeEach(func() { testCRPName = "crp" + utils.RandStr() - bindings = make([]*fleetv1beta1.ClusterResourceBinding, 0) - resourceSnapshots = make([]*fleetv1beta1.ClusterResourceSnapshot, 0) + bindings = make([]*placementv1beta1.ClusterResourceBinding, 0) + resourceSnapshots = make([]*placementv1beta1.ClusterResourceSnapshot, 0) }) AfterEach(func() { @@ -84,8 +84,8 @@ var _ = Describe("Test the rollout Controller", func() { // create CRP var targetCluster int32 = 10 rolloutCRP = clusterResourcePlacementForTest(testCRPName, - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, targetCluster), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)) + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, targetCluster), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)) Expect(k8sClient.Create(ctx, rolloutCRP)).Should(Succeed()) // create master resource snapshot that is latest masterSnapshot := generateResourceSnapshot(rolloutCRP.Name, 0, true) @@ -95,7 +95,7 @@ var _ = Describe("Test the rollout Controller", func() { clusters := make([]string, targetCluster) for i := 0; i < int(targetCluster); i++ { clusters[i] = "cluster-" + utils.RandStr() - binding := generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, masterSnapshot.Name, clusters[i]) + binding := generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, masterSnapshot.Name, clusters[i]) Expect(k8sClient.Create(ctx, binding)).Should(Succeed()) By(fmt.Sprintf("resource binding %s created", binding.Name)) bindings = append(bindings, binding) @@ -109,8 +109,8 @@ var _ = Describe("Test the rollout Controller", func() { targetClusterCount := int32(3) rolloutCRP = clusterResourcePlacementForTest( testCRPName, - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, targetClusterCount), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)) + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, targetClusterCount), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)) Expect(k8sClient.Create(ctx, rolloutCRP)).Should(Succeed(), "Failed to create CRP") // Create a master cluster resource snapshot. @@ -123,14 +123,14 @@ var _ = Describe("Test the rollout Controller", func() { clusters[i] = "cluster-" + utils.RandStr() // Prepare bindings of various states. - var binding *fleetv1beta1.ClusterResourceBinding + var binding *placementv1beta1.ClusterResourceBinding switch i % 3 { case 0: - binding = generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, resourceSnapshot.Name, clusters[i]) + binding = generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, resourceSnapshot.Name, clusters[i]) case 1: - binding = generateClusterResourceBinding(fleetv1beta1.BindingStateBound, resourceSnapshot.Name, clusters[i]) + binding = generateClusterResourceBinding(placementv1beta1.BindingStateBound, resourceSnapshot.Name, clusters[i]) default: - binding = generateClusterResourceBinding(fleetv1beta1.BindingStateUnscheduled, resourceSnapshot.Name, clusters[i]) + binding = generateClusterResourceBinding(placementv1beta1.BindingStateUnscheduled, resourceSnapshot.Name, clusters[i]) } Expect(k8sClient.Create(ctx, binding)).Should(Succeed(), "Failed to create cluster resource binding") bindings = append(bindings, binding) @@ -139,30 +139,30 @@ var _ = Describe("Test the rollout Controller", func() { // Verify that all the bindings are updated per rollout strategy. Eventually(func() error { for _, binding := range bindings { - gotBinding := &fleetv1beta1.ClusterResourceBinding{} + gotBinding := &placementv1beta1.ClusterResourceBinding{} if err := k8sClient.Get(ctx, types.NamespacedName{Name: binding.GetName()}, gotBinding); err != nil { return fmt.Errorf("failed to get binding %s: %w", binding.Name, err) } - wantBinding := &fleetv1beta1.ClusterResourceBinding{ + wantBinding := &placementv1beta1.ClusterResourceBinding{ ObjectMeta: metav1.ObjectMeta{ Name: binding.Name, }, - Spec: fleetv1beta1.ResourceBindingSpec{ + Spec: placementv1beta1.ResourceBindingSpec{ State: binding.Spec.State, TargetCluster: binding.Spec.TargetCluster, - ApplyStrategy: &fleetv1beta1.ApplyStrategy{ - ComparisonOption: fleetv1beta1.ComparisonOptionTypePartialComparison, - WhenToApply: fleetv1beta1.WhenToApplyTypeAlways, - WhenToTakeOver: fleetv1beta1.WhenToTakeOverTypeAlways, - Type: fleetv1beta1.ApplyStrategyTypeClientSideApply, + ApplyStrategy: &placementv1beta1.ApplyStrategy{ + ComparisonOption: placementv1beta1.ComparisonOptionTypePartialComparison, + WhenToApply: placementv1beta1.WhenToApplyTypeAlways, + WhenToTakeOver: placementv1beta1.WhenToTakeOverTypeAlways, + Type: placementv1beta1.ApplyStrategyTypeClientSideApply, }, }, } // The bound binding will have no changes; the scheduled binding, per given // rollout strategy, will be bound with the resource snapshot. - if binding.Spec.State == fleetv1beta1.BindingStateBound || binding.Spec.State == fleetv1beta1.BindingStateScheduled { - wantBinding.Spec.State = fleetv1beta1.BindingStateBound + if binding.Spec.State == placementv1beta1.BindingStateBound || binding.Spec.State == placementv1beta1.BindingStateScheduled { + wantBinding.Spec.State = placementv1beta1.BindingStateBound wantBinding.Spec.ResourceSnapshotName = resourceSnapshot.Name } if diff := cmp.Diff( @@ -181,15 +181,15 @@ var _ = Describe("Test the rollout Controller", func() { // conditions). Eventually(func() error { for _, binding := range bindings { - gotBinding := &fleetv1beta1.ClusterResourceBinding{} + gotBinding := &placementv1beta1.ClusterResourceBinding{} if err := k8sClient.Get(ctx, types.NamespacedName{Name: binding.GetName()}, gotBinding); err != nil { return fmt.Errorf("failed to get binding %s: %w", binding.Name, err) } - wantBindingStatus := &fleetv1beta1.ResourceBindingStatus{ + wantBindingStatus := &placementv1beta1.ResourceBindingStatus{ Conditions: []metav1.Condition{ { - Type: string(fleetv1beta1.ResourceBindingRolloutStarted), + Type: string(placementv1beta1.ResourceBindingRolloutStarted), Status: metav1.ConditionTrue, Reason: condition.RolloutStartedReason, ObservedGeneration: gotBinding.Generation, @@ -199,8 +199,8 @@ var _ = Describe("Test the rollout Controller", func() { // The scheduled binding will be set to the Bound state with the RolloutStarted // condition set to True; the bound binding will receive a True RolloutStarted // condition; the unscheduled binding will have no RolloutStarted condition update. - if binding.Spec.State == fleetv1beta1.BindingStateUnscheduled { - wantBindingStatus = &fleetv1beta1.ResourceBindingStatus{ + if binding.Spec.State == placementv1beta1.BindingStateUnscheduled { + wantBindingStatus = &placementv1beta1.ResourceBindingStatus{ Conditions: []metav1.Condition{}, } } @@ -216,12 +216,12 @@ var _ = Describe("Test the rollout Controller", func() { }, timeout, interval).Should(Succeed(), "Failed to verify that all the bindings have their status refreshed") // Update the CRP with a new apply strategy. - rolloutCRP.Spec.Strategy.ApplyStrategy = &fleetv1beta1.ApplyStrategy{ - ComparisonOption: fleetv1beta1.ComparisonOptionTypeFullComparison, - WhenToApply: fleetv1beta1.WhenToApplyTypeIfNotDrifted, - WhenToTakeOver: fleetv1beta1.WhenToTakeOverTypeIfNoDiff, - Type: fleetv1beta1.ApplyStrategyTypeServerSideApply, - ServerSideApplyConfig: &fleetv1beta1.ServerSideApplyConfig{ + rolloutCRP.Spec.Strategy.ApplyStrategy = &placementv1beta1.ApplyStrategy{ + ComparisonOption: placementv1beta1.ComparisonOptionTypeFullComparison, + WhenToApply: placementv1beta1.WhenToApplyTypeIfNotDrifted, + WhenToTakeOver: placementv1beta1.WhenToTakeOverTypeIfNoDiff, + Type: placementv1beta1.ApplyStrategyTypeServerSideApply, + ServerSideApplyConfig: &placementv1beta1.ServerSideApplyConfig{ ForceConflicts: true, }, } @@ -230,24 +230,24 @@ var _ = Describe("Test the rollout Controller", func() { // Verify that all the bindings are updated with the new apply strategy. Eventually(func() error { for _, binding := range bindings { - gotBinding := &fleetv1beta1.ClusterResourceBinding{} + gotBinding := &placementv1beta1.ClusterResourceBinding{} if err := k8sClient.Get(ctx, types.NamespacedName{Name: binding.GetName()}, gotBinding); err != nil { return fmt.Errorf("failed to get binding %s: %w", binding.Name, err) } - wantBinding := &fleetv1beta1.ClusterResourceBinding{ + wantBinding := &placementv1beta1.ClusterResourceBinding{ ObjectMeta: metav1.ObjectMeta{ Name: binding.Name, }, - Spec: fleetv1beta1.ResourceBindingSpec{ + Spec: placementv1beta1.ResourceBindingSpec{ State: binding.Spec.State, TargetCluster: binding.Spec.TargetCluster, - ApplyStrategy: &fleetv1beta1.ApplyStrategy{ - ComparisonOption: fleetv1beta1.ComparisonOptionTypeFullComparison, - WhenToApply: fleetv1beta1.WhenToApplyTypeIfNotDrifted, - WhenToTakeOver: fleetv1beta1.WhenToTakeOverTypeIfNoDiff, - Type: fleetv1beta1.ApplyStrategyTypeServerSideApply, - ServerSideApplyConfig: &fleetv1beta1.ServerSideApplyConfig{ + ApplyStrategy: &placementv1beta1.ApplyStrategy{ + ComparisonOption: placementv1beta1.ComparisonOptionTypeFullComparison, + WhenToApply: placementv1beta1.WhenToApplyTypeIfNotDrifted, + WhenToTakeOver: placementv1beta1.WhenToTakeOverTypeIfNoDiff, + Type: placementv1beta1.ApplyStrategyTypeServerSideApply, + ServerSideApplyConfig: &placementv1beta1.ServerSideApplyConfig{ ForceConflicts: true, }, }, @@ -255,8 +255,8 @@ var _ = Describe("Test the rollout Controller", func() { } // The bound binding will have no changes; the scheduled binding, per given // rollout strategy, will be bound with the resource snapshot. - if binding.Spec.State == fleetv1beta1.BindingStateBound || binding.Spec.State == fleetv1beta1.BindingStateScheduled { - wantBinding.Spec.State = fleetv1beta1.BindingStateBound + if binding.Spec.State == placementv1beta1.BindingStateBound || binding.Spec.State == placementv1beta1.BindingStateScheduled { + wantBinding.Spec.State = placementv1beta1.BindingStateBound wantBinding.Spec.ResourceSnapshotName = resourceSnapshot.Name } if diff := cmp.Diff( @@ -275,15 +275,15 @@ var _ = Describe("Test the rollout Controller", func() { // conditions). Eventually(func() error { for _, binding := range bindings { - gotBinding := &fleetv1beta1.ClusterResourceBinding{} + gotBinding := &placementv1beta1.ClusterResourceBinding{} if err := k8sClient.Get(ctx, types.NamespacedName{Name: binding.GetName()}, gotBinding); err != nil { return fmt.Errorf("failed to get binding %s: %w", binding.Name, err) } - wantBindingStatus := &fleetv1beta1.ResourceBindingStatus{ + wantBindingStatus := &placementv1beta1.ResourceBindingStatus{ Conditions: []metav1.Condition{ { - Type: string(fleetv1beta1.ResourceBindingRolloutStarted), + Type: string(placementv1beta1.ResourceBindingRolloutStarted), Status: metav1.ConditionTrue, Reason: condition.RolloutStartedReason, ObservedGeneration: gotBinding.Generation, @@ -293,8 +293,8 @@ var _ = Describe("Test the rollout Controller", func() { // The scheduled binding will be set to the Bound state with the RolloutStarted // condition set to True; the bound binding will receive a True RolloutStarted // condition; the unscheduled binding will have no RolloutStarted condition update. - if binding.Spec.State == fleetv1beta1.BindingStateUnscheduled { - wantBindingStatus = &fleetv1beta1.ResourceBindingStatus{ + if binding.Spec.State == placementv1beta1.BindingStateUnscheduled { + wantBindingStatus = &placementv1beta1.ResourceBindingStatus{ Conditions: []metav1.Condition{}, } } @@ -315,8 +315,8 @@ var _ = Describe("Test the rollout Controller", func() { var targetCluster int32 = 11 // rolloutStrategy not set. rolloutCRP = clusterResourcePlacementForTest(testCRPName, - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, targetCluster), - fleetv1beta1.RolloutStrategy{}) + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, targetCluster), + placementv1beta1.RolloutStrategy{}) Expect(k8sClient.Create(ctx, rolloutCRP)).Should(Succeed()) // create master resource snapshot that is latest masterSnapshot := generateResourceSnapshot(rolloutCRP.Name, 0, true) @@ -326,7 +326,7 @@ var _ = Describe("Test the rollout Controller", func() { clusters := make([]string, targetCluster) for i := 0; i < int(targetCluster); i++ { clusters[i] = "cluster-" + utils.RandStr() - binding := generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, masterSnapshot.Name, clusters[i]) + binding := generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, masterSnapshot.Name, clusters[i]) Expect(k8sClient.Create(ctx, binding)).Should(Succeed()) By(fmt.Sprintf("resource binding %s created", binding.Name)) bindings = append(bindings, binding) @@ -339,8 +339,8 @@ var _ = Describe("Test the rollout Controller", func() { // create CRP var initTargetClusterNum int32 = 11 rolloutCRP = clusterResourcePlacementForTest(testCRPName, - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, initTargetClusterNum), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)) + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, initTargetClusterNum), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)) Expect(k8sClient.Create(ctx, rolloutCRP)).Should(Succeed()) // create master resource snapshot that is latest masterSnapshot := generateResourceSnapshot(rolloutCRP.Name, 0, true) @@ -350,7 +350,7 @@ var _ = Describe("Test the rollout Controller", func() { clusters := make([]string, initTargetClusterNum) for i := 0; i < int(initTargetClusterNum); i++ { clusters[i] = "cluster-" + strconv.Itoa(i) - binding := generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, masterSnapshot.Name, clusters[i]) + binding := generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, masterSnapshot.Name, clusters[i]) Expect(k8sClient.Create(ctx, binding)).Should(Succeed()) By(fmt.Sprintf("resource binding %s created", binding.Name)) bindings = append(bindings, binding) @@ -367,8 +367,8 @@ var _ = Describe("Test the rollout Controller", func() { var newTargetClusterNum int32 = 9 rolloutCRP.Spec.Policy.NumberOfClusters = &newTargetClusterNum Expect(k8sClient.Update(ctx, rolloutCRP)).Should(Succeed()) - secondRoundBindings := make([]*fleetv1beta1.ClusterResourceBinding, 0) - deletedBindings := make([]*fleetv1beta1.ClusterResourceBinding, 0) + secondRoundBindings := make([]*placementv1beta1.ClusterResourceBinding, 0) + deletedBindings := make([]*placementv1beta1.ClusterResourceBinding, 0) stillScheduledClusterNum := 6 // the amount of clusters that are still scheduled in first round // simulate that some of the bindings are available // moved to before being set to unscheduled, otherwise, the rollout controller will try to delete the bindings before we mark them as available. @@ -377,7 +377,7 @@ var _ = Describe("Test the rollout Controller", func() { } for i := int(initTargetClusterNum - 1); i >= stillScheduledClusterNum; i-- { binding := bindings[i] - binding.Spec.State = fleetv1beta1.BindingStateUnscheduled + binding.Spec.State = placementv1beta1.BindingStateUnscheduled Expect(k8sClient.Update(ctx, binding)).Should(Succeed()) By(fmt.Sprintf("resource binding `%s` is marked as not scheduled", binding.Name)) deletedBindings = append(deletedBindings, binding) @@ -391,7 +391,7 @@ var _ = Describe("Test the rollout Controller", func() { } newlyScheduledClusterNum := int(newTargetClusterNum) - stillScheduledClusterNum for i := 0; i < newlyScheduledClusterNum; i++ { - binding := generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, masterSnapshot.Name, "cluster-"+strconv.Itoa(int(initTargetClusterNum)+i)) + binding := generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, masterSnapshot.Name, "cluster-"+strconv.Itoa(int(initTargetClusterNum)+i)) Expect(k8sClient.Create(ctx, binding)).Should(Succeed()) By(fmt.Sprintf("resource binding %s created", binding.Name)) bindings = append(bindings, binding) @@ -404,7 +404,7 @@ var _ = Describe("Test the rollout Controller", func() { if err != nil { return false } - if binding.Spec.State != fleetv1beta1.BindingStateBound || binding.Spec.ResourceSnapshotName != masterSnapshot.Name { + if binding.Spec.State != placementv1beta1.BindingStateBound || binding.Spec.ResourceSnapshotName != masterSnapshot.Name { return false } } @@ -429,8 +429,8 @@ var _ = Describe("Test the rollout Controller", func() { // create CRP var targetCluster int32 = 11 rolloutCRP = clusterResourcePlacementForTest(testCRPName, - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, targetCluster), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)) + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, targetCluster), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)) Expect(k8sClient.Create(ctx, rolloutCRP)).Should(Succeed()) // create master resource snapshot that is latest masterSnapshot := generateResourceSnapshot(rolloutCRP.Name, 0, true) @@ -440,7 +440,7 @@ var _ = Describe("Test the rollout Controller", func() { clusters := make([]string, targetCluster) for i := 0; i < int(targetCluster); i++ { clusters[i] = "cluster-" + strconv.Itoa(i) - binding := generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, masterSnapshot.Name, clusters[i]) + binding := generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, masterSnapshot.Name, clusters[i]) Expect(k8sClient.Create(ctx, binding)).Should(Succeed()) By(fmt.Sprintf("resource binding %s created", binding.Name)) bindings = append(bindings, binding) @@ -457,8 +457,8 @@ var _ = Describe("Test the rollout Controller", func() { var newTarget int32 = 9 rolloutCRP.Spec.Policy.NumberOfClusters = &newTarget Expect(k8sClient.Update(ctx, rolloutCRP)).Should(Succeed()) - secondRoundBindings := make([]*fleetv1beta1.ClusterResourceBinding, 0) - deletedBindings := make([]*fleetv1beta1.ClusterResourceBinding, 0) + secondRoundBindings := make([]*placementv1beta1.ClusterResourceBinding, 0) + deletedBindings := make([]*placementv1beta1.ClusterResourceBinding, 0) stillScheduled := 6 // simulate that some of the bindings are applied // moved to before being set to unscheduled, otherwise, the rollout controller will try to delete the bindings before we mark them as available. @@ -467,7 +467,7 @@ var _ = Describe("Test the rollout Controller", func() { } for i := int(targetCluster - 1); i >= stillScheduled; i-- { binding := bindings[i] - binding.Spec.State = fleetv1beta1.BindingStateUnscheduled + binding.Spec.State = placementv1beta1.BindingStateUnscheduled Expect(k8sClient.Update(ctx, binding)).Should(Succeed()) By(fmt.Sprintf("resource binding `%s` is marked as not scheduled", binding.Name)) deletedBindings = append(deletedBindings, binding) @@ -483,7 +483,7 @@ var _ = Describe("Test the rollout Controller", func() { // create the newly scheduled bindings newScheduled := int(newTarget) - stillScheduled for i := 0; i < newScheduled; i++ { - binding := generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, masterSnapshot.Name, "cluster-"+strconv.Itoa(int(targetCluster)+i)) + binding := generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, masterSnapshot.Name, "cluster-"+strconv.Itoa(int(targetCluster)+i)) Expect(k8sClient.Create(ctx, binding)).Should(Succeed()) By(fmt.Sprintf("resource binding %s created", binding.Name)) bindings = append(bindings, binding) @@ -491,8 +491,8 @@ var _ = Describe("Test the rollout Controller", func() { } // mark the master snapshot as not latest masterSnapshot.SetLabels(map[string]string{ - fleetv1beta1.PlacementTrackingLabel: testCRPName, - fleetv1beta1.IsLatestSnapshotLabel: "false"}, + placementv1beta1.PlacementTrackingLabel: testCRPName, + placementv1beta1.IsLatestSnapshotLabel: "false"}, ) Expect(k8sClient.Update(ctx, masterSnapshot)).Should(Succeed()) // create a new master resource snapshot @@ -505,7 +505,7 @@ var _ = Describe("Test the rollout Controller", func() { if err != nil { return false } - if binding.Spec.State != fleetv1beta1.BindingStateBound { + if binding.Spec.State != placementv1beta1.BindingStateBound { return false } } @@ -549,8 +549,8 @@ var _ = Describe("Test the rollout Controller", func() { // create CRP var targetCluster int32 = 5 rolloutCRP = clusterResourcePlacementForTest(testCRPName, - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, targetCluster), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)) + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, targetCluster), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)) Expect(k8sClient.Create(ctx, rolloutCRP)).Should(Succeed()) // create master resource snapshot that is latest latestSnapshot := generateResourceSnapshot(rolloutCRP.Name, 1, true) @@ -560,16 +560,16 @@ var _ = Describe("Test the rollout Controller", func() { clusters := make([]string, targetCluster) for i := 0; i < int(targetCluster); i++ { clusters[i] = "cluster-" + utils.RandStr() - binding := generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, latestSnapshot.Name, clusters[i]) + binding := generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, latestSnapshot.Name, clusters[i]) bindings = append(bindings, binding) } // create two unscheduled bindings and delete them - firstDeleteBinding := generateClusterResourceBinding(fleetv1beta1.BindingStateUnscheduled, latestSnapshot.Name, clusters[0]) + firstDeleteBinding := generateClusterResourceBinding(placementv1beta1.BindingStateUnscheduled, latestSnapshot.Name, clusters[0]) firstDeleteBinding.Name = "delete-" + firstDeleteBinding.Name firstDeleteBinding.SetFinalizers([]string{customBindingFinalizer}) Expect(k8sClient.Create(ctx, firstDeleteBinding)).Should(Succeed()) Expect(k8sClient.Delete(ctx, firstDeleteBinding)).Should(Succeed()) - secondDeleteBinding := generateClusterResourceBinding(fleetv1beta1.BindingStateUnscheduled, latestSnapshot.Name, clusters[2]) + secondDeleteBinding := generateClusterResourceBinding(placementv1beta1.BindingStateUnscheduled, latestSnapshot.Name, clusters[2]) secondDeleteBinding.Name = "delete-" + secondDeleteBinding.Name secondDeleteBinding.SetFinalizers([]string{customBindingFinalizer}) Expect(k8sClient.Create(ctx, secondDeleteBinding)).Should(Succeed()) @@ -619,8 +619,8 @@ var _ = Describe("Test the rollout Controller", func() { // create CRP var targetCluster int32 = 5 rolloutCRP = clusterResourcePlacementForTest(testCRPName, - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, targetCluster), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)) + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, targetCluster), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)) Expect(k8sClient.Create(ctx, rolloutCRP)).Should(Succeed()) // create master resource snapshot that is latest masterSnapshot := generateResourceSnapshot(rolloutCRP.Name, 0, true) @@ -630,7 +630,7 @@ var _ = Describe("Test the rollout Controller", func() { clusters := make([]string, targetCluster) for i := 0; i < int(targetCluster); i++ { clusters[i] = "cluster-" + strconv.Itoa(i) - binding := generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, masterSnapshot.Name, clusters[i]) + binding := generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, masterSnapshot.Name, clusters[i]) Expect(k8sClient.Create(ctx, binding)).Should(Succeed()) By(fmt.Sprintf("resource binding %s created", binding.Name)) bindings = append(bindings, binding) @@ -649,8 +649,8 @@ var _ = Describe("Test the rollout Controller", func() { } // mark the master snapshot as not latest masterSnapshot.SetLabels(map[string]string{ - fleetv1beta1.PlacementTrackingLabel: testCRPName, - fleetv1beta1.IsLatestSnapshotLabel: "false"}, + placementv1beta1.PlacementTrackingLabel: testCRPName, + placementv1beta1.IsLatestSnapshotLabel: "false"}, ) Expect(k8sClient.Update(ctx, masterSnapshot)).Should(Succeed()) // create a new master resource snapshot @@ -678,10 +678,10 @@ var _ = Describe("Test the rollout Controller", func() { // create CRP var targetCluster int32 = 11 rolloutCRP = clusterResourcePlacementForTest(testCRPName, - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, targetCluster), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)) + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, targetCluster), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)) // remove the strategy - rolloutCRP.Spec.Strategy = fleetv1beta1.RolloutStrategy{RollingUpdate: &fleetv1beta1.RollingUpdateConfig{UnavailablePeriodSeconds: ptr.To(60)}} + rolloutCRP.Spec.Strategy = placementv1beta1.RolloutStrategy{RollingUpdate: &placementv1beta1.RollingUpdateConfig{UnavailablePeriodSeconds: ptr.To(60)}} Expect(k8sClient.Create(ctx, rolloutCRP)).Should(Succeed()) // create master resource snapshot that is latest masterSnapshot := generateResourceSnapshot(rolloutCRP.Name, 0, true) @@ -691,7 +691,7 @@ var _ = Describe("Test the rollout Controller", func() { clusters := make([]string, targetCluster) for i := 0; i < int(targetCluster); i++ { clusters[i] = "cluster-" + utils.RandStr() - binding := generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, masterSnapshot.Name, clusters[i]) + binding := generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, masterSnapshot.Name, clusters[i]) Expect(k8sClient.Create(ctx, binding)).Should(Succeed()) By(fmt.Sprintf("resource binding %s created", binding.Name)) bindings = append(bindings, binding) @@ -710,8 +710,8 @@ var _ = Describe("Test the rollout Controller", func() { } // mark the master snapshot as not latest masterSnapshot.SetLabels(map[string]string{ - fleetv1beta1.PlacementTrackingLabel: testCRPName, - fleetv1beta1.IsLatestSnapshotLabel: "false"}, + placementv1beta1.PlacementTrackingLabel: testCRPName, + placementv1beta1.IsLatestSnapshotLabel: "false"}, ) Expect(k8sClient.Update(ctx, masterSnapshot)).Should(Succeed()) // create a new master resource snapshot @@ -753,8 +753,8 @@ var _ = Describe("Test the rollout Controller", func() { // create CRP var targetCluster int32 = 2 rolloutCRP = clusterResourcePlacementForTest(testCRPName, - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, targetCluster), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)) + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, targetCluster), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)) // Set MaxSurge to 0. rolloutCRP.Spec.Strategy.RollingUpdate.MaxSurge = &intstr.IntOrString{ Type: intstr.Int, @@ -769,7 +769,7 @@ var _ = Describe("Test the rollout Controller", func() { clusters := make([]string, targetCluster) for i := 0; i < int(targetCluster); i++ { clusters[i] = "cluster-" + utils.RandStr() - binding := generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, masterSnapshot.Name, clusters[i]) + binding := generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, masterSnapshot.Name, clusters[i]) Expect(k8sClient.Create(ctx, binding)).Should(Succeed()) By(fmt.Sprintf("resource binding %s created", binding.Name)) bindings = append(bindings, binding) @@ -787,7 +787,7 @@ var _ = Describe("Test the rollout Controller", func() { // Current state: one ready binding and one canBeReadyBinding. // create a new scheduled binding. cluster3 = "cluster-" + utils.RandStr() - newScheduledBinding := generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, masterSnapshot.Name, cluster3) + newScheduledBinding := generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, masterSnapshot.Name, cluster3) Expect(k8sClient.Create(ctx, newScheduledBinding)).Should(Succeed()) By(fmt.Sprintf("resource binding %s created", newScheduledBinding.Name)) // add new scheduled binding to list of bindings. @@ -804,7 +804,7 @@ var _ = Describe("Test the rollout Controller", func() { if err != nil { return err } - if newScheduledBinding.Spec.State == fleetv1beta1.BindingStateBound { + if newScheduledBinding.Spec.State == placementv1beta1.BindingStateBound { return fmt.Errorf("binding %s is in bound state, which is unexpected", newScheduledBinding.Name) } return nil @@ -819,7 +819,7 @@ var _ = Describe("Test the rollout Controller", func() { if err != nil { return err } - bindings[i].Spec.State = fleetv1beta1.BindingStateUnscheduled + bindings[i].Spec.State = placementv1beta1.BindingStateUnscheduled return k8sClient.Update(ctx, bindings[i]) }, timeout, interval).Should(BeNil(), "failed to update binding spec to unscheduled") @@ -841,7 +841,7 @@ var _ = Describe("Test the rollout Controller", func() { if err != nil { return false } - if bindings[i].Spec.State != fleetv1beta1.BindingStateBound || bindings[i].Spec.ResourceSnapshotName != masterSnapshot.Name { + if bindings[i].Spec.State != placementv1beta1.BindingStateBound || bindings[i].Spec.ResourceSnapshotName != masterSnapshot.Name { return false } return true @@ -853,8 +853,8 @@ var _ = Describe("Test the rollout Controller", func() { // create CRP var targetCluster int32 = 2 rolloutCRP = clusterResourcePlacementForTest(testCRPName, - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, targetCluster), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)) + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, targetCluster), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)) // Set MaxSurge to 0. rolloutCRP.Spec.Strategy.RollingUpdate.MaxSurge = &intstr.IntOrString{ Type: intstr.Int, @@ -869,7 +869,7 @@ var _ = Describe("Test the rollout Controller", func() { clusters := make([]string, targetCluster) for i := 0; i < int(targetCluster); i++ { clusters[i] = "cluster-" + utils.RandStr() - binding := generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, masterSnapshot.Name, clusters[i]) + binding := generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, masterSnapshot.Name, clusters[i]) Expect(k8sClient.Create(ctx, binding)).Should(Succeed()) By(fmt.Sprintf("resource binding %s created", binding.Name)) bindings = append(bindings, binding) @@ -882,7 +882,7 @@ var _ = Describe("Test the rollout Controller", func() { // where scheduler created new scheduled binding but user changed the target number from 3->2 again, before rollout controller reads CRP. // create a new scheduled binding. cluster3 = "cluster-" + utils.RandStr() - newScheduledBinding := generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, masterSnapshot.Name, cluster3) + newScheduledBinding := generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, masterSnapshot.Name, cluster3) Expect(k8sClient.Create(ctx, newScheduledBinding)).Should(Succeed()) By(fmt.Sprintf("resource binding %s created", newScheduledBinding.Name)) // add new scheduled binding to list of bindings. @@ -900,7 +900,7 @@ var _ = Describe("Test the rollout Controller", func() { if err != nil { return err } - if newScheduledBinding.Spec.State == fleetv1beta1.BindingStateBound { + if newScheduledBinding.Spec.State == placementv1beta1.BindingStateBound { return fmt.Errorf("binding %s is in bound state, which is unexpected", newScheduledBinding.Name) } return nil @@ -919,7 +919,7 @@ var _ = Describe("Test the rollout Controller", func() { if err != nil { return false } - if bindings[i].Spec.State != fleetv1beta1.BindingStateBound || bindings[i].Spec.ResourceSnapshotName != masterSnapshot.Name { + if bindings[i].Spec.State != placementv1beta1.BindingStateBound || bindings[i].Spec.ResourceSnapshotName != masterSnapshot.Name { return false } return true @@ -931,8 +931,8 @@ var _ = Describe("Test the rollout Controller", func() { By("Creating CRP with External strategy") var targetCluster int32 = 10 rolloutCRP = clusterResourcePlacementForTest(testCRPName, - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, targetCluster), - createPlacementRolloutStrategyForTest(fleetv1beta1.ExternalRolloutStrategyType, nil, nil)) + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, targetCluster), + createPlacementRolloutStrategyForTest(placementv1beta1.ExternalRolloutStrategyType, nil, nil)) Expect(k8sClient.Create(ctx, rolloutCRP)).Should(Succeed()) By("Creating the latest master resource snapshot") @@ -944,7 +944,7 @@ var _ = Describe("Test the rollout Controller", func() { clusters := make([]string, targetCluster) for i := 0; i < int(targetCluster); i++ { clusters[i] = "cluster-" + utils.RandStr() - binding := generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, masterSnapshot.Name, clusters[i]) + binding := generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, masterSnapshot.Name, clusters[i]) Expect(k8sClient.Create(ctx, binding)).Should(Succeed()) By(fmt.Sprintf("resource binding %s created", binding.Name)) bindings = append(bindings, binding) @@ -954,7 +954,7 @@ var _ = Describe("Test the rollout Controller", func() { verifyBindingsNotRolledOutConsistently(bindings) By("Updating CRP rollout strategy type to RollingUpdate") - rolloutCRP.Spec.Strategy.Type = fleetv1beta1.RollingUpdateRolloutStrategyType + rolloutCRP.Spec.Strategy.Type = placementv1beta1.RollingUpdateRolloutStrategyType rolloutCRP.Spec.Strategy.RollingUpdate = generateDefaultRollingUpdateConfig() Expect(k8sClient.Update(ctx, rolloutCRP)).Should(Succeed(), "Failed to update CRP") @@ -966,8 +966,8 @@ var _ = Describe("Test the rollout Controller", func() { By("Creating CRP with External strategy") var targetCluster int32 = 10 rolloutCRP = clusterResourcePlacementForTest(testCRPName, - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, targetCluster), - createPlacementRolloutStrategyForTest(fleetv1beta1.ExternalRolloutStrategyType, nil, nil)) + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, targetCluster), + createPlacementRolloutStrategyForTest(placementv1beta1.ExternalRolloutStrategyType, nil, nil)) Expect(k8sClient.Create(ctx, rolloutCRP)).Should(Succeed()) By("Creating the latest master resource snapshot") @@ -979,7 +979,7 @@ var _ = Describe("Test the rollout Controller", func() { clusters := make([]string, targetCluster) for i := 0; i < int(targetCluster); i++ { clusters[i] = "cluster-" + utils.RandStr() - binding := generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, masterSnapshot.Name, clusters[i]) + binding := generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, masterSnapshot.Name, clusters[i]) Expect(k8sClient.Create(ctx, binding)).Should(Succeed()) By(fmt.Sprintf("resource binding %s created", binding.Name)) bindings = append(bindings, binding) @@ -1001,8 +1001,8 @@ var _ = Describe("Test the rollout Controller", func() { By("Creating CRP with RollingUpdate strategy") var targetCluster int32 = 10 rolloutCRP = clusterResourcePlacementForTest(testCRPName, - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, targetCluster), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)) + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, targetCluster), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)) Expect(k8sClient.Create(ctx, rolloutCRP)).Should(Succeed()) By("Creating the latest master resource snapshot") @@ -1014,7 +1014,7 @@ var _ = Describe("Test the rollout Controller", func() { clusters := make([]string, targetCluster) for i := 0; i < int(targetCluster); i++ { clusters[i] = "cluster-" + strconv.Itoa(i) - binding := generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, masterSnapshot.Name, clusters[i]) + binding := generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, masterSnapshot.Name, clusters[i]) Expect(k8sClient.Create(ctx, binding)).Should(Succeed()) By(fmt.Sprintf("resource binding %s created", binding.Name)) bindings = append(bindings, binding) @@ -1024,15 +1024,15 @@ var _ = Describe("Test the rollout Controller", func() { verifyBindingsRolledOut(bindings, masterSnapshot, timeout) By("Updating CRP rollout strategy type to External") - rolloutCRP.Spec.Strategy.Type = fleetv1beta1.ExternalRolloutStrategyType + rolloutCRP.Spec.Strategy.Type = placementv1beta1.ExternalRolloutStrategyType rolloutCRP.Spec.Strategy.RollingUpdate = nil Expect(k8sClient.Update(ctx, rolloutCRP)).Should(Succeed(), "Failed to update CRP") By("Creating a new master resource snapshot") // Mark the master snapshot as not latest. masterSnapshot.SetLabels(map[string]string{ - fleetv1beta1.PlacementTrackingLabel: testCRPName, - fleetv1beta1.IsLatestSnapshotLabel: "false"}, + placementv1beta1.PlacementTrackingLabel: testCRPName, + placementv1beta1.IsLatestSnapshotLabel: "false"}, ) Expect(k8sClient.Update(ctx, masterSnapshot)).Should(Succeed()) // Create a new master resource snapshot. @@ -1061,7 +1061,7 @@ var _ = Describe("Test the rollout Controller", func() { }) -func verifyBindingsNotRolledOutConsistently(bindings []*fleetv1beta1.ClusterResourceBinding) { +func verifyBindingsNotRolledOutConsistently(bindings []*placementv1beta1.ClusterResourceBinding) { // Wait until the client informer is populated. Eventually(func() error { for _, binding := range bindings { @@ -1079,7 +1079,7 @@ func verifyBindingsNotRolledOutConsistently(bindings []*fleetv1beta1.ClusterReso if err != nil { return fmt.Errorf("failed to get binding %s: %w", binding.GetName(), err) } - if binding.Spec.State == fleetv1beta1.BindingStateBound { + if binding.Spec.State == placementv1beta1.BindingStateBound { return fmt.Errorf("binding %s is in bound state, which is unwanted", binding.GetName()) } } @@ -1087,7 +1087,7 @@ func verifyBindingsNotRolledOutConsistently(bindings []*fleetv1beta1.ClusterReso }, consistentTimeout, consistentInterval).Should(Succeed(), "rollout controller should not roll any binding to Bound state") } -func verifyBindingsRolledOut(bindings []*fleetv1beta1.ClusterResourceBinding, masterSnapshot *fleetv1beta1.ClusterResourceSnapshot, timeout time.Duration) { +func verifyBindingsRolledOut(bindings []*placementv1beta1.ClusterResourceBinding, masterSnapshot *placementv1beta1.ClusterResourceSnapshot, timeout time.Duration) { // Check that all bindings are bound and updated to the latest snapshot. Eventually(func() error { for _, binding := range bindings { @@ -1095,7 +1095,7 @@ func verifyBindingsRolledOut(bindings []*fleetv1beta1.ClusterResourceBinding, ma if err != nil { return fmt.Errorf("failed to get binding %s: %w", binding.GetName(), err) } - if binding.Spec.State != fleetv1beta1.BindingStateBound { + if binding.Spec.State != placementv1beta1.BindingStateBound { return fmt.Errorf("binding %s is not updated to Bound state, got: %s", binding.GetName(), binding.Spec.State) } if binding.Spec.ResourceSnapshotName != masterSnapshot.Name { @@ -1106,14 +1106,14 @@ func verifyBindingsRolledOut(bindings []*fleetv1beta1.ClusterResourceBinding, ma }, timeout, interval).Should(Succeed(), "rollout controller should roll out all the bindings") } -func markBindingAvailable(binding *fleetv1beta1.ClusterResourceBinding, trackable bool) { +func markBindingAvailable(binding *placementv1beta1.ClusterResourceBinding, trackable bool) { Eventually(func() error { reason := "trackable" if !trackable { reason = condition.WorkNotAllManifestsTrackableReason } binding.SetConditions(metav1.Condition{ - Type: string(fleetv1beta1.ResourceBindingAvailable), + Type: string(placementv1beta1.ResourceBindingAvailable), Status: metav1.ConditionTrue, Reason: reason, ObservedGeneration: binding.Generation, @@ -1130,9 +1130,9 @@ func markBindingAvailable(binding *fleetv1beta1.ClusterResourceBinding, trackabl By(fmt.Sprintf("resource binding `%s` is marked as available", binding.Name)) } -func markBindingApplied(binding *fleetv1beta1.ClusterResourceBinding, success bool) { +func markBindingApplied(binding *placementv1beta1.ClusterResourceBinding, success bool) { applyCondition := metav1.Condition{ - Type: string(fleetv1beta1.ResourceBindingApplied), + Type: string(placementv1beta1.ResourceBindingApplied), } if success { applyCondition.Status = metav1.ConditionTrue @@ -1156,35 +1156,35 @@ func markBindingApplied(binding *fleetv1beta1.ClusterResourceBinding, success bo By(fmt.Sprintf("resource binding `%s` is marked as applied with status %t", binding.Name, success)) } -func generateClusterResourceBinding(state fleetv1beta1.BindingState, resourceSnapshotName, targetCluster string) *fleetv1beta1.ClusterResourceBinding { - binding := &fleetv1beta1.ClusterResourceBinding{ +func generateClusterResourceBinding(state placementv1beta1.BindingState, resourceSnapshotName, targetCluster string) *placementv1beta1.ClusterResourceBinding { + binding := &placementv1beta1.ClusterResourceBinding{ ObjectMeta: metav1.ObjectMeta{ Name: "binding-" + resourceSnapshotName + "-" + targetCluster, Labels: map[string]string{ - fleetv1beta1.PlacementTrackingLabel: testCRPName, + placementv1beta1.PlacementTrackingLabel: testCRPName, }, }, - Spec: fleetv1beta1.ResourceBindingSpec{ + Spec: placementv1beta1.ResourceBindingSpec{ State: state, TargetCluster: targetCluster, }, } - if binding.Spec.State == fleetv1beta1.BindingStateBound { + if binding.Spec.State == placementv1beta1.BindingStateBound { binding.Spec.ResourceSnapshotName = resourceSnapshotName } return binding } -func generateResourceSnapshot(testCRPName string, resourceIndex int, isLatest bool) *fleetv1beta1.ClusterResourceSnapshot { - clusterResourceSnapshot := &fleetv1beta1.ClusterResourceSnapshot{ +func generateResourceSnapshot(testCRPName string, resourceIndex int, isLatest bool) *placementv1beta1.ClusterResourceSnapshot { + clusterResourceSnapshot := &placementv1beta1.ClusterResourceSnapshot{ ObjectMeta: metav1.ObjectMeta{ - Name: fmt.Sprintf(fleetv1beta1.ResourceSnapshotNameFmt, testCRPName, resourceIndex), + Name: fmt.Sprintf(placementv1beta1.ResourceSnapshotNameFmt, testCRPName, resourceIndex), Labels: map[string]string{ - fleetv1beta1.PlacementTrackingLabel: testCRPName, - fleetv1beta1.IsLatestSnapshotLabel: strconv.FormatBool(isLatest), + placementv1beta1.PlacementTrackingLabel: testCRPName, + placementv1beta1.IsLatestSnapshotLabel: strconv.FormatBool(isLatest), }, Annotations: map[string]string{ - fleetv1beta1.ResourceGroupHashAnnotation: "hash", + placementv1beta1.ResourceGroupHashAnnotation: "hash", }, }, } @@ -1193,7 +1193,7 @@ func generateResourceSnapshot(testCRPName string, resourceIndex int, isLatest bo } for _, rawContent := range rawContents { clusterResourceSnapshot.Spec.SelectedResources = append(clusterResourceSnapshot.Spec.SelectedResources, - fleetv1beta1.ResourceContent{ + placementv1beta1.ResourceContent{ RawExtension: runtime.RawExtension{Raw: rawContent}, }, ) diff --git a/pkg/controllers/rollout/controller_test.go b/pkg/controllers/rollout/controller_test.go index efd02dd0b..bb7d27db4 100644 --- a/pkg/controllers/rollout/controller_test.go +++ b/pkg/controllers/rollout/controller_test.go @@ -36,8 +36,7 @@ import ( "sigs.k8s.io/controller-runtime/pkg/reconcile" clusterv1beta1 "go.goms.io/fleet/apis/cluster/v1beta1" - fleetv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" - fleetv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" + placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" "go.goms.io/fleet/pkg/utils/condition" "go.goms.io/fleet/pkg/utils/controller" ) @@ -57,9 +56,9 @@ var ( cmpOptions = []cmp.Option{ cmp.AllowUnexported(toBeUpdatedBinding{}), cmpopts.EquateEmpty(), - cmpopts.IgnoreFields(fleetv1beta1.ClusterResourceBinding{}, "TypeMeta"), + cmpopts.IgnoreFields(placementv1beta1.ClusterResourceBinding{}, "TypeMeta"), cmpopts.IgnoreFields(metav1.ObjectMeta{}, "ResourceVersion"), - cmpopts.SortSlices(func(b1, b2 fleetv1beta1.ClusterResourceBinding) bool { + cmpopts.SortSlices(func(b1, b2 placementv1beta1.ClusterResourceBinding) bool { return b1.Name < b2.Name }), cmpopts.IgnoreFields(metav1.Condition{}, "Message"), @@ -83,15 +82,12 @@ var ( func serviceScheme(t *testing.T) *runtime.Scheme { scheme := runtime.NewScheme() - if err := fleetv1beta1.AddToScheme(scheme); err != nil { + if err := placementv1beta1.AddToScheme(scheme); err != nil { t.Fatalf("Failed to add placement v1beta1 scheme: %v", err) } if err := clusterv1beta1.AddToScheme(scheme); err != nil { t.Fatalf("Failed to add cluster v1beta1 scheme: %v", err) } - if err := fleetv1alpha1.AddToScheme(scheme); err != nil { - t.Fatalf("Failed to add placement v1alpha1 scheme: %v", err) - } return scheme } @@ -101,61 +97,61 @@ func TestReconcilerHandleResourceSnapshot(t *testing.T) { shouldEnqueue bool }{ "test enqueue a new master active resourceSnapshot": { - snapshot: &fleetv1beta1.ClusterResourceSnapshot{ + snapshot: &placementv1beta1.ClusterResourceSnapshot{ ObjectMeta: metav1.ObjectMeta{ Labels: map[string]string{ - fleetv1beta1.PlacementTrackingLabel: "placement", - fleetv1beta1.IsLatestSnapshotLabel: "true", + placementv1beta1.PlacementTrackingLabel: "placement", + placementv1beta1.IsLatestSnapshotLabel: "true", }, Annotations: map[string]string{ - fleetv1beta1.ResourceGroupHashAnnotation: "hash", + placementv1beta1.ResourceGroupHashAnnotation: "hash", }, }, }, shouldEnqueue: true, }, "test skip a none master active resourceSnapshot": { - snapshot: &fleetv1beta1.ClusterResourceSnapshot{ + snapshot: &placementv1beta1.ClusterResourceSnapshot{ ObjectMeta: metav1.ObjectMeta{ Labels: map[string]string{ - fleetv1beta1.PlacementTrackingLabel: "placement", - fleetv1beta1.IsLatestSnapshotLabel: "true", + placementv1beta1.PlacementTrackingLabel: "placement", + placementv1beta1.IsLatestSnapshotLabel: "true", }, }, }, shouldEnqueue: false, }, "test skip a none active master resourceSnapshot": { - snapshot: &fleetv1beta1.ClusterResourceSnapshot{ + snapshot: &placementv1beta1.ClusterResourceSnapshot{ ObjectMeta: metav1.ObjectMeta{ Labels: map[string]string{ - fleetv1beta1.PlacementTrackingLabel: "placement", + placementv1beta1.PlacementTrackingLabel: "placement", }, Annotations: map[string]string{ - fleetv1beta1.ResourceGroupHashAnnotation: "1", + placementv1beta1.ResourceGroupHashAnnotation: "1", }, }, }, shouldEnqueue: false, }, "test skip a none active none master resourceSnapshot": { - snapshot: &fleetv1beta1.ClusterResourceSnapshot{ + snapshot: &placementv1beta1.ClusterResourceSnapshot{ ObjectMeta: metav1.ObjectMeta{ Labels: map[string]string{ - fleetv1beta1.PlacementTrackingLabel: "placement", + placementv1beta1.PlacementTrackingLabel: "placement", }, }, }, shouldEnqueue: false, }, "test skip a malformatted active master resourceSnapshot": { - snapshot: &fleetv1beta1.ClusterResourceSnapshot{ + snapshot: &placementv1beta1.ClusterResourceSnapshot{ ObjectMeta: metav1.ObjectMeta{ Labels: map[string]string{ - fleetv1beta1.IsLatestSnapshotLabel: "true", + placementv1beta1.IsLatestSnapshotLabel: "true", }, Annotations: map[string]string{ - fleetv1beta1.ResourceGroupHashAnnotation: "1", + placementv1beta1.ResourceGroupHashAnnotation: "1", }, }, }, @@ -182,17 +178,17 @@ func TestReconcilerHandleResourceBinding(t *testing.T) { shouldEnqueue bool }{ "test enqueue a good resourceBinding": { - resourceBinding: &fleetv1beta1.ClusterResourceBinding{ + resourceBinding: &placementv1beta1.ClusterResourceBinding{ ObjectMeta: metav1.ObjectMeta{ Labels: map[string]string{ - fleetv1beta1.PlacementTrackingLabel: "placement", + placementv1beta1.PlacementTrackingLabel: "placement", }, }, }, shouldEnqueue: true, }, "test skip a malformatted resourceBinding": { - resourceBinding: &fleetv1beta1.ClusterResourceSnapshot{ + resourceBinding: &placementv1beta1.ClusterResourceSnapshot{ ObjectMeta: metav1.ObjectMeta{}, }, shouldEnqueue: false, @@ -214,54 +210,54 @@ func TestReconcilerHandleResourceBinding(t *testing.T) { func TestWaitForResourcesToCleanUp(t *testing.T) { tests := map[string]struct { - allBindings []*fleetv1beta1.ClusterResourceBinding + allBindings []*placementv1beta1.ClusterResourceBinding wantWait bool wantErr bool }{ "test deleting binding block schedule binding on the same cluster": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, "snapshot-1", cluster1), - setDeletionTimeStampForBinding(generateClusterResourceBinding(fleetv1beta1.BindingStateUnscheduled, "snapshot-1", cluster1)), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, "snapshot-1", cluster1), + setDeletionTimeStampForBinding(generateClusterResourceBinding(placementv1beta1.BindingStateUnscheduled, "snapshot-1", cluster1)), }, wantWait: true, wantErr: false, }, "test deleting binding not block binding on different cluster": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, "snapshot-1", cluster1), - setDeletionTimeStampForBinding(generateClusterResourceBinding(fleetv1beta1.BindingStateUnscheduled, "snapshot-1", cluster2)), - generateClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster3), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, "snapshot-1", cluster1), + setDeletionTimeStampForBinding(generateClusterResourceBinding(placementv1beta1.BindingStateUnscheduled, "snapshot-1", cluster2)), + generateClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster3), }, wantWait: false, wantErr: false, }, "test deleting binding cannot co-exsit with a bound binding on same cluster": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - setDeletionTimeStampForBinding(generateClusterResourceBinding(fleetv1beta1.BindingStateUnscheduled, "snapshot-1", cluster1)), - generateClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster1), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + setDeletionTimeStampForBinding(generateClusterResourceBinding(placementv1beta1.BindingStateUnscheduled, "snapshot-1", cluster1)), + generateClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster1), }, wantWait: false, wantErr: true, }, "test no two non-deleting binding can co-exsit on same cluster, case one": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, "snapshot-2", cluster1), - generateClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster1), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, "snapshot-2", cluster1), + generateClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster1), }, wantWait: false, wantErr: true, }, "test no two non-deleting binding can co-exsit on same cluster, case two": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, "snapshot-2", cluster1), - generateClusterResourceBinding(fleetv1beta1.BindingStateUnscheduled, "snapshot-1", cluster1), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, "snapshot-2", cluster1), + generateClusterResourceBinding(placementv1beta1.BindingStateUnscheduled, "snapshot-1", cluster1), }, wantWait: false, wantErr: true, }, } for name, tt := range tests { - crp := &fleetv1beta1.ClusterResourcePlacement{} + crp := &placementv1beta1.ClusterResourcePlacement{} t.Run(name, func(t *testing.T) { gotWait, err := waitForResourcesToCleanUp(controller.ConvertCRBArrayToBindingObjs(tt.allBindings), crp) if (err != nil) != tt.wantErr { @@ -285,9 +281,9 @@ func TestUpdateBindings(t *testing.T) { tests := map[string]struct { skipPuttingBindings bool // whether skip to put the bindings into the api server // build toBeUpdatedBinding with currentBinding and desiredBinding - bindings []fleetv1beta1.ClusterResourceBinding - desiredBindingsSpec []fleetv1beta1.ResourceBindingSpec - wantBindings []fleetv1beta1.ClusterResourceBinding + bindings []placementv1beta1.ClusterResourceBinding + desiredBindingsSpec []placementv1beta1.ResourceBindingSpec + wantBindings []placementv1beta1.ClusterResourceBinding wantErr error }{ "update bindings with nil": { @@ -295,49 +291,49 @@ func TestUpdateBindings(t *testing.T) { wantBindings: nil, }, "update bindings with empty": { - bindings: []fleetv1beta1.ClusterResourceBinding{}, + bindings: []placementv1beta1.ClusterResourceBinding{}, wantBindings: nil, }, "update a bounded binding with latest resources": { - bindings: []fleetv1beta1.ClusterResourceBinding{ + bindings: []placementv1beta1.ClusterResourceBinding{ { ObjectMeta: metav1.ObjectMeta{ Name: "binding-1", Generation: 15, }, - Spec: fleetv1beta1.ResourceBindingSpec{ - State: fleetv1beta1.BindingStateBound, + Spec: placementv1beta1.ResourceBindingSpec{ + State: placementv1beta1.BindingStateBound, TargetCluster: cluster1, ResourceSnapshotName: "snapshot-1", }, }, }, - desiredBindingsSpec: []fleetv1beta1.ResourceBindingSpec{ + desiredBindingsSpec: []placementv1beta1.ResourceBindingSpec{ { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster1, ResourceSnapshotName: "snapshot-2", ClusterResourceOverrideSnapshots: []string{"cro-1", "cro-2"}, - ResourceOverrideSnapshots: []fleetv1beta1.NamespacedName{{Name: "ro-1", Namespace: "ns-1"}}, + ResourceOverrideSnapshots: []placementv1beta1.NamespacedName{{Name: "ro-1", Namespace: "ns-1"}}, }, }, - wantBindings: []fleetv1beta1.ClusterResourceBinding{ + wantBindings: []placementv1beta1.ClusterResourceBinding{ { ObjectMeta: metav1.ObjectMeta{ Name: "binding-1", Generation: 15, }, - Spec: fleetv1beta1.ResourceBindingSpec{ - State: fleetv1beta1.BindingStateBound, + Spec: placementv1beta1.ResourceBindingSpec{ + State: placementv1beta1.BindingStateBound, TargetCluster: cluster1, ResourceSnapshotName: "snapshot-2", ClusterResourceOverrideSnapshots: []string{"cro-1", "cro-2"}, - ResourceOverrideSnapshots: []fleetv1beta1.NamespacedName{{Name: "ro-1", Namespace: "ns-1"}}, + ResourceOverrideSnapshots: []placementv1beta1.NamespacedName{{Name: "ro-1", Namespace: "ns-1"}}, }, - Status: fleetv1beta1.ResourceBindingStatus{ + Status: placementv1beta1.ResourceBindingStatus{ Conditions: []metav1.Condition{ { - Type: string(fleetv1beta1.ResourceBindingRolloutStarted), + Type: string(placementv1beta1.ResourceBindingRolloutStarted), Status: metav1.ConditionTrue, ObservedGeneration: 15, LastTransitionTime: metav1.NewTime(currentTime), @@ -349,21 +345,21 @@ func TestUpdateBindings(t *testing.T) { }, }, "update a bounded binding (having status) with latest resources": { - bindings: []fleetv1beta1.ClusterResourceBinding{ + bindings: []placementv1beta1.ClusterResourceBinding{ { ObjectMeta: metav1.ObjectMeta{ Name: "binding-1", Generation: 15, }, - Spec: fleetv1beta1.ResourceBindingSpec{ - State: fleetv1beta1.BindingStateBound, + Spec: placementv1beta1.ResourceBindingSpec{ + State: placementv1beta1.BindingStateBound, TargetCluster: cluster1, ResourceSnapshotName: "snapshot-1", }, - Status: fleetv1beta1.ResourceBindingStatus{ + Status: placementv1beta1.ResourceBindingStatus{ Conditions: []metav1.Condition{ { - Type: string(fleetv1beta1.ResourceBindingRolloutStarted), + Type: string(placementv1beta1.ResourceBindingRolloutStarted), Status: metav1.ConditionTrue, ObservedGeneration: 15, Reason: condition.RolloutStartedReason, @@ -373,32 +369,32 @@ func TestUpdateBindings(t *testing.T) { }, }, }, - desiredBindingsSpec: []fleetv1beta1.ResourceBindingSpec{ + desiredBindingsSpec: []placementv1beta1.ResourceBindingSpec{ { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster1, ResourceSnapshotName: "snapshot-2", ClusterResourceOverrideSnapshots: []string{"cro-1", "cro-2"}, - ResourceOverrideSnapshots: []fleetv1beta1.NamespacedName{{Name: "ro-1", Namespace: "ns-1"}}, + ResourceOverrideSnapshots: []placementv1beta1.NamespacedName{{Name: "ro-1", Namespace: "ns-1"}}, }, }, - wantBindings: []fleetv1beta1.ClusterResourceBinding{ + wantBindings: []placementv1beta1.ClusterResourceBinding{ { ObjectMeta: metav1.ObjectMeta{ Name: "binding-1", Generation: 15, // note, the fake client doesn't update the generation }, - Spec: fleetv1beta1.ResourceBindingSpec{ - State: fleetv1beta1.BindingStateBound, + Spec: placementv1beta1.ResourceBindingSpec{ + State: placementv1beta1.BindingStateBound, TargetCluster: cluster1, ResourceSnapshotName: "snapshot-2", ClusterResourceOverrideSnapshots: []string{"cro-1", "cro-2"}, - ResourceOverrideSnapshots: []fleetv1beta1.NamespacedName{{Name: "ro-1", Namespace: "ns-1"}}, + ResourceOverrideSnapshots: []placementv1beta1.NamespacedName{{Name: "ro-1", Namespace: "ns-1"}}, }, - Status: fleetv1beta1.ResourceBindingStatus{ + Status: placementv1beta1.ResourceBindingStatus{ Conditions: []metav1.Condition{ { - Type: string(fleetv1beta1.ResourceBindingRolloutStarted), + Type: string(placementv1beta1.ResourceBindingRolloutStarted), Status: metav1.ConditionTrue, ObservedGeneration: 15, LastTransitionTime: oldTransitionTime, @@ -410,20 +406,20 @@ func TestUpdateBindings(t *testing.T) { }, }, "update a scheduled binding with latest resources": { - bindings: []fleetv1beta1.ClusterResourceBinding{ + bindings: []placementv1beta1.ClusterResourceBinding{ { ObjectMeta: metav1.ObjectMeta{ Name: "binding-1", Generation: 15, }, - Spec: fleetv1beta1.ResourceBindingSpec{ - State: fleetv1beta1.BindingStateScheduled, + Spec: placementv1beta1.ResourceBindingSpec{ + State: placementv1beta1.BindingStateScheduled, TargetCluster: cluster1, }, - Status: fleetv1beta1.ResourceBindingStatus{ + Status: placementv1beta1.ResourceBindingStatus{ Conditions: []metav1.Condition{ { - Type: string(fleetv1beta1.ResourceBindingRolloutStarted), + Type: string(placementv1beta1.ResourceBindingRolloutStarted), Status: metav1.ConditionFalse, ObservedGeneration: 15, Reason: condition.RolloutNotStartedYetReason, @@ -433,32 +429,32 @@ func TestUpdateBindings(t *testing.T) { }, }, }, - desiredBindingsSpec: []fleetv1beta1.ResourceBindingSpec{ + desiredBindingsSpec: []placementv1beta1.ResourceBindingSpec{ { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster1, ResourceSnapshotName: "snapshot-2", ClusterResourceOverrideSnapshots: []string{"cro-1", "cro-2"}, - ResourceOverrideSnapshots: []fleetv1beta1.NamespacedName{{Name: "ro-1", Namespace: "ns-1"}}, + ResourceOverrideSnapshots: []placementv1beta1.NamespacedName{{Name: "ro-1", Namespace: "ns-1"}}, }, }, - wantBindings: []fleetv1beta1.ClusterResourceBinding{ + wantBindings: []placementv1beta1.ClusterResourceBinding{ { ObjectMeta: metav1.ObjectMeta{ Name: "binding-1", Generation: 15, }, - Spec: fleetv1beta1.ResourceBindingSpec{ - State: fleetv1beta1.BindingStateBound, + Spec: placementv1beta1.ResourceBindingSpec{ + State: placementv1beta1.BindingStateBound, TargetCluster: cluster1, ResourceSnapshotName: "snapshot-2", ClusterResourceOverrideSnapshots: []string{"cro-1", "cro-2"}, - ResourceOverrideSnapshots: []fleetv1beta1.NamespacedName{{Name: "ro-1", Namespace: "ns-1"}}, + ResourceOverrideSnapshots: []placementv1beta1.NamespacedName{{Name: "ro-1", Namespace: "ns-1"}}, }, - Status: fleetv1beta1.ResourceBindingStatus{ + Status: placementv1beta1.ResourceBindingStatus{ Conditions: []metav1.Condition{ { - Type: string(fleetv1beta1.ResourceBindingRolloutStarted), + Type: string(placementv1beta1.ResourceBindingRolloutStarted), Status: metav1.ConditionTrue, ObservedGeneration: 15, Reason: condition.RolloutStartedReason, @@ -470,47 +466,47 @@ func TestUpdateBindings(t *testing.T) { }, }, "delete an unscheduled binding": { - bindings: []fleetv1beta1.ClusterResourceBinding{ + bindings: []placementv1beta1.ClusterResourceBinding{ { ObjectMeta: metav1.ObjectMeta{ Name: "binding-1", Generation: 15, }, - Spec: fleetv1beta1.ResourceBindingSpec{ - State: fleetv1beta1.BindingStateUnscheduled, + Spec: placementv1beta1.ResourceBindingSpec{ + State: placementv1beta1.BindingStateUnscheduled, TargetCluster: cluster1, ResourceSnapshotName: "snapshot-1", }, }, }, - wantBindings: []fleetv1beta1.ClusterResourceBinding{}, + wantBindings: []placementv1beta1.ClusterResourceBinding{}, }, "delete an not found unscheduled binding": { skipPuttingBindings: true, - bindings: []fleetv1beta1.ClusterResourceBinding{ + bindings: []placementv1beta1.ClusterResourceBinding{ { ObjectMeta: metav1.ObjectMeta{ Name: "binding-1", Generation: 15, }, - Spec: fleetv1beta1.ResourceBindingSpec{ - State: fleetv1beta1.BindingStateUnscheduled, + Spec: placementv1beta1.ResourceBindingSpec{ + State: placementv1beta1.BindingStateUnscheduled, TargetCluster: cluster1, ResourceSnapshotName: "snapshot-1", }, }, }, - wantBindings: []fleetv1beta1.ClusterResourceBinding{}, + wantBindings: []placementv1beta1.ClusterResourceBinding{}, }, "update multiple bindings": { - bindings: []fleetv1beta1.ClusterResourceBinding{ + bindings: []placementv1beta1.ClusterResourceBinding{ { ObjectMeta: metav1.ObjectMeta{ Name: "binding-1", Generation: 15, }, - Spec: fleetv1beta1.ResourceBindingSpec{ - State: fleetv1beta1.BindingStateScheduled, + Spec: placementv1beta1.ResourceBindingSpec{ + State: placementv1beta1.BindingStateScheduled, TargetCluster: cluster1, }, }, @@ -519,44 +515,44 @@ func TestUpdateBindings(t *testing.T) { Name: "binding-2", Generation: 1, }, - Spec: fleetv1beta1.ResourceBindingSpec{ - State: fleetv1beta1.BindingStateBound, + Spec: placementv1beta1.ResourceBindingSpec{ + State: placementv1beta1.BindingStateBound, TargetCluster: cluster2, ResourceSnapshotName: "snapshot-2", }, }, }, - desiredBindingsSpec: []fleetv1beta1.ResourceBindingSpec{ + desiredBindingsSpec: []placementv1beta1.ResourceBindingSpec{ { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster1, ResourceSnapshotName: "snapshot-1", ClusterResourceOverrideSnapshots: []string{"cro-1", "cro-2"}, - ResourceOverrideSnapshots: []fleetv1beta1.NamespacedName{{Name: "ro-1", Namespace: "ns-1"}}, + ResourceOverrideSnapshots: []placementv1beta1.NamespacedName{{Name: "ro-1", Namespace: "ns-1"}}, }, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster2, ResourceSnapshotName: "snapshot-3", }, }, - wantBindings: []fleetv1beta1.ClusterResourceBinding{ + wantBindings: []placementv1beta1.ClusterResourceBinding{ { ObjectMeta: metav1.ObjectMeta{ Name: "binding-1", Generation: 15, }, - Spec: fleetv1beta1.ResourceBindingSpec{ - State: fleetv1beta1.BindingStateBound, + Spec: placementv1beta1.ResourceBindingSpec{ + State: placementv1beta1.BindingStateBound, TargetCluster: cluster1, ResourceSnapshotName: "snapshot-1", ClusterResourceOverrideSnapshots: []string{"cro-1", "cro-2"}, - ResourceOverrideSnapshots: []fleetv1beta1.NamespacedName{{Name: "ro-1", Namespace: "ns-1"}}, + ResourceOverrideSnapshots: []placementv1beta1.NamespacedName{{Name: "ro-1", Namespace: "ns-1"}}, }, - Status: fleetv1beta1.ResourceBindingStatus{ + Status: placementv1beta1.ResourceBindingStatus{ Conditions: []metav1.Condition{ { - Type: string(fleetv1beta1.ResourceBindingRolloutStarted), + Type: string(placementv1beta1.ResourceBindingRolloutStarted), Status: metav1.ConditionTrue, ObservedGeneration: 15, LastTransitionTime: metav1.NewTime(currentTime), @@ -570,15 +566,15 @@ func TestUpdateBindings(t *testing.T) { Name: "binding-2", Generation: 1, }, - Spec: fleetv1beta1.ResourceBindingSpec{ - State: fleetv1beta1.BindingStateBound, + Spec: placementv1beta1.ResourceBindingSpec{ + State: placementv1beta1.BindingStateBound, TargetCluster: cluster2, ResourceSnapshotName: "snapshot-3", }, - Status: fleetv1beta1.ResourceBindingStatus{ + Status: placementv1beta1.ResourceBindingStatus{ Conditions: []metav1.Condition{ { - Type: string(fleetv1beta1.ResourceBindingRolloutStarted), + Type: string(placementv1beta1.ResourceBindingRolloutStarted), Status: metav1.ConditionTrue, ObservedGeneration: 1, LastTransitionTime: metav1.NewTime(currentTime), @@ -627,7 +623,7 @@ func TestUpdateBindings(t *testing.T) { if err != nil { return } - bindingList := &fleetv1beta1.ClusterResourceBindingList{} + bindingList := &placementv1beta1.ClusterResourceBindingList{} if err := fakeClient.List(ctx, bindingList); err != nil { t.Fatalf("ClusterResourceBinding List() got error %v, want no err", err) } @@ -640,20 +636,20 @@ func TestUpdateBindings(t *testing.T) { func TestIsBindingReady(t *testing.T) { tests := map[string]struct { - binding *fleetv1beta1.ClusterResourceBinding + binding *placementv1beta1.ClusterResourceBinding readyTimeCutOff time.Time wantReady bool wantWaitTime time.Duration }{ "binding available (trackable) is ready": { - binding: &fleetv1beta1.ClusterResourceBinding{ + binding: &placementv1beta1.ClusterResourceBinding{ ObjectMeta: metav1.ObjectMeta{ Generation: 10, }, - Status: fleetv1beta1.ResourceBindingStatus{ + Status: placementv1beta1.ResourceBindingStatus{ Conditions: []metav1.Condition{ { - Type: string(fleetv1beta1.ResourceBindingAvailable), + Type: string(placementv1beta1.ResourceBindingAvailable), Status: metav1.ConditionTrue, ObservedGeneration: 10, Reason: "any", @@ -666,14 +662,14 @@ func TestIsBindingReady(t *testing.T) { wantWaitTime: 0, }, "binding available (not trackable) before the ready time cut off should return ready": { - binding: &fleetv1beta1.ClusterResourceBinding{ + binding: &placementv1beta1.ClusterResourceBinding{ ObjectMeta: metav1.ObjectMeta{ Generation: 10, }, - Status: fleetv1beta1.ResourceBindingStatus{ + Status: placementv1beta1.ResourceBindingStatus{ Conditions: []metav1.Condition{ { - Type: string(fleetv1beta1.ResourceBindingAvailable), + Type: string(placementv1beta1.ResourceBindingAvailable), Status: metav1.ConditionTrue, ObservedGeneration: 10, LastTransitionTime: metav1.Time{ @@ -689,14 +685,14 @@ func TestIsBindingReady(t *testing.T) { wantWaitTime: 0, }, "binding available (not trackable) after the ready time cut off should return not ready with a wait time": { - binding: &fleetv1beta1.ClusterResourceBinding{ + binding: &placementv1beta1.ClusterResourceBinding{ ObjectMeta: metav1.ObjectMeta{ Generation: 10, }, - Status: fleetv1beta1.ResourceBindingStatus{ + Status: placementv1beta1.ResourceBindingStatus{ Conditions: []metav1.Condition{ { - Type: string(fleetv1beta1.ResourceBindingAvailable), + Type: string(placementv1beta1.ResourceBindingAvailable), Status: metav1.ConditionTrue, ObservedGeneration: 10, LastTransitionTime: metav1.Time{ @@ -712,14 +708,14 @@ func TestIsBindingReady(t *testing.T) { wantWaitTime: time.Millisecond, }, "binding available (not trackable with old reason) after the ready time cut off should return not ready with a wait time": { - binding: &fleetv1beta1.ClusterResourceBinding{ + binding: &placementv1beta1.ClusterResourceBinding{ ObjectMeta: metav1.ObjectMeta{ Generation: 10, }, - Status: fleetv1beta1.ResourceBindingStatus{ + Status: placementv1beta1.ResourceBindingStatus{ Conditions: []metav1.Condition{ { - Type: string(fleetv1beta1.ResourceBindingAvailable), + Type: string(placementv1beta1.ResourceBindingAvailable), Status: metav1.ConditionTrue, ObservedGeneration: 10, LastTransitionTime: metav1.Time{ @@ -735,7 +731,7 @@ func TestIsBindingReady(t *testing.T) { wantWaitTime: time.Millisecond, }, "binding not available should return not ready with a negative wait time": { - binding: &fleetv1beta1.ClusterResourceBinding{ + binding: &placementv1beta1.ClusterResourceBinding{ ObjectMeta: metav1.ObjectMeta{ Generation: 10, }, @@ -745,14 +741,14 @@ func TestIsBindingReady(t *testing.T) { wantWaitTime: -1, }, "binding available for a previous generation should return not ready with a negative wait time": { - binding: &fleetv1beta1.ClusterResourceBinding{ + binding: &placementv1beta1.ClusterResourceBinding{ ObjectMeta: metav1.ObjectMeta{ Generation: 10, }, - Status: fleetv1beta1.ResourceBindingStatus{ + Status: placementv1beta1.ResourceBindingStatus{ Conditions: []metav1.Condition{ { - Type: string(fleetv1beta1.ResourceBindingAvailable), + Type: string(placementv1beta1.ResourceBindingAvailable), Status: metav1.ConditionTrue, ObservedGeneration: 9, //not the current generation LastTransitionTime: metav1.Time{ @@ -767,14 +763,14 @@ func TestIsBindingReady(t *testing.T) { wantWaitTime: -1, }, "binding diff report true should return ready": { - binding: &fleetv1beta1.ClusterResourceBinding{ + binding: &placementv1beta1.ClusterResourceBinding{ ObjectMeta: metav1.ObjectMeta{ Generation: 2, }, - Status: fleetv1beta1.ResourceBindingStatus{ + Status: placementv1beta1.ResourceBindingStatus{ Conditions: []metav1.Condition{ { - Type: string(fleetv1beta1.ResourceBindingDiffReported), + Type: string(placementv1beta1.ResourceBindingDiffReported), Status: metav1.ConditionTrue, LastTransitionTime: metav1.NewTime(now.Add(-5 * time.Minute)), ObservedGeneration: 2, @@ -787,14 +783,14 @@ func TestIsBindingReady(t *testing.T) { wantWaitTime: 0, }, "binding diff report false should return not ready and a negative wait time": { - binding: &fleetv1beta1.ClusterResourceBinding{ + binding: &placementv1beta1.ClusterResourceBinding{ ObjectMeta: metav1.ObjectMeta{ Generation: 10, }, - Status: fleetv1beta1.ResourceBindingStatus{ + Status: placementv1beta1.ResourceBindingStatus{ Conditions: []metav1.Condition{ { - Type: string(fleetv1beta1.ResourceBindingDiffReported), + Type: string(placementv1beta1.ResourceBindingDiffReported), Status: metav1.ConditionFalse, LastTransitionTime: metav1.NewTime(now.Add(-5 * time.Minute)), ObservedGeneration: 10, @@ -807,14 +803,14 @@ func TestIsBindingReady(t *testing.T) { wantWaitTime: -1, }, "binding diff report true on different generation should not be ready": { - binding: &fleetv1beta1.ClusterResourceBinding{ + binding: &placementv1beta1.ClusterResourceBinding{ ObjectMeta: metav1.ObjectMeta{ Generation: 10, }, - Status: fleetv1beta1.ResourceBindingStatus{ + Status: placementv1beta1.ResourceBindingStatus{ Conditions: []metav1.Condition{ { - Type: string(fleetv1beta1.ResourceBindingDiffReported), + Type: string(placementv1beta1.ResourceBindingDiffReported), Status: metav1.ConditionFalse, LastTransitionTime: metav1.NewTime(now.Add(-5 * time.Minute)), ObservedGeneration: 9, @@ -828,21 +824,21 @@ func TestIsBindingReady(t *testing.T) { }, "binding diff report false on different generation with successful current apply should be ready": { - binding: &fleetv1beta1.ClusterResourceBinding{ + binding: &placementv1beta1.ClusterResourceBinding{ ObjectMeta: metav1.ObjectMeta{ Generation: 10, }, - Status: fleetv1beta1.ResourceBindingStatus{ + Status: placementv1beta1.ResourceBindingStatus{ Conditions: []metav1.Condition{ { - Type: string(fleetv1beta1.ResourceBindingAvailable), + Type: string(placementv1beta1.ResourceBindingAvailable), Status: metav1.ConditionTrue, LastTransitionTime: metav1.NewTime(now.Add(-5 * time.Second)), Reason: condition.WorkAllManifestsAvailableReason, ObservedGeneration: 10, }, { - Type: string(fleetv1beta1.ResourceBindingDiffReported), + Type: string(placementv1beta1.ResourceBindingDiffReported), Status: metav1.ConditionFalse, LastTransitionTime: metav1.NewTime(now.Add(-5 * time.Minute)), ObservedGeneration: 9, //previous generation @@ -870,14 +866,14 @@ func TestIsBindingReady(t *testing.T) { func TestPickBindingsToRoll(t *testing.T) { tests := map[string]struct { - allBindings []*fleetv1beta1.ClusterResourceBinding + allBindings []*placementv1beta1.ClusterResourceBinding latestResourceSnapshotName string - crp *fleetv1beta1.ClusterResourcePlacement - matchedCROs []*fleetv1alpha1.ClusterResourceOverrideSnapshot - matchedROs []*fleetv1alpha1.ResourceOverrideSnapshot + crp *placementv1beta1.ClusterResourcePlacement + matchedCROs []*placementv1beta1.ClusterResourceOverrideSnapshot + matchedROs []*placementv1beta1.ResourceOverrideSnapshot clusters []clusterv1beta1.MemberCluster wantTobeUpdatedBindings []int - wantDesiredBindingsSpec []fleetv1beta1.ResourceBindingSpec // used to construct the want toBeUpdatedBindings + wantDesiredBindingsSpec []placementv1beta1.ResourceBindingSpec // used to construct the want toBeUpdatedBindings wantStaleUnselectedBindings []int wantUpToDateBoundBindings []int wantNeedRoll bool @@ -886,17 +882,17 @@ func TestPickBindingsToRoll(t *testing.T) { }{ // TODO: add more tests "test scheduled binding to bound, outdated resources and nil overrides - rollout allowed": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, "snapshot-1", cluster1), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, "snapshot-1", cluster1), }, latestResourceSnapshotName: "snapshot-2", crp: clusterResourcePlacementForTest("test", - createPlacementPolicyForTest(fleetv1beta1.PickAllPlacementType, 0), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)), + createPlacementPolicyForTest(placementv1beta1.PickAllPlacementType, 0), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)), wantTobeUpdatedBindings: []int{0}, - wantDesiredBindingsSpec: []fleetv1beta1.ResourceBindingSpec{ + wantDesiredBindingsSpec: []placementv1beta1.ResourceBindingSpec{ { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster1, ResourceSnapshotName: "snapshot-2", }, @@ -905,20 +901,20 @@ func TestPickBindingsToRoll(t *testing.T) { wantWaitTime: 0, }, "test scheduled binding to bound, outdated resources and updated apply strategy - rollout allowed": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, "snapshot-1", cluster1), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, "snapshot-1", cluster1), }, latestResourceSnapshotName: "snapshot-2", crp: clusterResourcePlacementForTest("test", - createPlacementPolicyForTest(fleetv1beta1.PickAllPlacementType, 0), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), - &fleetv1beta1.ApplyStrategy{ - Type: fleetv1beta1.ApplyStrategyTypeServerSideApply, + createPlacementPolicyForTest(placementv1beta1.PickAllPlacementType, 0), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), + &placementv1beta1.ApplyStrategy{ + Type: placementv1beta1.ApplyStrategyTypeServerSideApply, })), wantTobeUpdatedBindings: []int{0}, - wantDesiredBindingsSpec: []fleetv1beta1.ResourceBindingSpec{ + wantDesiredBindingsSpec: []placementv1beta1.ResourceBindingSpec{ { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster1, ResourceSnapshotName: "snapshot-2", // The pickBindingsToRoll method no longer refreshes apply strategy. @@ -928,19 +924,19 @@ func TestPickBindingsToRoll(t *testing.T) { wantWaitTime: 0, }, "test scheduled binding to bound, outdated resources and empty overrides - rollout allowed": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, "snapshot-1", cluster1), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, "snapshot-1", cluster1), }, latestResourceSnapshotName: "snapshot-2", crp: clusterResourcePlacementForTest("test", - createPlacementPolicyForTest(fleetv1beta1.PickAllPlacementType, 0), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)), - matchedROs: []*fleetv1alpha1.ResourceOverrideSnapshot{}, - matchedCROs: []*fleetv1alpha1.ClusterResourceOverrideSnapshot{}, + createPlacementPolicyForTest(placementv1beta1.PickAllPlacementType, 0), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)), + matchedROs: []*placementv1beta1.ResourceOverrideSnapshot{}, + matchedCROs: []*placementv1beta1.ClusterResourceOverrideSnapshot{}, wantTobeUpdatedBindings: []int{0}, - wantDesiredBindingsSpec: []fleetv1beta1.ResourceBindingSpec{ + wantDesiredBindingsSpec: []placementv1beta1.ResourceBindingSpec{ { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster1, ResourceSnapshotName: "snapshot-2", }, @@ -949,25 +945,25 @@ func TestPickBindingsToRoll(t *testing.T) { wantWaitTime: 0, }, "test scheduled binding to bound, outdated resources with overrides matching cluster - rollout allowed": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, "snapshot-1", cluster1), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, "snapshot-1", cluster1), }, latestResourceSnapshotName: "snapshot-2", crp: clusterResourcePlacementForTest("test", - createPlacementPolicyForTest(fleetv1beta1.PickAllPlacementType, 0), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)), - matchedCROs: []*fleetv1alpha1.ClusterResourceOverrideSnapshot{ + createPlacementPolicyForTest(placementv1beta1.PickAllPlacementType, 0), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)), + matchedCROs: []*placementv1beta1.ClusterResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "cro-1", }, - Spec: fleetv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: fleetv1alpha1.ClusterResourceOverrideSpec{ - Policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - ClusterSelector: &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{ + ClusterSelector: &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { LabelSelector: &metav1.LabelSelector{ MatchLabels: map[string]string{ @@ -984,19 +980,19 @@ func TestPickBindingsToRoll(t *testing.T) { }, }, }, - matchedROs: []*fleetv1alpha1.ResourceOverrideSnapshot{ + matchedROs: []*placementv1beta1.ResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "ro-2", Namespace: "test", }, - Spec: fleetv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: fleetv1alpha1.ResourceOverrideSpec{ - Policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - ClusterSelector: &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{ + ClusterSelector: &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { LabelSelector: &metav1.LabelSelector{ MatchLabels: map[string]string{ @@ -1025,13 +1021,13 @@ func TestPickBindingsToRoll(t *testing.T) { }, }, wantTobeUpdatedBindings: []int{0}, - wantDesiredBindingsSpec: []fleetv1beta1.ResourceBindingSpec{ + wantDesiredBindingsSpec: []placementv1beta1.ResourceBindingSpec{ { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster1, ResourceSnapshotName: "snapshot-2", ClusterResourceOverrideSnapshots: []string{"cro-1"}, - ResourceOverrideSnapshots: []fleetv1beta1.NamespacedName{ + ResourceOverrideSnapshots: []placementv1beta1.NamespacedName{ { Namespace: "test", Name: "ro-2", @@ -1043,25 +1039,25 @@ func TestPickBindingsToRoll(t *testing.T) { wantWaitTime: 0, }, "test scheduled binding to bound, outdated resources with overrides not matching any cluster - rollout allowed": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, "snapshot-1", cluster1), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, "snapshot-1", cluster1), }, latestResourceSnapshotName: "snapshot-2", crp: clusterResourcePlacementForTest("test", - createPlacementPolicyForTest(fleetv1beta1.PickAllPlacementType, 0), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)), - matchedCROs: []*fleetv1alpha1.ClusterResourceOverrideSnapshot{ + createPlacementPolicyForTest(placementv1beta1.PickAllPlacementType, 0), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)), + matchedCROs: []*placementv1beta1.ClusterResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "cro-1", }, - Spec: fleetv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: fleetv1alpha1.ClusterResourceOverrideSpec{ - Policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - ClusterSelector: &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{ + ClusterSelector: &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { LabelSelector: &metav1.LabelSelector{ MatchLabels: map[string]string{ @@ -1078,19 +1074,19 @@ func TestPickBindingsToRoll(t *testing.T) { }, }, }, - matchedROs: []*fleetv1alpha1.ResourceOverrideSnapshot{ + matchedROs: []*placementv1beta1.ResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "ro-2", Namespace: "test", }, - Spec: fleetv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: fleetv1alpha1.ResourceOverrideSpec{ - Policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - ClusterSelector: &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{ + ClusterSelector: &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { LabelSelector: &metav1.LabelSelector{ MatchLabels: map[string]string{ @@ -1115,9 +1111,9 @@ func TestPickBindingsToRoll(t *testing.T) { }, }, wantTobeUpdatedBindings: []int{0}, - wantDesiredBindingsSpec: []fleetv1beta1.ResourceBindingSpec{ + wantDesiredBindingsSpec: []placementv1beta1.ResourceBindingSpec{ { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster1, ResourceSnapshotName: "snapshot-2", }, @@ -1126,25 +1122,25 @@ func TestPickBindingsToRoll(t *testing.T) { wantWaitTime: 0, }, "test scheduled binding to bound, overrides matching cluster - rollout allowed": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, "snapshot-1", cluster1), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, "snapshot-1", cluster1), }, latestResourceSnapshotName: "snapshot-1", crp: clusterResourcePlacementForTest("test", - createPlacementPolicyForTest(fleetv1beta1.PickAllPlacementType, 0), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)), - matchedCROs: []*fleetv1alpha1.ClusterResourceOverrideSnapshot{ + createPlacementPolicyForTest(placementv1beta1.PickAllPlacementType, 0), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)), + matchedCROs: []*placementv1beta1.ClusterResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "cro-1", }, - Spec: fleetv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: fleetv1alpha1.ClusterResourceOverrideSpec{ - Policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - ClusterSelector: &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{ + ClusterSelector: &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { LabelSelector: &metav1.LabelSelector{ MatchLabels: map[string]string{ @@ -1161,19 +1157,19 @@ func TestPickBindingsToRoll(t *testing.T) { }, }, }, - matchedROs: []*fleetv1alpha1.ResourceOverrideSnapshot{ + matchedROs: []*placementv1beta1.ResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "ro-2", Namespace: "test", }, - Spec: fleetv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: fleetv1alpha1.ResourceOverrideSpec{ - Policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - ClusterSelector: &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{ + ClusterSelector: &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { LabelSelector: &metav1.LabelSelector{ MatchLabels: map[string]string{ @@ -1202,13 +1198,13 @@ func TestPickBindingsToRoll(t *testing.T) { }, }, wantTobeUpdatedBindings: []int{0}, - wantDesiredBindingsSpec: []fleetv1beta1.ResourceBindingSpec{ + wantDesiredBindingsSpec: []placementv1beta1.ResourceBindingSpec{ { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster1, ResourceSnapshotName: "snapshot-1", ClusterResourceOverrideSnapshots: []string{"cro-1"}, - ResourceOverrideSnapshots: []fleetv1beta1.NamespacedName{ + ResourceOverrideSnapshots: []placementv1beta1.NamespacedName{ { Namespace: "test", Name: "ro-2", @@ -1220,30 +1216,30 @@ func TestPickBindingsToRoll(t *testing.T) { wantWaitTime: 0, }, "test bound binding with latest resources - rollout not needed": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - generateClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster1), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + generateClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster1), }, latestResourceSnapshotName: "snapshot-1", crp: clusterResourcePlacementForTest("test", - createPlacementPolicyForTest(fleetv1beta1.PickAllPlacementType, 0), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)), + createPlacementPolicyForTest(placementv1beta1.PickAllPlacementType, 0), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)), wantTobeUpdatedBindings: []int{}, wantStaleUnselectedBindings: []int{}, wantUpToDateBoundBindings: []int{0}, wantNeedRoll: false, }, "test failed to apply bound binding, outdated resources - rollout allowed": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - generateFailedToApplyClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster1), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + generateFailedToApplyClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster1), }, latestResourceSnapshotName: "snapshot-2", crp: clusterResourcePlacementForTest("test", - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, 5), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)), + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, 5), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)), wantTobeUpdatedBindings: []int{0}, - wantDesiredBindingsSpec: []fleetv1beta1.ResourceBindingSpec{ + wantDesiredBindingsSpec: []placementv1beta1.ResourceBindingSpec{ { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster1, ResourceSnapshotName: "snapshot-2", }, @@ -1252,42 +1248,42 @@ func TestPickBindingsToRoll(t *testing.T) { wantWaitTime: defaultUnavailablePeriod * time.Second, }, "test one failed to apply bound binding and four failed non ready bound bindings, outdated resources with maxUnavailable specified - rollout allowed": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - generateFailedToApplyClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster1), - generateClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster2), - generateClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster3), - generateClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster4), - generateClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster5), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + generateFailedToApplyClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster1), + generateClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster2), + generateClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster3), + generateClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster4), + generateClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster5), }, latestResourceSnapshotName: "snapshot-2", crp: clusterResourcePlacementForTest("test", - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, 5), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)), // maxUnavailable is 1. + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, 5), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)), // maxUnavailable is 1. wantTobeUpdatedBindings: []int{0}, // failed to apply bound binding is always chosen as update candidate to be rolled out. wantStaleUnselectedBindings: []int{1, 2, 3, 4}, // there are no other ready bound bindings hence they are not rolled out, even with maxUnavailable specified. - wantDesiredBindingsSpec: []fleetv1beta1.ResourceBindingSpec{ + wantDesiredBindingsSpec: []placementv1beta1.ResourceBindingSpec{ { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster1, ResourceSnapshotName: "snapshot-2", }, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster2, ResourceSnapshotName: "snapshot-2", }, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster3, ResourceSnapshotName: "snapshot-2", }, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster4, ResourceSnapshotName: "snapshot-2", }, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster5, ResourceSnapshotName: "snapshot-2", }, @@ -1296,42 +1292,42 @@ func TestPickBindingsToRoll(t *testing.T) { wantWaitTime: defaultUnavailablePeriod * time.Second, }, "test three failed to apply bound binding, two ready bound binding, outdated resources with maxUnavailable specified - rollout allowed": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - generateFailedToApplyClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster1), - generateFailedToApplyClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster2), - generateFailedToApplyClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster3), - generateReadyClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster4), - generateReadyClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster5), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + generateFailedToApplyClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster1), + generateFailedToApplyClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster2), + generateFailedToApplyClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster3), + generateReadyClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster4), + generateReadyClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster5), }, latestResourceSnapshotName: "snapshot-2", crp: clusterResourcePlacementForTest("test", - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, 5), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)), // maxUnavailable is 1. + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, 5), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)), // maxUnavailable is 1. wantTobeUpdatedBindings: []int{0, 1, 2}, // all failed to apply bound bindings are always chosen as update candidates wantStaleUnselectedBindings: []int{3, 4}, // there are only two ready bindings out of five target bindings so these ready bindings cannot be updated. - wantDesiredBindingsSpec: []fleetv1beta1.ResourceBindingSpec{ + wantDesiredBindingsSpec: []placementv1beta1.ResourceBindingSpec{ { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster1, ResourceSnapshotName: "snapshot-2", }, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster2, ResourceSnapshotName: "snapshot-2", }, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster3, ResourceSnapshotName: "snapshot-2", }, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster4, ResourceSnapshotName: "snapshot-2", }, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster5, ResourceSnapshotName: "snapshot-2", }, @@ -1340,17 +1336,17 @@ func TestPickBindingsToRoll(t *testing.T) { wantWaitTime: defaultUnavailablePeriod * time.Second, }, "test bound ready bindings, maxUnavailable is set to zero - rollout blocked": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - generateReadyClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster1), - generateReadyClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster2), - generateReadyClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster3), - generateReadyClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster4), - generateReadyClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster5), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + generateReadyClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster1), + generateReadyClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster2), + generateReadyClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster3), + generateReadyClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster4), + generateReadyClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster5), }, latestResourceSnapshotName: "snapshot-2", crp: clusterResourcePlacementForTest("test", - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, 5), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, &fleetv1beta1.RollingUpdateConfig{ + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, 5), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, &placementv1beta1.RollingUpdateConfig{ MaxUnavailable: &intstr.IntOrString{ Type: intstr.Int, IntVal: 0, @@ -1363,29 +1359,29 @@ func TestPickBindingsToRoll(t *testing.T) { }, nil)), wantTobeUpdatedBindings: []int{}, wantStaleUnselectedBindings: []int{0, 1, 2, 3, 4}, // since maxUnavailable is set to zero no ready binding is updated. - wantDesiredBindingsSpec: []fleetv1beta1.ResourceBindingSpec{ + wantDesiredBindingsSpec: []placementv1beta1.ResourceBindingSpec{ { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster1, ResourceSnapshotName: "snapshot-2", }, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster2, ResourceSnapshotName: "snapshot-2", }, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster3, ResourceSnapshotName: "snapshot-2", }, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster4, ResourceSnapshotName: "snapshot-2", }, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster5, ResourceSnapshotName: "snapshot-2", }, @@ -1394,33 +1390,33 @@ func TestPickBindingsToRoll(t *testing.T) { wantWaitTime: 0, }, "test with no bindings": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{}, + allBindings: []*placementv1beta1.ClusterResourceBinding{}, latestResourceSnapshotName: "snapshot-2", crp: clusterResourcePlacementForTest("test", - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, 5), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)), + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, 5), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)), wantTobeUpdatedBindings: []int{}, wantNeedRoll: false, wantWaitTime: 0, }, "test two scheduled bindings, outdated resources - rollout allowed": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, "snapshot-1", cluster1), - generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, "snapshot-1", cluster2), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, "snapshot-1", cluster1), + generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, "snapshot-1", cluster2), }, latestResourceSnapshotName: "snapshot-2", crp: clusterResourcePlacementForTest("test", - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, 2), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)), + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, 2), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)), wantTobeUpdatedBindings: []int{0, 1}, - wantDesiredBindingsSpec: []fleetv1beta1.ResourceBindingSpec{ + wantDesiredBindingsSpec: []placementv1beta1.ResourceBindingSpec{ { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster1, ResourceSnapshotName: "snapshot-2", }, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster2, ResourceSnapshotName: "snapshot-2", }, @@ -1429,14 +1425,14 @@ func TestPickBindingsToRoll(t *testing.T) { wantWaitTime: 0, }, "test canBeReady bound and scheduled binding - rollout allowed with unavailable period wait time": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - generateCanBeReadyClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster1), - generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, "snapshot-1", cluster2), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + generateCanBeReadyClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster1), + generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, "snapshot-1", cluster2), }, latestResourceSnapshotName: "snapshot-2", crp: clusterResourcePlacementForTest("test", - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, 3), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, &fleetv1beta1.RollingUpdateConfig{ + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, 3), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, &placementv1beta1.RollingUpdateConfig{ MaxUnavailable: &intstr.IntOrString{ Type: intstr.String, StrVal: "20%", @@ -1449,14 +1445,14 @@ func TestPickBindingsToRoll(t *testing.T) { }, nil)), wantTobeUpdatedBindings: []int{1}, // scheduled binding is rolled out. wantStaleUnselectedBindings: []int{0}, // bound canBeReady binding cannot be rolled out because number of ready bindings is less than required. - wantDesiredBindingsSpec: []fleetv1beta1.ResourceBindingSpec{ + wantDesiredBindingsSpec: []placementv1beta1.ResourceBindingSpec{ { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster1, ResourceSnapshotName: "snapshot-2", }, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster2, ResourceSnapshotName: "snapshot-2", }, @@ -1465,17 +1461,17 @@ func TestPickBindingsToRoll(t *testing.T) { wantWaitTime: 60 * time.Second, }, "test two unscheduled bindings, maxUnavailable specified - rollout allowed": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - generateReadyClusterResourceBinding(fleetv1beta1.BindingStateUnscheduled, "snapshot-1", cluster1), - generateReadyClusterResourceBinding(fleetv1beta1.BindingStateUnscheduled, "snapshot-1", cluster2), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + generateReadyClusterResourceBinding(placementv1beta1.BindingStateUnscheduled, "snapshot-1", cluster1), + generateReadyClusterResourceBinding(placementv1beta1.BindingStateUnscheduled, "snapshot-1", cluster2), }, latestResourceSnapshotName: "snapshot-1", crp: clusterResourcePlacementForTest("test", - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, 2), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)), // maxUnavailable is set to 1. + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, 2), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)), // maxUnavailable is set to 1. wantTobeUpdatedBindings: []int{0}, // one ready unscheduled binding is removed since maxUnavailable is set to 1. wantStaleUnselectedBindings: []int{}, // remove candidate doesn't get appended as stale binding. - wantDesiredBindingsSpec: []fleetv1beta1.ResourceBindingSpec{ + wantDesiredBindingsSpec: []placementv1beta1.ResourceBindingSpec{ {}, {}, }, @@ -1483,22 +1479,22 @@ func TestPickBindingsToRoll(t *testing.T) { wantWaitTime: 0, }, "test overrides and the cluster is not found": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - generateClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster1), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + generateClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster1), }, latestResourceSnapshotName: "snapshot-1", - matchedCROs: []*fleetv1alpha1.ClusterResourceOverrideSnapshot{ + matchedCROs: []*placementv1beta1.ClusterResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "cro-1", }, - Spec: fleetv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: fleetv1alpha1.ClusterResourceOverrideSpec{ - Policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - ClusterSelector: &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{ + ClusterSelector: &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { LabelSelector: &metav1.LabelSelector{ MatchLabels: map[string]string{ @@ -1516,21 +1512,21 @@ func TestPickBindingsToRoll(t *testing.T) { }, }, crp: clusterResourcePlacementForTest("test", - createPlacementPolicyForTest(fleetv1beta1.PickAllPlacementType, 0), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)), + createPlacementPolicyForTest(placementv1beta1.PickAllPlacementType, 0), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)), wantErr: controller.ErrExpectedBehavior, }, "test bound bindings with different waitTimes and check the wait time should be the min of them all": { // want the min wait time of bound bindings that are not ready - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - generateNotTrackableClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster3, metav1.Time{Time: now.Add(-35 * time.Second)}), // notReady, waitTime = t - 35s - generateCanBeReadyClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster1), // notReady, no wait time because it does not have available condition yet, - generateReadyClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-2", cluster2), // Ready + allBindings: []*placementv1beta1.ClusterResourceBinding{ + generateNotTrackableClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster3, metav1.Time{Time: now.Add(-35 * time.Second)}), // notReady, waitTime = t - 35s + generateCanBeReadyClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster1), // notReady, no wait time because it does not have available condition yet, + generateReadyClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-2", cluster2), // Ready }, latestResourceSnapshotName: "snapshot-2", crp: clusterResourcePlacementForTest("test", - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, 3), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, &fleetv1beta1.RollingUpdateConfig{ + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, 3), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, &placementv1beta1.RollingUpdateConfig{ MaxUnavailable: &intstr.IntOrString{ Type: intstr.String, StrVal: "20%", @@ -1543,14 +1539,14 @@ func TestPickBindingsToRoll(t *testing.T) { }, nil)), // UnavailablePeriodSeconds is 60s -> readyTimeCutOff = t - 60s wantStaleUnselectedBindings: []int{0, 1}, wantUpToDateBoundBindings: []int{2}, - wantDesiredBindingsSpec: []fleetv1beta1.ResourceBindingSpec{ + wantDesiredBindingsSpec: []placementv1beta1.ResourceBindingSpec{ { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster3, ResourceSnapshotName: "snapshot-2", }, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster1, ResourceSnapshotName: "snapshot-2", }, @@ -1561,14 +1557,14 @@ func TestPickBindingsToRoll(t *testing.T) { }, "test unscheduled bindings with different waitTimes and check the wait time is correct": { // want the min wait time of unscheduled bindings that are not ready - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - generateNotTrackableClusterResourceBinding(fleetv1beta1.BindingStateUnscheduled, "snapshot-1", cluster2, metav1.Time{Time: now.Add(-1 * time.Minute)}), // NotReady, waitTime = t - 60s - generateNotTrackableClusterResourceBinding(fleetv1beta1.BindingStateUnscheduled, "snapshot-1", cluster3, metav1.Time{Time: now.Add(-35 * time.Second)}), // NotReady, waitTime = t - 35s + allBindings: []*placementv1beta1.ClusterResourceBinding{ + generateNotTrackableClusterResourceBinding(placementv1beta1.BindingStateUnscheduled, "snapshot-1", cluster2, metav1.Time{Time: now.Add(-1 * time.Minute)}), // NotReady, waitTime = t - 60s + generateNotTrackableClusterResourceBinding(placementv1beta1.BindingStateUnscheduled, "snapshot-1", cluster3, metav1.Time{Time: now.Add(-35 * time.Second)}), // NotReady, waitTime = t - 35s }, latestResourceSnapshotName: "snapshot-2", crp: clusterResourcePlacementForTest("test", - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, 3), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, &fleetv1beta1.RollingUpdateConfig{ + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, 3), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, &placementv1beta1.RollingUpdateConfig{ MaxUnavailable: &intstr.IntOrString{ Type: intstr.String, StrVal: "20%", @@ -1579,33 +1575,33 @@ func TestPickBindingsToRoll(t *testing.T) { }, UnavailablePeriodSeconds: ptr.To(60), }, nil)), // UnavailablePeriodSeconds is 60s -> readyTimeCutOff = t - 60s - wantStaleUnselectedBindings: []int{}, // empty list as unscheduled bindings will be removed and are not tracked in the CRP today. - wantDesiredBindingsSpec: []fleetv1beta1.ResourceBindingSpec{}, // unscheduled binding does not have desired spec so that putting the empty here + wantStaleUnselectedBindings: []int{}, // empty list as unscheduled bindings will be removed and are not tracked in the CRP today. + wantDesiredBindingsSpec: []placementv1beta1.ResourceBindingSpec{}, // unscheduled binding does not have desired spec so that putting the empty here wantNeedRoll: true, wantWaitTime: 25 * time.Second, // minWaitTime = (t - 35 seconds) - (t - 60 seconds) = 25 seconds }, "test only one bound but is deleting binding - rollout blocked": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - setDeletionTimeStampForBinding(generateClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster1)), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + setDeletionTimeStampForBinding(generateClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster1)), }, crp: clusterResourcePlacementForTest("test", - createPlacementPolicyForTest(fleetv1beta1.PickAllPlacementType, 0), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)), + createPlacementPolicyForTest(placementv1beta1.PickAllPlacementType, 0), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, generateDefaultRollingUpdateConfig(), nil)), wantTobeUpdatedBindings: []int{}, wantStaleUnselectedBindings: []int{}, wantNeedRoll: false, }, "test policy change with MaxSurge specified, evict resources on unscheduled cluster - rollout allowed for one scheduled binding": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - setDeletionTimeStampForBinding(generateCanBeReadyClusterResourceBinding(fleetv1beta1.BindingStateUnscheduled, "snapshot-1", cluster1)), - generateCanBeReadyClusterResourceBinding(fleetv1beta1.BindingStateUnscheduled, "snapshot-1", cluster2), - generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, "snapshot-1", cluster3), - generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, "snapshot-1", cluster4), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + setDeletionTimeStampForBinding(generateCanBeReadyClusterResourceBinding(placementv1beta1.BindingStateUnscheduled, "snapshot-1", cluster1)), + generateCanBeReadyClusterResourceBinding(placementv1beta1.BindingStateUnscheduled, "snapshot-1", cluster2), + generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, "snapshot-1", cluster3), + generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, "snapshot-1", cluster4), }, latestResourceSnapshotName: "snapshot-1", crp: clusterResourcePlacementForTest("test", - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, 2), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, &fleetv1beta1.RollingUpdateConfig{ + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, 2), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, &placementv1beta1.RollingUpdateConfig{ MaxUnavailable: &intstr.IntOrString{ Type: intstr.Int, IntVal: 0, @@ -1616,16 +1612,16 @@ func TestPickBindingsToRoll(t *testing.T) { }, UnavailablePeriodSeconds: ptr.To(1), }, nil)), - wantDesiredBindingsSpec: []fleetv1beta1.ResourceBindingSpec{ + wantDesiredBindingsSpec: []placementv1beta1.ResourceBindingSpec{ {}, {}, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster3, ResourceSnapshotName: "snapshot-1", }, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster4, ResourceSnapshotName: "snapshot-1", }, @@ -1636,16 +1632,16 @@ func TestPickBindingsToRoll(t *testing.T) { wantWaitTime: time.Second, }, "test policy change with MaxUnavailable specified, evict resources on unscheduled cluster - rollout allowed for one unscheduled binding": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - setDeletionTimeStampForBinding(generateReadyClusterResourceBinding(fleetv1beta1.BindingStateUnscheduled, "snapshot-1", cluster1)), - generateReadyClusterResourceBinding(fleetv1beta1.BindingStateUnscheduled, "snapshot-1", cluster2), - generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, "snapshot-1", cluster3), - generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, "snapshot-1", cluster4), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + setDeletionTimeStampForBinding(generateReadyClusterResourceBinding(placementv1beta1.BindingStateUnscheduled, "snapshot-1", cluster1)), + generateReadyClusterResourceBinding(placementv1beta1.BindingStateUnscheduled, "snapshot-1", cluster2), + generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, "snapshot-1", cluster3), + generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, "snapshot-1", cluster4), }, latestResourceSnapshotName: "snapshot-1", crp: clusterResourcePlacementForTest("test", - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, 2), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, &fleetv1beta1.RollingUpdateConfig{ + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, 2), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, &placementv1beta1.RollingUpdateConfig{ MaxUnavailable: &intstr.IntOrString{ Type: intstr.Int, IntVal: 2, @@ -1656,16 +1652,16 @@ func TestPickBindingsToRoll(t *testing.T) { }, UnavailablePeriodSeconds: ptr.To(1), }, nil)), - wantDesiredBindingsSpec: []fleetv1beta1.ResourceBindingSpec{ + wantDesiredBindingsSpec: []placementv1beta1.ResourceBindingSpec{ {}, {}, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster3, ResourceSnapshotName: "snapshot-1", }, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster4, ResourceSnapshotName: "snapshot-1", }, @@ -1676,14 +1672,14 @@ func TestPickBindingsToRoll(t *testing.T) { wantWaitTime: 0, }, "test resource snapshot change with MaxUnavailable specified, evict resources on ready bound binding - rollout allowed for one ready bound binding": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - setDeletionTimeStampForBinding(generateReadyClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster1)), - generateReadyClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster2), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + setDeletionTimeStampForBinding(generateReadyClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster1)), + generateReadyClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster2), }, latestResourceSnapshotName: "snapshot-2", crp: clusterResourcePlacementForTest("test", - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, 2), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, &fleetv1beta1.RollingUpdateConfig{ + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, 2), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, &placementv1beta1.RollingUpdateConfig{ MaxUnavailable: &intstr.IntOrString{ Type: intstr.Int, IntVal: 2, @@ -1694,10 +1690,10 @@ func TestPickBindingsToRoll(t *testing.T) { }, UnavailablePeriodSeconds: ptr.To(1), }, nil)), - wantDesiredBindingsSpec: []fleetv1beta1.ResourceBindingSpec{ + wantDesiredBindingsSpec: []placementv1beta1.ResourceBindingSpec{ {}, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster2, ResourceSnapshotName: "snapshot-2", }, @@ -1708,14 +1704,14 @@ func TestPickBindingsToRoll(t *testing.T) { wantWaitTime: 0, }, "test resource snapshot change with MaxUnavailable specified, evict resource on canBeReady binding - rollout blocked": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - setDeletionTimeStampForBinding(generateReadyClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster1)), - generateCanBeReadyClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster2), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + setDeletionTimeStampForBinding(generateReadyClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster1)), + generateCanBeReadyClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster2), }, latestResourceSnapshotName: "snapshot-2", crp: clusterResourcePlacementForTest("test", - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, 2), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, &fleetv1beta1.RollingUpdateConfig{ + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, 2), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, &placementv1beta1.RollingUpdateConfig{ MaxUnavailable: &intstr.IntOrString{ Type: intstr.Int, IntVal: 2, @@ -1726,10 +1722,10 @@ func TestPickBindingsToRoll(t *testing.T) { }, UnavailablePeriodSeconds: ptr.To(1), }, nil)), - wantDesiredBindingsSpec: []fleetv1beta1.ResourceBindingSpec{ + wantDesiredBindingsSpec: []placementv1beta1.ResourceBindingSpec{ {}, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster2, ResourceSnapshotName: "snapshot-2", }, @@ -1740,14 +1736,14 @@ func TestPickBindingsToRoll(t *testing.T) { wantWaitTime: time.Second, }, "test resource snapshot change with MaxUnavailable specified, evict resources on failed to apply bound binding - rollout allowed for one failed to apply bound binding": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - setDeletionTimeStampForBinding(generateReadyClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster1)), - generateFailedToApplyClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster2), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + setDeletionTimeStampForBinding(generateReadyClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster1)), + generateFailedToApplyClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster2), }, latestResourceSnapshotName: "snapshot-2", crp: clusterResourcePlacementForTest("test", - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, 2), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, &fleetv1beta1.RollingUpdateConfig{ + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, 2), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, &placementv1beta1.RollingUpdateConfig{ MaxUnavailable: &intstr.IntOrString{ Type: intstr.Int, IntVal: 0, @@ -1758,10 +1754,10 @@ func TestPickBindingsToRoll(t *testing.T) { }, UnavailablePeriodSeconds: ptr.To(1), }, nil)), - wantDesiredBindingsSpec: []fleetv1beta1.ResourceBindingSpec{ + wantDesiredBindingsSpec: []placementv1beta1.ResourceBindingSpec{ {}, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster2, ResourceSnapshotName: "snapshot-2", }, @@ -1772,16 +1768,16 @@ func TestPickBindingsToRoll(t *testing.T) { wantWaitTime: time.Second, }, "test upscale, evict resources from ready bound binding - rollout allowed for two new scheduled bindings": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - setDeletionTimeStampForBinding(generateReadyClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster1)), - generateReadyClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster2), - generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, "snapshot-1", cluster3), - generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, "snapshot-1", cluster4), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + setDeletionTimeStampForBinding(generateReadyClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster1)), + generateReadyClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster2), + generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, "snapshot-1", cluster3), + generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, "snapshot-1", cluster4), }, latestResourceSnapshotName: "snapshot-1", crp: clusterResourcePlacementForTest("test", - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, 4), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, &fleetv1beta1.RollingUpdateConfig{ + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, 4), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, &placementv1beta1.RollingUpdateConfig{ MaxUnavailable: &intstr.IntOrString{ Type: intstr.Int, IntVal: 0, @@ -1792,16 +1788,16 @@ func TestPickBindingsToRoll(t *testing.T) { }, UnavailablePeriodSeconds: ptr.To(1), }, nil)), - wantDesiredBindingsSpec: []fleetv1beta1.ResourceBindingSpec{ + wantDesiredBindingsSpec: []placementv1beta1.ResourceBindingSpec{ {}, {}, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster3, ResourceSnapshotName: "snapshot-1", }, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster4, ResourceSnapshotName: "snapshot-1", }, @@ -1813,18 +1809,18 @@ func TestPickBindingsToRoll(t *testing.T) { wantWaitTime: 0, }, "test upscale with policy change MaxSurge specified, evict resources from canBeReady bound binding - rollout allowed for three new scheduled bindings": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - setDeletionTimeStampForBinding(generateCanBeReadyClusterResourceBinding(fleetv1beta1.BindingStateUnscheduled, "snapshot-1", cluster1)), - generateCanBeReadyClusterResourceBinding(fleetv1beta1.BindingStateUnscheduled, "snapshot-1", cluster2), - generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, "snapshot-1", cluster3), - generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, "snapshot-1", cluster4), - generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, "snapshot-1", cluster5), - generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, "snapshot-1", cluster6), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + setDeletionTimeStampForBinding(generateCanBeReadyClusterResourceBinding(placementv1beta1.BindingStateUnscheduled, "snapshot-1", cluster1)), + generateCanBeReadyClusterResourceBinding(placementv1beta1.BindingStateUnscheduled, "snapshot-1", cluster2), + generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, "snapshot-1", cluster3), + generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, "snapshot-1", cluster4), + generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, "snapshot-1", cluster5), + generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, "snapshot-1", cluster6), }, latestResourceSnapshotName: "snapshot-1", crp: clusterResourcePlacementForTest("test", - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, 4), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, &fleetv1beta1.RollingUpdateConfig{ + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, 4), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, &placementv1beta1.RollingUpdateConfig{ MaxUnavailable: &intstr.IntOrString{ Type: intstr.Int, IntVal: 0, @@ -1835,26 +1831,26 @@ func TestPickBindingsToRoll(t *testing.T) { }, UnavailablePeriodSeconds: ptr.To(1), }, nil)), - wantDesiredBindingsSpec: []fleetv1beta1.ResourceBindingSpec{ + wantDesiredBindingsSpec: []placementv1beta1.ResourceBindingSpec{ {}, {}, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster3, ResourceSnapshotName: "snapshot-1", }, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster4, ResourceSnapshotName: "snapshot-1", }, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster5, ResourceSnapshotName: "snapshot-1", }, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster6, ResourceSnapshotName: "snapshot-1", }, @@ -1865,16 +1861,16 @@ func TestPickBindingsToRoll(t *testing.T) { wantWaitTime: time.Second, }, "test upscale with resource change MaxUnavailable specified, evict resources from ready bound binding - rollout allowed for old bound and new scheduled bindings": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - setDeletionTimeStampForBinding(generateReadyClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster1)), - generateReadyClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster2), - generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, "snapshot-2", cluster3), - generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, "snapshot-2", cluster4), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + setDeletionTimeStampForBinding(generateReadyClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster1)), + generateReadyClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster2), + generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, "snapshot-2", cluster3), + generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, "snapshot-2", cluster4), }, latestResourceSnapshotName: "snapshot-2", crp: clusterResourcePlacementForTest("test", - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, 4), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, &fleetv1beta1.RollingUpdateConfig{ + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, 4), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, &placementv1beta1.RollingUpdateConfig{ MaxUnavailable: &intstr.IntOrString{ Type: intstr.Int, IntVal: 4, @@ -1885,20 +1881,20 @@ func TestPickBindingsToRoll(t *testing.T) { }, UnavailablePeriodSeconds: ptr.To(1), }, nil)), - wantDesiredBindingsSpec: []fleetv1beta1.ResourceBindingSpec{ + wantDesiredBindingsSpec: []placementv1beta1.ResourceBindingSpec{ {}, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster2, ResourceSnapshotName: "snapshot-2", }, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster3, ResourceSnapshotName: "snapshot-2", }, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster4, ResourceSnapshotName: "snapshot-2", }, @@ -1909,16 +1905,16 @@ func TestPickBindingsToRoll(t *testing.T) { wantWaitTime: 0, }, "test downscale, evict resources from ready unscheduled binding - rollout allowed for one unscheduled binding": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - generateReadyClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster1), - generateReadyClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster2), - setDeletionTimeStampForBinding(generateReadyClusterResourceBinding(fleetv1beta1.BindingStateUnscheduled, "snapshot-1", cluster3)), - generateReadyClusterResourceBinding(fleetv1beta1.BindingStateUnscheduled, "snapshot-1", cluster4), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + generateReadyClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster1), + generateReadyClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster2), + setDeletionTimeStampForBinding(generateReadyClusterResourceBinding(placementv1beta1.BindingStateUnscheduled, "snapshot-1", cluster3)), + generateReadyClusterResourceBinding(placementv1beta1.BindingStateUnscheduled, "snapshot-1", cluster4), }, latestResourceSnapshotName: "snapshot-1", crp: clusterResourcePlacementForTest("test", - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, 2), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, &fleetv1beta1.RollingUpdateConfig{ + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, 2), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, &placementv1beta1.RollingUpdateConfig{ MaxUnavailable: &intstr.IntOrString{ Type: intstr.Int, IntVal: 0, @@ -1929,7 +1925,7 @@ func TestPickBindingsToRoll(t *testing.T) { }, UnavailablePeriodSeconds: ptr.To(1), }, nil)), - wantDesiredBindingsSpec: []fleetv1beta1.ResourceBindingSpec{ + wantDesiredBindingsSpec: []placementv1beta1.ResourceBindingSpec{ {}, {}, {}, @@ -1942,16 +1938,16 @@ func TestPickBindingsToRoll(t *testing.T) { wantWaitTime: 0, }, "test downscale, evict resources from ready bound binding - rollout allowed for two unscheduled bindings to be deleted": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - setDeletionTimeStampForBinding(generateReadyClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster1)), - generateReadyClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster2), - generateReadyClusterResourceBinding(fleetv1beta1.BindingStateUnscheduled, "snapshot-1", cluster3), - generateReadyClusterResourceBinding(fleetv1beta1.BindingStateUnscheduled, "snapshot-1", cluster4), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + setDeletionTimeStampForBinding(generateReadyClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster1)), + generateReadyClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster2), + generateReadyClusterResourceBinding(placementv1beta1.BindingStateUnscheduled, "snapshot-1", cluster3), + generateReadyClusterResourceBinding(placementv1beta1.BindingStateUnscheduled, "snapshot-1", cluster4), }, latestResourceSnapshotName: "snapshot-1", crp: clusterResourcePlacementForTest("test", - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, 2), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, &fleetv1beta1.RollingUpdateConfig{ + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, 2), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, &placementv1beta1.RollingUpdateConfig{ MaxUnavailable: &intstr.IntOrString{ Type: intstr.Int, IntVal: 1, @@ -1962,7 +1958,7 @@ func TestPickBindingsToRoll(t *testing.T) { }, UnavailablePeriodSeconds: ptr.To(1), }, nil)), - wantDesiredBindingsSpec: []fleetv1beta1.ResourceBindingSpec{ + wantDesiredBindingsSpec: []placementv1beta1.ResourceBindingSpec{ {}, {}, {}, @@ -1975,18 +1971,18 @@ func TestPickBindingsToRoll(t *testing.T) { wantWaitTime: 0, }, "test downscale with policy change, evict unscheduled ready binding - rollout allowed for one unscheduled binding": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - setDeletionTimeStampForBinding(generateReadyClusterResourceBinding(fleetv1beta1.BindingStateUnscheduled, "snapshot-1", cluster1)), - generateReadyClusterResourceBinding(fleetv1beta1.BindingStateUnscheduled, "snapshot-1", cluster2), - generateReadyClusterResourceBinding(fleetv1beta1.BindingStateUnscheduled, "snapshot-1", cluster3), - generateReadyClusterResourceBinding(fleetv1beta1.BindingStateUnscheduled, "snapshot-1", cluster4), - generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, "snapshot-1", cluster5), - generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, "snapshot-1", cluster6), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + setDeletionTimeStampForBinding(generateReadyClusterResourceBinding(placementv1beta1.BindingStateUnscheduled, "snapshot-1", cluster1)), + generateReadyClusterResourceBinding(placementv1beta1.BindingStateUnscheduled, "snapshot-1", cluster2), + generateReadyClusterResourceBinding(placementv1beta1.BindingStateUnscheduled, "snapshot-1", cluster3), + generateReadyClusterResourceBinding(placementv1beta1.BindingStateUnscheduled, "snapshot-1", cluster4), + generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, "snapshot-1", cluster5), + generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, "snapshot-1", cluster6), }, latestResourceSnapshotName: "snapshot-1", crp: clusterResourcePlacementForTest("test", - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, 2), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, &fleetv1beta1.RollingUpdateConfig{ + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, 2), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, &placementv1beta1.RollingUpdateConfig{ MaxUnavailable: &intstr.IntOrString{ Type: intstr.Int, IntVal: 0, @@ -1997,18 +1993,18 @@ func TestPickBindingsToRoll(t *testing.T) { }, UnavailablePeriodSeconds: ptr.To(1), }, nil)), - wantDesiredBindingsSpec: []fleetv1beta1.ResourceBindingSpec{ + wantDesiredBindingsSpec: []placementv1beta1.ResourceBindingSpec{ {}, {}, {}, {}, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster5, ResourceSnapshotName: "snapshot-1", }, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster6, ResourceSnapshotName: "snapshot-1", }, @@ -2019,18 +2015,18 @@ func TestPickBindingsToRoll(t *testing.T) { wantWaitTime: 0, }, "test downscale with policy change, evict unscheduled failed to apply binding - rollout allowed for new scheduled bindings": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - setDeletionTimeStampForBinding(generateFailedToApplyClusterResourceBinding(fleetv1beta1.BindingStateUnscheduled, "snapshot-1", cluster1)), - generateFailedToApplyClusterResourceBinding(fleetv1beta1.BindingStateUnscheduled, "snapshot-1", cluster2), - generateFailedToApplyClusterResourceBinding(fleetv1beta1.BindingStateUnscheduled, "snapshot-1", cluster3), - generateFailedToApplyClusterResourceBinding(fleetv1beta1.BindingStateUnscheduled, "snapshot-1", cluster4), - generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, "snapshot-1", cluster5), - generateClusterResourceBinding(fleetv1beta1.BindingStateScheduled, "snapshot-1", cluster6), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + setDeletionTimeStampForBinding(generateFailedToApplyClusterResourceBinding(placementv1beta1.BindingStateUnscheduled, "snapshot-1", cluster1)), + generateFailedToApplyClusterResourceBinding(placementv1beta1.BindingStateUnscheduled, "snapshot-1", cluster2), + generateFailedToApplyClusterResourceBinding(placementv1beta1.BindingStateUnscheduled, "snapshot-1", cluster3), + generateFailedToApplyClusterResourceBinding(placementv1beta1.BindingStateUnscheduled, "snapshot-1", cluster4), + generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, "snapshot-1", cluster5), + generateClusterResourceBinding(placementv1beta1.BindingStateScheduled, "snapshot-1", cluster6), }, latestResourceSnapshotName: "snapshot-1", crp: clusterResourcePlacementForTest("test", - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, 2), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, &fleetv1beta1.RollingUpdateConfig{ + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, 2), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, &placementv1beta1.RollingUpdateConfig{ MaxUnavailable: &intstr.IntOrString{ Type: intstr.Int, IntVal: 0, @@ -2041,18 +2037,18 @@ func TestPickBindingsToRoll(t *testing.T) { }, UnavailablePeriodSeconds: ptr.To(int(defaultUnavailablePeriod)), }, nil)), - wantDesiredBindingsSpec: []fleetv1beta1.ResourceBindingSpec{ + wantDesiredBindingsSpec: []placementv1beta1.ResourceBindingSpec{ {}, {}, {}, {}, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster5, ResourceSnapshotName: "snapshot-1", }, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster6, ResourceSnapshotName: "snapshot-1", }, @@ -2063,16 +2059,16 @@ func TestPickBindingsToRoll(t *testing.T) { wantWaitTime: defaultUnavailablePeriod * time.Second, }, "test downscale with resource snapshot change, evict ready bound binding - rollout allowed for one unscheduled binding": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - setDeletionTimeStampForBinding(generateReadyClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster1)), - generateReadyClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster2), - generateReadyClusterResourceBinding(fleetv1beta1.BindingStateUnscheduled, "snapshot-1", cluster3), - generateReadyClusterResourceBinding(fleetv1beta1.BindingStateUnscheduled, "snapshot-1", cluster4), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + setDeletionTimeStampForBinding(generateReadyClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster1)), + generateReadyClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster2), + generateReadyClusterResourceBinding(placementv1beta1.BindingStateUnscheduled, "snapshot-1", cluster3), + generateReadyClusterResourceBinding(placementv1beta1.BindingStateUnscheduled, "snapshot-1", cluster4), }, latestResourceSnapshotName: "snapshot-2", crp: clusterResourcePlacementForTest("test", - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, 2), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, &fleetv1beta1.RollingUpdateConfig{ + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, 2), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, &placementv1beta1.RollingUpdateConfig{ MaxUnavailable: &intstr.IntOrString{ Type: intstr.Int, IntVal: 0, @@ -2083,20 +2079,20 @@ func TestPickBindingsToRoll(t *testing.T) { }, UnavailablePeriodSeconds: ptr.To(1), }, nil)), - wantDesiredBindingsSpec: []fleetv1beta1.ResourceBindingSpec{ + wantDesiredBindingsSpec: []placementv1beta1.ResourceBindingSpec{ {}, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster2, ResourceSnapshotName: "snapshot-2", }, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster3, ResourceSnapshotName: "snapshot-2", }, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster4, ResourceSnapshotName: "snapshot-2", }, @@ -2107,16 +2103,16 @@ func TestPickBindingsToRoll(t *testing.T) { wantWaitTime: 0, }, "test downscale with resource snapshot change, evict ready unscheduled binding - rollout allowed for one unscheduled binding, one bound binding": { - allBindings: []*fleetv1beta1.ClusterResourceBinding{ - generateReadyClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster1), - generateReadyClusterResourceBinding(fleetv1beta1.BindingStateBound, "snapshot-1", cluster2), - setDeletionTimeStampForBinding(generateReadyClusterResourceBinding(fleetv1beta1.BindingStateUnscheduled, "snapshot-1", cluster3)), - generateReadyClusterResourceBinding(fleetv1beta1.BindingStateUnscheduled, "snapshot-1", cluster4), + allBindings: []*placementv1beta1.ClusterResourceBinding{ + generateReadyClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster1), + generateReadyClusterResourceBinding(placementv1beta1.BindingStateBound, "snapshot-1", cluster2), + setDeletionTimeStampForBinding(generateReadyClusterResourceBinding(placementv1beta1.BindingStateUnscheduled, "snapshot-1", cluster3)), + generateReadyClusterResourceBinding(placementv1beta1.BindingStateUnscheduled, "snapshot-1", cluster4), }, latestResourceSnapshotName: "snapshot-2", crp: clusterResourcePlacementForTest("test", - createPlacementPolicyForTest(fleetv1beta1.PickNPlacementType, 2), - createPlacementRolloutStrategyForTest(fleetv1beta1.RollingUpdateRolloutStrategyType, &fleetv1beta1.RollingUpdateConfig{ + createPlacementPolicyForTest(placementv1beta1.PickNPlacementType, 2), + createPlacementRolloutStrategyForTest(placementv1beta1.RollingUpdateRolloutStrategyType, &placementv1beta1.RollingUpdateConfig{ MaxUnavailable: &intstr.IntOrString{ Type: intstr.Int, IntVal: 1, @@ -2127,20 +2123,20 @@ func TestPickBindingsToRoll(t *testing.T) { }, UnavailablePeriodSeconds: ptr.To(1), }, nil)), - wantDesiredBindingsSpec: []fleetv1beta1.ResourceBindingSpec{ + wantDesiredBindingsSpec: []placementv1beta1.ResourceBindingSpec{ { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster1, ResourceSnapshotName: "snapshot-2", }, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster2, ResourceSnapshotName: "snapshot-2", }, {}, { - State: fleetv1beta1.BindingStateBound, + State: placementv1beta1.BindingStateBound, TargetCluster: cluster4, ResourceSnapshotName: "snapshot-2", }, @@ -2166,7 +2162,7 @@ func TestPickBindingsToRoll(t *testing.T) { r := Reconciler{ Client: fakeClient, } - resourceSnapshot := &fleetv1beta1.ClusterResourceSnapshot{ + resourceSnapshot := &placementv1beta1.ClusterResourceSnapshot{ ObjectMeta: metav1.ObjectMeta{ Name: tt.latestResourceSnapshotName, }, @@ -2183,7 +2179,7 @@ func TestPickBindingsToRoll(t *testing.T) { for i, index := range tt.wantTobeUpdatedBindings { // Unscheduled bindings are only removed in a single rollout cycle. bindingSpec := tt.allBindings[index].GetBindingSpec() - if bindingSpec.State != fleetv1beta1.BindingStateUnscheduled { + if bindingSpec.State != placementv1beta1.BindingStateUnscheduled { wantTobeUpdatedBindings[i].currentBinding = tt.allBindings[index] wantTobeUpdatedBindings[i].desiredBinding = tt.allBindings[index].DeepCopy() wantTobeUpdatedBindings[i].desiredBinding.SetBindingSpec(tt.wantDesiredBindingsSpec[index]) @@ -2195,7 +2191,7 @@ func TestPickBindingsToRoll(t *testing.T) { for i, index := range tt.wantStaleUnselectedBindings { // Unscheduled bindings are only removed in a single rollout cycle. bindingSpec := tt.allBindings[index].GetBindingSpec() - if bindingSpec.State != fleetv1beta1.BindingStateUnscheduled { + if bindingSpec.State != placementv1beta1.BindingStateUnscheduled { wantStaleUnselectedBindings[i].currentBinding = tt.allBindings[index] wantStaleUnselectedBindings[i].desiredBinding = tt.allBindings[index].DeepCopy() wantStaleUnselectedBindings[i].desiredBinding.SetBindingSpec(tt.wantDesiredBindingsSpec[index]) @@ -2229,14 +2225,14 @@ func TestPickBindingsToRoll(t *testing.T) { } } -func createPlacementPolicyForTest(placementType fleetv1beta1.PlacementType, numberOfClusters int32) *fleetv1beta1.PlacementPolicy { - return &fleetv1beta1.PlacementPolicy{ +func createPlacementPolicyForTest(placementType placementv1beta1.PlacementType, numberOfClusters int32) *placementv1beta1.PlacementPolicy { + return &placementv1beta1.PlacementPolicy{ PlacementType: placementType, NumberOfClusters: ptr.To(numberOfClusters), - Affinity: &fleetv1beta1.Affinity{ - ClusterAffinity: &fleetv1beta1.ClusterAffinity{ - RequiredDuringSchedulingIgnoredDuringExecution: &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{ + Affinity: &placementv1beta1.Affinity{ + ClusterAffinity: &placementv1beta1.ClusterAffinity{ + RequiredDuringSchedulingIgnoredDuringExecution: &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { LabelSelector: &metav1.LabelSelector{ MatchLabels: map[string]string{ @@ -2251,21 +2247,21 @@ func createPlacementPolicyForTest(placementType fleetv1beta1.PlacementType, numb } } -func createPlacementRolloutStrategyForTest(rolloutType fleetv1beta1.RolloutStrategyType, rollingUpdate *fleetv1beta1.RollingUpdateConfig, applyStrategy *fleetv1beta1.ApplyStrategy) fleetv1beta1.RolloutStrategy { - return fleetv1beta1.RolloutStrategy{ +func createPlacementRolloutStrategyForTest(rolloutType placementv1beta1.RolloutStrategyType, rollingUpdate *placementv1beta1.RollingUpdateConfig, applyStrategy *placementv1beta1.ApplyStrategy) placementv1beta1.RolloutStrategy { + return placementv1beta1.RolloutStrategy{ Type: rolloutType, RollingUpdate: rollingUpdate, ApplyStrategy: applyStrategy, } } -func clusterResourcePlacementForTest(crpName string, policy *fleetv1beta1.PlacementPolicy, strategy fleetv1beta1.RolloutStrategy) *fleetv1beta1.ClusterResourcePlacement { - return &fleetv1beta1.ClusterResourcePlacement{ +func clusterResourcePlacementForTest(crpName string, policy *placementv1beta1.PlacementPolicy, strategy placementv1beta1.RolloutStrategy) *placementv1beta1.ClusterResourcePlacement { + return &placementv1beta1.ClusterResourcePlacement{ ObjectMeta: metav1.ObjectMeta{ Name: crpName, }, - Spec: fleetv1beta1.PlacementSpec{ - ResourceSelectors: []fleetv1beta1.ClusterResourceSelector{ + Spec: placementv1beta1.PlacementSpec{ + ResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: corev1.GroupName, Version: "v1", @@ -2281,35 +2277,35 @@ func clusterResourcePlacementForTest(crpName string, policy *fleetv1beta1.Placem } } -func generateFailedToApplyClusterResourceBinding(state fleetv1beta1.BindingState, resourceSnapshotName, targetCluster string) *fleetv1beta1.ClusterResourceBinding { +func generateFailedToApplyClusterResourceBinding(state placementv1beta1.BindingState, resourceSnapshotName, targetCluster string) *placementv1beta1.ClusterResourceBinding { binding := generateClusterResourceBinding(state, resourceSnapshotName, targetCluster) binding.Status.Conditions = append(binding.Status.Conditions, metav1.Condition{ - Type: string(fleetv1beta1.ResourceBindingApplied), + Type: string(placementv1beta1.ResourceBindingApplied), Status: metav1.ConditionFalse, }) return binding } -func generateCanBeReadyClusterResourceBinding(state fleetv1beta1.BindingState, resourceSnapshotName, targetCluster string) *fleetv1beta1.ClusterResourceBinding { +func generateCanBeReadyClusterResourceBinding(state placementv1beta1.BindingState, resourceSnapshotName, targetCluster string) *placementv1beta1.ClusterResourceBinding { binding := generateClusterResourceBinding(state, resourceSnapshotName, targetCluster) binding.Status.Conditions = []metav1.Condition{ { - Type: string(fleetv1beta1.ResourceBindingApplied), + Type: string(placementv1beta1.ResourceBindingApplied), Status: metav1.ConditionTrue, }, } return binding } -func generateReadyClusterResourceBinding(state fleetv1beta1.BindingState, resourceSnapshotName, targetCluster string) *fleetv1beta1.ClusterResourceBinding { +func generateReadyClusterResourceBinding(state placementv1beta1.BindingState, resourceSnapshotName, targetCluster string) *placementv1beta1.ClusterResourceBinding { binding := generateClusterResourceBinding(state, resourceSnapshotName, targetCluster) binding.Status.Conditions = []metav1.Condition{ { - Type: string(fleetv1beta1.ResourceBindingApplied), + Type: string(placementv1beta1.ResourceBindingApplied), Status: metav1.ConditionTrue, }, { - Type: string(fleetv1beta1.ResourceBindingAvailable), + Type: string(placementv1beta1.ResourceBindingAvailable), Status: metav1.ConditionTrue, Reason: condition.WorkAllManifestsAvailableReason, // Make it ready }, @@ -2317,15 +2313,15 @@ func generateReadyClusterResourceBinding(state fleetv1beta1.BindingState, resour return binding } -func generateNotTrackableClusterResourceBinding(state fleetv1beta1.BindingState, resourceSnapshotName, targetCluster string, lastTransitionTime metav1.Time) *fleetv1beta1.ClusterResourceBinding { +func generateNotTrackableClusterResourceBinding(state placementv1beta1.BindingState, resourceSnapshotName, targetCluster string, lastTransitionTime metav1.Time) *placementv1beta1.ClusterResourceBinding { binding := generateClusterResourceBinding(state, resourceSnapshotName, targetCluster) binding.Status.Conditions = []metav1.Condition{ { - Type: string(fleetv1beta1.ResourceBindingApplied), + Type: string(placementv1beta1.ResourceBindingApplied), Status: metav1.ConditionTrue, }, { - Type: string(fleetv1beta1.ResourceBindingAvailable), + Type: string(placementv1beta1.ResourceBindingAvailable), Status: metav1.ConditionTrue, LastTransitionTime: lastTransitionTime, Reason: condition.WorkNotAvailabilityTrackableReason, // Make it not ready @@ -2334,15 +2330,15 @@ func generateNotTrackableClusterResourceBinding(state fleetv1beta1.BindingState, return binding } -func setDeletionTimeStampForBinding(binding *fleetv1beta1.ClusterResourceBinding) *fleetv1beta1.ClusterResourceBinding { +func setDeletionTimeStampForBinding(binding *placementv1beta1.ClusterResourceBinding) *placementv1beta1.ClusterResourceBinding { binding.DeletionTimestamp = &metav1.Time{ Time: now, } return binding } -func generateDefaultRollingUpdateConfig() *fleetv1beta1.RollingUpdateConfig { - return &fleetv1beta1.RollingUpdateConfig{ +func generateDefaultRollingUpdateConfig() *placementv1beta1.RollingUpdateConfig { + return &placementv1beta1.RollingUpdateConfig{ MaxUnavailable: &intstr.IntOrString{ Type: intstr.String, StrVal: "20%", @@ -2362,8 +2358,8 @@ func TestUpdateStaleBindingsStatus(t *testing.T) { tests := map[string]struct { skipPuttingBindings bool // whether skip to put the bindings into the api server // build toBeUpdatedBinding with currentBinding and desiredBinding - bindings []fleetv1beta1.ClusterResourceBinding - wantBindings []fleetv1beta1.ClusterResourceBinding + bindings []placementv1beta1.ClusterResourceBinding + wantBindings []placementv1beta1.ClusterResourceBinding wantErr error }{ "update bindings with nil": { @@ -2371,38 +2367,38 @@ func TestUpdateStaleBindingsStatus(t *testing.T) { wantBindings: nil, }, "update bindings with empty": { - bindings: []fleetv1beta1.ClusterResourceBinding{}, + bindings: []placementv1beta1.ClusterResourceBinding{}, wantBindings: nil, }, "update a bounded binding status": { - bindings: []fleetv1beta1.ClusterResourceBinding{ + bindings: []placementv1beta1.ClusterResourceBinding{ { ObjectMeta: metav1.ObjectMeta{ Name: "binding-1", Generation: 15, }, - Spec: fleetv1beta1.ResourceBindingSpec{ - State: fleetv1beta1.BindingStateBound, + Spec: placementv1beta1.ResourceBindingSpec{ + State: placementv1beta1.BindingStateBound, TargetCluster: cluster1, ResourceSnapshotName: "snapshot-1", }, }, }, - wantBindings: []fleetv1beta1.ClusterResourceBinding{ + wantBindings: []placementv1beta1.ClusterResourceBinding{ { ObjectMeta: metav1.ObjectMeta{ Name: "binding-1", Generation: 15, }, - Spec: fleetv1beta1.ResourceBindingSpec{ - State: fleetv1beta1.BindingStateBound, + Spec: placementv1beta1.ResourceBindingSpec{ + State: placementv1beta1.BindingStateBound, TargetCluster: cluster1, ResourceSnapshotName: "snapshot-1", }, - Status: fleetv1beta1.ResourceBindingStatus{ + Status: placementv1beta1.ResourceBindingStatus{ Conditions: []metav1.Condition{ { - Type: string(fleetv1beta1.ResourceBindingRolloutStarted), + Type: string(placementv1beta1.ResourceBindingRolloutStarted), Status: metav1.ConditionFalse, ObservedGeneration: 15, LastTransitionTime: metav1.NewTime(currentTime), @@ -2414,21 +2410,21 @@ func TestUpdateStaleBindingsStatus(t *testing.T) { }, }, "update unscheduled binding status": { - bindings: []fleetv1beta1.ClusterResourceBinding{ + bindings: []placementv1beta1.ClusterResourceBinding{ { ObjectMeta: metav1.ObjectMeta{ Name: "binding-1", Generation: 15, }, - Spec: fleetv1beta1.ResourceBindingSpec{ - State: fleetv1beta1.BindingStateUnscheduled, + Spec: placementv1beta1.ResourceBindingSpec{ + State: placementv1beta1.BindingStateUnscheduled, TargetCluster: cluster1, ResourceSnapshotName: "snapshot-1", }, - Status: fleetv1beta1.ResourceBindingStatus{ + Status: placementv1beta1.ResourceBindingStatus{ Conditions: []metav1.Condition{ { - Type: string(fleetv1beta1.ResourceBindingRolloutStarted), + Type: string(placementv1beta1.ResourceBindingRolloutStarted), Status: metav1.ConditionTrue, ObservedGeneration: 14, LastTransitionTime: metav1.NewTime(currentTime), @@ -2438,21 +2434,21 @@ func TestUpdateStaleBindingsStatus(t *testing.T) { }, }, }, - wantBindings: []fleetv1beta1.ClusterResourceBinding{ + wantBindings: []placementv1beta1.ClusterResourceBinding{ { ObjectMeta: metav1.ObjectMeta{ Name: "binding-1", Generation: 15, }, - Spec: fleetv1beta1.ResourceBindingSpec{ - State: fleetv1beta1.BindingStateUnscheduled, + Spec: placementv1beta1.ResourceBindingSpec{ + State: placementv1beta1.BindingStateUnscheduled, TargetCluster: cluster1, ResourceSnapshotName: "snapshot-1", }, - Status: fleetv1beta1.ResourceBindingStatus{ + Status: placementv1beta1.ResourceBindingStatus{ Conditions: []metav1.Condition{ { - Type: string(fleetv1beta1.ResourceBindingRolloutStarted), + Type: string(placementv1beta1.ResourceBindingRolloutStarted), Status: metav1.ConditionTrue, ObservedGeneration: 14, LastTransitionTime: metav1.NewTime(currentTime), @@ -2464,20 +2460,20 @@ func TestUpdateStaleBindingsStatus(t *testing.T) { }, }, "update multiple bindings": { - bindings: []fleetv1beta1.ClusterResourceBinding{ + bindings: []placementv1beta1.ClusterResourceBinding{ { ObjectMeta: metav1.ObjectMeta{ Name: "binding-1", Generation: 15, }, - Spec: fleetv1beta1.ResourceBindingSpec{ - State: fleetv1beta1.BindingStateScheduled, + Spec: placementv1beta1.ResourceBindingSpec{ + State: placementv1beta1.BindingStateScheduled, TargetCluster: cluster1, }, - Status: fleetv1beta1.ResourceBindingStatus{ + Status: placementv1beta1.ResourceBindingStatus{ Conditions: []metav1.Condition{ { - Type: string(fleetv1beta1.ResourceBindingRolloutStarted), + Type: string(placementv1beta1.ResourceBindingRolloutStarted), Status: metav1.ConditionFalse, ObservedGeneration: 15, LastTransitionTime: oldTransitionTime, @@ -2491,27 +2487,27 @@ func TestUpdateStaleBindingsStatus(t *testing.T) { Name: "binding-2", Generation: 1, }, - Spec: fleetv1beta1.ResourceBindingSpec{ - State: fleetv1beta1.BindingStateBound, + Spec: placementv1beta1.ResourceBindingSpec{ + State: placementv1beta1.BindingStateBound, TargetCluster: cluster2, ResourceSnapshotName: "snapshot-2", }, }, }, - wantBindings: []fleetv1beta1.ClusterResourceBinding{ + wantBindings: []placementv1beta1.ClusterResourceBinding{ { ObjectMeta: metav1.ObjectMeta{ Name: "binding-1", Generation: 15, }, - Spec: fleetv1beta1.ResourceBindingSpec{ - State: fleetv1beta1.BindingStateScheduled, + Spec: placementv1beta1.ResourceBindingSpec{ + State: placementv1beta1.BindingStateScheduled, TargetCluster: cluster1, }, - Status: fleetv1beta1.ResourceBindingStatus{ + Status: placementv1beta1.ResourceBindingStatus{ Conditions: []metav1.Condition{ { - Type: string(fleetv1beta1.ResourceBindingRolloutStarted), + Type: string(placementv1beta1.ResourceBindingRolloutStarted), Status: metav1.ConditionFalse, ObservedGeneration: 15, LastTransitionTime: oldTransitionTime, @@ -2525,15 +2521,15 @@ func TestUpdateStaleBindingsStatus(t *testing.T) { Name: "binding-2", Generation: 1, }, - Spec: fleetv1beta1.ResourceBindingSpec{ - State: fleetv1beta1.BindingStateBound, + Spec: placementv1beta1.ResourceBindingSpec{ + State: placementv1beta1.BindingStateBound, TargetCluster: cluster2, ResourceSnapshotName: "snapshot-2", }, - Status: fleetv1beta1.ResourceBindingStatus{ + Status: placementv1beta1.ResourceBindingStatus{ Conditions: []metav1.Condition{ { - Type: string(fleetv1beta1.ResourceBindingRolloutStarted), + Type: string(placementv1beta1.ResourceBindingRolloutStarted), Status: metav1.ConditionFalse, ObservedGeneration: 1, LastTransitionTime: metav1.NewTime(currentTime), @@ -2574,7 +2570,7 @@ func TestUpdateStaleBindingsStatus(t *testing.T) { if err := r.updateStaleBindingsStatus(ctx, inputs); err != nil { t.Fatalf("updateStaleBindingsStatus() got error %v, want no err", err) } - bindingList := &fleetv1beta1.ClusterResourceBindingList{} + bindingList := &placementv1beta1.ClusterResourceBindingList{} if err := fakeClient.List(ctx, bindingList); err != nil { t.Fatalf("updateStaleBindingsStatus List() got error %v, want no err", err) } @@ -2590,8 +2586,8 @@ func TestRefreshUpToDateBindingStatus(t *testing.T) { testCases := []struct { name string - upToDateBindings []fleetv1beta1.ClusterResourceBinding - wantBindings []fleetv1beta1.ClusterResourceBinding + upToDateBindings []placementv1beta1.ClusterResourceBinding + wantBindings []placementv1beta1.ClusterResourceBinding }{ { name: "nil array", @@ -2600,19 +2596,19 @@ func TestRefreshUpToDateBindingStatus(t *testing.T) { }, { name: "empty array", - upToDateBindings: []fleetv1beta1.ClusterResourceBinding{}, + upToDateBindings: []placementv1beta1.ClusterResourceBinding{}, wantBindings: nil, }, { name: "up to date bindings", - upToDateBindings: []fleetv1beta1.ClusterResourceBinding{ + upToDateBindings: []placementv1beta1.ClusterResourceBinding{ { ObjectMeta: metav1.ObjectMeta{ Name: "binding-1", Generation: 1, }, - Spec: fleetv1beta1.ResourceBindingSpec{ - State: fleetv1beta1.BindingStateBound, + Spec: placementv1beta1.ResourceBindingSpec{ + State: placementv1beta1.BindingStateBound, TargetCluster: cluster1, ResourceSnapshotName: "snapshot-1", }, @@ -2622,28 +2618,28 @@ func TestRefreshUpToDateBindingStatus(t *testing.T) { Name: "binding-2", Generation: 2, }, - Spec: fleetv1beta1.ResourceBindingSpec{ - State: fleetv1beta1.BindingStateBound, + Spec: placementv1beta1.ResourceBindingSpec{ + State: placementv1beta1.BindingStateBound, TargetCluster: cluster2, ResourceSnapshotName: "snapshot-1", }, }, }, - wantBindings: []fleetv1beta1.ClusterResourceBinding{ + wantBindings: []placementv1beta1.ClusterResourceBinding{ { ObjectMeta: metav1.ObjectMeta{ Name: "binding-1", Generation: 1, }, - Spec: fleetv1beta1.ResourceBindingSpec{ - State: fleetv1beta1.BindingStateBound, + Spec: placementv1beta1.ResourceBindingSpec{ + State: placementv1beta1.BindingStateBound, TargetCluster: cluster1, ResourceSnapshotName: "snapshot-1", }, - Status: fleetv1beta1.ResourceBindingStatus{ + Status: placementv1beta1.ResourceBindingStatus{ Conditions: []metav1.Condition{ { - Type: string(fleetv1beta1.ResourceBindingRolloutStarted), + Type: string(placementv1beta1.ResourceBindingRolloutStarted), Status: metav1.ConditionTrue, ObservedGeneration: 1, LastTransitionTime: metav1.NewTime(currentTime), @@ -2657,15 +2653,15 @@ func TestRefreshUpToDateBindingStatus(t *testing.T) { Name: "binding-2", Generation: 2, }, - Spec: fleetv1beta1.ResourceBindingSpec{ - State: fleetv1beta1.BindingStateBound, + Spec: placementv1beta1.ResourceBindingSpec{ + State: placementv1beta1.BindingStateBound, TargetCluster: cluster2, ResourceSnapshotName: "snapshot-1", }, - Status: fleetv1beta1.ResourceBindingStatus{ + Status: placementv1beta1.ResourceBindingStatus{ Conditions: []metav1.Condition{ { - Type: string(fleetv1beta1.ResourceBindingRolloutStarted), + Type: string(placementv1beta1.ResourceBindingRolloutStarted), Status: metav1.ConditionTrue, ObservedGeneration: 2, LastTransitionTime: metav1.NewTime(currentTime), @@ -2697,7 +2693,7 @@ func TestRefreshUpToDateBindingStatus(t *testing.T) { upToDateBindings := make([]toBeUpdatedBinding, 0, len(tc.upToDateBindings)) for i := range tc.upToDateBindings { // Get the data from the api server first so that the update won't fail because of the revision. - binding := &fleetv1beta1.ClusterResourceBinding{} + binding := &placementv1beta1.ClusterResourceBinding{} if err := fakeClient.Get(ctx, client.ObjectKey{Name: tc.upToDateBindings[i].Name}, binding); err != nil { t.Fatalf("failed to get binding: %v", err) } @@ -2706,7 +2702,7 @@ func TestRefreshUpToDateBindingStatus(t *testing.T) { if err := r.refreshUpToDateBindingStatus(ctx, upToDateBindings); err != nil { t.Fatalf("updateStaleBindingsStatus() = %v, want no error", err) } - bindingList := &fleetv1beta1.ClusterResourceBindingList{} + bindingList := &placementv1beta1.ClusterResourceBindingList{} if err := fakeClient.List(ctx, bindingList); err != nil { t.Fatalf("ClusterResourceBinding List() = %v, want no error", err) } @@ -2719,19 +2715,19 @@ func TestRefreshUpToDateBindingStatus(t *testing.T) { func TestCheckAndUpdateStaleBindingsStatus(t *testing.T) { generation := int64(15) - latestBindings := []*fleetv1beta1.ClusterResourceBinding{ + latestBindings := []*placementv1beta1.ClusterResourceBinding{ { ObjectMeta: metav1.ObjectMeta{ Name: "binding-1", Generation: generation, }, - Spec: fleetv1beta1.ResourceBindingSpec{ - State: fleetv1beta1.BindingStateBound, + Spec: placementv1beta1.ResourceBindingSpec{ + State: placementv1beta1.BindingStateBound, }, - Status: fleetv1beta1.ResourceBindingStatus{ + Status: placementv1beta1.ResourceBindingStatus{ Conditions: []metav1.Condition{ { - Type: string(fleetv1beta1.ResourceBindingRolloutStarted), + Type: string(placementv1beta1.ResourceBindingRolloutStarted), Status: metav1.ConditionTrue, ObservedGeneration: generation, Reason: condition.RolloutStartedReason, @@ -2744,13 +2740,13 @@ func TestCheckAndUpdateStaleBindingsStatus(t *testing.T) { Name: "binding-2", Generation: generation, }, - Spec: fleetv1beta1.ResourceBindingSpec{ - State: fleetv1beta1.BindingStateScheduled, + Spec: placementv1beta1.ResourceBindingSpec{ + State: placementv1beta1.BindingStateScheduled, }, - Status: fleetv1beta1.ResourceBindingStatus{ + Status: placementv1beta1.ResourceBindingStatus{ Conditions: []metav1.Condition{ { - Type: string(fleetv1beta1.ResourceBindingRolloutStarted), + Type: string(placementv1beta1.ResourceBindingRolloutStarted), Status: metav1.ConditionTrue, ObservedGeneration: generation, Reason: condition.RolloutStartedReason, @@ -2763,62 +2759,62 @@ func TestCheckAndUpdateStaleBindingsStatus(t *testing.T) { Name: "binding-3", Generation: generation, }, - Spec: fleetv1beta1.ResourceBindingSpec{ - State: fleetv1beta1.BindingStateUnscheduled, + Spec: placementv1beta1.ResourceBindingSpec{ + State: placementv1beta1.BindingStateUnscheduled, }, }, } tests := map[string]struct { - bindings []*fleetv1beta1.ClusterResourceBinding - wantBindings []fleetv1beta1.ClusterResourceBinding + bindings []*placementv1beta1.ClusterResourceBinding + wantBindings []placementv1beta1.ClusterResourceBinding }{ "update bindings with nil": { bindings: nil, wantBindings: nil, }, "update bindings with empty": { - bindings: []*fleetv1beta1.ClusterResourceBinding{}, + bindings: []*placementv1beta1.ClusterResourceBinding{}, wantBindings: nil, }, "bindings with rollout started condition": { bindings: latestBindings, - wantBindings: []fleetv1beta1.ClusterResourceBinding{ + wantBindings: []placementv1beta1.ClusterResourceBinding{ *latestBindings[0], *latestBindings[1], *latestBindings[2], }, }, "update stale bounded binding": { - bindings: []*fleetv1beta1.ClusterResourceBinding{ + bindings: []*placementv1beta1.ClusterResourceBinding{ { ObjectMeta: metav1.ObjectMeta{ Name: "binding-1", Generation: generation, }, - Spec: fleetv1beta1.ResourceBindingSpec{ - State: fleetv1beta1.BindingStateBound, + Spec: placementv1beta1.ResourceBindingSpec{ + State: placementv1beta1.BindingStateBound, }, }, }, - wantBindings: []fleetv1beta1.ClusterResourceBinding{ + wantBindings: []placementv1beta1.ClusterResourceBinding{ *latestBindings[0], }, }, "update stale scheduled bindings": { - bindings: []*fleetv1beta1.ClusterResourceBinding{ + bindings: []*placementv1beta1.ClusterResourceBinding{ { ObjectMeta: metav1.ObjectMeta{ Name: "binding-2", Generation: generation, }, - Spec: fleetv1beta1.ResourceBindingSpec{ - State: fleetv1beta1.BindingStateScheduled, + Spec: placementv1beta1.ResourceBindingSpec{ + State: placementv1beta1.BindingStateScheduled, }, - Status: fleetv1beta1.ResourceBindingStatus{ + Status: placementv1beta1.ResourceBindingStatus{ Conditions: []metav1.Condition{ { - Type: string(fleetv1beta1.ResourceBindingRolloutStarted), + Type: string(placementv1beta1.ResourceBindingRolloutStarted), Status: metav1.ConditionFalse, ObservedGeneration: generation, }, @@ -2826,24 +2822,24 @@ func TestCheckAndUpdateStaleBindingsStatus(t *testing.T) { }, }, }, - wantBindings: []fleetv1beta1.ClusterResourceBinding{ + wantBindings: []placementv1beta1.ClusterResourceBinding{ *latestBindings[1], }, }, "update multiple stale bindings": { - bindings: []*fleetv1beta1.ClusterResourceBinding{ + bindings: []*placementv1beta1.ClusterResourceBinding{ { ObjectMeta: metav1.ObjectMeta{ Name: "binding-1", Generation: generation, }, - Spec: fleetv1beta1.ResourceBindingSpec{ - State: fleetv1beta1.BindingStateBound, + Spec: placementv1beta1.ResourceBindingSpec{ + State: placementv1beta1.BindingStateBound, }, - Status: fleetv1beta1.ResourceBindingStatus{ + Status: placementv1beta1.ResourceBindingStatus{ Conditions: []metav1.Condition{ { - Type: string(fleetv1beta1.ResourceBindingRolloutStarted), + Type: string(placementv1beta1.ResourceBindingRolloutStarted), Status: metav1.ConditionTrue, ObservedGeneration: generation - 1, }, @@ -2855,13 +2851,13 @@ func TestCheckAndUpdateStaleBindingsStatus(t *testing.T) { Name: "binding-2", Generation: generation, }, - Spec: fleetv1beta1.ResourceBindingSpec{ - State: fleetv1beta1.BindingStateScheduled, + Spec: placementv1beta1.ResourceBindingSpec{ + State: placementv1beta1.BindingStateScheduled, }, - Status: fleetv1beta1.ResourceBindingStatus{ + Status: placementv1beta1.ResourceBindingStatus{ Conditions: []metav1.Condition{ { - Type: string(fleetv1beta1.ResourceBindingRolloutStarted), + Type: string(placementv1beta1.ResourceBindingRolloutStarted), Status: metav1.ConditionFalse, ObservedGeneration: generation, }, @@ -2870,7 +2866,7 @@ func TestCheckAndUpdateStaleBindingsStatus(t *testing.T) { }, latestBindings[2], }, - wantBindings: []fleetv1beta1.ClusterResourceBinding{ + wantBindings: []placementv1beta1.ClusterResourceBinding{ *latestBindings[0], *latestBindings[1], *latestBindings[2], @@ -2896,7 +2892,7 @@ func TestCheckAndUpdateStaleBindingsStatus(t *testing.T) { if err := r.checkAndUpdateStaleBindingsStatus(ctx, controller.ConvertCRBArrayToBindingObjs(tt.bindings)); err != nil { t.Fatalf("checkAndUpdateStaleBindingsStatus() got error %v, want no err", err) } - bindingList := &fleetv1beta1.ClusterResourceBindingList{} + bindingList := &placementv1beta1.ClusterResourceBindingList{} if err := fakeClient.List(ctx, bindingList); err != nil { t.Fatalf("checkAndUpdateStaleBindingsStatus List() got error %v, want no err", err) } @@ -2914,40 +2910,40 @@ func TestProcessApplyStrategyUpdates(t *testing.T) { testCases := []struct { name string - crp *fleetv1beta1.ClusterResourcePlacement - allBindings []*fleetv1beta1.ClusterResourceBinding - wantAllBindings []*fleetv1beta1.ClusterResourceBinding + crp *placementv1beta1.ClusterResourcePlacement + allBindings []*placementv1beta1.ClusterResourceBinding + wantAllBindings []*placementv1beta1.ClusterResourceBinding wantApplyStrategyUpdated bool }{ { name: "nil apply strategy", - crp: &fleetv1beta1.ClusterResourcePlacement{ + crp: &placementv1beta1.ClusterResourcePlacement{ ObjectMeta: metav1.ObjectMeta{ Name: crpName, }, - Spec: fleetv1beta1.PlacementSpec{ - Strategy: fleetv1beta1.RolloutStrategy{}, + Spec: placementv1beta1.PlacementSpec{ + Strategy: placementv1beta1.RolloutStrategy{}, }, }, - allBindings: []*fleetv1beta1.ClusterResourceBinding{ + allBindings: []*placementv1beta1.ClusterResourceBinding{ { ObjectMeta: metav1.ObjectMeta{ Name: "binding-1", }, - Spec: fleetv1beta1.ResourceBindingSpec{}, + Spec: placementv1beta1.ResourceBindingSpec{}, }, }, - wantAllBindings: []*fleetv1beta1.ClusterResourceBinding{ + wantAllBindings: []*placementv1beta1.ClusterResourceBinding{ { ObjectMeta: metav1.ObjectMeta{ Name: "binding-1", }, - Spec: fleetv1beta1.ResourceBindingSpec{ - ApplyStrategy: &fleetv1beta1.ApplyStrategy{ - Type: fleetv1beta1.ApplyStrategyTypeClientSideApply, - ComparisonOption: fleetv1beta1.ComparisonOptionTypePartialComparison, - WhenToApply: fleetv1beta1.WhenToApplyTypeAlways, - WhenToTakeOver: fleetv1beta1.WhenToTakeOverTypeAlways, + Spec: placementv1beta1.ResourceBindingSpec{ + ApplyStrategy: &placementv1beta1.ApplyStrategy{ + Type: placementv1beta1.ApplyStrategyTypeClientSideApply, + ComparisonOption: placementv1beta1.ComparisonOptionTypePartialComparison, + WhenToApply: placementv1beta1.WhenToApplyTypeAlways, + WhenToTakeOver: placementv1beta1.WhenToTakeOverTypeAlways, }, }, }, @@ -2956,22 +2952,22 @@ func TestProcessApplyStrategyUpdates(t *testing.T) { }, { name: "push apply strategy to bindings of various states", - crp: &fleetv1beta1.ClusterResourcePlacement{ + crp: &placementv1beta1.ClusterResourcePlacement{ ObjectMeta: metav1.ObjectMeta{ Name: crpName, }, - Spec: fleetv1beta1.PlacementSpec{ - Strategy: fleetv1beta1.RolloutStrategy{ - ApplyStrategy: &fleetv1beta1.ApplyStrategy{ - Type: fleetv1beta1.ApplyStrategyTypeServerSideApply, - ComparisonOption: fleetv1beta1.ComparisonOptionTypeFullComparison, - WhenToApply: fleetv1beta1.WhenToApplyTypeIfNotDrifted, - WhenToTakeOver: fleetv1beta1.WhenToTakeOverTypeIfNoDiff, + Spec: placementv1beta1.PlacementSpec{ + Strategy: placementv1beta1.RolloutStrategy{ + ApplyStrategy: &placementv1beta1.ApplyStrategy{ + Type: placementv1beta1.ApplyStrategyTypeServerSideApply, + ComparisonOption: placementv1beta1.ComparisonOptionTypeFullComparison, + WhenToApply: placementv1beta1.WhenToApplyTypeIfNotDrifted, + WhenToTakeOver: placementv1beta1.WhenToTakeOverTypeIfNoDiff, }, }, }, }, - allBindings: []*fleetv1beta1.ClusterResourceBinding{ + allBindings: []*placementv1beta1.ClusterResourceBinding{ // A binding that has been marked for deletion. { ObjectMeta: metav1.ObjectMeta{ @@ -2983,20 +2979,20 @@ func TestProcessApplyStrategyUpdates(t *testing.T) { "custom-deletion-blocker", }, }, - Spec: fleetv1beta1.ResourceBindingSpec{}, + Spec: placementv1beta1.ResourceBindingSpec{}, }, // A binding that already has the latest apply strategy. { ObjectMeta: metav1.ObjectMeta{ Name: "binding-2", }, - Spec: fleetv1beta1.ResourceBindingSpec{ + Spec: placementv1beta1.ResourceBindingSpec{ ResourceSnapshotName: "snapshot-2", - ApplyStrategy: &fleetv1beta1.ApplyStrategy{ - Type: fleetv1beta1.ApplyStrategyTypeServerSideApply, - ComparisonOption: fleetv1beta1.ComparisonOptionTypeFullComparison, - WhenToApply: fleetv1beta1.WhenToApplyTypeIfNotDrifted, - WhenToTakeOver: fleetv1beta1.WhenToTakeOverTypeIfNoDiff, + ApplyStrategy: &placementv1beta1.ApplyStrategy{ + Type: placementv1beta1.ApplyStrategyTypeServerSideApply, + ComparisonOption: placementv1beta1.ComparisonOptionTypeFullComparison, + WhenToApply: placementv1beta1.WhenToApplyTypeIfNotDrifted, + WhenToTakeOver: placementv1beta1.WhenToTakeOverTypeIfNoDiff, }, }, }, @@ -3005,18 +3001,18 @@ func TestProcessApplyStrategyUpdates(t *testing.T) { ObjectMeta: metav1.ObjectMeta{ Name: "binding-3", }, - Spec: fleetv1beta1.ResourceBindingSpec{ + Spec: placementv1beta1.ResourceBindingSpec{ ResourceSnapshotName: "snapshot-1", - ApplyStrategy: &fleetv1beta1.ApplyStrategy{ - Type: fleetv1beta1.ApplyStrategyTypeClientSideApply, - ComparisonOption: fleetv1beta1.ComparisonOptionTypePartialComparison, - WhenToApply: fleetv1beta1.WhenToApplyTypeAlways, - WhenToTakeOver: fleetv1beta1.WhenToTakeOverTypeAlways, + ApplyStrategy: &placementv1beta1.ApplyStrategy{ + Type: placementv1beta1.ApplyStrategyTypeClientSideApply, + ComparisonOption: placementv1beta1.ComparisonOptionTypePartialComparison, + WhenToApply: placementv1beta1.WhenToApplyTypeAlways, + WhenToTakeOver: placementv1beta1.WhenToTakeOverTypeAlways, }, }, }, }, - wantAllBindings: []*fleetv1beta1.ClusterResourceBinding{ + wantAllBindings: []*placementv1beta1.ClusterResourceBinding{ // Binding that has been marked for deletion should not be updated. { ObjectMeta: metav1.ObjectMeta{ @@ -3026,20 +3022,20 @@ func TestProcessApplyStrategyUpdates(t *testing.T) { "custom-deletion-blocker", }, }, - Spec: fleetv1beta1.ResourceBindingSpec{}, + Spec: placementv1beta1.ResourceBindingSpec{}, }, // Binding that already has the latest apply strategy should not be updated. { ObjectMeta: metav1.ObjectMeta{ Name: "binding-2", }, - Spec: fleetv1beta1.ResourceBindingSpec{ + Spec: placementv1beta1.ResourceBindingSpec{ ResourceSnapshotName: "snapshot-2", - ApplyStrategy: &fleetv1beta1.ApplyStrategy{ - Type: fleetv1beta1.ApplyStrategyTypeServerSideApply, - ComparisonOption: fleetv1beta1.ComparisonOptionTypeFullComparison, - WhenToApply: fleetv1beta1.WhenToApplyTypeIfNotDrifted, - WhenToTakeOver: fleetv1beta1.WhenToTakeOverTypeIfNoDiff, + ApplyStrategy: &placementv1beta1.ApplyStrategy{ + Type: placementv1beta1.ApplyStrategyTypeServerSideApply, + ComparisonOption: placementv1beta1.ComparisonOptionTypeFullComparison, + WhenToApply: placementv1beta1.WhenToApplyTypeIfNotDrifted, + WhenToTakeOver: placementv1beta1.WhenToTakeOverTypeIfNoDiff, }, }, }, @@ -3048,13 +3044,13 @@ func TestProcessApplyStrategyUpdates(t *testing.T) { ObjectMeta: metav1.ObjectMeta{ Name: "binding-3", }, - Spec: fleetv1beta1.ResourceBindingSpec{ + Spec: placementv1beta1.ResourceBindingSpec{ ResourceSnapshotName: "snapshot-1", - ApplyStrategy: &fleetv1beta1.ApplyStrategy{ - Type: fleetv1beta1.ApplyStrategyTypeServerSideApply, - ComparisonOption: fleetv1beta1.ComparisonOptionTypeFullComparison, - WhenToApply: fleetv1beta1.WhenToApplyTypeIfNotDrifted, - WhenToTakeOver: fleetv1beta1.WhenToTakeOverTypeIfNoDiff, + ApplyStrategy: &placementv1beta1.ApplyStrategy{ + Type: placementv1beta1.ApplyStrategyTypeServerSideApply, + ComparisonOption: placementv1beta1.ComparisonOptionTypeFullComparison, + WhenToApply: placementv1beta1.WhenToApplyTypeIfNotDrifted, + WhenToTakeOver: placementv1beta1.WhenToTakeOverTypeIfNoDiff, }, }, }, @@ -3063,22 +3059,22 @@ func TestProcessApplyStrategyUpdates(t *testing.T) { }, { name: "no apply strategy update needed", - crp: &fleetv1beta1.ClusterResourcePlacement{ + crp: &placementv1beta1.ClusterResourcePlacement{ ObjectMeta: metav1.ObjectMeta{ Name: crpName, }, - Spec: fleetv1beta1.PlacementSpec{ - Strategy: fleetv1beta1.RolloutStrategy{ - ApplyStrategy: &fleetv1beta1.ApplyStrategy{ - Type: fleetv1beta1.ApplyStrategyTypeClientSideApply, - ComparisonOption: fleetv1beta1.ComparisonOptionTypePartialComparison, - WhenToApply: fleetv1beta1.WhenToApplyTypeIfNotDrifted, - WhenToTakeOver: fleetv1beta1.WhenToTakeOverTypeIfNoDiff, + Spec: placementv1beta1.PlacementSpec{ + Strategy: placementv1beta1.RolloutStrategy{ + ApplyStrategy: &placementv1beta1.ApplyStrategy{ + Type: placementv1beta1.ApplyStrategyTypeClientSideApply, + ComparisonOption: placementv1beta1.ComparisonOptionTypePartialComparison, + WhenToApply: placementv1beta1.WhenToApplyTypeIfNotDrifted, + WhenToTakeOver: placementv1beta1.WhenToTakeOverTypeIfNoDiff, }, }, }, }, - allBindings: []*fleetv1beta1.ClusterResourceBinding{ + allBindings: []*placementv1beta1.ClusterResourceBinding{ // A binding that has been marked for deletion. { ObjectMeta: metav1.ObjectMeta{ @@ -3090,12 +3086,12 @@ func TestProcessApplyStrategyUpdates(t *testing.T) { "custom-deletion-blocker", }, }, - Spec: fleetv1beta1.ResourceBindingSpec{ - ApplyStrategy: &fleetv1beta1.ApplyStrategy{ - Type: fleetv1beta1.ApplyStrategyTypeClientSideApply, - ComparisonOption: fleetv1beta1.ComparisonOptionTypePartialComparison, - WhenToApply: fleetv1beta1.WhenToApplyTypeIfNotDrifted, - WhenToTakeOver: fleetv1beta1.WhenToTakeOverTypeIfNoDiff, + Spec: placementv1beta1.ResourceBindingSpec{ + ApplyStrategy: &placementv1beta1.ApplyStrategy{ + Type: placementv1beta1.ApplyStrategyTypeClientSideApply, + ComparisonOption: placementv1beta1.ComparisonOptionTypePartialComparison, + WhenToApply: placementv1beta1.WhenToApplyTypeIfNotDrifted, + WhenToTakeOver: placementv1beta1.WhenToTakeOverTypeIfNoDiff, }, }, }, @@ -3104,18 +3100,18 @@ func TestProcessApplyStrategyUpdates(t *testing.T) { ObjectMeta: metav1.ObjectMeta{ Name: "binding-2", }, - Spec: fleetv1beta1.ResourceBindingSpec{ + Spec: placementv1beta1.ResourceBindingSpec{ ResourceSnapshotName: "snapshot-2", - ApplyStrategy: &fleetv1beta1.ApplyStrategy{ - Type: fleetv1beta1.ApplyStrategyTypeClientSideApply, - ComparisonOption: fleetv1beta1.ComparisonOptionTypePartialComparison, - WhenToApply: fleetv1beta1.WhenToApplyTypeIfNotDrifted, - WhenToTakeOver: fleetv1beta1.WhenToTakeOverTypeIfNoDiff, + ApplyStrategy: &placementv1beta1.ApplyStrategy{ + Type: placementv1beta1.ApplyStrategyTypeClientSideApply, + ComparisonOption: placementv1beta1.ComparisonOptionTypePartialComparison, + WhenToApply: placementv1beta1.WhenToApplyTypeIfNotDrifted, + WhenToTakeOver: placementv1beta1.WhenToTakeOverTypeIfNoDiff, }, }, }, }, - wantAllBindings: []*fleetv1beta1.ClusterResourceBinding{ + wantAllBindings: []*placementv1beta1.ClusterResourceBinding{ // Binding that has been marked for deletion should not be updated. { ObjectMeta: metav1.ObjectMeta{ @@ -3125,12 +3121,12 @@ func TestProcessApplyStrategyUpdates(t *testing.T) { "custom-deletion-blocker", }, }, - Spec: fleetv1beta1.ResourceBindingSpec{ - ApplyStrategy: &fleetv1beta1.ApplyStrategy{ - Type: fleetv1beta1.ApplyStrategyTypeClientSideApply, - ComparisonOption: fleetv1beta1.ComparisonOptionTypePartialComparison, - WhenToApply: fleetv1beta1.WhenToApplyTypeIfNotDrifted, - WhenToTakeOver: fleetv1beta1.WhenToTakeOverTypeIfNoDiff, + Spec: placementv1beta1.ResourceBindingSpec{ + ApplyStrategy: &placementv1beta1.ApplyStrategy{ + Type: placementv1beta1.ApplyStrategyTypeClientSideApply, + ComparisonOption: placementv1beta1.ComparisonOptionTypePartialComparison, + WhenToApply: placementv1beta1.WhenToApplyTypeIfNotDrifted, + WhenToTakeOver: placementv1beta1.WhenToTakeOverTypeIfNoDiff, }, }, }, @@ -3139,13 +3135,13 @@ func TestProcessApplyStrategyUpdates(t *testing.T) { ObjectMeta: metav1.ObjectMeta{ Name: "binding-2", }, - Spec: fleetv1beta1.ResourceBindingSpec{ + Spec: placementv1beta1.ResourceBindingSpec{ ResourceSnapshotName: "snapshot-2", - ApplyStrategy: &fleetv1beta1.ApplyStrategy{ - Type: fleetv1beta1.ApplyStrategyTypeClientSideApply, - ComparisonOption: fleetv1beta1.ComparisonOptionTypePartialComparison, - WhenToApply: fleetv1beta1.WhenToApplyTypeIfNotDrifted, - WhenToTakeOver: fleetv1beta1.WhenToTakeOverTypeIfNoDiff, + ApplyStrategy: &placementv1beta1.ApplyStrategy{ + Type: placementv1beta1.ApplyStrategyTypeClientSideApply, + ComparisonOption: placementv1beta1.ComparisonOptionTypePartialComparison, + WhenToApply: placementv1beta1.WhenToApplyTypeIfNotDrifted, + WhenToTakeOver: placementv1beta1.WhenToTakeOverTypeIfNoDiff, }, }, }, @@ -3180,7 +3176,7 @@ func TestProcessApplyStrategyUpdates(t *testing.T) { for idx := range tc.wantAllBindings { wantBinding := tc.wantAllBindings[idx] - gotBinding := &fleetv1beta1.ClusterResourceBinding{} + gotBinding := &placementv1beta1.ClusterResourceBinding{} if err := fakeClient.Get(ctx, client.ObjectKey{Name: wantBinding.Name}, gotBinding); err != nil { t.Fatalf("failed to retrieve binding: %v", err) } diff --git a/pkg/controllers/rollout/suite_test.go b/pkg/controllers/rollout/suite_test.go index 99b37ea92..0aa6f6a71 100644 --- a/pkg/controllers/rollout/suite_test.go +++ b/pkg/controllers/rollout/suite_test.go @@ -38,8 +38,8 @@ import ( metricsserver "sigs.k8s.io/controller-runtime/pkg/metrics/server" clusterv1beta1 "go.goms.io/fleet/apis/cluster/v1beta1" - fleetv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" - fleetv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" + placementv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" + placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" ) var ( @@ -83,9 +83,9 @@ var _ = BeforeSuite(func() { //+kubebuilder:scaffold:scheme By("Set all the customized scheme") - Expect(fleetv1beta1.AddToScheme(scheme.Scheme)).Should(Succeed()) + Expect(placementv1beta1.AddToScheme(scheme.Scheme)).Should(Succeed()) Expect(clusterv1beta1.AddToScheme(scheme.Scheme)).Should(Succeed()) - Expect(fleetv1alpha1.AddToScheme(scheme.Scheme)).Should(Succeed()) + Expect(placementv1alpha1.AddToScheme(scheme.Scheme)).Should(Succeed()) By("starting the controller manager") klog.InitFlags(flag.CommandLine) diff --git a/pkg/controllers/updaterun/controller_integration_test.go b/pkg/controllers/updaterun/controller_integration_test.go index d70ca7faf..483a0c787 100644 --- a/pkg/controllers/updaterun/controller_integration_test.go +++ b/pkg/controllers/updaterun/controller_integration_test.go @@ -42,7 +42,6 @@ import ( ctrlmetrics "sigs.k8s.io/controller-runtime/pkg/metrics" clusterv1beta1 "go.goms.io/fleet/apis/cluster/v1beta1" - placementv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" "go.goms.io/fleet/pkg/utils" "go.goms.io/fleet/pkg/utils/condition" @@ -592,16 +591,16 @@ func generateTestClusterResourceSnapshot() *placementv1beta1.ClusterResourceSnap return clusterResourceSnapshot } -func generateTestClusterResourceOverride() *placementv1alpha1.ClusterResourceOverrideSnapshot { - return &placementv1alpha1.ClusterResourceOverrideSnapshot{ +func generateTestClusterResourceOverride() *placementv1beta1.ClusterResourceOverrideSnapshot { + return &placementv1beta1.ClusterResourceOverrideSnapshot{ ObjectMeta: metav1.ObjectMeta{ Name: testCROName, Labels: map[string]string{ placementv1beta1.IsLatestSnapshotLabel: strconv.FormatBool(true), }, }, - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "", @@ -610,8 +609,8 @@ func generateTestClusterResourceOverride() *placementv1alpha1.ClusterResourceOve Name: "test-namespace", }, }, - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -624,9 +623,9 @@ func generateTestClusterResourceOverride() *placementv1alpha1.ClusterResourceOve }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/labels/test", Value: apiextensionsv1.JSON{Raw: []byte(`"test"`)}, }, diff --git a/pkg/controllers/updaterun/execution_integration_test.go b/pkg/controllers/updaterun/execution_integration_test.go index df7297cf0..6b1dd5d7b 100644 --- a/pkg/controllers/updaterun/execution_integration_test.go +++ b/pkg/controllers/updaterun/execution_integration_test.go @@ -30,7 +30,6 @@ import ( "k8s.io/apimachinery/pkg/types" clusterv1beta1 "go.goms.io/fleet/apis/cluster/v1beta1" - placementv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" "go.goms.io/fleet/pkg/utils" "go.goms.io/fleet/pkg/utils/condition" @@ -45,7 +44,7 @@ var _ = Describe("UpdateRun execution tests - double stages", func() { var targetClusters []*clusterv1beta1.MemberCluster var unscheduledClusters []*clusterv1beta1.MemberCluster var resourceSnapshot *placementv1beta1.ClusterResourceSnapshot - var clusterResourceOverride *placementv1alpha1.ClusterResourceOverrideSnapshot + var clusterResourceOverride *placementv1beta1.ClusterResourceOverrideSnapshot var wantStatus *placementv1beta1.StagedUpdateRunStatus var numTargetClusters int var numUnscheduledClusters int diff --git a/pkg/controllers/updaterun/initialization_integration_test.go b/pkg/controllers/updaterun/initialization_integration_test.go index a7ab0a063..223de49a1 100644 --- a/pkg/controllers/updaterun/initialization_integration_test.go +++ b/pkg/controllers/updaterun/initialization_integration_test.go @@ -32,7 +32,6 @@ import ( "k8s.io/apimachinery/pkg/types" clusterv1beta1 "go.goms.io/fleet/apis/cluster/v1beta1" - placementv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" "go.goms.io/fleet/pkg/utils" ) @@ -59,7 +58,7 @@ var _ = Describe("Updaterun initialization tests", func() { var targetClusters []*clusterv1beta1.MemberCluster var unscheduledClusters []*clusterv1beta1.MemberCluster var resourceSnapshot *placementv1beta1.ClusterResourceSnapshot - var clusterResourceOverride *placementv1alpha1.ClusterResourceOverrideSnapshot + var clusterResourceOverride *placementv1beta1.ClusterResourceOverrideSnapshot BeforeEach(func() { testUpdateRunName = "updaterun-" + utils.RandStr() @@ -835,7 +834,7 @@ func generateSucceededInitializationStatus( updateRun *placementv1beta1.ClusterStagedUpdateRun, policySnapshot *placementv1beta1.ClusterSchedulingPolicySnapshot, updateStrategy *placementv1beta1.ClusterStagedUpdateStrategy, - clusterResourceOverride *placementv1alpha1.ClusterResourceOverrideSnapshot, + clusterResourceOverride *placementv1beta1.ClusterResourceOverrideSnapshot, ) *placementv1beta1.StagedUpdateRunStatus { status := &placementv1beta1.StagedUpdateRunStatus{ PolicySnapshotIndexUsed: policySnapshot.Labels[placementv1beta1.PolicyIndexLabel], diff --git a/pkg/controllers/updaterun/validation_integration_test.go b/pkg/controllers/updaterun/validation_integration_test.go index 5d498e8da..38846cad7 100644 --- a/pkg/controllers/updaterun/validation_integration_test.go +++ b/pkg/controllers/updaterun/validation_integration_test.go @@ -31,7 +31,6 @@ import ( "k8s.io/apimachinery/pkg/types" clusterv1beta1 "go.goms.io/fleet/apis/cluster/v1beta1" - placementv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" "go.goms.io/fleet/pkg/utils" ) @@ -45,7 +44,7 @@ var _ = Describe("UpdateRun validation tests", func() { var targetClusters []*clusterv1beta1.MemberCluster var unscheduledClusters []*clusterv1beta1.MemberCluster var resourceSnapshot *placementv1beta1.ClusterResourceSnapshot - var clusterResourceOverride *placementv1alpha1.ClusterResourceOverrideSnapshot + var clusterResourceOverride *placementv1beta1.ClusterResourceOverrideSnapshot var wantStatus *placementv1beta1.StagedUpdateRunStatus BeforeEach(func() { diff --git a/pkg/controllers/workgenerator/controller_integration_test.go b/pkg/controllers/workgenerator/controller_integration_test.go index 3b943b9d8..f8b81fab2 100644 --- a/pkg/controllers/workgenerator/controller_integration_test.go +++ b/pkg/controllers/workgenerator/controller_integration_test.go @@ -38,7 +38,6 @@ import ( "sigs.k8s.io/controller-runtime/pkg/client" clusterv1beta1 "go.goms.io/fleet/apis/cluster/v1beta1" - placementv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" "go.goms.io/fleet/pkg/controllers/workapplier" "go.goms.io/fleet/pkg/utils" @@ -57,9 +56,9 @@ var ( validResourceOverrideSnapshotName = "ro-1" invalidClusterResourceOverrideSnapshotName = "cro-2" // the overridden manifest is invalid - validClusterResourceOverrideSnapshot placementv1alpha1.ClusterResourceOverrideSnapshot - validResourceOverrideSnapshot placementv1alpha1.ResourceOverrideSnapshot - invalidClusterResourceOverrideSnapshot placementv1alpha1.ClusterResourceOverrideSnapshot + validClusterResourceOverrideSnapshot placementv1beta1.ClusterResourceOverrideSnapshot + validResourceOverrideSnapshot placementv1beta1.ResourceOverrideSnapshot + invalidClusterResourceOverrideSnapshot placementv1beta1.ClusterResourceOverrideSnapshot bindingStatusCmpOpts = cmp.Options{ cmpopts.SortSlices(utils.LessFuncConditionByType), diff --git a/pkg/controllers/workgenerator/override.go b/pkg/controllers/workgenerator/override.go index 4b2f47a0e..5c6ecb339 100644 --- a/pkg/controllers/workgenerator/override.go +++ b/pkg/controllers/workgenerator/override.go @@ -29,7 +29,6 @@ import ( "k8s.io/klog/v2" clusterv1beta1 "go.goms.io/fleet/apis/cluster/v1beta1" - placementv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" "go.goms.io/fleet/pkg/utils" "go.goms.io/fleet/pkg/utils/controller" @@ -37,13 +36,13 @@ import ( ) // TODO: combine the following two functions into one, as they are very similar. -func (r *Reconciler) fetchClusterResourceOverrideSnapshots(ctx context.Context, resourceBinding placementv1beta1.BindingObj) (map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ClusterResourceOverrideSnapshot, error) { - croMap := make(map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ClusterResourceOverrideSnapshot) +func (r *Reconciler) fetchClusterResourceOverrideSnapshots(ctx context.Context, resourceBinding placementv1beta1.BindingObj) (map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ClusterResourceOverrideSnapshot, error) { + croMap := make(map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ClusterResourceOverrideSnapshot) // For now, we get the snapshots sequentially. We can optimize this by getting them in parallel, but we need to reorder // the snapshot lists saved in the map. for _, name := range resourceBinding.GetBindingSpec().ClusterResourceOverrideSnapshots { - snapshot := &placementv1alpha1.ClusterResourceOverrideSnapshot{} + snapshot := &placementv1beta1.ClusterResourceOverrideSnapshot{} if err := r.Client.Get(ctx, types.NamespacedName{Name: name}, snapshot); err != nil { if errors.IsNotFound(err) { klog.ErrorS(err, "The clusterResourceOverrideSnapshot is deleted", "binding", klog.KObj(resourceBinding), "clusterResourceOverrideSnapshot", name) @@ -71,13 +70,13 @@ func (r *Reconciler) fetchClusterResourceOverrideSnapshots(ctx context.Context, return croMap, nil } -func (r *Reconciler) fetchResourceOverrideSnapshots(ctx context.Context, resourceBinding placementv1beta1.BindingObj) (map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ResourceOverrideSnapshot, error) { - roMap := make(map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ResourceOverrideSnapshot) +func (r *Reconciler) fetchResourceOverrideSnapshots(ctx context.Context, resourceBinding placementv1beta1.BindingObj) (map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ResourceOverrideSnapshot, error) { + roMap := make(map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ResourceOverrideSnapshot) // For now, we get the snapshots sequentially. We can optimize this by getting them in parallel, but we need to reorder // the snapshot lists saved in the map. for _, namespacedName := range resourceBinding.GetBindingSpec().ResourceOverrideSnapshots { - snapshot := &placementv1alpha1.ResourceOverrideSnapshot{} + snapshot := &placementv1beta1.ResourceOverrideSnapshot{} if err := r.Client.Get(ctx, types.NamespacedName{Name: namespacedName.Name, Namespace: namespacedName.Namespace}, snapshot); err != nil { if errors.IsNotFound(err) { // It could be caused by that the user updates the override too frequently and the snapshot has been replaced @@ -111,7 +110,7 @@ func (r *Reconciler) fetchResourceOverrideSnapshots(ctx context.Context, resourc // - true if the resource is deleted by the overrides. // - an error if the override rules are invalid. func (r *Reconciler) applyOverrides(resource *placementv1beta1.ResourceContent, cluster *clusterv1beta1.MemberCluster, - croMap map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ClusterResourceOverrideSnapshot, roMap map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ResourceOverrideSnapshot) (bool, error) { + croMap map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ClusterResourceOverrideSnapshot, roMap map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ResourceOverrideSnapshot) (bool, error) { if len(croMap) == 0 && len(roMap) == 0 { return false, nil } @@ -181,7 +180,7 @@ func (r *Reconciler) applyOverrides(resource *placementv1beta1.ResourceContent, return resource.Raw == nil, nil } -func applyOverrideRules(resource *placementv1beta1.ResourceContent, cluster *clusterv1beta1.MemberCluster, rules []placementv1alpha1.OverrideRule) error { +func applyOverrideRules(resource *placementv1beta1.ResourceContent, cluster *clusterv1beta1.MemberCluster, rules []placementv1beta1.OverrideRule) error { for _, rule := range rules { matched, err := overrider.IsClusterMatched(cluster, rule) if err != nil { @@ -191,7 +190,7 @@ func applyOverrideRules(resource *placementv1beta1.ResourceContent, cluster *clu if !matched { continue } - if rule.OverrideType == placementv1alpha1.DeleteOverrideType { + if rule.OverrideType == placementv1beta1.DeleteOverrideType { // Delete the resource resource.Raw = nil return nil @@ -206,7 +205,7 @@ func applyOverrideRules(resource *placementv1beta1.ResourceContent, cluster *clu } // applyJSONPatchOverride applies a JSON patch on the selected resources following [RFC 6902](https://datatracker.ietf.org/doc/html/rfc6902). -func applyJSONPatchOverride(resourceContent *placementv1beta1.ResourceContent, cluster *clusterv1beta1.MemberCluster, overrides []placementv1alpha1.JSONPatchOverride) error { +func applyJSONPatchOverride(resourceContent *placementv1beta1.ResourceContent, cluster *clusterv1beta1.MemberCluster, overrides []placementv1beta1.JSONPatchOverride) error { var err error if len(overrides) == 0 { // do nothing return nil @@ -217,7 +216,7 @@ func applyJSONPatchOverride(resourceContent *placementv1beta1.ResourceContent, c // Process the JSON string to replace variables jsonStr := string(overrides[i].Value.Raw) // Replace the built-in ${MEMBER-CLUSTER-NAME} variable with the actual cluster name - jsonStr = strings.ReplaceAll(jsonStr, placementv1alpha1.OverrideClusterNameVariable, cluster.Name) + jsonStr = strings.ReplaceAll(jsonStr, placementv1beta1.OverrideClusterNameVariable, cluster.Name) // Replace label key variables with actual label values jsonStr, err = replaceClusterLabelKeyVariables(jsonStr, cluster) if err != nil { @@ -253,11 +252,11 @@ func applyJSONPatchOverride(resourceContent *placementv1beta1.ResourceContent, c // the corresponding label values from the cluster. // If a label with the specified key doesn't exist, it returns an error. func replaceClusterLabelKeyVariables(input string, cluster *clusterv1beta1.MemberCluster) (string, error) { - prefixLen := len(placementv1alpha1.OverrideClusterLabelKeyVariablePrefix) + prefixLen := len(placementv1beta1.OverrideClusterLabelKeyVariablePrefix) result := input for { - startIdx := strings.Index(result, placementv1alpha1.OverrideClusterLabelKeyVariablePrefix) + startIdx := strings.Index(result, placementv1beta1.OverrideClusterLabelKeyVariablePrefix) if startIdx == -1 { break } diff --git a/pkg/controllers/workgenerator/override_test.go b/pkg/controllers/workgenerator/override_test.go index 600ffa727..79e8c79a2 100644 --- a/pkg/controllers/workgenerator/override_test.go +++ b/pkg/controllers/workgenerator/override_test.go @@ -35,7 +35,6 @@ import ( "sigs.k8s.io/controller-runtime/pkg/client/fake" clusterv1beta1 "go.goms.io/fleet/apis/cluster/v1beta1" - placementv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" "go.goms.io/fleet/pkg/utils" "go.goms.io/fleet/pkg/utils/controller" @@ -45,9 +44,6 @@ import ( func serviceScheme(t *testing.T) *runtime.Scheme { scheme := runtime.NewScheme() - if err := placementv1alpha1.AddToScheme(scheme); err != nil { - t.Fatalf("Failed to add v1alpha1 scheme: %v", err) - } if err := placementv1beta1.AddToScheme(scheme); err != nil { t.Fatalf("Failed to add v1beta1 scheme: %v", err) } @@ -55,7 +51,7 @@ func serviceScheme(t *testing.T) *runtime.Scheme { } func TestFetchClusterResourceOverrideSnapshot(t *testing.T) { - snapshots := []placementv1alpha1.ClusterResourceOverrideSnapshot{ + snapshots := []placementv1beta1.ClusterResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "cro-1", @@ -63,8 +59,8 @@ func TestFetchClusterResourceOverrideSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "rbac.authorization.k8s.io", @@ -89,8 +85,8 @@ func TestFetchClusterResourceOverrideSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "rbac.authorization.k8s.io", @@ -113,7 +109,7 @@ func TestFetchClusterResourceOverrideSnapshot(t *testing.T) { tests := []struct { name string snapshotNames []string - want map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ClusterResourceOverrideSnapshot + want map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ClusterResourceOverrideSnapshot wantErr error }{ { @@ -126,19 +122,19 @@ func TestFetchClusterResourceOverrideSnapshot(t *testing.T) { { name: "nil overrides in the binding", snapshotNames: nil, - want: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ClusterResourceOverrideSnapshot{}, + want: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ClusterResourceOverrideSnapshot{}, }, { name: "empty overrides in the binding", snapshotNames: []string{}, - want: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ClusterResourceOverrideSnapshot{}, + want: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ClusterResourceOverrideSnapshot{}, }, { name: "single override in the binding", snapshotNames: []string{ "cro-1", }, - want: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ClusterResourceOverrideSnapshot{ + want: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ClusterResourceOverrideSnapshot{ { Group: "rbac.authorization.k8s.io", Version: "v1", @@ -163,7 +159,7 @@ func TestFetchClusterResourceOverrideSnapshot(t *testing.T) { "cro-1", "cro-2", }, - want: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ClusterResourceOverrideSnapshot{ + want: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ClusterResourceOverrideSnapshot{ { Group: "rbac.authorization.k8s.io", Version: "v1", @@ -217,7 +213,7 @@ func TestFetchClusterResourceOverrideSnapshot(t *testing.T) { if gotErr, wantErr := err != nil, tc.wantErr != nil; gotErr != wantErr || !errors.Is(err, tc.wantErr) { t.Fatalf("fetchClusterResourceOverrideSnapshots() got error %v, want error %v", err, tc.wantErr) } - if diff := cmp.Diff(tc.want, got, cmpopts.IgnoreFields(placementv1alpha1.ClusterResourceOverrideSnapshot{}, "TypeMeta")); diff != "" { + if diff := cmp.Diff(tc.want, got, cmpopts.IgnoreFields(placementv1beta1.ClusterResourceOverrideSnapshot{}, "TypeMeta")); diff != "" { t.Errorf("fetchClusterResourceOverrideSnapshots() returned mismatch (-want, +got):\n%s", diff) } }) @@ -225,7 +221,7 @@ func TestFetchClusterResourceOverrideSnapshot(t *testing.T) { } func TestFetchResourceOverrideSnapshot(t *testing.T) { - snapshots := []placementv1alpha1.ResourceOverrideSnapshot{ + snapshots := []placementv1beta1.ResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "ro-1", @@ -234,9 +230,9 @@ func TestFetchResourceOverrideSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []placementv1alpha1.ResourceSelector{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "", Version: "v1", @@ -261,9 +257,9 @@ func TestFetchResourceOverrideSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []placementv1alpha1.ResourceSelector{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "", Version: "v1", @@ -282,9 +278,9 @@ func TestFetchResourceOverrideSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []placementv1alpha1.ResourceSelector{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "", Version: "v1", @@ -300,7 +296,7 @@ func TestFetchResourceOverrideSnapshot(t *testing.T) { tests := []struct { name string snapshotNames []placementv1beta1.NamespacedName - want map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ResourceOverrideSnapshot + want map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ResourceOverrideSnapshot wantErr error }{ { @@ -315,12 +311,12 @@ func TestFetchResourceOverrideSnapshot(t *testing.T) { { name: "nil overrides in the binding", snapshotNames: nil, - want: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ResourceOverrideSnapshot{}, + want: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ResourceOverrideSnapshot{}, }, { name: "empty overrides in the binding", snapshotNames: []placementv1beta1.NamespacedName{}, - want: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ResourceOverrideSnapshot{}, + want: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ResourceOverrideSnapshot{}, }, { name: "single override in the binding", @@ -330,7 +326,7 @@ func TestFetchResourceOverrideSnapshot(t *testing.T) { Namespace: "svc-namespace", }, }, - want: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ResourceOverrideSnapshot{ + want: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ResourceOverrideSnapshot{ { Group: "", Version: "v1", @@ -367,7 +363,7 @@ func TestFetchResourceOverrideSnapshot(t *testing.T) { Namespace: "svc-namespace", }, }, - want: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ResourceOverrideSnapshot{ + want: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ResourceOverrideSnapshot{ { Group: "", Version: "v1", @@ -424,7 +420,7 @@ func TestFetchResourceOverrideSnapshot(t *testing.T) { if gotErr, wantErr := err != nil, tc.wantErr != nil; gotErr != wantErr || !errors.Is(err, tc.wantErr) { t.Fatalf("fetchResourceOverrideSnapshots() got error %v, want error %v", err, tc.wantErr) } - if diff := cmp.Diff(tc.want, got, cmpopts.IgnoreFields(placementv1alpha1.ResourceOverrideSnapshot{}, "TypeMeta")); diff != "" { + if diff := cmp.Diff(tc.want, got, cmpopts.IgnoreFields(placementv1beta1.ResourceOverrideSnapshot{}, "TypeMeta")); diff != "" { t.Errorf("fetchResourceOverrideSnapshots() returned mismatch (-want, +got):\n%s", diff) } }) @@ -451,7 +447,7 @@ func TestApplyOverrides_clusterScopedResource(t *testing.T) { name string clusterRole rbacv1.ClusterRole cluster clusterv1beta1.MemberCluster - croMap map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ClusterResourceOverrideSnapshot + croMap map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ClusterResourceOverrideSnapshot wantClusterRole rbacv1.ClusterRole wantErr error wantDeleted bool @@ -464,7 +460,7 @@ func TestApplyOverrides_clusterScopedResource(t *testing.T) { Name: "clusterrole-name", }, }, - croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ClusterResourceOverrideSnapshot{}, + croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ClusterResourceOverrideSnapshot{}, wantClusterRole: rbacv1.ClusterRole{ TypeMeta: clusterRoleType, ObjectMeta: metav1.ObjectMeta{ @@ -483,7 +479,7 @@ func TestApplyOverrides_clusterScopedResource(t *testing.T) { }, }, }, - croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ClusterResourceOverrideSnapshot{ + croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ClusterResourceOverrideSnapshot{ { Group: "rbac.authorization.k8s.io", Version: "v1", @@ -491,10 +487,10 @@ func TestApplyOverrides_clusterScopedResource(t *testing.T) { Name: "not-found", }: { { - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -507,9 +503,9 @@ func TestApplyOverrides_clusterScopedResource(t *testing.T) { }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/labels/new-label", Value: apiextensionsv1.JSON{Raw: []byte(`"new-value"`)}, }, @@ -552,7 +548,7 @@ func TestApplyOverrides_clusterScopedResource(t *testing.T) { }, }, }, - croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ClusterResourceOverrideSnapshot{ + croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ClusterResourceOverrideSnapshot{ { Group: "rbac.authorization.k8s.io", Version: "v1", @@ -560,10 +556,10 @@ func TestApplyOverrides_clusterScopedResource(t *testing.T) { Name: "clusterrole-name", }: { { - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { // matching rule ClusterSelector: &placementv1beta1.ClusterSelector{ @@ -577,9 +573,9 @@ func TestApplyOverrides_clusterScopedResource(t *testing.T) { }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/labels/new-label", Value: apiextensionsv1.JSON{Raw: []byte(`"new-value"`)}, }, @@ -598,9 +594,9 @@ func TestApplyOverrides_clusterScopedResource(t *testing.T) { }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/metadata/labels/new-label", Value: apiextensionsv1.JSON{Raw: []byte(`"new-value1"`)}, }, @@ -648,7 +644,7 @@ func TestApplyOverrides_clusterScopedResource(t *testing.T) { }, }, }, - croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ClusterResourceOverrideSnapshot{ + croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ClusterResourceOverrideSnapshot{ { Group: "rbac.authorization.k8s.io", Version: "v1", @@ -656,10 +652,10 @@ func TestApplyOverrides_clusterScopedResource(t *testing.T) { Name: "clusterrole-name", }: { { - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -672,9 +668,9 @@ func TestApplyOverrides_clusterScopedResource(t *testing.T) { }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/rules/0/verbs/1", Value: apiextensionsv1.JSON{Raw: []byte(`"read"`)}, }, @@ -692,9 +688,9 @@ func TestApplyOverrides_clusterScopedResource(t *testing.T) { }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpRemove, + Operator: placementv1beta1.JSONPatchOverrideOpRemove, Path: "/rules/0/verbs/0", }, }, @@ -744,7 +740,7 @@ func TestApplyOverrides_clusterScopedResource(t *testing.T) { }, }, }, - croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ClusterResourceOverrideSnapshot{ + croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ClusterResourceOverrideSnapshot{ { Group: "rbac.authorization.k8s.io", Version: "v1", @@ -752,10 +748,10 @@ func TestApplyOverrides_clusterScopedResource(t *testing.T) { Name: "clusterrole-name", }: { { - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -768,9 +764,9 @@ func TestApplyOverrides_clusterScopedResource(t *testing.T) { }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/rules/0/verbs/1", Value: apiextensionsv1.JSON{Raw: []byte(`"read"`)}, }, @@ -788,9 +784,9 @@ func TestApplyOverrides_clusterScopedResource(t *testing.T) { }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpRemove, + Operator: placementv1beta1.JSONPatchOverrideOpRemove, Path: "/rules/0/verbs/1", }, }, @@ -840,7 +836,7 @@ func TestApplyOverrides_clusterScopedResource(t *testing.T) { }, }, }, - croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ClusterResourceOverrideSnapshot{ + croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ClusterResourceOverrideSnapshot{ { Group: "rbac.authorization.k8s.io", Version: "v1", @@ -848,10 +844,10 @@ func TestApplyOverrides_clusterScopedResource(t *testing.T) { Name: "clusterrole-name", }: { { - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -864,9 +860,9 @@ func TestApplyOverrides_clusterScopedResource(t *testing.T) { }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpRemove, + Operator: placementv1beta1.JSONPatchOverrideOpRemove, Path: "/rules/0/verbs", }, }, @@ -883,9 +879,9 @@ func TestApplyOverrides_clusterScopedResource(t *testing.T) { }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/rules/0/verbs/1", Value: apiextensionsv1.JSON{Raw: []byte(`"read"`)}, }, @@ -917,7 +913,7 @@ func TestApplyOverrides_clusterScopedResource(t *testing.T) { }, }, }, - croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ClusterResourceOverrideSnapshot{ + croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ClusterResourceOverrideSnapshot{ { Group: "rbac.authorization.k8s.io", Version: "v1", @@ -925,10 +921,10 @@ func TestApplyOverrides_clusterScopedResource(t *testing.T) { Name: "clusterrole-name", }: { { - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -941,9 +937,9 @@ func TestApplyOverrides_clusterScopedResource(t *testing.T) { }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/labels/new-label", Value: apiextensionsv1.JSON{Raw: []byte(`"new-value"`)}, }, @@ -975,7 +971,7 @@ func TestApplyOverrides_clusterScopedResource(t *testing.T) { }, }, }, - croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ClusterResourceOverrideSnapshot{ + croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ClusterResourceOverrideSnapshot{ { Group: "rbac.authorization.k8s.io", Version: "v1", @@ -983,10 +979,10 @@ func TestApplyOverrides_clusterScopedResource(t *testing.T) { Name: "clusterrole-name", }: { { - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -999,7 +995,7 @@ func TestApplyOverrides_clusterScopedResource(t *testing.T) { }, }, }, - OverrideType: placementv1alpha1.DeleteOverrideType, + OverrideType: placementv1beta1.DeleteOverrideType, }, { ClusterSelector: &placementv1beta1.ClusterSelector{ @@ -1013,9 +1009,9 @@ func TestApplyOverrides_clusterScopedResource(t *testing.T) { }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/metadata/labels/key1", Value: apiextensionsv1.JSON{Raw: []byte(`"new-value1"`)}, }, @@ -1051,7 +1047,7 @@ func TestApplyOverrides_clusterScopedResource(t *testing.T) { }, }, }, - croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ClusterResourceOverrideSnapshot{ + croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ClusterResourceOverrideSnapshot{ { Group: "rbac.authorization.k8s.io", Version: "v1", @@ -1059,10 +1055,10 @@ func TestApplyOverrides_clusterScopedResource(t *testing.T) { Name: "clusterrole-name", }: { { - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -1075,9 +1071,9 @@ func TestApplyOverrides_clusterScopedResource(t *testing.T) { }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/metadata/labels/key1", Value: apiextensionsv1.JSON{Raw: []byte(`"new-value1"`)}, }, @@ -1095,7 +1091,7 @@ func TestApplyOverrides_clusterScopedResource(t *testing.T) { }, }, }, - OverrideType: placementv1alpha1.DeleteOverrideType, + OverrideType: placementv1beta1.DeleteOverrideType, }, }, }, @@ -1165,8 +1161,8 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { name string deployment appsv1.Deployment cluster clusterv1beta1.MemberCluster - croMap map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ClusterResourceOverrideSnapshot - roMap map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ResourceOverrideSnapshot + croMap map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ClusterResourceOverrideSnapshot + roMap map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ResourceOverrideSnapshot wantDeployment appsv1.Deployment wantErr error wantDelete bool @@ -1188,8 +1184,8 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { Name: "cluster-1", }, }, - croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ClusterResourceOverrideSnapshot{}, - roMap: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ResourceOverrideSnapshot{}, + croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ClusterResourceOverrideSnapshot{}, + roMap: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ResourceOverrideSnapshot{}, wantDeployment: appsv1.Deployment{ TypeMeta: deploymentType, ObjectMeta: metav1.ObjectMeta{ @@ -1218,7 +1214,7 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { Name: "cluster-1", }, }, - croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ClusterResourceOverrideSnapshot{ + croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ClusterResourceOverrideSnapshot{ { Group: utils.NamespaceMetaGVK.Group, Version: utils.NamespaceMetaGVK.Version, @@ -1226,10 +1222,10 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { Name: "invalid-namespace", }: { { - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -1242,10 +1238,10 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { }, }, }, - OverrideType: placementv1alpha1.JSONPatchOverrideType, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + OverrideType: placementv1beta1.JSONPatchOverrideType, + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/labels/new-label", Value: apiextensionsv1.JSON{Raw: []byte(`"new-value"`)}, }, @@ -1258,7 +1254,7 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { }, }, }, - roMap: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ResourceOverrideSnapshot{}, + roMap: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ResourceOverrideSnapshot{}, wantDeployment: appsv1.Deployment{ TypeMeta: deploymentType, ObjectMeta: metav1.ObjectMeta{ @@ -1279,7 +1275,7 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { Namespace: "deployment-namespace", }, }, - croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ClusterResourceOverrideSnapshot{ + croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ClusterResourceOverrideSnapshot{ { Group: utils.NamespaceMetaGVK.Group, Version: utils.NamespaceMetaGVK.Version, @@ -1287,10 +1283,10 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { Name: "invalid-namespace", }: { { - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -1303,10 +1299,10 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { }, }, }, - OverrideType: placementv1alpha1.JSONPatchOverrideType, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + OverrideType: placementv1beta1.JSONPatchOverrideType, + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/labels/new-label", Value: apiextensionsv1.JSON{Raw: []byte(`"new-value"`)}, }, @@ -1319,7 +1315,7 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { }, }, }, - roMap: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ResourceOverrideSnapshot{ + roMap: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ResourceOverrideSnapshot{ { Group: "", Version: "v1", @@ -1328,16 +1324,16 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { Namespace: "deployment-namespace-1", }: { { - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: nil, // matching all the clusters - OverrideType: placementv1alpha1.JSONPatchOverrideType, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + OverrideType: placementv1beta1.JSONPatchOverrideType, + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/metadata/labels/app", Value: apiextensionsv1.JSON{Raw: []byte(`"app3"`)}, }, @@ -1379,7 +1375,7 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { }, }, }, - croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ClusterResourceOverrideSnapshot{ + croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ClusterResourceOverrideSnapshot{ { Group: utils.NamespaceMetaGVK.Group, Version: utils.NamespaceMetaGVK.Version, @@ -1387,10 +1383,10 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { Name: "deployment-namespace", }: { { - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -1403,9 +1399,9 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/labels/new-label", Value: apiextensionsv1.JSON{Raw: []byte(`"new-value"`)}, }, @@ -1423,10 +1419,10 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { }, }, }, - OverrideType: placementv1alpha1.JSONPatchOverrideType, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + OverrideType: placementv1beta1.JSONPatchOverrideType, + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/metadata/labels/new-label", Value: apiextensionsv1.JSON{Raw: []byte(`"new-value1"`)}, }, @@ -1472,7 +1468,7 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { }, }, }, - roMap: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ResourceOverrideSnapshot{ + roMap: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ResourceOverrideSnapshot{ { Group: utils.DeploymentGVK.Group, Version: utils.DeploymentGVK.Version, @@ -1481,10 +1477,10 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { Namespace: "deployment-namespace", }: { { - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -1497,10 +1493,10 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { }, }, }, - OverrideType: placementv1alpha1.JSONPatchOverrideType, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + OverrideType: placementv1beta1.JSONPatchOverrideType, + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/spec/minReadySeconds", Value: apiextensionsv1.JSON{Raw: []byte("1")}, }, @@ -1508,10 +1504,10 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { }, { ClusterSelector: &placementv1beta1.ClusterSelector{}, // selecting all the clusters - OverrideType: placementv1alpha1.JSONPatchOverrideType, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + OverrideType: placementv1beta1.JSONPatchOverrideType, + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/spec/minReadySeconds", Value: apiextensionsv1.JSON{Raw: []byte("2")}, }, @@ -1557,7 +1553,7 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { }, }, }, - croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ClusterResourceOverrideSnapshot{ + croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ClusterResourceOverrideSnapshot{ { Group: utils.NamespaceMetaGVK.Group, Version: utils.NamespaceMetaGVK.Version, @@ -1565,10 +1561,10 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { Name: "deployment-namespace", }: { { - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -1581,10 +1577,10 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { }, }, }, - OverrideType: placementv1alpha1.JSONPatchOverrideType, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + OverrideType: placementv1beta1.JSONPatchOverrideType, + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/metadata/labels/app", Value: apiextensionsv1.JSON{Raw: []byte(`"app2"`)}, }, @@ -1597,7 +1593,7 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { }, }, }, - roMap: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ResourceOverrideSnapshot{ + roMap: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ResourceOverrideSnapshot{ { Group: utils.DeploymentGVK.Group, Version: utils.DeploymentGVK.Version, @@ -1606,16 +1602,16 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { Namespace: "deployment-namespace", }: { { - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{}, // matching all the clusters - OverrideType: placementv1alpha1.JSONPatchOverrideType, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + OverrideType: placementv1beta1.JSONPatchOverrideType, + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/metadata/labels/app", Value: apiextensionsv1.JSON{Raw: []byte(`"app3"`)}, }, @@ -1660,7 +1656,7 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { }, }, }, - croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ClusterResourceOverrideSnapshot{ + croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ClusterResourceOverrideSnapshot{ { Group: utils.NamespaceMetaGVK.Group, Version: utils.NamespaceMetaGVK.Version, @@ -1668,10 +1664,10 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { Name: "deployment-namespace", }: { { - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -1684,10 +1680,10 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { }, }, }, - OverrideType: placementv1alpha1.JSONPatchOverrideType, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + OverrideType: placementv1beta1.JSONPatchOverrideType, + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/metadata/label/app", Value: apiextensionsv1.JSON{Raw: []byte(`"app2"`)}, }, @@ -1723,7 +1719,7 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { }, }, }, - roMap: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ResourceOverrideSnapshot{ + roMap: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ResourceOverrideSnapshot{ { Group: utils.DeploymentGVK.Group, Version: utils.DeploymentGVK.Version, @@ -1732,16 +1728,16 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { Namespace: "deployment-namespace", }: { { - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{}, // matching all the clusters - OverrideType: placementv1alpha1.JSONPatchOverrideType, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + OverrideType: placementv1beta1.JSONPatchOverrideType, + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/metadata/spec", Value: apiextensionsv1.JSON{Raw: []byte(`"app3"`)}, }, @@ -1777,7 +1773,7 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { }, }, }, - roMap: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ResourceOverrideSnapshot{ + roMap: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ResourceOverrideSnapshot{ { Group: utils.DeploymentGVK.Group, Version: utils.DeploymentGVK.Version, @@ -1786,13 +1782,13 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { Namespace: "deployment-namespace", }: { { - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{}, // matching all the clusters - OverrideType: placementv1alpha1.DeleteOverrideType, + OverrideType: placementv1beta1.DeleteOverrideType, }, }, }, @@ -1824,7 +1820,7 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { }, }, }, - croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ClusterResourceOverrideSnapshot{ + croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ClusterResourceOverrideSnapshot{ { Group: utils.NamespaceMetaGVK.Group, Version: utils.NamespaceMetaGVK.Version, @@ -1832,10 +1828,10 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { Name: "deployment-namespace", }: { { - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -1848,10 +1844,10 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { }, }, }, - OverrideType: placementv1alpha1.JSONPatchOverrideType, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + OverrideType: placementv1beta1.JSONPatchOverrideType, + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/metadata/labels/app", Value: apiextensionsv1.JSON{Raw: []byte(`"app2"`)}, }, @@ -1864,7 +1860,7 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { }, }, }, - roMap: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ResourceOverrideSnapshot{ + roMap: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ResourceOverrideSnapshot{ { Group: utils.DeploymentGVK.Group, Version: utils.DeploymentGVK.Version, @@ -1873,13 +1869,13 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { Namespace: "deployment-namespace", }: { { - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{}, // matching all the clusters - OverrideType: placementv1alpha1.DeleteOverrideType, + OverrideType: placementv1beta1.DeleteOverrideType, }, }, }, @@ -1911,7 +1907,7 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { }, }, }, - croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ClusterResourceOverrideSnapshot{ + croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ClusterResourceOverrideSnapshot{ { Group: utils.NamespaceMetaGVK.Group, Version: utils.NamespaceMetaGVK.Version, @@ -1919,10 +1915,10 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { Name: "deployment-namespace", }: { { - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -1935,7 +1931,7 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { }, }, }, - OverrideType: placementv1alpha1.DeleteOverrideType, + OverrideType: placementv1beta1.DeleteOverrideType, }, }, }, @@ -1944,7 +1940,7 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { }, }, }, - roMap: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ResourceOverrideSnapshot{ + roMap: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ResourceOverrideSnapshot{ { Group: utils.DeploymentGVK.Group, Version: utils.DeploymentGVK.Version, @@ -1953,15 +1949,15 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { Namespace: "deployment-namespace", }: { { - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{}, // matching all the clusters - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/labels/new-label", Value: apiextensionsv1.JSON{Raw: []byte(`"new-value"`)}, }, @@ -1997,7 +1993,7 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { }, }, }, - roMap: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ResourceOverrideSnapshot{ + roMap: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ResourceOverrideSnapshot{ { Group: utils.DeploymentGVK.Group, Version: utils.DeploymentGVK.Version, @@ -2006,23 +2002,23 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { Namespace: "deployment-namespace", }: { { - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{}, // matching all the clusters - OverrideType: placementv1alpha1.JSONPatchOverrideType, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + OverrideType: placementv1beta1.JSONPatchOverrideType, + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/metadata/labels/app", - Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`"%s"`, placementv1alpha1.OverrideClusterNameVariable))}, + Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`"%s"`, placementv1beta1.OverrideClusterNameVariable))}, }, { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/annotations", - Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf("{\"app\": \"%s\", \"test\": \"nginx\"}", placementv1alpha1.OverrideClusterNameVariable))}, + Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf("{\"app\": \"%s\", \"test\": \"nginx\"}", placementv1beta1.OverrideClusterNameVariable))}, }, }, }, @@ -2066,7 +2062,7 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { Name: "cluster-1", }, }, - roMap: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ResourceOverrideSnapshot{ + roMap: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ResourceOverrideSnapshot{ { Group: utils.DeploymentGVK.Group, Version: utils.DeploymentGVK.Version, @@ -2075,23 +2071,23 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { Namespace: "deployment-namespace", }: { { - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{}, // matching all the clusters - OverrideType: placementv1alpha1.JSONPatchOverrideType, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + OverrideType: placementv1beta1.JSONPatchOverrideType, + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/metadata/labels/app", - Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`"%s"`, placementv1alpha1.OverrideClusterNameVariable))}, + Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`"%s"`, placementv1beta1.OverrideClusterNameVariable))}, }, { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/annotations", - Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf("{\"app\": \"workload-%s\", \"test\": \"nginx\"}", placementv1alpha1.OverrideClusterNameVariable))}, + Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf("{\"app\": \"workload-%s\", \"test\": \"nginx\"}", placementv1beta1.OverrideClusterNameVariable))}, }, }, }, @@ -2139,8 +2135,8 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { }, }, }, - croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ClusterResourceOverrideSnapshot{}, - roMap: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ResourceOverrideSnapshot{ + croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ClusterResourceOverrideSnapshot{}, + roMap: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ResourceOverrideSnapshot{ { Group: utils.DeploymentGVK.Group, Version: utils.DeploymentGVK.Version, @@ -2149,24 +2145,24 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { Namespace: "deployment-namespace", }: { { - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{}, // matching all the clusters - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/metadata/labels/app", - Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`"%s-region"`, placementv1alpha1.OverrideClusterLabelKeyVariablePrefix+"region}"))}, + Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`"%s-region"`, placementv1beta1.OverrideClusterLabelKeyVariablePrefix+"region}"))}, }, { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/annotations", Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`{"environment": "%s", "zone": "%s"}`, - placementv1alpha1.OverrideClusterLabelKeyVariablePrefix+"env}", - placementv1alpha1.OverrideClusterLabelKeyVariablePrefix+"zone}"))}, + placementv1beta1.OverrideClusterLabelKeyVariablePrefix+"env}", + placementv1beta1.OverrideClusterLabelKeyVariablePrefix+"zone}"))}, }, }, }, @@ -2212,8 +2208,8 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { }, }, }, - croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ClusterResourceOverrideSnapshot{}, - roMap: map[placementv1beta1.ResourceIdentifier][]*placementv1alpha1.ResourceOverrideSnapshot{ + croMap: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ClusterResourceOverrideSnapshot{}, + roMap: map[placementv1beta1.ResourceIdentifier][]*placementv1beta1.ResourceOverrideSnapshot{ { Group: utils.DeploymentGVK.Group, Version: utils.DeploymentGVK.Version, @@ -2222,17 +2218,17 @@ func TestApplyOverrides_namespacedScopeResource(t *testing.T) { Namespace: "deployment-namespace", }: { { - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{}, // matching all the clusters - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/metadata/labels/app", - Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`"%s-app"`, placementv1alpha1.OverrideClusterLabelKeyVariablePrefix+"non-existent}"))}, + Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`"%s-app"`, placementv1beta1.OverrideClusterLabelKeyVariablePrefix+"non-existent}"))}, }, }, }, @@ -2292,7 +2288,7 @@ func TestApplyJSONPatchOverride(t *testing.T) { testCases := []struct { name string deployment appsv1.Deployment - overrides []placementv1alpha1.JSONPatchOverride + overrides []placementv1beta1.JSONPatchOverride cluster *clusterv1beta1.MemberCluster wantDeployment appsv1.Deployment wantErr bool @@ -2309,7 +2305,7 @@ func TestApplyJSONPatchOverride(t *testing.T) { }, }, }, - overrides: []placementv1alpha1.JSONPatchOverride{}, + overrides: []placementv1beta1.JSONPatchOverride{}, wantDeployment: appsv1.Deployment{ TypeMeta: deploymentType, ObjectMeta: metav1.ObjectMeta{ @@ -2334,9 +2330,9 @@ func TestApplyJSONPatchOverride(t *testing.T) { }, }, }, - overrides: []placementv1alpha1.JSONPatchOverride{ + overrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/labels", Value: apiextensionsv1.JSON{Raw: []byte(`{"app": "nginx"}`)}, }, @@ -2365,9 +2361,9 @@ func TestApplyJSONPatchOverride(t *testing.T) { }, }, }, - overrides: []placementv1alpha1.JSONPatchOverride{ + overrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/metadata/labels", Value: apiextensionsv1.JSON{Raw: []byte(`{"app": "nginx"}`)}, }, @@ -2392,10 +2388,10 @@ func TestApplyJSONPatchOverride(t *testing.T) { Namespace: "deployment-namespace", }, }, - overrides: []placementv1alpha1.JSONPatchOverride{ + overrides: []placementv1beta1.JSONPatchOverride{ { // To add the first key, it cannot use "replace" as the path is missing. - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/labels", Value: apiextensionsv1.JSON{Raw: []byte(`{"app": "nginx"}`)}, }, @@ -2423,9 +2419,9 @@ func TestApplyJSONPatchOverride(t *testing.T) { }, }, }, - overrides: []placementv1alpha1.JSONPatchOverride{ + overrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/labels/new-label", Value: apiextensionsv1.JSON{Raw: []byte(`"new-value"`)}, }, @@ -2454,9 +2450,9 @@ func TestApplyJSONPatchOverride(t *testing.T) { }, }, }, - overrides: []placementv1alpha1.JSONPatchOverride{ + overrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpRemove, + Operator: placementv1beta1.JSONPatchOverrideOpRemove, Path: "/metadata/labels/app", }, }, @@ -2481,9 +2477,9 @@ func TestApplyJSONPatchOverride(t *testing.T) { }, }, }, - overrides: []placementv1alpha1.JSONPatchOverride{ + overrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/metadata/labels/app", Value: apiextensionsv1.JSON{Raw: []byte(`"new-value"`)}, }, @@ -2514,14 +2510,14 @@ func TestApplyJSONPatchOverride(t *testing.T) { MinReadySeconds: 10, }, }, - overrides: []placementv1alpha1.JSONPatchOverride{ + overrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/metadata/labels/app", Value: apiextensionsv1.JSON{Raw: []byte(`"new-value"`)}, }, { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/spec/minReadySeconds", Value: apiextensionsv1.JSON{Raw: []byte("1")}, }, @@ -2550,9 +2546,9 @@ func TestApplyJSONPatchOverride(t *testing.T) { }, }, }, - overrides: []placementv1alpha1.JSONPatchOverride{ + overrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/metadata/labels/app", Value: apiextensionsv1.JSON{Raw: []byte("new-value")}, }, @@ -2571,9 +2567,9 @@ func TestApplyJSONPatchOverride(t *testing.T) { }, }, }, - overrides: []placementv1alpha1.JSONPatchOverride{ + overrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/metadata/invalid", Value: apiextensionsv1.JSON{Raw: []byte(`"new-value"`)}, }, @@ -2592,14 +2588,14 @@ func TestApplyJSONPatchOverride(t *testing.T) { }, }, }, - overrides: []placementv1alpha1.JSONPatchOverride{ + overrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/metadata/labels/app", Value: apiextensionsv1.JSON{Raw: []byte(`"$CLUSTER_NAME"`)}, }, { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/labels/${Member-Cluster-Name}", Value: apiextensionsv1.JSON{Raw: []byte(`"${CLUSTER-NAME}"`)}, }, @@ -2633,16 +2629,16 @@ func TestApplyJSONPatchOverride(t *testing.T) { }, }, }, - overrides: []placementv1alpha1.JSONPatchOverride{ + overrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/metadata/labels/app", - Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`"%s"`, placementv1alpha1.OverrideClusterNameVariable))}, + Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`"%s"`, placementv1beta1.OverrideClusterNameVariable))}, }, { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/annotations", - Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf("{\"app\": \"workload-%s\", \"test\": \"nginx\"}", placementv1alpha1.OverrideClusterNameVariable))}, + Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf("{\"app\": \"workload-%s\", \"test\": \"nginx\"}", placementv1beta1.OverrideClusterNameVariable))}, }, }, cluster: &clusterv1beta1.MemberCluster{ @@ -2677,18 +2673,18 @@ func TestApplyJSONPatchOverride(t *testing.T) { }, }, }, - overrides: []placementv1alpha1.JSONPatchOverride{ + overrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/metadata/labels/app", - Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`"%s-app"`, placementv1alpha1.OverrideClusterLabelKeyVariablePrefix+"region}"))}, + Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`"%s-app"`, placementv1beta1.OverrideClusterLabelKeyVariablePrefix+"region}"))}, }, { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/annotations", Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`{"environment": "%s", "zone": "%s"}`, - placementv1alpha1.OverrideClusterLabelKeyVariablePrefix+"fleet-kubernetes.io/env}", - placementv1alpha1.OverrideClusterLabelKeyVariablePrefix+"zone}"))}, + placementv1beta1.OverrideClusterLabelKeyVariablePrefix+"fleet-kubernetes.io/env}", + placementv1beta1.OverrideClusterLabelKeyVariablePrefix+"zone}"))}, }, }, cluster: &clusterv1beta1.MemberCluster{ @@ -2728,11 +2724,11 @@ func TestApplyJSONPatchOverride(t *testing.T) { }, }, }, - overrides: []placementv1alpha1.JSONPatchOverride{ + overrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/metadata/labels/app", - Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`"%s-app"`, placementv1alpha1.OverrideClusterLabelKeyVariablePrefix+"non-existent}"))}, + Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`"%s-app"`, placementv1beta1.OverrideClusterLabelKeyVariablePrefix+"non-existent}"))}, }, }, wantErr: true, diff --git a/pkg/controllers/workgenerator/suite_test.go b/pkg/controllers/workgenerator/suite_test.go index 60f9b3df3..48a9ac61e 100644 --- a/pkg/controllers/workgenerator/suite_test.go +++ b/pkg/controllers/workgenerator/suite_test.go @@ -44,7 +44,6 @@ import ( workv1alpha1 "sigs.k8s.io/work-api/pkg/apis/v1alpha1" clusterv1beta1 "go.goms.io/fleet/apis/cluster/v1beta1" - placementv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" "go.goms.io/fleet/pkg/utils" "go.goms.io/fleet/test/utils/informer" @@ -98,7 +97,6 @@ var _ = BeforeSuite(func() { Expect(placementv1beta1.AddToScheme(scheme.Scheme)).Should(Succeed()) Expect(workv1alpha1.AddToScheme(scheme.Scheme)).Should(Succeed()) Expect(clusterv1beta1.AddToScheme(scheme.Scheme)).Should(Succeed()) - Expect(placementv1alpha1.AddToScheme(scheme.Scheme)).Should(Succeed()) By("starting the controller manager") klog.InitFlags(flag.CommandLine) @@ -163,15 +161,15 @@ func createOverrides() { Expect(k8sClient.Create(ctx, &appNamespace)).Should(Succeed(), "Failed to create the application namespace") By(fmt.Sprintf("Application namespace %s created", appNamespaceName)) - validClusterResourceOverrideSnapshot = placementv1alpha1.ClusterResourceOverrideSnapshot{ + validClusterResourceOverrideSnapshot = placementv1beta1.ClusterResourceOverrideSnapshot{ ObjectMeta: metav1.ObjectMeta{ Name: validClusterResourceOverrideSnapshotName, Labels: map[string]string{ placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: utils.NamespaceGVK.Group, @@ -180,8 +178,8 @@ func createOverrides() { Name: appNamespaceName, }, }, - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -194,9 +192,9 @@ func createOverrides() { }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/labels/new-label", Value: apiextensionsv1.JSON{Raw: []byte(`"new-value"`)}, }, @@ -211,7 +209,7 @@ func createOverrides() { Expect(k8sClient.Create(ctx, &validClusterResourceOverrideSnapshot)).Should(Succeed(), "Failed to create the cro-1") By(fmt.Sprintf("Cluster resource override snapshot %s created", validClusterResourceOverrideSnapshotName)) - validResourceOverrideSnapshot = placementv1alpha1.ResourceOverrideSnapshot{ + validResourceOverrideSnapshot = placementv1beta1.ResourceOverrideSnapshot{ ObjectMeta: metav1.ObjectMeta{ Name: validResourceOverrideSnapshotName, Namespace: appNamespaceName, @@ -219,9 +217,9 @@ func createOverrides() { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []placementv1alpha1.ResourceSelector{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "test.kubernetes-fleet.io", Version: "v1alpha1", @@ -229,15 +227,15 @@ func createOverrides() { Name: "random-test-resource", }, }, - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{}, // select all members }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/spec/foo", Value: apiextensionsv1.JSON{Raw: []byte(`"foo2"`)}, }, @@ -252,15 +250,15 @@ func createOverrides() { Expect(k8sClient.Create(ctx, &validResourceOverrideSnapshot)).Should(Succeed(), "Failed to create the ro-1") By(fmt.Sprintf("Resource override snapshot %s created", validResourceOverrideSnapshotName)) - invalidClusterResourceOverrideSnapshot = placementv1alpha1.ClusterResourceOverrideSnapshot{ + invalidClusterResourceOverrideSnapshot = placementv1beta1.ClusterResourceOverrideSnapshot{ ObjectMeta: metav1.ObjectMeta{ Name: invalidClusterResourceOverrideSnapshotName, Labels: map[string]string{ placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: utils.NamespaceGVK.Group, @@ -269,8 +267,8 @@ func createOverrides() { Name: appNamespaceName, }, }, - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -283,9 +281,9 @@ func createOverrides() { }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/invalid/path", Value: apiextensionsv1.JSON{Raw: []byte(`"new-value"`)}, }, diff --git a/pkg/utils/apiresources.go b/pkg/utils/apiresources.go index 910ae1263..2bb9001e2 100644 --- a/pkg/utils/apiresources.go +++ b/pkg/utils/apiresources.go @@ -27,7 +27,6 @@ import ( metricsV1beta1 "k8s.io/metrics/pkg/apis/metrics/v1beta1" clusterv1beta1 "go.goms.io/fleet/apis/cluster/v1beta1" - placementv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" fleetv1alpha1 "go.goms.io/fleet/apis/v1alpha1" ) @@ -112,23 +111,23 @@ var ( } ClusterResourceOverrideGK = schema.GroupKind{ - Group: placementv1alpha1.GroupVersion.Group, - Kind: placementv1alpha1.ClusterResourceOverrideKind, + Group: placementv1beta1.GroupVersion.Group, + Kind: placementv1beta1.ClusterResourceOverrideKind, } ClusterResourceOverrideSnapshotGK = schema.GroupKind{ - Group: placementv1alpha1.GroupVersion.Group, - Kind: placementv1alpha1.ClusterResourceOverrideSnapshotKind, + Group: placementv1beta1.GroupVersion.Group, + Kind: placementv1beta1.ClusterResourceOverrideSnapshotKind, } ResourceOverrideGK = schema.GroupKind{ - Group: placementv1alpha1.GroupVersion.Group, - Kind: placementv1alpha1.ResourceOverrideKind, + Group: placementv1beta1.GroupVersion.Group, + Kind: placementv1beta1.ResourceOverrideKind, } ResourceOverrideSnapshotGK = schema.GroupKind{ - Group: placementv1alpha1.GroupVersion.Group, - Kind: placementv1alpha1.ResourceOverrideSnapshotKind, + Group: placementv1beta1.GroupVersion.Group, + Kind: placementv1beta1.ResourceOverrideSnapshotKind, } // we use `;` to separate the different api groups diff --git a/pkg/utils/common.go b/pkg/utils/common.go index 1c595032d..92208086d 100644 --- a/pkg/utils/common.go +++ b/pkg/utils/common.go @@ -48,7 +48,6 @@ import ( fleetnetworkingv1alpha1 "go.goms.io/fleet-networking/api/v1alpha1" clusterv1beta1 "go.goms.io/fleet/apis/cluster/v1beta1" - placementv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" fleetv1alpha1 "go.goms.io/fleet/apis/v1alpha1" "go.goms.io/fleet/pkg/utils/condition" @@ -406,15 +405,15 @@ var ( } ClusterResourceOverrideSnapshotKind = schema.GroupVersionKind{ - Group: placementv1alpha1.GroupVersion.Group, - Version: placementv1alpha1.GroupVersion.Version, - Kind: placementv1alpha1.ClusterResourceOverrideSnapshotKind, + Group: placementv1beta1.GroupVersion.Group, + Version: placementv1beta1.GroupVersion.Version, + Kind: placementv1beta1.ClusterResourceOverrideSnapshotKind, } ResourceOverrideSnapshotKind = schema.GroupVersionKind{ - Group: placementv1alpha1.GroupVersion.Group, - Version: placementv1alpha1.GroupVersion.Version, - Kind: placementv1alpha1.ResourceOverrideSnapshotKind, + Group: placementv1beta1.GroupVersion.Group, + Version: placementv1beta1.GroupVersion.Version, + Kind: placementv1beta1.ResourceOverrideSnapshotKind, } DeploymentGVR = schema.GroupVersionResource{ diff --git a/pkg/utils/overrider/overrider.go b/pkg/utils/overrider/overrider.go index f4652f4e9..6575dad68 100644 --- a/pkg/utils/overrider/overrider.go +++ b/pkg/utils/overrider/overrider.go @@ -33,7 +33,6 @@ import ( "sigs.k8s.io/controller-runtime/pkg/client" clusterv1beta1 "go.goms.io/fleet/apis/cluster/v1beta1" - placementv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" "go.goms.io/fleet/pkg/utils" "go.goms.io/fleet/pkg/utils/controller" @@ -48,17 +47,17 @@ func FetchAllMatchingOverridesForResourceSnapshot( manager informer.Manager, placementKey string, masterResourceSnapshot placementv1beta1.ResourceSnapshotObj, -) ([]*placementv1alpha1.ClusterResourceOverrideSnapshot, []*placementv1alpha1.ResourceOverrideSnapshot, error) { +) ([]*placementv1beta1.ClusterResourceOverrideSnapshot, []*placementv1beta1.ResourceOverrideSnapshot, error) { // fetch the cro and ro snapshot list first before finding the matched ones. latestSnapshotLabelMatcher := client.MatchingLabels{ placementv1beta1.IsLatestSnapshotLabel: strconv.FormatBool(true), } - croList := &placementv1alpha1.ClusterResourceOverrideSnapshotList{} + croList := &placementv1beta1.ClusterResourceOverrideSnapshotList{} if err := c.List(ctx, croList, latestSnapshotLabelMatcher); err != nil { klog.ErrorS(err, "Failed to list all the clusterResourceOverrideSnapshots") return nil, nil, err } - roList := &placementv1alpha1.ResourceOverrideSnapshotList{} + roList := &placementv1beta1.ResourceOverrideSnapshotList{} if err := c.List(ctx, roList, latestSnapshotLabelMatcher); err != nil { klog.ErrorS(err, "Failed to list all the resourceOverrideSnapshots") return nil, nil, err @@ -113,8 +112,8 @@ func FetchAllMatchingOverridesForResourceSnapshot( } } - filteredCRO := make([]*placementv1alpha1.ClusterResourceOverrideSnapshot, 0, len(croList.Items)) - filteredRO := make([]*placementv1alpha1.ResourceOverrideSnapshot, 0, len(roList.Items)) + filteredCRO := make([]*placementv1beta1.ClusterResourceOverrideSnapshot, 0, len(croList.Items)) + filteredRO := make([]*placementv1beta1.ResourceOverrideSnapshot, 0, len(roList.Items)) for i := range croList.Items { placementInOverride := croList.Items[i].Spec.OverrideSpec.Placement if placementInOverride != nil && placementInOverride.Name != placementKey { @@ -164,8 +163,8 @@ func PickFromResourceMatchedOverridesForTargetCluster( ctx context.Context, c client.Reader, targetCluster string, - croList []*placementv1alpha1.ClusterResourceOverrideSnapshot, - roList []*placementv1alpha1.ResourceOverrideSnapshot, + croList []*placementv1beta1.ClusterResourceOverrideSnapshot, + roList []*placementv1beta1.ResourceOverrideSnapshot, ) ([]string, []placementv1beta1.NamespacedName, error) { if len(croList) == 0 && len(roList) == 0 { return nil, nil, nil @@ -181,7 +180,7 @@ func PickFromResourceMatchedOverridesForTargetCluster( return nil, nil, controller.NewAPIServerError(true, err) } - croFiltered := make([]*placementv1alpha1.ClusterResourceOverrideSnapshot, 0, len(croList)) + croFiltered := make([]*placementv1beta1.ClusterResourceOverrideSnapshot, 0, len(croList)) for i, cro := range croList { matched, err := isClusterMatched(&cluster, cro.Spec.OverrideSpec.Policy) if err != nil { @@ -197,7 +196,7 @@ func PickFromResourceMatchedOverridesForTargetCluster( return croFiltered[i].Name < croFiltered[j].Name }) - roFiltered := make([]*placementv1alpha1.ResourceOverrideSnapshot, 0, len(roList)) + roFiltered := make([]*placementv1beta1.ResourceOverrideSnapshot, 0, len(roList)) for i, ro := range roList { matched, err := isClusterMatched(&cluster, ro.Spec.OverrideSpec.Policy) if err != nil { @@ -227,7 +226,7 @@ func PickFromResourceMatchedOverridesForTargetCluster( return croNames, roNames, nil } -func isClusterMatched(cluster *clusterv1beta1.MemberCluster, policy *placementv1alpha1.OverridePolicy) (bool, error) { +func isClusterMatched(cluster *clusterv1beta1.MemberCluster, policy *placementv1beta1.OverridePolicy) (bool, error) { if policy == nil { return false, errors.New("policy is nil") } @@ -244,7 +243,7 @@ func isClusterMatched(cluster *clusterv1beta1.MemberCluster, policy *placementv1 } // IsClusterMatched checks if the cluster is matched with the override rules. -func IsClusterMatched(cluster *clusterv1beta1.MemberCluster, rule placementv1alpha1.OverrideRule) (bool, error) { +func IsClusterMatched(cluster *clusterv1beta1.MemberCluster, rule placementv1beta1.OverrideRule) (bool, error) { if rule.ClusterSelector == nil { // it means matching no member clusters return false, nil } diff --git a/pkg/utils/overrider/overrider_test.go b/pkg/utils/overrider/overrider_test.go index b0589b9a0..0e955cb3a 100644 --- a/pkg/utils/overrider/overrider_test.go +++ b/pkg/utils/overrider/overrider_test.go @@ -31,7 +31,6 @@ import ( "sigs.k8s.io/controller-runtime/pkg/client/fake" clusterv1beta1 "go.goms.io/fleet/apis/cluster/v1beta1" - placementv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" "go.goms.io/fleet/pkg/utils/controller" "go.goms.io/fleet/test/utils/informer" @@ -50,9 +49,6 @@ func serviceScheme(t *testing.T) *runtime.Scheme { if err := clusterv1beta1.AddToScheme(scheme); err != nil { t.Fatalf("Failed to add cluster v1beta1 scheme: %v", err) } - if err := placementv1alpha1.AddToScheme(scheme); err != nil { - t.Fatalf("Failed to add v1alpha1 scheme: %v", err) - } return scheme } @@ -82,10 +78,10 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { name string master *placementv1beta1.ClusterResourceSnapshot snapshots []placementv1beta1.ClusterResourceSnapshot - croList []placementv1alpha1.ClusterResourceOverrideSnapshot - roList []placementv1alpha1.ResourceOverrideSnapshot - wantCRO []*placementv1alpha1.ClusterResourceOverrideSnapshot - wantRO []*placementv1alpha1.ResourceOverrideSnapshot + croList []placementv1beta1.ClusterResourceOverrideSnapshot + roList []placementv1beta1.ResourceOverrideSnapshot + wantCRO []*placementv1beta1.ClusterResourceOverrideSnapshot + wantRO []*placementv1beta1.ResourceOverrideSnapshot }{ { name: "single resource snapshot selecting empty resources", @@ -102,7 +98,7 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { }, }, }, - croList: []placementv1alpha1.ClusterResourceOverrideSnapshot{ + croList: []placementv1beta1.ClusterResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "cro-1", @@ -110,11 +106,11 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{}, + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{}, }, }, - wantCRO: []*placementv1alpha1.ClusterResourceOverrideSnapshot{}, - wantRO: []*placementv1alpha1.ResourceOverrideSnapshot{}, + wantCRO: []*placementv1beta1.ClusterResourceOverrideSnapshot{}, + wantRO: []*placementv1beta1.ResourceOverrideSnapshot{}, }, { name: "single resource snapshot with no matched overrides", @@ -136,7 +132,7 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { }, }, }, - croList: []placementv1alpha1.ClusterResourceOverrideSnapshot{ + croList: []placementv1beta1.ClusterResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "cro-1", @@ -144,8 +140,8 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "rbac.authorization.k8s.io", @@ -158,7 +154,7 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { }, }, }, - roList: []placementv1alpha1.ResourceOverrideSnapshot{ + roList: []placementv1beta1.ResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "ro-1", @@ -166,9 +162,9 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []placementv1alpha1.ResourceSelector{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "rbac.authorization.k8s.io", Version: "v1", @@ -180,8 +176,8 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { }, }, }, - wantCRO: []*placementv1alpha1.ClusterResourceOverrideSnapshot{}, - wantRO: []*placementv1alpha1.ResourceOverrideSnapshot{}, + wantCRO: []*placementv1beta1.ClusterResourceOverrideSnapshot{}, + wantRO: []*placementv1beta1.ResourceOverrideSnapshot{}, }, { name: "single resource snapshot with matched cro and ro", @@ -203,7 +199,7 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { }, }, }, - croList: []placementv1alpha1.ClusterResourceOverrideSnapshot{ + croList: []placementv1beta1.ClusterResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "cro-1", @@ -211,8 +207,8 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "", @@ -225,7 +221,7 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { }, }, }, - roList: []placementv1alpha1.ResourceOverrideSnapshot{ + roList: []placementv1beta1.ResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "ro-1", @@ -234,9 +230,9 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []placementv1alpha1.ResourceSelector{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "", Version: "v1", @@ -248,7 +244,7 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { }, }, }, - wantCRO: []*placementv1alpha1.ClusterResourceOverrideSnapshot{ + wantCRO: []*placementv1beta1.ClusterResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "cro-1", @@ -256,8 +252,8 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "", @@ -270,7 +266,7 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { }, }, }, - wantRO: []*placementv1alpha1.ResourceOverrideSnapshot{ + wantRO: []*placementv1beta1.ResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "ro-1", @@ -279,9 +275,9 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []placementv1alpha1.ResourceSelector{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "", Version: "v1", @@ -314,13 +310,13 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { }, }, }, - croList: []placementv1alpha1.ClusterResourceOverrideSnapshot{ + croList: []placementv1beta1.ClusterResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "cro-1", }, - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "", @@ -333,15 +329,15 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { }, }, }, - roList: []placementv1alpha1.ResourceOverrideSnapshot{ + roList: []placementv1beta1.ResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "ro-1", Namespace: "svc-namespace", }, - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []placementv1alpha1.ResourceSelector{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "", Version: "v1", @@ -353,8 +349,8 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { }, }, }, - wantCRO: []*placementv1alpha1.ClusterResourceOverrideSnapshot{}, - wantRO: []*placementv1alpha1.ResourceOverrideSnapshot{}, + wantCRO: []*placementv1beta1.ClusterResourceOverrideSnapshot{}, + wantRO: []*placementv1beta1.ResourceOverrideSnapshot{}, }, { name: "multiple resource snapshots with matched cro and ro", @@ -413,7 +409,7 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { }, }, }, - croList: []placementv1alpha1.ClusterResourceOverrideSnapshot{ + croList: []placementv1beta1.ClusterResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "cro-1", @@ -421,8 +417,8 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "rbac.authorization.k8s.io", @@ -441,8 +437,8 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "rbac.authorization.k8s.io", @@ -455,7 +451,7 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { }, }, }, - roList: []placementv1alpha1.ResourceOverrideSnapshot{ + roList: []placementv1beta1.ResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "ro-1", @@ -464,9 +460,9 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []placementv1alpha1.ResourceSelector{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "apps", Version: "v1", @@ -491,9 +487,9 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []placementv1alpha1.ResourceSelector{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "apps", Version: "v1", @@ -505,7 +501,7 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { }, }, }, - wantCRO: []*placementv1alpha1.ClusterResourceOverrideSnapshot{ + wantCRO: []*placementv1beta1.ClusterResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "cro-2", @@ -513,8 +509,8 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "rbac.authorization.k8s.io", @@ -527,7 +523,7 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { }, }, }, - wantRO: []*placementv1alpha1.ResourceOverrideSnapshot{ + wantRO: []*placementv1beta1.ResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "ro-2", @@ -536,9 +532,9 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []placementv1alpha1.ResourceSelector{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "apps", Version: "v1", @@ -557,9 +553,9 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []placementv1alpha1.ResourceSelector{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "apps", Version: "v1", @@ -635,7 +631,7 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { }, }, }, - croList: []placementv1alpha1.ClusterResourceOverrideSnapshot{ + croList: []placementv1beta1.ClusterResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "cro-1", @@ -643,9 +639,9 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ - Placement: &placementv1alpha1.PlacementRef{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ + Placement: &placementv1beta1.PlacementRef{ Name: crpName, }, ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ @@ -666,8 +662,8 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "rbac.authorization.k8s.io", @@ -680,7 +676,7 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { }, }, }, - roList: []placementv1alpha1.ResourceOverrideSnapshot{ + roList: []placementv1beta1.ResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "ro-1", @@ -689,9 +685,9 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []placementv1alpha1.ResourceSelector{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "apps", Version: "v1", @@ -716,12 +712,12 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - Placement: &placementv1alpha1.PlacementRef{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + Placement: &placementv1beta1.PlacementRef{ Name: crpName, }, - ResourceSelectors: []placementv1alpha1.ResourceSelector{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "apps", Version: "v1", @@ -733,7 +729,7 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { }, }, }, - wantCRO: []*placementv1alpha1.ClusterResourceOverrideSnapshot{ + wantCRO: []*placementv1beta1.ClusterResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "cro-2", @@ -741,8 +737,8 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "rbac.authorization.k8s.io", @@ -755,7 +751,7 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { }, }, }, - wantRO: []*placementv1alpha1.ResourceOverrideSnapshot{ + wantRO: []*placementv1beta1.ResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "ro-2", @@ -764,12 +760,12 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - Placement: &placementv1alpha1.PlacementRef{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + Placement: &placementv1beta1.PlacementRef{ Name: crpName, }, - ResourceSelectors: []placementv1alpha1.ResourceSelector{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "apps", Version: "v1", @@ -788,9 +784,9 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []placementv1alpha1.ResourceSelector{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "apps", Version: "v1", @@ -830,7 +826,7 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { }, }, }, - croList: []placementv1alpha1.ClusterResourceOverrideSnapshot{ + croList: []placementv1beta1.ClusterResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "cro-1", @@ -838,8 +834,8 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "", @@ -858,8 +854,8 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "", @@ -872,7 +868,7 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { }, }, }, - roList: []placementv1alpha1.ResourceOverrideSnapshot{ + roList: []placementv1beta1.ResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "ro-1", @@ -881,9 +877,9 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []placementv1alpha1.ResourceSelector{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "", Version: "v1", @@ -902,9 +898,9 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []placementv1alpha1.ResourceSelector{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "", Version: "v1", @@ -916,7 +912,7 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { }, }, }, - wantCRO: []*placementv1alpha1.ClusterResourceOverrideSnapshot{ + wantCRO: []*placementv1beta1.ClusterResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "cro-1", @@ -924,8 +920,8 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "", @@ -944,8 +940,8 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "", @@ -958,7 +954,7 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { }, }, }, - wantRO: []*placementv1alpha1.ResourceOverrideSnapshot{ + wantRO: []*placementv1beta1.ResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "ro-1", @@ -967,9 +963,9 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []placementv1alpha1.ResourceSelector{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "", Version: "v1", @@ -988,9 +984,9 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []placementv1alpha1.ResourceSelector{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "", Version: "v1", @@ -1060,7 +1056,7 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { }, }, }, - croList: []placementv1alpha1.ClusterResourceOverrideSnapshot{ + croList: []placementv1beta1.ClusterResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "cro-1", @@ -1068,8 +1064,8 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "rbac.authorization.k8s.io", @@ -1088,9 +1084,9 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ - Placement: &placementv1alpha1.PlacementRef{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ + Placement: &placementv1beta1.PlacementRef{ Name: "other-placement", }, ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ @@ -1105,7 +1101,7 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { }, }, }, - roList: []placementv1alpha1.ResourceOverrideSnapshot{ + roList: []placementv1beta1.ResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "ro-1", @@ -1114,12 +1110,12 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - Placement: &placementv1alpha1.PlacementRef{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + Placement: &placementv1beta1.PlacementRef{ Name: "other-placement", }, - ResourceSelectors: []placementv1alpha1.ResourceSelector{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "apps", Version: "v1", @@ -1144,12 +1140,12 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - Placement: &placementv1alpha1.PlacementRef{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + Placement: &placementv1beta1.PlacementRef{ Name: "other-placement", }, - ResourceSelectors: []placementv1alpha1.ResourceSelector{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "apps", Version: "v1", @@ -1161,8 +1157,8 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { }, }, }, - wantCRO: []*placementv1alpha1.ClusterResourceOverrideSnapshot{}, - wantRO: []*placementv1alpha1.ResourceOverrideSnapshot{}, + wantCRO: []*placementv1beta1.ClusterResourceOverrideSnapshot{}, + wantRO: []*placementv1beta1.ResourceOverrideSnapshot{}, }, } @@ -1189,10 +1185,10 @@ func TestFetchAllMatchingOverridesForResourceSnapshot(t *testing.T) { } options := []cmp.Option{ cmpopts.IgnoreFields(metav1.ObjectMeta{}, "ResourceVersion"), - cmpopts.SortSlices(func(o1, o2 placementv1alpha1.ClusterResourceOverride) bool { + cmpopts.SortSlices(func(o1, o2 placementv1beta1.ClusterResourceOverride) bool { return o1.Name < o2.Name }), - cmpopts.SortSlices(func(o1, o2 placementv1alpha1.ResourceOverride) bool { + cmpopts.SortSlices(func(o1, o2 placementv1beta1.ResourceOverride) bool { if o1.Namespace == o2.Namespace { return o1.Name < o2.Name } @@ -1215,8 +1211,8 @@ func TestPickFromResourceMatchedOverridesForTargetCluster(t *testing.T) { tests := []struct { name string cluster *clusterv1beta1.MemberCluster - croList []*placementv1alpha1.ClusterResourceOverrideSnapshot - roList []*placementv1alpha1.ResourceOverrideSnapshot + croList []*placementv1beta1.ClusterResourceOverrideSnapshot + roList []*placementv1beta1.ResourceOverrideSnapshot wantCRO []string wantRO []placementv1beta1.NamespacedName wantErr error @@ -1238,15 +1234,15 @@ func TestPickFromResourceMatchedOverridesForTargetCluster(t *testing.T) { Name: clusterName, }, }, - croList: []*placementv1alpha1.ClusterResourceOverrideSnapshot{ + croList: []*placementv1beta1.ClusterResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "cro-1", }, - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { // empty cluster label selector selects all clusters ClusterSelector: &placementv1beta1.ClusterSelector{}, @@ -1273,10 +1269,10 @@ func TestPickFromResourceMatchedOverridesForTargetCluster(t *testing.T) { ObjectMeta: metav1.ObjectMeta{ Name: "cro-2", }, - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { // empty cluster label selector selects all clusters ClusterSelector: &placementv1beta1.ClusterSelector{}, @@ -1287,16 +1283,16 @@ func TestPickFromResourceMatchedOverridesForTargetCluster(t *testing.T) { }, }, }, - roList: []*placementv1alpha1.ResourceOverrideSnapshot{ + roList: []*placementv1beta1.ResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "ro-1", Namespace: "svc-namespace", }, - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { // empty cluster label selector selects all clusters ClusterSelector: &placementv1beta1.ClusterSelector{}, @@ -1311,10 +1307,10 @@ func TestPickFromResourceMatchedOverridesForTargetCluster(t *testing.T) { Name: "ro-2", Namespace: "deployment-namespace", }, - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { // empty cluster label selector selects all clusters ClusterSelector: &placementv1beta1.ClusterSelector{}, @@ -1339,7 +1335,7 @@ func TestPickFromResourceMatchedOverridesForTargetCluster(t *testing.T) { }, { name: "cluster not found", - croList: []*placementv1alpha1.ClusterResourceOverrideSnapshot{ + croList: []*placementv1beta1.ClusterResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "cro-2", @@ -1347,10 +1343,10 @@ func TestPickFromResourceMatchedOverridesForTargetCluster(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { // empty cluster label selector selects all clusters ClusterSelector: &placementv1beta1.ClusterSelector{}, @@ -1375,7 +1371,7 @@ func TestPickFromResourceMatchedOverridesForTargetCluster(t *testing.T) { Name: clusterName, }, }, - croList: []*placementv1alpha1.ClusterResourceOverrideSnapshot{ + croList: []*placementv1beta1.ClusterResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "cro-1", @@ -1383,10 +1379,10 @@ func TestPickFromResourceMatchedOverridesForTargetCluster(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { // empty cluster label selector selects all clusters ClusterSelector: &placementv1beta1.ClusterSelector{}, @@ -1416,10 +1412,10 @@ func TestPickFromResourceMatchedOverridesForTargetCluster(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { // empty cluster label selector selects all clusters ClusterSelector: &placementv1beta1.ClusterSelector{}, @@ -1430,7 +1426,7 @@ func TestPickFromResourceMatchedOverridesForTargetCluster(t *testing.T) { }, }, }, - roList: []*placementv1alpha1.ResourceOverrideSnapshot{ + roList: []*placementv1beta1.ResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "ro-1", @@ -1439,10 +1435,10 @@ func TestPickFromResourceMatchedOverridesForTargetCluster(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { // empty cluster label selector selects all clusters ClusterSelector: &placementv1beta1.ClusterSelector{}, @@ -1460,10 +1456,10 @@ func TestPickFromResourceMatchedOverridesForTargetCluster(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { // empty cluster label selector selects all clusters ClusterSelector: &placementv1beta1.ClusterSelector{}, @@ -1497,7 +1493,7 @@ func TestPickFromResourceMatchedOverridesForTargetCluster(t *testing.T) { }, }, }, - croList: []*placementv1alpha1.ClusterResourceOverrideSnapshot{ + croList: []*placementv1beta1.ClusterResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "cro-1", @@ -1505,10 +1501,10 @@ func TestPickFromResourceMatchedOverridesForTargetCluster(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -1534,10 +1530,10 @@ func TestPickFromResourceMatchedOverridesForTargetCluster(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -1557,7 +1553,7 @@ func TestPickFromResourceMatchedOverridesForTargetCluster(t *testing.T) { }, }, }, - roList: []*placementv1alpha1.ResourceOverrideSnapshot{ + roList: []*placementv1beta1.ResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "ro-1", @@ -1566,10 +1562,10 @@ func TestPickFromResourceMatchedOverridesForTargetCluster(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -1596,10 +1592,10 @@ func TestPickFromResourceMatchedOverridesForTargetCluster(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -1642,7 +1638,7 @@ func TestPickFromResourceMatchedOverridesForTargetCluster(t *testing.T) { }, }, }, - croList: []*placementv1alpha1.ClusterResourceOverrideSnapshot{ + croList: []*placementv1beta1.ClusterResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "cro-1", @@ -1650,10 +1646,10 @@ func TestPickFromResourceMatchedOverridesForTargetCluster(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ClusterResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ClusterResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ClusterResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -1673,7 +1669,7 @@ func TestPickFromResourceMatchedOverridesForTargetCluster(t *testing.T) { }, }, }, - roList: []*placementv1alpha1.ResourceOverrideSnapshot{ + roList: []*placementv1beta1.ResourceOverrideSnapshot{ { ObjectMeta: metav1.ObjectMeta{ Name: "ro-1", @@ -1682,10 +1678,10 @@ func TestPickFromResourceMatchedOverridesForTargetCluster(t *testing.T) { placementv1beta1.IsLatestSnapshotLabel: "true", }, }, - Spec: placementv1alpha1.ResourceOverrideSnapshotSpec{ - OverrideSpec: placementv1alpha1.ResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ResourceOverrideSnapshotSpec{ + OverrideSpec: placementv1beta1.ResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -1735,7 +1731,7 @@ func TestIsClusterMatched(t *testing.T) { tests := []struct { name string cluster clusterv1beta1.MemberCluster - rule placementv1alpha1.OverrideRule + rule placementv1beta1.OverrideRule want bool }{ { @@ -1745,7 +1741,7 @@ func TestIsClusterMatched(t *testing.T) { Name: "cluster-1", }, }, - rule: placementv1alpha1.OverrideRule{}, // nil cluster selector selects no clusters + rule: placementv1beta1.OverrideRule{}, // nil cluster selector selects no clusters want: false, }, { @@ -1755,7 +1751,7 @@ func TestIsClusterMatched(t *testing.T) { Name: "cluster-1", }, }, - rule: placementv1alpha1.OverrideRule{ + rule: placementv1beta1.OverrideRule{ ClusterSelector: &placementv1beta1.ClusterSelector{}, // empty cluster label selects all clusters }, want: true, @@ -1767,7 +1763,7 @@ func TestIsClusterMatched(t *testing.T) { Name: "cluster-1", }, }, - rule: placementv1alpha1.OverrideRule{ + rule: placementv1beta1.OverrideRule{ ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{}, // empty cluster label terms selects all clusters }, @@ -1781,7 +1777,7 @@ func TestIsClusterMatched(t *testing.T) { Name: "cluster-1", }, }, - rule: placementv1alpha1.OverrideRule{ + rule: placementv1beta1.OverrideRule{ ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { @@ -1799,7 +1795,7 @@ func TestIsClusterMatched(t *testing.T) { Name: "cluster-1", }, }, - rule: placementv1alpha1.OverrideRule{ + rule: placementv1beta1.OverrideRule{ ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { @@ -1821,7 +1817,7 @@ func TestIsClusterMatched(t *testing.T) { }, }, }, - rule: placementv1alpha1.OverrideRule{ + rule: placementv1beta1.OverrideRule{ ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { @@ -1847,7 +1843,7 @@ func TestIsClusterMatched(t *testing.T) { }, }, }, - rule: placementv1alpha1.OverrideRule{ + rule: placementv1beta1.OverrideRule{ ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { @@ -1880,7 +1876,7 @@ func TestIsClusterMatched(t *testing.T) { }, }, }, - rule: placementv1alpha1.OverrideRule{ + rule: placementv1beta1.OverrideRule{ ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { diff --git a/pkg/utils/validator/clusterresourceoverride.go b/pkg/utils/validator/clusterresourceoverride.go index 1f90bc65a..f3f3921d0 100644 --- a/pkg/utils/validator/clusterresourceoverride.go +++ b/pkg/utils/validator/clusterresourceoverride.go @@ -22,12 +22,11 @@ import ( "k8s.io/apimachinery/pkg/util/errors" - fleetv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" - fleetv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" + placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" ) // ValidateClusterResourceOverride validates cluster resource override fields and returns error. -func ValidateClusterResourceOverride(cro fleetv1alpha1.ClusterResourceOverride, croList *fleetv1alpha1.ClusterResourceOverrideList) error { +func ValidateClusterResourceOverride(cro placementv1beta1.ClusterResourceOverride, croList *placementv1beta1.ClusterResourceOverrideList) error { allErr := make([]error, 0) // Check if the resource is being selected by resource name @@ -51,8 +50,8 @@ func ValidateClusterResourceOverride(cro fleetv1alpha1.ClusterResourceOverride, } // validateClusterResourceSelectors checks if override is selecting resource by name. -func validateClusterResourceSelectors(cro fleetv1alpha1.ClusterResourceOverride) error { - selectorMap := make(map[fleetv1beta1.ClusterResourceSelector]bool) +func validateClusterResourceSelectors(cro placementv1beta1.ClusterResourceOverride) error { + selectorMap := make(map[placementv1beta1.ClusterResourceSelector]bool) allErr := make([]error, 0) for _, selector := range cro.Spec.ClusterResourceSelectors { // Check if the resource is not being selected by label selector @@ -75,12 +74,12 @@ func validateClusterResourceSelectors(cro fleetv1alpha1.ClusterResourceOverride) // validateClusterResourceOverrideResourceLimit checks if there is only 1 cluster resource override per resource, // assuming the resource will be selected by the name only. -func validateClusterResourceOverrideResourceLimit(cro fleetv1alpha1.ClusterResourceOverride, croList *fleetv1alpha1.ClusterResourceOverrideList) error { +func validateClusterResourceOverrideResourceLimit(cro placementv1beta1.ClusterResourceOverride, croList *placementv1beta1.ClusterResourceOverrideList) error { // Check if croList is nil or empty, no need to check for resource limit if croList == nil || len(croList.Items) == 0 { return nil } - overrideMap := make(map[fleetv1beta1.ClusterResourceSelector]string) + overrideMap := make(map[placementv1beta1.ClusterResourceSelector]string) // Add overrides and its selectors to the map for _, override := range croList.Items { selectors := override.Spec.ClusterResourceSelectors diff --git a/pkg/utils/validator/clusterresourceoverride_test.go b/pkg/utils/validator/clusterresourceoverride_test.go index 7040fe5df..8278d66aa 100644 --- a/pkg/utils/validator/clusterresourceoverride_test.go +++ b/pkg/utils/validator/clusterresourceoverride_test.go @@ -10,19 +10,18 @@ import ( metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" apierrors "k8s.io/apimachinery/pkg/util/errors" - fleetv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" - fleetv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" + placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" ) func TestValidateClusterResourceSelectors(t *testing.T) { tests := map[string]struct { - cro fleetv1alpha1.ClusterResourceOverride + cro placementv1beta1.ClusterResourceOverride wantErrMsg error }{ "resource selected by label selector": { - cro: fleetv1alpha1.ClusterResourceOverride{ - Spec: fleetv1alpha1.ClusterResourceOverrideSpec{ - ClusterResourceSelectors: []fleetv1beta1.ClusterResourceSelector{ + cro: placementv1beta1.ClusterResourceOverride{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ + ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "group", Version: "v1", @@ -39,9 +38,9 @@ func TestValidateClusterResourceSelectors(t *testing.T) { wantErrMsg: fmt.Errorf("label selector is not supported for resource selection"), }, "resource selected by empty name": { - cro: fleetv1alpha1.ClusterResourceOverride{ - Spec: fleetv1alpha1.ClusterResourceOverrideSpec{ - ClusterResourceSelectors: []fleetv1beta1.ClusterResourceSelector{ + cro: placementv1beta1.ClusterResourceOverride{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ + ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "group", Version: "v1", @@ -54,9 +53,9 @@ func TestValidateClusterResourceSelectors(t *testing.T) { wantErrMsg: fmt.Errorf("resource name is required for resource selection"), }, "duplicate resources selected": { - cro: fleetv1alpha1.ClusterResourceOverride{ - Spec: fleetv1alpha1.ClusterResourceOverrideSpec{ - ClusterResourceSelectors: []fleetv1beta1.ClusterResourceSelector{ + cro: placementv1beta1.ClusterResourceOverride{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ + ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "group", Version: "v1", @@ -73,12 +72,12 @@ func TestValidateClusterResourceSelectors(t *testing.T) { }, }, wantErrMsg: fmt.Errorf("resource selector %+v already exists, and must be unique", - fleetv1beta1.ClusterResourceSelector{Group: "group", Version: "v1", Kind: "Kind", Name: "example"}), + placementv1beta1.ClusterResourceSelector{Group: "group", Version: "v1", Kind: "Kind", Name: "example"}), }, "resource selected by name": { - cro: fleetv1alpha1.ClusterResourceOverride{ - Spec: fleetv1alpha1.ClusterResourceOverrideSpec{ - ClusterResourceSelectors: []fleetv1beta1.ClusterResourceSelector{ + cro: placementv1beta1.ClusterResourceOverride{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ + ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "rbac.authorization.k8s.io", Version: "v1", @@ -91,9 +90,9 @@ func TestValidateClusterResourceSelectors(t *testing.T) { wantErrMsg: nil, }, "multiple invalid resources selected": { - cro: fleetv1alpha1.ClusterResourceOverride{ - Spec: fleetv1alpha1.ClusterResourceOverrideSpec{ - ClusterResourceSelectors: []fleetv1beta1.ClusterResourceSelector{ + cro: placementv1beta1.ClusterResourceOverride{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ + ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "group", Version: "v1", @@ -125,9 +124,9 @@ func TestValidateClusterResourceSelectors(t *testing.T) { }, }, }, - wantErrMsg: apierrors.NewAggregate([]error{fmt.Errorf("label selector is not supported for resource selection %+v", fleetv1beta1.ClusterResourceSelector{Group: "group", Version: "v1", Kind: "Kind", LabelSelector: &metav1.LabelSelector{MatchLabels: map[string]string{"key": "value"}}}), - fmt.Errorf("resource name is required for resource selection %+v", fleetv1beta1.ClusterResourceSelector{Group: "group", Version: "v1", Kind: "Kind", Name: ""}), - fmt.Errorf("resource selector %+v already exists, and must be unique", fleetv1beta1.ClusterResourceSelector{Group: "group", Version: "v1", Kind: "Kind", Name: "example"})}), + wantErrMsg: apierrors.NewAggregate([]error{fmt.Errorf("label selector is not supported for resource selection %+v", placementv1beta1.ClusterResourceSelector{Group: "group", Version: "v1", Kind: "Kind", LabelSelector: &metav1.LabelSelector{MatchLabels: map[string]string{"key": "value"}}}), + fmt.Errorf("resource name is required for resource selection %+v", placementv1beta1.ClusterResourceSelector{Group: "group", Version: "v1", Kind: "Kind", Name: ""}), + fmt.Errorf("resource selector %+v already exists, and must be unique", placementv1beta1.ClusterResourceSelector{Group: "group", Version: "v1", Kind: "Kind", Name: "example"})}), }, } for testName, tt := range tests { @@ -146,17 +145,17 @@ func TestValidateClusterResourceSelectors(t *testing.T) { func TestValidateClusterResourceOverrideResourceLimit(t *testing.T) { tests := map[string]struct { - cro fleetv1alpha1.ClusterResourceOverride + cro placementv1beta1.ClusterResourceOverride overrideCount int wantErrMsg error }{ "create one cluster resource override for resource foo": { - cro: fleetv1alpha1.ClusterResourceOverride{ + cro: placementv1beta1.ClusterResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: "override-1", }, - Spec: fleetv1alpha1.ClusterResourceOverrideSpec{ - ClusterResourceSelectors: []fleetv1beta1.ClusterResourceSelector{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ + ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "rbac.authorization.k8s.io", Version: "v1", @@ -170,12 +169,12 @@ func TestValidateClusterResourceOverrideResourceLimit(t *testing.T) { wantErrMsg: nil, }, "one override, selecting the same resource by other override already": { - cro: fleetv1alpha1.ClusterResourceOverride{ + cro: placementv1beta1.ClusterResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: "override-2", }, - Spec: fleetv1alpha1.ClusterResourceOverrideSpec{ - ClusterResourceSelectors: []fleetv1beta1.ClusterResourceSelector{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ + ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "group", Version: "v1", @@ -193,15 +192,15 @@ func TestValidateClusterResourceOverrideResourceLimit(t *testing.T) { }, overrideCount: 1, wantErrMsg: fmt.Errorf("invalid resource selector %+v: the resource has been selected by both %v and %v, which is not supported", - fleetv1beta1.ClusterResourceSelector{Group: "group", Version: "v1", Kind: "kind", Name: "example-0"}, "override-2", "override-0"), + placementv1beta1.ClusterResourceSelector{Group: "group", Version: "v1", Kind: "kind", Name: "example-0"}, "override-2", "override-0"), }, "one override, which exists": { - cro: fleetv1alpha1.ClusterResourceOverride{ + cro: placementv1beta1.ClusterResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: "override-1", }, - Spec: fleetv1alpha1.ClusterResourceOverrideSpec{ - ClusterResourceSelectors: []fleetv1beta1.ClusterResourceSelector{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ + ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "rbac.authorization.k8s.io", Version: "v1", @@ -215,12 +214,12 @@ func TestValidateClusterResourceOverrideResourceLimit(t *testing.T) { wantErrMsg: nil, }, "croList is empty": { - cro: fleetv1alpha1.ClusterResourceOverride{ + cro: placementv1beta1.ClusterResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: "override-2", }, - Spec: fleetv1alpha1.ClusterResourceOverrideSpec{ - ClusterResourceSelectors: []fleetv1beta1.ClusterResourceSelector{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ + ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "rbac.authorization.k8s.io", Version: "v1", @@ -236,14 +235,14 @@ func TestValidateClusterResourceOverrideResourceLimit(t *testing.T) { } for testName, tt := range tests { t.Run(testName, func(t *testing.T) { - croList := &fleetv1alpha1.ClusterResourceOverrideList{} + croList := &placementv1beta1.ClusterResourceOverrideList{} for i := 0; i < tt.overrideCount; i++ { - cro := fleetv1alpha1.ClusterResourceOverride{ + cro := placementv1beta1.ClusterResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: fmt.Sprintf("override-%d", i), }, - Spec: fleetv1alpha1.ClusterResourceOverrideSpec{ - ClusterResourceSelectors: []fleetv1beta1.ClusterResourceSelector{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ + ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "group", Version: "v1", @@ -268,8 +267,8 @@ func TestValidateClusterResourceOverrideResourceLimit(t *testing.T) { } func TestValidateClusterResourceOverride(t *testing.T) { - validClusterSelector := &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{ + validClusterSelector := &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { LabelSelector: &metav1.LabelSelector{ MatchLabels: map[string]string{ @@ -287,16 +286,16 @@ func TestValidateClusterResourceOverride(t *testing.T) { }, } - validJSONPatchOverrides := []fleetv1alpha1.JSONPatchOverride{ + validJSONPatchOverrides := []placementv1beta1.JSONPatchOverride{ { - Operator: fleetv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/labels/new-label", Value: apiextensionsv1.JSON{Raw: []byte(`"new-value"`)}, }, } - validPolicy := &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + validPolicy := &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: validClusterSelector, JSONPatchOverrides: validJSONPatchOverrides, @@ -305,14 +304,14 @@ func TestValidateClusterResourceOverride(t *testing.T) { } tests := map[string]struct { - cro fleetv1alpha1.ClusterResourceOverride - croList *fleetv1alpha1.ClusterResourceOverrideList + cro placementv1beta1.ClusterResourceOverride + croList *placementv1beta1.ClusterResourceOverrideList wantErrMsg error }{ "valid cluster resource override": { - cro: fleetv1alpha1.ClusterResourceOverride{ - Spec: fleetv1alpha1.ClusterResourceOverrideSpec{ - ClusterResourceSelectors: []fleetv1beta1.ClusterResourceSelector{ + cro: placementv1beta1.ClusterResourceOverride{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ + ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "rbac.authorization.k8s.io", Version: "v1", @@ -323,13 +322,13 @@ func TestValidateClusterResourceOverride(t *testing.T) { Policy: validPolicy, }, }, - croList: &fleetv1alpha1.ClusterResourceOverrideList{}, + croList: &placementv1beta1.ClusterResourceOverrideList{}, wantErrMsg: nil, }, "invalid cluster resource override - fail validateResourceSelector": { - cro: fleetv1alpha1.ClusterResourceOverride{ - Spec: fleetv1alpha1.ClusterResourceOverrideSpec{ - ClusterResourceSelectors: []fleetv1beta1.ClusterResourceSelector{ + cro: placementv1beta1.ClusterResourceOverride{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ + ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "group", Version: "v1", @@ -356,20 +355,20 @@ func TestValidateClusterResourceOverride(t *testing.T) { Policy: validPolicy, }, }, - croList: &fleetv1alpha1.ClusterResourceOverrideList{}, + croList: &placementv1beta1.ClusterResourceOverrideList{}, wantErrMsg: apierrors.NewAggregate([]error{fmt.Errorf("resource selector %+v already exists, and must be unique", - fleetv1beta1.ClusterResourceSelector{Group: "group", Version: "v1", Kind: "kind", Name: "example"}), + placementv1beta1.ClusterResourceSelector{Group: "group", Version: "v1", Kind: "kind", Name: "example"}), fmt.Errorf("label selector is not supported for resource selection %+v", - fleetv1beta1.ClusterResourceSelector{Group: "group", Version: "v1", Kind: "kind", + placementv1beta1.ClusterResourceSelector{Group: "group", Version: "v1", Kind: "kind", LabelSelector: &metav1.LabelSelector{MatchLabels: map[string]string{"key": "value"}}})}), }, "invalid cluster resource override - fail ValidateClusterResourceOverrideResourceLimit": { - cro: fleetv1alpha1.ClusterResourceOverride{ + cro: placementv1beta1.ClusterResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: "override-1", }, - Spec: fleetv1alpha1.ClusterResourceOverrideSpec{ - ClusterResourceSelectors: []fleetv1beta1.ClusterResourceSelector{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ + ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "group", Version: "v1", @@ -380,12 +379,12 @@ func TestValidateClusterResourceOverride(t *testing.T) { Policy: validPolicy, }, }, - croList: &fleetv1alpha1.ClusterResourceOverrideList{ - Items: []fleetv1alpha1.ClusterResourceOverride{ + croList: &placementv1beta1.ClusterResourceOverrideList{ + Items: []placementv1beta1.ClusterResourceOverride{ { ObjectMeta: metav1.ObjectMeta{Name: "override-0"}, - Spec: fleetv1alpha1.ClusterResourceOverrideSpec{ - ClusterResourceSelectors: []fleetv1beta1.ClusterResourceSelector{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ + ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "group", Version: "v1", @@ -399,12 +398,12 @@ func TestValidateClusterResourceOverride(t *testing.T) { }, }, wantErrMsg: fmt.Errorf("invalid resource selector %+v: the resource has been selected by both %v and %v, which is not supported", - fleetv1beta1.ClusterResourceSelector{Group: "group", Version: "v1", Kind: "kind", Name: "duplicate-example"}, "override-1", "override-0"), + placementv1beta1.ClusterResourceSelector{Group: "group", Version: "v1", Kind: "kind", Name: "duplicate-example"}, "override-1", "override-0"), }, "valid cluster resource override - empty croList": { - cro: fleetv1alpha1.ClusterResourceOverride{ - Spec: fleetv1alpha1.ClusterResourceOverrideSpec{ - ClusterResourceSelectors: []fleetv1beta1.ClusterResourceSelector{ + cro: placementv1beta1.ClusterResourceOverride{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ + ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "rbac.authorization.k8s.io", Version: "v1", @@ -415,13 +414,13 @@ func TestValidateClusterResourceOverride(t *testing.T) { Policy: validPolicy, }, }, - croList: &fleetv1alpha1.ClusterResourceOverrideList{}, + croList: &placementv1beta1.ClusterResourceOverrideList{}, wantErrMsg: nil, }, "valid cluster resource override - croList nil": { - cro: fleetv1alpha1.ClusterResourceOverride{ - Spec: fleetv1alpha1.ClusterResourceOverrideSpec{ - ClusterResourceSelectors: []fleetv1beta1.ClusterResourceSelector{ + cro: placementv1beta1.ClusterResourceOverride{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ + ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "rbac.authorization.k8s.io", Version: "v1", @@ -436,19 +435,19 @@ func TestValidateClusterResourceOverride(t *testing.T) { wantErrMsg: nil, }, "invalid cluster resource override - fail validateClusterResourceOverridePolicy with unsupported type": { - cro: fleetv1alpha1.ClusterResourceOverride{ - Spec: fleetv1alpha1.ClusterResourceOverrideSpec{ - Policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + cro: placementv1beta1.ClusterResourceOverride{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - ClusterSelector: &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{ + ClusterSelector: &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { - PropertySelector: &fleetv1beta1.PropertySelector{ - MatchExpressions: []fleetv1beta1.PropertySelectorRequirement{ + PropertySelector: &placementv1beta1.PropertySelector{ + MatchExpressions: []placementv1beta1.PropertySelectorRequirement{ { Name: "example", - Operator: fleetv1beta1.PropertySelectorGreaterThanOrEqualTo, + Operator: placementv1beta1.PropertySelectorGreaterThanOrEqualTo, Values: []string{"1"}, }, }, @@ -461,17 +460,17 @@ func TestValidateClusterResourceOverride(t *testing.T) { }, }, }, - croList: &fleetv1alpha1.ClusterResourceOverrideList{}, + croList: &placementv1beta1.ClusterResourceOverrideList{}, wantErrMsg: errors.New("only labelSelector is supported"), }, "invalid cluster resource override - fail validateClusterResourceOverridePolicy with nil label selector": { - cro: fleetv1alpha1.ClusterResourceOverride{ - Spec: fleetv1alpha1.ClusterResourceOverrideSpec{ - Policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + cro: placementv1beta1.ClusterResourceOverride{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - ClusterSelector: &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{ + ClusterSelector: &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { LabelSelector: nil, }, @@ -485,13 +484,13 @@ func TestValidateClusterResourceOverride(t *testing.T) { wantErrMsg: errors.New("labelSelector is required"), }, "valid cluster resource override - empty cluster selector terms": { - cro: fleetv1alpha1.ClusterResourceOverride{ - Spec: fleetv1alpha1.ClusterResourceOverrideSpec{ - Policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + cro: placementv1beta1.ClusterResourceOverride{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - ClusterSelector: &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{}, + ClusterSelector: &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{}, }, JSONPatchOverrides: validJSONPatchOverrides, }, @@ -502,13 +501,13 @@ func TestValidateClusterResourceOverride(t *testing.T) { wantErrMsg: nil, }, "valid cluster resource override - empty match labels & match expressions": { - cro: fleetv1alpha1.ClusterResourceOverride{ - Spec: fleetv1alpha1.ClusterResourceOverrideSpec{ - Policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + cro: placementv1beta1.ClusterResourceOverride{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - ClusterSelector: &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{ + ClusterSelector: &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { LabelSelector: &metav1.LabelSelector{MatchLabels: nil}, }, @@ -517,8 +516,8 @@ func TestValidateClusterResourceOverride(t *testing.T) { JSONPatchOverrides: validJSONPatchOverrides, }, { - ClusterSelector: &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{ + ClusterSelector: &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { LabelSelector: &metav1.LabelSelector{MatchExpressions: nil}, }, @@ -533,21 +532,21 @@ func TestValidateClusterResourceOverride(t *testing.T) { wantErrMsg: nil, }, "valid cluster resource override - no policy": { - cro: fleetv1alpha1.ClusterResourceOverride{ - Spec: fleetv1alpha1.ClusterResourceOverrideSpec{ + cro: placementv1beta1.ClusterResourceOverride{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ Policy: nil, }, }, wantErrMsg: nil, }, "valid cluster resource override - delete policy": { - cro: fleetv1alpha1.ClusterResourceOverride{ - Spec: fleetv1alpha1.ClusterResourceOverrideSpec{ - Policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + cro: placementv1beta1.ClusterResourceOverride{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: validClusterSelector, - OverrideType: fleetv1alpha1.DeleteOverrideType, + OverrideType: placementv1beta1.DeleteOverrideType, }, }, }, @@ -556,13 +555,13 @@ func TestValidateClusterResourceOverride(t *testing.T) { wantErrMsg: nil, }, "valid cluster resource override - policy with all label selectors": { - cro: fleetv1alpha1.ClusterResourceOverride{ - Spec: fleetv1alpha1.ClusterResourceOverrideSpec{ - Policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + cro: placementv1beta1.ClusterResourceOverride{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - ClusterSelector: &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{ + ClusterSelector: &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { LabelSelector: &metav1.LabelSelector{ MatchLabels: map[string]string{ @@ -579,12 +578,12 @@ func TestValidateClusterResourceOverride(t *testing.T) { }, }, }, - OverrideType: fleetv1alpha1.JSONPatchOverrideType, + OverrideType: placementv1beta1.JSONPatchOverrideType, JSONPatchOverrides: validJSONPatchOverrides, }, { - ClusterSelector: &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{ + ClusterSelector: &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { LabelSelector: &metav1.LabelSelector{ MatchLabels: map[string]string{ @@ -601,7 +600,7 @@ func TestValidateClusterResourceOverride(t *testing.T) { }, }, }, - OverrideType: fleetv1alpha1.JSONPatchOverrideType, + OverrideType: placementv1beta1.JSONPatchOverrideType, JSONPatchOverrides: validJSONPatchOverrides, }, }, @@ -611,19 +610,19 @@ func TestValidateClusterResourceOverride(t *testing.T) { wantErrMsg: nil, }, "invalid cluster resource override - policy with unsupported selector type": { - cro: fleetv1alpha1.ClusterResourceOverride{ - Spec: fleetv1alpha1.ClusterResourceOverrideSpec{ - Policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + cro: placementv1beta1.ClusterResourceOverride{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - ClusterSelector: &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{ + ClusterSelector: &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { - PropertySelector: &fleetv1beta1.PropertySelector{ - MatchExpressions: []fleetv1beta1.PropertySelectorRequirement{ + PropertySelector: &placementv1beta1.PropertySelector{ + MatchExpressions: []placementv1beta1.PropertySelectorRequirement{ { Name: "example", - Operator: fleetv1beta1.PropertySelectorGreaterThanOrEqualTo, + Operator: placementv1beta1.PropertySelectorGreaterThanOrEqualTo, Values: []string{"1"}, }, }, @@ -639,12 +638,12 @@ func TestValidateClusterResourceOverride(t *testing.T) { wantErrMsg: errors.New("only labelSelector is supported"), }, "valid cluster resource override - policy with no cluster selector": { - cro: fleetv1alpha1.ClusterResourceOverride{ - Spec: fleetv1alpha1.ClusterResourceOverrideSpec{ - Policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + cro: placementv1beta1.ClusterResourceOverride{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - OverrideType: fleetv1alpha1.JSONPatchOverrideType, + OverrideType: placementv1beta1.JSONPatchOverrideType, JSONPatchOverrides: validJSONPatchOverrides, }, }, @@ -654,13 +653,13 @@ func TestValidateClusterResourceOverride(t *testing.T) { wantErrMsg: nil, }, "invalid cluster resource override - policy with multiple rules": { - cro: fleetv1alpha1.ClusterResourceOverride{ - Spec: fleetv1alpha1.ClusterResourceOverrideSpec{ - Policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + cro: placementv1beta1.ClusterResourceOverride{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - ClusterSelector: &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{ + ClusterSelector: &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { LabelSelector: &metav1.LabelSelector{ MatchLabels: map[string]string{ @@ -669,23 +668,23 @@ func TestValidateClusterResourceOverride(t *testing.T) { }, }, { - PropertySorter: &fleetv1beta1.PropertySorter{ + PropertySorter: &placementv1beta1.PropertySorter{ Name: "example", - SortOrder: fleetv1beta1.Descending, + SortOrder: placementv1beta1.Descending, }, }, }, }, }, { - ClusterSelector: &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{ + ClusterSelector: &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { - PropertySelector: &fleetv1beta1.PropertySelector{ - MatchExpressions: []fleetv1beta1.PropertySelectorRequirement{ + PropertySelector: &placementv1beta1.PropertySelector{ + MatchExpressions: []placementv1beta1.PropertySelectorRequirement{ { Name: "example", - Operator: fleetv1beta1.PropertySelectorGreaterThanOrEqualTo, + Operator: placementv1beta1.PropertySelectorGreaterThanOrEqualTo, Values: []string{"1"}, }, }, @@ -701,17 +700,17 @@ func TestValidateClusterResourceOverride(t *testing.T) { wantErrMsg: errors.New("only labelSelector is supported"), }, "valid cluster resource override - policy with nil label selector": { - cro: fleetv1alpha1.ClusterResourceOverride{ - Spec: fleetv1alpha1.ClusterResourceOverrideSpec{ - Policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + cro: placementv1beta1.ClusterResourceOverride{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - ClusterSelector: &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{ + ClusterSelector: &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ {}, }, }, - OverrideType: fleetv1alpha1.JSONPatchOverrideType, + OverrideType: placementv1beta1.JSONPatchOverrideType, JSONPatchOverrides: validJSONPatchOverrides, }, }, @@ -721,13 +720,13 @@ func TestValidateClusterResourceOverride(t *testing.T) { wantErrMsg: errors.New("labelSelector is required"), }, "invalid cluster resource override - multiple invalid override paths, 1 valid": { - cro: fleetv1alpha1.ClusterResourceOverride{ - Spec: fleetv1alpha1.ClusterResourceOverrideSpec{ - Policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + cro: placementv1beta1.ClusterResourceOverride{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - ClusterSelector: &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{ + ClusterSelector: &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { LabelSelector: &metav1.LabelSelector{ MatchLabels: map[string]string{ @@ -737,24 +736,24 @@ func TestValidateClusterResourceOverride(t *testing.T) { }, }, }, - OverrideType: fleetv1alpha1.JSONPatchOverrideType, - JSONPatchOverrides: []fleetv1alpha1.JSONPatchOverride{ + OverrideType: placementv1beta1.JSONPatchOverrideType, + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: fleetv1alpha1.JSONPatchOverrideOpRemove, + Operator: placementv1beta1.JSONPatchOverrideOpRemove, Path: "/Kind", }, { - Operator: fleetv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "spec.resourceSelectors/matchExpressions", Value: apiextensionsv1.JSON{Raw: []byte(`"new-value"`)}, }, { - Operator: fleetv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "", Value: apiextensionsv1.JSON{Raw: []byte(`"new-reason"`)}, }, { - Operator: fleetv1alpha1.JSONPatchOverrideOpRemove, + Operator: placementv1beta1.JSONPatchOverrideOpRemove, Path: "/status", Value: apiextensionsv1.JSON{Raw: []byte(`"new-value"`)}, }, @@ -766,22 +765,22 @@ func TestValidateClusterResourceOverride(t *testing.T) { }, wantErrMsg: apierrors.NewAggregate([]error{ fmt.Errorf("invalid JSONPatchOverride %s: path must start with /", - fleetv1alpha1.JSONPatchOverride{Operator: fleetv1alpha1.JSONPatchOverrideOpAdd, Path: "spec.resourceSelectors/matchExpressions", Value: apiextensionsv1.JSON{Raw: []byte(`"new-value"`)}}), + placementv1beta1.JSONPatchOverride{Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "spec.resourceSelectors/matchExpressions", Value: apiextensionsv1.JSON{Raw: []byte(`"new-value"`)}}), fmt.Errorf("invalid JSONPatchOverride %s: path cannot be empty", - fleetv1alpha1.JSONPatchOverride{Operator: fleetv1alpha1.JSONPatchOverrideOpReplace, Path: "", Value: apiextensionsv1.JSON{Raw: []byte(`"new-reason"`)}}), + placementv1beta1.JSONPatchOverride{Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "", Value: apiextensionsv1.JSON{Raw: []byte(`"new-reason"`)}}), fmt.Errorf("invalid JSONPatchOverride %s: cannot override status fields", - fleetv1alpha1.JSONPatchOverride{Operator: fleetv1alpha1.JSONPatchOverrideOpRemove, Path: "/status", Value: apiextensionsv1.JSON{Raw: []byte(`"new-value"`)}}), + placementv1beta1.JSONPatchOverride{Operator: placementv1beta1.JSONPatchOverrideOpRemove, Path: "/status", Value: apiextensionsv1.JSON{Raw: []byte(`"new-value"`)}}), fmt.Errorf("invalid JSONPatchOverride %s: remove operation cannot have value", - fleetv1alpha1.JSONPatchOverride{Operator: fleetv1alpha1.JSONPatchOverrideOpRemove, Path: "/status", Value: apiextensionsv1.JSON{Raw: []byte(`"new-value"`)}}), + placementv1beta1.JSONPatchOverride{Operator: placementv1beta1.JSONPatchOverrideOpRemove, Path: "/status", Value: apiextensionsv1.JSON{Raw: []byte(`"new-value"`)}}), }), }, "valid cluster resource override - empty cluster selector": { - cro: fleetv1alpha1.ClusterResourceOverride{ - Spec: fleetv1alpha1.ClusterResourceOverrideSpec{ - Policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + cro: placementv1beta1.ClusterResourceOverride{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - ClusterSelector: &fleetv1beta1.ClusterSelector{}, + ClusterSelector: &placementv1beta1.ClusterSelector{}, JSONPatchOverrides: validJSONPatchOverrides, }, }, diff --git a/pkg/utils/validator/resourceoverride.go b/pkg/utils/validator/resourceoverride.go index 9dc881a86..116523541 100644 --- a/pkg/utils/validator/resourceoverride.go +++ b/pkg/utils/validator/resourceoverride.go @@ -24,11 +24,11 @@ import ( apierrors "k8s.io/apimachinery/pkg/util/errors" - fleetv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" + placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" ) // ValidateResourceOverride validates resource override fields and returns error. -func ValidateResourceOverride(ro fleetv1alpha1.ResourceOverride, roList *fleetv1alpha1.ResourceOverrideList) error { +func ValidateResourceOverride(ro placementv1beta1.ResourceOverride, roList *placementv1beta1.ResourceOverrideList) error { allErr := make([]error, 0) // Check if the resource is being selected by resource name. @@ -52,8 +52,8 @@ func ValidateResourceOverride(ro fleetv1alpha1.ResourceOverride, roList *fleetv1 } // validateResourceSelectors checks if override is selecting a unique resource. -func validateResourceSelectors(ro fleetv1alpha1.ResourceOverride) error { - selectorMap := make(map[fleetv1alpha1.ResourceSelector]bool) +func validateResourceSelectors(ro placementv1beta1.ResourceOverride) error { + selectorMap := make(map[placementv1beta1.ResourceSelector]bool) allErr := make([]error, 0) for _, selector := range ro.Spec.ResourceSelectors { // Check if there are any duplicate selectors. @@ -67,12 +67,12 @@ func validateResourceSelectors(ro fleetv1alpha1.ResourceOverride) error { // validateResourceOverrideResourceLimit checks if there is only 1 resource override per resource, // assuming the resource will be selected by the name only. -func validateResourceOverrideResourceLimit(ro fleetv1alpha1.ResourceOverride, roList *fleetv1alpha1.ResourceOverrideList) error { +func validateResourceOverrideResourceLimit(ro placementv1beta1.ResourceOverride, roList *placementv1beta1.ResourceOverrideList) error { // Check if roList is nil or empty, no need to check for resource limit. if roList == nil || len(roList.Items) == 0 { return nil } - overrideMap := make(map[fleetv1alpha1.ResourceSelector]string) + overrideMap := make(map[placementv1beta1.ResourceSelector]string) // Add overrides and its selectors to the map. for _, override := range roList.Items { selectors := override.Spec.ResourceSelectors @@ -96,7 +96,7 @@ func validateResourceOverrideResourceLimit(ro fleetv1alpha1.ResourceOverride, ro } // validateOverridePolicy checks if override rule is selecting resource by name. -func validateOverridePolicy(policy *fleetv1alpha1.OverridePolicy) error { +func validateOverridePolicy(policy *placementv1beta1.OverridePolicy) error { allErr := make([]error, 0) for _, rule := range policy.OverrideRules { if rule.ClusterSelector != nil { @@ -114,12 +114,12 @@ func validateOverridePolicy(policy *fleetv1alpha1.OverridePolicy) error { } } switch rule.OverrideType { - case fleetv1alpha1.DeleteOverrideType: + case placementv1beta1.DeleteOverrideType: if len(rule.JSONPatchOverrides) != 0 { return errors.New("invalid JSONPatchOverrides: JSONPatchOverrides cannot be set when the override type is Delete") } - case fleetv1alpha1.JSONPatchOverrideType: + case placementv1beta1.JSONPatchOverrideType: if err := validateJSONPatchOverride(rule.JSONPatchOverrides); err != nil { allErr = append(allErr, err) } @@ -129,7 +129,7 @@ func validateOverridePolicy(policy *fleetv1alpha1.OverridePolicy) error { } // validateJSONPatchOverride checks if JSON patch override is valid. -func validateJSONPatchOverride(jsonPatchOverrides []fleetv1alpha1.JSONPatchOverride) error { +func validateJSONPatchOverride(jsonPatchOverrides []placementv1beta1.JSONPatchOverride) error { if len(jsonPatchOverrides) == 0 { return errors.New("invalid JSONPatchOverrides: JSONPatchOverrides cannot be empty") } @@ -140,7 +140,7 @@ func validateJSONPatchOverride(jsonPatchOverrides []fleetv1alpha1.JSONPatchOverr allErr = append(allErr, fmt.Errorf("invalid JSONPatchOverride %s: %w", patch, err)) } - if patch.Operator == fleetv1alpha1.JSONPatchOverrideOpRemove && len(patch.Value.Raw) != 0 { + if patch.Operator == placementv1beta1.JSONPatchOverrideOpRemove && len(patch.Value.Raw) != 0 { allErr = append(allErr, fmt.Errorf("invalid JSONPatchOverride %s: remove operation cannot have value", patch)) } } diff --git a/pkg/utils/validator/resourceoverride_test.go b/pkg/utils/validator/resourceoverride_test.go index e870aa6c6..b90c4af8b 100644 --- a/pkg/utils/validator/resourceoverride_test.go +++ b/pkg/utils/validator/resourceoverride_test.go @@ -10,19 +10,18 @@ import ( metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" apierrors "k8s.io/apimachinery/pkg/util/errors" - fleetv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" - fleetv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" + placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" ) func TestValidateResourceSelectors(t *testing.T) { tests := map[string]struct { - ro fleetv1alpha1.ResourceOverride + ro placementv1beta1.ResourceOverride wantErrMsg error }{ "duplicate resources selected": { - ro: fleetv1alpha1.ResourceOverride{ - Spec: fleetv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []fleetv1alpha1.ResourceSelector{ + ro: placementv1beta1.ResourceOverride{ + Spec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "group", Version: "v1", @@ -39,12 +38,12 @@ func TestValidateResourceSelectors(t *testing.T) { }, }, wantErrMsg: fmt.Errorf("resource selector %+v already exists, and must be unique", - fleetv1alpha1.ResourceSelector{Group: "group", Version: "v1", Kind: "Kind", Name: "example"}), + placementv1beta1.ResourceSelector{Group: "group", Version: "v1", Kind: "Kind", Name: "example"}), }, "resource selected by name": { - ro: fleetv1alpha1.ResourceOverride{ - Spec: fleetv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []fleetv1alpha1.ResourceSelector{ + ro: placementv1beta1.ResourceOverride{ + Spec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "rbac.authorization.k8s.io", Version: "v1", @@ -73,17 +72,17 @@ func TestValidateResourceSelectors(t *testing.T) { func TestValidateResourceOverrideResourceLimit(t *testing.T) { tests := map[string]struct { - ro fleetv1alpha1.ResourceOverride + ro placementv1beta1.ResourceOverride overrideCount int wantErrMsg error }{ "create one resource override for resource foo": { - ro: fleetv1alpha1.ResourceOverride{ + ro: placementv1beta1.ResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: "override-1", }, - Spec: fleetv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []fleetv1alpha1.ResourceSelector{ + Spec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "rbac.authorization.k8s.io", Version: "v1", @@ -97,12 +96,12 @@ func TestValidateResourceOverrideResourceLimit(t *testing.T) { wantErrMsg: nil, }, "one override, selecting the same resource by other override already": { - ro: fleetv1alpha1.ResourceOverride{ + ro: placementv1beta1.ResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: "override-2", }, - Spec: fleetv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []fleetv1alpha1.ResourceSelector{ + Spec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "group", Version: "v1", @@ -120,15 +119,15 @@ func TestValidateResourceOverrideResourceLimit(t *testing.T) { }, overrideCount: 1, wantErrMsg: fmt.Errorf("invalid resource selector %+v: the resource has been selected by both %v and %v, which is not supported", - fleetv1alpha1.ResourceSelector{Group: "group", Version: "v1", Kind: "kind", Name: "example-0"}, "override-2", "override-0"), + placementv1beta1.ResourceSelector{Group: "group", Version: "v1", Kind: "kind", Name: "example-0"}, "override-2", "override-0"), }, "one override, which exists": { - ro: fleetv1alpha1.ResourceOverride{ + ro: placementv1beta1.ResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: "override-1", }, - Spec: fleetv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []fleetv1alpha1.ResourceSelector{ + Spec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "rbac.authorization.k8s.io", Version: "v1", @@ -142,12 +141,12 @@ func TestValidateResourceOverrideResourceLimit(t *testing.T) { wantErrMsg: nil, }, "roList is empty": { - ro: fleetv1alpha1.ResourceOverride{ + ro: placementv1beta1.ResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: "override-2", }, - Spec: fleetv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []fleetv1alpha1.ResourceSelector{ + Spec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "rbac.authorization.k8s.io", Version: "v1", @@ -163,14 +162,14 @@ func TestValidateResourceOverrideResourceLimit(t *testing.T) { } for testName, tt := range tests { t.Run(testName, func(t *testing.T) { - roList := &fleetv1alpha1.ResourceOverrideList{} + roList := &placementv1beta1.ResourceOverrideList{} for i := 0; i < tt.overrideCount; i++ { - ro := fleetv1alpha1.ResourceOverride{ + ro := placementv1beta1.ResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: fmt.Sprintf("override-%d", i), }, - Spec: fleetv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []fleetv1alpha1.ResourceSelector{ + Spec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "group", Version: "v1", @@ -195,8 +194,8 @@ func TestValidateResourceOverrideResourceLimit(t *testing.T) { } func TestValidateResourceOverride(t *testing.T) { - validClusterSelector := &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{ + validClusterSelector := &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { LabelSelector: &metav1.LabelSelector{ MatchLabels: map[string]string{ @@ -214,16 +213,16 @@ func TestValidateResourceOverride(t *testing.T) { }, } - validJSONPatchOverrides := []fleetv1alpha1.JSONPatchOverride{ + validJSONPatchOverrides := []placementv1beta1.JSONPatchOverride{ { - Operator: fleetv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/labels/new-label", Value: apiextensionsv1.JSON{Raw: []byte(`"new-value"`)}, }, } - validPolicy := &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + validPolicy := &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: validClusterSelector, JSONPatchOverrides: validJSONPatchOverrides, @@ -232,14 +231,14 @@ func TestValidateResourceOverride(t *testing.T) { } tests := map[string]struct { - ro fleetv1alpha1.ResourceOverride - roList *fleetv1alpha1.ResourceOverrideList + ro placementv1beta1.ResourceOverride + roList *placementv1beta1.ResourceOverrideList wantErrMsg error }{ "valid resource override": { - ro: fleetv1alpha1.ResourceOverride{ - Spec: fleetv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []fleetv1alpha1.ResourceSelector{ + ro: placementv1beta1.ResourceOverride{ + Spec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "rbac.authorization.k8s.io", Version: "v1", @@ -250,13 +249,13 @@ func TestValidateResourceOverride(t *testing.T) { Policy: validPolicy, }, }, - roList: &fleetv1alpha1.ResourceOverrideList{}, + roList: &placementv1beta1.ResourceOverrideList{}, wantErrMsg: nil, }, "invalid resource override - fail validateResourceSelector": { - ro: fleetv1alpha1.ResourceOverride{ - Spec: fleetv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []fleetv1alpha1.ResourceSelector{ + ro: placementv1beta1.ResourceOverride{ + Spec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "group", Version: "v1", @@ -273,17 +272,17 @@ func TestValidateResourceOverride(t *testing.T) { Policy: validPolicy, }, }, - roList: &fleetv1alpha1.ResourceOverrideList{}, + roList: &placementv1beta1.ResourceOverrideList{}, wantErrMsg: fmt.Errorf("resource selector %+v already exists, and must be unique", - fleetv1alpha1.ResourceSelector{Group: "group", Version: "v1", Kind: "kind", Name: "example"}), + placementv1beta1.ResourceSelector{Group: "group", Version: "v1", Kind: "kind", Name: "example"}), }, "invalid resource override - fail ValidateResourceOverrideResourceLimit": { - ro: fleetv1alpha1.ResourceOverride{ + ro: placementv1beta1.ResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: "override-1", }, - Spec: fleetv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []fleetv1alpha1.ResourceSelector{ + Spec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "group", Version: "v1", @@ -294,12 +293,12 @@ func TestValidateResourceOverride(t *testing.T) { Policy: validPolicy, }, }, - roList: &fleetv1alpha1.ResourceOverrideList{ - Items: []fleetv1alpha1.ResourceOverride{ + roList: &placementv1beta1.ResourceOverrideList{ + Items: []placementv1beta1.ResourceOverride{ { ObjectMeta: metav1.ObjectMeta{Name: "override-0"}, - Spec: fleetv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []fleetv1alpha1.ResourceSelector{ + Spec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "group", Version: "v1", @@ -312,12 +311,12 @@ func TestValidateResourceOverride(t *testing.T) { }, }, wantErrMsg: fmt.Errorf("invalid resource selector %+v: the resource has been selected by both %v and %v, which is not supported", - fleetv1alpha1.ResourceSelector{Group: "group", Version: "v1", Kind: "kind", Name: "duplicate-example"}, "override-1", "override-0"), + placementv1beta1.ResourceSelector{Group: "group", Version: "v1", Kind: "kind", Name: "duplicate-example"}, "override-1", "override-0"), }, "valid resource override - empty roList": { - ro: fleetv1alpha1.ResourceOverride{ - Spec: fleetv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []fleetv1alpha1.ResourceSelector{ + ro: placementv1beta1.ResourceOverride{ + Spec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "rbac.authorization.k8s.io", Version: "v1", @@ -328,13 +327,13 @@ func TestValidateResourceOverride(t *testing.T) { Policy: validPolicy, }, }, - roList: &fleetv1alpha1.ResourceOverrideList{}, + roList: &placementv1beta1.ResourceOverrideList{}, wantErrMsg: nil, }, "valid resource override - roList nil": { - ro: fleetv1alpha1.ResourceOverride{ - Spec: fleetv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []fleetv1alpha1.ResourceSelector{ + ro: placementv1beta1.ResourceOverride{ + Spec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "rbac.authorization.k8s.io", Version: "v1", @@ -349,9 +348,9 @@ func TestValidateResourceOverride(t *testing.T) { wantErrMsg: nil, }, "valid resource override - delete nil": { - ro: fleetv1alpha1.ResourceOverride{ - Spec: fleetv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []fleetv1alpha1.ResourceSelector{ + ro: placementv1beta1.ResourceOverride{ + Spec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "rbac.authorization.k8s.io", Version: "v1", @@ -359,11 +358,11 @@ func TestValidateResourceOverride(t *testing.T) { Name: "test-cluster-role", }, }, - Policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: validClusterSelector, - OverrideType: fleetv1alpha1.DeleteOverrideType, + OverrideType: placementv1beta1.DeleteOverrideType, }, }, }, @@ -373,19 +372,19 @@ func TestValidateResourceOverride(t *testing.T) { wantErrMsg: nil, }, "invalid resource override - fail validateResourceOverridePolicy with unsupported type ": { - ro: fleetv1alpha1.ResourceOverride{ - Spec: fleetv1alpha1.ResourceOverrideSpec{ - Policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + ro: placementv1beta1.ResourceOverride{ + Spec: placementv1beta1.ResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - ClusterSelector: &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{ + ClusterSelector: &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { - PropertySelector: &fleetv1beta1.PropertySelector{ - MatchExpressions: []fleetv1beta1.PropertySelectorRequirement{ + PropertySelector: &placementv1beta1.PropertySelector{ + MatchExpressions: []placementv1beta1.PropertySelectorRequirement{ { Name: "example", - Operator: fleetv1beta1.PropertySelectorGreaterThanOrEqualTo, + Operator: placementv1beta1.PropertySelectorGreaterThanOrEqualTo, Values: []string{"1"}, }, }, @@ -398,17 +397,17 @@ func TestValidateResourceOverride(t *testing.T) { }, }, }, - roList: &fleetv1alpha1.ResourceOverrideList{}, + roList: &placementv1beta1.ResourceOverrideList{}, wantErrMsg: fmt.Errorf("only labelSelector is supported"), }, "invalid resource override - fail validateResourceOverridePolicy with nil label selector": { - ro: fleetv1alpha1.ResourceOverride{ - Spec: fleetv1alpha1.ResourceOverrideSpec{ - Policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + ro: placementv1beta1.ResourceOverride{ + Spec: placementv1beta1.ResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - ClusterSelector: &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{ + ClusterSelector: &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { LabelSelector: nil, }, @@ -422,13 +421,13 @@ func TestValidateResourceOverride(t *testing.T) { wantErrMsg: errors.New("labelSelector is required"), }, "valid resource override - empty cluster selector": { - ro: fleetv1alpha1.ResourceOverride{ - Spec: fleetv1alpha1.ResourceOverrideSpec{ - Policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + ro: placementv1beta1.ResourceOverride{ + Spec: placementv1beta1.ResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - ClusterSelector: &fleetv1beta1.ClusterSelector{}, - OverrideType: fleetv1alpha1.JSONPatchOverrideType, + ClusterSelector: &placementv1beta1.ClusterSelector{}, + OverrideType: placementv1beta1.JSONPatchOverrideType, JSONPatchOverrides: validJSONPatchOverrides, }, }, @@ -438,15 +437,15 @@ func TestValidateResourceOverride(t *testing.T) { wantErrMsg: nil, }, "valid resource override - cluster selector with empty terms": { - ro: fleetv1alpha1.ResourceOverride{ - Spec: fleetv1alpha1.ResourceOverrideSpec{ - Policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + ro: placementv1beta1.ResourceOverride{ + Spec: placementv1beta1.ResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - ClusterSelector: &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{}, + ClusterSelector: &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{}, }, - OverrideType: fleetv1alpha1.JSONPatchOverrideType, + OverrideType: placementv1beta1.JSONPatchOverrideType, JSONPatchOverrides: validJSONPatchOverrides, }, }, @@ -456,30 +455,30 @@ func TestValidateResourceOverride(t *testing.T) { wantErrMsg: nil, }, "valid resource override - empty match labels & match expressions": { - ro: fleetv1alpha1.ResourceOverride{ - Spec: fleetv1alpha1.ResourceOverrideSpec{ - Policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + ro: placementv1beta1.ResourceOverride{ + Spec: placementv1beta1.ResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - ClusterSelector: &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{ + ClusterSelector: &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { LabelSelector: &metav1.LabelSelector{MatchLabels: nil}, }, }, }, - OverrideType: fleetv1alpha1.JSONPatchOverrideType, + OverrideType: placementv1beta1.JSONPatchOverrideType, JSONPatchOverrides: validJSONPatchOverrides, }, { - ClusterSelector: &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{ + ClusterSelector: &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { LabelSelector: &metav1.LabelSelector{MatchExpressions: nil}, }, }, }, - OverrideType: fleetv1alpha1.JSONPatchOverrideType, + OverrideType: placementv1beta1.JSONPatchOverrideType, JSONPatchOverrides: validJSONPatchOverrides, }, }, @@ -489,21 +488,21 @@ func TestValidateResourceOverride(t *testing.T) { wantErrMsg: nil, }, "valid resource override - no policy": { - ro: fleetv1alpha1.ResourceOverride{ - Spec: fleetv1alpha1.ResourceOverrideSpec{ + ro: placementv1beta1.ResourceOverride{ + Spec: placementv1beta1.ResourceOverrideSpec{ Policy: nil, }, }, wantErrMsg: nil, }, "invalid resource override - multiple invalid override paths": { - ro: fleetv1alpha1.ResourceOverride{ - Spec: fleetv1alpha1.ResourceOverrideSpec{ - Policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + ro: placementv1beta1.ResourceOverride{ + Spec: placementv1beta1.ResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - ClusterSelector: &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{ + ClusterSelector: &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { LabelSelector: &metav1.LabelSelector{ MatchLabels: map[string]string{ @@ -513,24 +512,24 @@ func TestValidateResourceOverride(t *testing.T) { }, }, }, - OverrideType: fleetv1alpha1.JSONPatchOverrideType, - JSONPatchOverrides: []fleetv1alpha1.JSONPatchOverride{ + OverrideType: placementv1beta1.JSONPatchOverrideType, + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: fleetv1alpha1.JSONPatchOverrideOpRemove, + Operator: placementv1beta1.JSONPatchOverrideOpRemove, Path: "/apiVersion", }, { - Operator: fleetv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/annotations/0", Value: apiextensionsv1.JSON{Raw: []byte(`"new-value"`)}, }, { - Operator: fleetv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/status/conditions/0/reason", Value: apiextensionsv1.JSON{Raw: []byte(`"new-reason"`)}, }, { - Operator: fleetv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/////kind///", Value: apiextensionsv1.JSON{Raw: []byte(`"value"`)}, }, @@ -541,11 +540,11 @@ func TestValidateResourceOverride(t *testing.T) { }, }, wantErrMsg: apierrors.NewAggregate([]error{fmt.Errorf("invalid JSONPatchOverride %s: cannot override typeMeta fields", - fleetv1alpha1.JSONPatchOverride{Operator: fleetv1alpha1.JSONPatchOverrideOpRemove, Path: "/apiVersion"}), + placementv1beta1.JSONPatchOverride{Operator: placementv1beta1.JSONPatchOverrideOpRemove, Path: "/apiVersion"}), fmt.Errorf("invalid JSONPatchOverride %s: cannot override status fields", - fleetv1alpha1.JSONPatchOverride{Operator: fleetv1alpha1.JSONPatchOverrideOpReplace, Path: "/status/conditions/0/reason", Value: apiextensionsv1.JSON{Raw: []byte(`"new-reason"`)}}), + placementv1beta1.JSONPatchOverride{Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/status/conditions/0/reason", Value: apiextensionsv1.JSON{Raw: []byte(`"new-reason"`)}}), fmt.Errorf("invalid JSONPatchOverride %s: path cannot contain empty string", - fleetv1alpha1.JSONPatchOverride{Operator: fleetv1alpha1.JSONPatchOverrideOpReplace, Path: "/////kind///", Value: apiextensionsv1.JSON{Raw: []byte(`"value"`)}}), + placementv1beta1.JSONPatchOverride{Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/////kind///", Value: apiextensionsv1.JSON{Raw: []byte(`"value"`)}}), }), }, } @@ -564,24 +563,24 @@ func TestValidateResourceOverride(t *testing.T) { } func TestValidateOverridePolicy(t *testing.T) { - validJSONPatchOverrides := []fleetv1alpha1.JSONPatchOverride{ + validJSONPatchOverrides := []placementv1beta1.JSONPatchOverride{ { - Operator: fleetv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/labels/new-label", Value: apiextensionsv1.JSON{Raw: []byte(`"new-value"`)}, }, } tests := map[string]struct { - policy *fleetv1alpha1.OverridePolicy + policy *placementv1beta1.OverridePolicy wantErrMsg error }{ "all label selectors": { - policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - ClusterSelector: &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{ + ClusterSelector: &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { LabelSelector: &metav1.LabelSelector{ MatchLabels: map[string]string{ @@ -601,8 +600,8 @@ func TestValidateOverridePolicy(t *testing.T) { JSONPatchOverrides: validJSONPatchOverrides, }, { - ClusterSelector: &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{ + ClusterSelector: &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { LabelSelector: &metav1.LabelSelector{ MatchLabels: map[string]string{ @@ -626,17 +625,17 @@ func TestValidateOverridePolicy(t *testing.T) { wantErrMsg: nil, }, "unsupported selector type - property selector": { - policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - ClusterSelector: &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{ + ClusterSelector: &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { - PropertySelector: &fleetv1beta1.PropertySelector{ - MatchExpressions: []fleetv1beta1.PropertySelectorRequirement{ + PropertySelector: &placementv1beta1.PropertySelector{ + MatchExpressions: []placementv1beta1.PropertySelectorRequirement{ { Name: "example", - Operator: fleetv1beta1.PropertySelectorGreaterThanOrEqualTo, + Operator: placementv1beta1.PropertySelectorGreaterThanOrEqualTo, Values: []string{"1"}, }, }, @@ -650,8 +649,8 @@ func TestValidateOverridePolicy(t *testing.T) { wantErrMsg: fmt.Errorf("only labelSelector is supported"), }, "no cluster selector": { - policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { JSONPatchOverrides: validJSONPatchOverrides, }, @@ -660,10 +659,10 @@ func TestValidateOverridePolicy(t *testing.T) { wantErrMsg: nil, }, "empty cluster selector": { - policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - ClusterSelector: &fleetv1beta1.ClusterSelector{}, + ClusterSelector: &placementv1beta1.ClusterSelector{}, JSONPatchOverrides: validJSONPatchOverrides, }, }, @@ -671,11 +670,11 @@ func TestValidateOverridePolicy(t *testing.T) { wantErrMsg: nil, }, "nil label selector": { - policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - ClusterSelector: &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{ + ClusterSelector: &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ {}, }, }, @@ -685,11 +684,11 @@ func TestValidateOverridePolicy(t *testing.T) { wantErrMsg: errors.New("labelSelector is required"), }, "nil JSONPatchOverride": { - policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - ClusterSelector: &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{ + ClusterSelector: &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { LabelSelector: &metav1.LabelSelector{ MatchLabels: map[string]string{ @@ -699,7 +698,7 @@ func TestValidateOverridePolicy(t *testing.T) { }, }, }, - OverrideType: fleetv1alpha1.JSONPatchOverrideType, + OverrideType: placementv1beta1.JSONPatchOverrideType, JSONPatchOverrides: nil, }, }, @@ -707,11 +706,11 @@ func TestValidateOverridePolicy(t *testing.T) { wantErrMsg: errors.New("JSONPatchOverrides cannot be empty"), }, "empty JSONPatchOverrides with jsonPatch override type": { - policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - ClusterSelector: &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{ + ClusterSelector: &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { LabelSelector: &metav1.LabelSelector{ MatchLabels: map[string]string{ @@ -721,19 +720,19 @@ func TestValidateOverridePolicy(t *testing.T) { }, }, }, - OverrideType: fleetv1alpha1.JSONPatchOverrideType, - JSONPatchOverrides: []fleetv1alpha1.JSONPatchOverride{}, + OverrideType: placementv1beta1.JSONPatchOverrideType, + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{}, }, }, }, wantErrMsg: errors.New("JSONPatchOverrides cannot be empty"), }, "JSONPatchOverrides with delete override type": { - policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - ClusterSelector: &fleetv1beta1.ClusterSelector{ - ClusterSelectorTerms: []fleetv1beta1.ClusterSelectorTerm{ + ClusterSelector: &placementv1beta1.ClusterSelector{ + ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { LabelSelector: &metav1.LabelSelector{ MatchLabels: map[string]string{ @@ -743,7 +742,7 @@ func TestValidateOverridePolicy(t *testing.T) { }, }, }, - OverrideType: fleetv1alpha1.DeleteOverrideType, + OverrideType: placementv1beta1.DeleteOverrideType, JSONPatchOverrides: validJSONPatchOverrides, }, }, @@ -751,14 +750,14 @@ func TestValidateOverridePolicy(t *testing.T) { wantErrMsg: errors.New("JSONPatchOverrides cannot be set when the override type is Delete"), }, "invalid JSONPatchOverridesPath": { - policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - ClusterSelector: &fleetv1beta1.ClusterSelector{}, - OverrideType: fleetv1alpha1.JSONPatchOverrideType, - JSONPatchOverrides: []fleetv1alpha1.JSONPatchOverride{ + ClusterSelector: &placementv1beta1.ClusterSelector{}, + OverrideType: placementv1beta1.JSONPatchOverrideType, + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: fleetv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/metadata/finalizers", Value: apiextensionsv1.JSON{Raw: []byte(`"new-value"`)}, }, @@ -769,14 +768,14 @@ func TestValidateOverridePolicy(t *testing.T) { wantErrMsg: errors.New("cannot override metadata fields except annotations and labels"), }, "invalid JSONPatchOverride": { - policy: &fleetv1alpha1.OverridePolicy{ - OverrideRules: []fleetv1alpha1.OverrideRule{ + policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { - ClusterSelector: &fleetv1beta1.ClusterSelector{}, - OverrideType: fleetv1alpha1.JSONPatchOverrideType, - JSONPatchOverrides: []fleetv1alpha1.JSONPatchOverride{ + ClusterSelector: &placementv1beta1.ClusterSelector{}, + OverrideType: placementv1beta1.JSONPatchOverrideType, + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: fleetv1alpha1.JSONPatchOverrideOpRemove, + Operator: placementv1beta1.JSONPatchOverrideOpRemove, Path: "/apiVersionabc", Value: apiextensionsv1.JSON{Raw: []byte(`"new-value"`)}, }, @@ -803,13 +802,13 @@ func TestValidateOverridePolicy(t *testing.T) { func TestValidateJSONPatchOverride(t *testing.T) { tests := map[string]struct { - jsonPatchOverrides []fleetv1alpha1.JSONPatchOverride + jsonPatchOverrides []placementv1beta1.JSONPatchOverride wantErrMsg error }{ "valid json patch override": { - jsonPatchOverrides: []fleetv1alpha1.JSONPatchOverride{ + jsonPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: fleetv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/spec/clusterResourceSelector/kind", Value: apiextensionsv1.JSON{Raw: []byte(`"ClusterRole"`)}, }, @@ -817,9 +816,9 @@ func TestValidateJSONPatchOverride(t *testing.T) { wantErrMsg: nil, }, "invalid json patch override - invalid remove operation": { - jsonPatchOverrides: []fleetv1alpha1.JSONPatchOverride{ + jsonPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: fleetv1alpha1.JSONPatchOverrideOpRemove, + Operator: placementv1beta1.JSONPatchOverrideOpRemove, Path: "/spec/clusterResourceSelector/kind", Value: apiextensionsv1.JSON{Raw: []byte(`"ClusterRole"`)}, }, @@ -831,13 +830,13 @@ func TestValidateJSONPatchOverride(t *testing.T) { wantErrMsg: errors.New("JSONPatchOverrides cannot be empty"), }, "invalid json patch override - empty jsonPatchOverrides": { - jsonPatchOverrides: []fleetv1alpha1.JSONPatchOverride{}, + jsonPatchOverrides: []placementv1beta1.JSONPatchOverride{}, wantErrMsg: errors.New("JSONPatchOverrides cannot be empty"), }, "invalid json patch override - invalid path": { - jsonPatchOverrides: []fleetv1alpha1.JSONPatchOverride{ + jsonPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: fleetv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/status/conditions/0/reason", Value: apiextensionsv1.JSON{Raw: []byte(`"new-reason"`)}, }, diff --git a/pkg/webhook/clusterresourceoverride/clusterresourceoverride_validating_webhook.go b/pkg/webhook/clusterresourceoverride/clusterresourceoverride_validating_webhook.go index 5aeea8a07..47cc4aff5 100644 --- a/pkg/webhook/clusterresourceoverride/clusterresourceoverride_validating_webhook.go +++ b/pkg/webhook/clusterresourceoverride/clusterresourceoverride_validating_webhook.go @@ -29,14 +29,14 @@ import ( "sigs.k8s.io/controller-runtime/pkg/webhook" "sigs.k8s.io/controller-runtime/pkg/webhook/admission" - fleetv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" + placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" "go.goms.io/fleet/pkg/utils" "go.goms.io/fleet/pkg/utils/validator" ) var ( // ValidationPath is the webhook service path which admission requests are routed to for validating ClusterResourceOverride resources. - ValidationPath = fmt.Sprintf(utils.ValidationPathFmt, fleetv1alpha1.GroupVersion.Group, fleetv1alpha1.GroupVersion.Version, "clusterresourceoverride") + ValidationPath = fmt.Sprintf(utils.ValidationPathFmt, placementv1beta1.GroupVersion.Group, placementv1beta1.GroupVersion.Version, "clusterresourceoverride") ) type clusterResourceOverrideValidator struct { @@ -53,7 +53,7 @@ func Add(mgr manager.Manager) error { // Handle clusterResourceOverrideValidator checks to see if cluster resource override is valid func (v *clusterResourceOverrideValidator) Handle(ctx context.Context, req admission.Request) admission.Response { - var cro fleetv1alpha1.ClusterResourceOverride + var cro placementv1beta1.ClusterResourceOverride klog.V(2).InfoS("Validating webhook handling cluster resource override", "operation", req.Operation) if err := v.decoder.Decode(req, &cro); err != nil { klog.ErrorS(err, "Failed to decode cluster resource override object for validating fields", "userName", req.UserInfo.Username, "groups", req.UserInfo.Groups) @@ -80,8 +80,8 @@ func (v *clusterResourceOverrideValidator) Handle(ctx context.Context, req admis } // listClusterResourceOverride returns a list of cluster resource overrides. -func listClusterResourceOverride(ctx context.Context, client client.Client) (*fleetv1alpha1.ClusterResourceOverrideList, error) { - croList := &fleetv1alpha1.ClusterResourceOverrideList{} +func listClusterResourceOverride(ctx context.Context, client client.Client) (*placementv1beta1.ClusterResourceOverrideList, error) { + croList := &placementv1beta1.ClusterResourceOverrideList{} if err := client.List(ctx, croList); err != nil { klog.ErrorS(err, "Failed to list clusterResourceOverrides when validating") return nil, fmt.Errorf("failed to list clusterResourceOverrides, please retry the request: %w", err) diff --git a/pkg/webhook/resourceoverride/resourceoverride_validating_webhook.go b/pkg/webhook/resourceoverride/resourceoverride_validating_webhook.go index c52639f01..149b794ed 100644 --- a/pkg/webhook/resourceoverride/resourceoverride_validating_webhook.go +++ b/pkg/webhook/resourceoverride/resourceoverride_validating_webhook.go @@ -29,14 +29,14 @@ import ( "sigs.k8s.io/controller-runtime/pkg/webhook" "sigs.k8s.io/controller-runtime/pkg/webhook/admission" - fleetv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" + placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" "go.goms.io/fleet/pkg/utils" "go.goms.io/fleet/pkg/utils/validator" ) var ( // ValidationPath is the webhook service path which admission requests are routed to for validating resourceoverride resources. - ValidationPath = fmt.Sprintf(utils.ValidationPathFmt, fleetv1alpha1.GroupVersion.Group, fleetv1alpha1.GroupVersion.Version, "resourceoverride") + ValidationPath = fmt.Sprintf(utils.ValidationPathFmt, placementv1beta1.GroupVersion.Group, placementv1beta1.GroupVersion.Version, "resourceoverride") ) type resourceOverrideValidator struct { @@ -53,7 +53,7 @@ func Add(mgr manager.Manager) error { // Handle resourceOverrideValidator checks to see if resource override is valid. func (v *resourceOverrideValidator) Handle(ctx context.Context, req admission.Request) admission.Response { - var ro fleetv1alpha1.ResourceOverride + var ro placementv1beta1.ResourceOverride klog.V(2).InfoS("Validating webhook handling resource override", "operation", req.Operation) if err := v.decoder.Decode(req, &ro); err != nil { klog.ErrorS(err, "Failed to decode resource override object for validating fields", "userName", req.UserInfo.Username, "groups", req.UserInfo.Groups) @@ -61,7 +61,7 @@ func (v *resourceOverrideValidator) Handle(ctx context.Context, req admission.Re } // List all the resource overrides in the same namespace - roList := &fleetv1alpha1.ResourceOverrideList{} + roList := &placementv1beta1.ResourceOverrideList{} if err := v.client.List(ctx, roList, client.InNamespace(ro.Namespace)); err != nil { klog.ErrorS(err, "Failed to list resourceOverrides when validating") return admission.Errored(http.StatusInternalServerError, fmt.Errorf("failed to list resourceOverrides, please retry the request: %w", err)) diff --git a/pkg/webhook/webhook.go b/pkg/webhook/webhook.go index 7b1ff19fb..1524b5953 100644 --- a/pkg/webhook/webhook.go +++ b/pkg/webhook/webhook.go @@ -53,7 +53,6 @@ import ( workv1alpha1 "sigs.k8s.io/work-api/pkg/apis/v1alpha1" clusterv1beta1 "go.goms.io/fleet/apis/cluster/v1beta1" - placementv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" fleetv1alpha1 "go.goms.io/fleet/apis/v1alpha1" "go.goms.io/fleet/cmd/hubagent/options" @@ -351,7 +350,7 @@ func (w *Config) buildFleetValidatingWebhooks() []admv1.ValidatingWebhook { admv1.Create, admv1.Update, }, - Rule: createRule([]string{placementv1alpha1.GroupVersion.Group}, []string{placementv1alpha1.GroupVersion.Version}, []string{clusterResourceOverrideName}, &clusterScope), + Rule: createRule([]string{placementv1beta1.GroupVersion.Group}, []string{placementv1beta1.GroupVersion.Version}, []string{clusterResourceOverrideName}, &clusterScope), }, }, TimeoutSeconds: longWebhookTimeout, @@ -368,7 +367,7 @@ func (w *Config) buildFleetValidatingWebhooks() []admv1.ValidatingWebhook { admv1.Create, admv1.Update, }, - Rule: createRule([]string{placementv1alpha1.GroupVersion.Group}, []string{placementv1alpha1.GroupVersion.Version}, []string{resourceOverrideName}, &namespacedScope), + Rule: createRule([]string{placementv1beta1.GroupVersion.Group}, []string{placementv1beta1.GroupVersion.Version}, []string{resourceOverrideName}, &namespacedScope), }, }, TimeoutSeconds: longWebhookTimeout, diff --git a/test/e2e/README.md b/test/e2e/README.md index 8c9a30660..01e204a58 100644 --- a/test/e2e/README.md +++ b/test/e2e/README.md @@ -40,6 +40,11 @@ test suites, follow the steps below: ginkgo --label-filter="custom" -v -p . ``` + or run tests involving member cluster join/leave scenarios with the following command (serially) + ```sh + ginkgo --label-filter="joinleave" -v . + ``` + or create a launch.json in your vscode workspace. ```yaml { diff --git a/test/e2e/join_and_leave_test.go b/test/e2e/join_and_leave_test.go index 1aeb2d8af..a1e4891c7 100644 --- a/test/e2e/join_and_leave_test.go +++ b/test/e2e/join_and_leave_test.go @@ -43,7 +43,7 @@ const ( ) // Note that this container cannot run in parallel with other containers. -var _ = Describe("Test member cluster join and leave flow", Ordered, Serial, func() { +var _ = Describe("Test member cluster join and leave flow", Label("joinleave"), Ordered, Serial, func() { crpName := fmt.Sprintf(crpNameTemplate, GinkgoParallelProcess()) workNamespaceName := fmt.Sprintf(workNamespaceNameTemplate, GinkgoParallelProcess()) internalServiceExportName := fmt.Sprintf("internal-service-export-%d", GinkgoParallelProcess()) @@ -79,7 +79,7 @@ var _ = Describe("Test member cluster join and leave flow", Ordered, Serial, fun } }) - Context("Test cluster join and leave flow with CRP not deleted", Ordered, Serial, func() { + Context("Test cluster join and leave flow with CRP not deleted", Label("joinleave"), Ordered, Serial, func() { It("Create the test resources in the namespace", createWrappedResourcesForEnvelopTest) It("Create the CRP that select the name space and place it to all clusters", func() { @@ -245,8 +245,8 @@ var _ = Describe("Test member cluster join and leave flow", Ordered, Serial, fun }) }) -var _ = Describe("Test member cluster force delete flow", Ordered, Serial, func() { - Context("Test cluster join and leave flow with member agent down and force delete member cluster", Ordered, Serial, func() { +var _ = Describe("Test member cluster force delete flow", Label("joinleave"), Ordered, Serial, func() { + Context("Test cluster join and leave flow with member agent down and force delete member cluster", Label("joinleave"), Ordered, Serial, func() { It("Simulate the member agent going down in member cluster", func() { updateMemberAgentDeploymentReplicas(memberCluster3WestProdClient, 0) }) diff --git a/test/e2e/placement_cro_test.go b/test/e2e/placement_cro_test.go index 32030520d..adce9e73b 100644 --- a/test/e2e/placement_cro_test.go +++ b/test/e2e/placement_cro_test.go @@ -26,7 +26,6 @@ import ( metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" - placementv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" ) @@ -37,28 +36,28 @@ import ( var _ = Context("creating clusterResourceOverride (selecting all clusters) to override all resources under the namespace", Ordered, func() { crpName := fmt.Sprintf(crpNameTemplate, GinkgoParallelProcess()) croName := fmt.Sprintf(croNameTemplate, GinkgoParallelProcess()) - croSnapShotName := fmt.Sprintf(placementv1alpha1.OverrideSnapshotNameFmt, croName, 0) + croSnapShotName := fmt.Sprintf(placementv1beta1.OverrideSnapshotNameFmt, croName, 0) BeforeAll(func() { By("creating work resources") createWorkResources() // Create the cro before crp so that the observed resource index is predictable. - cro := &placementv1alpha1.ClusterResourceOverride{ + cro := &placementv1beta1.ClusterResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: croName, }, - Spec: placementv1alpha1.ClusterResourceOverrideSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ ClusterResourceSelectors: workResourceSelector(), - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{}, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/annotations", Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`{"%s": "%s"}`, croTestAnnotationKey, croTestAnnotationValue))}, }, @@ -72,7 +71,7 @@ var _ = Context("creating clusterResourceOverride (selecting all clusters) to ov Expect(hubClient.Create(ctx, cro)).To(Succeed(), "Failed to create clusterResourceOverride %s", croName) //this is to make sure the cro snapshot is created before the CRP Eventually(func() error { - croSnap := &placementv1alpha1.ClusterResourceOverrideSnapshot{} + croSnap := &placementv1beta1.ClusterResourceOverrideSnapshot{} return hubClient.Get(ctx, types.NamespacedName{Name: croSnapShotName}, croSnap) }, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update ro as expected", crpName) @@ -104,24 +103,24 @@ var _ = Context("creating clusterResourceOverride (selecting all clusters) to ov It("update cro attached to this CRP only and change annotation value", func() { Eventually(func() error { - cro := &placementv1alpha1.ClusterResourceOverride{} + cro := &placementv1beta1.ClusterResourceOverride{} if err := hubClient.Get(ctx, types.NamespacedName{Name: croName}, cro); err != nil { return err } - cro.Spec = placementv1alpha1.ClusterResourceOverrideSpec{ - Placement: &placementv1alpha1.PlacementRef{ + cro.Spec = placementv1beta1.ClusterResourceOverrideSpec{ + Placement: &placementv1beta1.PlacementRef{ Name: crpName, // assigned CRP name }, ClusterResourceSelectors: workResourceSelector(), - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{}, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/annotations", // changed the annotation value to croTestAnnotationValue1 Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`{"%s": "%s"}`, croTestAnnotationKey, croTestAnnotationValue1))}, @@ -136,7 +135,7 @@ var _ = Context("creating clusterResourceOverride (selecting all clusters) to ov }) It("should refresh the CRP status even as there is no change on the resources", func() { - wantCRONames := []string{fmt.Sprintf(placementv1alpha1.OverrideSnapshotNameFmt, croName, 1)} + wantCRONames := []string{fmt.Sprintf(placementv1beta1.OverrideSnapshotNameFmt, croName, 1)} crpStatusUpdatedActual := crpStatusWithOverrideUpdatedActual(workResourceIdentifiers(), allMemberClusterNames, "0", wantCRONames, nil) Eventually(crpStatusUpdatedActual, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update CRP %s status as expected", crpName) }) @@ -151,11 +150,11 @@ var _ = Context("creating clusterResourceOverride (selecting all clusters) to ov It("update cro attached to this CRP only and no updates on the namespace", func() { Eventually(func() error { - cro := &placementv1alpha1.ClusterResourceOverride{} + cro := &placementv1beta1.ClusterResourceOverride{} if err := hubClient.Get(ctx, types.NamespacedName{Name: croName}, cro); err != nil { return err } - cro.Spec.Policy.OverrideRules = append(cro.Spec.Policy.OverrideRules, placementv1alpha1.OverrideRule{ + cro.Spec.Policy.OverrideRules = append(cro.Spec.Policy.OverrideRules, placementv1beta1.OverrideRule{ ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { @@ -167,14 +166,14 @@ var _ = Context("creating clusterResourceOverride (selecting all clusters) to ov }, }, }, - OverrideType: placementv1alpha1.DeleteOverrideType, + OverrideType: placementv1beta1.DeleteOverrideType, }) return hubClient.Update(ctx, cro) }, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update cro as expected", crpName) }) It("should update CRP status on demand as expected", func() { - wantCRONames := []string{fmt.Sprintf(placementv1alpha1.OverrideSnapshotNameFmt, croName, 2)} + wantCRONames := []string{fmt.Sprintf(placementv1beta1.OverrideSnapshotNameFmt, croName, 2)} crpStatusUpdatedActual := crpStatusWithOverrideUpdatedActual(workResourceIdentifiers(), allMemberClusterNames, "0", wantCRONames, nil) Eventually(crpStatusUpdatedActual, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update CRP %s status as expected", crpName) }) @@ -207,33 +206,33 @@ var _ = Context("creating clusterResourceOverride (selecting all clusters) to ov var _ = Context("creating clusterResourceOverride with multiple jsonPatchOverrides", Ordered, func() { crpName := fmt.Sprintf(crpNameTemplate, GinkgoParallelProcess()) croName := fmt.Sprintf(croNameTemplate, GinkgoParallelProcess()) - croSnapShotName := fmt.Sprintf(placementv1alpha1.OverrideSnapshotNameFmt, croName, 0) + croSnapShotName := fmt.Sprintf(placementv1beta1.OverrideSnapshotNameFmt, croName, 0) BeforeAll(func() { By("creating work resources") createWorkResources() // Create the cro before crp so that the observed resource index is predictable. - cro := &placementv1alpha1.ClusterResourceOverride{ + cro := &placementv1beta1.ClusterResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: croName, }, - Spec: placementv1alpha1.ClusterResourceOverrideSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ ClusterResourceSelectors: workResourceSelector(), - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{}, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/annotations", Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`{"%s": "%s"}`, croTestAnnotationKey, croTestAnnotationValue))}, }, { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: fmt.Sprintf("/metadata/annotations/%s", croTestAnnotationKey1), Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`"%s"`, croTestAnnotationValue1))}, }, @@ -248,7 +247,7 @@ var _ = Context("creating clusterResourceOverride with multiple jsonPatchOverrid //this is to make sure the cro snapshot is created before the CRP Eventually(func() error { - croSnap := &placementv1alpha1.ClusterResourceOverrideSnapshot{} + croSnap := &placementv1beta1.ClusterResourceOverrideSnapshot{} return hubClient.Get(ctx, types.NamespacedName{Name: croSnapShotName}, croSnap) }, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update ro as expected", crpName) @@ -280,11 +279,11 @@ var _ = Context("creating clusterResourceOverride with multiple jsonPatchOverrid It("update cro attached to an invalid CRP", func() { Eventually(func() error { - cro := &placementv1alpha1.ClusterResourceOverride{} + cro := &placementv1beta1.ClusterResourceOverride{} if err := hubClient.Get(ctx, types.NamespacedName{Name: croName}, cro); err != nil { return err } - cro.Spec.Placement = &placementv1alpha1.PlacementRef{ + cro.Spec.Placement = &placementv1beta1.PlacementRef{ Name: "invalid-crp", // assigned CRP name } return hubClient.Update(ctx, cro) @@ -292,7 +291,7 @@ var _ = Context("creating clusterResourceOverride with multiple jsonPatchOverrid }) It("CRP status should not be changed", func() { - wantCRONames := []string{fmt.Sprintf(placementv1alpha1.OverrideSnapshotNameFmt, croName, 0)} + wantCRONames := []string{fmt.Sprintf(placementv1beta1.OverrideSnapshotNameFmt, croName, 0)} crpStatusUpdatedActual := crpStatusWithOverrideUpdatedActual(workResourceIdentifiers(), allMemberClusterNames, "0", wantCRONames, nil) Consistently(crpStatusUpdatedActual, consistentlyDuration, consistentlyInterval).Should(Succeed(), "CRP %s status has been changed", crpName) }) @@ -301,21 +300,21 @@ var _ = Context("creating clusterResourceOverride with multiple jsonPatchOverrid var _ = Context("creating clusterResourceOverride with different rules for each cluster", Ordered, func() { crpName := fmt.Sprintf(crpNameTemplate, GinkgoParallelProcess()) croName := fmt.Sprintf(croNameTemplate, GinkgoParallelProcess()) - croSnapShotName := fmt.Sprintf(placementv1alpha1.OverrideSnapshotNameFmt, croName, 0) + croSnapShotName := fmt.Sprintf(placementv1beta1.OverrideSnapshotNameFmt, croName, 0) BeforeAll(func() { By("creating work resources") createWorkResources() // Create the cro before crp so that the observed resource index is predictable. - cro := &placementv1alpha1.ClusterResourceOverride{ + cro := &placementv1beta1.ClusterResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: croName, }, - Spec: placementv1alpha1.ClusterResourceOverrideSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ ClusterResourceSelectors: workResourceSelector(), - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -326,9 +325,9 @@ var _ = Context("creating clusterResourceOverride with different rules for each }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/annotations", Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`{"%s": "%s-0"}`, croTestAnnotationKey, croTestAnnotationValue))}, }, @@ -344,9 +343,9 @@ var _ = Context("creating clusterResourceOverride with different rules for each }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/annotations", Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`{"%s": "%s-1"}`, croTestAnnotationKey, croTestAnnotationValue))}, }, @@ -362,9 +361,9 @@ var _ = Context("creating clusterResourceOverride with different rules for each }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/annotations", Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`{"%s": "%s-2"}`, croTestAnnotationKey, croTestAnnotationValue))}, }, @@ -379,7 +378,7 @@ var _ = Context("creating clusterResourceOverride with different rules for each //this is to make sure the cro snapshot is created before the CRP Eventually(func() error { - croSnap := &placementv1alpha1.ClusterResourceOverrideSnapshot{} + croSnap := &placementv1beta1.ClusterResourceOverrideSnapshot{} return hubClient.Get(ctx, types.NamespacedName{Name: croSnapShotName}, croSnap) }, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update ro as expected", crpName) @@ -421,17 +420,17 @@ var _ = Context("creating clusterResourceOverride with different rules for each By("creating work resources") createWorkResources() createCRP(crpName) - cro := &placementv1alpha1.ClusterResourceOverride{ + cro := &placementv1beta1.ClusterResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: croName, }, - Spec: placementv1alpha1.ClusterResourceOverrideSpec{ - Placement: &placementv1alpha1.PlacementRef{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ + Placement: &placementv1beta1.PlacementRef{ Name: crpName, // assigned CRP name }, ClusterResourceSelectors: workResourceSelector(), - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -447,11 +446,11 @@ var _ = Context("creating clusterResourceOverride with different rules for each }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/annotations", - Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`{"%s": "test-%s"}`, croTestAnnotationKey, placementv1alpha1.OverrideClusterNameVariable))}, + Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`{"%s": "test-%s"}`, croTestAnnotationKey, placementv1beta1.OverrideClusterNameVariable))}, }, }, }, @@ -472,7 +471,7 @@ var _ = Context("creating clusterResourceOverride with different rules for each }) It("should update CRP status as expected", func() { - wantCRONames := []string{fmt.Sprintf(placementv1alpha1.OverrideSnapshotNameFmt, croName, 0)} + wantCRONames := []string{fmt.Sprintf(placementv1beta1.OverrideSnapshotNameFmt, croName, 0)} crpStatusUpdatedActual := crpStatusWithOverrideUpdatedActual(workResourceIdentifiers(), allMemberClusterNames, "0", wantCRONames, nil) Eventually(crpStatusUpdatedActual, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update CRP %s status as expected", crpName) }) @@ -491,28 +490,28 @@ var _ = Context("creating clusterResourceOverride with different rules for each var _ = Context("creating clusterResourceOverride with incorrect path", Ordered, func() { crpName := fmt.Sprintf(crpNameTemplate, GinkgoParallelProcess()) croName := fmt.Sprintf(croNameTemplate, GinkgoParallelProcess()) - croSnapShotName := fmt.Sprintf(placementv1alpha1.OverrideSnapshotNameFmt, croName, 0) + croSnapShotName := fmt.Sprintf(placementv1beta1.OverrideSnapshotNameFmt, croName, 0) BeforeAll(func() { By("creating work resources") createWorkResources() // Create the cro before crp so that the observed resource index is predictable. - cro := &placementv1alpha1.ClusterResourceOverride{ + cro := &placementv1beta1.ClusterResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: croName, }, - Spec: placementv1alpha1.ClusterResourceOverrideSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ ClusterResourceSelectors: workResourceSelector(), - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{}, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: fmt.Sprintf("/metadata/annotations/%s", croTestAnnotationKey), Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`"%s"`, croTestAnnotationValue))}, }, @@ -527,7 +526,7 @@ var _ = Context("creating clusterResourceOverride with incorrect path", Ordered, //this is to make sure the cro snapshot is created before the CRP Eventually(func() error { - croSnap := &placementv1alpha1.ClusterResourceOverrideSnapshot{} + croSnap := &placementv1beta1.ClusterResourceOverrideSnapshot{} return hubClient.Get(ctx, types.NamespacedName{Name: croSnapShotName}, croSnap) }, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update ro as expected", crpName) @@ -556,28 +555,28 @@ var _ = Context("creating clusterResourceOverride with incorrect path", Ordered, var _ = Context("creating clusterResourceOverride with and resource becomes invalid after override", Ordered, func() { crpName := fmt.Sprintf(crpNameTemplate, GinkgoParallelProcess()) croName := fmt.Sprintf(croNameTemplate, GinkgoParallelProcess()) - croSnapShotName := fmt.Sprintf(placementv1alpha1.OverrideSnapshotNameFmt, croName, 0) + croSnapShotName := fmt.Sprintf(placementv1beta1.OverrideSnapshotNameFmt, croName, 0) BeforeAll(func() { By("creating work resources") createWorkResources() // Create the cro before crp so that the observed resource index is predictable. - cro := &placementv1alpha1.ClusterResourceOverride{ + cro := &placementv1beta1.ClusterResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: croName, }, - Spec: placementv1alpha1.ClusterResourceOverrideSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ ClusterResourceSelectors: workResourceSelector(), - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{}, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/annotations", Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`"%s"`, croTestAnnotationValue))}, }, @@ -592,7 +591,7 @@ var _ = Context("creating clusterResourceOverride with and resource becomes inva //this is to make sure the cro snapshot is created before the CRP Eventually(func() error { - croSnap := &placementv1alpha1.ClusterResourceOverrideSnapshot{} + croSnap := &placementv1beta1.ClusterResourceOverrideSnapshot{} return hubClient.Get(ctx, types.NamespacedName{Name: croSnapShotName}, croSnap) }, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update ro as expected", crpName) @@ -627,17 +626,17 @@ var _ = Context("creating clusterResourceOverride with delete rules for one clus createWorkResources() // Create the cro before crp so that the observed resource index is predictable. - cro := &placementv1alpha1.ClusterResourceOverride{ + cro := &placementv1beta1.ClusterResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: croName, }, - Spec: placementv1alpha1.ClusterResourceOverrideSpec{ - Placement: &placementv1alpha1.PlacementRef{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ + Placement: &placementv1beta1.PlacementRef{ Name: crpName, // assigned CRP name }, ClusterResourceSelectors: workResourceSelector(), - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -648,9 +647,9 @@ var _ = Context("creating clusterResourceOverride with delete rules for one clus }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/annotations", Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`{"%s": "%s"}`, croTestAnnotationKey1, croTestAnnotationValue1))}, }, @@ -667,7 +666,7 @@ var _ = Context("creating clusterResourceOverride with delete rules for one clus }, }, }, - OverrideType: placementv1alpha1.DeleteOverrideType, + OverrideType: placementv1beta1.DeleteOverrideType, }, }, }, @@ -689,7 +688,7 @@ var _ = Context("creating clusterResourceOverride with delete rules for one clus }) It("should update CRP status as expected", func() { - wantCRONames := []string{fmt.Sprintf(placementv1alpha1.OverrideSnapshotNameFmt, croName, 0)} + wantCRONames := []string{fmt.Sprintf(placementv1beta1.OverrideSnapshotNameFmt, croName, 0)} crpStatusUpdatedActual := crpStatusWithOverrideUpdatedActual(workResourceIdentifiers(), allMemberClusterNames, "0", wantCRONames, nil) Eventually(crpStatusUpdatedActual, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update CRP %s status as expected", crpName) }) diff --git a/test/e2e/placement_ro_test.go b/test/e2e/placement_ro_test.go index 49b71b39b..ee7afe42d 100644 --- a/test/e2e/placement_ro_test.go +++ b/test/e2e/placement_ro_test.go @@ -27,7 +27,6 @@ import ( metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" - placementv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" scheduler "go.goms.io/fleet/pkg/scheduler/framework" "go.goms.io/fleet/pkg/utils/condition" @@ -45,25 +44,25 @@ var _ = Context("creating resourceOverride (selecting all clusters) to override // Create the CRP. createCRP(crpName) // Create the ro. - ro := &placementv1alpha1.ResourceOverride{ + ro := &placementv1beta1.ResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: roName, Namespace: roNamespace, }, - Spec: placementv1alpha1.ResourceOverrideSpec{ - Placement: &placementv1alpha1.PlacementRef{ + Spec: placementv1beta1.ResourceOverrideSpec{ + Placement: &placementv1beta1.PlacementRef{ Name: crpName, // assigned CRP name }, ResourceSelectors: configMapSelector(), - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{}, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/annotations", Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`{"%s": "%s"}`, roTestAnnotationKey, roTestAnnotationValue))}, }, @@ -96,7 +95,7 @@ var _ = Context("creating resourceOverride (selecting all clusters) to override It("should update CRP status as expected", func() { wantRONames := []placementv1beta1.NamespacedName{ - {Namespace: roNamespace, Name: fmt.Sprintf(placementv1alpha1.OverrideSnapshotNameFmt, roName, 0)}, + {Namespace: roNamespace, Name: fmt.Sprintf(placementv1beta1.OverrideSnapshotNameFmt, roName, 0)}, } crpStatusUpdatedActual := crpStatusWithOverrideUpdatedActual(workResourceIdentifiers(), allMemberClusterNames, "0", nil, wantRONames) Eventually(crpStatusUpdatedActual, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update CRP %s status as expected", crpName) @@ -112,24 +111,24 @@ var _ = Context("creating resourceOverride (selecting all clusters) to override It("update ro attached to this CRP only and change annotation value", func() { Eventually(func() error { - ro := &placementv1alpha1.ResourceOverride{} + ro := &placementv1beta1.ResourceOverride{} if err := hubClient.Get(ctx, types.NamespacedName{Name: roName, Namespace: roNamespace}, ro); err != nil { return err } - ro.Spec = placementv1alpha1.ResourceOverrideSpec{ - Placement: &placementv1alpha1.PlacementRef{ + ro.Spec = placementv1beta1.ResourceOverrideSpec{ + Placement: &placementv1beta1.PlacementRef{ Name: crpName, }, ResourceSelectors: configMapSelector(), - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{}, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/annotations", Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`{"%s": "%s"}`, roTestAnnotationKey, roTestAnnotationValue1))}, }, @@ -144,7 +143,7 @@ var _ = Context("creating resourceOverride (selecting all clusters) to override It("should update CRP status as expected", func() { wantRONames := []placementv1beta1.NamespacedName{ - {Namespace: roNamespace, Name: fmt.Sprintf(placementv1alpha1.OverrideSnapshotNameFmt, roName, 1)}, + {Namespace: roNamespace, Name: fmt.Sprintf(placementv1beta1.OverrideSnapshotNameFmt, roName, 1)}, } crpStatusUpdatedActual := crpStatusWithOverrideUpdatedActual(workResourceIdentifiers(), allMemberClusterNames, "0", nil, wantRONames) Eventually(crpStatusUpdatedActual, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update CRP %s status as expected", crpName) @@ -160,11 +159,11 @@ var _ = Context("creating resourceOverride (selecting all clusters) to override It("update ro attached to this CRP only and no update on the configmap itself", func() { Eventually(func() error { - ro := &placementv1alpha1.ResourceOverride{} + ro := &placementv1beta1.ResourceOverride{} if err := hubClient.Get(ctx, types.NamespacedName{Name: roName, Namespace: roNamespace}, ro); err != nil { return err } - ro.Spec.Policy.OverrideRules = append(ro.Spec.Policy.OverrideRules, placementv1alpha1.OverrideRule{ + ro.Spec.Policy.OverrideRules = append(ro.Spec.Policy.OverrideRules, placementv1beta1.OverrideRule{ ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ { @@ -176,7 +175,7 @@ var _ = Context("creating resourceOverride (selecting all clusters) to override }, }, }, - OverrideType: placementv1alpha1.DeleteOverrideType, + OverrideType: placementv1beta1.DeleteOverrideType, }) return hubClient.Update(ctx, ro) }, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update ro as expected", crpName) @@ -184,7 +183,7 @@ var _ = Context("creating resourceOverride (selecting all clusters) to override It("should refresh the CRP status even as there is no change on the resources", func() { wantRONames := []placementv1beta1.NamespacedName{ - {Namespace: roNamespace, Name: fmt.Sprintf(placementv1alpha1.OverrideSnapshotNameFmt, roName, 2)}, + {Namespace: roNamespace, Name: fmt.Sprintf(placementv1beta1.OverrideSnapshotNameFmt, roName, 2)}, } crpStatusUpdatedActual := crpStatusWithOverrideUpdatedActual(workResourceIdentifiers(), allMemberClusterNames, "0", nil, wantRONames) Eventually(crpStatusUpdatedActual, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update CRP %s status as expected", crpName) @@ -203,33 +202,33 @@ var _ = Context("creating resourceOverride with multiple jsonPatchOverrides to o crpName := fmt.Sprintf(crpNameTemplate, GinkgoParallelProcess()) roName := fmt.Sprintf(roNameTemplate, GinkgoParallelProcess()) roNamespace := fmt.Sprintf(workNamespaceNameTemplate, GinkgoParallelProcess()) - roSnapShotName := fmt.Sprintf(placementv1alpha1.OverrideSnapshotNameFmt, roName, 0) + roSnapShotName := fmt.Sprintf(placementv1beta1.OverrideSnapshotNameFmt, roName, 0) BeforeAll(func() { By("creating work resources") createWorkResources() - ro := &placementv1alpha1.ResourceOverride{ + ro := &placementv1beta1.ResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: roName, Namespace: roNamespace, }, - Spec: placementv1alpha1.ResourceOverrideSpec{ + Spec: placementv1beta1.ResourceOverrideSpec{ ResourceSelectors: configMapSelector(), - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{}, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/annotations", Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`{"%s": "%s"}`, roTestAnnotationKey, roTestAnnotationValue))}, }, { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: fmt.Sprintf("/metadata/annotations/%s", roTestAnnotationKey1), Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`"%s"`, roTestAnnotationValue1))}, }, @@ -243,7 +242,7 @@ var _ = Context("creating resourceOverride with multiple jsonPatchOverrides to o Expect(hubClient.Create(ctx, ro)).To(Succeed(), "Failed to create resourceOverride %s", roName) // wait until the snapshot is created so that the observed resource index is predictable. Eventually(func() error { - roSnap := &placementv1alpha1.ResourceOverrideSnapshot{} + roSnap := &placementv1beta1.ResourceOverrideSnapshot{} return hubClient.Get(ctx, types.NamespacedName{Name: roSnapShotName, Namespace: roNamespace}, roSnap) }, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update ro as expected", crpName) @@ -277,11 +276,11 @@ var _ = Context("creating resourceOverride with multiple jsonPatchOverrides to o It("update ro attached to an invalid CRP", func() { Eventually(func() error { - ro := &placementv1alpha1.ResourceOverride{} + ro := &placementv1beta1.ResourceOverride{} if err := hubClient.Get(ctx, types.NamespacedName{Name: roName, Namespace: roNamespace}, ro); err != nil { return err } - ro.Spec.Placement = &placementv1alpha1.PlacementRef{ + ro.Spec.Placement = &placementv1beta1.PlacementRef{ Name: "invalid-crp", // assigned CRP name } return hubClient.Update(ctx, ro) @@ -290,7 +289,7 @@ var _ = Context("creating resourceOverride with multiple jsonPatchOverrides to o It("CRP status should not be changed", func() { wantRONames := []placementv1beta1.NamespacedName{ - {Namespace: roNamespace, Name: fmt.Sprintf(placementv1alpha1.OverrideSnapshotNameFmt, roName, 0)}, + {Namespace: roNamespace, Name: fmt.Sprintf(placementv1beta1.OverrideSnapshotNameFmt, roName, 0)}, } crpStatusUpdatedActual := crpStatusWithOverrideUpdatedActual(workResourceIdentifiers(), allMemberClusterNames, "0", nil, wantRONames) Consistently(crpStatusUpdatedActual, consistentlyDuration, consistentlyInterval).Should(Succeed(), "CRP %s status has been changed", crpName) @@ -309,18 +308,18 @@ var _ = Context("creating resourceOverride with different rules for each cluster // Create the CRP. createCRP(crpName) // Create the ro. - ro := &placementv1alpha1.ResourceOverride{ + ro := &placementv1beta1.ResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: roName, Namespace: roNamespace, }, - Spec: placementv1alpha1.ResourceOverrideSpec{ - Placement: &placementv1alpha1.PlacementRef{ + Spec: placementv1beta1.ResourceOverrideSpec{ + Placement: &placementv1beta1.PlacementRef{ Name: crpName, // assigned CRP name }, ResourceSelectors: configMapSelector(), - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -331,9 +330,9 @@ var _ = Context("creating resourceOverride with different rules for each cluster }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/annotations", Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`{"%s": "%s-0"}`, roTestAnnotationKey, roTestAnnotationValue))}, }, @@ -349,9 +348,9 @@ var _ = Context("creating resourceOverride with different rules for each cluster }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/annotations", Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`{"%s": "%s-1"}`, roTestAnnotationKey, roTestAnnotationValue))}, }, @@ -367,9 +366,9 @@ var _ = Context("creating resourceOverride with different rules for each cluster }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/annotations", Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`{"%s": "%s-2"}`, roTestAnnotationKey, roTestAnnotationValue))}, }, @@ -393,7 +392,7 @@ var _ = Context("creating resourceOverride with different rules for each cluster It("should update CRP status as expected", func() { wantRONames := []placementv1beta1.NamespacedName{ - {Namespace: roNamespace, Name: fmt.Sprintf(placementv1alpha1.OverrideSnapshotNameFmt, roName, 0)}, + {Namespace: roNamespace, Name: fmt.Sprintf(placementv1beta1.OverrideSnapshotNameFmt, roName, 0)}, } crpStatusUpdatedActual := crpStatusWithOverrideUpdatedActual(workResourceIdentifiers(), allMemberClusterNames, "0", nil, wantRONames) Eventually(crpStatusUpdatedActual, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update CRP %s status as expected", crpName) @@ -415,27 +414,27 @@ var _ = Context("creating resourceOverride and clusterResourceOverride, resource croName := fmt.Sprintf(croNameTemplate, GinkgoParallelProcess()) roName := fmt.Sprintf(roNameTemplate, GinkgoParallelProcess()) roNamespace := fmt.Sprintf(workNamespaceNameTemplate, GinkgoParallelProcess()) - roSnapShotName := fmt.Sprintf(placementv1alpha1.OverrideSnapshotNameFmt, roName, 0) - croSnapShotName := fmt.Sprintf(placementv1alpha1.OverrideSnapshotNameFmt, croName, 0) + roSnapShotName := fmt.Sprintf(placementv1beta1.OverrideSnapshotNameFmt, roName, 0) + croSnapShotName := fmt.Sprintf(placementv1beta1.OverrideSnapshotNameFmt, croName, 0) BeforeAll(func() { By("creating work resources") createWorkResources() - cro := &placementv1alpha1.ClusterResourceOverride{ + cro := &placementv1beta1.ClusterResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: croName, }, - Spec: placementv1alpha1.ClusterResourceOverrideSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ ClusterResourceSelectors: workResourceSelector(), - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{}, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/annotations", Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`{"%s": "%s"}`, croTestAnnotationKey, croTestAnnotationValue))}, }, @@ -447,22 +446,22 @@ var _ = Context("creating resourceOverride and clusterResourceOverride, resource } By(fmt.Sprintf("creating clusterResourceOverride %s", croName)) Expect(hubClient.Create(ctx, cro)).To(Succeed(), "Failed to create clusterResourceOverride %s", croName) - ro := &placementv1alpha1.ResourceOverride{ + ro := &placementv1beta1.ResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: roName, Namespace: roNamespace, }, - Spec: placementv1alpha1.ResourceOverrideSpec{ + Spec: placementv1beta1.ResourceOverrideSpec{ ResourceSelectors: configMapSelector(), - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{}, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/annotations", Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`{"%s": "%s"}`, roTestAnnotationKey, roTestAnnotationValue))}, }, @@ -476,11 +475,11 @@ var _ = Context("creating resourceOverride and clusterResourceOverride, resource Expect(hubClient.Create(ctx, ro)).To(Succeed(), "Failed to create resourceOverride %s", roName) // wait until the snapshot is created so that the observed resource index is predictable. Eventually(func() error { - roSnap := &placementv1alpha1.ResourceOverrideSnapshot{} + roSnap := &placementv1beta1.ResourceOverrideSnapshot{} return hubClient.Get(ctx, types.NamespacedName{Name: roSnapShotName, Namespace: roNamespace}, roSnap) }, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update ro as expected", crpName) Eventually(func() error { - croSnap := &placementv1alpha1.ClusterResourceOverrideSnapshot{} + croSnap := &placementv1beta1.ClusterResourceOverrideSnapshot{} return hubClient.Get(ctx, types.NamespacedName{Name: croSnapShotName}, croSnap) }, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update ro as expected", crpName) @@ -529,31 +528,31 @@ var _ = Context("creating resourceOverride with incorrect path", Ordered, func() crpName := fmt.Sprintf(crpNameTemplate, GinkgoParallelProcess()) roName := fmt.Sprintf(croNameTemplate, GinkgoParallelProcess()) roNamespace := fmt.Sprintf(workNamespaceNameTemplate, GinkgoParallelProcess()) - roSnapShotName := fmt.Sprintf(placementv1alpha1.OverrideSnapshotNameFmt, roName, 0) + roSnapShotName := fmt.Sprintf(placementv1beta1.OverrideSnapshotNameFmt, roName, 0) BeforeAll(func() { By("creating work resources") createWorkResources() // Create the bad ro. - ro := &placementv1alpha1.ResourceOverride{ + ro := &placementv1beta1.ResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: roName, Namespace: roNamespace, }, - Spec: placementv1alpha1.ResourceOverrideSpec{ - Placement: &placementv1alpha1.PlacementRef{ + Spec: placementv1beta1.ResourceOverrideSpec{ + Placement: &placementv1beta1.PlacementRef{ Name: crpName, // assigned CRP name }, ResourceSelectors: configMapSelector(), - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{}, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: fmt.Sprintf("/metadata/annotations/%s", roTestAnnotationKey), Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`"%s"`, roTestAnnotationValue))}, }, @@ -567,7 +566,7 @@ var _ = Context("creating resourceOverride with incorrect path", Ordered, func() Expect(hubClient.Create(ctx, ro)).To(Succeed(), "Failed to create resourceOverride %s", roName) // wait until the snapshot is created so that failed override won't block the rollout Eventually(func() error { - roSnap := &placementv1alpha1.ResourceOverrideSnapshot{} + roSnap := &placementv1beta1.ResourceOverrideSnapshot{} return hubClient.Get(ctx, types.NamespacedName{Name: roSnapShotName, Namespace: roNamespace}, roSnap) }, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update ro as expected", crpName) @@ -606,25 +605,25 @@ var _ = Context("creating resourceOverride and resource becomes invalid after ov // Create the CRP. createCRP(crpName) // Create the ro. - ro := &placementv1alpha1.ResourceOverride{ + ro := &placementv1beta1.ResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: roName, Namespace: roNamespace, }, - Spec: placementv1alpha1.ResourceOverrideSpec{ - Placement: &placementv1alpha1.PlacementRef{ + Spec: placementv1beta1.ResourceOverrideSpec{ + Placement: &placementv1beta1.PlacementRef{ Name: crpName, // assigned CRP name }, ResourceSelectors: configMapSelector(), - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{}, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/annotations", Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`"%s"`, roTestAnnotationValue))}, }, @@ -648,7 +647,7 @@ var _ = Context("creating resourceOverride and resource becomes invalid after ov It("should update CRP status as expected", func() { wantRONames := []placementv1beta1.NamespacedName{ - {Namespace: roNamespace, Name: fmt.Sprintf(placementv1alpha1.OverrideSnapshotNameFmt, roName, 0)}, + {Namespace: roNamespace, Name: fmt.Sprintf(placementv1beta1.OverrideSnapshotNameFmt, roName, 0)}, } crpStatusUpdatedActual := crpStatusWithWorkSynchronizedUpdatedFailedActual(workResourceIdentifiers(), allMemberClusterNames, "0", nil, wantRONames) Eventually(crpStatusUpdatedActual, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update CRP %s status as expected", crpName) @@ -662,22 +661,22 @@ var _ = Context("creating resourceOverride with a templated rules with cluster n crpName := fmt.Sprintf(crpNameTemplate, GinkgoParallelProcess()) roName := fmt.Sprintf(roNameTemplate, GinkgoParallelProcess()) roNamespace := fmt.Sprintf(workNamespaceNameTemplate, GinkgoParallelProcess()) - roSnapShotName := fmt.Sprintf(placementv1alpha1.OverrideSnapshotNameFmt, roName, 0) + roSnapShotName := fmt.Sprintf(placementv1beta1.OverrideSnapshotNameFmt, roName, 0) BeforeAll(func() { By("creating work resources") createWorkResources() // Create the ro before crp so that the observed resource index is predictable. - ro := &placementv1alpha1.ResourceOverride{ + ro := &placementv1beta1.ResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: roName, Namespace: roNamespace, }, - Spec: placementv1alpha1.ResourceOverrideSpec{ + Spec: placementv1beta1.ResourceOverrideSpec{ ResourceSelectors: configMapSelector(), - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -693,16 +692,16 @@ var _ = Context("creating resourceOverride with a templated rules with cluster n }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/data/data", - Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`"%s"`, placementv1alpha1.OverrideClusterNameVariable))}, + Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`"%s"`, placementv1beta1.OverrideClusterNameVariable))}, }, { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/data/newField", - Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`"new-%s"`, placementv1alpha1.OverrideClusterNameVariable))}, + Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`"new-%s"`, placementv1beta1.OverrideClusterNameVariable))}, }, }, }, @@ -713,7 +712,7 @@ var _ = Context("creating resourceOverride with a templated rules with cluster n By(fmt.Sprintf("creating resourceOverride %s", roName)) Expect(hubClient.Create(ctx, ro)).To(Succeed(), "Failed to create resourceOverride %s", roName) Eventually(func() error { - roSnap := &placementv1alpha1.ResourceOverrideSnapshot{} + roSnap := &placementv1beta1.ResourceOverrideSnapshot{} return hubClient.Get(ctx, types.NamespacedName{Name: roSnapShotName, Namespace: roNamespace}, roSnap) }, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update ro as expected", crpName) @@ -761,22 +760,22 @@ var _ = Context("creating resourceOverride with delete configMap", Ordered, func crpName := fmt.Sprintf(crpNameTemplate, GinkgoParallelProcess()) roName := fmt.Sprintf(roNameTemplate, GinkgoParallelProcess()) roNamespace := fmt.Sprintf(workNamespaceNameTemplate, GinkgoParallelProcess()) - roSnapShotName := fmt.Sprintf(placementv1alpha1.OverrideSnapshotNameFmt, roName, 0) + roSnapShotName := fmt.Sprintf(placementv1beta1.OverrideSnapshotNameFmt, roName, 0) BeforeAll(func() { By("creating work resources") createWorkResources() // Create the ro before crp so that the observed resource index is predictable. - ro := &placementv1alpha1.ResourceOverride{ + ro := &placementv1beta1.ResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: roName, Namespace: roNamespace, }, - Spec: placementv1alpha1.ResourceOverrideSpec{ + Spec: placementv1beta1.ResourceOverrideSpec{ ResourceSelectors: configMapSelector(), - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -787,9 +786,9 @@ var _ = Context("creating resourceOverride with delete configMap", Ordered, func }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/annotations", Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`{"%s": "%s"}`, roTestAnnotationKey, roTestAnnotationValue))}, }, @@ -805,7 +804,7 @@ var _ = Context("creating resourceOverride with delete configMap", Ordered, func }, }, }, - OverrideType: placementv1alpha1.DeleteOverrideType, + OverrideType: placementv1beta1.DeleteOverrideType, }, }, }, @@ -814,7 +813,7 @@ var _ = Context("creating resourceOverride with delete configMap", Ordered, func By(fmt.Sprintf("creating resourceOverride %s", roName)) Expect(hubClient.Create(ctx, ro)).To(Succeed(), "Failed to create resourceOverride %s", roName) Eventually(func() error { - roSnap := &placementv1alpha1.ResourceOverrideSnapshot{} + roSnap := &placementv1beta1.ResourceOverrideSnapshot{} return hubClient.Get(ctx, types.NamespacedName{Name: roSnapShotName, Namespace: roNamespace}, roSnap) }, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update ro as expected", crpName) @@ -885,18 +884,18 @@ var _ = Context("creating resourceOverride with a templated rules with cluster l createWorkResources() // Create the ro before crp so that the observed resource index is predictable. - ro := &placementv1alpha1.ResourceOverride{ + ro := &placementv1beta1.ResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: roName, Namespace: roNamespace, }, - Spec: placementv1alpha1.ResourceOverrideSpec{ - Placement: &placementv1alpha1.PlacementRef{ + Spec: placementv1beta1.ResourceOverrideSpec{ + Placement: &placementv1beta1.PlacementRef{ Name: crpName, // assigned CRP name }, ResourceSelectors: configMapSelector(), - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -916,16 +915,16 @@ var _ = Context("creating resourceOverride with a templated rules with cluster l }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/data/region", - Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`"%s%s}"`, placementv1alpha1.OverrideClusterLabelKeyVariablePrefix, regionLabelName))}, + Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`"%s%s}"`, placementv1beta1.OverrideClusterLabelKeyVariablePrefix, regionLabelName))}, }, { - Operator: placementv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/data/data", - Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`"newdata-%s%s}"`, placementv1alpha1.OverrideClusterLabelKeyVariablePrefix, envLabelName))}, + Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`"newdata-%s%s}"`, placementv1beta1.OverrideClusterLabelKeyVariablePrefix, envLabelName))}, }, }, }, @@ -950,7 +949,7 @@ var _ = Context("creating resourceOverride with a templated rules with cluster l It("should update CRP status as expected", func() { wantRONames := []placementv1beta1.NamespacedName{ - {Namespace: roNamespace, Name: fmt.Sprintf(placementv1alpha1.OverrideSnapshotNameFmt, roName, 0)}, + {Namespace: roNamespace, Name: fmt.Sprintf(placementv1beta1.OverrideSnapshotNameFmt, roName, 0)}, } crpStatusUpdatedActual := crpStatusWithOverrideUpdatedActual(workResourceIdentifiers(), allMemberClusterNames, "0", nil, wantRONames) Eventually(crpStatusUpdatedActual, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update CRP %s status as expected", crpName) @@ -978,11 +977,11 @@ var _ = Context("creating resourceOverride with a templated rules with cluster l It("should handle non-existent cluster label key gracefully", func() { By("Update the ResourceOverride to use a non-existent label key") Eventually(func() error { - ro := &placementv1alpha1.ResourceOverride{} + ro := &placementv1beta1.ResourceOverride{} if err := hubClient.Get(ctx, types.NamespacedName{Name: roName, Namespace: roNamespace}, ro); err != nil { return err } - ro.Spec.Policy.OverrideRules[0].JSONPatchOverrides[0].Value = apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`"%snon-existent-label}"`, placementv1alpha1.OverrideClusterLabelKeyVariablePrefix))} + ro.Spec.Policy.OverrideRules[0].JSONPatchOverrides[0].Value = apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`"%snon-existent-label}"`, placementv1beta1.OverrideClusterLabelKeyVariablePrefix))} return hubClient.Update(ctx, ro) }, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update resourceOverride %s with non-existent label key", roName) @@ -1036,24 +1035,24 @@ var _ = Context("creating resourceOverride with non-exist label", Ordered, func( crpName := fmt.Sprintf(crpNameTemplate, GinkgoParallelProcess()) roName := fmt.Sprintf(croNameTemplate, GinkgoParallelProcess()) roNamespace := fmt.Sprintf(workNamespaceNameTemplate, GinkgoParallelProcess()) - roSnapShotName := fmt.Sprintf(placementv1alpha1.OverrideSnapshotNameFmt, roName, 0) + roSnapShotName := fmt.Sprintf(placementv1beta1.OverrideSnapshotNameFmt, roName, 0) BeforeAll(func() { By("creating work resources") createWorkResources() // Create the bad ro. - ro := &placementv1alpha1.ResourceOverride{ + ro := &placementv1beta1.ResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: roName, Namespace: roNamespace, }, - Spec: placementv1alpha1.ResourceOverrideSpec{ - Placement: &placementv1alpha1.PlacementRef{ + Spec: placementv1beta1.ResourceOverrideSpec{ + Placement: &placementv1beta1.PlacementRef{ Name: crpName, // assigned CRP name }, ResourceSelectors: configMapSelector(), - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -1073,16 +1072,16 @@ var _ = Context("creating resourceOverride with non-exist label", Ordered, func( }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/data/region", - Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`"%s%s}"`, placementv1alpha1.OverrideClusterLabelKeyVariablePrefix, "non-existent-label"))}, + Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`"%s%s}"`, placementv1beta1.OverrideClusterLabelKeyVariablePrefix, "non-existent-label"))}, }, { - Operator: placementv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/data/data", - Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`"newdata-%s%s}"`, placementv1alpha1.OverrideClusterLabelKeyVariablePrefix, envLabelName))}, + Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`"newdata-%s%s}"`, placementv1beta1.OverrideClusterLabelKeyVariablePrefix, envLabelName))}, }, }, }, @@ -1093,7 +1092,7 @@ var _ = Context("creating resourceOverride with non-exist label", Ordered, func( By(fmt.Sprintf("creating the bad resourceOverride %s", roName)) Expect(hubClient.Create(ctx, ro)).To(Succeed(), "Failed to create resourceOverride %s", roName) Eventually(func() error { - roSnap := &placementv1alpha1.ResourceOverrideSnapshot{} + roSnap := &placementv1beta1.ResourceOverrideSnapshot{} return hubClient.Get(ctx, types.NamespacedName{Name: roSnapShotName, Namespace: roNamespace}, roSnap) }, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update ro as expected", crpName) diff --git a/test/e2e/resources_test.go b/test/e2e/resources_test.go index 86fc253e1..eab4ceeef 100644 --- a/test/e2e/resources_test.go +++ b/test/e2e/resources_test.go @@ -30,7 +30,6 @@ import ( fleetnetworkingv1alpha1 "go.goms.io/fleet-networking/api/v1alpha1" - placementv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" ) @@ -67,8 +66,8 @@ func workResourceSelector() []placementv1beta1.ClusterResourceSelector { } } -func configMapSelector() []placementv1alpha1.ResourceSelector { - return []placementv1alpha1.ResourceSelector{ +func configMapSelector() []placementv1beta1.ResourceSelector { + return []placementv1beta1.ResourceSelector{ { Group: "", Kind: "ConfigMap", diff --git a/test/e2e/scheduler_watchers_test.go b/test/e2e/scheduler_watchers_test.go index 3013339c8..79a66e46c 100644 --- a/test/e2e/scheduler_watchers_test.go +++ b/test/e2e/scheduler_watchers_test.go @@ -61,7 +61,7 @@ const ( // Note that most of the cases below are Serial ones, as they manipulate the list of member // clusters in the test environment directly, which may incur side effects when running in // parallel with other test cases. -var _ = Describe("responding to specific member cluster changes", func() { +var _ = Describe("responding to specific member cluster changes", Label("joinleave"), func() { Context("cluster becomes eligible for PickAll CRPs, just joined", Serial, Ordered, func() { crpName := fmt.Sprintf(crpNameTemplate, GinkgoParallelProcess()) diff --git a/test/e2e/updaterun_test.go b/test/e2e/updaterun_test.go index a9a1cc44c..dc64f50a3 100644 --- a/test/e2e/updaterun_test.go +++ b/test/e2e/updaterun_test.go @@ -29,7 +29,6 @@ import ( "k8s.io/utils/ptr" "sigs.k8s.io/controller-runtime/pkg/client" - placementv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" "go.goms.io/fleet/pkg/utils/condition" "go.goms.io/fleet/test/e2e/framework" @@ -44,6 +43,8 @@ const ( policySnapshotIndex1st = "0" policySnapshotIndex2nd = "1" policySnapshotIndex3rd = "2" + + testConfigMapDataValue = "new" ) // Note that this container will run in parallel with other containers. @@ -86,7 +87,7 @@ var _ = Describe("test CRP rollout with staged update run", func() { oldConfigMap = appConfigMap() newConfigMap = appConfigMap() - newConfigMap.Data["data"] = "new" + newConfigMap.Data["data"] = testConfigMapDataValue }) AfterAll(func() { @@ -149,7 +150,7 @@ var _ = Describe("test CRP rollout with staged update run", func() { }) It("Should update the configmap successfully on hub but not change member clusters", func() { - Eventually(func() error { return hubClient.Update(ctx, &newConfigMap) }, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update configmap on hub") + updateConfigMapSucceed(&newConfigMap) for _, cluster := range allMemberClusters { configMapActual := configMapPlacedOnClusterActual(cluster, &oldConfigMap) @@ -647,14 +648,14 @@ var _ = Describe("test CRP rollout with staged update run", func() { createWorkResources() // Create the cro before crp so that the observed resource index is predictable. - cro := &placementv1alpha1.ClusterResourceOverride{ + cro := &placementv1beta1.ClusterResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: croName, }, - Spec: placementv1alpha1.ClusterResourceOverrideSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ ClusterResourceSelectors: workResourceSelector(), - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -665,9 +666,9 @@ var _ = Describe("test CRP rollout with staged update run", func() { }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/annotations", Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`{"%s": "%s-0"}`, croTestAnnotationKey, croTestAnnotationValue))}, }, @@ -680,15 +681,15 @@ var _ = Describe("test CRP rollout with staged update run", func() { Expect(hubClient.Create(ctx, cro)).To(Succeed(), "Failed to create clusterResourceOverride %s", croName) // Create the ro before crp so that the observed resource index is predictable. - ro := &placementv1alpha1.ResourceOverride{ + ro := &placementv1beta1.ResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: roName, Namespace: roNamespace, }, - Spec: placementv1alpha1.ResourceOverrideSpec{ + Spec: placementv1beta1.ResourceOverrideSpec{ ResourceSelectors: configMapSelector(), - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -699,9 +700,9 @@ var _ = Describe("test CRP rollout with staged update run", func() { }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/annotations", Value: apiextensionsv1.JSON{Raw: []byte(fmt.Sprintf(`{"%s": "%s-1"}`, roTestAnnotationKey, roTestAnnotationValue))}, }, @@ -904,10 +905,245 @@ var _ = Describe("test CRP rollout with staged update run", func() { It("Should not rollout any resources to member clusters as it's reportDiff mode", checkIfRemovedWorkResourcesFromAllMemberClustersConsistently) }) + + Context("Test CRP rollout strategy transition from rollingUpdate to external", Ordered, func() { + var strategy *placementv1beta1.ClusterStagedUpdateStrategy + updateRunName := fmt.Sprintf(updateRunNameWithSubIndexTemplate, GinkgoParallelProcess(), 0) + var oldConfigMap, newConfigMap corev1.ConfigMap + + BeforeAll(func() { + // Create a test namespace and a configMap inside it on the hub cluster. + createWorkResources() + + // Create the CRP with rollingUpdate strategy initially. + crp := &placementv1beta1.ClusterResourcePlacement{ + ObjectMeta: metav1.ObjectMeta{ + Name: crpName, + // Add a custom finalizer; this would allow us to better observe + // the behavior of the controllers. + Finalizers: []string{customDeletionBlockerFinalizer}, + }, + Spec: placementv1beta1.PlacementSpec{ + ResourceSelectors: workResourceSelector(), + Strategy: placementv1beta1.RolloutStrategy{ + Type: placementv1beta1.RollingUpdateRolloutStrategyType, + }, + }, + } + Expect(hubClient.Create(ctx, crp)).To(Succeed(), "Failed to create CRP") + + // Create the clusterStagedUpdateStrategy for later use. + strategy = createStagedUpdateStrategySucceed(strategyName) + + oldConfigMap = appConfigMap() + newConfigMap = appConfigMap() + newConfigMap.Data["data"] = testConfigMapDataValue + }) + + AfterAll(func() { + // Remove the custom deletion blocker finalizer from the CRP. + ensureCRPAndRelatedResourcesDeleted(crpName, allMemberClusters) + + // Delete the clusterStagedUpdateRun. + ensureUpdateRunDeletion(updateRunName) + + // Delete the clusterStagedUpdateStrategy. + ensureUpdateRunStrategyDeletion(strategyName) + }) + + It("Should rollout resources to all member clusters with rollingUpdate strategy", func() { + crpStatusUpdatedActual := crpStatusUpdatedActual(workResourceIdentifiers(), allMemberClusterNames, nil, resourceSnapshotIndex1st) + Eventually(crpStatusUpdatedActual, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update CRP %s status as expected", crpName) + checkIfPlacedWorkResourcesOnMemberClustersInUpdateRun(allMemberClusters) + }) + + It("Update CRP to use external rollout strategy", func() { + Eventually(func() error { + crp := &placementv1beta1.ClusterResourcePlacement{} + if err := hubClient.Get(ctx, client.ObjectKey{Name: crpName}, crp); err != nil { + return fmt.Errorf("failed to get the crp: %w", err) + } + crp.Spec.Strategy = placementv1beta1.RolloutStrategy{ + Type: placementv1beta1.ExternalRolloutStrategyType, + } + return hubClient.Update(ctx, crp) + }, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update CRP strategy to external rollout") + }) + + It("Should update crp status to reflect external rollout strategy", func() { + crpStatusUpdatedActual := crpStatusWithExternalStrategyActual(workResourceIdentifiers(), resourceSnapshotIndex1st, true, allMemberClusterNames, + []string{resourceSnapshotIndex1st, resourceSnapshotIndex1st, resourceSnapshotIndex1st}, []bool{true, true, true}, nil, nil) + Eventually(crpStatusUpdatedActual, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update CRP %s status for external strategy", crpName) + }) + + It("Update the configmap on hub but should not rollout to member clusters", func() { + updateConfigMapSucceed(&newConfigMap) + + // Verify old configmap is still on all member clusters + for _, cluster := range allMemberClusters { + configMapActual := configMapPlacedOnClusterActual(cluster, &oldConfigMap) + Consistently(configMapActual, consistentlyDuration, consistentlyInterval).Should(Succeed(), "Failed to keep old configmap %s data on cluster %s", oldConfigMap.Name, cluster.ClusterName) + } + }) + + It("Should have the new resource snapshot but CRP status should remain completed with old snapshot", func() { + validateLatestResourceSnapshot(crpName, resourceSnapshotIndex2nd) + + // CRP status should still show completed with old snapshot + crpStatusUpdatedActual := crpStatusWithExternalStrategyActual(workResourceIdentifiers(), resourceSnapshotIndex1st, true, allMemberClusterNames, + []string{resourceSnapshotIndex1st, resourceSnapshotIndex1st, resourceSnapshotIndex1st}, []bool{true, true, true}, nil, nil) + Consistently(crpStatusUpdatedActual, consistentlyDuration, consistentlyInterval).Should(Succeed(), "Failed to keep CRP %s status as expected", crpName) + }) + + It("Create a staged update run with new resourceSnapshotIndex and verify rollout happens", func() { + createStagedUpdateRunSucceed(updateRunName, crpName, resourceSnapshotIndex2nd, strategyName) + + // Verify rollout to canary cluster first + By("Verify that the new configmap is updated on member-cluster-2 during canary stage") + configMapActual := configMapPlacedOnClusterActual(allMemberClusters[1], &newConfigMap) + Eventually(configMapActual, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update to the new configmap %s on cluster %s", newConfigMap.Name, allMemberClusterNames[1]) + + validateAndApproveClusterApprovalRequests(updateRunName, envCanary) + + // Verify complete rollout + updateRunSucceededActual := updateRunStatusSucceededActual(updateRunName, policySnapshotIndex1st, len(allMemberClusters), nil, &strategy.Spec, [][]string{{allMemberClusterNames[1]}, {allMemberClusterNames[0], allMemberClusterNames[2]}}, nil, nil, nil) + Eventually(updateRunSucceededActual, updateRunEventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to validate updateRun %s succeeded", updateRunName) + + // Verify new configmap is on all member clusters + for _, cluster := range allMemberClusters { + configMapActual := configMapPlacedOnClusterActual(cluster, &newConfigMap) + Eventually(configMapActual, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update to the new configmap %s on cluster %s", newConfigMap.Name, cluster.ClusterName) + } + }) + + It("Should update crp status as completed with new snapshot", func() { + crpStatusUpdatedActual := crpStatusWithExternalStrategyActual(workResourceIdentifiers(), resourceSnapshotIndex2nd, true, allMemberClusterNames, + []string{resourceSnapshotIndex2nd, resourceSnapshotIndex2nd, resourceSnapshotIndex2nd}, []bool{true, true, true}, nil, nil) + Eventually(crpStatusUpdatedActual, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update CRP %s status as expected", crpName) + }) + }) + + Context("Test CRP rollout strategy transition from external to rollingUpdate", Ordered, func() { + var strategy *placementv1beta1.ClusterStagedUpdateStrategy + updateRunName := fmt.Sprintf(updateRunNameWithSubIndexTemplate, GinkgoParallelProcess(), 0) + var oldConfigMap, newConfigMap corev1.ConfigMap + + BeforeAll(func() { + // Create a test namespace and a configMap inside it on the hub cluster. + createWorkResources() + + // Create the CRP with external rollout strategy initially. + crp := &placementv1beta1.ClusterResourcePlacement{ + ObjectMeta: metav1.ObjectMeta{ + Name: crpName, + // Add a custom finalizer; this would allow us to better observe + // the behavior of the controllers. + Finalizers: []string{customDeletionBlockerFinalizer}, + }, + Spec: placementv1beta1.PlacementSpec{ + ResourceSelectors: workResourceSelector(), + Strategy: placementv1beta1.RolloutStrategy{ + Type: placementv1beta1.ExternalRolloutStrategyType, + }, + }, + } + Expect(hubClient.Create(ctx, crp)).To(Succeed(), "Failed to create CRP") + + // Create the clusterStagedUpdateStrategy. + strategy = createStagedUpdateStrategySucceed(strategyName) + + oldConfigMap = appConfigMap() + newConfigMap = appConfigMap() + newConfigMap.Data["data"] = testConfigMapDataValue + }) + + AfterAll(func() { + // Remove the custom deletion blocker finalizer from the CRP. + ensureCRPAndRelatedResourcesDeleted(crpName, allMemberClusters) + + // Delete the clusterStagedUpdateRun. + ensureUpdateRunDeletion(updateRunName) + + // Delete the clusterStagedUpdateStrategy. + ensureUpdateRunStrategyDeletion(strategyName) + }) + + It("Should not rollout any resources to member clusters with external strategy", checkIfRemovedWorkResourcesFromAllMemberClustersConsistently) + + It("Should have the latest resource snapshot", func() { + validateLatestResourceSnapshot(crpName, resourceSnapshotIndex1st) + }) + + It("Should update crp status as pending rollout", func() { + crpStatusUpdatedActual := crpStatusWithExternalStrategyActual(nil, "", false, allMemberClusterNames, []string{"", "", ""}, []bool{false, false, false}, nil, nil) + Eventually(crpStatusUpdatedActual, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update CRP %s status as expected", crpName) + }) + + It("Create updateRun and verify resources are rolled out", func() { + createStagedUpdateRunSucceed(updateRunName, crpName, resourceSnapshotIndex1st, strategyName) + + validateAndApproveClusterApprovalRequests(updateRunName, envCanary) + + updateRunSucceededActual := updateRunStatusSucceededActual(updateRunName, policySnapshotIndex1st, len(allMemberClusters), nil, &strategy.Spec, [][]string{{allMemberClusterNames[1]}, {allMemberClusterNames[0], allMemberClusterNames[2]}}, nil, nil, nil) + Eventually(updateRunSucceededActual, updateRunEventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to validate updateRun %s succeeded", updateRunName) + + checkIfPlacedWorkResourcesOnMemberClustersInUpdateRun(allMemberClusters) + }) + + It("Should update crp status as completed", func() { + crpStatusUpdatedActual := crpStatusWithExternalStrategyActual(workResourceIdentifiers(), resourceSnapshotIndex1st, true, allMemberClusterNames, + []string{resourceSnapshotIndex1st, resourceSnapshotIndex1st, resourceSnapshotIndex1st}, []bool{true, true, true}, nil, nil) + Eventually(crpStatusUpdatedActual, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update CRP %s status as expected", crpName) + }) + + It("Update the configmap on hub but should not rollout to member clusters with external strategy", func() { + updateConfigMapSucceed(&newConfigMap) + + // Verify old configmap is still on all member clusters + for _, cluster := range allMemberClusters { + configMapActual := configMapPlacedOnClusterActual(cluster, &oldConfigMap) + Consistently(configMapActual, consistentlyDuration, consistentlyInterval).Should(Succeed(), "Failed to keep old configmap %s data on cluster %s", oldConfigMap.Name, cluster.ClusterName) + } + }) + + It("Should have new resource snapshot but CRP status should remain completed with old snapshot", func() { + validateLatestResourceSnapshot(crpName, resourceSnapshotIndex2nd) + + // CRP status should still show completed with old snapshot + crpStatusUpdatedActual := crpStatusWithExternalStrategyActual(workResourceIdentifiers(), resourceSnapshotIndex1st, true, allMemberClusterNames, + []string{resourceSnapshotIndex1st, resourceSnapshotIndex1st, resourceSnapshotIndex1st}, []bool{true, true, true}, nil, nil) + Consistently(crpStatusUpdatedActual, consistentlyDuration, consistentlyInterval).Should(Succeed(), "Failed to keep CRP %s status as expected", crpName) + }) + + It("Update CRP to use rollingUpdate strategy", func() { + Eventually(func() error { + crp := &placementv1beta1.ClusterResourcePlacement{} + if err := hubClient.Get(ctx, client.ObjectKey{Name: crpName}, crp); err != nil { + return fmt.Errorf("failed to get the crp: %w", err) + } + crp.Spec.Strategy = placementv1beta1.RolloutStrategy{ + Type: placementv1beta1.RollingUpdateRolloutStrategyType, + } + return hubClient.Update(ctx, crp) + }, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update CRP strategy to rollingUpdate") + }) + + It("Should automatically rollout new resources to all member clusters with rollingUpdate strategy", func() { + // Verify CRP status shows all clusters with new resource snapshot + crpStatusUpdatedActual := crpStatusUpdatedActual(workResourceIdentifiers(), allMemberClusterNames, nil, resourceSnapshotIndex2nd) + Eventually(crpStatusUpdatedActual, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update CRP %s status with rollingUpdate strategy", crpName) + + // Verify new configmap is on all member clusters + for _, cluster := range allMemberClusters { + configMapActual := configMapPlacedOnClusterActual(cluster, &newConfigMap) + Eventually(configMapActual, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update to the new configmap %s on cluster %s", newConfigMap.Name, cluster.ClusterName) + } + }) + }) }) // Note that this container cannot run in parallel with other containers. -var _ = Describe("Test member cluster join and leave flow with updateRun", Ordered, Serial, func() { +var _ = Describe("Test member cluster join and leave flow with updateRun", Label("joinleave"), Ordered, Serial, func() { crpName := fmt.Sprintf(crpNameTemplate, GinkgoParallelProcess()) strategyName := fmt.Sprintf(updateRunStrategyNameTemplate, GinkgoParallelProcess()) var strategy *placementv1beta1.ClusterStagedUpdateStrategy @@ -1008,7 +1244,7 @@ var _ = Describe("Test member cluster join and leave flow with updateRun", Order ensureUpdateRunStrategyDeletion(strategyName) }) - Context("UpdateRun should delete the binding of a left cluster but resources are kept", Ordered, Serial, func() { + Context("UpdateRun should delete the binding of a left cluster but resources are kept", Label("joinleave"), Ordered, Serial, func() { It("Should validate binding for member cluster 1 is set to Unscheduled", func() { bindingUnscheduledActual := bindingStateActual(crpName, allMemberClusterNames[0], placementv1beta1.BindingStateUnscheduled) Eventually(bindingUnscheduledActual, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to mark binding for member cluster %s as unscheduled", allMemberClusterNames[0]) @@ -1056,7 +1292,7 @@ var _ = Describe("Test member cluster join and leave flow with updateRun", Order }) }) - Context("Rejoin a member cluster when resources are not changed", Ordered, Serial, func() { + Context("Rejoin a member cluster when resources are not changed", Label("joinleave"), Ordered, Serial, func() { It("Should be able to rejoin member cluster 1", func() { setMemberClusterToJoin(allMemberClusters[0]) checkIfMemberClusterHasJoined(allMemberClusters[0]) @@ -1084,7 +1320,7 @@ var _ = Describe("Test member cluster join and leave flow with updateRun", Order }) }) - Context("Rejoin a member cluster when resources are changed", Ordered, Serial, func() { + Context("Rejoin a member cluster when resources are changed", Label("joinleave"), Ordered, Serial, func() { var newConfigMap corev1.ConfigMap It("Generate a new configMap", func() { @@ -1098,7 +1334,7 @@ var _ = Describe("Test member cluster join and leave flow with updateRun", Order }) It("Should update the resources on hub cluster", func() { - Eventually(func() error { return hubClient.Update(ctx, &newConfigMap) }, eventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to update configmap on hub") + updateConfigMapSucceed(&newConfigMap) }) It("Should have the latest resource snapshot with updated resources", func() { @@ -1134,7 +1370,7 @@ var _ = Describe("Test member cluster join and leave flow with updateRun", Order }) }) - Context("Rejoin a member cluster after orphaned resources are deleted on the member cluster", Ordered, Serial, func() { + Context("Rejoin a member cluster after orphaned resources are deleted on the member cluster", Label("joinleave"), Ordered, Serial, func() { It("Should delete the orphaned resources on member cluster 1", func() { cleanWorkResourcesOnCluster(allMemberClusters[0]) }) @@ -1166,7 +1402,7 @@ var _ = Describe("Test member cluster join and leave flow with updateRun", Order }) }) - Context("Rejoin a member cluster and change to rollout CRP with rollingUpdate", Ordered, Serial, func() { + Context("Rejoin a member cluster and change to rollout CRP with rollingUpdate", Label("joinleave"), Ordered, Serial, func() { It("Should be able to rejoin member cluster 1", func() { setMemberClusterToJoin(allMemberClusters[0]) checkIfMemberClusterHasJoined(allMemberClusters[0]) @@ -1336,3 +1572,11 @@ func validateAndApproveClusterApprovalRequests(updateRunName, stageName string) return hubClient.Status().Update(ctx, appReq) }, updateRunEventuallyDuration, eventuallyInterval).Should(Succeed(), "Failed to get or approve approval request") } + +func updateConfigMapSucceed(newConfigMap *corev1.ConfigMap) { + cm := &corev1.ConfigMap{} + key := client.ObjectKey{Namespace: newConfigMap.Namespace, Name: newConfigMap.Name} + Expect(hubClient.Get(ctx, key, cm)).To(Succeed(), "Failed to get configmap %s in namespace %s", newConfigMap.Name, newConfigMap.Namespace) + cm.Data = newConfigMap.Data + Expect(hubClient.Update(ctx, cm)).To(Succeed(), "Failed to update configmap %s in namespace %s", newConfigMap.Name, newConfigMap.Namespace) +} diff --git a/test/e2e/utils_test.go b/test/e2e/utils_test.go index 30d824c83..a3adf4633 100644 --- a/test/e2e/utils_test.go +++ b/test/e2e/utils_test.go @@ -43,7 +43,6 @@ import ( "sigs.k8s.io/controller-runtime/pkg/client" clusterv1beta1 "go.goms.io/fleet/apis/cluster/v1beta1" - placementv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" imcv1beta1 "go.goms.io/fleet/pkg/controllers/internalmembercluster/v1beta1" "go.goms.io/fleet/pkg/controllers/workapplier" @@ -923,13 +922,13 @@ func cleanupCRP(name string) { // createResourceOverrides creates a number of resource overrides. func createResourceOverrides(namespace string, number int) { for i := 0; i < number; i++ { - ro := &placementv1alpha1.ResourceOverride{ + ro := &placementv1beta1.ResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: fmt.Sprintf(roNameTemplate, i), Namespace: namespace, }, - Spec: placementv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []placementv1alpha1.ResourceSelector{ + Spec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "apps", Kind: "Deployment", @@ -937,8 +936,8 @@ func createResourceOverrides(namespace string, number int) { Name: fmt.Sprintf("test-deployment-%d", i), }, }, - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -958,9 +957,9 @@ func createResourceOverrides(namespace string, number int) { }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpRemove, + Operator: placementv1beta1.JSONPatchOverrideOpRemove, Path: "/meta/labels/test-key", }, }, @@ -976,11 +975,11 @@ func createResourceOverrides(namespace string, number int) { // createClusterResourceOverrides creates a number of cluster resource overrides. func createClusterResourceOverrides(number int) { for i := 0; i < number; i++ { - cro := &placementv1alpha1.ClusterResourceOverride{ + cro := &placementv1beta1.ClusterResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: fmt.Sprintf(croNameTemplate, i), }, - Spec: placementv1alpha1.ClusterResourceOverrideSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "rbac.authorization.k8s.io/v1", @@ -989,8 +988,8 @@ func createClusterResourceOverrides(number int) { Name: fmt.Sprintf("test-cluster-role-%d", i), }, }, - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -1010,9 +1009,9 @@ func createClusterResourceOverrides(number int) { }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpRemove, + Operator: placementv1beta1.JSONPatchOverrideOpRemove, Path: "/meta/labels/test-key", }, }, @@ -1249,14 +1248,14 @@ func updateCRPWithTolerations(tolerations []placementv1beta1.Toleration) { } func cleanupClusterResourceOverride(name string) { - cro := &placementv1alpha1.ClusterResourceOverride{ + cro := &placementv1beta1.ClusterResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: name, }, } Expect(client.IgnoreNotFound(hubClient.Delete(ctx, cro))).To(Succeed(), "Failed to delete clusterResourceOverride %s", name) Eventually(func() error { - if err := hubClient.Get(ctx, types.NamespacedName{Name: name}, &placementv1alpha1.ClusterResourceOverride{}); !k8serrors.IsNotFound(err) { + if err := hubClient.Get(ctx, types.NamespacedName{Name: name}, &placementv1beta1.ClusterResourceOverride{}); !k8serrors.IsNotFound(err) { return fmt.Errorf("clusterResourceOverride %s still exists or an unexpected error occurred: %w", name, err) } return nil @@ -1264,7 +1263,7 @@ func cleanupClusterResourceOverride(name string) { } func cleanupResourceOverride(name string, namespace string) { - ro := &placementv1alpha1.ResourceOverride{ + ro := &placementv1beta1.ResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: name, Namespace: namespace, @@ -1272,7 +1271,7 @@ func cleanupResourceOverride(name string, namespace string) { } Expect(client.IgnoreNotFound(hubClient.Delete(ctx, ro))).To(Succeed(), "Failed to delete resourceOverride %s", name) Eventually(func() error { - if err := hubClient.Get(ctx, types.NamespacedName{Name: name, Namespace: namespace}, &placementv1alpha1.ResourceOverride{}); !k8serrors.IsNotFound(err) { + if err := hubClient.Get(ctx, types.NamespacedName{Name: name, Namespace: namespace}, &placementv1beta1.ResourceOverride{}); !k8serrors.IsNotFound(err) { return fmt.Errorf("resourceOverride %s still exists or an unexpected error occurred: %w", name, err) } return nil diff --git a/test/e2e/webhook_test.go b/test/e2e/webhook_test.go index 6d4125f2c..516b15221 100644 --- a/test/e2e/webhook_test.go +++ b/test/e2e/webhook_test.go @@ -30,7 +30,6 @@ import ( "k8s.io/apimachinery/pkg/types" clusterv1beta1 "go.goms.io/fleet/apis/cluster/v1beta1" - placementv1alpha1 "go.goms.io/fleet/apis/placement/v1alpha1" placementv1beta1 "go.goms.io/fleet/apis/placement/v1beta1" "go.goms.io/fleet/pkg/utils" "go.goms.io/fleet/pkg/webhook/managedresource" @@ -442,8 +441,8 @@ var _ = Describe("webhook tests for ClusterResourceOverride CREATE operations", Version: "v1", Name: fmt.Sprintf("test-clusterrole-%d", GinkgoParallelProcess()), } - policy := &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + policy := &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -463,9 +462,9 @@ var _ = Describe("webhook tests for ClusterResourceOverride CREATE operations", }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpRemove, + Operator: placementv1beta1.JSONPatchOverrideOpRemove, Path: "/meta/labels/test-key", }, }, @@ -489,11 +488,11 @@ var _ = Describe("webhook tests for ClusterResourceOverride CREATE operations", Version: "v1", } // Create the CRO. - cro := &placementv1alpha1.ClusterResourceOverride{ + cro := &placementv1beta1.ClusterResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: croName, }, - Spec: placementv1alpha1.ClusterResourceOverrideSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ invalidSelector, selector, selector, invalidSelector1, }, @@ -527,11 +526,11 @@ var _ = Describe("webhook tests for ClusterResourceOverride CREATE operation lim It("should deny create CRO with 100 existing CROs", func() { Consistently(func(g Gomega) error { - cro101 := &placementv1alpha1.ClusterResourceOverride{ + cro101 := &placementv1beta1.ClusterResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: "test-cro-101", }, - Spec: placementv1alpha1.ClusterResourceOverrideSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "rbac.authorization.k8s.io/v1", @@ -540,8 +539,8 @@ var _ = Describe("webhook tests for ClusterResourceOverride CREATE operation lim Name: "test-cluster-role-101", }, }, - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -561,9 +560,9 @@ var _ = Describe("webhook tests for ClusterResourceOverride CREATE operation lim }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpRemove, + Operator: placementv1beta1.JSONPatchOverrideOpRemove, Path: "/meta/labels/test-key", }, }, @@ -592,16 +591,16 @@ var _ = Describe("webhook tests for ClusterResourceOverride CREATE operations re } BeforeAll(func() { By("create clusterResourceOverride") - cro := &placementv1alpha1.ClusterResourceOverride{ + cro := &placementv1beta1.ClusterResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: croName, }, - Spec: placementv1alpha1.ClusterResourceOverrideSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ selector, }, - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -621,9 +620,9 @@ var _ = Describe("webhook tests for ClusterResourceOverride CREATE operations re }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpRemove, + Operator: placementv1beta1.JSONPatchOverrideOpRemove, Path: "/meta/labels/test-key", }, }, @@ -642,16 +641,16 @@ var _ = Describe("webhook tests for ClusterResourceOverride CREATE operations re It("should deny create for invalid cluster resource override", func() { Consistently(func(g Gomega) error { - cro1 := &placementv1alpha1.ClusterResourceOverride{ + cro1 := &placementv1beta1.ClusterResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: fmt.Sprintf("test-cro-%d", GinkgoParallelProcess()), }, - Spec: placementv1alpha1.ClusterResourceOverrideSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ selector, }, - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -668,23 +667,23 @@ var _ = Describe("webhook tests for ClusterResourceOverride CREATE operations re }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpRemove, + Operator: placementv1beta1.JSONPatchOverrideOpRemove, Path: "/meta/labels/test-key", }, { - Operator: placementv1alpha1.JSONPatchOverrideOpRemove, + Operator: placementv1beta1.JSONPatchOverrideOpRemove, Path: "/meta/annotations/test-key", Value: apiextensionsv1.JSON{Raw: []byte(`"test-value"`)}, }, { - Operator: placementv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/kind", Value: apiextensionsv1.JSON{Raw: []byte(`"new-kind"`)}, }, { - Operator: placementv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "////", Value: apiextensionsv1.JSON{Raw: []byte(`"new-kind"`)}, }, @@ -711,11 +710,11 @@ var _ = Describe("webhook tests for ClusterResourceOverride CREATE operations re var _ = Describe("webhook tests for CRO UPDATE operations", Ordered, func() { croName := fmt.Sprintf(croNameTemplate, GinkgoParallelProcess()) cro1Name := fmt.Sprintf("test-cro-%d", GinkgoParallelProcess()) - cro := &placementv1alpha1.ClusterResourceOverride{ + cro := &placementv1beta1.ClusterResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: croName, }, - Spec: placementv1alpha1.ClusterResourceOverrideSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "rbac.authorization.k8s.io/v1", @@ -724,15 +723,15 @@ var _ = Describe("webhook tests for CRO UPDATE operations", Ordered, func() { Name: fmt.Sprintf("test-clusterrole-%d", GinkgoParallelProcess()), }, }, - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{}, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpRemove, + Operator: placementv1beta1.JSONPatchOverrideOpRemove, Path: "/meta/labels/test-key", }, }, @@ -755,7 +754,7 @@ var _ = Describe("webhook tests for CRO UPDATE operations", Ordered, func() { It("should deny update CRO with invalid cluster resource selections", func() { Eventually(func(g Gomega) error { - var cro placementv1alpha1.ClusterResourceOverride + var cro placementv1beta1.ClusterResourceOverride g.Expect(hubClient.Get(ctx, types.NamespacedName{Name: croName}, &cro)).Should(Succeed()) invalidSelector := placementv1beta1.ClusterResourceSelector{ Group: "rbac.authorization.k8s.io/v1", @@ -790,11 +789,11 @@ var _ = Describe("webhook tests for CRO UPDATE operations", Ordered, func() { It("should deny update CRO for invalid cluster resource override", func() { Eventually(func(g Gomega) error { - cro1 := &placementv1alpha1.ClusterResourceOverride{ + cro1 := &placementv1beta1.ClusterResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: cro1Name, }, - Spec: placementv1alpha1.ClusterResourceOverrideSpec{ + Spec: placementv1beta1.ClusterResourceOverrideSpec{ ClusterResourceSelectors: []placementv1beta1.ClusterResourceSelector{ { Group: "rbac.authorization.k8s.io/v1", @@ -803,15 +802,15 @@ var _ = Describe("webhook tests for CRO UPDATE operations", Ordered, func() { Name: "test-clusterrole", }, }, - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{}, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpRemove, + Operator: placementv1beta1.JSONPatchOverrideOpRemove, Path: "/meta/labels/test-key", }, }, @@ -821,7 +820,7 @@ var _ = Describe("webhook tests for CRO UPDATE operations", Ordered, func() { }, } Expect(hubClient.Create(ctx, cro1)).To(Succeed(), "Failed to create CRO %s", cro1.Name) - var cro placementv1alpha1.ClusterResourceOverride + var cro placementv1beta1.ClusterResourceOverride g.Expect(hubClient.Get(ctx, types.NamespacedName{Name: croName}, &cro)).Should(Succeed()) selector := placementv1beta1.ClusterResourceSelector{ Group: "rbac.authorization.k8s.io/v1", @@ -842,12 +841,12 @@ var _ = Describe("webhook tests for CRO UPDATE operations", Ordered, func() { }, } cro.Spec.Policy.OverrideRules[0].ClusterSelector.ClusterSelectorTerms = append(cro.Spec.Policy.OverrideRules[0].ClusterSelector.ClusterSelectorTerms, clusterSelectorTerm) - cro.Spec.Policy.OverrideRules[0].JSONPatchOverrides = append(cro.Spec.Policy.OverrideRules[0].JSONPatchOverrides, placementv1alpha1.JSONPatchOverride{ - Operator: placementv1alpha1.JSONPatchOverrideOpRemove, + cro.Spec.Policy.OverrideRules[0].JSONPatchOverrides = append(cro.Spec.Policy.OverrideRules[0].JSONPatchOverrides, placementv1beta1.JSONPatchOverride{ + Operator: placementv1beta1.JSONPatchOverrideOpRemove, Path: "/kind", }) - cro.Spec.Policy.OverrideRules[0].JSONPatchOverrides = append(cro.Spec.Policy.OverrideRules[0].JSONPatchOverrides, placementv1alpha1.JSONPatchOverride{ - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + cro.Spec.Policy.OverrideRules[0].JSONPatchOverrides = append(cro.Spec.Policy.OverrideRules[0].JSONPatchOverrides, placementv1beta1.JSONPatchOverride{ + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "", Value: apiextensionsv1.JSON{Raw: []byte(`"new-value"`)}, }) @@ -870,14 +869,14 @@ var _ = Describe("webhook tests for CRO UPDATE operations", Ordered, func() { var _ = Describe("webhook tests for ResourceOverride CREATE operations", func() { roName := fmt.Sprintf(roNameTemplate, GinkgoParallelProcess()) roNamespace := fmt.Sprintf(workNamespaceNameTemplate, GinkgoParallelProcess()) - selector := placementv1alpha1.ResourceSelector{ + selector := placementv1beta1.ResourceSelector{ Group: "apps", Kind: "Deployment", Version: "v1", Name: fmt.Sprintf("deployment-test-%d", GinkgoParallelProcess()), } - policy := &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + policy := &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -897,9 +896,9 @@ var _ = Describe("webhook tests for ResourceOverride CREATE operations", func() }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpRemove, + Operator: placementv1beta1.JSONPatchOverrideOpRemove, Path: "/meta/labels/test-key", }, }, @@ -919,13 +918,13 @@ var _ = Describe("webhook tests for ResourceOverride CREATE operations", func() It("should deny create RO with invalid resource selection", func() { Consistently(func(g Gomega) error { - ro := &placementv1alpha1.ResourceOverride{ + ro := &placementv1beta1.ResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: roName, Namespace: roNamespace, }, - Spec: placementv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []placementv1alpha1.ResourceSelector{ + Spec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ selector, selector, }, Policy: policy, @@ -964,13 +963,13 @@ var _ = Describe("webhook tests for ResourceOverride CREATE operation limitation It("should deny create RO with 100 existing ROs", func() { Consistently(func(g Gomega) error { By("Try to create the 101st ResourceOverride") - ro101 := &placementv1alpha1.ResourceOverride{ + ro101 := &placementv1beta1.ResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: "test-ro-101", Namespace: roNamespace, }, - Spec: placementv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []placementv1alpha1.ResourceSelector{ + Spec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ { Group: "apps", Kind: "Deployment", @@ -978,8 +977,8 @@ var _ = Describe("webhook tests for ResourceOverride CREATE operation limitation Name: "test-deployment-101", }, }, - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -999,9 +998,9 @@ var _ = Describe("webhook tests for ResourceOverride CREATE operation limitation }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpRemove, + Operator: placementv1beta1.JSONPatchOverrideOpRemove, Path: "/meta/labels/test-key", }, }, @@ -1022,14 +1021,14 @@ var _ = Describe("webhook tests for ResourceOverride CREATE operation limitation var _ = Describe("webhook tests for ResourceOverride CREATE operations resource selection limitations", Ordered, Serial, func() { roName := fmt.Sprintf(roNameTemplate, GinkgoParallelProcess()) roNamespace := fmt.Sprintf(workNamespaceNameTemplate, GinkgoParallelProcess()) - selector := placementv1alpha1.ResourceSelector{ + selector := placementv1beta1.ResourceSelector{ Group: "apps", Kind: "Deployment", Version: "v1", Name: fmt.Sprintf("deployment-test-%d", GinkgoParallelProcess()), } - policy := &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + policy := &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{ @@ -1049,9 +1048,9 @@ var _ = Describe("webhook tests for ResourceOverride CREATE operations resource }, }, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpRemove, + Operator: placementv1beta1.JSONPatchOverrideOpRemove, Path: "/meta/labels/test-key", }, }, @@ -1064,13 +1063,13 @@ var _ = Describe("webhook tests for ResourceOverride CREATE operations resource createWorkResources() By("create resourceOverride") - ro := &placementv1alpha1.ResourceOverride{ + ro := &placementv1beta1.ResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: roName, Namespace: roNamespace, }, - Spec: placementv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []placementv1alpha1.ResourceSelector{ + Spec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ selector, }, Policy: policy, @@ -1090,32 +1089,32 @@ var _ = Describe("webhook tests for ResourceOverride CREATE operations resource It("should deny create RO with invalid resource override", func() { Consistently(func(g Gomega) error { By("create 2nd resourceOverride with same resource selection") - ro1 := &placementv1alpha1.ResourceOverride{ + ro1 := &placementv1beta1.ResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: fmt.Sprintf("test-ro-%d", GinkgoParallelProcess()), Namespace: roNamespace, }, - Spec: placementv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []placementv1alpha1.ResourceSelector{ + Spec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ selector, }, - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: nil, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpRemove, + Operator: placementv1beta1.JSONPatchOverrideOpRemove, Path: "/meta/labels/test-key", Value: apiextensionsv1.JSON{Raw: []byte(`"test-value"`)}, }, { - Operator: placementv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "/kind", Value: apiextensionsv1.JSON{Raw: []byte(`"new-kind"`)}, }, { - Operator: placementv1alpha1.JSONPatchOverrideOpReplace, + Operator: placementv1beta1.JSONPatchOverrideOpReplace, Path: "////", Value: apiextensionsv1.JSON{Raw: []byte(`"new-kind"`)}, }, @@ -1141,7 +1140,7 @@ var _ = Describe("webhook tests for ResourceOverride UPDATE operations", Ordered roName := fmt.Sprintf(roNameTemplate, GinkgoParallelProcess()) ro1Name := fmt.Sprintf("test-ro-%d", GinkgoParallelProcess()) roNamespace := fmt.Sprintf(workNamespaceNameTemplate, GinkgoParallelProcess()) - selector := placementv1alpha1.ResourceSelector{ + selector := placementv1beta1.ResourceSelector{ Group: "apps", Kind: "Deployment", Version: "v1", @@ -1153,24 +1152,24 @@ var _ = Describe("webhook tests for ResourceOverride UPDATE operations", Ordered createWorkResources() By("creating ResourceOverride") - ro := &placementv1alpha1.ResourceOverride{ + ro := &placementv1beta1.ResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: roName, Namespace: roNamespace, }, - Spec: placementv1alpha1.ResourceOverrideSpec{ - ResourceSelectors: []placementv1alpha1.ResourceSelector{ + Spec: placementv1beta1.ResourceOverrideSpec{ + ResourceSelectors: []placementv1beta1.ResourceSelector{ selector, }, - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: &placementv1beta1.ClusterSelector{ ClusterSelectorTerms: []placementv1beta1.ClusterSelectorTerm{}, }, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpRemove, + Operator: placementv1beta1.JSONPatchOverrideOpRemove, Path: "/meta/labels/test-key", }, }, @@ -1193,7 +1192,7 @@ var _ = Describe("webhook tests for ResourceOverride UPDATE operations", Ordered It("should deny update RO with invalid resource selection", func() { Eventually(func(g Gomega) error { - var ro placementv1alpha1.ResourceOverride + var ro placementv1beta1.ResourceOverride g.Expect(hubClient.Get(ctx, types.NamespacedName{Name: roName, Namespace: roNamespace}, &ro)).Should(Succeed()) ro.Spec.ResourceSelectors = append(ro.Spec.ResourceSelectors, selector) ro.Spec.ResourceSelectors = append(ro.Spec.ResourceSelectors, selector) @@ -1210,25 +1209,25 @@ var _ = Describe("webhook tests for ResourceOverride UPDATE operations", Ordered }) It("should deny update RO with invalid resource override", func() { - newSelector := placementv1alpha1.ResourceSelector{ + newSelector := placementv1beta1.ResourceSelector{ Group: "apps", Kind: "Deployment", Version: "v1", Name: "test-deployment-x", } - ro1 := &placementv1alpha1.ResourceOverride{ + ro1 := &placementv1beta1.ResourceOverride{ ObjectMeta: metav1.ObjectMeta{ Name: fmt.Sprintf("test-ro-%d", GinkgoParallelProcess()), Namespace: roNamespace, }, - Spec: placementv1alpha1.ResourceOverrideSpec{ - Policy: &placementv1alpha1.OverridePolicy{ - OverrideRules: []placementv1alpha1.OverrideRule{ + Spec: placementv1beta1.ResourceOverrideSpec{ + Policy: &placementv1beta1.OverridePolicy{ + OverrideRules: []placementv1beta1.OverrideRule{ { ClusterSelector: nil, - JSONPatchOverrides: []placementv1alpha1.JSONPatchOverride{ + JSONPatchOverrides: []placementv1beta1.JSONPatchOverride{ { - Operator: placementv1alpha1.JSONPatchOverrideOpRemove, + Operator: placementv1beta1.JSONPatchOverrideOpRemove, Path: "/meta/labels/test-key", }, }, @@ -1241,7 +1240,7 @@ var _ = Describe("webhook tests for ResourceOverride UPDATE operations", Ordered By("creating a new resource override") Expect(hubClient.Create(ctx, ro1)).To(Succeed(), "Failed to create RO %s", ro1.Name) Eventually(func(g Gomega) error { - var ro placementv1alpha1.ResourceOverride + var ro placementv1beta1.ResourceOverride g.Expect(hubClient.Get(ctx, types.NamespacedName{Name: roName, Namespace: roNamespace}, &ro)).Should(Succeed()) ro.Spec.ResourceSelectors = append(ro.Spec.ResourceSelectors, newSelector) clusterSelectorTerm := placementv1beta1.ClusterSelectorTerm{ @@ -1256,22 +1255,22 @@ var _ = Describe("webhook tests for ResourceOverride UPDATE operations", Ordered }, } ro.Spec.Policy.OverrideRules[0].ClusterSelector.ClusterSelectorTerms = append(ro.Spec.Policy.OverrideRules[0].ClusterSelector.ClusterSelectorTerms, clusterSelectorTerm) - ro.Spec.Policy.OverrideRules[0].JSONPatchOverrides = append(ro.Spec.Policy.OverrideRules[0].JSONPatchOverrides, placementv1alpha1.JSONPatchOverride{ - Operator: placementv1alpha1.JSONPatchOverrideOpRemove, + ro.Spec.Policy.OverrideRules[0].JSONPatchOverrides = append(ro.Spec.Policy.OverrideRules[0].JSONPatchOverrides, placementv1beta1.JSONPatchOverride{ + Operator: placementv1beta1.JSONPatchOverrideOpRemove, Path: "/status/conditions/0", Value: apiextensionsv1.JSON{Raw: []byte(`"new-value"`)}, }) - ro.Spec.Policy.OverrideRules[0].JSONPatchOverrides = append(ro.Spec.Policy.OverrideRules[0].JSONPatchOverrides, placementv1alpha1.JSONPatchOverride{ - Operator: placementv1alpha1.JSONPatchOverrideOpRemove, + ro.Spec.Policy.OverrideRules[0].JSONPatchOverrides = append(ro.Spec.Policy.OverrideRules[0].JSONPatchOverrides, placementv1beta1.JSONPatchOverride{ + Operator: placementv1beta1.JSONPatchOverrideOpRemove, Path: "/status/conditions/0", }) - ro.Spec.Policy.OverrideRules[0].JSONPatchOverrides = append(ro.Spec.Policy.OverrideRules[0].JSONPatchOverrides, placementv1alpha1.JSONPatchOverride{ - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + ro.Spec.Policy.OverrideRules[0].JSONPatchOverrides = append(ro.Spec.Policy.OverrideRules[0].JSONPatchOverrides, placementv1beta1.JSONPatchOverride{ + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "////kind", Value: apiextensionsv1.JSON{Raw: []byte(`"new-value"`)}, }) - ro.Spec.Policy.OverrideRules[0].JSONPatchOverrides = append(ro.Spec.Policy.OverrideRules[0].JSONPatchOverrides, placementv1alpha1.JSONPatchOverride{ - Operator: placementv1alpha1.JSONPatchOverrideOpAdd, + ro.Spec.Policy.OverrideRules[0].JSONPatchOverrides = append(ro.Spec.Policy.OverrideRules[0].JSONPatchOverrides, placementv1beta1.JSONPatchOverride{ + Operator: placementv1beta1.JSONPatchOverrideOpAdd, Path: "/metadata/finalizers/0", Value: apiextensionsv1.JSON{Raw: []byte(`"new-finalizer"`)}, })