diff --git a/pkg/adapter/kubernetes/blueprintcr/v1/doguConfigDiff.go b/pkg/adapter/kubernetes/blueprintcr/v1/doguConfigDiff.go index 8836d78e..61d2b934 100644 --- a/pkg/adapter/kubernetes/blueprintcr/v1/doguConfigDiff.go +++ b/pkg/adapter/kubernetes/blueprintcr/v1/doguConfigDiff.go @@ -21,35 +21,18 @@ type DoguConfigEntryDiff struct { NeededAction ConfigAction `json:"neededAction"` } -type SensitiveDoguConfigDiff []SensitiveDoguConfigEntryDiff -type SensitiveDoguConfigEntryDiff struct { - Key string `json:"key"` - Actual DoguConfigValueState `json:"actual"` - Expected DoguConfigValueState `json:"expected"` - NeededAction ConfigAction `json:"neededAction"` -} +type SensitiveDoguConfigDiff = DoguConfigDiff +type SensitiveDoguConfigEntryDiff = DoguConfigEntryDiff -func convertToCombinedDoguConfigDiffDomain(doguName string, dto CombinedDoguConfigDiff) domain.CombinedDoguConfigDiffs { +func convertToDoguConfigDiffsDomain(doguName string, dto DoguConfigDiff) domain.DoguConfigDiffs { var doguConfigDiff domain.DoguConfigDiffs - if len(dto.DoguConfigDiff) != 0 { - doguConfigDiff = make(domain.DoguConfigDiffs, len(dto.DoguConfigDiff)) - for i, entryDiff := range dto.DoguConfigDiff { + if len(dto) != 0 { + doguConfigDiff = make(domain.DoguConfigDiffs, len(dto)) + for i, entryDiff := range dto { doguConfigDiff[i] = convertToDoguConfigEntryDiffDomain(doguName, entryDiff) } } - - var sensitiveDoguConfigDiff domain.SensitiveDoguConfigDiffs - if len(dto.SensitiveDoguConfigDiff) != 0 { - sensitiveDoguConfigDiff = make(domain.SensitiveDoguConfigDiffs, len(dto.SensitiveDoguConfigDiff)) - for i, entryDiff := range dto.SensitiveDoguConfigDiff { - sensitiveDoguConfigDiff[i] = convertToSensitiveDoguConfigEntryDiffDomain(doguName, entryDiff) - } - } - - return domain.CombinedDoguConfigDiffs{ - DoguConfigDiff: doguConfigDiff, - SensitiveDoguConfigDiff: sensitiveDoguConfigDiff, - } + return doguConfigDiff } func convertToDoguConfigEntryDiffDomain(doguName string, dto DoguConfigEntryDiff) domain.DoguConfigEntryDiff { @@ -70,45 +53,12 @@ func convertToDoguConfigEntryDiffDomain(doguName string, dto DoguConfigEntryDiff } } -func convertToSensitiveDoguConfigEntryDiffDomain(doguName string, dto SensitiveDoguConfigEntryDiff) domain.SensitiveDoguConfigEntryDiff { - return domain.SensitiveDoguConfigEntryDiff{ - Key: common.SensitiveDoguConfigKey{ - DoguName: common.SimpleDoguName(doguName), - Key: config.Key(dto.Key), - }, - Actual: domain.DoguConfigValueState{ - Value: dto.Actual.Value, - Exists: dto.Actual.Exists, - }, - Expected: domain.DoguConfigValueState{ - Value: dto.Expected.Value, - Exists: dto.Expected.Exists, - }, - NeededAction: domain.ConfigAction(dto.NeededAction), - } -} - -func convertToCombinedDoguConfigDiffDTO(domainModel domain.CombinedDoguConfigDiffs) CombinedDoguConfigDiff { - var doguConfigDiff DoguConfigDiff - if len(domainModel.DoguConfigDiff) != 0 { - doguConfigDiff = make(DoguConfigDiff, len(domainModel.DoguConfigDiff)) - for i, entryDiff := range domainModel.DoguConfigDiff { - doguConfigDiff[i] = convertToDoguConfigEntryDiffDTO(entryDiff) - } - } - - var sensitiveDoguConfigDiff SensitiveDoguConfigDiff - if len(domainModel.SensitiveDoguConfigDiff) != 0 { - sensitiveDoguConfigDiff = make(SensitiveDoguConfigDiff, len(domainModel.SensitiveDoguConfigDiff)) - for i, entryDiff := range domainModel.SensitiveDoguConfigDiff { - sensitiveDoguConfigDiff[i] = convertToSensitiveDoguConfigEntryDiffDTO(entryDiff) - } - } - - return CombinedDoguConfigDiff{ - DoguConfigDiff: doguConfigDiff, - SensitiveDoguConfigDiff: sensitiveDoguConfigDiff, +func convertToDoguConfigEntryDiffsDTO(domainDiffs domain.DoguConfigDiffs) []DoguConfigEntryDiff { + var dtoDiffs []DoguConfigEntryDiff + for _, domainDiff := range domainDiffs { + dtoDiffs = append(dtoDiffs, convertToDoguConfigEntryDiffDTO(domainDiff)) } + return dtoDiffs } func convertToDoguConfigEntryDiffDTO(domainModel domain.DoguConfigEntryDiff) DoguConfigEntryDiff { @@ -125,18 +75,3 @@ func convertToDoguConfigEntryDiffDTO(domainModel domain.DoguConfigEntryDiff) Dog NeededAction: ConfigAction(domainModel.NeededAction), } } - -func convertToSensitiveDoguConfigEntryDiffDTO(domainModel domain.SensitiveDoguConfigEntryDiff) SensitiveDoguConfigEntryDiff { - return SensitiveDoguConfigEntryDiff{ - Key: string(domainModel.Key.Key), - Actual: DoguConfigValueState{ - Value: domainModel.Actual.Value, - Exists: domainModel.Actual.Exists, - }, - Expected: DoguConfigValueState{ - Value: domainModel.Expected.Value, - Exists: domainModel.Expected.Exists, - }, - NeededAction: ConfigAction(domainModel.NeededAction), - } -} diff --git a/pkg/adapter/kubernetes/blueprintcr/v1/stateDiff.go b/pkg/adapter/kubernetes/blueprintcr/v1/stateDiff.go index dac6ca67..105a6b0c 100644 --- a/pkg/adapter/kubernetes/blueprintcr/v1/stateDiff.go +++ b/pkg/adapter/kubernetes/blueprintcr/v1/stateDiff.go @@ -5,6 +5,7 @@ import ( "fmt" "github.com/cloudogu/k8s-blueprint-operator/pkg/domain" "github.com/cloudogu/k8s-blueprint-operator/pkg/domain/common" + "slices" ) // StateDiff is the result of comparing the EffectiveBlueprint to the current cluster state. @@ -31,18 +32,36 @@ func ConvertToStateDiffDTO(domainModel domain.StateDiff) StateDiff { componentDiffsV1[string(componentDiff.Name)] = convertToComponentDiffDTO(componentDiff) } - var doguConfigDiffs map[string]CombinedDoguConfigDiff + var dogus []common.SimpleDoguName + var combinedConfigDiffs map[string]CombinedDoguConfigDiff + var doguConfigDiffByDogu map[common.SimpleDoguName]DoguConfigDiff + var sensitiveDoguConfigDiff map[common.SimpleDoguName]SensitiveDoguConfigDiff + if len(domainModel.DoguConfigDiffs) != 0 { - doguConfigDiffs = make(map[string]CombinedDoguConfigDiff) + combinedConfigDiffs = make(map[string]CombinedDoguConfigDiff) for doguName, doguConfigDiff := range domainModel.DoguConfigDiffs { - doguConfigDiffs[string(doguName)] = convertToCombinedDoguConfigDiffDTO(doguConfigDiff) + doguConfigDiffByDogu[doguName] = convertToDoguConfigEntryDiffsDTO(doguConfigDiff) + dogus = append(dogus, doguName) + } + for doguName, doguConfigDiff := range domainModel.SensitiveDoguConfigDiffs { + sensitiveDoguConfigDiff[doguName] = convertToDoguConfigEntryDiffsDTO(doguConfigDiff) + dogus = append(dogus, doguName) + } + + //remove duplicates, so we have a complete list of all dogus with config + dogus = slices.Compact(dogus) + for _, doguName := range dogus { + combinedConfigDiffs[string(doguName)] = CombinedDoguConfigDiff{ + DoguConfigDiff: doguConfigDiffByDogu[doguName], + SensitiveDoguConfigDiff: sensitiveDoguConfigDiff[doguName], + } } } return StateDiff{ DoguDiffs: doguDiffs, ComponentDiffs: componentDiffsV1, - DoguConfigDiffs: doguConfigDiffs, + DoguConfigDiffs: combinedConfigDiffs, GlobalConfigDiff: convertToGlobalConfigDiffDTO(domainModel.GlobalConfigDiffs), } } @@ -69,18 +88,22 @@ func ConvertToStateDiffDomain(dto StateDiff) (domain.StateDiff, error) { return domain.StateDiff{}, fmt.Errorf("failed to convert state diff DTO to domain model: %w", err) } - var doguConfigDiffs map[common.SimpleDoguName]domain.CombinedDoguConfigDiffs + var doguConfigDiffs map[common.SimpleDoguName]domain.DoguConfigDiffs + var sensitiveDoguConfigDiffs map[common.SimpleDoguName]domain.SensitiveDoguConfigDiffs if len(dto.DoguConfigDiffs) != 0 { - doguConfigDiffs = make(map[common.SimpleDoguName]domain.CombinedDoguConfigDiffs) + doguConfigDiffs = map[common.SimpleDoguName]domain.DoguConfigDiffs{} + sensitiveDoguConfigDiffs = map[common.SimpleDoguName]domain.SensitiveDoguConfigDiffs{} for doguName, doguConfigDiff := range dto.DoguConfigDiffs { - doguConfigDiffs[common.SimpleDoguName(doguName)] = convertToCombinedDoguConfigDiffDomain(doguName, doguConfigDiff) + doguConfigDiffs[common.SimpleDoguName(doguName)] = convertToDoguConfigDiffsDomain(doguName, doguConfigDiff.DoguConfigDiff) + sensitiveDoguConfigDiffs[common.SimpleDoguName(doguName)] = convertToDoguConfigDiffsDomain(doguName, doguConfigDiff.SensitiveDoguConfigDiff) } } return domain.StateDiff{ - DoguDiffs: doguDiffs, - ComponentDiffs: componentDiffs, - DoguConfigDiffs: doguConfigDiffs, - GlobalConfigDiffs: convertToGlobalConfigDiffDomain(dto.GlobalConfigDiff), + DoguDiffs: doguDiffs, + ComponentDiffs: componentDiffs, + DoguConfigDiffs: doguConfigDiffs, + SensitiveDoguConfigDiffs: sensitiveDoguConfigDiffs, + GlobalConfigDiffs: convertToGlobalConfigDiffDomain(dto.GlobalConfigDiff), }, nil } diff --git a/pkg/application/doguRestartUseCase_test.go b/pkg/application/doguRestartUseCase_test.go index 82447bf3..0f796d02 100644 --- a/pkg/application/doguRestartUseCase_test.go +++ b/pkg/application/doguRestartUseCase_test.go @@ -11,15 +11,20 @@ import ( "testing" ) +var ( + testDoguSimpleName = common.SimpleDoguName("testDogu1") +) + func TestDoguRestartUseCase_TriggerDoguRestarts(t *testing.T) { t.Run("no dogu restarts triggered on blueprint with empty state diff", func(t *testing.T) { // given testContext := context.Background() testStateDiff := domain.StateDiff{ - DoguDiffs: domain.DoguDiffs{}, - ComponentDiffs: domain.ComponentDiffs{}, - DoguConfigDiffs: map[common.SimpleDoguName]domain.CombinedDoguConfigDiffs{}, - GlobalConfigDiffs: domain.GlobalConfigDiffs{}, + DoguDiffs: domain.DoguDiffs{}, + ComponentDiffs: domain.ComponentDiffs{}, + DoguConfigDiffs: map[common.SimpleDoguName]domain.DoguConfigDiffs{}, + SensitiveDoguConfigDiffs: map[common.SimpleDoguName]domain.SensitiveDoguConfigDiffs{}, + GlobalConfigDiffs: domain.GlobalConfigDiffs{}, } testBlueprint := domain.BlueprintSpec{ Id: testBlueprintId, @@ -51,9 +56,10 @@ func TestDoguRestartUseCase_TriggerDoguRestarts(t *testing.T) { // given testContext := context.Background() testStateDiff := domain.StateDiff{ - DoguDiffs: domain.DoguDiffs{}, - ComponentDiffs: domain.ComponentDiffs{}, - DoguConfigDiffs: map[common.SimpleDoguName]domain.CombinedDoguConfigDiffs{}, + DoguDiffs: domain.DoguDiffs{}, + ComponentDiffs: domain.ComponentDiffs{}, + DoguConfigDiffs: map[common.SimpleDoguName]domain.DoguConfigDiffs{}, + SensitiveDoguConfigDiffs: map[common.SimpleDoguName]domain.SensitiveDoguConfigDiffs{}, GlobalConfigDiffs: domain.GlobalConfigDiffs{{ Key: "testkey", Actual: domain.GlobalConfigValueState{Value: "changed", Exists: true}, @@ -72,7 +78,6 @@ func TestDoguRestartUseCase_TriggerDoguRestarts(t *testing.T) { PersistenceContext: nil, Events: nil, } - testDoguSimpleName := common.SimpleDoguName("testdogu1") installedDogu := ecosystem.DoguInstallation{ Name: common.QualifiedDoguName{Namespace: "testing", SimpleName: testDoguSimpleName}, Version: core.Version{Raw: "1.0.0-1", Major: 1, Extra: 1}, @@ -106,9 +111,10 @@ func TestDoguRestartUseCase_TriggerDoguRestarts(t *testing.T) { // given testContext := context.Background() testStateDiff := domain.StateDiff{ - DoguDiffs: domain.DoguDiffs{}, - ComponentDiffs: domain.ComponentDiffs{}, - DoguConfigDiffs: map[common.SimpleDoguName]domain.CombinedDoguConfigDiffs{}, + DoguDiffs: domain.DoguDiffs{}, + ComponentDiffs: domain.ComponentDiffs{}, + DoguConfigDiffs: map[common.SimpleDoguName]domain.DoguConfigDiffs{}, + SensitiveDoguConfigDiffs: map[common.SimpleDoguName]domain.SensitiveDoguConfigDiffs{}, GlobalConfigDiffs: domain.GlobalConfigDiffs{{ Key: "testkey", Actual: domain.GlobalConfigValueState{Value: "changed", Exists: true}, @@ -147,9 +153,10 @@ func TestDoguRestartUseCase_TriggerDoguRestarts(t *testing.T) { // given testContext := context.Background() testStateDiff := domain.StateDiff{ - DoguDiffs: domain.DoguDiffs{}, - ComponentDiffs: domain.ComponentDiffs{}, - DoguConfigDiffs: map[common.SimpleDoguName]domain.CombinedDoguConfigDiffs{}, + DoguDiffs: domain.DoguDiffs{}, + ComponentDiffs: domain.ComponentDiffs{}, + DoguConfigDiffs: map[common.SimpleDoguName]domain.DoguConfigDiffs{}, + SensitiveDoguConfigDiffs: map[common.SimpleDoguName]domain.SensitiveDoguConfigDiffs{}, GlobalConfigDiffs: domain.GlobalConfigDiffs{{ Key: "testkey", Actual: domain.GlobalConfigValueState{Value: "changed", Exists: true}, @@ -168,7 +175,6 @@ func TestDoguRestartUseCase_TriggerDoguRestarts(t *testing.T) { PersistenceContext: nil, Events: nil, } - testDoguSimpleName := common.SimpleDoguName("testdogu1") installedDogu := ecosystem.DoguInstallation{ Name: common.QualifiedDoguName{Namespace: "testing", SimpleName: testDoguSimpleName}, Version: core.Version{Raw: "1.0.0-1", Major: 1, Extra: 1}, @@ -199,20 +205,20 @@ func TestDoguRestartUseCase_TriggerDoguRestarts(t *testing.T) { t.Run("restart some dogus", func(t *testing.T) { // given - doguConfigDiff := map[common.SimpleDoguName]domain.CombinedDoguConfigDiffs{} - testDoguSimpleName := common.SimpleDoguName("testdogu1") - doguConfigDiff[testDoguSimpleName] = domain.CombinedDoguConfigDiffs{DoguConfigDiff: domain.DoguConfigDiffs{{ - Key: common.DoguConfigKey{DoguName: testDoguSimpleName, Key: "testkey"}, - Actual: domain.DoguConfigValueState{Value: "changed", Exists: true}, - Expected: domain.DoguConfigValueState{Value: "initial", Exists: true}, - NeededAction: domain.ConfigActionSet}}, - } + testContext := context.Background() testStateDiff := domain.StateDiff{ - DoguDiffs: domain.DoguDiffs{}, - ComponentDiffs: domain.ComponentDiffs{}, - DoguConfigDiffs: doguConfigDiff, - GlobalConfigDiffs: domain.GlobalConfigDiffs{}, + DoguDiffs: domain.DoguDiffs{}, + ComponentDiffs: domain.ComponentDiffs{}, + DoguConfigDiffs: map[common.SimpleDoguName]domain.DoguConfigDiffs{ + testDoguSimpleName: {{ + Key: common.DoguConfigKey{DoguName: testDoguSimpleName, Key: "testKey"}, + Actual: domain.DoguConfigValueState{Value: "changed", Exists: true}, + Expected: domain.DoguConfigValueState{Value: "initial", Exists: true}, + NeededAction: domain.ConfigActionSet}}, + }, + SensitiveDoguConfigDiffs: map[common.SimpleDoguName]domain.SensitiveDoguConfigDiffs{}, + GlobalConfigDiffs: domain.GlobalConfigDiffs{}, } testDogu := domain.Dogu{ Name: common.QualifiedDoguName{SimpleName: testDoguSimpleName, Namespace: "testing"}, @@ -248,20 +254,19 @@ func TestDoguRestartUseCase_TriggerDoguRestarts(t *testing.T) { t.Run("fail on dogu restart for some dogus", func(t *testing.T) { // given - doguConfigDiff := map[common.SimpleDoguName]domain.CombinedDoguConfigDiffs{} - testDoguSimpleName := common.SimpleDoguName("testdogu1") - doguConfigDiff[testDoguSimpleName] = domain.CombinedDoguConfigDiffs{DoguConfigDiff: domain.DoguConfigDiffs{{ - Key: common.DoguConfigKey{DoguName: testDoguSimpleName, Key: "testkey"}, - Actual: domain.DoguConfigValueState{Value: "changed", Exists: true}, - Expected: domain.DoguConfigValueState{Value: "initial", Exists: true}, - NeededAction: domain.ConfigActionSet}}, - } testContext := context.Background() testStateDiff := domain.StateDiff{ - DoguDiffs: domain.DoguDiffs{}, - ComponentDiffs: domain.ComponentDiffs{}, - DoguConfigDiffs: doguConfigDiff, - GlobalConfigDiffs: domain.GlobalConfigDiffs{}, + DoguDiffs: domain.DoguDiffs{}, + ComponentDiffs: domain.ComponentDiffs{}, + DoguConfigDiffs: map[common.SimpleDoguName]domain.DoguConfigDiffs{ + testDoguSimpleName: {{ + Key: common.DoguConfigKey{DoguName: testDoguSimpleName, Key: "testKey"}, + Actual: domain.DoguConfigValueState{Value: "changed", Exists: true}, + Expected: domain.DoguConfigValueState{Value: "initial", Exists: true}, + NeededAction: domain.ConfigActionSet}}, + }, + SensitiveDoguConfigDiffs: map[common.SimpleDoguName]domain.SensitiveDoguConfigDiffs{}, + GlobalConfigDiffs: domain.GlobalConfigDiffs{}, } testDogu := domain.Dogu{ Name: common.QualifiedDoguName{SimpleName: testDoguSimpleName, Namespace: "testing"}, @@ -297,20 +302,19 @@ func TestDoguRestartUseCase_TriggerDoguRestarts(t *testing.T) { t.Run("fail on error in blueprint spec update", func(t *testing.T) { // given - doguConfigDiff := map[common.SimpleDoguName]domain.CombinedDoguConfigDiffs{} - testDoguSimpleName := common.SimpleDoguName("testdogu1") - doguConfigDiff[testDoguSimpleName] = domain.CombinedDoguConfigDiffs{DoguConfigDiff: domain.DoguConfigDiffs{{ - Key: common.DoguConfigKey{DoguName: testDoguSimpleName, Key: "testkey"}, - Actual: domain.DoguConfigValueState{Value: "changed", Exists: true}, - Expected: domain.DoguConfigValueState{Value: "initial", Exists: true}, - NeededAction: domain.ConfigActionSet}}, - } testContext := context.Background() testStateDiff := domain.StateDiff{ - DoguDiffs: domain.DoguDiffs{}, - ComponentDiffs: domain.ComponentDiffs{}, - DoguConfigDiffs: doguConfigDiff, - GlobalConfigDiffs: domain.GlobalConfigDiffs{}, + DoguDiffs: domain.DoguDiffs{}, + ComponentDiffs: domain.ComponentDiffs{}, + DoguConfigDiffs: map[common.SimpleDoguName]domain.DoguConfigDiffs{ + testDoguSimpleName: {{ + Key: common.DoguConfigKey{DoguName: testDoguSimpleName, Key: "testKey"}, + Actual: domain.DoguConfigValueState{Value: "changed", Exists: true}, + Expected: domain.DoguConfigValueState{Value: "initial", Exists: true}, + NeededAction: domain.ConfigActionSet}}, + }, + SensitiveDoguConfigDiffs: map[common.SimpleDoguName]domain.SensitiveDoguConfigDiffs{}, + GlobalConfigDiffs: domain.GlobalConfigDiffs{}, } testDogu := domain.Dogu{ Name: common.QualifiedDoguName{SimpleName: testDoguSimpleName, Namespace: "testing"}, @@ -347,20 +351,19 @@ func TestDoguRestartUseCase_TriggerDoguRestarts(t *testing.T) { t.Run("fail on error when getting blueprint", func(t *testing.T) { // given - doguConfigDiff := map[common.SimpleDoguName]domain.CombinedDoguConfigDiffs{} - testDoguSimpleName := common.SimpleDoguName("testdogu1") - doguConfigDiff[testDoguSimpleName] = domain.CombinedDoguConfigDiffs{DoguConfigDiff: domain.DoguConfigDiffs{{ - Key: common.DoguConfigKey{DoguName: testDoguSimpleName, Key: "testkey"}, - Actual: domain.DoguConfigValueState{Value: "changed", Exists: true}, - Expected: domain.DoguConfigValueState{Value: "initial", Exists: true}, - NeededAction: domain.ConfigActionSet}}, - } testContext := context.Background() testStateDiff := domain.StateDiff{ - DoguDiffs: domain.DoguDiffs{}, - ComponentDiffs: domain.ComponentDiffs{}, - DoguConfigDiffs: doguConfigDiff, - GlobalConfigDiffs: domain.GlobalConfigDiffs{}, + DoguDiffs: domain.DoguDiffs{}, + ComponentDiffs: domain.ComponentDiffs{}, + DoguConfigDiffs: map[common.SimpleDoguName]domain.DoguConfigDiffs{ + testDoguSimpleName: {{ + Key: common.DoguConfigKey{DoguName: testDoguSimpleName, Key: "testKey"}, + Actual: domain.DoguConfigValueState{Value: "changed", Exists: true}, + Expected: domain.DoguConfigValueState{Value: "initial", Exists: true}, + NeededAction: domain.ConfigActionSet}}, + }, + SensitiveDoguConfigDiffs: map[common.SimpleDoguName]domain.SensitiveDoguConfigDiffs{}, + GlobalConfigDiffs: domain.GlobalConfigDiffs{}, } testDogu := domain.Dogu{ Name: common.QualifiedDoguName{SimpleName: testDoguSimpleName, Namespace: "testing"}, diff --git a/pkg/application/ecosystemConfigUseCase.go b/pkg/application/ecosystemConfigUseCase.go index 9663b6ed..2f4caa93 100644 --- a/pkg/application/ecosystemConfigUseCase.go +++ b/pkg/application/ecosystemConfigUseCase.go @@ -49,13 +49,19 @@ func (useCase *EcosystemConfigUseCase) ApplyConfig(ctx context.Context, blueprin logger.Info("dogu config diffs are empty...") } + sensitiveDoguConfigDiffs := blueprintSpec.StateDiff.SensitiveDoguConfigDiffs + isEmptySensitiveDiff := len(sensitiveDoguConfigDiffs) == 0 + if isEmptySensitiveDiff { + logger.Info("sensitive dogu config diffs are empty...") + } + globalConfigDiffs := blueprintSpec.StateDiff.GlobalConfigDiffs isEmptyGlobalDiff := len(globalConfigDiffs) == 0 if isEmptyGlobalDiff { logger.Info("global config diffs are empty...") } - if isEmptyDoguDiff && isEmptyGlobalDiff { + if isEmptyDoguDiff && isEmptyGlobalDiff && isEmptySensitiveDiff { return useCase.markConfigApplied(ctx, blueprintSpec) } @@ -71,7 +77,7 @@ func (useCase *EcosystemConfigUseCase) ApplyConfig(ctx context.Context, blueprin } err = applyDoguConfigDiffs(ctx, useCase.sensitiveDoguConfigRepository, blueprintSpec.StateDiff.SensitiveDoguConfigDiffs) if err != nil { - return useCase.handleFailedApplyEcosystemConfig(ctx, blueprintSpec, fmt.Errorf("could not apply normal dogu config: %w", err)) + return useCase.handleFailedApplyEcosystemConfig(ctx, blueprintSpec, fmt.Errorf("could not apply sensitive dogu config: %w", err)) } err = useCase.applyGlobalConfigDiffs(ctx, globalConfigDiffs.GetGlobalConfigDiffsByAction()) if err != nil { diff --git a/pkg/application/ecosystemConfigUseCase_test.go b/pkg/application/ecosystemConfigUseCase_test.go index c1b6b4fb..357a5337 100644 --- a/pkg/application/ecosystemConfigUseCase_test.go +++ b/pkg/application/ecosystemConfigUseCase_test.go @@ -42,26 +42,24 @@ func TestEcosystemConfigUseCase_ApplyConfig(t *testing.T) { NeededActions: []domain.Action{}, }, }, - DoguConfigDiffs: map[common.SimpleDoguName]domain.CombinedDoguConfigDiffs{ + DoguConfigDiffs: map[common.SimpleDoguName]domain.DoguConfigDiffs{ redmine: { - DoguConfigDiff: []domain.DoguConfigEntryDiff{ - getSetDoguConfigEntryDiff("key", "value", redmine), - getRemoveDoguConfigEntryDiff("key", redmine), - }, - SensitiveDoguConfigDiff: []domain.SensitiveDoguConfigEntryDiff{ - sensitiveRedmineDiff, - getRemoveSensitiveDoguConfigEntryDiff("key", redmine), - }, + getSetDoguConfigEntryDiff("key", "value", redmine), + getRemoveDoguConfigEntryDiff("key", redmine), }, cas: { - DoguConfigDiff: []domain.DoguConfigEntryDiff{ - getSetDoguConfigEntryDiff("key", "value", cas), - getRemoveDoguConfigEntryDiff("key", cas), - }, - SensitiveDoguConfigDiff: []domain.SensitiveDoguConfigEntryDiff{ - sensitiveCasDiff, - getRemoveSensitiveDoguConfigEntryDiff("key", cas), - }, + getSetDoguConfigEntryDiff("key", "value", cas), + getRemoveDoguConfigEntryDiff("key", cas), + }, + }, + SensitiveDoguConfigDiffs: map[common.SimpleDoguName]domain.SensitiveDoguConfigDiffs{ + redmine: { + sensitiveRedmineDiff, + getRemoveSensitiveDoguConfigEntryDiff("key", redmine), + }, + cas: { + sensitiveCasDiff, + getRemoveSensitiveDoguConfigEntryDiff("key", cas), }, }, GlobalConfigDiffs: domain.GlobalConfigDiffs{ @@ -128,8 +126,9 @@ func TestEcosystemConfigUseCase_ApplyConfig(t *testing.T) { spec := &domain.BlueprintSpec{ StateDiff: domain.StateDiff{ - DoguConfigDiffs: map[common.SimpleDoguName]domain.CombinedDoguConfigDiffs{}, - GlobalConfigDiffs: domain.GlobalConfigDiffs{}, + DoguConfigDiffs: map[common.SimpleDoguName]domain.DoguConfigDiffs{}, + SensitiveDoguConfigDiffs: map[common.SimpleDoguName]domain.SensitiveDoguConfigDiffs{}, + GlobalConfigDiffs: domain.GlobalConfigDiffs{}, }, } @@ -152,7 +151,8 @@ func TestEcosystemConfigUseCase_ApplyConfig(t *testing.T) { spec := &domain.BlueprintSpec{ StateDiff: domain.StateDiff{ - DoguConfigDiffs: map[common.SimpleDoguName]domain.CombinedDoguConfigDiffs{}, + DoguConfigDiffs: map[common.SimpleDoguName]domain.DoguConfigDiffs{}, + SensitiveDoguConfigDiffs: map[common.SimpleDoguName]domain.SensitiveDoguConfigDiffs{}, GlobalConfigDiffs: domain.GlobalConfigDiffs{ getSetGlobalConfigEntryDiff("key", "value"), }, @@ -182,16 +182,12 @@ func TestEcosystemConfigUseCase_ApplyConfig(t *testing.T) { spec := &domain.BlueprintSpec{ StateDiff: domain.StateDiff{ - DoguConfigDiffs: map[common.SimpleDoguName]domain.CombinedDoguConfigDiffs{ + DoguConfigDiffs: map[common.SimpleDoguName]domain.DoguConfigDiffs{ redmine: { - DoguConfigDiff: []domain.DoguConfigEntryDiff{ - getSetDoguConfigEntryDiff("key", "value", redmine), - }, + getSetDoguConfigEntryDiff("key", "value", redmine), }, cas: { - DoguConfigDiff: []domain.DoguConfigEntryDiff{ - getSetDoguConfigEntryDiff("key", "value", cas), - }, + getSetDoguConfigEntryDiff("key", "value", cas), }, }, }, @@ -231,19 +227,14 @@ func TestEcosystemConfigUseCase_ApplyConfig(t *testing.T) { sensitiveDoguConfigMock := newMockSensitiveDoguConfigRepository(t) globalConfigMock := newMockGlobalConfigRepository(t) - casDiff := getSensitiveDoguConfigEntryDiffForAction("key", "value", cas, domain.ConfigActionSet) spec := &domain.BlueprintSpec{ StateDiff: domain.StateDiff{ - DoguConfigDiffs: map[common.SimpleDoguName]domain.CombinedDoguConfigDiffs{ + SensitiveDoguConfigDiffs: map[common.SimpleDoguName]domain.DoguConfigDiffs{ redmine: { - SensitiveDoguConfigDiff: []domain.SensitiveDoguConfigEntryDiff{ - getSensitiveDoguConfigEntryDiffForAction("key", "value", redmine, domain.ConfigActionSet), - }, + getSensitiveDoguConfigEntryDiffForAction("key", "value", redmine, domain.ConfigActionSet), }, cas: { - SensitiveDoguConfigDiff: []domain.SensitiveDoguConfigEntryDiff{ - casDiff, - }, + getSensitiveDoguConfigEntryDiffForAction("key", "value", cas, domain.ConfigActionSet), }, }, }, @@ -288,7 +279,8 @@ func TestEcosystemConfigUseCase_ApplyConfig(t *testing.T) { spec := &domain.BlueprintSpec{ StateDiff: domain.StateDiff{ - DoguConfigDiffs: map[common.SimpleDoguName]domain.CombinedDoguConfigDiffs{}, + DoguConfigDiffs: map[common.SimpleDoguName]domain.DoguConfigDiffs{}, + SensitiveDoguConfigDiffs: map[common.SimpleDoguName]domain.SensitiveDoguConfigDiffs{}, GlobalConfigDiffs: domain.GlobalConfigDiffs{ getSetGlobalConfigEntryDiff("key", "value"), }, @@ -331,17 +323,13 @@ func TestEcosystemConfigUseCase_applyDoguConfigDiffs(t *testing.T) { t.Run("should save diffs with action set", func(t *testing.T) { // given doguConfigMock := newMockDoguConfigRepository(t) - sensitiveConfigMock := newMockDoguConfigRepository(t) - sut := NewEcosystemConfigUseCase(nil, doguConfigMock, sensitiveConfigMock, nil) diff1 := getSetDoguConfigEntryDiff("key1", "update1", redmine) diff2 := getSetDoguConfigEntryDiff("key2", "update2", redmine) - diff3 := getSetDoguConfigEntryDiff("key3", "update3", redmine) - diff4 := getSetDoguConfigEntryDiff("key4", "update4", redmine) - diffsByDogu := map[common.SimpleDoguName]domain.CombinedDoguConfigDiffs{ + diffsByDogu := map[common.SimpleDoguName]domain.DoguConfigDiffs{ redmine: { - DoguConfigDiff: []domain.DoguConfigEntryDiff{diff1, diff2}, - SensitiveDoguConfigDiff: []domain.DoguConfigEntryDiff{diff3, diff4}, + diff1, + diff2, }, } @@ -349,10 +337,6 @@ func TestEcosystemConfigUseCase_applyDoguConfigDiffs(t *testing.T) { "key1": "val1", "key2": "val2", }) - sensitiveRedmineConfig := config.CreateDoguConfig(redmine, map[config.Key]config.Value{ - "key3": "val3", - "key4": "val4", - }) // do not use redmineConfig here, because there is a bug in the k8s-registry lib // TODO: remove workaround when bug #50007 is fixed @@ -365,32 +349,15 @@ func TestEcosystemConfigUseCase_applyDoguConfigDiffs(t *testing.T) { updatedConfig, err = updatedConfig.Set(diff2.Key.Key, config.Value(diff2.Expected.Value)) require.NoError(t, err) - // do not use redmineConfig here, because there is a bug in the k8s-registry lib - // TODO: remove workaround when bug #50007 is fixed - updatedSensitiveConfig := config.CreateDoguConfig(redmine, map[config.Key]config.Value{ - "key3": "val3", - "key4": "val4", - }).Config - updatedSensitiveConfig, err = updatedSensitiveConfig.Set(diff3.Key.Key, config.Value(diff3.Expected.Value)) - require.NoError(t, err) - updatedSensitiveConfig, err = updatedSensitiveConfig.Set(diff4.Key.Key, config.Value(diff4.Expected.Value)) - require.NoError(t, err) - doguConfigMock.EXPECT(). GetAllExisting(testCtx, []common.SimpleDoguName{redmine}). Return(map[config.SimpleDoguName]config.DoguConfig{redmine: redmineConfig}, nil) doguConfigMock.EXPECT(). UpdateOrCreate(testCtx, config.DoguConfig{DoguName: redmine, Config: updatedConfig}). Return(config.DoguConfig{}, nil) - sensitiveConfigMock.EXPECT(). - GetAllExisting(testCtx, []common.SimpleDoguName{redmine}). - Return(map[config.SimpleDoguName]config.DoguConfig{redmine: sensitiveRedmineConfig}, nil) - sensitiveConfigMock.EXPECT(). - UpdateOrCreate(testCtx, config.DoguConfig{DoguName: redmine, Config: updatedSensitiveConfig}). - Return(config.DoguConfig{}, nil) // when - err = sut.applyDoguConfigDiffs(testCtx, diffsByDogu) + err = applyDoguConfigDiffs(testCtx, doguConfigMock, diffsByDogu) // then require.NoError(t, err) @@ -399,12 +366,10 @@ func TestEcosystemConfigUseCase_applyDoguConfigDiffs(t *testing.T) { t.Run("should delete diffs with action remove", func(t *testing.T) { // given doguConfigMock := newMockDoguConfigRepository(t) - sensitiveConfigMock := newMockDoguConfigRepository(t) - sut := NewEcosystemConfigUseCase(nil, doguConfigMock, sensitiveConfigMock, nil) diff1 := getRemoveDoguConfigEntryDiff("key1", redmine) diff2 := getRemoveDoguConfigEntryDiff("key2", redmine) - diffsByDogu := map[common.SimpleDoguName]domain.CombinedDoguConfigDiffs{ - redmine: {DoguConfigDiff: []domain.DoguConfigEntryDiff{diff1, diff2}}, + diffsByDogu := map[common.SimpleDoguName]domain.DoguConfigDiffs{ + redmine: {diff1, diff2}, } redmineConfig := config.CreateDoguConfig(redmine, map[config.Key]config.Value{ @@ -425,12 +390,9 @@ func TestEcosystemConfigUseCase_applyDoguConfigDiffs(t *testing.T) { doguConfigMock.EXPECT(). UpdateOrCreate(testCtx, config.DoguConfig{DoguName: redmine, Config: updatedConfig}). Return(config.DoguConfig{}, nil) - sensitiveConfigMock.EXPECT(). - GetAllExisting(testCtx, emptyDoguList). - Return(map[config.SimpleDoguName]config.DoguConfig{}, nil) // when - err := sut.applyDoguConfigDiffs(testCtx, diffsByDogu) + err := applyDoguConfigDiffs(testCtx, doguConfigMock, diffsByDogu) // then require.NoError(t, err) @@ -439,24 +401,19 @@ func TestEcosystemConfigUseCase_applyDoguConfigDiffs(t *testing.T) { t.Run("should apply nothing on action none", func(t *testing.T) { // given doguConfigMock := newMockDoguConfigRepository(t) - sensitiveConfigMock := newMockDoguConfigRepository(t) - sut := NewEcosystemConfigUseCase(nil, doguConfigMock, sensitiveConfigMock, nil) diff1 := domain.DoguConfigEntryDiff{ NeededAction: domain.ConfigActionNone, } - diffsByDogu := map[common.SimpleDoguName]domain.CombinedDoguConfigDiffs{ - redmine: {DoguConfigDiff: []domain.DoguConfigEntryDiff{diff1}}, + diffsByDogu := map[common.SimpleDoguName]domain.DoguConfigDiffs{ + redmine: {diff1}, } doguConfigMock.EXPECT(). GetAllExisting(testCtx, emptyDoguList). Return(map[config.SimpleDoguName]config.DoguConfig{}, nil) - sensitiveConfigMock.EXPECT(). - GetAllExisting(testCtx, emptyDoguList). - Return(map[config.SimpleDoguName]config.DoguConfig{}, nil) // when - err := sut.applyDoguConfigDiffs(testCtx, diffsByDogu) + err := applyDoguConfigDiffs(testCtx, doguConfigMock, diffsByDogu) // then require.NoError(t, err) @@ -465,11 +422,9 @@ func TestEcosystemConfigUseCase_applyDoguConfigDiffs(t *testing.T) { t.Run("err when GetAllExisting fails", func(t *testing.T) { // given doguConfigMock := newMockDoguConfigRepository(t) - sensitiveConfigMock := newMockDoguConfigRepository(t) - sut := NewEcosystemConfigUseCase(nil, doguConfigMock, sensitiveConfigMock, nil) diff1 := getSetDoguConfigEntryDiff("key1", "value", redmine) - diffsByDogu := map[common.SimpleDoguName]domain.CombinedDoguConfigDiffs{ - redmine: {DoguConfigDiff: []domain.DoguConfigEntryDiff{diff1}}, + diffsByDogu := map[common.SimpleDoguName]domain.DoguConfigDiffs{ + redmine: {diff1}, } expectedError := liberrors.NewConnectionError(assert.AnError) @@ -478,7 +433,7 @@ func TestEcosystemConfigUseCase_applyDoguConfigDiffs(t *testing.T) { Return(map[config.SimpleDoguName]config.DoguConfig{}, expectedError) // when - err := sut.applyDoguConfigDiffs(testCtx, diffsByDogu) + err := applyDoguConfigDiffs(testCtx, doguConfigMock, diffsByDogu) // then require.Error(t, err) @@ -488,11 +443,9 @@ func TestEcosystemConfigUseCase_applyDoguConfigDiffs(t *testing.T) { t.Run("error while applying key", func(t *testing.T) { // given doguConfigMock := newMockDoguConfigRepository(t) - sensitiveConfigMock := newMockDoguConfigRepository(t) - sut := NewEcosystemConfigUseCase(nil, doguConfigMock, sensitiveConfigMock, nil) diff1 := getSetDoguConfigEntryDiff("key1/key1_1", "value", redmine) - diffsByDogu := map[common.SimpleDoguName]domain.CombinedDoguConfigDiffs{ - redmine: {DoguConfigDiff: []domain.DoguConfigEntryDiff{diff1}}, + diffsByDogu := map[common.SimpleDoguName]domain.DoguConfigDiffs{ + redmine: {diff1}, } redmineConfig := config.CreateDoguConfig(redmine, map[config.Key]config.Value{ @@ -505,7 +458,7 @@ func TestEcosystemConfigUseCase_applyDoguConfigDiffs(t *testing.T) { Return(map[config.SimpleDoguName]config.DoguConfig{redmine: redmineConfig}, nil) // when - err := sut.applyDoguConfigDiffs(testCtx, diffsByDogu) + err := applyDoguConfigDiffs(testCtx, doguConfigMock, diffsByDogu) // then assert.Error(t, err, "should throw an error when trying to create a sub key for an existing key") diff --git a/pkg/application/stateDiffUseCase_test.go b/pkg/application/stateDiffUseCase_test.go index 945a8176..d030df5b 100644 --- a/pkg/application/stateDiffUseCase_test.go +++ b/pkg/application/stateDiffUseCase_test.go @@ -555,23 +555,20 @@ func TestStateDiffUseCase_DetermineStateDiff(t *testing.T) { // then require.NoError(t, err) - expectedConfigDiff := map[common.SimpleDoguName]domain.CombinedDoguConfigDiffs{ - "nginx-static": { - DoguConfigDiff: []domain.DoguConfigEntryDiff{ - { - Key: nginxStaticConfigKeyNginxKey1, - Actual: domain.DoguConfigValueState{Value: "val1", Exists: true}, - Expected: domain.DoguConfigValueState{Value: "nginxVal1", Exists: true}, - NeededAction: domain.ConfigActionSet, - }, - { - Key: nginxStaticConfigKeyNginxKey2, - Actual: domain.DoguConfigValueState{Value: "val2", Exists: true}, - Expected: domain.DoguConfigValueState{Value: "", Exists: false}, - NeededAction: domain.ConfigActionRemove, - }, + expectedConfigDiff := map[common.SimpleDoguName]domain.DoguConfigDiffs{ + nginxStatic: { + domain.DoguConfigEntryDiff{ + Key: nginxStaticConfigKeyNginxKey1, + Actual: domain.DoguConfigValueState{Value: "val1", Exists: true}, + Expected: domain.DoguConfigValueState{Value: "nginxVal1", Exists: true}, + NeededAction: domain.ConfigActionSet, + }, + domain.DoguConfigEntryDiff{ + Key: nginxStaticConfigKeyNginxKey2, + Actual: domain.DoguConfigValueState{Value: "val2", Exists: true}, + Expected: domain.DoguConfigValueState{Value: "", Exists: false}, + NeededAction: domain.ConfigActionRemove, }, - SensitiveDoguConfigDiff: nil, }, } assert.Equal(t, expectedConfigDiff, blueprint.StateDiff.DoguConfigDiffs) @@ -583,8 +580,8 @@ func TestStateDiffUseCase_DetermineStateDiff(t *testing.T) { EffectiveBlueprint: domain.EffectiveBlueprint{ Config: domain.Config{ Dogus: map[common.SimpleDoguName]domain.CombinedDoguConfig{ - nginxStaticQualifiedDoguName.SimpleName: { - DoguName: nginxStaticQualifiedDoguName.SimpleName, + nginxStatic: { + DoguName: nginxStatic, SensitiveConfig: domain.SensitiveDoguConfig{ Present: map[common.SensitiveDoguConfigKey]common.SensitiveDoguConfigValue{ nginxStaticSensitiveConfigKeyNginxKey1: "nginxVal1", @@ -642,25 +639,23 @@ func TestStateDiffUseCase_DetermineStateDiff(t *testing.T) { // then require.NoError(t, err) - expectedConfigDiff := map[common.SimpleDoguName]domain.CombinedDoguConfigDiffs{ - "nginx-static": { - SensitiveDoguConfigDiff: []domain.SensitiveDoguConfigEntryDiff{ - { - Key: nginxStaticSensitiveConfigKeyNginxKey1, - Actual: domain.DoguConfigValueState{Value: "val1", Exists: true}, - Expected: domain.DoguConfigValueState{Value: "nginxVal1", Exists: true}, - NeededAction: domain.ConfigActionSet, - }, - { - Key: nginxStaticSensitiveConfigKeyNginxKey2, - Actual: domain.DoguConfigValueState{Value: "val2", Exists: true}, - Expected: domain.DoguConfigValueState{Value: "", Exists: false}, - NeededAction: domain.ConfigActionRemove, - }, + expectedConfigDiff := map[common.SimpleDoguName]domain.DoguConfigDiffs{ + nginxStatic: { + { + Key: nginxStaticSensitiveConfigKeyNginxKey1, + Actual: domain.DoguConfigValueState{Value: "val1", Exists: true}, + Expected: domain.DoguConfigValueState{Value: "nginxVal1", Exists: true}, + NeededAction: domain.ConfigActionSet, + }, + { + Key: nginxStaticSensitiveConfigKeyNginxKey2, + Actual: domain.DoguConfigValueState{Value: "val2", Exists: true}, + Expected: domain.DoguConfigValueState{Value: "", Exists: false}, + NeededAction: domain.ConfigActionRemove, }, }, } - assert.Equal(t, expectedConfigDiff, blueprint.StateDiff.DoguConfigDiffs) + assert.Equal(t, expectedConfigDiff, blueprint.StateDiff.SensitiveDoguConfigDiffs) }) } diff --git a/pkg/domain/stateDiffConfig.go b/pkg/domain/stateDiffConfig.go index 0fa24b28..59180232 100644 --- a/pkg/domain/stateDiffConfig.go +++ b/pkg/domain/stateDiffConfig.go @@ -48,7 +48,7 @@ func determineConfigDiffs( GlobalConfigDiffs, ) { return determineDogusConfigDiffs(blueprintConfig.Dogus, configByDogu), - determineDogusConfigDiffs(blueprintConfig.Dogus, SensitiveConfigByDogu), + determineSensitiveDogusConfigDiffs(blueprintConfig.Dogus, SensitiveConfigByDogu), determineGlobalConfigDiffs(blueprintConfig.Global, globalConfig) } @@ -63,6 +63,17 @@ func determineDogusConfigDiffs( return diffsPerDogu } +func determineSensitiveDogusConfigDiffs( + combinedDoguConfigs map[common.SimpleDoguName]CombinedDoguConfig, + configByDogu map[common.SimpleDoguName]config.DoguConfig, +) map[common.SimpleDoguName]DoguConfigDiffs { + diffsPerDogu := map[common.SimpleDoguName]DoguConfigDiffs{} + for doguName, combinedDoguConfig := range combinedDoguConfigs { + diffsPerDogu[doguName] = determineDoguConfigDiffs(combinedDoguConfig.SensitiveConfig, configByDogu) + } + return diffsPerDogu +} + func getNeededConfigAction(expected ConfigValueState, actual ConfigValueState) ConfigAction { if expected == actual { return ConfigActionNone