From b0901c0badf946cf8ac136ad29a1ed606f0b1af4 Mon Sep 17 00:00:00 2001 From: Alexander Dammeier Date: Tue, 15 Oct 2024 13:39:26 +0200 Subject: [PATCH] #81 implement repos for dogu config --- .../config/kubernetes/doguConfigRepository.go | 25 ++++++++----- .../config/kubernetes/errorhandling.go | 2 +- .../config/kubernetes/errorhandling_test.go | 36 +++++++++++++++++++ .../sensitiveDoguConfigRepository.go | 25 ++++++++----- 4 files changed, 69 insertions(+), 19 deletions(-) create mode 100644 pkg/adapter/config/kubernetes/errorhandling_test.go diff --git a/pkg/adapter/config/kubernetes/doguConfigRepository.go b/pkg/adapter/config/kubernetes/doguConfigRepository.go index a4b0f81..ecf10d0 100644 --- a/pkg/adapter/config/kubernetes/doguConfigRepository.go +++ b/pkg/adapter/config/kubernetes/doguConfigRepository.go @@ -2,8 +2,8 @@ package kubernetes import ( "context" + "fmt" "github.com/cloudogu/k8s-blueprint-operator/pkg/domain/common" - "github.com/cloudogu/k8s-blueprint-operator/pkg/domainservice" "github.com/cloudogu/k8s-registry-lib/config" "github.com/cloudogu/k8s-registry-lib/repository" ) @@ -13,8 +13,15 @@ type DoguConfigRepository struct { } func (e DoguConfigRepository) GetAll(ctx context.Context, doguNames []common.SimpleDoguName) (map[common.SimpleDoguName]config.DoguConfig, error) { - //TODO implement me - panic("implement me") + var configByDogus map[common.SimpleDoguName]config.DoguConfig + for _, doguName := range doguNames { + loaded, err := e.Get(ctx, doguName) + if err != nil { + return nil, fmt.Errorf("could not load config for all given dogus: %w", err) + } + configByDogus[doguName] = loaded + } + return configByDogus, nil } func NewDoguConfigRepository(repo repository.DoguConfigRepository) *DoguConfigRepository { @@ -22,17 +29,17 @@ func NewDoguConfigRepository(repo repository.DoguConfigRepository) *DoguConfigRe } func (e DoguConfigRepository) Get(ctx context.Context, doguName common.SimpleDoguName) (config.DoguConfig, error) { - // TODO: There seems to be no way to know, if we have a NotFoundError or a connection error. - return e.repo.Get(ctx, doguName) + loadedConfig, err := e.repo.Get(ctx, doguName) + if err != nil { + return loadedConfig, fmt.Errorf("could not load dogu config: %w", mapToBlueprintError(err)) + } + return loadedConfig, nil } func (e DoguConfigRepository) Update(ctx context.Context, config config.DoguConfig) (config.DoguConfig, error) { updatedConfig, err := e.repo.Update(ctx, config) - // TODO: we cannot see here, if there is a real conflict or there was a connection error. - // With a conflict, we can immediately restart the business process - // With an connection error we need a longer backoff (internalError) if err != nil { - return config, domainservice.NewInternalError(err, "failed to update config for %s", config.DoguName) + return updatedConfig, fmt.Errorf("could not update dogu config: %w", mapToBlueprintError(err)) } return updatedConfig, nil } diff --git a/pkg/adapter/config/kubernetes/errorhandling.go b/pkg/adapter/config/kubernetes/errorhandling.go index 735ed6b..80fa767 100644 --- a/pkg/adapter/config/kubernetes/errorhandling.go +++ b/pkg/adapter/config/kubernetes/errorhandling.go @@ -14,7 +14,7 @@ func mapToBlueprintError(err error) error { } else if liberrors.IsConnectionError(err) { return domainservice.NewInternalError(err, "could not load/update config due to connection problems") } else if liberrors.IsAlreadyExistsError(err) { - return domainservice.NewInternalError(err, "could not create config as it already exists") + return domainservice.NewConflictError(err, "could not create config as it already exists") } else { // GenericError and fallback if even that would not match the error return domainservice.NewInternalError(err, "could not load/update config due to an unknown problem") diff --git a/pkg/adapter/config/kubernetes/errorhandling_test.go b/pkg/adapter/config/kubernetes/errorhandling_test.go new file mode 100644 index 0000000..919a5be --- /dev/null +++ b/pkg/adapter/config/kubernetes/errorhandling_test.go @@ -0,0 +1,36 @@ +package kubernetes + +import ( + "fmt" + "github.com/cloudogu/k8s-blueprint-operator/pkg/domainservice" + liberrors "github.com/cloudogu/k8s-registry-lib/errors" + "github.com/stretchr/testify/assert" + "testing" +) + +func Test_mapToBlueprintError(t *testing.T) { + tests := []struct { + name string + givenError error + errTypeAssert func(err error) bool + }{ + {"no error", nil, nil}, + {"connectionError", liberrors.NewConnectionError(assert.AnError), domainservice.IsInternalError}, + {"notFoundError", liberrors.NewNotFoundError(assert.AnError), domainservice.IsNotFoundError}, + {"conflictError", liberrors.NewConflictError(assert.AnError), domainservice.IsConflictError}, + {"alreadyExistsError", liberrors.NewAlreadyExistsError(assert.AnError), domainservice.IsConflictError}, + {"genericError", liberrors.NewGenericError(assert.AnError), domainservice.IsInternalError}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + testString := fmt.Sprintf("mapToBlueprintError(%v)", tt.givenError) + resultError := mapToBlueprintError(tt.givenError) + if tt.givenError != nil { + assert.ErrorContains(t, resultError, tt.givenError.Error(), testString) + } + if tt.errTypeAssert != nil { + assert.True(t, tt.errTypeAssert(resultError), testString) + } + }) + } +} diff --git a/pkg/adapter/config/kubernetes/sensitiveDoguConfigRepository.go b/pkg/adapter/config/kubernetes/sensitiveDoguConfigRepository.go index a2963e5..d66a509 100644 --- a/pkg/adapter/config/kubernetes/sensitiveDoguConfigRepository.go +++ b/pkg/adapter/config/kubernetes/sensitiveDoguConfigRepository.go @@ -2,8 +2,8 @@ package kubernetes import ( "context" + "fmt" "github.com/cloudogu/k8s-blueprint-operator/pkg/domain/common" - "github.com/cloudogu/k8s-blueprint-operator/pkg/domainservice" "github.com/cloudogu/k8s-registry-lib/config" "github.com/cloudogu/k8s-registry-lib/repository" ) @@ -13,8 +13,15 @@ type SensitiveDoguConfigRepository struct { } func (e SensitiveDoguConfigRepository) GetAll(ctx context.Context, doguNames []common.SimpleDoguName) (map[common.SimpleDoguName]config.DoguConfig, error) { - //TODO implement me - panic("implement me") + var configByDogus map[common.SimpleDoguName]config.DoguConfig + for _, doguName := range doguNames { + loaded, err := e.Get(ctx, doguName) + if err != nil { + return nil, fmt.Errorf("could not load sensitive config for all given dogus: %w", err) + } + configByDogus[doguName] = loaded + } + return configByDogus, nil } func NewSensitiveDoguConfigRepository(repo repository.DoguConfigRepository) *SensitiveDoguConfigRepository { @@ -22,17 +29,17 @@ func NewSensitiveDoguConfigRepository(repo repository.DoguConfigRepository) *Sen } func (e SensitiveDoguConfigRepository) Get(ctx context.Context, doguName common.SimpleDoguName) (config.DoguConfig, error) { - // TODO: There seems to be no way to know, if we have a NotFoundError or a connection error. - return e.repo.Get(ctx, doguName) + loadedConfig, err := e.repo.Get(ctx, doguName) + if err != nil { + return loadedConfig, fmt.Errorf("could not load sensitive dogu config: %w", mapToBlueprintError(err)) + } + return loadedConfig, nil } func (e SensitiveDoguConfigRepository) Update(ctx context.Context, config config.DoguConfig) (config.DoguConfig, error) { updatedConfig, err := e.repo.Update(ctx, config) - // TODO: we cannot see here, if there is a real conflict or there was a connection error. - // With a conflict, we can immediately restart the business process - // With an connection error we need a longer backoff (internalError) if err != nil { - return config, domainservice.NewInternalError(err, "failed to update sensitive config for %s", config.DoguName) + return updatedConfig, fmt.Errorf("could not update sensitive dogu config: %w", mapToBlueprintError(err)) } return updatedConfig, nil }