Add PR locking configuration at the digger.yml level

backend/controllers/github.go

@@ -486,21 +486,24 @@ func handlePullRequestEvent(gh utils.GithubClientProvider, payload *github.PullR
 	}
 
 	// perform locking/unlocking in backend
-	for _, project := range impactedProjects {
-		prLock := dg_locking.PullRequestLock{
-			InternalLock: locking.BackendDBLock{
-				OrgId: organisationId,
-			},
-			CIService:        ghService,
-			Reporter:         comment_updater.NoopReporter{},
-			ProjectName:      project.Name,
-			ProjectNamespace: repoFullName,
-			PrNumber:         prNumber,
-		}
-		err = PerformLockingActionFromCommand(prLock, *diggerCommand)
-		if err != nil {
-			utils.InitCommentReporter(ghService, prNumber, fmt.Sprintf(":x: Failed perform lock action on project: %v %v", project.Name, err))
-			return fmt.Errorf("failed to perform lock action on project: %v, %v", project.Name, err)
+	if config.PrLocks {
+		for _, project := range impactedProjects {
+			prLock := dg_locking.PullRequestLock{
+				Enable: config.PrLocks,
+				InternalLock: locking.BackendDBLock{
+					OrgId: organisationId,
+				},
+				CIService:        ghService,
+				Reporter:         comment_updater.NoopReporter{},
+				ProjectName:      project.Name,
+				ProjectNamespace: repoFullName,
+				PrNumber:         prNumber,
+			}
+			err = PerformLockingActionFromCommand(prLock, *diggerCommand)
+			if err != nil {
+				utils.InitCommentReporter(ghService, prNumber, fmt.Sprintf(":x: Failed perform lock action on project: %v %v", project.Name, err))
+				return fmt.Errorf("failed to perform lock action on project: %v, %v", project.Name, err)
+			}
 		}
 	}
 
@@ -765,21 +768,24 @@ func handleIssueCommentEvent(gh utils.GithubClientProvider, payload *github.Issu
 	log.Printf("GitHub IssueComment event processed successfully\n")
 
 	// perform unlocking in backend
-	for _, project := range impactedProjects {
-		prLock := dg_locking.PullRequestLock{
-			InternalLock: locking.BackendDBLock{
-				OrgId: orgId,
-			},
-			CIService:        ghService,
-			Reporter:         comment_updater.NoopReporter{},
-			ProjectName:      project.Name,
-			ProjectNamespace: repoFullName,
-			PrNumber:         issueNumber,
-		}
-		err = PerformLockingActionFromCommand(prLock, *diggerCommand)
-		if err != nil {
-			utils.InitCommentReporter(ghService, issueNumber, fmt.Sprintf(":x: Failed perform lock action on project: %v %v", project.Name, err))
-			return fmt.Errorf("failed perform lock action on project: %v %v", project.Name, err)
+	if config.PrLocks {
+		for _, project := range impactedProjects {
+			prLock := dg_locking.PullRequestLock{
+				Enable: config.PrLocks,
+				InternalLock: locking.BackendDBLock{
+					OrgId: orgId,
+				},
+				CIService:        ghService,
+				Reporter:         comment_updater.NoopReporter{},
+				ProjectName:      project.Name,
+				ProjectNamespace: repoFullName,
+				PrNumber:         issueNumber,
+			}
+			err = PerformLockingActionFromCommand(prLock, *diggerCommand)
+			if err != nil {
+				utils.InitCommentReporter(ghService, issueNumber, fmt.Sprintf(":x: Failed perform lock action on project: %v %v", project.Name, err))
+				return fmt.Errorf("failed perform lock action on project: %v %v", project.Name, err)
+			}
 		}
 	}
 

cli/pkg/core/execution/execution.go

@@ -28,6 +28,7 @@ type Executor interface {
 }
 
 type LockingExecutorWrapper struct {
+	Enable      bool
 	ProjectLock locking.ProjectLock
 	Executor    Executor
 }
@@ -82,6 +83,9 @@ func (l LockingExecutorWrapper) Unlock() error {
 }
 
 func (l LockingExecutorWrapper) Lock() error {
+	if !l.Enable {
+		return nil
+	}
 	_, err := l.ProjectLock.Lock()
 	if err != nil {
 		return fmt.Errorf("failed to aquire lock: %s, %v", l.ProjectLock.LockId(), err)

cli/pkg/digger/digger.go

@@ -11,8 +11,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/diggerhq/digger/libs/comment_utils/summary"
-
 	"github.com/diggerhq/digger/cli/pkg/core/backend"
 	core_drift "github.com/diggerhq/digger/cli/pkg/core/drift"
 	"github.com/diggerhq/digger/cli/pkg/core/execution"
@@ -206,6 +204,7 @@ func run(command string, job orchestrator.Job, policyChecker policy.Checker, org
 	}
 
 	projectLock := &locking2.PullRequestLock{
+		Enable:           config.PrLocks,
 		InternalLock:     lock,
 		Reporter:         reporter,
 		CIService:        prService,

docs/reference/digger.yml.mdx

@@ -22,6 +22,7 @@ auto_merge: true
 ```yml
 traverse_to_nested_projects: true
 auto_merge: false
+pr_locks: true
 projects:
   - name: prod
     dir: prod
@@ -101,6 +102,7 @@ workflows:
 | --------------------------- | ---------------------------------------------------------- | ------- | -------- | ------------------------------------------------------ | ----- |
 | telemetry                   | boolean                                                    | true    | no       | allows collecting anonymised usage and debugging data  |       |
 | auto_merge                  | boolean                                                    | false   | no       | automatically merge pull requests when all checks pass |       |
+| pr_locks                    | boolean                                                    | true    | no       | Enable PR-level locking                                |       |
 | projects                    | array of [Projects](/reference/digger.yml#project)         | \[\]    | no       | list of projects to manage                             |       |
 | generate_projects           | [GenerateProjects](/reference/digger.yml#generateprojects) | {}      | no       | generate projects from a directory structure           |       |
 | workflows                   | map of [Workflows](/reference/digger.yml#workflows)        | {}      | no       | workflows and configurations to run on events          |       |

libs/digger_config/config.go

@@ -8,6 +8,7 @@ type DiggerConfig struct {
 	AllowDraftPRs              bool
 	CommentRenderMode          string
 	DependencyConfiguration    DependencyConfiguration
+	PrLocks                    bool
 	Projects                   []Project
 	AutoMerge                  bool
 	Telemetry                  bool

libs/digger_config/converters.go

@@ -184,6 +184,12 @@ func ConvertDiggerYamlToConfig(diggerYaml *DiggerConfigYaml) (*DiggerConfig, gra
 		diggerConfig.MentionDriftedProjectsInPR = false
 	}
 
+	if diggerYaml.PrLocks != nil {
+		diggerConfig.PrLocks = *diggerYaml.PrLocks
+	} else {
+		diggerConfig.PrLocks = true
+	}
+
 	if diggerYaml.Telemetry != nil {
 		diggerConfig.Telemetry = *diggerYaml.Telemetry
 	} else {

libs/digger_config/yaml.go

@@ -10,6 +10,7 @@ type DiggerConfigYaml struct {
 	ApplyAfterMerge            *bool                        `yaml:"apply_after_merge"`
 	AllowDraftPRs              *bool                        `yaml:"allow_draft_prs"`
 	DependencyConfiguration    *DependencyConfigurationYaml `yaml:"dependency_configuration"`
+	PrLocks                    *bool                        `yaml:"pr_locks"`
 	Projects                   []*ProjectYaml               `yaml:"projects"`
 	AutoMerge                  *bool                        `yaml:"auto_merge"`
 	CommentRenderMode          *string                      `yaml:"comment_render_mode"`

libs/locking/locking.go

@@ -25,6 +25,7 @@ import (
 )
 
 type PullRequestLock struct {
+	Enable           bool
 	InternalLock     Lock
 	CIService        orchestrator.PullRequestService
 	Reporter         reporting.Reporter
@@ -62,7 +63,11 @@ func (projectLock *PullRequestLock) Lock() (bool, error) {
 		return false, nil
 	}
 
-	existingLockTransactionId, err := projectLock.InternalLock.GetLock(lockId)
+	var existingLockTransactionId *int
+	if projectLock.Enable {
+		existingLockTransactionId, err = projectLock.InternalLock.GetLock(lockId)
+	}
+
 	if err != nil {
 		log.Printf("failed to get lock: %v\n", err)
 		return false, err