From 5fd5517b8a5cc7f49bbee9be59a2252627ad94c0 Mon Sep 17 00:00:00 2001 From: Dmitry Mordvinov Date: Fri, 10 Jul 2026 15:28:45 +0300 Subject: [PATCH] feat: add option `LegacyNoReleaseLock` to install/uninstall/rollback actions Signed-off-by: Dmitry Mordvinov --- pkg/action/release_install.go | 26 ++++++++++++++++---------- pkg/action/release_rollback.go | 26 ++++++++++++++++---------- pkg/action/release_uninstall.go | 26 ++++++++++++++++---------- pkg/action/release_uninstall_legacy.go | 21 +++++++++++++-------- 4 files changed, 61 insertions(+), 38 deletions(-) diff --git a/pkg/action/release_install.go b/pkg/action/release_install.go index 06556399..8638a1f5 100644 --- a/pkg/action/release_install.go +++ b/pkg/action/release_install.go @@ -95,6 +95,8 @@ type ReleaseInstallOptions struct { // LegacyLogRegistryStreamOut is the output writer for Helm registry client logs. // Defaults to io.Discard if not set. Used for debugging registry operations. LegacyLogRegistryStreamOut io.Writer + // LegacyNoReleaseLock, when true, disables acquiring the werf-synchronization release lock in the cluster. + LegacyNoReleaseLock bool // LegacyProgressReportCh, when non-nil, receives ProgressReport snapshots during deployment. // Must be a buffered channel with capacity >= 1. The caller owns the channel and is responsible // for its lifecycle. Intermediate reports may be dropped if the consumer is slow; the final @@ -268,10 +270,12 @@ func releaseInstall(ctx context.Context, ctxCancelFn context.CancelCauseFunc, re } var lockManager *lock.LockManager - if m, err := lock.NewLockManager(ctx, releaseNamespace, false, clientFactory); err != nil { - return fmt.Errorf("construct lock manager: %w", err) - } else { - lockManager = m + if !opts.LegacyNoReleaseLock { + if m, err := lock.NewLockManager(ctx, releaseNamespace, false, clientFactory); err != nil { + return fmt.Errorf("construct lock manager: %w", err) + } else { + lockManager = m + } } if err := createReleaseNamespace(ctx, clientFactory, releaseNamespace); err != nil { @@ -280,12 +284,14 @@ func releaseInstall(ctx context.Context, ctxCancelFn context.CancelCauseFunc, re log.Default.Info(ctx, color.Style{color.Bold, color.Green}.Render("Start release")+" %q (namespace: %q)", releaseName, releaseNamespace) - if lock, err := lockManager.LockRelease(ctx, releaseName); err != nil { - return fmt.Errorf("lock release: %w", err) - } else { - defer func() { - _ = lockManager.Unlock(lock) - }() + if lockManager != nil { + if lock, err := lockManager.LockRelease(ctx, releaseName); err != nil { + return fmt.Errorf("lock release: %w", err) + } else { + defer func() { + _ = lockManager.Unlock(lock) + }() + } } log.Default.Debug(ctx, "Build release history") diff --git a/pkg/action/release_rollback.go b/pkg/action/release_rollback.go index 3a6a38e4..5f92d955 100644 --- a/pkg/action/release_rollback.go +++ b/pkg/action/release_rollback.go @@ -47,6 +47,8 @@ type ReleaseRollbackOptions struct { // ForceAdoption, when true, allows adopting resources that belong to a different Helm release. // WARNING: This can lead to conflicts if resources are managed by multiple releases. ForceAdoption bool + // LegacyNoReleaseLock, when true, disables acquiring the werf-synchronization release lock in the cluster. + LegacyNoReleaseLock bool // NetworkParallelism limits the number of concurrent network-related operations (API calls, resource fetches). // Defaults to DefaultNetworkParallelism if not set or <= 0. NetworkParallelism int @@ -158,20 +160,24 @@ func releaseRollback(ctx context.Context, ctxCancelFn context.CancelCauseFunc, r } var lockManager *lock.LockManager - if m, err := lock.NewLockManager(ctx, releaseNamespace, false, clientFactory); err != nil { - return fmt.Errorf("construct lock manager: %w", err) - } else { - lockManager = m + if !opts.LegacyNoReleaseLock { + if m, err := lock.NewLockManager(ctx, releaseNamespace, false, clientFactory); err != nil { + return fmt.Errorf("construct lock manager: %w", err) + } else { + lockManager = m + } } log.Default.Info(ctx, color.Style{color.Bold, color.Green}.Render("Start rollback of release")+" %q (namespace: %q)", releaseName, releaseNamespace) - if lock, err := lockManager.LockRelease(ctx, releaseName); err != nil { - return fmt.Errorf("lock release: %w", err) - } else { - defer func() { - _ = lockManager.Unlock(lock) - }() + if lockManager != nil { + if lock, err := lockManager.LockRelease(ctx, releaseName); err != nil { + return fmt.Errorf("lock release: %w", err) + } else { + defer func() { + _ = lockManager.Unlock(lock) + }() + } } log.Default.Debug(ctx, "Build release history") diff --git a/pkg/action/release_uninstall.go b/pkg/action/release_uninstall.go index 1a13c6c7..85931ecd 100644 --- a/pkg/action/release_uninstall.go +++ b/pkg/action/release_uninstall.go @@ -43,6 +43,8 @@ type ReleaseUninstallOptions struct { // DeleteReleaseNamespace, when true, deletes the release namespace after uninstalling the release. // WARNING: This will delete the entire namespace including resources not managed by this release. DeleteReleaseNamespace bool + // LegacyNoReleaseLock, when true, disables acquiring the werf-synchronization release lock in the cluster. + LegacyNoReleaseLock bool // LegacyProgressReportCh, when non-nil, receives ProgressReport snapshots during deployment. // Must be a buffered channel with capacity >= 1. The caller owns the channel and is responsible // for its lifecycle. Intermediate reports may be dropped if the consumer is slow; the final @@ -153,10 +155,12 @@ func releaseUninstall(ctx context.Context, ctxCancelFn context.CancelCauseFunc, } var lockManager *lock.LockManager - if m, err := lock.NewLockManager(ctx, releaseNamespace, false, clientFactory); err != nil { - return fmt.Errorf("construct lock manager: %w", err) - } else { - lockManager = m + if !opts.LegacyNoReleaseLock { + if m, err := lock.NewLockManager(ctx, releaseNamespace, false, clientFactory); err != nil { + return fmt.Errorf("construct lock manager: %w", err) + } else { + lockManager = m + } } nsMeta := spec.NewResourceMeta(releaseNamespace, "", releaseNamespace, "", schema.GroupVersionKind{Version: "v1", Kind: "Namespace"}, nil, nil) @@ -188,12 +192,14 @@ func releaseUninstall(ctx context.Context, ctxCancelFn context.CancelCauseFunc, if err := func() error { log.Default.Info(ctx, color.Style{color.Bold, color.Green}.Render("Delete release")+" %q (namespace: %q)", releaseName, releaseNamespace) - if lock, err := lockManager.LockRelease(ctx, releaseName); err != nil { - return fmt.Errorf("lock release: %w", err) - } else { - defer func() { - _ = lockManager.Unlock(lock) - }() + if lockManager != nil { + if lock, err := lockManager.LockRelease(ctx, releaseName); err != nil { + return fmt.Errorf("lock release: %w", err) + } else { + defer func() { + _ = lockManager.Unlock(lock) + }() + } } log.Default.Debug(ctx, "Build release history") diff --git a/pkg/action/release_uninstall_legacy.go b/pkg/action/release_uninstall_legacy.go index 653a2bde..4a29024b 100644 --- a/pkg/action/release_uninstall_legacy.go +++ b/pkg/action/release_uninstall_legacy.go @@ -43,6 +43,7 @@ type LegacyReleaseUninstallOptions struct { common.TrackingOptions DeleteReleaseNamespace bool + LegacyNoReleaseLock bool NetworkParallelism int NoDeleteHooks bool ReleaseHistoryLimit int @@ -215,16 +216,20 @@ func legacyReleaseUninstall(ctx context.Context, releaseName, releaseNamespace s log.Default.Info(ctx, color.Style{color.Bold, color.Green}.Render("Deleting release")+" %q (namespace: %q)", releaseName, releaseNamespace) var lockManager *lock.LockManager - if m, err := lock.NewLockManager(ctx, releaseNamespace, false, clientFactory); err != nil { - return fmt.Errorf("construct lock manager: %w", err) - } else { - lockManager = m + if !opts.LegacyNoReleaseLock { + if m, err := lock.NewLockManager(ctx, releaseNamespace, false, clientFactory); err != nil { + return fmt.Errorf("construct lock manager: %w", err) + } else { + lockManager = m + } } - if lock, err := lockManager.LockRelease(ctx, releaseName); err != nil { - return fmt.Errorf("lock release: %w", err) - } else { - defer lockManager.Unlock(lock) + if lockManager != nil { + if lock, err := lockManager.LockRelease(ctx, releaseName); err != nil { + return fmt.Errorf("lock release: %w", err) + } else { + defer lockManager.Unlock(lock) + } } helmUninstallCmd := helmv3.NewUninstallCmd(