From 980706a1e37f9466d9d15ceacef9d5928510e231 Mon Sep 17 00:00:00 2001 From: Samuel K Date: Sat, 17 Oct 2026 18:13:19 -0600 Subject: [PATCH] refactor(provider): share operation lock helper --- cmd/mcp/tools_provider.go | 9 ++---- cmd/pro/update_provider.go | 9 ++---- cmd/provider/add.go | 9 ++---- cmd/provider/delete.go | 9 ++---- cmd/provider/init.go | 10 ++----- cmd/provider/rename.go | 18 ++++-------- cmd/provider/set.go | 9 ++---- cmd/provider/set_source.go | 9 ++---- cmd/provider/use.go | 11 ++------ pkg/provider/operationlock.go | 24 ++++++++++++++++ pkg/provider/operationlock_test.go | 44 ++++++++++++++++++++++++++++++ 11 files changed, 98 insertions(+), 63 deletions(-) create mode 100644 pkg/provider/operationlock_test.go diff --git a/cmd/mcp/tools_provider.go b/cmd/mcp/tools_provider.go index 1ff1d73fef..6038a7468e 100644 --- a/cmd/mcp/tools_provider.go +++ b/cmd/mcp/tools_provider.go @@ -148,14 +148,11 @@ func runProviderDelete(ctx context.Context, g *flags.GlobalFlags, name string) e return err } - opLock, err := provider.GetProviderOperationLock(devsyConfig.DefaultContext, name) + unlock, err := provider.LockProvider(devsyConfig.DefaultContext, name) if err != nil { - return fmt.Errorf("get operation lock: %w", err) - } - if err := opLock.Lock(); err != nil { - return fmt.Errorf("acquire operation lock: %w", err) + return err } - defer func() { _ = opLock.Unlock() }() + defer unlock() devsyConfig, err = config.LoadConfig(devsyConfig.DefaultContext, g.Provider) if err != nil { diff --git a/cmd/pro/update_provider.go b/cmd/pro/update_provider.go index ab9b6ef507..07ad9a55b5 100644 --- a/cmd/pro/update_provider.go +++ b/cmd/pro/update_provider.go @@ -62,14 +62,11 @@ func (cmd *UpdateProviderCmd) Run(ctx context.Context, args []string) error { if provider.Source.Internal { return nil } - opLock, err := provider2.GetProviderOperationLock(devsyConfig.DefaultContext, provider.Name) + unlock, err := provider2.LockProvider(devsyConfig.DefaultContext, provider.Name) if err != nil { - return fmt.Errorf("get operation lock: %w", err) - } - if err := opLock.Lock(); err != nil { - return fmt.Errorf("acquire operation lock: %w", err) + return err } - defer func() { _ = opLock.Unlock() }() + defer unlock() devsyConfig, err = config.LoadConfig(devsyConfig.DefaultContext, cmd.Provider) if err != nil { return err diff --git a/cmd/provider/add.go b/cmd/provider/add.go index a868a03b37..1c088a3003 100644 --- a/cmd/provider/add.go +++ b/cmd/provider/add.go @@ -108,14 +108,11 @@ func (cmd *AddCmd) Run(ctx context.Context, devsyConfig *config.Config, args []s sort.Strings(names) } for _, name := range names { - opLock, lockErr := provider.GetProviderOperationLock(devsyConfig.DefaultContext, name) + unlock, lockErr := provider.LockProviderNamed(devsyConfig.DefaultContext, name) if lockErr != nil { - return fmt.Errorf("get operation lock for %s: %w", name, lockErr) + return lockErr } - if lockErr := opLock.Lock(); lockErr != nil { - return fmt.Errorf("acquire operation lock for %s: %w", name, lockErr) - } - defer func() { _ = opLock.Unlock() }() + defer unlock() } devsyConfig, err = config.LoadConfig(devsyConfig.DefaultContext, cmd.Provider) if err != nil { diff --git a/cmd/provider/delete.go b/cmd/provider/delete.go index 53304b8020..9b66832914 100644 --- a/cmd/provider/delete.go +++ b/cmd/provider/delete.go @@ -73,14 +73,11 @@ func (cmd *DeleteCmd) Run(ctx context.Context, args []string) error { return fmt.Errorf("specify a provider to delete") } - opLock, err := provider2.GetProviderOperationLock(devsyConfig.DefaultContext, provider) + unlock, err := provider2.LockProvider(devsyConfig.DefaultContext, provider) if err != nil { - return fmt.Errorf("get operation lock: %w", err) - } - if err := opLock.Lock(); err != nil { - return fmt.Errorf("acquire operation lock: %w", err) + return err } - defer func() { _ = opLock.Unlock() }() + defer unlock() devsyConfig, err = config.LoadConfig(devsyConfig.DefaultContext, cmd.Provider) if err != nil { diff --git a/cmd/provider/init.go b/cmd/provider/init.go index 49093a2452..4c28c8db5a 100644 --- a/cmd/provider/init.go +++ b/cmd/provider/init.go @@ -2,7 +2,6 @@ package provider import ( "context" - "fmt" "os" "github.com/devsy-org/devsy/cmd/completion" @@ -40,14 +39,11 @@ func NewInitCmd(f *flags.GlobalFlags) *cobra.Command { return err } - opLock, err := provider2.GetProviderOperationLock(devsyConfig.DefaultContext, name) + unlock, err := provider2.LockProvider(devsyConfig.DefaultContext, name) if err != nil { - return fmt.Errorf("get operation lock: %w", err) - } - if err := opLock.Lock(); err != nil { - return fmt.Errorf("acquire operation lock: %w", err) + return err } - defer func() { _ = opLock.Unlock() }() + defer unlock() devsyConfig, err = config.LoadConfig(devsyConfig.DefaultContext, cmd.Provider) if err != nil { diff --git a/cmd/provider/rename.go b/cmd/provider/rename.go index 66a6f2df85..c4e2e63d9f 100644 --- a/cmd/provider/rename.go +++ b/cmd/provider/rename.go @@ -57,23 +57,17 @@ func (cmd *RenameCmd) Run(ctx context.Context, args []string) error { return err } - lock1, err := provider.GetProviderOperationLock(devsyConfig.DefaultContext, names[0]) + unlock1, err := provider.LockProviderNamed(devsyConfig.DefaultContext, names[0]) if err != nil { - return fmt.Errorf("get operation lock for %s: %w", names[0], err) - } - if err := lock1.Lock(); err != nil { - return fmt.Errorf("acquire operation lock for %s: %w", names[0], err) + return err } - defer func() { _ = lock1.Unlock() }() + defer unlock1() - lock2, err := provider.GetProviderOperationLock(devsyConfig.DefaultContext, names[1]) + unlock2, err := provider.LockProviderNamed(devsyConfig.DefaultContext, names[1]) if err != nil { - return fmt.Errorf("get operation lock for %s: %w", names[1], err) - } - if err := lock2.Lock(); err != nil { - return fmt.Errorf("acquire operation lock for %s: %w", names[1], err) + return err } - defer func() { _ = lock2.Unlock() }() + defer unlock2() devsyConfig, err = config.LoadConfig(devsyConfig.DefaultContext, cmd.Provider) if err != nil { diff --git a/cmd/provider/set.go b/cmd/provider/set.go index 8c5e6db57c..43239af78e 100644 --- a/cmd/provider/set.go +++ b/cmd/provider/set.go @@ -68,17 +68,14 @@ func (cmd *SetCmd) Run(ctx context.Context, args []string) error { if err != nil { return err } - opLock, err := provider2.GetProviderOperationLock( + unlock, err := provider2.LockProvider( devsyConfig.DefaultContext, providerWithOptions.Config.Name, ) if err != nil { - return fmt.Errorf("get operation lock: %w", err) - } - if err := opLock.Lock(); err != nil { - return fmt.Errorf("acquire operation lock: %w", err) + return err } - defer func() { _ = opLock.Unlock() }() + defer unlock() devsyConfig, providerWithOptions, err = cmd.loadProviderInContext( devsyConfig.DefaultContext, diff --git a/cmd/provider/set_source.go b/cmd/provider/set_source.go index 7fad9d4bed..e974340067 100644 --- a/cmd/provider/set_source.go +++ b/cmd/provider/set_source.go @@ -62,14 +62,11 @@ func (cmd *SetSourceCmd) Run(ctx context.Context, devsyConfig *config.Config, ar } providerName := args[0] - opLock, err := provider2.GetProviderOperationLock(devsyConfig.DefaultContext, providerName) + unlock, err := provider2.LockProvider(devsyConfig.DefaultContext, providerName) if err != nil { - return fmt.Errorf("get operation lock: %w", err) - } - if err := opLock.Lock(); err != nil { - return fmt.Errorf("acquire operation lock: %w", err) + return err } - defer func() { _ = opLock.Unlock() }() + defer unlock() devsyConfig, err = config.LoadConfig(devsyConfig.DefaultContext, cmd.Provider) if err != nil { diff --git a/cmd/provider/use.go b/cmd/provider/use.go index 78bff145a1..90b2778c3d 100644 --- a/cmd/provider/use.go +++ b/cmd/provider/use.go @@ -1,8 +1,6 @@ package provider import ( - "fmt" - "github.com/devsy-org/devsy/cmd/completion" "github.com/devsy-org/devsy/cmd/flags" "github.com/devsy-org/devsy/pkg/config" @@ -19,14 +17,11 @@ func UseProvider(contextOverride, providerOverride, name string) error { if err != nil { return err } - opLock, err := provider.GetProviderOperationLock(initial.DefaultContext, name) + unlock, err := provider.LockProvider(initial.DefaultContext, name) if err != nil { - return fmt.Errorf("get operation lock: %w", err) - } - if err := opLock.Lock(); err != nil { - return fmt.Errorf("acquire operation lock: %w", err) + return err } - defer func() { _ = opLock.Unlock() }() + defer unlock() var resolved string err = config.UpdateConfig( diff --git a/pkg/provider/operationlock.go b/pkg/provider/operationlock.go index b02a49b4eb..4759c4cf76 100644 --- a/pkg/provider/operationlock.go +++ b/pkg/provider/operationlock.go @@ -23,6 +23,30 @@ func GetProviderOperationLock(contextName, providerName string) (*flock.Flock, e return flock.New(filepath.Join(locksDir, providerName+".provider-operation.lock")), nil } +// LockProvider acquires the operation lock for providerName in contextName and +// returns the func that releases it. Errors are wrapped as "get operation lock" +// or "acquire operation lock". Callers defer the returned func. +func LockProvider(contextName, providerName string) (func(), error) { + return lockProvider(contextName, providerName, "") +} + +// LockProviderNamed is LockProvider with the provider name in the error text +// ("get operation lock for : ..."). +func LockProviderNamed(contextName, providerName string) (func(), error) { + return lockProvider(contextName, providerName, " for "+providerName) +} + +func lockProvider(contextName, providerName, errSuffix string) (func(), error) { + opLock, err := GetProviderOperationLock(contextName, providerName) + if err != nil { + return nil, fmt.Errorf("get operation lock%s: %w", errSuffix, err) + } + if err := opLock.Lock(); err != nil { + return nil, fmt.Errorf("acquire operation lock%s: %w", errSuffix, err) + } + return func() { _ = opLock.Unlock() }, nil +} + // GetProInstanceOperationLock serializes creation of one Pro host without // sharing a lock file with provider rename or lifecycle operations. func GetProInstanceOperationLock(contextName, host string) (*flock.Flock, error) { diff --git a/pkg/provider/operationlock_test.go b/pkg/provider/operationlock_test.go new file mode 100644 index 0000000000..825cae89f2 --- /dev/null +++ b/pkg/provider/operationlock_test.go @@ -0,0 +1,44 @@ +package provider + +import ( + "testing" + + "github.com/stretchr/testify/require" +) + +func TestLockProviderHoldsLockUntilUnlock(t *testing.T) { + useTempDevsyHome(t) + + probe, err := GetProviderOperationLock("default", "same") + require.NoError(t, err) + + unlock, err := LockProvider("default", "same") + require.NoError(t, err) + + held, err := probe.TryLock() + require.NoError(t, err) + require.False(t, held, "operation lock must be held until unlock is called") + + unlock() + + acquired, err := probe.TryLock() + require.NoError(t, err) + require.True(t, acquired, "unlock must release the operation lock") + require.NoError(t, probe.Unlock()) +} + +func TestLockProviderWrapsGetError(t *testing.T) { + useTempDevsyHome(t) + + unlock, err := LockProvider("default", "") + require.EqualError(t, err, `get operation lock: invalid provider name ""`) + require.Nil(t, unlock) +} + +func TestLockProviderNamedIncludesNameInError(t *testing.T) { + useTempDevsyHome(t) + + unlock, err := LockProviderNamed("default", "") + require.EqualError(t, err, `get operation lock for : invalid provider name ""`) + require.Nil(t, unlock) +}