Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
50 changes: 5 additions & 45 deletions cmd/env/delete.go
Original file line number Diff line number Diff line change
Expand Up @@ -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"
Expand Down Expand Up @@ -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,
})
}
126 changes: 25 additions & 101 deletions cmd/env/delete_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -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)
}
187 changes: 187 additions & 0 deletions cmd/internal/managedvalue/delete.go
Original file line number Diff line number Diff line change
@@ -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
}
Loading
Loading