From 41f21ebbd7839a64cbdb5c4f49061eab9f66976f Mon Sep 17 00:00:00 2001 From: odubajDT <93584209+odubajDT@users.noreply.github.com> Date: Mon, 28 Nov 2022 12:36:33 +0100 Subject: [PATCH] chore(operator): restructure packages (#469) Signed-off-by: odubajDT --- .../controllers/common/evaluationhandler.go | 8 +- .../common/evaluationhandler_test.go | 57 +++--- .../common/helperfunctions_test.go | 170 ++++++++++++++++++ operator/controllers/common/metrics.go | 33 ++-- operator/controllers/common/metrics_test.go | 40 ++--- operator/controllers/common/phasehandler.go | 26 +-- .../controllers/common/phasehandler_test.go | 92 +++++----- operator/controllers/common/spanhandler.go | 5 +- .../controllers/common/spanhandler_test.go | 6 +- operator/controllers/common/taskhandler.go | 11 +- .../controllers/common/taskhandler_test.go | 57 +++--- operator/controllers/common/test_utils.go | 20 +-- .../controllers/{common => errors}/errors.go | 2 +- .../activemetricsobject.go | 5 +- .../activemetricsobject_test.go | 8 +- .../{common => interfaces}/controller.go | 2 +- .../fake/activemetricsobject_mock.go | 0 .../fake/listitem_mock.go | 0 .../fake/metricsobject_mock.go | 0 .../fake/phaseitem_mock.go | 64 +++---- .../fake/spanitem_mock.go | 0 .../fake/tracer_mock.go | 0 .../{common => interfaces}/listitem.go | 9 +- .../{common => interfaces}/listitem_test.go | 8 +- .../{common => interfaces}/metricsobject.go | 5 +- .../metricsobject_test.go | 8 +- .../{common => interfaces}/phaseitem.go | 18 +- .../{common => interfaces}/phaseitem_test.go | 28 +-- .../{common => interfaces}/spanitem.go | 5 +- .../{common => interfaces}/spanitem_test.go | 10 +- .../{common => interfaces}/tracer.go | 2 +- operator/controllers/keptnapp/controller.go | 7 +- .../controllers/keptnapp/controller_test.go | 15 +- .../controllers/keptnappversion/controller.go | 42 ++--- .../keptnappversion/controller_test.go | 43 ++--- .../reconcile_prepostdeployment.go | 16 +- .../reconcile_prepostevaluation.go | 16 +- .../reconcile_workloadsstate.go | 16 +- .../controllers/keptnevaluation/controller.go | 30 ++-- operator/controllers/keptntask/controller.go | 10 +- .../controllers/keptntask/function_utils.go | 12 +- operator/controllers/keptntask/job_utils.go | 8 +- .../controllers/keptntask/job_utils_test.go | 6 +- .../keptntaskdefinition/reconcile_function.go | 4 +- .../controllers/keptnworkload/controller.go | 4 +- .../keptnworkloadinstance/controller.go | 49 ++--- .../keptnworkloadinstance/controller_test.go | 46 ++--- .../reconcile_deploymentstate.go | 16 +- .../reconcile_prepostdeployment.go | 16 +- .../reconcile_prepostevaluation.go | 16 +- operator/test/component/appcontroller_test.go | 18 +- operator/test/component/common.go | 6 +- operator/test/component/load_test.go | 4 +- operator/test/component/suite_test.go | 15 +- .../test/component/taskcontroller_test.go | 8 +- .../workloadinstancecontroller_test.go | 53 +++--- operator/webhooks/pod_mutating_webhook.go | 70 ++++---- .../webhooks/pod_mutating_webhook_test.go | 162 ++++++++--------- 58 files changed, 800 insertions(+), 607 deletions(-) create mode 100644 operator/controllers/common/helperfunctions_test.go rename operator/controllers/{common => errors}/errors.go (99%) rename operator/controllers/{common => interfaces}/activemetricsobject.go (86%) rename operator/controllers/{common => interfaces}/activemetricsobject_test.go (82%) rename operator/controllers/{common => interfaces}/controller.go (86%) rename operator/controllers/{common => interfaces}/fake/activemetricsobject_mock.go (100%) rename operator/controllers/{common => interfaces}/fake/listitem_mock.go (100%) rename operator/controllers/{common => interfaces}/fake/metricsobject_mock.go (100%) rename operator/controllers/{common => interfaces}/fake/phaseitem_mock.go (95%) rename operator/controllers/{common => interfaces}/fake/spanitem_mock.go (100%) rename operator/controllers/{common => interfaces}/fake/tracer_mock.go (100%) rename operator/controllers/{common => interfaces}/listitem.go (70%) rename operator/controllers/{common => interfaces}/listitem_test.go (78%) rename operator/controllers/{common => interfaces}/metricsobject.go (92%) rename operator/controllers/{common => interfaces}/metricsobject_test.go (90%) rename operator/controllers/{common => interfaces}/phaseitem.go (87%) rename operator/controllers/{common => interfaces}/phaseitem_test.go (85%) rename operator/controllers/{common => interfaces}/spanitem.go (89%) rename operator/controllers/{common => interfaces}/spanitem_test.go (84%) rename operator/controllers/{common => interfaces}/tracer.go (88%) diff --git a/operator/controllers/common/evaluationhandler.go b/operator/controllers/common/evaluationhandler.go index 3e115b0d53..5a3ce46f53 100644 --- a/operator/controllers/common/evaluationhandler.go +++ b/operator/controllers/common/evaluationhandler.go @@ -8,6 +8,8 @@ import ( "github.com/go-logr/logr" klcv1alpha1 "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + controllererrors "github.com/keptn/lifecycle-toolkit/operator/controllers/errors" + "github.com/keptn/lifecycle-toolkit/operator/controllers/interfaces" "go.opentelemetry.io/otel/codes" "go.opentelemetry.io/otel/trace" "k8s.io/apimachinery/pkg/api/errors" @@ -34,7 +36,7 @@ type EvaluationCreateAttributes struct { } func (r EvaluationHandler) ReconcileEvaluations(ctx context.Context, phaseCtx context.Context, reconcileObject client.Object, evaluationCreateAttributes EvaluationCreateAttributes) ([]klcv1alpha1.EvaluationStatus, apicommon.StatusSummary, error) { - piWrapper, err := NewPhaseItemWrapperFromClientObject(reconcileObject) + piWrapper, err := interfaces.NewPhaseItemWrapperFromClientObject(reconcileObject) if err != nil { return nil, apicommon.StatusSummary{}, err } @@ -124,7 +126,7 @@ func (r EvaluationHandler) ReconcileEvaluations(ctx context.Context, phaseCtx co } spanEvaluationTrace.End() if err := r.SpanHandler.UnbindSpan(evaluation, ""); err != nil { - r.Log.Error(err, ErrCouldNotUnbindSpan, evaluation.Name) + r.Log.Error(err, controllererrors.ErrCouldNotUnbindSpan, evaluation.Name) } evaluationStatus.SetEndTime() } @@ -143,7 +145,7 @@ func (r EvaluationHandler) ReconcileEvaluations(ctx context.Context, phaseCtx co } func (r EvaluationHandler) CreateKeptnEvaluation(ctx context.Context, namespace string, reconcileObject client.Object, evaluationCreateAttributes EvaluationCreateAttributes) (string, error) { - piWrapper, err := NewPhaseItemWrapperFromClientObject(reconcileObject) + piWrapper, err := interfaces.NewPhaseItemWrapperFromClientObject(reconcileObject) if err != nil { return "", err } diff --git a/operator/controllers/common/evaluationhandler_test.go b/operator/controllers/common/evaluationhandler_test.go index a84f005719..32e8a5a474 100644 --- a/operator/controllers/common/evaluationhandler_test.go +++ b/operator/controllers/common/evaluationhandler_test.go @@ -6,8 +6,9 @@ import ( "testing" "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" kltfake "github.com/keptn/lifecycle-toolkit/operator/controllers/common/fake" + controllererrors "github.com/keptn/lifecycle-toolkit/operator/controllers/errors" "github.com/stretchr/testify/require" "go.opentelemetry.io/otel/trace" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -24,7 +25,7 @@ func TestEvaluationHandler(t *testing.T) { object client.Object createAttr EvaluationCreateAttributes wantStatus []v1alpha1.EvaluationStatus - wantSummary common.StatusSummary + wantSummary apicommon.StatusSummary evalObj v1alpha1.KeptnEvaluation wantErr error getSpanCalls int @@ -36,8 +37,8 @@ func TestEvaluationHandler(t *testing.T) { evalObj: v1alpha1.KeptnEvaluation{}, createAttr: EvaluationCreateAttributes{}, wantStatus: nil, - wantSummary: common.StatusSummary{}, - wantErr: ErrCannotWrapToPhaseItem, + wantSummary: apicommon.StatusSummary{}, + wantErr: controllererrors.ErrCannotWrapToPhaseItem, getSpanCalls: 0, unbindSpanCalls: 0, }, @@ -48,10 +49,10 @@ func TestEvaluationHandler(t *testing.T) { createAttr: EvaluationCreateAttributes{ SpanName: "", EvaluationDefinition: "", - CheckType: common.PreDeploymentEvaluationCheckType, + CheckType: apicommon.PreDeploymentEvaluationCheckType, }, wantStatus: []v1alpha1.EvaluationStatus(nil), - wantSummary: common.StatusSummary{}, + wantSummary: apicommon.StatusSummary{}, wantErr: nil, getSpanCalls: 0, unbindSpanCalls: 0, @@ -69,16 +70,16 @@ func TestEvaluationHandler(t *testing.T) { createAttr: EvaluationCreateAttributes{ SpanName: "", EvaluationDefinition: "eval-def", - CheckType: common.PreDeploymentEvaluationCheckType, + CheckType: apicommon.PreDeploymentEvaluationCheckType, }, wantStatus: []v1alpha1.EvaluationStatus{ { EvaluationDefinitionName: "eval-def", - Status: common.StatePending, + Status: apicommon.StatePending, EvaluationName: "pre-eval-eval-def-", }, }, - wantSummary: common.StatusSummary{Total: 1, Pending: 1}, + wantSummary: apicommon.StatusSummary{Total: 1, Pending: 1}, wantErr: nil, getSpanCalls: 1, unbindSpanCalls: 0, @@ -92,11 +93,11 @@ func TestEvaluationHandler(t *testing.T) { }, }, Status: v1alpha1.KeptnAppVersionStatus{ - PreDeploymentEvaluationStatus: common.StateSucceeded, + PreDeploymentEvaluationStatus: apicommon.StateSucceeded, PreDeploymentEvaluationTaskStatus: []v1alpha1.EvaluationStatus{ { EvaluationDefinitionName: "eval-def", - Status: common.StateSucceeded, + Status: apicommon.StateSucceeded, EvaluationName: "pre-eval-eval-def-", }, }, @@ -106,16 +107,16 @@ func TestEvaluationHandler(t *testing.T) { createAttr: EvaluationCreateAttributes{ SpanName: "", EvaluationDefinition: "eval-def", - CheckType: common.PreDeploymentEvaluationCheckType, + CheckType: apicommon.PreDeploymentEvaluationCheckType, }, wantStatus: []v1alpha1.EvaluationStatus{ { EvaluationDefinitionName: "eval-def", - Status: common.StateSucceeded, + Status: apicommon.StateSucceeded, EvaluationName: "pre-eval-eval-def-", }, }, - wantSummary: common.StatusSummary{Total: 1, Succeeded: 1}, + wantSummary: apicommon.StatusSummary{Total: 1, Succeeded: 1}, wantErr: nil, getSpanCalls: 0, unbindSpanCalls: 0, @@ -132,11 +133,11 @@ func TestEvaluationHandler(t *testing.T) { }, }, Status: v1alpha1.KeptnAppVersionStatus{ - PreDeploymentEvaluationStatus: common.StateSucceeded, + PreDeploymentEvaluationStatus: apicommon.StateSucceeded, PreDeploymentEvaluationTaskStatus: []v1alpha1.EvaluationStatus{ { EvaluationDefinitionName: "eval-def", - Status: common.StateProgressing, + Status: apicommon.StateProgressing, EvaluationName: "pre-eval-eval-def-", }, }, @@ -148,22 +149,22 @@ func TestEvaluationHandler(t *testing.T) { Name: "pre-eval-eval-def-", }, Status: v1alpha1.KeptnEvaluationStatus{ - OverallStatus: common.StateFailed, + OverallStatus: apicommon.StateFailed, }, }, createAttr: EvaluationCreateAttributes{ SpanName: "", EvaluationDefinition: "eval-def", - CheckType: common.PreDeploymentEvaluationCheckType, + CheckType: apicommon.PreDeploymentEvaluationCheckType, }, wantStatus: []v1alpha1.EvaluationStatus{ { EvaluationDefinitionName: "eval-def", - Status: common.StateFailed, + Status: apicommon.StateFailed, EvaluationName: "pre-eval-eval-def-", }, }, - wantSummary: common.StatusSummary{Total: 1, Failed: 1}, + wantSummary: apicommon.StatusSummary{Total: 1, Failed: 1}, wantErr: nil, getSpanCalls: 1, unbindSpanCalls: 1, @@ -180,11 +181,11 @@ func TestEvaluationHandler(t *testing.T) { }, }, Status: v1alpha1.KeptnAppVersionStatus{ - PreDeploymentEvaluationStatus: common.StateSucceeded, + PreDeploymentEvaluationStatus: apicommon.StateSucceeded, PreDeploymentEvaluationTaskStatus: []v1alpha1.EvaluationStatus{ { EvaluationDefinitionName: "eval-def", - Status: common.StateProgressing, + Status: apicommon.StateProgressing, EvaluationName: "pre-eval-eval-def-", }, }, @@ -196,22 +197,22 @@ func TestEvaluationHandler(t *testing.T) { Name: "pre-eval-eval-def-", }, Status: v1alpha1.KeptnEvaluationStatus{ - OverallStatus: common.StateSucceeded, + OverallStatus: apicommon.StateSucceeded, }, }, createAttr: EvaluationCreateAttributes{ SpanName: "", EvaluationDefinition: "eval-def", - CheckType: common.PreDeploymentEvaluationCheckType, + CheckType: apicommon.PreDeploymentEvaluationCheckType, }, wantStatus: []v1alpha1.EvaluationStatus{ { EvaluationDefinitionName: "eval-def", - Status: common.StateSucceeded, + Status: apicommon.StateSucceeded, EvaluationName: "pre-eval-eval-def-", }, }, - wantSummary: common.StatusSummary{Total: 1, Succeeded: 1}, + wantSummary: apicommon.StatusSummary{Total: 1, Succeeded: 1}, wantErr: nil, getSpanCalls: 1, unbindSpanCalls: 1, @@ -269,7 +270,7 @@ func TestEvaluationHandler_createEvaluation(t *testing.T) { object: &v1alpha1.KeptnEvaluation{}, createAttr: EvaluationCreateAttributes{}, wantName: "", - wantErr: ErrCannotWrapToPhaseItem, + wantErr: controllererrors.ErrCannotWrapToPhaseItem, }, { name: "created evaluation", @@ -286,7 +287,7 @@ func TestEvaluationHandler_createEvaluation(t *testing.T) { createAttr: EvaluationCreateAttributes{ SpanName: "", EvaluationDefinition: "eval-def", - CheckType: common.PreDeploymentEvaluationCheckType, + CheckType: apicommon.PreDeploymentEvaluationCheckType, }, wantName: "pre-eval-eval-def-", wantErr: nil, diff --git a/operator/controllers/common/helperfunctions_test.go b/operator/controllers/common/helperfunctions_test.go new file mode 100644 index 0000000000..6c37e2471e --- /dev/null +++ b/operator/controllers/common/helperfunctions_test.go @@ -0,0 +1,170 @@ +package common + +import ( + "testing" + + klcv1alpha1 "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + "github.com/stretchr/testify/require" + "k8s.io/apimachinery/pkg/types" +) + +func Test_GetTaskStatus(t *testing.T) { + tests := []struct { + name string + inStatus []klcv1alpha1.TaskStatus + want klcv1alpha1.TaskStatus + }{ + { + name: "non-existing", + inStatus: []klcv1alpha1.TaskStatus{ + { + TaskDefinitionName: "def-name", + TaskName: "name", + Status: apicommon.StatePending, + }, + }, + want: klcv1alpha1.TaskStatus{ + TaskDefinitionName: "non-existing", + Status: apicommon.StatePending, + TaskName: "", + }, + }, + { + name: "def-name", + inStatus: []klcv1alpha1.TaskStatus{ + { + TaskDefinitionName: "def-name", + TaskName: "name", + Status: apicommon.StateProgressing, + }, + }, + want: klcv1alpha1.TaskStatus{ + TaskDefinitionName: "def-name", + TaskName: "name", + Status: apicommon.StateProgressing, + }, + }, + { + name: "empty", + inStatus: []klcv1alpha1.TaskStatus{}, + want: klcv1alpha1.TaskStatus{ + TaskDefinitionName: "empty", + Status: apicommon.StatePending, + TaskName: "", + }, + }, + } + + for _, tt := range tests { + t.Run("", func(t *testing.T) { + require.Equal(t, GetTaskStatus(tt.name, tt.inStatus), tt.want) + }) + } +} + +func Test_GetEvaluationStatus(t *testing.T) { + tests := []struct { + name string + inStatus []klcv1alpha1.EvaluationStatus + want klcv1alpha1.EvaluationStatus + }{ + { + name: "non-existing", + inStatus: []klcv1alpha1.EvaluationStatus{ + { + EvaluationDefinitionName: "def-name", + EvaluationName: "name", + Status: apicommon.StatePending, + }, + }, + want: klcv1alpha1.EvaluationStatus{ + EvaluationDefinitionName: "non-existing", + Status: apicommon.StatePending, + EvaluationName: "", + }, + }, + { + name: "def-name", + inStatus: []klcv1alpha1.EvaluationStatus{ + { + EvaluationDefinitionName: "def-name", + EvaluationName: "name", + Status: apicommon.StateProgressing, + }, + }, + want: klcv1alpha1.EvaluationStatus{ + EvaluationDefinitionName: "def-name", + EvaluationName: "name", + Status: apicommon.StateProgressing, + }, + }, + { + name: "empty", + inStatus: []klcv1alpha1.EvaluationStatus{}, + want: klcv1alpha1.EvaluationStatus{ + EvaluationDefinitionName: "empty", + Status: apicommon.StatePending, + EvaluationName: "", + }, + }, + } + + for _, tt := range tests { + t.Run("", func(t *testing.T) { + require.Equal(t, GetEvaluationStatus(tt.name, tt.inStatus), tt.want) + }) + } +} + +func Test_GetAppVersionName(t *testing.T) { + tests := []struct { + namespace string + appName string + version string + want types.NamespacedName + }{ + { + namespace: "namespace", + appName: "name", + version: "version", + want: types.NamespacedName{ + Namespace: "namespace", + Name: "name-version", + }, + }, + { + namespace: "", + appName: "name", + version: "version", + want: types.NamespacedName{ + Namespace: "", + Name: "name-version", + }, + }, + { + namespace: "namespace", + appName: "", + version: "version", + want: types.NamespacedName{ + Namespace: "namespace", + Name: "-version", + }, + }, + { + namespace: "namespace", + appName: "name", + version: "", + want: types.NamespacedName{ + Namespace: "namespace", + Name: "name-", + }, + }, + } + + for _, tt := range tests { + t.Run("", func(t *testing.T) { + require.Equal(t, GetAppVersionName(tt.namespace, tt.appName, tt.version), tt.want) + }) + } +} diff --git a/operator/controllers/common/metrics.go b/operator/controllers/common/metrics.go index 65d641d284..9a39f99214 100644 --- a/operator/controllers/common/metrics.go +++ b/operator/controllers/common/metrics.go @@ -4,8 +4,9 @@ import ( "context" "fmt" - "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + controllererrors "github.com/keptn/lifecycle-toolkit/operator/controllers/errors" + "github.com/keptn/lifecycle-toolkit/operator/controllers/interfaces" "k8s.io/apimachinery/pkg/types" "sigs.k8s.io/controller-runtime/pkg/client" ) @@ -13,10 +14,10 @@ import ( func GetDeploymentDuration(ctx context.Context, client client.Client, reconcileObjectList client.ObjectList) ([]apicommon.GaugeFloatValue, error) { err := client.List(ctx, reconcileObjectList) if err != nil { - return nil, fmt.Errorf(ErrCannotRetrieveInstancesMsg, err) + return nil, fmt.Errorf(controllererrors.ErrCannotRetrieveInstancesMsg, err) } - piWrapper, err := NewListItemWrapperFromClientObjectList(reconcileObjectList) + piWrapper, err := interfaces.NewListItemWrapperFromClientObjectList(reconcileObjectList) if err != nil { return nil, err } @@ -24,7 +25,7 @@ func GetDeploymentDuration(ctx context.Context, client client.Client, reconcileO res := []apicommon.GaugeFloatValue{} for _, ro := range piWrapper.GetItems() { - reconcileObject, _ := NewMetricsObjectWrapperFromClientObject(ro) + reconcileObject, _ := interfaces.NewMetricsObjectWrapperFromClientObject(ro) if reconcileObject.IsEndTimeSet() { duration := reconcileObject.GetEndTime().Sub(reconcileObject.GetStartTime()) res = append(res, apicommon.GaugeFloatValue{ @@ -40,29 +41,29 @@ func GetDeploymentDuration(ctx context.Context, client client.Client, reconcileO func GetDeploymentInterval(ctx context.Context, client client.Client, reconcileObjectList client.ObjectList, previousObject client.Object) ([]apicommon.GaugeFloatValue, error) { err := client.List(ctx, reconcileObjectList) if err != nil { - return nil, fmt.Errorf(ErrCannotRetrieveInstancesMsg, err) + return nil, fmt.Errorf(controllererrors.ErrCannotRetrieveInstancesMsg, err) } - piWrapper, err := NewListItemWrapperFromClientObjectList(reconcileObjectList) + piWrapper, err := interfaces.NewListItemWrapperFromClientObjectList(reconcileObjectList) if err != nil { return nil, err } - res := []common.GaugeFloatValue{} + res := []apicommon.GaugeFloatValue{} for _, ro := range piWrapper.GetItems() { - reconcileObject, _ := NewMetricsObjectWrapperFromClientObject(ro) + reconcileObject, _ := interfaces.NewMetricsObjectWrapperFromClientObject(ro) if reconcileObject.GetPreviousVersion() != "" { err := client.Get(ctx, types.NamespacedName{Name: fmt.Sprintf("%s-%s", reconcileObject.GetParentName(), reconcileObject.GetPreviousVersion()), Namespace: reconcileObject.GetNamespace()}, previousObject) if err != nil { return nil, nil } - piWrapper2, err := NewMetricsObjectWrapperFromClientObject(previousObject) + piWrapper2, err := interfaces.NewMetricsObjectWrapperFromClientObject(previousObject) if err != nil { return nil, err } if reconcileObject.IsEndTimeSet() { previousInterval := reconcileObject.GetEndTime().Sub(piWrapper2.GetStartTime()) - res = append(res, common.GaugeFloatValue{ + res = append(res, apicommon.GaugeFloatValue{ Value: previousInterval.Seconds(), Attributes: reconcileObject.GetDurationMetricsAttributes(), }) @@ -72,25 +73,25 @@ func GetDeploymentInterval(ctx context.Context, client client.Client, reconcileO return res, nil } -func GetActiveInstances(ctx context.Context, client client.Client, reconcileObjectList client.ObjectList) ([]common.GaugeValue, error) { +func GetActiveInstances(ctx context.Context, client client.Client, reconcileObjectList client.ObjectList) ([]apicommon.GaugeValue, error) { err := client.List(ctx, reconcileObjectList) if err != nil { - return nil, fmt.Errorf(ErrCannotRetrieveInstancesMsg, err) + return nil, fmt.Errorf(controllererrors.ErrCannotRetrieveInstancesMsg, err) } - piWrapper, err := NewListItemWrapperFromClientObjectList(reconcileObjectList) + piWrapper, err := interfaces.NewListItemWrapperFromClientObjectList(reconcileObjectList) if err != nil { return nil, err } - res := []common.GaugeValue{} + res := []apicommon.GaugeValue{} for _, ro := range piWrapper.GetItems() { - activeMetricsObject, _ := NewActiveMetricsObjectWrapperFromClientObject(ro) + activeMetricsObject, _ := interfaces.NewActiveMetricsObjectWrapperFromClientObject(ro) gaugeValue := int64(0) if !activeMetricsObject.IsEndTimeSet() { gaugeValue = int64(1) } - res = append(res, common.GaugeValue{ + res = append(res, apicommon.GaugeValue{ Value: gaugeValue, Attributes: activeMetricsObject.GetActiveMetricsAttributes(), }) diff --git a/operator/controllers/common/metrics_test.go b/operator/controllers/common/metrics_test.go index 20e181e917..39c772251f 100644 --- a/operator/controllers/common/metrics_test.go +++ b/operator/controllers/common/metrics_test.go @@ -6,8 +6,8 @@ import ( "time" lifecyclev1alpha1 "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + controllererrors "github.com/keptn/lifecycle-toolkit/operator/controllers/errors" "github.com/stretchr/testify/require" "go.opentelemetry.io/otel/attribute" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -28,7 +28,7 @@ func TestMetrics_GetDeploymentDuration(t *testing.T) { name: "failed to create wrapper", list: &lifecyclev1alpha1.KeptnAppList{}, clientObjects: &lifecyclev1alpha1.KeptnAppList{}, - err: ErrCannotWrapToListItem, + err: controllererrors.ErrCannotWrapToListItem, result: nil, }, { @@ -69,9 +69,9 @@ func TestMetrics_GetDeploymentDuration(t *testing.T) { { Value: 5 * time.Second.Seconds(), Attributes: []attribute.KeyValue{ - common.AppName.String("appName"), - common.AppVersion.String("version"), - common.AppPreviousVersion.String("previousVersion"), + apicommon.AppName.String("appName"), + apicommon.AppVersion.String("version"), + apicommon.AppPreviousVersion.String("previousVersion"), }, }, }, @@ -103,7 +103,7 @@ func TestMetrics_GetActiveInstances(t *testing.T) { name: "failed to create wrapper", list: &lifecyclev1alpha1.KeptnAppList{}, clientObjects: &lifecyclev1alpha1.KeptnAppList{}, - err: ErrCannotWrapToListItem, + err: controllererrors.ErrCannotWrapToListItem, result: nil, }, { @@ -131,9 +131,9 @@ func TestMetrics_GetActiveInstances(t *testing.T) { { Value: 1, Attributes: []attribute.KeyValue{ - common.AppName.String("appName"), - common.AppVersion.String("version"), - common.AppNamespace.String("namespace"), + apicommon.AppName.String("appName"), + apicommon.AppVersion.String("version"), + apicommon.AppNamespace.String("namespace"), }, }, }, @@ -166,9 +166,9 @@ func TestMetrics_GetActiveInstances(t *testing.T) { { Value: 0, Attributes: []attribute.KeyValue{ - common.AppName.String("appName"), - common.AppVersion.String("version"), - common.AppNamespace.String("namespace"), + apicommon.AppName.String("appName"), + apicommon.AppVersion.String("version"), + apicommon.AppNamespace.String("namespace"), }, }, }, @@ -203,7 +203,7 @@ func TestMetrics_GetDeploymentInterval(t *testing.T) { list: &lifecyclev1alpha1.KeptnAppList{}, clientObjects: &lifecyclev1alpha1.KeptnAppList{}, clientObject: &lifecyclev1alpha1.KeptnApp{}, - err: ErrCannotWrapToListItem, + err: controllererrors.ErrCannotWrapToListItem, result: nil, }, { @@ -279,7 +279,7 @@ func TestMetrics_GetDeploymentInterval(t *testing.T) { }, }, }, - err: ErrCannotWrapToMetricsObject, + err: controllererrors.ErrCannotWrapToMetricsObject, result: nil, }, { @@ -366,17 +366,17 @@ func TestMetrics_GetDeploymentInterval(t *testing.T) { { Value: 5, Attributes: []attribute.KeyValue{ - common.AppName.String("appName"), - common.AppVersion.String("version"), - common.AppPreviousVersion.String("previousVersion"), + apicommon.AppName.String("appName"), + apicommon.AppVersion.String("version"), + apicommon.AppPreviousVersion.String("previousVersion"), }, }, { Value: 5, Attributes: []attribute.KeyValue{ - common.AppName.String("appName"), - common.AppVersion.String("version"), - common.AppPreviousVersion.String("previousVersion"), + apicommon.AppName.String("appName"), + apicommon.AppVersion.String("version"), + apicommon.AppPreviousVersion.String("previousVersion"), }, }, }, diff --git a/operator/controllers/common/phasehandler.go b/operator/controllers/common/phasehandler.go index a98a8a9a26..c74a179199 100644 --- a/operator/controllers/common/phasehandler.go +++ b/operator/controllers/common/phasehandler.go @@ -6,7 +6,9 @@ import ( "time" "github.com/go-logr/logr" - "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + controllererrors "github.com/keptn/lifecycle-toolkit/operator/controllers/errors" + "github.com/keptn/lifecycle-toolkit/operator/controllers/interfaces" "go.opentelemetry.io/otel/codes" "go.opentelemetry.io/otel/trace" "k8s.io/client-go/tools/record" @@ -26,13 +28,13 @@ type PhaseResult struct { ctrl.Result } -func RecordEvent(recorder record.EventRecorder, phase common.KeptnPhaseType, eventType string, reconcileObject client.Object, shortReason string, longReason string, version string) { +func RecordEvent(recorder record.EventRecorder, phase apicommon.KeptnPhaseType, eventType string, reconcileObject client.Object, shortReason string, longReason string, version string) { recorder.Event(reconcileObject, eventType, fmt.Sprintf("%s%s", phase.ShortName, shortReason), fmt.Sprintf("%s %s / Namespace: %s, Name: %s, Version: %s ", phase.LongName, longReason, reconcileObject.GetNamespace(), reconcileObject.GetName(), version)) } -func (r PhaseHandler) HandlePhase(ctx context.Context, ctxTrace context.Context, tracer trace.Tracer, reconcileObject client.Object, phase common.KeptnPhaseType, span trace.Span, reconcilePhase func(phaseCtx context.Context) (common.KeptnState, error)) (*PhaseResult, error) { +func (r PhaseHandler) HandlePhase(ctx context.Context, ctxTrace context.Context, tracer trace.Tracer, reconcileObject client.Object, phase apicommon.KeptnPhaseType, span trace.Span, reconcilePhase func(phaseCtx context.Context) (apicommon.KeptnState, error)) (*PhaseResult, error) { requeueResult := ctrl.Result{Requeue: true, RequeueAfter: 5 * time.Second} - piWrapper, err := NewPhaseItemWrapperFromClientObject(reconcileObject) + piWrapper, err := interfaces.NewPhaseItemWrapperFromClientObject(reconcileObject) if err != nil { return &PhaseResult{Continue: false, Result: ctrl.Result{Requeue: true}}, err } @@ -58,11 +60,11 @@ func (r PhaseHandler) HandlePhase(ctx context.Context, ctxTrace context.Context, } if state.IsPending() { - state = common.StateProgressing + state = apicommon.StateProgressing } - defer func(ctx context.Context, oldStatus common.KeptnState, oldPhase string, reconcileObject client.Object) { - piWrapper, _ := NewPhaseItemWrapperFromClientObject(reconcileObject) + defer func(ctx context.Context, oldStatus apicommon.KeptnState, oldPhase string, reconcileObject client.Object) { + piWrapper, _ := interfaces.NewPhaseItemWrapperFromClientObject(reconcileObject) if oldStatus != piWrapper.GetState() || oldPhase != piWrapper.GetCurrentPhase() { if err := r.Status().Update(ctx, reconcileObject); err != nil { r.Log.Error(err, "could not update status") @@ -73,31 +75,31 @@ func (r PhaseHandler) HandlePhase(ctx context.Context, ctxTrace context.Context, if state.IsCompleted() { if state.IsFailed() { piWrapper.Complete() - piWrapper.SetState(common.StateFailed) + piWrapper.SetState(apicommon.StateFailed) spanPhaseTrace.AddEvent(phase.LongName + " has failed") spanPhaseTrace.SetStatus(codes.Error, "Failed") spanPhaseTrace.End() if err := r.SpanHandler.UnbindSpan(reconcileObject, phase.ShortName); err != nil { - r.Log.Error(err, ErrCouldNotUnbindSpan, reconcileObject.GetName()) + r.Log.Error(err, controllererrors.ErrCouldNotUnbindSpan, reconcileObject.GetName()) } RecordEvent(r.Recorder, phase, "Warning", reconcileObject, "Failed", "has failed", piWrapper.GetVersion()) piWrapper.CancelRemainingPhases(phase) return &PhaseResult{Continue: false, Result: ctrl.Result{}}, nil } - piWrapper.SetState(common.StateSucceeded) + piWrapper.SetState(apicommon.StateSucceeded) spanPhaseTrace.AddEvent(phase.LongName + " has succeeded") spanPhaseTrace.SetStatus(codes.Ok, "Succeeded") spanPhaseTrace.End() if err := r.SpanHandler.UnbindSpan(reconcileObject, phase.ShortName); err != nil { - r.Log.Error(err, ErrCouldNotUnbindSpan, reconcileObject.GetName()) + r.Log.Error(err, controllererrors.ErrCouldNotUnbindSpan, reconcileObject.GetName()) } RecordEvent(r.Recorder, phase, "Normal", reconcileObject, "Succeeded", "has succeeded", piWrapper.GetVersion()) return &PhaseResult{Continue: true, Result: requeueResult}, nil } - piWrapper.SetState(common.StateProgressing) + piWrapper.SetState(apicommon.StateProgressing) RecordEvent(r.Recorder, phase, "Warning", reconcileObject, "NotFinished", "has not finished", piWrapper.GetVersion()) return &PhaseResult{Continue: false, Result: requeueResult}, nil diff --git a/operator/controllers/common/phasehandler_test.go b/operator/controllers/common/phasehandler_test.go index 615abf63f4..c45713d7d9 100644 --- a/operator/controllers/common/phasehandler_test.go +++ b/operator/controllers/common/phasehandler_test.go @@ -7,7 +7,7 @@ import ( "time" "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" "github.com/stretchr/testify/require" "go.opentelemetry.io/otel/trace" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -23,8 +23,8 @@ func TestPhaseHandler(t *testing.T) { name string handler PhaseHandler object *v1alpha1.KeptnAppVersion - phase common.KeptnPhaseType - reconcilePhase func(phaseCtx context.Context) (common.KeptnState, error) + phase apicommon.KeptnPhaseType + reconcilePhase func(phaseCtx context.Context) (apicommon.KeptnState, error) wantObject *v1alpha1.KeptnAppVersion want *PhaseResult wantErr error @@ -37,14 +37,14 @@ func TestPhaseHandler(t *testing.T) { }, object: &v1alpha1.KeptnAppVersion{ Status: v1alpha1.KeptnAppVersionStatus{ - Status: common.StateCancelled, + Status: apicommon.StateCancelled, }, }, want: &PhaseResult{Continue: false, Result: ctrl.Result{}}, wantErr: nil, wantObject: &v1alpha1.KeptnAppVersion{ Status: v1alpha1.KeptnAppVersionStatus{ - Status: common.StateCancelled, + Status: apicommon.StateCancelled, }, }, }, @@ -58,20 +58,20 @@ func TestPhaseHandler(t *testing.T) { }, object: &v1alpha1.KeptnAppVersion{ Status: v1alpha1.KeptnAppVersionStatus{ - Status: common.StatePending, - CurrentPhase: common.PhaseAppDeployment.LongName, + Status: apicommon.StatePending, + CurrentPhase: apicommon.PhaseAppDeployment.LongName, }, }, - phase: common.PhaseAppDeployment, - reconcilePhase: func(phaseCtx context.Context) (common.KeptnState, error) { + phase: apicommon.PhaseAppDeployment, + reconcilePhase: func(phaseCtx context.Context) (apicommon.KeptnState, error) { return "", fmt.Errorf("some err") }, want: &PhaseResult{Continue: false, Result: requeueResult}, wantErr: fmt.Errorf("some err"), wantObject: &v1alpha1.KeptnAppVersion{ Status: v1alpha1.KeptnAppVersionStatus{ - Status: common.StatePending, - CurrentPhase: common.PhaseAppDeployment.ShortName, + Status: apicommon.StatePending, + CurrentPhase: apicommon.PhaseAppDeployment.ShortName, }, }, }, @@ -85,20 +85,20 @@ func TestPhaseHandler(t *testing.T) { }, object: &v1alpha1.KeptnAppVersion{ Status: v1alpha1.KeptnAppVersionStatus{ - Status: common.StatePending, - CurrentPhase: common.PhaseAppDeployment.LongName, + Status: apicommon.StatePending, + CurrentPhase: apicommon.PhaseAppDeployment.LongName, }, }, - phase: common.PhaseAppDeployment, - reconcilePhase: func(phaseCtx context.Context) (common.KeptnState, error) { - return common.StatePending, nil + phase: apicommon.PhaseAppDeployment, + reconcilePhase: func(phaseCtx context.Context) (apicommon.KeptnState, error) { + return apicommon.StatePending, nil }, want: &PhaseResult{Continue: false, Result: requeueResult}, wantErr: nil, wantObject: &v1alpha1.KeptnAppVersion{ Status: v1alpha1.KeptnAppVersionStatus{ - Status: common.StateProgressing, - CurrentPhase: common.PhaseAppDeployment.ShortName, + Status: apicommon.StateProgressing, + CurrentPhase: apicommon.PhaseAppDeployment.ShortName, }, }, }, @@ -112,20 +112,20 @@ func TestPhaseHandler(t *testing.T) { }, object: &v1alpha1.KeptnAppVersion{ Status: v1alpha1.KeptnAppVersionStatus{ - Status: common.StatePending, - CurrentPhase: common.PhaseAppDeployment.LongName, + Status: apicommon.StatePending, + CurrentPhase: apicommon.PhaseAppDeployment.LongName, }, }, - phase: common.PhaseAppDeployment, - reconcilePhase: func(phaseCtx context.Context) (common.KeptnState, error) { - return common.StateProgressing, nil + phase: apicommon.PhaseAppDeployment, + reconcilePhase: func(phaseCtx context.Context) (apicommon.KeptnState, error) { + return apicommon.StateProgressing, nil }, want: &PhaseResult{Continue: false, Result: requeueResult}, wantErr: nil, wantObject: &v1alpha1.KeptnAppVersion{ Status: v1alpha1.KeptnAppVersionStatus{ - Status: common.StateProgressing, - CurrentPhase: common.PhaseAppDeployment.ShortName, + Status: apicommon.StateProgressing, + CurrentPhase: apicommon.PhaseAppDeployment.ShortName, }, }, }, @@ -139,20 +139,20 @@ func TestPhaseHandler(t *testing.T) { }, object: &v1alpha1.KeptnAppVersion{ Status: v1alpha1.KeptnAppVersionStatus{ - Status: common.StatePending, - CurrentPhase: common.PhaseAppDeployment.LongName, + Status: apicommon.StatePending, + CurrentPhase: apicommon.PhaseAppDeployment.LongName, }, }, - phase: common.PhaseAppDeployment, - reconcilePhase: func(phaseCtx context.Context) (common.KeptnState, error) { - return common.StateSucceeded, nil + phase: apicommon.PhaseAppDeployment, + reconcilePhase: func(phaseCtx context.Context) (apicommon.KeptnState, error) { + return apicommon.StateSucceeded, nil }, want: &PhaseResult{Continue: true, Result: requeueResult}, wantErr: nil, wantObject: &v1alpha1.KeptnAppVersion{ Status: v1alpha1.KeptnAppVersionStatus{ - Status: common.StateSucceeded, - CurrentPhase: common.PhaseAppDeployment.ShortName, + Status: apicommon.StateSucceeded, + CurrentPhase: apicommon.PhaseAppDeployment.ShortName, }, }, }, @@ -166,20 +166,20 @@ func TestPhaseHandler(t *testing.T) { }, object: &v1alpha1.KeptnAppVersion{ Status: v1alpha1.KeptnAppVersionStatus{ - Status: common.StateProgressing, - CurrentPhase: common.PhaseAppPreEvaluation.LongName, + Status: apicommon.StateProgressing, + CurrentPhase: apicommon.PhaseAppPreEvaluation.LongName, }, }, - phase: common.PhaseAppPreEvaluation, - reconcilePhase: func(phaseCtx context.Context) (common.KeptnState, error) { - return common.StateFailed, nil + phase: apicommon.PhaseAppPreEvaluation, + reconcilePhase: func(phaseCtx context.Context) (apicommon.KeptnState, error) { + return apicommon.StateFailed, nil }, want: &PhaseResult{Continue: false, Result: ctrl.Result{}}, wantErr: nil, wantObject: &v1alpha1.KeptnAppVersion{ Status: v1alpha1.KeptnAppVersionStatus{ - Status: common.StateFailed, - CurrentPhase: common.PhaseAppPreEvaluation.ShortName, + Status: apicommon.StateFailed, + CurrentPhase: apicommon.PhaseAppPreEvaluation.ShortName, EndTime: v1.Time{Time: time.Now().UTC()}, }, }, @@ -194,20 +194,20 @@ func TestPhaseHandler(t *testing.T) { }, object: &v1alpha1.KeptnAppVersion{ Status: v1alpha1.KeptnAppVersionStatus{ - Status: common.StateProgressing, - CurrentPhase: common.PhaseAppPreEvaluation.LongName, + Status: apicommon.StateProgressing, + CurrentPhase: apicommon.PhaseAppPreEvaluation.LongName, }, }, - phase: common.PhaseAppPreEvaluation, - reconcilePhase: func(phaseCtx context.Context) (common.KeptnState, error) { - return common.StateUnknown, nil + phase: apicommon.PhaseAppPreEvaluation, + reconcilePhase: func(phaseCtx context.Context) (apicommon.KeptnState, error) { + return apicommon.StateUnknown, nil }, want: &PhaseResult{Continue: false, Result: requeueResult}, wantErr: nil, wantObject: &v1alpha1.KeptnAppVersion{ Status: v1alpha1.KeptnAppVersionStatus{ - Status: common.StateProgressing, - CurrentPhase: common.PhaseAppPreEvaluation.ShortName, + Status: apicommon.StateProgressing, + CurrentPhase: apicommon.PhaseAppPreEvaluation.ShortName, }, }, }, diff --git a/operator/controllers/common/spanhandler.go b/operator/controllers/common/spanhandler.go index 4a9dac75eb..b6ddf340c6 100644 --- a/operator/controllers/common/spanhandler.go +++ b/operator/controllers/common/spanhandler.go @@ -4,6 +4,7 @@ import ( "context" "sync" + "github.com/keptn/lifecycle-toolkit/operator/controllers/interfaces" "go.opentelemetry.io/otel" "go.opentelemetry.io/otel/propagation" "go.opentelemetry.io/otel/trace" @@ -27,7 +28,7 @@ type SpanHandler struct { } func (r *SpanHandler) GetSpan(ctx context.Context, tracer trace.Tracer, reconcileObject client.Object, phase string) (context.Context, trace.Span, error) { - piWrapper, err := NewSpanItemWrapperFromClientObject(reconcileObject) + piWrapper, err := interfaces.NewSpanItemWrapperFromClientObject(reconcileObject) if err != nil { return nil, nil, err } @@ -56,7 +57,7 @@ func (r *SpanHandler) GetSpan(ctx context.Context, tracer trace.Tracer, reconcil } func (r *SpanHandler) UnbindSpan(reconcileObject client.Object, phase string) error { - piWrapper, err := NewSpanItemWrapperFromClientObject(reconcileObject) + piWrapper, err := interfaces.NewSpanItemWrapperFromClientObject(reconcileObject) if err != nil { return err } diff --git a/operator/controllers/common/spanhandler_test.go b/operator/controllers/common/spanhandler_test.go index b81143ed82..cb05c932c5 100644 --- a/operator/controllers/common/spanhandler_test.go +++ b/operator/controllers/common/spanhandler_test.go @@ -5,7 +5,7 @@ import ( "testing" "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" "github.com/stretchr/testify/require" "go.opentelemetry.io/otel" "sigs.k8s.io/controller-runtime/pkg/client" @@ -57,7 +57,7 @@ func TestSpanHandler_GetSpan(t *testing.T) { wi.Spec.Version = "test" r := SpanHandler{} - phase := common.PhaseAppDeployment.ShortName + phase := apicommon.PhaseAppDeployment.ShortName tracer := otel.Tracer("keptn/test") ctx, span, err := r.GetSpan(context.TODO(), tracer, wi, phase) @@ -80,7 +80,7 @@ func TestSpanHandler_GetSpan(t *testing.T) { wi2.Spec.Version = "test2" tracer2 := otel.Tracer("keptn/test2") - phase2 := common.PhaseWorkloadPreDeployment.LongName + phase2 := apicommon.PhaseWorkloadPreDeployment.LongName ctx3, span3, err3 := r.GetSpan(context.TODO(), tracer2, wi2, phase2) diff --git a/operator/controllers/common/taskhandler.go b/operator/controllers/common/taskhandler.go index 313badbf99..7fd03b6c51 100644 --- a/operator/controllers/common/taskhandler.go +++ b/operator/controllers/common/taskhandler.go @@ -7,8 +7,9 @@ import ( "github.com/go-logr/logr" klcv1alpha1 "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + controllererrors "github.com/keptn/lifecycle-toolkit/operator/controllers/errors" + "github.com/keptn/lifecycle-toolkit/operator/controllers/interfaces" "go.opentelemetry.io/otel/codes" "go.opentelemetry.io/otel/trace" "k8s.io/apimachinery/pkg/api/errors" @@ -31,11 +32,11 @@ type TaskHandler struct { type TaskCreateAttributes struct { SpanName string TaskDefinition string - CheckType common.CheckType + CheckType apicommon.CheckType } func (r TaskHandler) ReconcileTasks(ctx context.Context, phaseCtx context.Context, reconcileObject client.Object, taskCreateAttributes TaskCreateAttributes) ([]klcv1alpha1.TaskStatus, apicommon.StatusSummary, error) { - piWrapper, err := NewPhaseItemWrapperFromClientObject(reconcileObject) + piWrapper, err := interfaces.NewPhaseItemWrapperFromClientObject(reconcileObject) if err != nil { return nil, apicommon.StatusSummary{}, err } @@ -125,7 +126,7 @@ func (r TaskHandler) ReconcileTasks(ctx context.Context, phaseCtx context.Contex } spanTaskTrace.End() if err := r.SpanHandler.UnbindSpan(task, ""); err != nil { - r.Log.Error(err, ErrCouldNotUnbindSpan, task.Name) + r.Log.Error(err, controllererrors.ErrCouldNotUnbindSpan, task.Name) } taskStatus.SetEndTime() } @@ -144,7 +145,7 @@ func (r TaskHandler) ReconcileTasks(ctx context.Context, phaseCtx context.Contex } func (r TaskHandler) CreateKeptnTask(ctx context.Context, namespace string, reconcileObject client.Object, taskCreateAttributes TaskCreateAttributes) (string, error) { - piWrapper, err := NewPhaseItemWrapperFromClientObject(reconcileObject) + piWrapper, err := interfaces.NewPhaseItemWrapperFromClientObject(reconcileObject) if err != nil { return "", err } diff --git a/operator/controllers/common/taskhandler_test.go b/operator/controllers/common/taskhandler_test.go index be768595b3..c38a746792 100644 --- a/operator/controllers/common/taskhandler_test.go +++ b/operator/controllers/common/taskhandler_test.go @@ -6,8 +6,9 @@ import ( "testing" "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" kltfake "github.com/keptn/lifecycle-toolkit/operator/controllers/common/fake" + controllererrors "github.com/keptn/lifecycle-toolkit/operator/controllers/errors" "github.com/stretchr/testify/require" "go.opentelemetry.io/otel/trace" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -24,7 +25,7 @@ func TestTaskHandler(t *testing.T) { object client.Object createAttr TaskCreateAttributes wantStatus []v1alpha1.TaskStatus - wantSummary common.StatusSummary + wantSummary apicommon.StatusSummary taskObj v1alpha1.KeptnTask wantErr error getSpanCalls int @@ -36,8 +37,8 @@ func TestTaskHandler(t *testing.T) { taskObj: v1alpha1.KeptnTask{}, createAttr: TaskCreateAttributes{}, wantStatus: nil, - wantSummary: common.StatusSummary{}, - wantErr: ErrCannotWrapToPhaseItem, + wantSummary: apicommon.StatusSummary{}, + wantErr: controllererrors.ErrCannotWrapToPhaseItem, getSpanCalls: 0, unbindSpanCalls: 0, }, @@ -48,10 +49,10 @@ func TestTaskHandler(t *testing.T) { createAttr: TaskCreateAttributes{ SpanName: "", TaskDefinition: "", - CheckType: common.PreDeploymentCheckType, + CheckType: apicommon.PreDeploymentCheckType, }, wantStatus: []v1alpha1.TaskStatus(nil), - wantSummary: common.StatusSummary{}, + wantSummary: apicommon.StatusSummary{}, wantErr: nil, getSpanCalls: 0, unbindSpanCalls: 0, @@ -69,16 +70,16 @@ func TestTaskHandler(t *testing.T) { createAttr: TaskCreateAttributes{ SpanName: "", TaskDefinition: "task-def", - CheckType: common.PreDeploymentCheckType, + CheckType: apicommon.PreDeploymentCheckType, }, wantStatus: []v1alpha1.TaskStatus{ { TaskDefinitionName: "task-def", - Status: common.StatePending, + Status: apicommon.StatePending, TaskName: "pre-task-def-", }, }, - wantSummary: common.StatusSummary{Total: 1, Pending: 1}, + wantSummary: apicommon.StatusSummary{Total: 1, Pending: 1}, wantErr: nil, getSpanCalls: 1, unbindSpanCalls: 0, @@ -92,11 +93,11 @@ func TestTaskHandler(t *testing.T) { }, }, Status: v1alpha1.KeptnAppVersionStatus{ - PreDeploymentStatus: common.StateSucceeded, + PreDeploymentStatus: apicommon.StateSucceeded, PreDeploymentTaskStatus: []v1alpha1.TaskStatus{ { TaskDefinitionName: "task-def", - Status: common.StateSucceeded, + Status: apicommon.StateSucceeded, TaskName: "pre-task-def-", }, }, @@ -106,16 +107,16 @@ func TestTaskHandler(t *testing.T) { createAttr: TaskCreateAttributes{ SpanName: "", TaskDefinition: "task-def", - CheckType: common.PreDeploymentCheckType, + CheckType: apicommon.PreDeploymentCheckType, }, wantStatus: []v1alpha1.TaskStatus{ { TaskDefinitionName: "task-def", - Status: common.StateSucceeded, + Status: apicommon.StateSucceeded, TaskName: "pre-task-def-", }, }, - wantSummary: common.StatusSummary{Total: 1, Succeeded: 1}, + wantSummary: apicommon.StatusSummary{Total: 1, Succeeded: 1}, wantErr: nil, getSpanCalls: 0, unbindSpanCalls: 0, @@ -132,11 +133,11 @@ func TestTaskHandler(t *testing.T) { }, }, Status: v1alpha1.KeptnAppVersionStatus{ - PreDeploymentStatus: common.StateSucceeded, + PreDeploymentStatus: apicommon.StateSucceeded, PreDeploymentTaskStatus: []v1alpha1.TaskStatus{ { TaskDefinitionName: "task-def", - Status: common.StateProgressing, + Status: apicommon.StateProgressing, TaskName: "pre-task-def-", }, }, @@ -148,22 +149,22 @@ func TestTaskHandler(t *testing.T) { Name: "pre-task-def-", }, Status: v1alpha1.KeptnTaskStatus{ - Status: common.StateFailed, + Status: apicommon.StateFailed, }, }, createAttr: TaskCreateAttributes{ SpanName: "", TaskDefinition: "task-def", - CheckType: common.PreDeploymentCheckType, + CheckType: apicommon.PreDeploymentCheckType, }, wantStatus: []v1alpha1.TaskStatus{ { TaskDefinitionName: "task-def", - Status: common.StateFailed, + Status: apicommon.StateFailed, TaskName: "pre-task-def-", }, }, - wantSummary: common.StatusSummary{Total: 1, Failed: 1}, + wantSummary: apicommon.StatusSummary{Total: 1, Failed: 1}, wantErr: nil, getSpanCalls: 1, unbindSpanCalls: 1, @@ -180,11 +181,11 @@ func TestTaskHandler(t *testing.T) { }, }, Status: v1alpha1.KeptnAppVersionStatus{ - PreDeploymentStatus: common.StateSucceeded, + PreDeploymentStatus: apicommon.StateSucceeded, PreDeploymentTaskStatus: []v1alpha1.TaskStatus{ { TaskDefinitionName: "task-def", - Status: common.StateProgressing, + Status: apicommon.StateProgressing, TaskName: "pre-task-def-", }, }, @@ -196,22 +197,22 @@ func TestTaskHandler(t *testing.T) { Name: "pre-task-def-", }, Status: v1alpha1.KeptnTaskStatus{ - Status: common.StateSucceeded, + Status: apicommon.StateSucceeded, }, }, createAttr: TaskCreateAttributes{ SpanName: "", TaskDefinition: "task-def", - CheckType: common.PreDeploymentCheckType, + CheckType: apicommon.PreDeploymentCheckType, }, wantStatus: []v1alpha1.TaskStatus{ { TaskDefinitionName: "task-def", - Status: common.StateSucceeded, + Status: apicommon.StateSucceeded, TaskName: "pre-task-def-", }, }, - wantSummary: common.StatusSummary{Total: 1, Succeeded: 1}, + wantSummary: apicommon.StatusSummary{Total: 1, Succeeded: 1}, wantErr: nil, getSpanCalls: 1, unbindSpanCalls: 1, @@ -269,7 +270,7 @@ func TestTaskHandler_createTask(t *testing.T) { object: &v1alpha1.KeptnEvaluation{}, createAttr: TaskCreateAttributes{}, wantName: "", - wantErr: ErrCannotWrapToPhaseItem, + wantErr: controllererrors.ErrCannotWrapToPhaseItem, }, { name: "created task", @@ -285,7 +286,7 @@ func TestTaskHandler_createTask(t *testing.T) { }, createAttr: TaskCreateAttributes{ SpanName: "", - CheckType: common.PreDeploymentCheckType, + CheckType: apicommon.PreDeploymentCheckType, TaskDefinition: "task-def", }, wantName: "pre-task-def-", diff --git a/operator/controllers/common/test_utils.go b/operator/controllers/common/test_utils.go index 1b600af2e6..f40dd1a84f 100644 --- a/operator/controllers/common/test_utils.go +++ b/operator/controllers/common/test_utils.go @@ -5,7 +5,7 @@ import ( "fmt" lfcv1alpha1 "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - keptncommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" "go.opentelemetry.io/otel/metric/instrument" "go.opentelemetry.io/otel/metric/unit" "go.opentelemetry.io/otel/sdk/metric" @@ -69,17 +69,17 @@ func AddWorkloadInstance(c client.Client, name string, namespace string) error { TraceId: nil, }, Status: lfcv1alpha1.KeptnWorkloadInstanceStatus{ - DeploymentStatus: keptncommon.StateSucceeded, - PreDeploymentStatus: keptncommon.StateSucceeded, - PostDeploymentStatus: keptncommon.StateSucceeded, - PreDeploymentEvaluationStatus: keptncommon.StateSucceeded, - PostDeploymentEvaluationStatus: keptncommon.StateSucceeded, - CurrentPhase: keptncommon.PhaseWorkloadPostEvaluation.ShortName, + DeploymentStatus: apicommon.StateSucceeded, + PreDeploymentStatus: apicommon.StateSucceeded, + PostDeploymentStatus: apicommon.StateSucceeded, + PreDeploymentEvaluationStatus: apicommon.StateSucceeded, + PostDeploymentEvaluationStatus: apicommon.StateSucceeded, + CurrentPhase: apicommon.PhaseWorkloadPostEvaluation.ShortName, PreDeploymentTaskStatus: nil, PostDeploymentTaskStatus: nil, PreDeploymentEvaluationTaskStatus: nil, PostDeploymentEvaluationTaskStatus: nil, - Status: keptncommon.StateSucceeded, + Status: apicommon.StateSucceeded, StartTime: metav1.Time{}, EndTime: metav1.Time{}, }, @@ -87,7 +87,7 @@ func AddWorkloadInstance(c client.Client, name string, namespace string) error { return c.Create(context.TODO(), wi) } -func InitAppMeters() keptncommon.KeptnMeters { +func InitAppMeters() apicommon.KeptnMeters { provider := metric.NewMeterProvider() meter := provider.Meter("keptn/task") appCount, _ := meter.SyncInt64().Counter("keptn.app.count", instrument.WithDescription("a simple counter for Keptn Apps")) @@ -95,7 +95,7 @@ func InitAppMeters() keptncommon.KeptnMeters { deploymentCount, _ := meter.SyncInt64().Counter("keptn.deployment.count", instrument.WithDescription("a simple counter for Keptn Deployments")) deploymentDuration, _ := meter.SyncFloat64().Histogram("keptn.deployment.duration", instrument.WithDescription("a histogram of duration for Keptn Deployments"), instrument.WithUnit(unit.Unit("s"))) - meters := keptncommon.KeptnMeters{ + meters := apicommon.KeptnMeters{ AppCount: appCount, AppDuration: appDuration, DeploymentCount: deploymentCount, diff --git a/operator/controllers/common/errors.go b/operator/controllers/errors/errors.go similarity index 99% rename from operator/controllers/common/errors.go rename to operator/controllers/errors/errors.go index 19bc35ec89..ccbd19c9a5 100644 --- a/operator/controllers/common/errors.go +++ b/operator/controllers/errors/errors.go @@ -1,4 +1,4 @@ -package common +package errors import "fmt" diff --git a/operator/controllers/common/activemetricsobject.go b/operator/controllers/interfaces/activemetricsobject.go similarity index 86% rename from operator/controllers/common/activemetricsobject.go rename to operator/controllers/interfaces/activemetricsobject.go index 52103a96c2..c75263ae49 100644 --- a/operator/controllers/common/activemetricsobject.go +++ b/operator/controllers/interfaces/activemetricsobject.go @@ -1,6 +1,7 @@ -package common +package interfaces import ( + "github.com/keptn/lifecycle-toolkit/operator/controllers/errors" "go.opentelemetry.io/otel/attribute" "sigs.k8s.io/controller-runtime/pkg/client" ) @@ -20,7 +21,7 @@ type ActiveMetricsObjectWrapper struct { func NewActiveMetricsObjectWrapperFromClientObject(object client.Object) (*ActiveMetricsObjectWrapper, error) { amo, ok := object.(ActiveMetricsObject) if !ok { - return nil, ErrCannotWrapToActiveMetricsObject + return nil, errors.ErrCannotWrapToActiveMetricsObject } return &ActiveMetricsObjectWrapper{Obj: amo}, nil } diff --git a/operator/controllers/common/activemetricsobject_test.go b/operator/controllers/interfaces/activemetricsobject_test.go similarity index 82% rename from operator/controllers/common/activemetricsobject_test.go rename to operator/controllers/interfaces/activemetricsobject_test.go index 5e3128da88..1b29d89176 100644 --- a/operator/controllers/common/activemetricsobject_test.go +++ b/operator/controllers/interfaces/activemetricsobject_test.go @@ -1,11 +1,11 @@ -package common +package interfaces import ( "testing" "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" - "github.com/keptn/lifecycle-toolkit/operator/controllers/common/fake" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + "github.com/keptn/lifecycle-toolkit/operator/controllers/interfaces/fake" "github.com/stretchr/testify/require" "go.opentelemetry.io/otel/attribute" ) @@ -13,7 +13,7 @@ import ( func TestActiveMetricsObjectWrapper(t *testing.T) { appVersion := v1alpha1.KeptnAppVersion{ Status: v1alpha1.KeptnAppVersionStatus{ - Status: common.StateFailed, + Status: apicommon.StateFailed, CurrentPhase: "test", }, } diff --git a/operator/controllers/common/controller.go b/operator/controllers/interfaces/controller.go similarity index 86% rename from operator/controllers/common/controller.go rename to operator/controllers/interfaces/controller.go index c45dfa7e86..af6fb1991a 100644 --- a/operator/controllers/common/controller.go +++ b/operator/controllers/interfaces/controller.go @@ -1,4 +1,4 @@ -package common +package interfaces import ctrl "sigs.k8s.io/controller-runtime" diff --git a/operator/controllers/common/fake/activemetricsobject_mock.go b/operator/controllers/interfaces/fake/activemetricsobject_mock.go similarity index 100% rename from operator/controllers/common/fake/activemetricsobject_mock.go rename to operator/controllers/interfaces/fake/activemetricsobject_mock.go diff --git a/operator/controllers/common/fake/listitem_mock.go b/operator/controllers/interfaces/fake/listitem_mock.go similarity index 100% rename from operator/controllers/common/fake/listitem_mock.go rename to operator/controllers/interfaces/fake/listitem_mock.go diff --git a/operator/controllers/common/fake/metricsobject_mock.go b/operator/controllers/interfaces/fake/metricsobject_mock.go similarity index 100% rename from operator/controllers/common/fake/metricsobject_mock.go rename to operator/controllers/interfaces/fake/metricsobject_mock.go diff --git a/operator/controllers/common/fake/phaseitem_mock.go b/operator/controllers/interfaces/fake/phaseitem_mock.go similarity index 95% rename from operator/controllers/common/fake/phaseitem_mock.go rename to operator/controllers/interfaces/fake/phaseitem_mock.go index ab94650fcb..164dfc2b28 100644 --- a/operator/controllers/common/fake/phaseitem_mock.go +++ b/operator/controllers/interfaces/fake/phaseitem_mock.go @@ -5,7 +5,7 @@ package fake import ( lfcv1alpha1 "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - keptncommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" "go.opentelemetry.io/otel/attribute" "go.opentelemetry.io/otel/trace" "sync" @@ -18,16 +18,16 @@ import ( // // // make and configure a mocked common.PhaseItem // mockedPhaseItem := &PhaseItemMock{ -// CancelRemainingPhasesFunc: func(phase keptncommon.KeptnPhaseType) { +// CancelRemainingPhasesFunc: func(phase apicommon.KeptnPhaseType) { // panic("mock out the CancelRemainingPhases method") // }, // CompleteFunc: func() { // panic("mock out the Complete method") // }, -// GenerateEvaluationFunc: func(evaluationDefinition string, checkType keptncommon.CheckType) lfcv1alpha1.KeptnEvaluation { +// GenerateEvaluationFunc: func(evaluationDefinition string, checkType apicommon.CheckType) lfcv1alpha1.KeptnEvaluation { // panic("mock out the GenerateEvaluation method") // }, -// GenerateTaskFunc: func(taskDefinition string, checkType keptncommon.CheckType) lfcv1alpha1.KeptnTask { +// GenerateTaskFunc: func(taskDefinition string, checkType apicommon.CheckType) lfcv1alpha1.KeptnTask { // panic("mock out the GenerateTask method") // }, // GetAppNameFunc: func() string { @@ -78,7 +78,7 @@ import ( // GetStartTimeFunc: func() time.Time { // panic("mock out the GetStartTime method") // }, -// GetStateFunc: func() keptncommon.KeptnState { +// GetStateFunc: func() apicommon.KeptnState { // panic("mock out the GetState method") // }, // GetVersionFunc: func() string { @@ -93,7 +93,7 @@ import ( // SetSpanAttributesFunc: func(span trace.Span) { // panic("mock out the SetSpanAttributes method") // }, -// SetStateFunc: func(keptnState keptncommon.KeptnState) { +// SetStateFunc: func(keptnState apicommon.KeptnState) { // panic("mock out the SetState method") // }, // } @@ -104,16 +104,16 @@ import ( // } type PhaseItemMock struct { // CancelRemainingPhasesFunc mocks the CancelRemainingPhases method. - CancelRemainingPhasesFunc func(phase keptncommon.KeptnPhaseType) + CancelRemainingPhasesFunc func(phase apicommon.KeptnPhaseType) // CompleteFunc mocks the Complete method. CompleteFunc func() // GenerateEvaluationFunc mocks the GenerateEvaluation method. - GenerateEvaluationFunc func(evaluationDefinition string, checkType keptncommon.CheckType) lfcv1alpha1.KeptnEvaluation + GenerateEvaluationFunc func(evaluationDefinition string, checkType apicommon.CheckType) lfcv1alpha1.KeptnEvaluation // GenerateTaskFunc mocks the GenerateTask method. - GenerateTaskFunc func(taskDefinition string, checkType keptncommon.CheckType) lfcv1alpha1.KeptnTask + GenerateTaskFunc func(taskDefinition string, checkType apicommon.CheckType) lfcv1alpha1.KeptnTask // GetAppNameFunc mocks the GetAppName method. GetAppNameFunc func() string @@ -164,7 +164,7 @@ type PhaseItemMock struct { GetStartTimeFunc func() time.Time // GetStateFunc mocks the GetState method. - GetStateFunc func() keptncommon.KeptnState + GetStateFunc func() apicommon.KeptnState // GetVersionFunc mocks the GetVersion method. GetVersionFunc func() string @@ -179,14 +179,14 @@ type PhaseItemMock struct { SetSpanAttributesFunc func(span trace.Span) // SetStateFunc mocks the SetState method. - SetStateFunc func(keptnState keptncommon.KeptnState) + SetStateFunc func(keptnState apicommon.KeptnState) // calls tracks calls to the methods. calls struct { // CancelRemainingPhases holds details about calls to the CancelRemainingPhases method. CancelRemainingPhases []struct { // Phase is the phase argument value. - Phase keptncommon.KeptnPhaseType + Phase apicommon.KeptnPhaseType } // Complete holds details about calls to the Complete method. Complete []struct { @@ -196,14 +196,14 @@ type PhaseItemMock struct { // EvaluationDefinition is the evaluationDefinition argument value. EvaluationDefinition string // CheckType is the checkType argument value. - CheckType keptncommon.CheckType + CheckType apicommon.CheckType } // GenerateTask holds details about calls to the GenerateTask method. GenerateTask []struct { // TaskDefinition is the taskDefinition argument value. TaskDefinition string // CheckType is the checkType argument value. - CheckType keptncommon.CheckType + CheckType apicommon.CheckType } // GetAppName holds details about calls to the GetAppName method. GetAppName []struct { @@ -275,7 +275,7 @@ type PhaseItemMock struct { // SetState holds details about calls to the SetState method. SetState []struct { // KeptnState is the keptnState argument value. - KeptnState keptncommon.KeptnState + KeptnState apicommon.KeptnState } } lockCancelRemainingPhases sync.RWMutex @@ -307,12 +307,12 @@ type PhaseItemMock struct { } // CancelRemainingPhases calls CancelRemainingPhasesFunc. -func (mock *PhaseItemMock) CancelRemainingPhases(phase keptncommon.KeptnPhaseType) { +func (mock *PhaseItemMock) CancelRemainingPhases(phase apicommon.KeptnPhaseType) { if mock.CancelRemainingPhasesFunc == nil { panic("PhaseItemMock.CancelRemainingPhasesFunc: method is nil but PhaseItem.CancelRemainingPhases was just called") } callInfo := struct { - Phase keptncommon.KeptnPhaseType + Phase apicommon.KeptnPhaseType }{ Phase: phase, } @@ -326,10 +326,10 @@ func (mock *PhaseItemMock) CancelRemainingPhases(phase keptncommon.KeptnPhaseTyp // Check the length with: // len(mockedPhaseItem.CancelRemainingPhasesCalls()) func (mock *PhaseItemMock) CancelRemainingPhasesCalls() []struct { - Phase keptncommon.KeptnPhaseType + Phase apicommon.KeptnPhaseType } { var calls []struct { - Phase keptncommon.KeptnPhaseType + Phase apicommon.KeptnPhaseType } mock.lockCancelRemainingPhases.RLock() calls = mock.calls.CancelRemainingPhases @@ -364,13 +364,13 @@ func (mock *PhaseItemMock) CompleteCalls() []struct { } // GenerateEvaluation calls GenerateEvaluationFunc. -func (mock *PhaseItemMock) GenerateEvaluation(evaluationDefinition string, checkType keptncommon.CheckType) lfcv1alpha1.KeptnEvaluation { +func (mock *PhaseItemMock) GenerateEvaluation(evaluationDefinition string, checkType apicommon.CheckType) lfcv1alpha1.KeptnEvaluation { if mock.GenerateEvaluationFunc == nil { panic("PhaseItemMock.GenerateEvaluationFunc: method is nil but PhaseItem.GenerateEvaluation was just called") } callInfo := struct { EvaluationDefinition string - CheckType keptncommon.CheckType + CheckType apicommon.CheckType }{ EvaluationDefinition: evaluationDefinition, CheckType: checkType, @@ -386,11 +386,11 @@ func (mock *PhaseItemMock) GenerateEvaluation(evaluationDefinition string, check // len(mockedPhaseItem.GenerateEvaluationCalls()) func (mock *PhaseItemMock) GenerateEvaluationCalls() []struct { EvaluationDefinition string - CheckType keptncommon.CheckType + CheckType apicommon.CheckType } { var calls []struct { EvaluationDefinition string - CheckType keptncommon.CheckType + CheckType apicommon.CheckType } mock.lockGenerateEvaluation.RLock() calls = mock.calls.GenerateEvaluation @@ -399,13 +399,13 @@ func (mock *PhaseItemMock) GenerateEvaluationCalls() []struct { } // GenerateTask calls GenerateTaskFunc. -func (mock *PhaseItemMock) GenerateTask(taskDefinition string, checkType keptncommon.CheckType) lfcv1alpha1.KeptnTask { +func (mock *PhaseItemMock) GenerateTask(taskDefinition string, checkType apicommon.CheckType) lfcv1alpha1.KeptnTask { if mock.GenerateTaskFunc == nil { panic("PhaseItemMock.GenerateTaskFunc: method is nil but PhaseItem.GenerateTask was just called") } callInfo := struct { TaskDefinition string - CheckType keptncommon.CheckType + CheckType apicommon.CheckType }{ TaskDefinition: taskDefinition, CheckType: checkType, @@ -421,11 +421,11 @@ func (mock *PhaseItemMock) GenerateTask(taskDefinition string, checkType keptnco // len(mockedPhaseItem.GenerateTaskCalls()) func (mock *PhaseItemMock) GenerateTaskCalls() []struct { TaskDefinition string - CheckType keptncommon.CheckType + CheckType apicommon.CheckType } { var calls []struct { TaskDefinition string - CheckType keptncommon.CheckType + CheckType apicommon.CheckType } mock.lockGenerateTask.RLock() calls = mock.calls.GenerateTask @@ -850,7 +850,7 @@ func (mock *PhaseItemMock) GetStartTimeCalls() []struct { } // GetState calls GetStateFunc. -func (mock *PhaseItemMock) GetState() keptncommon.KeptnState { +func (mock *PhaseItemMock) GetState() apicommon.KeptnState { if mock.GetStateFunc == nil { panic("PhaseItemMock.GetStateFunc: method is nil but PhaseItem.GetState was just called") } @@ -990,12 +990,12 @@ func (mock *PhaseItemMock) SetSpanAttributesCalls() []struct { } // SetState calls SetStateFunc. -func (mock *PhaseItemMock) SetState(keptnState keptncommon.KeptnState) { +func (mock *PhaseItemMock) SetState(keptnState apicommon.KeptnState) { if mock.SetStateFunc == nil { panic("PhaseItemMock.SetStateFunc: method is nil but PhaseItem.SetState was just called") } callInfo := struct { - KeptnState keptncommon.KeptnState + KeptnState apicommon.KeptnState }{ KeptnState: keptnState, } @@ -1009,10 +1009,10 @@ func (mock *PhaseItemMock) SetState(keptnState keptncommon.KeptnState) { // Check the length with: // len(mockedPhaseItem.SetStateCalls()) func (mock *PhaseItemMock) SetStateCalls() []struct { - KeptnState keptncommon.KeptnState + KeptnState apicommon.KeptnState } { var calls []struct { - KeptnState keptncommon.KeptnState + KeptnState apicommon.KeptnState } mock.lockSetState.RLock() calls = mock.calls.SetState diff --git a/operator/controllers/common/fake/spanitem_mock.go b/operator/controllers/interfaces/fake/spanitem_mock.go similarity index 100% rename from operator/controllers/common/fake/spanitem_mock.go rename to operator/controllers/interfaces/fake/spanitem_mock.go diff --git a/operator/controllers/common/fake/tracer_mock.go b/operator/controllers/interfaces/fake/tracer_mock.go similarity index 100% rename from operator/controllers/common/fake/tracer_mock.go rename to operator/controllers/interfaces/fake/tracer_mock.go diff --git a/operator/controllers/common/listitem.go b/operator/controllers/interfaces/listitem.go similarity index 70% rename from operator/controllers/common/listitem.go rename to operator/controllers/interfaces/listitem.go index aa1ba80f86..ada924123f 100644 --- a/operator/controllers/common/listitem.go +++ b/operator/controllers/interfaces/listitem.go @@ -1,6 +1,9 @@ -package common +package interfaces -import "sigs.k8s.io/controller-runtime/pkg/client" +import ( + "github.com/keptn/lifecycle-toolkit/operator/controllers/errors" + "sigs.k8s.io/controller-runtime/pkg/client" +) //go:generate moq -pkg fake --skip-ensure -out ./fake/listitem_mock.go . ListItem type ListItem interface { @@ -14,7 +17,7 @@ type ListItemWrapper struct { func NewListItemWrapperFromClientObjectList(object client.ObjectList) (*ListItemWrapper, error) { pi, ok := object.(ListItem) if !ok { - return nil, ErrCannotWrapToListItem + return nil, errors.ErrCannotWrapToListItem } return &ListItemWrapper{Obj: pi}, nil } diff --git a/operator/controllers/common/listitem_test.go b/operator/controllers/interfaces/listitem_test.go similarity index 78% rename from operator/controllers/common/listitem_test.go rename to operator/controllers/interfaces/listitem_test.go index 103f0e3eaa..b762d0b117 100644 --- a/operator/controllers/common/listitem_test.go +++ b/operator/controllers/interfaces/listitem_test.go @@ -1,11 +1,11 @@ -package common +package interfaces import ( "testing" "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" - "github.com/keptn/lifecycle-toolkit/operator/controllers/common/fake" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + "github.com/keptn/lifecycle-toolkit/operator/controllers/interfaces/fake" "github.com/stretchr/testify/require" "sigs.k8s.io/controller-runtime/pkg/client" ) @@ -15,7 +15,7 @@ func TestListItemWrapper(t *testing.T) { Items: []v1alpha1.KeptnAppVersion{ { Status: v1alpha1.KeptnAppVersionStatus{ - Status: common.StateFailed, + Status: apicommon.StateFailed, CurrentPhase: "test", }, }, diff --git a/operator/controllers/common/metricsobject.go b/operator/controllers/interfaces/metricsobject.go similarity index 92% rename from operator/controllers/common/metricsobject.go rename to operator/controllers/interfaces/metricsobject.go index 4ef3b0553b..0c43e8c68c 100644 --- a/operator/controllers/common/metricsobject.go +++ b/operator/controllers/interfaces/metricsobject.go @@ -1,8 +1,9 @@ -package common +package interfaces import ( "time" + "github.com/keptn/lifecycle-toolkit/operator/controllers/errors" "go.opentelemetry.io/otel/attribute" "sigs.k8s.io/controller-runtime/pkg/client" ) @@ -28,7 +29,7 @@ type MetricsObjectWrapper struct { func NewMetricsObjectWrapperFromClientObject(object client.Object) (*MetricsObjectWrapper, error) { mo, ok := object.(MetricsObject) if !ok { - return nil, ErrCannotWrapToMetricsObject + return nil, errors.ErrCannotWrapToMetricsObject } return &MetricsObjectWrapper{Obj: mo}, nil } diff --git a/operator/controllers/common/metricsobject_test.go b/operator/controllers/interfaces/metricsobject_test.go similarity index 90% rename from operator/controllers/common/metricsobject_test.go rename to operator/controllers/interfaces/metricsobject_test.go index b877e2ef5d..332ac3a63b 100644 --- a/operator/controllers/common/metricsobject_test.go +++ b/operator/controllers/interfaces/metricsobject_test.go @@ -1,12 +1,12 @@ -package common +package interfaces import ( "testing" "time" "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" - "github.com/keptn/lifecycle-toolkit/operator/controllers/common/fake" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + "github.com/keptn/lifecycle-toolkit/operator/controllers/interfaces/fake" "github.com/stretchr/testify/require" "go.opentelemetry.io/otel/attribute" ) @@ -14,7 +14,7 @@ import ( func TestMetricsObjectWrapper(t *testing.T) { appVersion := v1alpha1.KeptnAppVersion{ Status: v1alpha1.KeptnAppVersionStatus{ - Status: common.StateFailed, + Status: apicommon.StateFailed, CurrentPhase: "test", }, } diff --git a/operator/controllers/common/phaseitem.go b/operator/controllers/interfaces/phaseitem.go similarity index 87% rename from operator/controllers/common/phaseitem.go rename to operator/controllers/interfaces/phaseitem.go index 385810cdd0..5770bbc142 100644 --- a/operator/controllers/common/phaseitem.go +++ b/operator/controllers/interfaces/phaseitem.go @@ -1,11 +1,11 @@ -package common +package interfaces import ( "time" klcv1alpha1 "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + "github.com/keptn/lifecycle-toolkit/operator/controllers/errors" "go.opentelemetry.io/otel/attribute" "go.opentelemetry.io/otel/trace" "sigs.k8s.io/controller-runtime/pkg/client" @@ -36,11 +36,11 @@ type PhaseItem interface { GetPostDeploymentEvaluations() []string GetPreDeploymentEvaluationTaskStatus() []klcv1alpha1.EvaluationStatus GetPostDeploymentEvaluationTaskStatus() []klcv1alpha1.EvaluationStatus - GenerateTask(taskDefinition string, checkType common.CheckType) klcv1alpha1.KeptnTask - GenerateEvaluation(evaluationDefinition string, checkType common.CheckType) klcv1alpha1.KeptnEvaluation + GenerateTask(taskDefinition string, checkType apicommon.CheckType) klcv1alpha1.KeptnTask + GenerateEvaluation(evaluationDefinition string, checkType apicommon.CheckType) klcv1alpha1.KeptnEvaluation GetSpanAttributes() []attribute.KeyValue SetSpanAttributes(span trace.Span) - CancelRemainingPhases(phase common.KeptnPhaseType) + CancelRemainingPhases(phase apicommon.KeptnPhaseType) } type PhaseItemWrapper struct { @@ -50,7 +50,7 @@ type PhaseItemWrapper struct { func NewPhaseItemWrapperFromClientObject(object client.Object) (*PhaseItemWrapper, error) { pi, ok := object.(PhaseItem) if !ok { - return nil, ErrCannotWrapToPhaseItem + return nil, errors.ErrCannotWrapToPhaseItem } return &PhaseItemWrapper{Obj: pi}, nil } @@ -139,11 +139,11 @@ func (pw PhaseItemWrapper) GetPostDeploymentEvaluationTaskStatus() []klcv1alpha1 return pw.Obj.GetPostDeploymentEvaluationTaskStatus() } -func (pw PhaseItemWrapper) GenerateTask(taskDefinition string, checkType common.CheckType) klcv1alpha1.KeptnTask { +func (pw PhaseItemWrapper) GenerateTask(taskDefinition string, checkType apicommon.CheckType) klcv1alpha1.KeptnTask { return pw.Obj.GenerateTask(taskDefinition, checkType) } -func (pw PhaseItemWrapper) GenerateEvaluation(evaluationDefinition string, checkType common.CheckType) klcv1alpha1.KeptnEvaluation { +func (pw PhaseItemWrapper) GenerateEvaluation(evaluationDefinition string, checkType apicommon.CheckType) klcv1alpha1.KeptnEvaluation { return pw.Obj.GenerateEvaluation(evaluationDefinition, checkType) } @@ -155,6 +155,6 @@ func (pw PhaseItemWrapper) GetSpanAttributes() []attribute.KeyValue { return pw.Obj.GetSpanAttributes() } -func (pw PhaseItemWrapper) CancelRemainingPhases(phase common.KeptnPhaseType) { +func (pw PhaseItemWrapper) CancelRemainingPhases(phase apicommon.KeptnPhaseType) { pw.Obj.CancelRemainingPhases(phase) } diff --git a/operator/controllers/common/phaseitem_test.go b/operator/controllers/interfaces/phaseitem_test.go similarity index 85% rename from operator/controllers/common/phaseitem_test.go rename to operator/controllers/interfaces/phaseitem_test.go index db21bed34e..592cd3fc98 100644 --- a/operator/controllers/common/phaseitem_test.go +++ b/operator/controllers/interfaces/phaseitem_test.go @@ -1,12 +1,12 @@ -package common +package interfaces import ( "testing" "time" "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" - "github.com/keptn/lifecycle-toolkit/operator/controllers/common/fake" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + "github.com/keptn/lifecycle-toolkit/operator/controllers/interfaces/fake" "github.com/stretchr/testify/require" "go.opentelemetry.io/otel/attribute" "go.opentelemetry.io/otel/trace" @@ -15,7 +15,7 @@ import ( func TestPhaseItemWrapper_GetState(t *testing.T) { appVersion := &v1alpha1.KeptnAppVersion{ Status: v1alpha1.KeptnAppVersionStatus{ - Status: common.StateFailed, + Status: apicommon.StateFailed, CurrentPhase: "test", }, } @@ -32,10 +32,10 @@ func TestPhaseItemWrapper_GetState(t *testing.T) { func TestPhaseItem(t *testing.T) { phaseItemMock := fake.PhaseItemMock{ - GetStateFunc: func() common.KeptnState { - return common.StatePending + GetStateFunc: func() apicommon.KeptnState { + return apicommon.StatePending }, - SetStateFunc: func(keptnState common.KeptnState) { + SetStateFunc: func(keptnState apicommon.KeptnState) { }, GetCurrentPhaseFunc: func() string { return "phase" @@ -95,15 +95,15 @@ func TestPhaseItem(t *testing.T) { GetPostDeploymentEvaluationTaskStatusFunc: func() []v1alpha1.EvaluationStatus { return nil }, - GenerateTaskFunc: func(taskDefinition string, checkType common.CheckType) v1alpha1.KeptnTask { + GenerateTaskFunc: func(taskDefinition string, checkType apicommon.CheckType) v1alpha1.KeptnTask { return v1alpha1.KeptnTask{} }, - GenerateEvaluationFunc: func(evaluationDefinition string, checkType common.CheckType) v1alpha1.KeptnEvaluation { + GenerateEvaluationFunc: func(evaluationDefinition string, checkType apicommon.CheckType) v1alpha1.KeptnEvaluation { return v1alpha1.KeptnEvaluation{} }, SetSpanAttributesFunc: func(span trace.Span) { }, - CancelRemainingPhasesFunc: func(phase common.KeptnPhaseType) { + CancelRemainingPhasesFunc: func(phase apicommon.KeptnPhaseType) { }, } @@ -112,7 +112,7 @@ func TestPhaseItem(t *testing.T) { _ = wrapper.GetState() require.Len(t, phaseItemMock.GetStateCalls(), 1) - wrapper.SetState(common.StateFailed) + wrapper.SetState(apicommon.StateFailed) require.Len(t, phaseItemMock.SetStateCalls(), 1) _ = wrapper.GetCurrentPhase() @@ -175,16 +175,16 @@ func TestPhaseItem(t *testing.T) { _ = wrapper.GetPostDeploymentEvaluationTaskStatus() require.Len(t, phaseItemMock.GetPostDeploymentEvaluationTaskStatusCalls(), 1) - _ = wrapper.GenerateTask("", common.PostDeploymentCheckType) + _ = wrapper.GenerateTask("", apicommon.PostDeploymentCheckType) require.Len(t, phaseItemMock.GenerateTaskCalls(), 1) - _ = wrapper.GenerateEvaluation("", common.PostDeploymentCheckType) + _ = wrapper.GenerateEvaluation("", apicommon.PostDeploymentCheckType) require.Len(t, phaseItemMock.GenerateEvaluationCalls(), 1) wrapper.SetSpanAttributes(nil) require.Len(t, phaseItemMock.SetSpanAttributesCalls(), 1) - wrapper.CancelRemainingPhases(common.PhaseAppDeployment) + wrapper.CancelRemainingPhases(apicommon.PhaseAppDeployment) require.Len(t, phaseItemMock.CancelRemainingPhasesCalls(), 1) } diff --git a/operator/controllers/common/spanitem.go b/operator/controllers/interfaces/spanitem.go similarity index 89% rename from operator/controllers/common/spanitem.go rename to operator/controllers/interfaces/spanitem.go index da73864d5b..48e77ca0fd 100644 --- a/operator/controllers/common/spanitem.go +++ b/operator/controllers/interfaces/spanitem.go @@ -1,6 +1,7 @@ -package common +package interfaces import ( + "github.com/keptn/lifecycle-toolkit/operator/controllers/errors" "go.opentelemetry.io/otel/propagation" "go.opentelemetry.io/otel/trace" "sigs.k8s.io/controller-runtime/pkg/client" @@ -23,7 +24,7 @@ type SpanItemWrapper struct { func NewSpanItemWrapperFromClientObject(object client.Object) (*SpanItemWrapper, error) { mo, ok := object.(SpanItem) if !ok { - return nil, ErrCannotWrapToSpanItem + return nil, errors.ErrCannotWrapToSpanItem } return &SpanItemWrapper{Obj: mo}, nil } diff --git a/operator/controllers/common/spanitem_test.go b/operator/controllers/interfaces/spanitem_test.go similarity index 84% rename from operator/controllers/common/spanitem_test.go rename to operator/controllers/interfaces/spanitem_test.go index b2329ade37..94911aca91 100644 --- a/operator/controllers/common/spanitem_test.go +++ b/operator/controllers/interfaces/spanitem_test.go @@ -1,11 +1,11 @@ -package common +package interfaces import ( "testing" "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" - "github.com/keptn/lifecycle-toolkit/operator/controllers/common/fake" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + "github.com/keptn/lifecycle-toolkit/operator/controllers/interfaces/fake" "github.com/stretchr/testify/require" "go.opentelemetry.io/otel/propagation" "go.opentelemetry.io/otel/trace" @@ -20,10 +20,10 @@ func TestSpanItemWrapper(t *testing.T) { Spec: v1alpha1.KeptnEvaluationSpec{ AppName: "app", AppVersion: "appversion", - Type: common.PostDeploymentCheckType, + Type: apicommon.PostDeploymentCheckType, }, Status: v1alpha1.KeptnEvaluationStatus{ - OverallStatus: common.StateFailed, + OverallStatus: apicommon.StateFailed, }, } diff --git a/operator/controllers/common/tracer.go b/operator/controllers/interfaces/tracer.go similarity index 88% rename from operator/controllers/common/tracer.go rename to operator/controllers/interfaces/tracer.go index a8964c4dc6..bd88b808ff 100644 --- a/operator/controllers/common/tracer.go +++ b/operator/controllers/interfaces/tracer.go @@ -1,4 +1,4 @@ -package common +package interfaces import "go.opentelemetry.io/otel/trace" diff --git a/operator/controllers/keptnapp/controller.go b/operator/controllers/keptnapp/controller.go index 1d26619b91..7d19292008 100644 --- a/operator/controllers/keptnapp/controller.go +++ b/operator/controllers/keptnapp/controller.go @@ -22,7 +22,8 @@ import ( "github.com/go-logr/logr" klcv1alpha1 "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - "github.com/keptn/lifecycle-toolkit/operator/controllers/common" + controllererrors "github.com/keptn/lifecycle-toolkit/operator/controllers/errors" + "github.com/keptn/lifecycle-toolkit/operator/controllers/interfaces" "go.opentelemetry.io/otel" "go.opentelemetry.io/otel/codes" "go.opentelemetry.io/otel/propagation" @@ -46,7 +47,7 @@ type KeptnAppReconciler struct { Scheme *runtime.Scheme Recorder record.EventRecorder Log logr.Logger - Tracer common.ITracer + Tracer interfaces.ITracer } //+kubebuilder:rbac:groups=lifecycle.keptn.sh,resources=keptnapps,verbs=get;list;watch;create;update;patch;delete @@ -74,7 +75,7 @@ func (r *KeptnAppReconciler) Reconcile(ctx context.Context, req ctrl.Request) (c return reconcile.Result{}, nil } if err != nil { - return reconcile.Result{}, fmt.Errorf(common.ErrCannotFetchAppMsg, err) + return reconcile.Result{}, fmt.Errorf(controllererrors.ErrCannotFetchAppMsg, err) } traceContextCarrier := propagation.MapCarrier(app.Annotations) diff --git a/operator/controllers/keptnapp/controller_test.go b/operator/controllers/keptnapp/controller_test.go index 5ae3b53258..a8baa716b9 100644 --- a/operator/controllers/keptnapp/controller_test.go +++ b/operator/controllers/keptnapp/controller_test.go @@ -6,9 +6,10 @@ import ( "testing" lfcv1alpha1 "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - keptncommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" - utils "github.com/keptn/lifecycle-toolkit/operator/controllers/common" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + controllercommon "github.com/keptn/lifecycle-toolkit/operator/controllers/common" "github.com/keptn/lifecycle-toolkit/operator/controllers/common/fake" + interfacesfake "github.com/keptn/lifecycle-toolkit/operator/controllers/interfaces/fake" "github.com/magiconair/properties/assert" "github.com/stretchr/testify/require" "go.opentelemetry.io/otel/trace" @@ -91,11 +92,11 @@ func TestKeptnAppReconciler_reconcile(t *testing.T) { //setting up fakeclient CRD data - err := utils.AddApp(r.Client, "myapp") + err := controllercommon.AddApp(r.Client, "myapp") require.Nil(t, err) - err = utils.AddApp(r.Client, "myfinishedapp") + err = controllercommon.AddApp(r.Client, "myfinishedapp") require.Nil(t, err) - err = utils.AddAppVersion(r.Client, "default", "myfinishedapp", "1.0.0", nil, lfcv1alpha1.KeptnAppVersionStatus{Status: keptncommon.StateSucceeded}) + err = controllercommon.AddAppVersion(r.Client, "default", "myfinishedapp", "1.0.0", nil, lfcv1alpha1.KeptnAppVersionStatus{Status: apicommon.StateSucceeded}) require.Nil(t, err) for _, tt := range tests { @@ -126,7 +127,7 @@ func TestKeptnAppReconciler_reconcile(t *testing.T) { assert.Equal(t, tracer.StartCalls()[3].SpanName, "reconcile_app") } -func setupReconciler(t *testing.T) (*KeptnAppReconciler, chan string, *fake.ITracerMock) { +func setupReconciler(t *testing.T) (*KeptnAppReconciler, chan string, *interfacesfake.ITracerMock) { //setup logger opts := zap.Options{ Development: true, @@ -134,7 +135,7 @@ func setupReconciler(t *testing.T) (*KeptnAppReconciler, chan string, *fake.ITra ctrl.SetLogger(zap.New(zap.UseFlagOptions(&opts))) //fake a tracer - tr := &fake.ITracerMock{StartFunc: func(ctx context.Context, spanName string, opts ...trace.SpanStartOption) (context.Context, trace.Span) { + tr := &interfacesfake.ITracerMock{StartFunc: func(ctx context.Context, spanName string, opts ...trace.SpanStartOption) (context.Context, trace.Span) { return ctx, trace.SpanFromContext(ctx) }} diff --git a/operator/controllers/keptnappversion/controller.go b/operator/controllers/keptnappversion/controller.go index 3fab763f8c..0478705130 100644 --- a/operator/controllers/keptnappversion/controller.go +++ b/operator/controllers/keptnappversion/controller.go @@ -23,8 +23,10 @@ import ( "github.com/go-logr/logr" klcv1alpha1 "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" controllercommon "github.com/keptn/lifecycle-toolkit/operator/controllers/common" + controllererrors "github.com/keptn/lifecycle-toolkit/operator/controllers/errors" + "github.com/keptn/lifecycle-toolkit/operator/controllers/interfaces" "go.opentelemetry.io/otel" "go.opentelemetry.io/otel/codes" "go.opentelemetry.io/otel/propagation" @@ -45,8 +47,8 @@ type KeptnAppVersionReconciler struct { client.Client Log logr.Logger Recorder record.EventRecorder - Tracer controllercommon.ITracer - Meters common.KeptnMeters + Tracer interfaces.ITracer + Meters apicommon.KeptnMeters SpanHandler controllercommon.ISpanHandler } @@ -76,14 +78,14 @@ func (r *KeptnAppVersionReconciler) Reconcile(ctx context.Context, req ctrl.Requ if err != nil { r.Log.Error(err, "App Version not found") - return reconcile.Result{}, fmt.Errorf(controllercommon.ErrCannotFetchAppVersionMsg, err) + return reconcile.Result{}, fmt.Errorf(controllererrors.ErrCannotFetchAppVersionMsg, err) } ctx, ctxAppTrace, span, endSpan := setupSpansContexts(ctx, appVersion, r) defer endSpan() - phase := common.PhaseAppPreDeployment + phase := apicommon.PhaseAppPreDeployment phaseHandler := controllercommon.PhaseHandler{ Client: r.Client, @@ -104,8 +106,8 @@ func (r *KeptnAppVersionReconciler) Reconcile(ctx context.Context, req ctrl.Requ } if !appVersion.IsPreDeploymentSucceeded() { - reconcilePreDep := func(phaseCtx context.Context) (common.KeptnState, error) { - return r.reconcilePrePostDeployment(ctx, phaseCtx, appVersion, common.PreDeploymentCheckType) + reconcilePreDep := func(phaseCtx context.Context) (apicommon.KeptnState, error) { + return r.reconcilePrePostDeployment(ctx, phaseCtx, appVersion, apicommon.PreDeploymentCheckType) } result, err := phaseHandler.HandlePhase(ctx, ctxAppTrace, r.Tracer, appVersion, phase, span, reconcilePreDep) if !result.Continue { @@ -113,10 +115,10 @@ func (r *KeptnAppVersionReconciler) Reconcile(ctx context.Context, req ctrl.Requ } } - phase = common.PhaseAppPreEvaluation + phase = apicommon.PhaseAppPreEvaluation if !appVersion.IsPreDeploymentEvaluationSucceeded() { - reconcilePreEval := func(phaseCtx context.Context) (common.KeptnState, error) { - return r.reconcilePrePostEvaluation(ctx, phaseCtx, appVersion, common.PreDeploymentEvaluationCheckType) + reconcilePreEval := func(phaseCtx context.Context) (apicommon.KeptnState, error) { + return r.reconcilePrePostEvaluation(ctx, phaseCtx, appVersion, apicommon.PreDeploymentEvaluationCheckType) } result, err := phaseHandler.HandlePhase(ctx, ctxAppTrace, r.Tracer, appVersion, phase, span, reconcilePreEval) if !result.Continue { @@ -124,9 +126,9 @@ func (r *KeptnAppVersionReconciler) Reconcile(ctx context.Context, req ctrl.Requ } } - phase = common.PhaseAppDeployment + phase = apicommon.PhaseAppDeployment if !appVersion.AreWorkloadsSucceeded() { - reconcileAppDep := func(phaseCtx context.Context) (common.KeptnState, error) { + reconcileAppDep := func(phaseCtx context.Context) (apicommon.KeptnState, error) { return r.reconcileWorkloads(ctx, appVersion) } result, err := phaseHandler.HandlePhase(ctx, ctxAppTrace, r.Tracer, appVersion, phase, span, reconcileAppDep) @@ -135,10 +137,10 @@ func (r *KeptnAppVersionReconciler) Reconcile(ctx context.Context, req ctrl.Requ } } - phase = common.PhaseAppPostDeployment + phase = apicommon.PhaseAppPostDeployment if !appVersion.IsPostDeploymentSucceeded() { - reconcilePostDep := func(phaseCtx context.Context) (common.KeptnState, error) { - return r.reconcilePrePostDeployment(ctx, phaseCtx, appVersion, common.PostDeploymentCheckType) + reconcilePostDep := func(phaseCtx context.Context) (apicommon.KeptnState, error) { + return r.reconcilePrePostDeployment(ctx, phaseCtx, appVersion, apicommon.PostDeploymentCheckType) } result, err := phaseHandler.HandlePhase(ctx, ctxAppTrace, r.Tracer, appVersion, phase, span, reconcilePostDep) if !result.Continue { @@ -146,10 +148,10 @@ func (r *KeptnAppVersionReconciler) Reconcile(ctx context.Context, req ctrl.Requ } } - phase = common.PhaseAppPostEvaluation + phase = apicommon.PhaseAppPostEvaluation if !appVersion.IsPostDeploymentEvaluationCompleted() { - reconcilePostEval := func(phaseCtx context.Context) (common.KeptnState, error) { - return r.reconcilePrePostEvaluation(ctx, phaseCtx, appVersion, common.PostDeploymentEvaluationCheckType) + reconcilePostEval := func(phaseCtx context.Context) (apicommon.KeptnState, error) { + return r.reconcilePrePostEvaluation(ctx, phaseCtx, appVersion, apicommon.PostDeploymentEvaluationCheckType) } result, err := phaseHandler.HandlePhase(ctx, ctxAppTrace, r.Tracer, appVersion, phase, span, reconcilePostEval) if !result.Continue { @@ -167,7 +169,7 @@ func (r *KeptnAppVersionReconciler) Reconcile(ctx context.Context, req ctrl.Requ // AppVersion is completed at this place if !appVersion.IsEndTimeSet() { - appVersion.Status.CurrentPhase = common.PhaseCompleted.ShortName + appVersion.Status.CurrentPhase = apicommon.PhaseCompleted.ShortName appVersion.SetEndTime() } @@ -186,7 +188,7 @@ func (r *KeptnAppVersionReconciler) Reconcile(ctx context.Context, req ctrl.Requ spanAppTrace.SetStatus(codes.Ok, "Finished") spanAppTrace.End() if err := r.SpanHandler.UnbindSpan(appVersion, ""); err != nil { - r.Log.Error(err, controllercommon.ErrCouldNotUnbindSpan, appVersion.Name) + r.Log.Error(err, controllererrors.ErrCouldNotUnbindSpan, appVersion.Name) } return ctrl.Result{}, nil diff --git a/operator/controllers/keptnappversion/controller_test.go b/operator/controllers/keptnappversion/controller_test.go index 5507c38f72..f4d1110292 100644 --- a/operator/controllers/keptnappversion/controller_test.go +++ b/operator/controllers/keptnappversion/controller_test.go @@ -8,9 +8,10 @@ import ( "testing" lfcv1alpha1 "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - keptncommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" - utils "github.com/keptn/lifecycle-toolkit/operator/controllers/common" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + controllercommon "github.com/keptn/lifecycle-toolkit/operator/controllers/common" "github.com/keptn/lifecycle-toolkit/operator/controllers/common/fake" + interfacesfake "github.com/keptn/lifecycle-toolkit/operator/controllers/interfaces/fake" "github.com/magiconair/properties/assert" "github.com/stretchr/testify/require" "go.opentelemetry.io/otel/trace" @@ -84,9 +85,9 @@ func TestKeptnAppVersionReconciler_reconcile(t *testing.T) { //setting up fakeclient CRD data - err := utils.AddAppVersion(r.Client, "default", "myappversion", "1.0.0", nil, lfcv1alpha1.KeptnAppVersionStatus{Status: keptncommon.StatePending}) + err := controllercommon.AddAppVersion(r.Client, "default", "myappversion", "1.0.0", nil, lfcv1alpha1.KeptnAppVersionStatus{Status: apicommon.StatePending}) require.Nil(t, err) - err = utils.AddAppVersion(r.Client, "default", "myfinishedapp", "1.0.0", nil, createFinishedAppVersionStatus()) + err = controllercommon.AddAppVersion(r.Client, "default", "myfinishedapp", "1.0.0", nil, createFinishedAppVersionStatus()) require.Nil(t, err) traces := 0 @@ -121,18 +122,18 @@ func TestKeptnAppVersionReconciler_reconcile(t *testing.T) { func createFinishedAppVersionStatus() lfcv1alpha1.KeptnAppVersionStatus { return lfcv1alpha1.KeptnAppVersionStatus{ - CurrentPhase: keptncommon.PhaseCompleted.ShortName, - PreDeploymentStatus: keptncommon.StateSucceeded, - PostDeploymentStatus: keptncommon.StateSucceeded, - PreDeploymentEvaluationStatus: keptncommon.StateSucceeded, - PostDeploymentEvaluationStatus: keptncommon.StateSucceeded, - PreDeploymentTaskStatus: []lfcv1alpha1.TaskStatus{{Status: keptncommon.StateSucceeded}}, - PostDeploymentTaskStatus: []lfcv1alpha1.TaskStatus{{Status: keptncommon.StateSucceeded}}, - PreDeploymentEvaluationTaskStatus: []lfcv1alpha1.EvaluationStatus{{Status: keptncommon.StateSucceeded}}, - PostDeploymentEvaluationTaskStatus: []lfcv1alpha1.EvaluationStatus{{Status: keptncommon.StateSucceeded}}, - WorkloadOverallStatus: keptncommon.StateSucceeded, - WorkloadStatus: []lfcv1alpha1.WorkloadStatus{{Status: keptncommon.StateSucceeded}}, - Status: keptncommon.StateSucceeded, + CurrentPhase: apicommon.PhaseCompleted.ShortName, + PreDeploymentStatus: apicommon.StateSucceeded, + PostDeploymentStatus: apicommon.StateSucceeded, + PreDeploymentEvaluationStatus: apicommon.StateSucceeded, + PostDeploymentEvaluationStatus: apicommon.StateSucceeded, + PreDeploymentTaskStatus: []lfcv1alpha1.TaskStatus{{Status: apicommon.StateSucceeded}}, + PostDeploymentTaskStatus: []lfcv1alpha1.TaskStatus{{Status: apicommon.StateSucceeded}}, + PreDeploymentEvaluationTaskStatus: []lfcv1alpha1.EvaluationStatus{{Status: apicommon.StateSucceeded}}, + PostDeploymentEvaluationTaskStatus: []lfcv1alpha1.EvaluationStatus{{Status: apicommon.StateSucceeded}}, + WorkloadOverallStatus: apicommon.StateSucceeded, + WorkloadStatus: []lfcv1alpha1.WorkloadStatus{{Status: apicommon.StateSucceeded}}, + Status: apicommon.StateSucceeded, } } @@ -144,19 +145,19 @@ func setupReconcilerWithMeters(t *testing.T) *KeptnAppVersionReconciler { ctrl.SetLogger(zap.New(zap.UseFlagOptions(&opts))) //fake a tracer - tr := &fake.ITracerMock{StartFunc: func(ctx context.Context, spanName string, opts ...trace.SpanStartOption) (context.Context, trace.Span) { + tr := &interfacesfake.ITracerMock{StartFunc: func(ctx context.Context, spanName string, opts ...trace.SpanStartOption) (context.Context, trace.Span) { return ctx, trace.SpanFromContext(ctx) }} r := &KeptnAppVersionReconciler{ Log: ctrl.Log.WithName("test-appVersionController"), Tracer: tr, - Meters: utils.InitAppMeters(), + Meters: controllercommon.InitAppMeters(), } return r } -func setupReconciler(t *testing.T) (*KeptnAppVersionReconciler, chan string, *fake.ITracerMock, *fake.ISpanHandlerMock) { +func setupReconciler(t *testing.T) (*KeptnAppVersionReconciler, chan string, *interfacesfake.ITracerMock, *fake.ISpanHandlerMock) { //setup logger opts := zap.Options{ Development: true, @@ -164,7 +165,7 @@ func setupReconciler(t *testing.T) (*KeptnAppVersionReconciler, chan string, *fa ctrl.SetLogger(zap.New(zap.UseFlagOptions(&opts))) //fake a tracer - tr := &fake.ITracerMock{StartFunc: func(ctx context.Context, spanName string, opts ...trace.SpanStartOption) (context.Context, trace.Span) { + tr := &interfacesfake.ITracerMock{StartFunc: func(ctx context.Context, spanName string, opts ...trace.SpanStartOption) (context.Context, trace.Span) { return ctx, trace.SpanFromContext(ctx) }} @@ -189,7 +190,7 @@ func setupReconciler(t *testing.T) (*KeptnAppVersionReconciler, chan string, *fa Log: ctrl.Log.WithName("test-appVersionController"), Tracer: tr, SpanHandler: spanRecorder, - Meters: utils.InitAppMeters(), + Meters: controllercommon.InitAppMeters(), } return r, recorder.Events, tr, spanRecorder } diff --git a/operator/controllers/keptnappversion/reconcile_prepostdeployment.go b/operator/controllers/keptnappversion/reconcile_prepostdeployment.go index 76e65ca01e..9462ede560 100644 --- a/operator/controllers/keptnappversion/reconcile_prepostdeployment.go +++ b/operator/controllers/keptnappversion/reconcile_prepostdeployment.go @@ -5,11 +5,11 @@ import ( "fmt" klcv1alpha1 "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" controllercommon "github.com/keptn/lifecycle-toolkit/operator/controllers/common" ) -func (r *KeptnAppVersionReconciler) reconcilePrePostDeployment(ctx context.Context, phaseCtx context.Context, appVersion *klcv1alpha1.KeptnAppVersion, checkType common.CheckType) (common.KeptnState, error) { +func (r *KeptnAppVersionReconciler) reconcilePrePostDeployment(ctx context.Context, phaseCtx context.Context, appVersion *klcv1alpha1.KeptnAppVersion, checkType apicommon.CheckType) (apicommon.KeptnState, error) { taskHandler := controllercommon.TaskHandler{ Client: r.Client, Recorder: r.Recorder, @@ -20,21 +20,21 @@ func (r *KeptnAppVersionReconciler) reconcilePrePostDeployment(ctx context.Conte } taskCreateAttributes := controllercommon.TaskCreateAttributes{ - SpanName: fmt.Sprintf(common.CreateAppTaskSpanName, checkType), + SpanName: fmt.Sprintf(apicommon.CreateAppTaskSpanName, checkType), CheckType: checkType, } newStatus, state, err := taskHandler.ReconcileTasks(ctx, phaseCtx, appVersion, taskCreateAttributes) if err != nil { - return common.StateUnknown, err + return apicommon.StateUnknown, err } - overallState := common.GetOverallState(state) + overallState := apicommon.GetOverallState(state) switch checkType { - case common.PreDeploymentCheckType: + case apicommon.PreDeploymentCheckType: appVersion.Status.PreDeploymentStatus = overallState appVersion.Status.PreDeploymentTaskStatus = newStatus - case common.PostDeploymentCheckType: + case apicommon.PostDeploymentCheckType: appVersion.Status.PostDeploymentStatus = overallState appVersion.Status.PostDeploymentTaskStatus = newStatus } @@ -42,7 +42,7 @@ func (r *KeptnAppVersionReconciler) reconcilePrePostDeployment(ctx context.Conte // Write Status Field err = r.Client.Status().Update(ctx, appVersion) if err != nil { - return common.StateUnknown, err + return apicommon.StateUnknown, err } return overallState, nil } diff --git a/operator/controllers/keptnappversion/reconcile_prepostevaluation.go b/operator/controllers/keptnappversion/reconcile_prepostevaluation.go index 6267065fb5..92303a32b2 100644 --- a/operator/controllers/keptnappversion/reconcile_prepostevaluation.go +++ b/operator/controllers/keptnappversion/reconcile_prepostevaluation.go @@ -5,11 +5,11 @@ import ( "fmt" klcv1alpha1 "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" controllercommon "github.com/keptn/lifecycle-toolkit/operator/controllers/common" ) -func (r *KeptnAppVersionReconciler) reconcilePrePostEvaluation(ctx context.Context, phaseCtx context.Context, appVersion *klcv1alpha1.KeptnAppVersion, checkType common.CheckType) (common.KeptnState, error) { +func (r *KeptnAppVersionReconciler) reconcilePrePostEvaluation(ctx context.Context, phaseCtx context.Context, appVersion *klcv1alpha1.KeptnAppVersion, checkType apicommon.CheckType) (apicommon.KeptnState, error) { evaluationHandler := controllercommon.EvaluationHandler{ Client: r.Client, Recorder: r.Recorder, @@ -20,22 +20,22 @@ func (r *KeptnAppVersionReconciler) reconcilePrePostEvaluation(ctx context.Conte } evaluationCreateAttributes := controllercommon.EvaluationCreateAttributes{ - SpanName: fmt.Sprintf(common.CreateAppEvalSpanName, checkType), + SpanName: fmt.Sprintf(apicommon.CreateAppEvalSpanName, checkType), CheckType: checkType, } newStatus, state, err := evaluationHandler.ReconcileEvaluations(ctx, phaseCtx, appVersion, evaluationCreateAttributes) if err != nil { - return common.StateUnknown, err + return apicommon.StateUnknown, err } - overallState := common.GetOverallState(state) + overallState := apicommon.GetOverallState(state) switch checkType { - case common.PreDeploymentEvaluationCheckType: + case apicommon.PreDeploymentEvaluationCheckType: appVersion.Status.PreDeploymentEvaluationStatus = overallState appVersion.Status.PreDeploymentEvaluationTaskStatus = newStatus - case common.PostDeploymentEvaluationCheckType: + case apicommon.PostDeploymentEvaluationCheckType: appVersion.Status.PostDeploymentEvaluationStatus = overallState appVersion.Status.PostDeploymentEvaluationTaskStatus = newStatus } @@ -43,7 +43,7 @@ func (r *KeptnAppVersionReconciler) reconcilePrePostEvaluation(ctx context.Conte // Write Status Field err = r.Client.Status().Update(ctx, appVersion) if err != nil { - return common.StateUnknown, err + return apicommon.StateUnknown, err } return overallState, nil } diff --git a/operator/controllers/keptnappversion/reconcile_workloadsstate.go b/operator/controllers/keptnappversion/reconcile_workloadsstate.go index 446c6c0ce6..839fab9cf3 100644 --- a/operator/controllers/keptnappversion/reconcile_workloadsstate.go +++ b/operator/controllers/keptnappversion/reconcile_workloadsstate.go @@ -4,18 +4,18 @@ import ( "context" klcv1alpha1 "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" controllercommon "github.com/keptn/lifecycle-toolkit/operator/controllers/common" "k8s.io/apimachinery/pkg/api/errors" "k8s.io/apimachinery/pkg/types" ) -func (r *KeptnAppVersionReconciler) reconcileWorkloads(ctx context.Context, appVersion *klcv1alpha1.KeptnAppVersion) (common.KeptnState, error) { +func (r *KeptnAppVersionReconciler) reconcileWorkloads(ctx context.Context, appVersion *klcv1alpha1.KeptnAppVersion) (apicommon.KeptnState, error) { r.Log.Info("Reconciling Workloads") - var summary common.StatusSummary + var summary apicommon.StatusSummary summary.Total = len(appVersion.Spec.Workloads) - phase := common.KeptnPhaseType{ + phase := apicommon.KeptnPhaseType{ ShortName: "ReconcileWorkload", LongName: "Reconcile Workloads", } @@ -26,10 +26,10 @@ func (r *KeptnAppVersionReconciler) reconcileWorkloads(ctx context.Context, appV workload, err := r.getWorkloadInstance(ctx, getWorkloadInstanceName(appVersion.Namespace, appVersion.Spec.AppName, w.Name, w.Version)) if err != nil && errors.IsNotFound(err) { controllercommon.RecordEvent(r.Recorder, phase, "Warning", appVersion, "NotFound", "workloadInstance not found", appVersion.GetVersion()) - workload.Status.Status = common.StatePending + workload.Status.Status = apicommon.StatePending } else if err != nil { r.Log.Error(err, "Could not get workload") - workload.Status.Status = common.StateUnknown + workload.Status.Status = apicommon.StateUnknown } workloadStatus := workload.Status.Status @@ -37,10 +37,10 @@ func (r *KeptnAppVersionReconciler) reconcileWorkloads(ctx context.Context, appV Workload: w, Status: workloadStatus, }) - summary = common.UpdateStatusSummary(workloadStatus, summary) + summary = apicommon.UpdateStatusSummary(workloadStatus, summary) } - overallState := common.GetOverallState(summary) + overallState := apicommon.GetOverallState(summary) appVersion.Status.WorkloadOverallStatus = overallState r.Log.Info("Overall state of workloads", "state", appVersion.Status.WorkloadOverallStatus) diff --git a/operator/controllers/keptnevaluation/controller.go b/operator/controllers/keptnevaluation/controller.go index 1ed6fadb3b..25b65498ba 100644 --- a/operator/controllers/keptnevaluation/controller.go +++ b/operator/controllers/keptnevaluation/controller.go @@ -26,8 +26,8 @@ import ( "github.com/go-logr/logr" klcv1alpha1 "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" - controllercommon "github.com/keptn/lifecycle-toolkit/operator/controllers/common" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + controllererrors "github.com/keptn/lifecycle-toolkit/operator/controllers/errors" promapi "github.com/prometheus/client_golang/api" prometheus "github.com/prometheus/client_golang/api/prometheus/v1" "github.com/prometheus/common/model" @@ -51,7 +51,7 @@ type KeptnEvaluationReconciler struct { Scheme *runtime.Scheme Recorder record.EventRecorder Log logr.Logger - Meters common.KeptnMeters + Meters apicommon.KeptnMeters Tracer trace.Tracer } @@ -96,9 +96,9 @@ func (r *KeptnEvaluationReconciler) Reconcile(ctx context.Context, req ctrl.Requ if evaluation.Status.RetryCount >= evaluation.Spec.Retries { r.recordEvent("Warning", evaluation, "ReconcileTimeOut", "retryCount exceeded") - err := controllercommon.ErrRetryCountExceeded + err := controllererrors.ErrRetryCountExceeded span.SetStatus(codes.Error, err.Error()) - evaluation.Status.OverallStatus = common.StateFailed + evaluation.Status.OverallStatus = apicommon.StateFailed err2 := r.updateFinishedEvaluationMetrics(ctx, evaluation, span) if err2 != nil { r.Log.Error(err2, "failed to update finished evaluation metrics") @@ -121,7 +121,7 @@ func (r *KeptnEvaluationReconciler) Reconcile(ctx context.Context, req ctrl.Requ return ctrl.Result{}, nil } - statusSummary := common.StatusSummary{} + statusSummary := apicommon.StatusSummary{} statusSummary.Total = len(evaluationDefinition.Spec.Objectives) newStatus := make(map[string]klcv1alpha1.EvaluationStatusItem) @@ -134,21 +134,21 @@ func (r *KeptnEvaluationReconciler) Reconcile(ctx context.Context, req ctrl.Requ evaluation.AddEvaluationStatus(query) } if evaluation.Status.EvaluationStatus[query.Name].Status.IsSucceeded() { - statusSummary = common.UpdateStatusSummary(common.StateSucceeded, statusSummary) + statusSummary = apicommon.UpdateStatusSummary(apicommon.StateSucceeded, statusSummary) newStatus[query.Name] = evaluation.Status.EvaluationStatus[query.Name] continue } statusItem := r.queryEvaluation(query, *evaluationProvider) - statusSummary = common.UpdateStatusSummary(statusItem.Status, statusSummary) + statusSummary = apicommon.UpdateStatusSummary(statusItem.Status, statusSummary) newStatus[query.Name] = *statusItem } evaluation.Status.RetryCount++ evaluation.Status.EvaluationStatus = newStatus - if common.GetOverallState(statusSummary) == common.StateSucceeded { - evaluation.Status.OverallStatus = common.StateSucceeded + if apicommon.GetOverallState(statusSummary) == apicommon.StateSucceeded { + evaluation.Status.OverallStatus = apicommon.StateSucceeded } else { - evaluation.Status.OverallStatus = common.StateProgressing + evaluation.Status.OverallStatus = apicommon.StateProgressing } } @@ -232,7 +232,7 @@ func (r *KeptnEvaluationReconciler) fetchDefinitionAndProvider(ctx context.Conte func (r *KeptnEvaluationReconciler) queryEvaluation(objective klcv1alpha1.Objective, provider klcv1alpha1.KeptnEvaluationProvider) *klcv1alpha1.EvaluationStatusItem { query := &klcv1alpha1.EvaluationStatusItem{ Value: "", - Status: common.StateFailed, //setting status per default to failed + Status: apicommon.StateFailed, //setting status per default to failed } queryTime := time.Now().UTC() @@ -288,7 +288,7 @@ func (r *KeptnEvaluationReconciler) queryEvaluation(objective klcv1alpha1.Object r.Log.Error(err, "Could not check query result") } if check { - query.Status = common.StateSucceeded + query.Status = apicommon.StateSucceeded } return query } @@ -296,7 +296,7 @@ func (r *KeptnEvaluationReconciler) queryEvaluation(objective klcv1alpha1.Object func (r *KeptnEvaluationReconciler) checkValue(objective klcv1alpha1.Objective, query *klcv1alpha1.EvaluationStatusItem) (bool, error) { if len(query.Value) == 0 || len(objective.EvaluationTarget) == 0 { - return false, controllercommon.ErrNoValues + return false, controllererrors.ErrNoValues } eval := objective.EvaluationTarget[1:] @@ -319,7 +319,7 @@ func (r *KeptnEvaluationReconciler) checkValue(objective klcv1alpha1.Objective, case "<": return resultValue < compareValue, nil default: - return false, controllercommon.ErrInvalidOperator + return false, controllererrors.ErrInvalidOperator } } diff --git a/operator/controllers/keptntask/controller.go b/operator/controllers/keptntask/controller.go index d455075733..3a39e509c0 100644 --- a/operator/controllers/keptntask/controller.go +++ b/operator/controllers/keptntask/controller.go @@ -23,8 +23,8 @@ import ( "github.com/go-logr/logr" klcv1alpha1 "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" - controllercommon "github.com/keptn/lifecycle-toolkit/operator/controllers/common" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + controllererrors "github.com/keptn/lifecycle-toolkit/operator/controllers/errors" "go.opentelemetry.io/otel" "go.opentelemetry.io/otel/codes" "go.opentelemetry.io/otel/propagation" @@ -45,7 +45,7 @@ type KeptnTaskReconciler struct { Scheme *runtime.Scheme Recorder record.EventRecorder Log logr.Logger - Meters common.KeptnMeters + Meters apicommon.KeptnMeters Tracer trace.Tracer } @@ -99,7 +99,7 @@ func (r *KeptnTaskReconciler) Reconcile(ctx context.Context, req ctrl.Request) ( span.SetStatus(codes.Error, err.Error()) r.Log.Error(err, "could not create Job") } else { - task.Status.Status = common.StateProgressing + task.Status.Status = apicommon.StateProgressing } return ctrl.Result{Requeue: true, RequeueAfter: 10 * time.Second}, nil } @@ -150,7 +150,7 @@ func (r *KeptnTaskReconciler) JobExists(ctx context.Context, task klcv1alpha1.Ke } if len(jobLabels) == 0 { - return false, fmt.Errorf(controllercommon.ErrNoLabelsFoundTask, task.Name) + return false, fmt.Errorf(controllererrors.ErrNoLabelsFoundTask, task.Name) } if err := r.Client.List(ctx, jobList, client.InNamespace(namespace), jobLabels); err != nil { diff --git a/operator/controllers/keptntask/function_utils.go b/operator/controllers/keptntask/function_utils.go index 8850145364..84a1767d37 100644 --- a/operator/controllers/keptntask/function_utils.go +++ b/operator/controllers/keptntask/function_utils.go @@ -7,8 +7,8 @@ import ( "os" klcv1alpha1 "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" - controllercommon "github.com/keptn/lifecycle-toolkit/operator/controllers/common" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + controllererrors "github.com/keptn/lifecycle-toolkit/operator/controllers/errors" batchv1 "k8s.io/api/batch/v1" corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -25,7 +25,7 @@ type FunctionExecutionParams struct { func (r *KeptnTaskReconciler) generateFunctionJob(task *klcv1alpha1.KeptnTask, params FunctionExecutionParams) (*batchv1.Job, error) { randomId := rand.Intn(99999-10000) + 10000 - jobId := fmt.Sprintf("klc-%s-%d", common.TruncateString(task.Name, common.MaxTaskNameLength), randomId) + jobId := fmt.Sprintf("klc-%s-%d", apicommon.TruncateString(task.Name, apicommon.MaxTaskNameLength), randomId) job := &batchv1.Job{ ObjectMeta: metav1.ObjectMeta{ Name: jobId, @@ -55,14 +55,14 @@ func (r *KeptnTaskReconciler) generateFunctionJob(task *klcv1alpha1.KeptnTask, p if len(params.Parameters) > 0 { jsonParams, err := json.Marshal(params.Parameters) if err != nil { - return job, controllercommon.ErrCannotMarshalParams + return job, controllererrors.ErrCannotMarshalParams } envVars = append(envVars, corev1.EnvVar{Name: "DATA", Value: string(jsonParams)}) } jsonParams, err := json.Marshal(params.Context) if err != nil { - return job, controllercommon.ErrCannotMarshalParams + return job, controllererrors.ErrCannotMarshalParams } envVars = append(envVars, corev1.EnvVar{Name: "CONTEXT", Value: string(jsonParams)}) @@ -133,7 +133,7 @@ func (r *KeptnTaskReconciler) parseFunctionTaskDefinition(definition *klcv1alpha } else { // If not, check if it has an HTTP reference. If this is also not the case and the object has no parent, something is wrong if definition.Spec.Function.HttpReference.Url == "" && !hasParent { - return params, false, fmt.Errorf(controllercommon.ErrNoConfigMapMsg, definition.Namespace, definition.Name) + return params, false, fmt.Errorf(controllererrors.ErrNoConfigMapMsg, definition.Namespace, definition.Name) } params.URL = definition.Spec.Function.HttpReference.Url } diff --git a/operator/controllers/keptntask/job_utils.go b/operator/controllers/keptntask/job_utils.go index e6422d75d4..201f72f582 100644 --- a/operator/controllers/keptntask/job_utils.go +++ b/operator/controllers/keptntask/job_utils.go @@ -7,7 +7,7 @@ import ( "github.com/imdario/mergo" klcv1alpha1 "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" batchv1 "k8s.io/api/batch/v1" "k8s.io/apimachinery/pkg/types" ctrl "sigs.k8s.io/controller-runtime" @@ -29,7 +29,7 @@ func (r *KeptnTaskReconciler) createJob(ctx context.Context, req ctrl.Request, t } task.Status.JobName = jobName - task.Status.Status = common.StatePending + task.Status.Status = apicommon.StatePending err = r.Client.Status().Update(ctx, task) if err != nil { r.Log.Error(err, "could not update KeptnTask status reference for: "+task.Name) @@ -115,9 +115,9 @@ func (r *KeptnTaskReconciler) updateJob(ctx context.Context, req ctrl.Request, t return err } if job.Status.Succeeded > 0 { - task.Status.Status = common.StateSucceeded + task.Status.Status = apicommon.StateSucceeded } else if job.Status.Failed > 0 { - task.Status.Status = common.StateFailed + task.Status.Status = apicommon.StateFailed } return nil } diff --git a/operator/controllers/keptntask/job_utils_test.go b/operator/controllers/keptntask/job_utils_test.go index ded766559c..ea5d968ffe 100644 --- a/operator/controllers/keptntask/job_utils_test.go +++ b/operator/controllers/keptntask/job_utils_test.go @@ -5,7 +5,7 @@ import ( "testing" klcv1alpha1 "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" "github.com/stretchr/testify/require" batchv1 "k8s.io/api/batch/v1" v1 "k8s.io/api/core/v1" @@ -121,7 +121,7 @@ func TestKeptnTaskReconciler_updateJob(t *testing.T) { err = r.updateJob(context.TODO(), req, task) require.Nil(t, err) - require.Equal(t, common.StateFailed, task.Status.Status) + require.Equal(t, apicommon.StateFailed, task.Status.Status) // now, set the job to succeeded job.Status.Succeeded = 1 @@ -133,7 +133,7 @@ func TestKeptnTaskReconciler_updateJob(t *testing.T) { err = r.updateJob(context.TODO(), req, task) require.Nil(t, err) - require.Equal(t, common.StateSucceeded, task.Status.Status) + require.Equal(t, apicommon.StateSucceeded, task.Status.Status) } func makeJob(name, namespace string) *batchv1.Job { diff --git a/operator/controllers/keptntaskdefinition/reconcile_function.go b/operator/controllers/keptntaskdefinition/reconcile_function.go index 158b9ef61a..f53a0f0a92 100644 --- a/operator/controllers/keptntaskdefinition/reconcile_function.go +++ b/operator/controllers/keptntaskdefinition/reconcile_function.go @@ -6,7 +6,7 @@ import ( "reflect" klcv1alpha1 "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - controllercommon "github.com/keptn/lifecycle-toolkit/operator/controllers/common" + controllererrors "github.com/keptn/lifecycle-toolkit/operator/controllers/errors" corev1 "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -41,7 +41,7 @@ func (r *KeptnTaskDefinitionReconciler) reconcileFunctionInline(ctx context.Cont if errors.IsNotFound(err) { cmIsNew = true } else { - return fmt.Errorf(controllercommon.ErrCannotGetFunctionConfigMap, err) + return fmt.Errorf(controllererrors.ErrCannotGetFunctionConfigMap, err) } } diff --git a/operator/controllers/keptnworkload/controller.go b/operator/controllers/keptnworkload/controller.go index 53c2b2784c..5b0acfdbe1 100644 --- a/operator/controllers/keptnworkload/controller.go +++ b/operator/controllers/keptnworkload/controller.go @@ -22,7 +22,7 @@ import ( "github.com/go-logr/logr" klcv1alpha1 "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - controllercommon "github.com/keptn/lifecycle-toolkit/operator/controllers/common" + controllererrors "github.com/keptn/lifecycle-toolkit/operator/controllers/errors" "go.opentelemetry.io/otel" "go.opentelemetry.io/otel/codes" "go.opentelemetry.io/otel/propagation" @@ -73,7 +73,7 @@ func (r *KeptnWorkloadReconciler) Reconcile(ctx context.Context, req ctrl.Reques return reconcile.Result{}, nil } if err != nil { - return reconcile.Result{}, fmt.Errorf(controllercommon.ErrCannotRetrieveWorkloadMsg, err) + return reconcile.Result{}, fmt.Errorf(controllererrors.ErrCannotRetrieveWorkloadMsg, err) } traceContextCarrier := propagation.MapCarrier(workload.Annotations) diff --git a/operator/controllers/keptnworkloadinstance/controller.go b/operator/controllers/keptnworkloadinstance/controller.go index 9e55c09db8..838c05ff5b 100644 --- a/operator/controllers/keptnworkloadinstance/controller.go +++ b/operator/controllers/keptnworkloadinstance/controller.go @@ -24,8 +24,9 @@ import ( "github.com/go-logr/logr" version "github.com/hashicorp/go-version" klcv1alpha1 "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" controllercommon "github.com/keptn/lifecycle-toolkit/operator/controllers/common" + controllererrors "github.com/keptn/lifecycle-toolkit/operator/controllers/errors" "go.opentelemetry.io/otel" "go.opentelemetry.io/otel/codes" "go.opentelemetry.io/otel/propagation" @@ -46,7 +47,7 @@ type KeptnWorkloadInstanceReconciler struct { Scheme *runtime.Scheme Recorder record.EventRecorder Log logr.Logger - Meters common.KeptnMeters + Meters apicommon.KeptnMeters Tracer trace.Tracer SpanHandler *controllercommon.SpanHandler } @@ -82,7 +83,7 @@ func (r *KeptnWorkloadInstanceReconciler) Reconcile(ctx context.Context, req ctr if err != nil { r.Log.Error(err, "Workload Instance not found") - return reconcile.Result{}, fmt.Errorf(controllercommon.ErrCannotRetrieveWorkloadInstancesMsg, err) + return reconcile.Result{}, fmt.Errorf(controllererrors.ErrCannotRetrieveWorkloadInstancesMsg, err) } //setup otel @@ -106,17 +107,17 @@ func (r *KeptnWorkloadInstanceReconciler) Reconcile(ctx context.Context, req ctr }(span, workloadInstance) //Wait for pre-evaluation checks of App - phase := common.PhaseAppPreEvaluation + phase := apicommon.PhaseAppPreEvaluation found, appVersion, err := r.getAppVersionForWorkloadInstance(ctx, workloadInstance) if err != nil { span.SetStatus(codes.Error, err.Error()) controllercommon.RecordEvent(r.Recorder, phase, "Warning", workloadInstance, "GetAppVersionFailed", "has failed since app could not be retrieved", workloadInstance.GetVersion()) - return reconcile.Result{Requeue: true, RequeueAfter: 10 * time.Second}, fmt.Errorf(controllercommon.ErrCannotFetchAppVersionForWorkloadInstanceMsg + err.Error()) + return reconcile.Result{Requeue: true, RequeueAfter: 10 * time.Second}, fmt.Errorf(controllererrors.ErrCannotFetchAppVersionForWorkloadInstanceMsg + err.Error()) } else if !found { span.SetStatus(codes.Error, "app could not be found") controllercommon.RecordEvent(r.Recorder, phase, "Warning", workloadInstance, "AppVersionNotFound", "has failed since app could not be found", workloadInstance.GetVersion()) - return reconcile.Result{Requeue: true, RequeueAfter: 10 * time.Second}, fmt.Errorf(controllercommon.ErrCannotFetchAppVersionForWorkloadInstanceMsg) + return reconcile.Result{Requeue: true, RequeueAfter: 10 * time.Second}, fmt.Errorf(controllererrors.ErrCannotFetchAppVersionForWorkloadInstanceMsg) } appPreEvalStatus := appVersion.Status.PreDeploymentEvaluationStatus @@ -132,7 +133,7 @@ func (r *KeptnWorkloadInstanceReconciler) Reconcile(ctx context.Context, req ctr controllercommon.RecordEvent(r.Recorder, phase, "Normal", workloadInstance, "FinishedSuccess", "Pre evaluations tasks for app have finished successfully", workloadInstance.GetVersion()) //Wait for pre-deployment checks of Workload - phase = common.PhaseWorkloadPreDeployment + phase = apicommon.PhaseWorkloadPreDeployment phaseHandler := controllercommon.PhaseHandler{ Client: r.Client, Recorder: r.Recorder, @@ -142,7 +143,7 @@ func (r *KeptnWorkloadInstanceReconciler) Reconcile(ctx context.Context, req ctr // set the App trace id if not already set if len(workloadInstance.Spec.TraceId) < 1 { - appDeploymentTraceID := appVersion.Status.PhaseTraceIDs[common.PhaseAppDeployment.ShortName] + appDeploymentTraceID := appVersion.Status.PhaseTraceIDs[apicommon.PhaseAppDeployment.ShortName] if appDeploymentTraceID != nil { workloadInstance.Spec.TraceId = appDeploymentTraceID } else { @@ -168,8 +169,8 @@ func (r *KeptnWorkloadInstanceReconciler) Reconcile(ctx context.Context, req ctr } if !workloadInstance.IsPreDeploymentSucceeded() { - reconcilePre := func(phaseCtx context.Context) (common.KeptnState, error) { - return r.reconcilePrePostDeployment(ctx, phaseCtx, workloadInstance, common.PreDeploymentCheckType) + reconcilePre := func(phaseCtx context.Context) (apicommon.KeptnState, error) { + return r.reconcilePrePostDeployment(ctx, phaseCtx, workloadInstance, apicommon.PreDeploymentCheckType) } result, err := phaseHandler.HandlePhase(ctx, ctxWorkloadTrace, r.Tracer, workloadInstance, phase, span, reconcilePre) if !result.Continue { @@ -178,10 +179,10 @@ func (r *KeptnWorkloadInstanceReconciler) Reconcile(ctx context.Context, req ctr } //Wait for pre-evaluation checks of Workload - phase = common.PhaseWorkloadPreEvaluation + phase = apicommon.PhaseWorkloadPreEvaluation if !workloadInstance.IsPreDeploymentEvaluationSucceeded() { - reconcilePreEval := func(phaseCtx context.Context) (common.KeptnState, error) { - return r.reconcilePrePostEvaluation(ctx, phaseCtx, workloadInstance, common.PreDeploymentEvaluationCheckType) + reconcilePreEval := func(phaseCtx context.Context) (apicommon.KeptnState, error) { + return r.reconcilePrePostEvaluation(ctx, phaseCtx, workloadInstance, apicommon.PreDeploymentEvaluationCheckType) } result, err := phaseHandler.HandlePhase(ctx, ctxWorkloadTrace, r.Tracer, workloadInstance, phase, span, reconcilePreEval) if !result.Continue { @@ -190,9 +191,9 @@ func (r *KeptnWorkloadInstanceReconciler) Reconcile(ctx context.Context, req ctr } //Wait for deployment of Workload - phase = common.PhaseWorkloadDeployment + phase = apicommon.PhaseWorkloadDeployment if !workloadInstance.IsDeploymentSucceeded() { - reconcileWorkloadInstance := func(phaseCtx context.Context) (common.KeptnState, error) { + reconcileWorkloadInstance := func(phaseCtx context.Context) (apicommon.KeptnState, error) { return r.reconcileDeployment(ctx, workloadInstance) } result, err := phaseHandler.HandlePhase(ctx, ctxWorkloadTrace, r.Tracer, workloadInstance, phase, span, reconcileWorkloadInstance) @@ -202,10 +203,10 @@ func (r *KeptnWorkloadInstanceReconciler) Reconcile(ctx context.Context, req ctr } //Wait for post-deployment checks of Workload - phase = common.PhaseWorkloadPostDeployment + phase = apicommon.PhaseWorkloadPostDeployment if !workloadInstance.IsPostDeploymentSucceeded() { - reconcilePostDeployment := func(phaseCtx context.Context) (common.KeptnState, error) { - return r.reconcilePrePostDeployment(ctx, phaseCtx, workloadInstance, common.PostDeploymentCheckType) + reconcilePostDeployment := func(phaseCtx context.Context) (apicommon.KeptnState, error) { + return r.reconcilePrePostDeployment(ctx, phaseCtx, workloadInstance, apicommon.PostDeploymentCheckType) } result, err := phaseHandler.HandlePhase(ctx, ctxWorkloadTrace, r.Tracer, workloadInstance, phase, span, reconcilePostDeployment) if !result.Continue { @@ -214,10 +215,10 @@ func (r *KeptnWorkloadInstanceReconciler) Reconcile(ctx context.Context, req ctr } //Wait for post-evaluation checks of Workload - phase = common.PhaseWorkloadPostEvaluation + phase = apicommon.PhaseWorkloadPostEvaluation if !workloadInstance.IsPostDeploymentEvaluationSucceeded() { - reconcilePostEval := func(phaseCtx context.Context) (common.KeptnState, error) { - return r.reconcilePrePostEvaluation(ctx, phaseCtx, workloadInstance, common.PostDeploymentEvaluationCheckType) + reconcilePostEval := func(phaseCtx context.Context) (apicommon.KeptnState, error) { + return r.reconcilePrePostEvaluation(ctx, phaseCtx, workloadInstance, apicommon.PostDeploymentEvaluationCheckType) } result, err := phaseHandler.HandlePhase(ctx, ctxWorkloadTrace, r.Tracer, workloadInstance, phase, span, reconcilePostEval) if !result.Continue { @@ -227,8 +228,8 @@ func (r *KeptnWorkloadInstanceReconciler) Reconcile(ctx context.Context, req ctr // WorkloadInstance is completed at this place if !workloadInstance.IsEndTimeSet() { - workloadInstance.Status.CurrentPhase = common.PhaseCompleted.ShortName - workloadInstance.Status.Status = common.StateSucceeded + workloadInstance.Status.CurrentPhase = apicommon.PhaseCompleted.ShortName + workloadInstance.Status.Status = apicommon.StateSucceeded workloadInstance.SetEndTime() } @@ -248,7 +249,7 @@ func (r *KeptnWorkloadInstanceReconciler) Reconcile(ctx context.Context, req ctr spanWorkloadTrace.SetStatus(codes.Ok, "Finished") spanWorkloadTrace.End() if err := r.SpanHandler.UnbindSpan(workloadInstance, ""); err != nil { - r.Log.Error(err, controllercommon.ErrCouldNotUnbindSpan, workloadInstance.Name) + r.Log.Error(err, controllererrors.ErrCouldNotUnbindSpan, workloadInstance.Name) } controllercommon.RecordEvent(r.Recorder, phase, "Normal", workloadInstance, "Finished", "is finished", workloadInstance.GetVersion()) diff --git a/operator/controllers/keptnworkloadinstance/controller_test.go b/operator/controllers/keptnworkloadinstance/controller_test.go index b7e1170168..1a752e9c39 100644 --- a/operator/controllers/keptnworkloadinstance/controller_test.go +++ b/operator/controllers/keptnworkloadinstance/controller_test.go @@ -8,10 +8,10 @@ import ( "github.com/go-logr/logr" klcv1alpha1 "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - keptncommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" controllercommon "github.com/keptn/lifecycle-toolkit/operator/controllers/common" - utils "github.com/keptn/lifecycle-toolkit/operator/controllers/common" "github.com/keptn/lifecycle-toolkit/operator/controllers/common/fake" + interfacesfake "github.com/keptn/lifecycle-toolkit/operator/controllers/interfaces/fake" "github.com/magiconair/properties/assert" "github.com/stretchr/testify/require" testrequire "github.com/stretchr/testify/require" @@ -50,7 +50,7 @@ func TestKeptnWorkloadInstanceReconciler_reconcileDeployment_FailedReplicaSet(t keptnState, err := r.reconcileDeployment(context.TODO(), workloadInstance) testrequire.Nil(t, err) - testrequire.Equal(t, keptncommon.StateProgressing, keptnState) + testrequire.Equal(t, apicommon.StateProgressing, keptnState) } func makeWorkloadInstanceWithRef(objectMeta metav1.ObjectMeta, refKind string) *klcv1alpha1.KeptnWorkloadInstance { @@ -93,7 +93,7 @@ func TestKeptnWorkloadInstanceReconciler_reconcileDeployment_FailedStatefulSet(t keptnState, err := r.reconcileDeployment(context.TODO(), workloadInstance) testrequire.Nil(t, err) - testrequire.Equal(t, keptncommon.StateProgressing, keptnState) + testrequire.Equal(t, apicommon.StateProgressing, keptnState) } func TestKeptnWorkloadInstanceReconciler_reconcileDeployment_FailedDaemonSet(t *testing.T) { @@ -116,7 +116,7 @@ func TestKeptnWorkloadInstanceReconciler_reconcileDeployment_FailedDaemonSet(t * keptnState, err := r.reconcileDeployment(context.TODO(), workloadInstance) testrequire.Nil(t, err) - testrequire.Equal(t, keptncommon.StateProgressing, keptnState) + testrequire.Equal(t, apicommon.StateProgressing, keptnState) } func TestKeptnWorkloadInstanceReconciler_reconcileDeployment_ReadyReplicaSet(t *testing.T) { @@ -140,7 +140,7 @@ func TestKeptnWorkloadInstanceReconciler_reconcileDeployment_ReadyReplicaSet(t * keptnState, err := r.reconcileDeployment(context.TODO(), workloadInstance) testrequire.Nil(t, err) - testrequire.Equal(t, keptncommon.StateSucceeded, keptnState) + testrequire.Equal(t, apicommon.StateSucceeded, keptnState) } func TestKeptnWorkloadInstanceReconciler_reconcileDeployment_ReadyStatefulSet(t *testing.T) { @@ -164,7 +164,7 @@ func TestKeptnWorkloadInstanceReconciler_reconcileDeployment_ReadyStatefulSet(t keptnState, err := r.reconcileDeployment(context.TODO(), workloadInstance) testrequire.Nil(t, err) - testrequire.Equal(t, keptncommon.StateSucceeded, keptnState) + testrequire.Equal(t, apicommon.StateSucceeded, keptnState) } func TestKeptnWorkloadInstanceReconciler_reconcileDeployment_ReadyDaemonSet(t *testing.T) { @@ -187,7 +187,7 @@ func TestKeptnWorkloadInstanceReconciler_reconcileDeployment_ReadyDaemonSet(t *t keptnState, err := r.reconcileDeployment(context.TODO(), workloadInstance) testrequire.Nil(t, err) - testrequire.Equal(t, keptncommon.StateSucceeded, keptnState) + testrequire.Equal(t, apicommon.StateSucceeded, keptnState) } func TestKeptnWorkloadInstanceReconciler_IsPodRunning(t *testing.T) { @@ -511,7 +511,7 @@ func TestKeptnWorkloadInstanceReconciler_Reconcile(t *testing.T) { Scheme *runtime.Scheme Recorder record.EventRecorder Log logr.Logger - Meters keptncommon.KeptnMeters + Meters apicommon.KeptnMeters Tracer trace.Tracer SpanHandler *controllercommon.SpanHandler } @@ -548,16 +548,16 @@ func TestKeptnWorkloadInstanceReconciler_Reconcile(t *testing.T) { }, wantErr: false, fields: fields{ - SpanHandler: &utils.SpanHandler{}, + SpanHandler: &controllercommon.SpanHandler{}, }, }, } - err := utils.AddWorkloadInstance(r.Client, "some-wi", testNamespace) + err := controllercommon.AddWorkloadInstance(r.Client, "some-wi", testNamespace) require.Nil(t, err) - err = utils.AddApp(r.Client, "some-app") + err = controllercommon.AddApp(r.Client, "some-app") require.Nil(t, err) - err = utils.AddAppVersion( + err = controllercommon.AddAppVersion( r.Client, testNamespace, "some-app", @@ -569,18 +569,18 @@ func TestKeptnWorkloadInstanceReconciler_Reconcile(t *testing.T) { }, }, klcv1alpha1.KeptnAppVersionStatus{ - PreDeploymentStatus: keptncommon.StateSucceeded, - PostDeploymentStatus: keptncommon.StateSucceeded, - PreDeploymentEvaluationStatus: keptncommon.StateSucceeded, - PostDeploymentEvaluationStatus: keptncommon.StateSucceeded, - WorkloadOverallStatus: keptncommon.StateSucceeded, + PreDeploymentStatus: apicommon.StateSucceeded, + PostDeploymentStatus: apicommon.StateSucceeded, + PreDeploymentEvaluationStatus: apicommon.StateSucceeded, + PostDeploymentEvaluationStatus: apicommon.StateSucceeded, + WorkloadOverallStatus: apicommon.StateSucceeded, WorkloadStatus: nil, - CurrentPhase: keptncommon.PhaseWorkloadPostEvaluation.ShortName, + CurrentPhase: apicommon.PhaseWorkloadPostEvaluation.ShortName, PreDeploymentTaskStatus: nil, PostDeploymentTaskStatus: nil, PreDeploymentEvaluationTaskStatus: nil, PostDeploymentEvaluationTaskStatus: nil, - Status: keptncommon.StateSucceeded, + Status: apicommon.StateSucceeded, StartTime: metav1.Time{}, EndTime: metav1.Time{}, }, @@ -606,7 +606,7 @@ func TestKeptnWorkloadInstanceReconciler_Reconcile(t *testing.T) { } } -func setupReconciler(t *testing.T) (*KeptnWorkloadInstanceReconciler, chan string, *fake.ITracerMock) { +func setupReconciler(t *testing.T) (*KeptnWorkloadInstanceReconciler, chan string, *interfacesfake.ITracerMock) { //setup logger opts := zap.Options{ Development: true, @@ -614,7 +614,7 @@ func setupReconciler(t *testing.T) (*KeptnWorkloadInstanceReconciler, chan strin ctrl.SetLogger(zap.New(zap.UseFlagOptions(&opts))) //fake a tracer - tr := &fake.ITracerMock{StartFunc: func(ctx context.Context, spanName string, opts ...trace.SpanStartOption) (context.Context, trace.Span) { + tr := &interfacesfake.ITracerMock{StartFunc: func(ctx context.Context, spanName string, opts ...trace.SpanStartOption) (context.Context, trace.Span) { return ctx, trace.SpanFromContext(ctx) }} @@ -629,7 +629,7 @@ func setupReconciler(t *testing.T) (*KeptnWorkloadInstanceReconciler, chan strin Recorder: recorder, Log: ctrl.Log.WithName("test-appController"), Tracer: tr, - Meters: utils.InitAppMeters(), + Meters: controllercommon.InitAppMeters(), SpanHandler: &controllercommon.SpanHandler{}, } return r, recorder.Events, tr diff --git a/operator/controllers/keptnworkloadinstance/reconcile_deploymentstate.go b/operator/controllers/keptnworkloadinstance/reconcile_deploymentstate.go index 4b248d0eb1..00dd0435fe 100644 --- a/operator/controllers/keptnworkloadinstance/reconcile_deploymentstate.go +++ b/operator/controllers/keptnworkloadinstance/reconcile_deploymentstate.go @@ -4,15 +4,15 @@ import ( "context" klcv1alpha1 "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" - controllercommon "github.com/keptn/lifecycle-toolkit/operator/controllers/common" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + controllererrors "github.com/keptn/lifecycle-toolkit/operator/controllers/errors" appsv1 "k8s.io/api/apps/v1" corev1 "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/types" "sigs.k8s.io/controller-runtime/pkg/client" ) -func (r *KeptnWorkloadInstanceReconciler) reconcileDeployment(ctx context.Context, workloadInstance *klcv1alpha1.KeptnWorkloadInstance) (common.KeptnState, error) { +func (r *KeptnWorkloadInstanceReconciler) reconcileDeployment(ctx context.Context, workloadInstance *klcv1alpha1.KeptnWorkloadInstance) (apicommon.KeptnState, error) { var isRunning bool var err error @@ -26,21 +26,21 @@ func (r *KeptnWorkloadInstanceReconciler) reconcileDeployment(ctx context.Contex case "DaemonSet": isRunning, err = r.isDaemonSetRunning(ctx, workloadInstance.Spec.ResourceReference, workloadInstance.Namespace) default: - isRunning, err = false, controllercommon.ErrUnsupportedWorkloadInstanceResourceReference + isRunning, err = false, controllererrors.ErrUnsupportedWorkloadInstanceResourceReference } if err != nil { - return common.StateUnknown, err + return apicommon.StateUnknown, err } if isRunning { - workloadInstance.Status.DeploymentStatus = common.StateSucceeded + workloadInstance.Status.DeploymentStatus = apicommon.StateSucceeded } else { - workloadInstance.Status.DeploymentStatus = common.StateProgressing + workloadInstance.Status.DeploymentStatus = apicommon.StateProgressing } err = r.Client.Status().Update(ctx, workloadInstance) if err != nil { - return common.StateUnknown, err + return apicommon.StateUnknown, err } return workloadInstance.Status.DeploymentStatus, nil } diff --git a/operator/controllers/keptnworkloadinstance/reconcile_prepostdeployment.go b/operator/controllers/keptnworkloadinstance/reconcile_prepostdeployment.go index 76f363039f..23c6229ff9 100644 --- a/operator/controllers/keptnworkloadinstance/reconcile_prepostdeployment.go +++ b/operator/controllers/keptnworkloadinstance/reconcile_prepostdeployment.go @@ -5,11 +5,11 @@ import ( "fmt" klcv1alpha1 "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" controllercommon "github.com/keptn/lifecycle-toolkit/operator/controllers/common" ) -func (r *KeptnWorkloadInstanceReconciler) reconcilePrePostDeployment(ctx context.Context, phaseCtx context.Context, workloadInstance *klcv1alpha1.KeptnWorkloadInstance, checkType common.CheckType) (common.KeptnState, error) { +func (r *KeptnWorkloadInstanceReconciler) reconcilePrePostDeployment(ctx context.Context, phaseCtx context.Context, workloadInstance *klcv1alpha1.KeptnWorkloadInstance, checkType apicommon.CheckType) (apicommon.KeptnState, error) { taskHandler := controllercommon.TaskHandler{ Client: r.Client, Recorder: r.Recorder, @@ -20,22 +20,22 @@ func (r *KeptnWorkloadInstanceReconciler) reconcilePrePostDeployment(ctx context } taskCreateAttributes := controllercommon.TaskCreateAttributes{ - SpanName: fmt.Sprintf(common.CreateWorkloadTaskSpanName, checkType), + SpanName: fmt.Sprintf(apicommon.CreateWorkloadTaskSpanName, checkType), CheckType: checkType, } newStatus, state, err := taskHandler.ReconcileTasks(ctx, phaseCtx, workloadInstance, taskCreateAttributes) if err != nil { - return common.StateUnknown, err + return apicommon.StateUnknown, err } - overallState := common.GetOverallState(state) + overallState := apicommon.GetOverallState(state) switch checkType { - case common.PreDeploymentCheckType: + case apicommon.PreDeploymentCheckType: workloadInstance.Status.PreDeploymentStatus = overallState workloadInstance.Status.PreDeploymentTaskStatus = newStatus - case common.PostDeploymentCheckType: + case apicommon.PostDeploymentCheckType: workloadInstance.Status.PostDeploymentStatus = overallState workloadInstance.Status.PostDeploymentTaskStatus = newStatus } @@ -43,7 +43,7 @@ func (r *KeptnWorkloadInstanceReconciler) reconcilePrePostDeployment(ctx context // Write Status Field err = r.Client.Status().Update(ctx, workloadInstance) if err != nil { - return common.StateUnknown, err + return apicommon.StateUnknown, err } return overallState, nil } diff --git a/operator/controllers/keptnworkloadinstance/reconcile_prepostevaluation.go b/operator/controllers/keptnworkloadinstance/reconcile_prepostevaluation.go index 67f88006ef..2b285479c4 100644 --- a/operator/controllers/keptnworkloadinstance/reconcile_prepostevaluation.go +++ b/operator/controllers/keptnworkloadinstance/reconcile_prepostevaluation.go @@ -5,11 +5,11 @@ import ( "fmt" klcv1alpha1 "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" controllercommon "github.com/keptn/lifecycle-toolkit/operator/controllers/common" ) -func (r *KeptnWorkloadInstanceReconciler) reconcilePrePostEvaluation(ctx context.Context, phaseCtx context.Context, workloadInstance *klcv1alpha1.KeptnWorkloadInstance, checkType common.CheckType) (common.KeptnState, error) { +func (r *KeptnWorkloadInstanceReconciler) reconcilePrePostEvaluation(ctx context.Context, phaseCtx context.Context, workloadInstance *klcv1alpha1.KeptnWorkloadInstance, checkType apicommon.CheckType) (apicommon.KeptnState, error) { evaluationHandler := controllercommon.EvaluationHandler{ Client: r.Client, Recorder: r.Recorder, @@ -20,22 +20,22 @@ func (r *KeptnWorkloadInstanceReconciler) reconcilePrePostEvaluation(ctx context } evaluationCreateAttributes := controllercommon.EvaluationCreateAttributes{ - SpanName: fmt.Sprintf(common.CreateWorkloadEvalSpanName, checkType), + SpanName: fmt.Sprintf(apicommon.CreateWorkloadEvalSpanName, checkType), CheckType: checkType, } newStatus, state, err := evaluationHandler.ReconcileEvaluations(ctx, phaseCtx, workloadInstance, evaluationCreateAttributes) if err != nil { - return common.StateUnknown, err + return apicommon.StateUnknown, err } - overallState := common.GetOverallState(state) + overallState := apicommon.GetOverallState(state) switch checkType { - case common.PreDeploymentEvaluationCheckType: + case apicommon.PreDeploymentEvaluationCheckType: workloadInstance.Status.PreDeploymentEvaluationStatus = overallState workloadInstance.Status.PreDeploymentEvaluationTaskStatus = newStatus - case common.PostDeploymentEvaluationCheckType: + case apicommon.PostDeploymentEvaluationCheckType: workloadInstance.Status.PostDeploymentEvaluationStatus = overallState workloadInstance.Status.PostDeploymentEvaluationTaskStatus = newStatus } @@ -43,7 +43,7 @@ func (r *KeptnWorkloadInstanceReconciler) reconcilePrePostEvaluation(ctx context // Write Status Field err = r.Client.Status().Update(ctx, workloadInstance) if err != nil { - return common.StateUnknown, err + return apicommon.StateUnknown, err } return overallState, nil } diff --git a/operator/test/component/appcontroller_test.go b/operator/test/component/appcontroller_test.go index 312c3cd8e1..d514cbc94b 100644 --- a/operator/test/component/appcontroller_test.go +++ b/operator/test/component/appcontroller_test.go @@ -4,8 +4,8 @@ import ( "fmt" klcv1alpha1 "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" - keptncontroller "github.com/keptn/lifecycle-toolkit/operator/controllers/common" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + "github.com/keptn/lifecycle-toolkit/operator/controllers/interfaces" "github.com/keptn/lifecycle-toolkit/operator/controllers/keptnapp" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" @@ -44,7 +44,7 @@ var _ = Describe("KeptnAppController", Ordered, func() { tracer = otelsdk.NewTracerProvider(otelsdk.WithSpanProcessor(spanRecorder)) ////setup controllers here - controllers := []keptncontroller.Controller{&keptnapp.KeptnAppReconciler{ + controllers := []interfaces.Controller{&keptnapp.KeptnAppReconciler{ Client: k8sManager.GetClient(), Scheme: k8sManager.GetScheme(), Recorder: k8sManager.GetEventRecorderFor("test-app-controller"), @@ -143,16 +143,16 @@ func assertAppSpan(instance *klcv1alpha1.KeptnApp, spanRecorder *sdktest.SpanRec }, "10s").Should(BeTrue()) Expect(spans[0].Name()).To(Equal(fmt.Sprintf("%s-%s", instance.Name, instance.Spec.Version))) - Expect(spans[0].Attributes()).To(ContainElement(common.AppName.String(instance.Name))) - Expect(spans[0].Attributes()).To(ContainElement(common.AppVersion.String(instance.Spec.Version))) + Expect(spans[0].Attributes()).To(ContainElement(apicommon.AppName.String(instance.Name))) + Expect(spans[0].Attributes()).To(ContainElement(apicommon.AppVersion.String(instance.Spec.Version))) Expect(spans[1].Name()).To(Equal("create_app_version")) - Expect(spans[1].Attributes()).To(ContainElement(common.AppName.String(instance.Name))) - Expect(spans[1].Attributes()).To(ContainElement(common.AppVersion.String(instance.Spec.Version))) + Expect(spans[1].Attributes()).To(ContainElement(apicommon.AppName.String(instance.Name))) + Expect(spans[1].Attributes()).To(ContainElement(apicommon.AppVersion.String(instance.Spec.Version))) Expect(spans[2].Name()).To(Equal("reconcile_app")) - Expect(spans[2].Attributes()).To(ContainElement(common.AppName.String(instance.Name))) - Expect(spans[2].Attributes()).To(ContainElement(common.AppVersion.String(instance.Spec.Version))) + Expect(spans[2].Attributes()).To(ContainElement(apicommon.AppName.String(instance.Name))) + Expect(spans[2].Attributes()).To(ContainElement(apicommon.AppVersion.String(instance.Spec.Version))) } func createInstanceInCluster(name string, namespace string, version string) *klcv1alpha1.KeptnApp { diff --git a/operator/test/component/common.go b/operator/test/component/common.go index b1a4addef1..faac0936ec 100644 --- a/operator/test/component/common.go +++ b/operator/test/component/common.go @@ -1,13 +1,13 @@ package component import ( - "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" "go.opentelemetry.io/otel/metric/instrument" "go.opentelemetry.io/otel/metric/unit" "go.opentelemetry.io/otel/sdk/metric" ) -func initKeptnMeters() common.KeptnMeters { +func initKeptnMeters() apicommon.KeptnMeters { provider := metric.NewMeterProvider() meter := provider.Meter("keptn/task") deploymentCount, _ := meter.SyncInt64().Counter("keptn.deployment.count", instrument.WithDescription("a simple counter for Keptn Deployments")) @@ -19,7 +19,7 @@ func initKeptnMeters() common.KeptnMeters { evaluationCount, _ := meter.SyncInt64().Counter("keptn.evaluation.count", instrument.WithDescription("a simple counter for Keptn Evaluations")) evaluationDuration, _ := meter.SyncFloat64().Histogram("keptn.evaluation.duration", instrument.WithDescription("a histogram of duration for Keptn Evaluations"), instrument.WithUnit(unit.Unit("s"))) - meters := common.KeptnMeters{ + meters := apicommon.KeptnMeters{ TaskCount: taskCount, TaskDuration: taskDuration, DeploymentCount: deploymentCount, diff --git a/operator/test/component/load_test.go b/operator/test/component/load_test.go index d3cc78f7d7..64ff4768f1 100644 --- a/operator/test/component/load_test.go +++ b/operator/test/component/load_test.go @@ -8,7 +8,7 @@ import ( "time" klcv1alpha1 "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - keptncontroller "github.com/keptn/lifecycle-toolkit/operator/controllers/common" + "github.com/keptn/lifecycle-toolkit/operator/controllers/interfaces" "github.com/keptn/lifecycle-toolkit/operator/controllers/keptnapp" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" @@ -42,7 +42,7 @@ var _ = Describe("[Feature:Performance] Load KeptnAppController", Ordered, func( spanRecorder = sdktest.NewSpanRecorder() tracer = otelsdk.NewTracerProvider(otelsdk.WithSpanProcessor(spanRecorder)) - controllers := []keptncontroller.Controller{&keptnapp.KeptnAppReconciler{ + controllers := []interfaces.Controller{&keptnapp.KeptnAppReconciler{ Client: k8sManager.GetClient(), Scheme: k8sManager.GetScheme(), Recorder: k8sManager.GetEventRecorderFor("load-app-controller"), diff --git a/operator/test/component/suite_test.go b/operator/test/component/suite_test.go index bc151260cf..4c3bd800b7 100644 --- a/operator/test/component/suite_test.go +++ b/operator/test/component/suite_test.go @@ -19,8 +19,14 @@ package component import ( "context" "fmt" + "os" + "path/filepath" + "strings" + "testing" + "time" + klcv1alpha1 "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - keptncontroller "github.com/keptn/lifecycle-toolkit/operator/controllers/common" + "github.com/keptn/lifecycle-toolkit/operator/controllers/interfaces" . "github.com/onsi/ginkgo/v2" "github.com/onsi/ginkgo/v2/types" . "github.com/onsi/gomega" @@ -30,16 +36,11 @@ import ( apierrors "k8s.io/apimachinery/pkg/api/errors" "k8s.io/client-go/kubernetes/scheme" "k8s.io/client-go/rest" - "os" - "path/filepath" ctrl "sigs.k8s.io/controller-runtime" "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/envtest" logf "sigs.k8s.io/controller-runtime/pkg/log" "sigs.k8s.io/controller-runtime/pkg/log/zap" - "strings" - "testing" - "time" //+kubebuilder:scaffold:imports ) @@ -137,7 +138,7 @@ func ignoreAlreadyExists(err error) error { return err } -func setupManager(rec []keptncontroller.Controller) { +func setupManager(rec []interfaces.Controller) { for _, r := range rec { err := r.SetupWithManager(k8sManager) Expect(err).To(BeNil()) diff --git a/operator/test/component/taskcontroller_test.go b/operator/test/component/taskcontroller_test.go index 4e9e2467de..e1cb7a062d 100644 --- a/operator/test/component/taskcontroller_test.go +++ b/operator/test/component/taskcontroller_test.go @@ -5,8 +5,8 @@ import ( "os" klcv1alpha1 "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - keptncommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" - keptncontroller "github.com/keptn/lifecycle-toolkit/operator/controllers/common" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + "github.com/keptn/lifecycle-toolkit/operator/controllers/interfaces" "github.com/keptn/lifecycle-toolkit/operator/controllers/keptntask" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" @@ -41,7 +41,7 @@ var _ = Describe("KeptnTaskController", Ordered, func() { tracer = otelsdk.NewTracerProvider(otelsdk.WithSpanProcessor(spanRecorder)) ////setup controllers here - controllers := []keptncontroller.Controller{&keptntask.KeptnTaskReconciler{ + controllers := []interfaces.Controller{&keptntask.KeptnTaskReconciler{ Client: k8sManager.GetClient(), Scheme: k8sManager.GetScheme(), Recorder: k8sManager.GetEventRecorderFor("test-task-controller"), @@ -102,7 +102,7 @@ var _ = Describe("KeptnTaskController", Ordered, func() { Name: task.Name, }, task) g.Expect(err).To(BeNil()) - g.Expect(task.Status.Status).To(Equal(keptncommon.StateFailed)) + g.Expect(task.Status.Status).To(Equal(apicommon.StateFailed)) }, "10s").Should(Succeed()) }) AfterEach(func() { diff --git a/operator/test/component/workloadinstancecontroller_test.go b/operator/test/component/workloadinstancecontroller_test.go index 3c850fbd11..babebce4f7 100644 --- a/operator/test/component/workloadinstancecontroller_test.go +++ b/operator/test/component/workloadinstancecontroller_test.go @@ -5,8 +5,9 @@ import ( "time" klcv1alpha1 "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" - keptncontroller "github.com/keptn/lifecycle-toolkit/operator/controllers/common" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + controllercommon "github.com/keptn/lifecycle-toolkit/operator/controllers/common" + "github.com/keptn/lifecycle-toolkit/operator/controllers/interfaces" "github.com/keptn/lifecycle-toolkit/operator/controllers/keptnworkloadinstance" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" @@ -64,13 +65,13 @@ var _ = Describe("KeptnWorkloadInstanceController", Ordered, func() { tracer = otelsdk.NewTracerProvider(otelsdk.WithSpanProcessor(spanRecorder)) ////setup controllers here - controllers := []keptncontroller.Controller{&keptnworkloadinstance.KeptnWorkloadInstanceReconciler{ + controllers := []interfaces.Controller{&keptnworkloadinstance.KeptnWorkloadInstanceReconciler{ Client: k8sManager.GetClient(), Scheme: k8sManager.GetScheme(), Recorder: k8sManager.GetEventRecorderFor("test-app-controller"), Log: GinkgoLogr, Meters: initKeptnMeters(), - SpanHandler: &keptncontroller.SpanHandler{}, + SpanHandler: &controllercommon.SpanHandler{}, Tracer: tracer.Tracer("test-app-tracer"), }} setupManager(controllers) // we can register multiple time the same controller @@ -162,7 +163,7 @@ var _ = Describe("KeptnWorkloadInstanceController", Ordered, func() { Expect(err).To(BeNil()) By("Setting the App PreDeploymentEvaluation Status to 'Succeeded'") - appVersion.Status.PreDeploymentEvaluationStatus = common.StateSucceeded + appVersion.Status.PreDeploymentEvaluationStatus = apicommon.StateSucceeded err = k8sClient.Status().Update(ctx, appVersion) Expect(err).To(BeNil()) @@ -212,7 +213,7 @@ var _ = Describe("KeptnWorkloadInstanceController", Ordered, func() { wi := &klcv1alpha1.KeptnWorkloadInstance{} err := k8sClient.Get(ctx, wiNameObj, wi) g.Expect(err).To(BeNil()) - g.Expect(wi.Status.DeploymentStatus).To(Equal(common.StateSucceeded)) + g.Expect(wi.Status.DeploymentStatus).To(Equal(apicommon.StateSucceeded)) }, "20s").Should(Succeed()) }) It("should detect that the referenced DaemonSet is progressing", func() { @@ -240,7 +241,7 @@ var _ = Describe("KeptnWorkloadInstanceController", Ordered, func() { Expect(err).To(BeNil()) By("Setting the App PreDeploymentEvaluation Status to 'Succeeded'") - appVersion.Status.PreDeploymentEvaluationStatus = common.StateSucceeded + appVersion.Status.PreDeploymentEvaluationStatus = apicommon.StateSucceeded err = k8sClient.Status().Update(ctx, appVersion) Expect(err).To(BeNil()) @@ -289,7 +290,7 @@ var _ = Describe("KeptnWorkloadInstanceController", Ordered, func() { wi := &klcv1alpha1.KeptnWorkloadInstance{} err := k8sClient.Get(ctx, wiNameObj, wi) g.Expect(err).To(BeNil()) - g.Expect(wi.Status.DeploymentStatus).To(Equal(common.StateSucceeded)) + g.Expect(wi.Status.DeploymentStatus).To(Equal(apicommon.StateSucceeded)) }, "20s").Should(Succeed()) }) It("should be cancelled when pre-eval checks failed", func() { @@ -302,7 +303,7 @@ var _ = Describe("KeptnWorkloadInstanceController", Ordered, func() { EvaluationDefinition: "eval-def", Workload: "test-app-wname", WorkloadVersion: "2.0", - Type: common.PreDeploymentEvaluationCheckType, + Type: apicommon.PreDeploymentEvaluationCheckType, Retries: 10, }, } @@ -316,11 +317,11 @@ var _ = Describe("KeptnWorkloadInstanceController", Ordered, func() { Expect(err).To(BeNil()) evaluation.Status = klcv1alpha1.KeptnEvaluationStatus{ - OverallStatus: common.StateFailed, + OverallStatus: apicommon.StateFailed, RetryCount: 10, EvaluationStatus: map[string]klcv1alpha1.EvaluationStatusItem{ "something": { - Status: common.StateFailed, + Status: apicommon.StateFailed, Value: "10", }, }, @@ -350,17 +351,17 @@ var _ = Describe("KeptnWorkloadInstanceController", Ordered, func() { Expect(err).To(BeNil()) wi.Status = klcv1alpha1.KeptnWorkloadInstanceStatus{ - PreDeploymentStatus: common.StateSucceeded, - PreDeploymentEvaluationStatus: common.StateProgressing, - DeploymentStatus: common.StatePending, - PostDeploymentStatus: common.StatePending, - PostDeploymentEvaluationStatus: common.StatePending, - CurrentPhase: common.PhaseWorkloadPreEvaluation.ShortName, - Status: common.StateProgressing, + PreDeploymentStatus: apicommon.StateSucceeded, + PreDeploymentEvaluationStatus: apicommon.StateProgressing, + DeploymentStatus: apicommon.StatePending, + PostDeploymentStatus: apicommon.StatePending, + PostDeploymentEvaluationStatus: apicommon.StatePending, + CurrentPhase: apicommon.PhaseWorkloadPreEvaluation.ShortName, + Status: apicommon.StateProgressing, PreDeploymentEvaluationTaskStatus: []klcv1alpha1.EvaluationStatus{ { EvaluationName: "pre-eval-eval-def", - Status: common.StateProgressing, + Status: apicommon.StateProgressing, EvaluationDefinitionName: "eval-def", }, }, @@ -379,12 +380,12 @@ var _ = Describe("KeptnWorkloadInstanceController", Ordered, func() { err := k8sClient.Get(ctx, wiNameObj, wi) g.Expect(err).To(BeNil()) g.Expect(wi).To(Not(BeNil())) - g.Expect(wi.Status.PreDeploymentStatus).To(BeEquivalentTo(common.StateSucceeded)) - g.Expect(wi.Status.PreDeploymentEvaluationStatus).To(BeEquivalentTo(common.StateFailed)) - g.Expect(wi.Status.DeploymentStatus).To(BeEquivalentTo(common.StateCancelled)) - g.Expect(wi.Status.PostDeploymentStatus).To(BeEquivalentTo(common.StateCancelled)) - g.Expect(wi.Status.PostDeploymentEvaluationStatus).To(BeEquivalentTo(common.StateCancelled)) - g.Expect(wi.Status.Status).To(BeEquivalentTo(common.StateFailed)) + g.Expect(wi.Status.PreDeploymentStatus).To(BeEquivalentTo(apicommon.StateSucceeded)) + g.Expect(wi.Status.PreDeploymentEvaluationStatus).To(BeEquivalentTo(apicommon.StateFailed)) + g.Expect(wi.Status.DeploymentStatus).To(BeEquivalentTo(apicommon.StateCancelled)) + g.Expect(wi.Status.PostDeploymentStatus).To(BeEquivalentTo(apicommon.StateCancelled)) + g.Expect(wi.Status.PostDeploymentEvaluationStatus).To(BeEquivalentTo(apicommon.StateCancelled)) + g.Expect(wi.Status.Status).To(BeEquivalentTo(apicommon.StateFailed)) }, "30s").Should(Succeed()) }) AfterEach(func() { @@ -424,7 +425,7 @@ func createAppVersionInCluster(name string, namespace string, version string) *k By("Invoking Reconciling for Create") Expect(ignoreAlreadyExists(k8sClient.Create(ctx, instance))).Should(Succeed()) - instance.Status.PreDeploymentEvaluationStatus = common.StateSucceeded + instance.Status.PreDeploymentEvaluationStatus = apicommon.StateSucceeded _ = k8sClient.Status().Update(ctx, instance) return instance } diff --git a/operator/webhooks/pod_mutating_webhook.go b/operator/webhooks/pod_mutating_webhook.go index a404e0c384..d5d00dce64 100644 --- a/operator/webhooks/pod_mutating_webhook.go +++ b/operator/webhooks/pod_mutating_webhook.go @@ -11,7 +11,7 @@ import ( "github.com/go-logr/logr" klcv1alpha1 "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1" - "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/semconv" "go.opentelemetry.io/otel" "go.opentelemetry.io/otel/codes" @@ -72,7 +72,7 @@ func (a *PodMutatingWebhook) Handle(ctx context.Context, req admission.Request) return admission.Errored(http.StatusInternalServerError, err) } - if namespace.GetAnnotations()[common.NamespaceEnabledAnnotation] != "enabled" { + if namespace.GetAnnotations()[apicommon.NamespaceEnabledAnnotation] != "enabled" { logger.Info("namespace is not enabled for lifecycle controller", "namespace", req.Namespace) return admission.Allowed("namespace is not enabled for lifecycle controller") } @@ -143,10 +143,10 @@ func (a *PodMutatingWebhook) InjectDecoder(d *admission.Decoder) error { } func (a *PodMutatingWebhook) isPodAnnotated(pod *corev1.Pod) (bool, error) { - workload, gotWorkloadAnnotation := getLabelOrAnnotation(&pod.ObjectMeta, common.WorkloadAnnotation, common.K8sRecommendedWorkloadAnnotations) - version, gotVersionAnnotation := getLabelOrAnnotation(&pod.ObjectMeta, common.VersionAnnotation, common.K8sRecommendedVersionAnnotations) + workload, gotWorkloadAnnotation := getLabelOrAnnotation(&pod.ObjectMeta, apicommon.WorkloadAnnotation, apicommon.K8sRecommendedWorkloadAnnotations) + version, gotVersionAnnotation := getLabelOrAnnotation(&pod.ObjectMeta, apicommon.VersionAnnotation, apicommon.K8sRecommendedVersionAnnotations) - if len(workload) > common.MaxWorkloadNameLength || len(version) > common.MaxVersionLength { + if len(workload) > apicommon.MaxWorkloadNameLength || len(version) > apicommon.MaxVersionLength { return false, ErrTooLongAnnotations } @@ -155,7 +155,7 @@ func (a *PodMutatingWebhook) isPodAnnotated(pod *corev1.Pod) (bool, error) { if len(pod.Annotations) == 0 { pod.Annotations = make(map[string]string) } - pod.Annotations[common.VersionAnnotation] = a.calculateVersion(pod) + pod.Annotations[apicommon.VersionAnnotation] = a.calculateVersion(pod) } return true, nil } @@ -209,15 +209,15 @@ func (a *PodMutatingWebhook) copyResourceLabelsIfPresent(sourceResource *metav1. var workloadName, appName, version, preDeploymentChecks, postDeploymentChecks, preEvaluationChecks, postEvaluationChecks string var gotWorkloadName, gotVersion bool - workloadName, gotWorkloadName = getLabelOrAnnotation(sourceResource, common.WorkloadAnnotation, common.K8sRecommendedWorkloadAnnotations) - appName, _ = getLabelOrAnnotation(sourceResource, common.AppAnnotation, common.K8sRecommendedAppAnnotations) - version, gotVersion = getLabelOrAnnotation(sourceResource, common.VersionAnnotation, common.K8sRecommendedVersionAnnotations) - preDeploymentChecks, _ = getLabelOrAnnotation(sourceResource, common.PreDeploymentTaskAnnotation, "") - postDeploymentChecks, _ = getLabelOrAnnotation(sourceResource, common.PostDeploymentTaskAnnotation, "") - preEvaluationChecks, _ = getLabelOrAnnotation(sourceResource, common.PreDeploymentEvaluationAnnotation, "") - postEvaluationChecks, _ = getLabelOrAnnotation(sourceResource, common.PostDeploymentEvaluationAnnotation, "") + workloadName, gotWorkloadName = getLabelOrAnnotation(sourceResource, apicommon.WorkloadAnnotation, apicommon.K8sRecommendedWorkloadAnnotations) + appName, _ = getLabelOrAnnotation(sourceResource, apicommon.AppAnnotation, apicommon.K8sRecommendedAppAnnotations) + version, gotVersion = getLabelOrAnnotation(sourceResource, apicommon.VersionAnnotation, apicommon.K8sRecommendedVersionAnnotations) + preDeploymentChecks, _ = getLabelOrAnnotation(sourceResource, apicommon.PreDeploymentTaskAnnotation, "") + postDeploymentChecks, _ = getLabelOrAnnotation(sourceResource, apicommon.PostDeploymentTaskAnnotation, "") + preEvaluationChecks, _ = getLabelOrAnnotation(sourceResource, apicommon.PreDeploymentEvaluationAnnotation, "") + postEvaluationChecks, _ = getLabelOrAnnotation(sourceResource, apicommon.PostDeploymentEvaluationAnnotation, "") - if len(workloadName) > common.MaxWorkloadNameLength || len(version) > common.MaxVersionLength { + if len(workloadName) > apicommon.MaxWorkloadNameLength || len(version) > apicommon.MaxVersionLength { return false, ErrTooLongAnnotations } @@ -226,19 +226,19 @@ func (a *PodMutatingWebhook) copyResourceLabelsIfPresent(sourceResource *metav1. } if gotWorkloadName { - setMapKey(targetPod.Annotations, common.WorkloadAnnotation, workloadName) + setMapKey(targetPod.Annotations, apicommon.WorkloadAnnotation, workloadName) if !gotVersion { - setMapKey(targetPod.Annotations, common.VersionAnnotation, a.calculateVersion(targetPod)) + setMapKey(targetPod.Annotations, apicommon.VersionAnnotation, a.calculateVersion(targetPod)) } else { - setMapKey(targetPod.Annotations, common.VersionAnnotation, version) + setMapKey(targetPod.Annotations, apicommon.VersionAnnotation, version) } - setMapKey(targetPod.Annotations, common.AppAnnotation, appName) - setMapKey(targetPod.Annotations, common.PreDeploymentTaskAnnotation, preDeploymentChecks) - setMapKey(targetPod.Annotations, common.PostDeploymentTaskAnnotation, postDeploymentChecks) - setMapKey(targetPod.Annotations, common.PreDeploymentEvaluationAnnotation, preEvaluationChecks) - setMapKey(targetPod.Annotations, common.PostDeploymentEvaluationAnnotation, postEvaluationChecks) + setMapKey(targetPod.Annotations, apicommon.AppAnnotation, appName) + setMapKey(targetPod.Annotations, apicommon.PreDeploymentTaskAnnotation, preDeploymentChecks) + setMapKey(targetPod.Annotations, apicommon.PostDeploymentTaskAnnotation, postDeploymentChecks) + setMapKey(targetPod.Annotations, apicommon.PreDeploymentEvaluationAnnotation, preEvaluationChecks) + setMapKey(targetPod.Annotations, apicommon.PostDeploymentEvaluationAnnotation, postEvaluationChecks) return true, nil } @@ -246,10 +246,10 @@ func (a *PodMutatingWebhook) copyResourceLabelsIfPresent(sourceResource *metav1. } func (a *PodMutatingWebhook) isAppAnnotationPresent(pod *corev1.Pod) (bool, error) { - app, gotAppAnnotation := getLabelOrAnnotation(&pod.ObjectMeta, common.AppAnnotation, common.K8sRecommendedAppAnnotations) + app, gotAppAnnotation := getLabelOrAnnotation(&pod.ObjectMeta, apicommon.AppAnnotation, apicommon.K8sRecommendedAppAnnotations) if gotAppAnnotation { - if len(app) > common.MaxAppNameLength { + if len(app) > apicommon.MaxAppNameLength { return false, ErrTooLongAnnotations } return true, nil @@ -258,7 +258,7 @@ func (a *PodMutatingWebhook) isAppAnnotationPresent(pod *corev1.Pod) (bool, erro if len(pod.Annotations) == 0 { pod.Annotations = make(map[string]string) } - pod.Annotations[common.AppAnnotation], _ = getLabelOrAnnotation(&pod.ObjectMeta, common.WorkloadAnnotation, common.K8sRecommendedWorkloadAnnotations) + pod.Annotations[apicommon.AppAnnotation], _ = getLabelOrAnnotation(&pod.ObjectMeta, apicommon.WorkloadAnnotation, apicommon.K8sRecommendedWorkloadAnnotations) return false, nil } @@ -393,27 +393,27 @@ func (a *PodMutatingWebhook) handleApp(ctx context.Context, logger logr.Logger, } func (a *PodMutatingWebhook) generateWorkload(ctx context.Context, pod *corev1.Pod, namespace string) *klcv1alpha1.KeptnWorkload { - version, _ := getLabelOrAnnotation(&pod.ObjectMeta, common.VersionAnnotation, common.K8sRecommendedVersionAnnotations) - applicationName, _ := getLabelOrAnnotation(&pod.ObjectMeta, common.AppAnnotation, common.K8sRecommendedAppAnnotations) + version, _ := getLabelOrAnnotation(&pod.ObjectMeta, apicommon.VersionAnnotation, apicommon.K8sRecommendedVersionAnnotations) + applicationName, _ := getLabelOrAnnotation(&pod.ObjectMeta, apicommon.AppAnnotation, apicommon.K8sRecommendedAppAnnotations) var preDeploymentTasks []string var postDeploymentTasks []string var preDeploymentEvaluation []string var postDeploymentEvaluation []string - if annotations, found := getLabelOrAnnotation(&pod.ObjectMeta, common.PreDeploymentTaskAnnotation, ""); found { + if annotations, found := getLabelOrAnnotation(&pod.ObjectMeta, apicommon.PreDeploymentTaskAnnotation, ""); found { preDeploymentTasks = strings.Split(annotations, ",") } - if annotations, found := getLabelOrAnnotation(&pod.ObjectMeta, common.PostDeploymentTaskAnnotation, ""); found { + if annotations, found := getLabelOrAnnotation(&pod.ObjectMeta, apicommon.PostDeploymentTaskAnnotation, ""); found { postDeploymentTasks = strings.Split(annotations, ",") } - if annotations, found := getLabelOrAnnotation(&pod.ObjectMeta, common.PreDeploymentEvaluationAnnotation, ""); found { + if annotations, found := getLabelOrAnnotation(&pod.ObjectMeta, apicommon.PreDeploymentEvaluationAnnotation, ""); found { preDeploymentEvaluation = strings.Split(annotations, ",") } - if annotations, found := getLabelOrAnnotation(&pod.ObjectMeta, common.PostDeploymentEvaluationAnnotation, ""); found { + if annotations, found := getLabelOrAnnotation(&pod.ObjectMeta, apicommon.PostDeploymentEvaluationAnnotation, ""); found { postDeploymentEvaluation = strings.Split(annotations, ",") } @@ -443,7 +443,7 @@ func (a *PodMutatingWebhook) generateWorkload(ctx context.Context, pod *corev1.P } func (a *PodMutatingWebhook) generateApp(ctx context.Context, pod *corev1.Pod, namespace string) *klcv1alpha1.KeptnApp { - version, _ := getLabelOrAnnotation(&pod.ObjectMeta, common.VersionAnnotation, common.K8sRecommendedVersionAnnotations) + version, _ := getLabelOrAnnotation(&pod.ObjectMeta, apicommon.VersionAnnotation, apicommon.K8sRecommendedVersionAnnotations) appName := a.getAppName(pod) // create TraceContext @@ -474,13 +474,13 @@ func (a *PodMutatingWebhook) generateApp(ctx context.Context, pod *corev1.Pod, n } func (a *PodMutatingWebhook) getWorkloadName(pod *corev1.Pod) string { - workloadName, _ := getLabelOrAnnotation(&pod.ObjectMeta, common.WorkloadAnnotation, common.K8sRecommendedWorkloadAnnotations) - applicationName, _ := getLabelOrAnnotation(&pod.ObjectMeta, common.AppAnnotation, common.K8sRecommendedAppAnnotations) + workloadName, _ := getLabelOrAnnotation(&pod.ObjectMeta, apicommon.WorkloadAnnotation, apicommon.K8sRecommendedWorkloadAnnotations) + applicationName, _ := getLabelOrAnnotation(&pod.ObjectMeta, apicommon.AppAnnotation, apicommon.K8sRecommendedAppAnnotations) return strings.ToLower(applicationName + "-" + workloadName) } func (a *PodMutatingWebhook) getAppName(pod *corev1.Pod) string { - applicationName, _ := getLabelOrAnnotation(&pod.ObjectMeta, common.AppAnnotation, common.K8sRecommendedAppAnnotations) + applicationName, _ := getLabelOrAnnotation(&pod.ObjectMeta, apicommon.AppAnnotation, apicommon.K8sRecommendedAppAnnotations) return strings.ToLower(applicationName) } diff --git a/operator/webhooks/pod_mutating_webhook_test.go b/operator/webhooks/pod_mutating_webhook_test.go index 5ba78c9f39..1e7d1dd197 100644 --- a/operator/webhooks/pod_mutating_webhook_test.go +++ b/operator/webhooks/pod_mutating_webhook_test.go @@ -7,7 +7,7 @@ import ( "github.com/go-logr/logr" "github.com/go-logr/logr/testr" - "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" + apicommon "github.com/keptn/lifecycle-toolkit/operator/api/v1alpha1/common" "github.com/keptn/lifecycle-toolkit/operator/controllers/common/fake" "github.com/stretchr/testify/require" "go.opentelemetry.io/otel/trace" @@ -117,7 +117,7 @@ func TestPodMutatingWebhook_getAppName(t *testing.T) { pod: &corev1.Pod{ ObjectMeta: metav1.ObjectMeta{ Annotations: map[string]string{ - common.AppAnnotation: "SOME-APP-NAME", + apicommon.AppAnnotation: "SOME-APP-NAME", }, }, }, @@ -130,7 +130,7 @@ func TestPodMutatingWebhook_getAppName(t *testing.T) { pod: &corev1.Pod{ ObjectMeta: metav1.ObjectMeta{ Labels: map[string]string{ - common.AppAnnotation: "SOME-APP-NAME", + apicommon.AppAnnotation: "SOME-APP-NAME", }, }, }, @@ -143,10 +143,10 @@ func TestPodMutatingWebhook_getAppName(t *testing.T) { pod: &corev1.Pod{ ObjectMeta: metav1.ObjectMeta{ Annotations: map[string]string{ - common.AppAnnotation: "SOME-APP-NAME-ANNOTATION", + apicommon.AppAnnotation: "SOME-APP-NAME-ANNOTATION", }, Labels: map[string]string{ - common.AppAnnotation: "SOME-APP-NAME-LABEL", + apicommon.AppAnnotation: "SOME-APP-NAME-LABEL", }, }, }, @@ -193,8 +193,8 @@ func TestPodMutatingWebhook_getWorkloadName(t *testing.T) { pod: &corev1.Pod{ ObjectMeta: metav1.ObjectMeta{ Annotations: map[string]string{ - common.AppAnnotation: "SOME-APP-NAME", - common.WorkloadAnnotation: "SOME-WORKLOAD-NAME", + apicommon.AppAnnotation: "SOME-APP-NAME", + apicommon.WorkloadAnnotation: "SOME-WORKLOAD-NAME", }, }, }, @@ -207,8 +207,8 @@ func TestPodMutatingWebhook_getWorkloadName(t *testing.T) { pod: &corev1.Pod{ ObjectMeta: metav1.ObjectMeta{ Labels: map[string]string{ - common.AppAnnotation: "SOME-APP-NAME", - common.WorkloadAnnotation: "SOME-WORKLOAD-NAME", + apicommon.AppAnnotation: "SOME-APP-NAME", + apicommon.WorkloadAnnotation: "SOME-WORKLOAD-NAME", }, }, }, @@ -221,12 +221,12 @@ func TestPodMutatingWebhook_getWorkloadName(t *testing.T) { pod: &corev1.Pod{ ObjectMeta: metav1.ObjectMeta{ Annotations: map[string]string{ - common.AppAnnotation: "SOME-APP-NAME-ANNOTATION", - common.WorkloadAnnotation: "SOME-WORKLOAD-NAME-ANNOTATION", + apicommon.AppAnnotation: "SOME-APP-NAME-ANNOTATION", + apicommon.WorkloadAnnotation: "SOME-WORKLOAD-NAME-ANNOTATION", }, Labels: map[string]string{ - common.AppAnnotation: "SOME-APP-NAME-LABEL", - common.WorkloadAnnotation: "SOME-WORKLOAD-NAME-LABEL", + apicommon.AppAnnotation: "SOME-APP-NAME-LABEL", + apicommon.WorkloadAnnotation: "SOME-WORKLOAD-NAME-LABEL", }, }, }, @@ -267,11 +267,11 @@ func Test_getLabelOrAnnotation(t *testing.T) { args: args{ resource: &metav1.ObjectMeta{ Annotations: map[string]string{ - common.AppAnnotation: "some-app-name", + apicommon.AppAnnotation: "some-app-name", }, }, - primaryAnnotation: common.AppAnnotation, - secondaryAnnotation: common.K8sRecommendedAppAnnotations, + primaryAnnotation: apicommon.AppAnnotation, + secondaryAnnotation: apicommon.K8sRecommendedAppAnnotations, }, want: "some-app-name", want1: true, @@ -281,11 +281,11 @@ func Test_getLabelOrAnnotation(t *testing.T) { args: args{ resource: &metav1.ObjectMeta{ Annotations: map[string]string{ - common.K8sRecommendedAppAnnotations: "some-app-name", + apicommon.K8sRecommendedAppAnnotations: "some-app-name", }, }, - primaryAnnotation: common.AppAnnotation, - secondaryAnnotation: common.K8sRecommendedAppAnnotations, + primaryAnnotation: apicommon.AppAnnotation, + secondaryAnnotation: apicommon.K8sRecommendedAppAnnotations, }, want: "some-app-name", want1: true, @@ -295,11 +295,11 @@ func Test_getLabelOrAnnotation(t *testing.T) { args: args{ resource: &metav1.ObjectMeta{ Labels: map[string]string{ - common.AppAnnotation: "some-app-name", + apicommon.AppAnnotation: "some-app-name", }, }, - primaryAnnotation: common.AppAnnotation, - secondaryAnnotation: common.K8sRecommendedAppAnnotations, + primaryAnnotation: apicommon.AppAnnotation, + secondaryAnnotation: apicommon.K8sRecommendedAppAnnotations, }, want: "some-app-name", want1: true, @@ -309,11 +309,11 @@ func Test_getLabelOrAnnotation(t *testing.T) { args: args{ resource: &metav1.ObjectMeta{ Labels: map[string]string{ - common.K8sRecommendedAppAnnotations: "some-app-name", + apicommon.K8sRecommendedAppAnnotations: "some-app-name", }, }, - primaryAnnotation: common.AppAnnotation, - secondaryAnnotation: common.K8sRecommendedAppAnnotations, + primaryAnnotation: apicommon.AppAnnotation, + secondaryAnnotation: apicommon.K8sRecommendedAppAnnotations, }, want: "some-app-name", want1: true, @@ -326,8 +326,8 @@ func Test_getLabelOrAnnotation(t *testing.T) { "some-other-annotation": "some-app-name", }, }, - primaryAnnotation: common.AppAnnotation, - secondaryAnnotation: common.K8sRecommendedAppAnnotations, + primaryAnnotation: apicommon.AppAnnotation, + secondaryAnnotation: apicommon.K8sRecommendedAppAnnotations, }, want: "", want1: false, @@ -340,7 +340,7 @@ func Test_getLabelOrAnnotation(t *testing.T) { "some-other-annotation": "some-app-name", }, }, - primaryAnnotation: common.AppAnnotation, + primaryAnnotation: apicommon.AppAnnotation, secondaryAnnotation: "", }, want: "", @@ -385,8 +385,8 @@ func TestPodMutatingWebhook_isPodAnnotated(t *testing.T) { pod: &corev1.Pod{ ObjectMeta: metav1.ObjectMeta{ Annotations: map[string]string{ - common.AppAnnotation: "SOME-APP-NAME-ANNOTATION", - common.WorkloadAnnotation: "workload-name-that-is-too-loooooooooooooooooooooooooooooooooooooooooooooooooong", + apicommon.AppAnnotation: "SOME-APP-NAME-ANNOTATION", + apicommon.WorkloadAnnotation: "workload-name-that-is-too-loooooooooooooooooooooooooooooooooooooooooooooooooong", }, }, }, @@ -400,7 +400,7 @@ func TestPodMutatingWebhook_isPodAnnotated(t *testing.T) { pod: &corev1.Pod{ ObjectMeta: metav1.ObjectMeta{ Annotations: map[string]string{ - common.WorkloadAnnotation: "some-workload-name", + apicommon.WorkloadAnnotation: "some-workload-name", }, }, }, @@ -421,7 +421,7 @@ func TestPodMutatingWebhook_isPodAnnotated(t *testing.T) { }, ObjectMeta: metav1.ObjectMeta{ Labels: map[string]string{ - common.WorkloadAnnotation: "some-workload-name", + apicommon.WorkloadAnnotation: "some-workload-name", }, }, }, @@ -438,10 +438,10 @@ func TestPodMutatingWebhook_isPodAnnotated(t *testing.T) { }, ObjectMeta: metav1.ObjectMeta{ Labels: map[string]string{ - common.WorkloadAnnotation: "some-workload-name", + apicommon.WorkloadAnnotation: "some-workload-name", }, Annotations: map[string]string{ - common.VersionAnnotation: "v1", + apicommon.VersionAnnotation: "v1", }, }, }, @@ -764,13 +764,13 @@ func TestPodMutatingWebhook_copyResourceLabelsIfPresent(t *testing.T) { sourceResource: &metav1.ObjectMeta{ Name: "testSourceObject", Annotations: map[string]string{ - common.WorkloadAnnotation: "some-workload-name", - common.AppAnnotation: "some-app-name", - common.VersionAnnotation: "v1.0.0", - common.PreDeploymentTaskAnnotation: "some-pre-deployment-task", - common.PostDeploymentTaskAnnotation: "some-post-deployment-task", - common.PreDeploymentEvaluationAnnotation: "some-pre-deployment-evaluation", - common.PostDeploymentEvaluationAnnotation: "some-post-deployment-evaluation", + apicommon.WorkloadAnnotation: "some-workload-name", + apicommon.AppAnnotation: "some-app-name", + apicommon.VersionAnnotation: "v1.0.0", + apicommon.PreDeploymentTaskAnnotation: "some-pre-deployment-task", + apicommon.PostDeploymentTaskAnnotation: "some-post-deployment-task", + apicommon.PreDeploymentEvaluationAnnotation: "some-pre-deployment-evaluation", + apicommon.PostDeploymentEvaluationAnnotation: "some-post-deployment-evaluation", }, }, targetPod: &corev1.Pod{ @@ -786,13 +786,13 @@ func TestPodMutatingWebhook_copyResourceLabelsIfPresent(t *testing.T) { TypeMeta: metav1.TypeMeta{}, ObjectMeta: metav1.ObjectMeta{ Annotations: map[string]string{ - common.WorkloadAnnotation: "some-workload-name", - common.AppAnnotation: "some-app-name", - common.VersionAnnotation: "v1.0.0", - common.PreDeploymentTaskAnnotation: "some-pre-deployment-task", - common.PostDeploymentTaskAnnotation: "some-post-deployment-task", - common.PreDeploymentEvaluationAnnotation: "some-pre-deployment-evaluation", - common.PostDeploymentEvaluationAnnotation: "some-post-deployment-evaluation", + apicommon.WorkloadAnnotation: "some-workload-name", + apicommon.AppAnnotation: "some-app-name", + apicommon.VersionAnnotation: "v1.0.0", + apicommon.PreDeploymentTaskAnnotation: "some-pre-deployment-task", + apicommon.PostDeploymentTaskAnnotation: "some-post-deployment-task", + apicommon.PreDeploymentEvaluationAnnotation: "some-pre-deployment-evaluation", + apicommon.PostDeploymentEvaluationAnnotation: "some-post-deployment-evaluation", }, }, }, @@ -803,13 +803,13 @@ func TestPodMutatingWebhook_copyResourceLabelsIfPresent(t *testing.T) { sourceResource: &metav1.ObjectMeta{ Name: "testSourceObject", Labels: map[string]string{ - common.WorkloadAnnotation: "some-workload-name", - common.AppAnnotation: "some-app-name", - common.VersionAnnotation: "v1.0.0", - common.PreDeploymentTaskAnnotation: "some-pre-deployment-task", - common.PostDeploymentTaskAnnotation: "some-post-deployment-task", - common.PreDeploymentEvaluationAnnotation: "some-pre-deployment-evaluation", - common.PostDeploymentEvaluationAnnotation: "some-post-deployment-evaluation", + apicommon.WorkloadAnnotation: "some-workload-name", + apicommon.AppAnnotation: "some-app-name", + apicommon.VersionAnnotation: "v1.0.0", + apicommon.PreDeploymentTaskAnnotation: "some-pre-deployment-task", + apicommon.PostDeploymentTaskAnnotation: "some-post-deployment-task", + apicommon.PreDeploymentEvaluationAnnotation: "some-pre-deployment-evaluation", + apicommon.PostDeploymentEvaluationAnnotation: "some-post-deployment-evaluation", }, }, targetPod: &corev1.Pod{}, @@ -820,13 +820,13 @@ func TestPodMutatingWebhook_copyResourceLabelsIfPresent(t *testing.T) { TypeMeta: metav1.TypeMeta{}, ObjectMeta: metav1.ObjectMeta{ Annotations: map[string]string{ - common.WorkloadAnnotation: "some-workload-name", - common.AppAnnotation: "some-app-name", - common.VersionAnnotation: "v1.0.0", - common.PreDeploymentTaskAnnotation: "some-pre-deployment-task", - common.PostDeploymentTaskAnnotation: "some-post-deployment-task", - common.PreDeploymentEvaluationAnnotation: "some-pre-deployment-evaluation", - common.PostDeploymentEvaluationAnnotation: "some-post-deployment-evaluation", + apicommon.WorkloadAnnotation: "some-workload-name", + apicommon.AppAnnotation: "some-app-name", + apicommon.VersionAnnotation: "v1.0.0", + apicommon.PreDeploymentTaskAnnotation: "some-pre-deployment-task", + apicommon.PostDeploymentTaskAnnotation: "some-post-deployment-task", + apicommon.PreDeploymentEvaluationAnnotation: "some-pre-deployment-evaluation", + apicommon.PostDeploymentEvaluationAnnotation: "some-post-deployment-evaluation", }, }, }, @@ -837,12 +837,12 @@ func TestPodMutatingWebhook_copyResourceLabelsIfPresent(t *testing.T) { sourceResource: &metav1.ObjectMeta{ Name: "testSourceObject", Labels: map[string]string{ - common.WorkloadAnnotation: "some-workload-name", - common.AppAnnotation: "some-app-name", - common.PreDeploymentTaskAnnotation: "some-pre-deployment-task", - common.PostDeploymentTaskAnnotation: "some-post-deployment-task", - common.PreDeploymentEvaluationAnnotation: "some-pre-deployment-evaluation", - common.PostDeploymentEvaluationAnnotation: "some-post-deployment-evaluation", + apicommon.WorkloadAnnotation: "some-workload-name", + apicommon.AppAnnotation: "some-app-name", + apicommon.PreDeploymentTaskAnnotation: "some-pre-deployment-task", + apicommon.PostDeploymentTaskAnnotation: "some-post-deployment-task", + apicommon.PreDeploymentEvaluationAnnotation: "some-pre-deployment-evaluation", + apicommon.PostDeploymentEvaluationAnnotation: "some-post-deployment-evaluation", }, }, targetPod: &corev1.Pod{ @@ -864,13 +864,13 @@ func TestPodMutatingWebhook_copyResourceLabelsIfPresent(t *testing.T) { TypeMeta: metav1.TypeMeta{}, ObjectMeta: metav1.ObjectMeta{ Annotations: map[string]string{ - common.WorkloadAnnotation: "some-workload-name", - common.AppAnnotation: "some-app-name", - common.VersionAnnotation: "v1.0.0", - common.PreDeploymentTaskAnnotation: "some-pre-deployment-task", - common.PostDeploymentTaskAnnotation: "some-post-deployment-task", - common.PreDeploymentEvaluationAnnotation: "some-pre-deployment-evaluation", - common.PostDeploymentEvaluationAnnotation: "some-post-deployment-evaluation", + apicommon.WorkloadAnnotation: "some-workload-name", + apicommon.AppAnnotation: "some-app-name", + apicommon.VersionAnnotation: "v1.0.0", + apicommon.PreDeploymentTaskAnnotation: "some-pre-deployment-task", + apicommon.PostDeploymentTaskAnnotation: "some-post-deployment-task", + apicommon.PreDeploymentEvaluationAnnotation: "some-pre-deployment-evaluation", + apicommon.PostDeploymentEvaluationAnnotation: "some-post-deployment-evaluation", }, }, Spec: corev1.PodSpec{ @@ -889,7 +889,7 @@ func TestPodMutatingWebhook_copyResourceLabelsIfPresent(t *testing.T) { sourceResource: &metav1.ObjectMeta{ Name: "testSourceObject", Labels: map[string]string{ - common.WorkloadAnnotation: "some-workload-name-that-is-very-looooooooooooooooooooooong", + apicommon.WorkloadAnnotation: "some-workload-name-that-is-very-looooooooooooooooooooooong", }, }, targetPod: &corev1.Pod{}, @@ -947,7 +947,7 @@ func TestPodMutatingWebhook_isAppAnnotationPresent(t *testing.T) { pod: &corev1.Pod{ ObjectMeta: metav1.ObjectMeta{ Annotations: map[string]string{ - common.AppAnnotation: "some-app-name", + apicommon.AppAnnotation: "some-app-name", }, }, }, @@ -969,7 +969,7 @@ func TestPodMutatingWebhook_isAppAnnotationPresent(t *testing.T) { pod: &corev1.Pod{ ObjectMeta: metav1.ObjectMeta{ Annotations: map[string]string{ - common.AppAnnotation: "some-app-annotation-that-is-very-looooooooooooooooooooong", + apicommon.AppAnnotation: "some-app-annotation-that-is-very-looooooooooooooooooooong", }, }, }, @@ -983,7 +983,7 @@ func TestPodMutatingWebhook_isAppAnnotationPresent(t *testing.T) { pod: &corev1.Pod{ ObjectMeta: metav1.ObjectMeta{ Annotations: map[string]string{ - common.WorkloadAnnotation: "some-workload-name", + apicommon.WorkloadAnnotation: "some-workload-name", }, }, }, @@ -993,8 +993,8 @@ func TestPodMutatingWebhook_isAppAnnotationPresent(t *testing.T) { wantedPod: &corev1.Pod{ ObjectMeta: metav1.ObjectMeta{ Annotations: map[string]string{ - common.AppAnnotation: "some-workload-name", - common.WorkloadAnnotation: "some-workload-name", + apicommon.AppAnnotation: "some-workload-name", + apicommon.WorkloadAnnotation: "some-workload-name", }, }, },