diff --git a/cmd/env/delete.go b/cmd/env/delete.go index 9e89114354..cbeb811af7 100644 --- a/cmd/env/delete.go +++ b/cmd/env/delete.go @@ -2,11 +2,10 @@ package env import ( "context" - "errors" "fmt" - "slices" "github.com/devsy-org/devsy/cmd/flags" + "github.com/devsy-org/devsy/cmd/internal/managedvalue" "github.com/devsy-org/devsy/pkg/config" "github.com/devsy-org/devsy/pkg/log" "github.com/devsy-org/devsy/pkg/secrets" @@ -77,48 +76,9 @@ type deleteEnvRequest struct { save func(*config.Config) error } -type removedEnvBinding struct { - attached bool - index int -} - func deleteEnvironmentValue(request deleteEnvRequest) error { - devsyConfig := request.config - store := request.store - contextName := request.context - name := request.name - saveConfig := request.save - var binding removedEnvBinding - if ctxConfig := devsyConfig.Contexts[contextName]; ctxConfig != nil { - if idx := slices.Index(ctxConfig.EnvVars, name); idx >= 0 { - binding = removedEnvBinding{attached: true, index: idx} - ctxConfig.EnvVars = slices.Delete(ctxConfig.EnvVars, idx, idx+1) - if err := saveConfig(devsyConfig); err != nil { - return err - } - } - } - - deleteErr := store.Delete(contextName, name) - if deleteErr == nil || !binding.attached { - return deleteErr - } - - if _, err := store.Get(contextName, name); err != nil { - return deleteErr - } - - ctxConfig := devsyConfig.Contexts[contextName] - ctxConfig.EnvVars = append(ctxConfig.EnvVars, "") - copy(ctxConfig.EnvVars[binding.index+1:], ctxConfig.EnvVars[binding.index:]) - ctxConfig.EnvVars[binding.index] = name - if rollbackErr := saveConfig(devsyConfig); rollbackErr != nil { - rollbackMessage := "restore environment variable attachment after failed delete: %w" - return errors.Join( - deleteErr, - fmt.Errorf(rollbackMessage, rollbackErr), - ) - } - - return deleteErr + return managedvalue.Delete(managedvalue.DeleteRequest{ + Config: request.config, Store: request.store, Context: request.context, + Name: request.name, Binding: managedvalue.EnvBinding, Save: request.save, + }) } diff --git a/cmd/env/delete_test.go b/cmd/env/delete_test.go index 7109c928bf..45dfb57889 100644 --- a/cmd/env/delete_test.go +++ b/cmd/env/delete_test.go @@ -9,119 +9,43 @@ import ( "github.com/stretchr/testify/require" ) -type deleteTestStore struct { - value string - deleteErr error - getErr error -} +type deleteTestStore struct{ deleteErr error } const ( - deleteEnvName = "FOO" - deleteTestValue = "delete-value" + firstBinding = "FIRST" + lastBinding = "LAST" ) -func (s *deleteTestStore) Set(string, string, string, secrets.Kind) error { return nil } -func (s *deleteTestStore) Get(string, string) (string, error) { - if s.getErr != nil { - return "", s.getErr - } - return s.value, nil +func (*deleteTestStore) Set(string, string, string, secrets.Kind) error { return nil } +func (*deleteTestStore) Get(string, string) (string, error) { + panic("delete rollback must not call Get") } -func (s *deleteTestStore) Meta(string, string) (secrets.SecretMeta, error) { +func (*deleteTestStore) Meta(string, string) (secrets.SecretMeta, error) { return secrets.SecretMeta{}, nil } +func (*deleteTestStore) List(string) ([]secrets.SecretMeta, error) { return nil, nil } +func (s *deleteTestStore) Delete(string, string) error { return s.deleteErr } -func (s *deleteTestStore) List(string) ([]secrets.SecretMeta, error) { return nil, nil } -func (s *deleteTestStore) Delete(string, string) error { return s.deleteErr } - -func TestDeleteEnvironmentValueRestoresAttachedBindingWhenDeleteFails(t *testing.T) { - cfg := deleteTestConfig([]string{"DELETE_FIRST", deleteEnvName, "DELETE_LAST"}) - deleteErr := errors.New("delete failed") - store := &deleteTestStore{value: deleteTestValue, deleteErr: deleteErr} - - err := deleteEnvironmentValue(deleteEnvRequest{ - config: cfg, - store: store, - context: config.DefaultContext, - name: deleteEnvName, - save: func(*config.Config) error { - return nil - }, - }) - - require.ErrorIs(t, err, deleteErr) - require.Equal(t, []string{"DELETE_FIRST", deleteEnvName, "DELETE_LAST"}, cfg.Current().EnvVars) -} - -func TestDeleteEnvironmentValueLeavesBindingRemovedWhenValueUnavailable(t *testing.T) { - cfg := deleteTestConfig([]string{deleteEnvName}) - deleteErr := errors.New("delete failed") - store := &deleteTestStore{deleteErr: deleteErr, getErr: secrets.ErrSecretNotFound} - - err := deleteEnvironmentValue(deleteEnvRequest{ - config: cfg, - store: store, - context: config.DefaultContext, - name: deleteEnvName, - save: func(*config.Config) error { - return nil +func TestDeleteEnvironmentValueRestoresPersistedAttachmentAfterOrdinaryFailure(t *testing.T) { + config.ResetPathManager() + t.Cleanup(config.ResetPathManager) + t.Setenv(config.EnvHome, t.TempDir()) + const name = "LOG_LEVEL" + cfg := &config.Config{ + DefaultContext: config.DefaultContext, + Contexts: map[string]*config.ContextConfig{ + config.DefaultContext: {EnvVars: []string{firstBinding, name, lastBinding}}, }, - }) - - require.ErrorIs(t, err, deleteErr) - require.Empty(t, cfg.Current().EnvVars) -} - -func TestDeleteEnvironmentValueJoinsRollbackFailure(t *testing.T) { - cfg := deleteTestConfig([]string{deleteEnvName}) + } + require.NoError(t, config.SaveConfig(cfg)) deleteErr := errors.New("delete failed") - rollbackErr := errors.New("rollback failed") - store := &deleteTestStore{value: deleteTestValue, deleteErr: deleteErr} - saves := 0 - err := deleteEnvironmentValue(deleteEnvRequest{ - config: cfg, - store: store, - context: config.DefaultContext, - name: deleteEnvName, - save: func(*config.Config) error { - saves++ - if saves == 2 { - return rollbackErr - } - return nil - }, + config: cfg, store: &deleteTestStore{deleteErr: deleteErr}, context: config.DefaultContext, + name: name, save: config.SaveConfig, }) - require.ErrorIs(t, err, deleteErr) - require.ErrorIs(t, err, rollbackErr) - require.Equal(t, []string{deleteEnvName}, cfg.Current().EnvVars) -} - -func TestDeleteEnvironmentValueDoesNotSaveForUnattachedValue(t *testing.T) { - cfg := deleteTestConfig(nil) - saves := 0 - store := &deleteTestStore{value: deleteTestValue} - - require.NoError(t, deleteEnvironmentValue(deleteEnvRequest{ - config: cfg, - store: store, - context: config.DefaultContext, - name: deleteEnvName, - save: func(*config.Config) error { - saves++ - return nil - }, - })) - require.Zero(t, saves) -} - -func deleteTestConfig(envVars []string) *config.Config { - return &config.Config{ - DefaultContext: config.DefaultContext, - Contexts: map[string]*config.ContextConfig{ - config.DefaultContext: {EnvVars: envVars}, - }, - } + reloaded, loadErr := config.LoadConfig("", "") + require.NoError(t, loadErr) + require.Equal(t, []string{firstBinding, name, lastBinding}, reloaded.Current().EnvVars) } diff --git a/cmd/internal/managedvalue/delete.go b/cmd/internal/managedvalue/delete.go new file mode 100644 index 0000000000..2367de593b --- /dev/null +++ b/cmd/internal/managedvalue/delete.go @@ -0,0 +1,187 @@ +package managedvalue + +import ( + "errors" + "fmt" + "slices" + + "github.com/devsy-org/devsy/pkg/config" + "github.com/devsy-org/devsy/pkg/secrets" +) + +type BindingKind uint8 + +const ( + EnvBinding BindingKind = iota + SecretBinding +) + +type DeleteRequest struct { + Config *config.Config + Store secrets.Store + Context string + Name string + Binding BindingKind + Save func(*config.Config) error +} + +type ConsistencyError struct { + Context string + Name string + Binding BindingKind + Phase string + Cause error + Rollback error +} + +func (e *ConsistencyError) Error() string { + kind := e.bindingName() + switch e.Phase { + case "store-indeterminate": + return fmt.Sprintf( + "could not complete deletion of %s %q in context %q: "+ + "the store outcome is indeterminate and the context attachment is detached; "+ + "restore backend access, verify the value, then attach it again or retry deletion", + kind, e.Name, e.Context, + ) + case "config-rollback": + return fmt.Sprintf( + "could not restore the %s attachment for %q in context %q: "+ + "the stored value was preserved but config.yaml remains detached; "+ + "repair config persistence, then attach the value again or retry deletion", + kind, e.Name, e.Context, + ) + default: + return fmt.Sprintf( + "could not complete deletion of %s %q in context %q", + kind, e.Name, e.Context, + ) + } +} + +func (e *ConsistencyError) Unwrap() []error { + return []error{e.Cause, e.Rollback} +} + +func (e *ConsistencyError) bindingName() string { + if e.Binding == SecretBinding { + return "secret" + } + return "environment variable" +} + +type removedBinding struct { + attached bool + index int +} + +func Delete(request DeleteRequest) error { + if request.Config == nil || request.Store == nil { + return errors.New("managed value delete requires config and store") + } + if request.Save == nil { + request.Save = config.SaveConfig + } + + ctxConfig := request.Config.Contexts[request.Context] + removed, err := persistDetachedBinding(request, ctxConfig) + if err != nil { + return err + } + + if err := request.Store.Delete(request.Context, request.Name); err != nil { + return compensateAttachment(request, ctxConfig, removed, err) + } + return nil +} + +func persistDetachedBinding( + request DeleteRequest, + ctxConfig *config.ContextConfig, +) (removedBinding, error) { + removed := removeBinding(ctxConfig, request.Binding, request.Name) + if !removed.attached { + return removed, nil + } + if err := request.Save(request.Config); err != nil { + restoreBinding(ctxConfig, request.Binding, request.Name, removed) + return removedBinding{}, err + } + return removed, nil +} + +func compensateAttachment( + request DeleteRequest, + ctxConfig *config.ContextConfig, + removed removedBinding, + deleteErr error, +) error { + if !removed.attached { + return deleteErr + } + if errors.Is(deleteErr, secrets.ErrStateIndeterminate) { + return &ConsistencyError{ + Context: request.Context, + Name: request.Name, + Binding: request.Binding, + Phase: "store-indeterminate", + Cause: deleteErr, + } + } + + restoreBinding(ctxConfig, request.Binding, request.Name, removed) + return persistRestoredBinding(request, deleteErr) +} + +func persistRestoredBinding(request DeleteRequest, deleteErr error) error { + if err := request.Save(request.Config); err != nil { + return &ConsistencyError{ + Context: request.Context, + Name: request.Name, + Binding: request.Binding, + Phase: "config-rollback", + Cause: deleteErr, + Rollback: err, + } + } + return deleteErr +} + +func removeBinding(ctxConfig *config.ContextConfig, kind BindingKind, name string) removedBinding { + if ctxConfig == nil { + return removedBinding{} + } + bindings := bindingsFor(ctxConfig, kind) + index := slices.Index(*bindings, name) + if index < 0 { + return removedBinding{} + } + *bindings = slices.Delete(*bindings, index, index+1) + return removedBinding{attached: true, index: index} +} + +func restoreBinding( + ctxConfig *config.ContextConfig, + kind BindingKind, + name string, + removed removedBinding, +) { + if ctxConfig == nil || !removed.attached { + return + } + bindings := bindingsFor(ctxConfig, kind) + if slices.Contains(*bindings, name) { + return + } + index := min(removed.index, len(*bindings)) + *bindings = append(*bindings, "") + copy((*bindings)[index+1:], (*bindings)[index:]) + (*bindings)[index] = name +} + +func bindingsFor(ctxConfig *config.ContextConfig, kind BindingKind) *[]string { + if kind == SecretBinding { + return &ctxConfig.Secrets + } + return &ctxConfig.EnvVars +} diff --git a/cmd/internal/managedvalue/delete_test.go b/cmd/internal/managedvalue/delete_test.go new file mode 100644 index 0000000000..5888f5cdb2 --- /dev/null +++ b/cmd/internal/managedvalue/delete_test.go @@ -0,0 +1,173 @@ +package managedvalue + +import ( + "errors" + "testing" + + "github.com/devsy-org/devsy/pkg/config" + "github.com/devsy-org/devsy/pkg/secrets" + "github.com/stretchr/testify/require" +) + +type testStore struct { + deleteErr error + deleteCalls int + getCalls int +} + +const testManagedValueName = "VALUE" + +func (*testStore) Set(_, _, _ string, _ secrets.Kind) error { return nil } +func (s *testStore) Get(string, string) (string, error) { + s.getCalls++ + return "", nil +} + +func (*testStore) Meta(string, string) (secrets.SecretMeta, error) { + return secrets.SecretMeta{}, nil +} + +func (*testStore) List(string) ([]secrets.SecretMeta, error) { + return nil, nil +} + +func (s *testStore) Delete(string, string) error { + s.deleteCalls++ + return s.deleteErr +} + +func TestDeleteRestoresAttachmentAfterOrdinaryStoreFailure(t *testing.T) { + for _, binding := range []BindingKind{EnvBinding, SecretBinding} { + t.Run(bindingName(binding), func(t *testing.T) { + cfg := testConfig(binding, []string{"BEFORE", testManagedValueName, "AFTER"}) + store := &testStore{deleteErr: errors.New("delete failed")} + saves := 0 + err := Delete(DeleteRequest{ + Config: cfg, + Store: store, + Context: config.DefaultContext, + Name: testManagedValueName, + Binding: binding, + Save: func(*config.Config) error { saves++; return nil }, + }) + require.ErrorIs(t, err, store.deleteErr) + require.Equal( + t, + []string{"BEFORE", testManagedValueName, "AFTER"}, + bindingValues(cfg, binding), + ) + require.Equal(t, 2, saves) + require.Zero(t, store.getCalls) + }) + } +} + +func TestDeleteIndeterminateStoreFailureLeavesAttachmentDetached(t *testing.T) { + store := &testStore{deleteErr: &secrets.MutationError{ + Operation: "delete", Context: config.DefaultContext, Name: testManagedValueName, + Cause: errors.New("remove failed"), Rollback: errors.New("restore failed"), + }} + cfg := testConfig(SecretBinding, []string{testManagedValueName}) + err := Delete(DeleteRequest{ + Config: cfg, + Store: store, + Context: config.DefaultContext, + Name: testManagedValueName, + Binding: SecretBinding, + Save: func(*config.Config) error { return nil }, + }) + var consistencyErr *ConsistencyError + require.ErrorAs(t, err, &consistencyErr) + require.Equal(t, "store-indeterminate", consistencyErr.Phase) + require.Empty(t, cfg.Current().Secrets) + require.Zero(t, store.getCalls) + require.NotContains(t, err.Error(), "secret payload") +} + +func TestDeleteRollbackSaveFailureReportsKnownSplitState(t *testing.T) { + store := &testStore{deleteErr: errors.New("delete failed")} + rollbackErr := errors.New("config write failed") + cfg := testConfig(SecretBinding, []string{testManagedValueName}) + saves := 0 + err := Delete(DeleteRequest{ + Config: cfg, + Store: store, + Context: config.DefaultContext, + Name: testManagedValueName, + Binding: SecretBinding, + Save: func(*config.Config) error { + saves++ + if saves == 2 { + return rollbackErr + } + return nil + }, + }) + var consistencyErr *ConsistencyError + require.ErrorAs(t, err, &consistencyErr) + require.ErrorIs(t, err, store.deleteErr) + require.ErrorIs(t, err, rollbackErr) + require.Equal(t, "config-rollback", consistencyErr.Phase) + require.Equal(t, []string{testManagedValueName}, cfg.Current().Secrets) + require.NotContains(t, err.Error(), "secret payload") + require.Zero(t, store.getCalls) +} + +func TestDeleteInitialSaveFailureRestoresMemoryAndSkipsStore(t *testing.T) { + cfg := testConfig(EnvBinding, []string{testManagedValueName}) + store := &testStore{} + saveErr := errors.New("config write failed") + err := Delete(DeleteRequest{ + Config: cfg, + Store: store, + Context: config.DefaultContext, + Name: testManagedValueName, + Binding: EnvBinding, + Save: func(*config.Config) error { return saveErr }, + }) + require.ErrorIs(t, err, saveErr) + require.Equal(t, []string{testManagedValueName}, cfg.Current().EnvVars) + require.Zero(t, store.deleteCalls) +} + +func TestDeleteUnattachedDoesNotSaveConfig(t *testing.T) { + cfg := testConfig(SecretBinding, nil) + store := &testStore{} + saves := 0 + require.NoError(t, Delete(DeleteRequest{ + Config: cfg, + Store: store, + Context: config.DefaultContext, + Name: testManagedValueName, + Binding: SecretBinding, + Save: func(*config.Config) error { saves++; return nil }, + })) + require.Zero(t, saves) +} + +func testConfig(kind BindingKind, values []string) *config.Config { + ctx := &config.ContextConfig{} + if kind == SecretBinding { + ctx.Secrets = values + } else { + ctx.EnvVars = values + } + return &config.Config{ + DefaultContext: config.DefaultContext, + Contexts: map[string]*config.ContextConfig{config.DefaultContext: ctx}, + } +} + +func bindingValues(cfg *config.Config, kind BindingKind) []string { + if kind == SecretBinding { + return cfg.Current().Secrets + } + return cfg.Current().EnvVars +} + +func bindingName(kind BindingKind) string { + if kind == SecretBinding { + return "secret" + } + return "env" +} diff --git a/cmd/secrets/delete.go b/cmd/secrets/delete.go index f60f37c668..82a0dd943f 100644 --- a/cmd/secrets/delete.go +++ b/cmd/secrets/delete.go @@ -2,11 +2,10 @@ package secrets import ( "context" - "errors" "fmt" - "slices" "github.com/devsy-org/devsy/cmd/flags" + "github.com/devsy-org/devsy/cmd/internal/managedvalue" "github.com/devsy-org/devsy/pkg/config" "github.com/devsy-org/devsy/pkg/log" devsysecrets "github.com/devsy-org/devsy/pkg/secrets" @@ -80,47 +79,9 @@ type deleteSecretRequest struct { save func(*config.Config) error } -type removedSecretBinding struct { - attached bool - index int -} - func deleteSecretValue(request deleteSecretRequest) error { - devsyConfig := request.config - store := request.store - contextName := request.context - name := request.name - saveConfig := request.save - var binding removedSecretBinding - if ctxConfig := devsyConfig.Contexts[contextName]; ctxConfig != nil { - if idx := slices.Index(ctxConfig.Secrets, name); idx >= 0 { - binding = removedSecretBinding{attached: true, index: idx} - ctxConfig.Secrets = slices.Delete(ctxConfig.Secrets, idx, idx+1) - if err := saveConfig(devsyConfig); err != nil { - return err - } - } - } - - deleteErr := store.Delete(contextName, name) - if deleteErr == nil || !binding.attached { - return deleteErr - } - - if _, err := store.Get(contextName, name); err != nil { - return deleteErr - } - - ctxConfig := devsyConfig.Contexts[contextName] - ctxConfig.Secrets = append(ctxConfig.Secrets, "") - copy(ctxConfig.Secrets[binding.index+1:], ctxConfig.Secrets[binding.index:]) - ctxConfig.Secrets[binding.index] = name - if rollbackErr := saveConfig(devsyConfig); rollbackErr != nil { - return errors.Join( - deleteErr, - fmt.Errorf("restore secret attachment after failed delete: %w", rollbackErr), - ) - } - - return deleteErr + return managedvalue.Delete(managedvalue.DeleteRequest{ + Config: request.config, Store: request.store, Context: request.context, + Name: request.name, Binding: managedvalue.SecretBinding, Save: request.save, + }) } diff --git a/cmd/secrets/delete_test.go b/cmd/secrets/delete_test.go index 9361d2caa7..8b5ae7d149 100644 --- a/cmd/secrets/delete_test.go +++ b/cmd/secrets/delete_test.go @@ -9,123 +9,50 @@ import ( "github.com/stretchr/testify/require" ) -type deleteTestStore struct { - value string - deleteErr error - getErr error -} +type deleteTestStore struct{ deleteErr error } const ( - deleteSecretName = "DELETE_TOKEN" - deleteTestValue = "delete-value" + firstBinding = "FIRST" + lastBinding = "LAST" ) -func (s *deleteTestStore) Set(string, string, string, devsysecrets.Kind) error { return nil } -func (s *deleteTestStore) Get(string, string) (string, error) { - if s.getErr != nil { - return "", s.getErr - } - return s.value, nil +func (*deleteTestStore) Set(string, string, string, devsysecrets.Kind) error { return nil } +func (*deleteTestStore) Get(string, string) (string, error) { + panic("delete rollback must not call Get") } -func (s *deleteTestStore) Meta(string, string) (devsysecrets.SecretMeta, error) { +func (*deleteTestStore) Meta(string, string) (devsysecrets.SecretMeta, error) { return devsysecrets.SecretMeta{}, nil } +func (*deleteTestStore) List(string) ([]devsysecrets.SecretMeta, error) { return nil, nil } +func (s *deleteTestStore) Delete(string, string) error { return s.deleteErr } -func (s *deleteTestStore) List(string) ([]devsysecrets.SecretMeta, error) { return nil, nil } -func (s *deleteTestStore) Delete(string, string) error { return s.deleteErr } - -func TestDeleteSecretValueRestoresAttachedBindingWhenDeleteFails(t *testing.T) { - cfg := deleteTestConfig([]string{"DELETE_FIRST", deleteSecretName, "DELETE_LAST"}) - deleteErr := errors.New("delete failed") - store := &deleteTestStore{value: deleteTestValue, deleteErr: deleteErr} - - err := deleteSecretValue(deleteSecretRequest{ - config: cfg, - store: store, - context: config.DefaultContext, - name: deleteSecretName, - save: func(*config.Config) error { - return nil - }, - }) - - require.ErrorIs(t, err, deleteErr) - require.Equal( - t, - []string{"DELETE_FIRST", deleteSecretName, "DELETE_LAST"}, - cfg.Current().Secrets, - ) -} - -func TestDeleteSecretValueLeavesBindingRemovedWhenValueUnavailable(t *testing.T) { - cfg := deleteTestConfig([]string{deleteSecretName}) - deleteErr := errors.New("delete failed") - store := &deleteTestStore{deleteErr: deleteErr, getErr: devsysecrets.ErrSecretNotFound} - - err := deleteSecretValue(deleteSecretRequest{ - config: cfg, - store: store, - context: config.DefaultContext, - name: deleteSecretName, - save: func(*config.Config) error { - return nil +func TestDeleteSecretValueRestoresPersistedAttachmentAfterOrdinaryFailure(t *testing.T) { + config.ResetPathManager() + t.Cleanup(config.ResetPathManager) + t.Setenv(config.EnvHome, t.TempDir()) + const name = "DELETE_TOKEN" + cfg := &config.Config{ + DefaultContext: config.DefaultContext, + Contexts: map[string]*config.ContextConfig{ + config.DefaultContext: {Secrets: []string{firstBinding, name, lastBinding}}, }, - }) - - require.ErrorIs(t, err, deleteErr) - require.Empty(t, cfg.Current().Secrets) -} - -func TestDeleteSecretValueJoinsRollbackFailure(t *testing.T) { - cfg := deleteTestConfig([]string{deleteSecretName}) + } + require.NoError(t, config.SaveConfig(cfg)) deleteErr := errors.New("delete failed") - rollbackErr := errors.New("rollback failed") - store := &deleteTestStore{value: deleteTestValue, deleteErr: deleteErr} - saves := 0 - err := deleteSecretValue(deleteSecretRequest{ - config: cfg, - store: store, - context: config.DefaultContext, - name: deleteSecretName, - save: func(*config.Config) error { - saves++ - if saves == 2 { - return rollbackErr - } - return nil - }, + config: cfg, store: &deleteTestStore{deleteErr: deleteErr}, context: config.DefaultContext, + name: name, save: config.SaveConfig, }) - require.ErrorIs(t, err, deleteErr) - require.ErrorIs(t, err, rollbackErr) - require.Equal(t, []string{deleteSecretName}, cfg.Current().Secrets) -} - -func TestDeleteSecretValueDoesNotSaveForUnattachedValue(t *testing.T) { - cfg := deleteTestConfig(nil) - saves := 0 - store := &deleteTestStore{value: deleteTestValue} - - require.NoError(t, deleteSecretValue(deleteSecretRequest{ - config: cfg, - store: store, - context: config.DefaultContext, - name: deleteSecretName, - save: func(*config.Config) error { - saves++ - return nil - }, - })) - require.Zero(t, saves) + reloaded, loadErr := config.LoadConfig("", "") + require.NoError(t, loadErr) + require.Equal(t, []string{firstBinding, name, lastBinding}, reloaded.Current().Secrets) } -func deleteTestConfig(secretsList []string) *config.Config { +func deleteTestConfig(names []string) *config.Config { return &config.Config{ DefaultContext: config.DefaultContext, - Contexts: map[string]*config.ContextConfig{ - config.DefaultContext: {Secrets: secretsList}, - }, + Contexts: map[string]*config.ContextConfig{config.DefaultContext: {Secrets: names}}, } } diff --git a/pkg/secrets/local_store.go b/pkg/secrets/local_store.go index 7af00a5075..406604a90b 100644 --- a/pkg/secrets/local_store.go +++ b/pkg/secrets/local_store.go @@ -32,6 +32,7 @@ type localStore struct { indexPath string now func() time.Time keySource keySource + saveIndex func(*index) error } func NewStoreForConfig(devsyConfig *config.Config) (Store, error) { @@ -83,6 +84,7 @@ func newLocalStoreWithRegistry( backends: backends, indexPath: indexPath, now: time.Now, + saveIndex: func(idx *index) error { return idx.save() }, } } @@ -182,15 +184,131 @@ func (s *localStore) Delete(context, name string) error { return err } s.repairLegacyOwnership(idx) + return deleteIndexEntry(s, idx, context, name) +} + +func deleteIndexEntry(s *localStore, idx *index, context, name string) error { + meta, exists := idx.get(context, name) + if !exists { + return nil + } + if !meta.Sensitive() { + idx.remove(context, name) + return s.saveIndex(idx) + } + return deleteSecretEntry(s, idx, meta) +} + +func deleteSecretEntry(s *localStore, idx *index, meta SecretMeta) error { + context := meta.Context + name := meta.Name + snapshots, err := snapshotSecretValues(s, idx, meta) + if err != nil { + return err + } + if err := removeSnapshots(snapshots); err != nil { + return compensateDelete(context, name, err, snapshots) + } + + idx.remove(context, name) + if err := s.saveIndex(idx); err != nil { + return compensateDelete(context, name, err, snapshots) + } + + return nil +} + +func compensateDelete(context, name string, cause error, snapshots []backendValueSnapshot) error { + if rollbackErr := restoreSnapshots(snapshots); rollbackErr != nil { + return &MutationError{ + Operation: "delete", + Context: context, + Name: name, + Cause: cause, + Rollback: rollbackErr, + } + } + return cause +} + +type backendValueSnapshot struct { + backend backend + key string + value string +} + +func snapshotSecretValues( + s *localStore, + idx *index, + meta SecretMeta, +) ([]backendValueSnapshot, error) { + key := backendKey(meta.Context, meta.Name) + kinds, err := deletionBackendKinds(s, idx, meta, key) + if err != nil { + return nil, err + } + snapshots := make([]backendValueSnapshot, 0, len(kinds)) + for _, kind := range kinds { + b, err := s.backends.Open(kind, idx, false) + if err != nil { + return nil, err + } + value, err := b.get(key) + if errors.Is(err, ErrSecretNotFound) { + continue + } + if err != nil { + return nil, err + } + snapshots = append(snapshots, backendValueSnapshot{backend: b, key: key, value: value}) + } + return snapshots, nil +} + +func deletionBackendKinds( + s *localStore, + idx *index, + meta SecretMeta, + key string, +) ([]Backend, error) { + if meta.Backend != "" { + return []Backend{meta.Backend}, nil + } + + var kinds []Backend + for _, kind := range []Backend{BackendKeyring, BackendFile} { + present, conclusive := s.backends.Probe(kind, idx, key) + if !conclusive { + return nil, fmt.Errorf( + "cannot safely delete unowned secret because secrets backend %q could not be probed; "+ + "restore access to that backend or set the secret again", + kind, + ) + } + if present { + kinds = append(kinds, kind) + } + } + return kinds, nil +} - if meta, ok := idx.get(context, name); ok && meta.Sensitive() { - if err := s.removeSecretValue(idx, meta); err != nil { +func removeSnapshots(snapshots []backendValueSnapshot) error { + for _, snapshot := range snapshots { + if err := snapshot.backend.remove(snapshot.key); err != nil { return err } } - idx.remove(context, name) + return nil +} - return idx.save() +func restoreSnapshots(snapshots []backendValueSnapshot) error { + var rollbackErr error + for _, snapshot := range snapshots { + if err := snapshot.backend.set(snapshot.key, snapshot.value); err != nil { + rollbackErr = errors.Join(rollbackErr, err) + } + } + return rollbackErr } func (s *localStore) Meta(context, name string) (SecretMeta, error) { @@ -394,18 +512,6 @@ func (s *localStore) provenOwner(idx *index, key string) (Backend, bool) { return found[0], true } -func (s *localStore) removeSecretValue(idx *index, meta SecretMeta) error { - key := backendKey(meta.Context, meta.Name) - if meta.Backend == "" { - return s.removeFromProbeableBackends(idx, key) - } - b, err := s.backends.Open(meta.Backend, idx, false) - if err != nil { - return err - } - return b.remove(key) -} - func (s *localStore) removeFromProbeableBackends(idx *index, key string) error { var present []Backend for _, kind := range []Backend{BackendKeyring, BackendFile} { diff --git a/pkg/secrets/store.go b/pkg/secrets/store.go index 8c85271538..dd2ad780ec 100644 --- a/pkg/secrets/store.go +++ b/pkg/secrets/store.go @@ -9,6 +9,27 @@ import ( var ErrSecretNotFound = errors.New("secret not found") +var ErrStateIndeterminate = errors.New("managed value state is indeterminate") + +type MutationError struct { + Operation string + Context string + Name string + Cause error + Rollback error +} + +func (e *MutationError) Error() string { + return fmt.Sprintf( + "%s managed value %s/%s failed and could not be fully compensated", + e.Operation, e.Context, e.Name, + ) +} + +func (e *MutationError) Unwrap() []error { + return []error{ErrStateIndeterminate, e.Cause, e.Rollback} +} + // namePattern enforces a POSIX env identifier; a leading digit is rejected // because such a name cannot be exported as an environment variable. var namePattern = regexp.MustCompile(`^[A-Za-z_][A-Za-z0-9_]*$`) @@ -55,6 +76,8 @@ type Store interface { Get(context, name string) (string, error) Meta(context, name string) (SecretMeta, error) List(context string) ([]SecretMeta, error) + // Delete returns nil after removal. An ordinary error guarantees the + // original store state was restored; ErrStateIndeterminate means it was not. Delete(context, name string) error } diff --git a/pkg/secrets/store_internal_test.go b/pkg/secrets/store_internal_test.go index 5cb5dc70d9..9384b00267 100644 --- a/pkg/secrets/store_internal_test.go +++ b/pkg/secrets/store_internal_test.go @@ -72,7 +72,10 @@ func TestResolveBackend_IgnoresGarbageEnv(t *testing.T) { } type mapBackend struct { - values map[string]string + values map[string]string + removeCalls int + removeErrors map[int]error + setError error } func newMapBackend() *mapBackend { return &mapBackend{values: map[string]string{}} } @@ -105,6 +108,9 @@ func (r mapBackendRegistry) Probe(kind Backend, _ *index, key string) (bool, boo } func (m *mapBackend) set(key, value string) error { + if m.setError != nil { + return m.setError + } m.values[key] = value return nil } @@ -118,10 +124,86 @@ func (m *mapBackend) get(key string) (string, error) { } func (m *mapBackend) remove(key string) error { + m.removeCalls++ + if err := m.removeErrors[m.removeCalls]; err != nil { + return err + } delete(m.values, key) return nil } +func TestLocalStoreDelete_EnvIndexSaveFailurePreservesEntry(t *testing.T) { + s := newTestStore(t, newMapBackend()) + require.NoError(t, s.Set(testContext, "INLINE", "plain", KindEnv)) + s.saveIndex = func(*index) error { return errors.New("index save failed") } + + err := s.Delete(testContext, "INLINE") + require.ErrorContains(t, err, "index save failed") + value, err := s.Get(testContext, "INLINE") + require.NoError(t, err) + require.Equal(t, "plain", value) +} + +func TestLocalStoreDelete_SecretIndexSaveFailureRestoresBackendValue(t *testing.T) { + backend := newMapBackend() + s := newTestStore(t, backend) + require.NoError(t, s.Set(testContext, "TOKEN", "private payload", KindSecret)) + indexBytes, err := os.ReadFile(s.indexPath) + require.NoError(t, err) + s.saveIndex = func(*index) error { return errors.New("index save failed") } + + err = s.Delete(testContext, "TOKEN") + require.ErrorContains(t, err, "index save failed") + require.Equal(t, "private payload", backend.values[backendKey(testContext, "TOKEN")]) + currentIndex, err := os.ReadFile(s.indexPath) + require.NoError(t, err) + require.Equal(t, indexBytes, currentIndex) +} + +func TestLocalStoreDelete_BackendFailureAfterPartialRemovalRestoresEarlierValues(t *testing.T) { + keyring := newMapBackend() + file := newMapBackend() + key := backendKey(testContext, "LEGACY") + keyring.values[key] = "first payload" + file.values[key] = "second payload" + file.removeErrors = map[int]error{1: errors.New("backend removal failed")} + indexPath := writeLegacyIndex(t, + " LEGACY:\n name: LEGACY\n context: default\n kind: secret\n", + ) + backends := map[Backend]*mapBackend{ + BackendKeyring: keyring, + BackendFile: file, + } + registry := mapBackendRegistry{backends: backends} + s := newLocalStoreWithRegistry(BackendKeyring, indexPath, registry) + + err := s.Delete(testContext, "LEGACY") + require.ErrorContains(t, err, "backend removal failed") + require.NotErrorIs(t, err, ErrStateIndeterminate) + require.Equal(t, "first payload", keyring.values[key]) + require.Equal(t, "second payload", file.values[key]) + _, metaErr := s.Meta(testContext, "LEGACY") + require.NoError(t, metaErr) +} + +func TestLocalStoreDelete_CompensationFailureReturnsIndeterminateError(t *testing.T) { + backend := newMapBackend() + backend.values[backendKey(testContext, "TOKEN")] = "private payload" + s := newTestStore(t, backend) + require.NoError(t, s.Set(testContext, "TOKEN", "private payload", KindSecret)) + backend.removeErrors = map[int]error{1: errors.New("backend removal failed")} + backend.setError = errors.New("backend restoration failed") + + err := s.Delete(testContext, "TOKEN") + require.ErrorIs(t, err, ErrStateIndeterminate) + var mutationErr *MutationError + require.ErrorAs(t, err, &mutationErr) + require.ErrorContains(t, err, "default/TOKEN") + require.NotContains(t, err.Error(), "private payload") + require.ErrorContains(t, mutationErr.Cause, "backend removal failed") + require.ErrorContains(t, mutationErr.Rollback, "backend restoration failed") +} + func newTestStore(t *testing.T, b backend) *localStore { t.Helper() return newLocalStore(b, filepath.Join(t.TempDir(), IndexFileName))