fallback strategy, remove sleep block (#2305)

* fallback strategy, remove sleep block

* remove comment changes

* restore TODO comment

* limit scope of fallback

* remove escape to default

* remove unused getdefault

* preserve returned commit sha

* remove unused

* remove comment

Author: breardon2011

backend/controllers/github_helpers.go

@@ -591,6 +591,84 @@ func retrieveConfigFromCache(orgId uint, repoFullName string) (string, *digger_c
 	return repoCache.DiggerYmlStr, &config, &projectsGraph, &taConfig, nil
 }
 
+// GetDiggerConfigForBranchWithFallback attempts to load config from the specified branch,
+// and falls back to the target branch if the branch doesn't exist and shouldFallback is true
+func GetDiggerConfigForBranchWithFallback(gh utils.GithubClientProvider, installationId int64, repoFullName string, repoOwner string, repoName string, cloneUrl string, branch string, targetBranch string, shouldFallback bool, changedFiles []string, taConfig *tac.AtlantisConfig) (string, *github2.GithubService, *digger_config.DiggerConfig, graph.Graph[string, digger_config.Project], error) {
+	slog.Info("Attempting to get Digger config for branch with fallback",
+		"repoFullName", repoFullName,
+		"primaryBranch", branch,
+		"targetBranch", targetBranch,
+		"shouldFallback", shouldFallback,
+	)
+
+	ghService, _, err := utils.GetGithubService(gh, installationId, repoFullName, repoOwner, repoName)
+	if err != nil {
+		return "", nil, nil, nil,fmt.Errorf("error getting github service")
+	}
+
+	// Try the primary branch first
+	diggerYmlStr, ghService, config, dependencyGraph, err := GetDiggerConfigForBranch(
+		gh, installationId, repoFullName, repoOwner, repoName, cloneUrl, branch, changedFiles, taConfig,
+	)
+
+	actualBranchUsed := branch
+
+	if err != nil {
+		// Check if it's a "branch not found" error
+		errMsg := err.Error()
+		isBranchNotFound := strings.Contains(errMsg, "Remote branch") && strings.Contains(errMsg, "not found") ||
+			strings.Contains(errMsg, "couldn't find remote ref") ||
+			strings.Contains(errMsg, "exit status 128")
+
+		if isBranchNotFound && branch != targetBranch && shouldFallback {
+			slog.Warn("Branch not found and fallback enabled, falling back to target branch",
+				"missingBranch", branch,
+				"targetBranch", targetBranch,
+				"repoFullName", repoFullName,
+				"originalError", err,
+			)
+
+			// Try the target branch as fallback
+			var fallbackErr error
+			diggerYmlStr, ghService, config, dependencyGraph, fallbackErr = GetDiggerConfigForBranch(
+				gh, installationId, repoFullName, repoOwner, repoName, cloneUrl, targetBranch, changedFiles, taConfig,
+			)
+
+			if fallbackErr != nil {
+				slog.Error("Fallback to target branch also failed",
+					"targetBranch", targetBranch,
+					"repoFullName", repoFullName,
+					"fallbackError", fallbackErr,
+				)
+				return "", nil, nil, nil, fmt.Errorf("failed to load config from branch '%s' (branch not found) and fallback to target branch '%s' also failed: %v", branch, targetBranch, fallbackErr)
+			}
+
+			slog.Info("Successfully loaded config from target branch",
+				"targetBranch", targetBranch,
+				"repoFullName", repoFullName,
+			)
+
+			actualBranchUsed = targetBranch
+		} else {
+			// Either not a branch-not-found error, or fallback is disabled
+			if isBranchNotFound && !shouldFallback {
+				slog.Info("Branch not found but fallback is disabled",
+					"missingBranch", branch,
+					"repoFullName", repoFullName,
+				)
+			}
+			return "", nil, nil, nil, err
+		}
+	}
+
+	slog.Info("Config loaded successfully",
+		"repoFullName", repoFullName,
+		"branchUsed", actualBranchUsed,
+	)
+
+	return diggerYmlStr, ghService, config, dependencyGraph, nil
+}
+
 // TODO: Refactor this func to receive ghService as input
 func getDiggerConfigForPR(gh utils.GithubClientProvider, orgId uint, prLabels []string, installationId int64, repoFullName string, repoOwner string, repoName string, cloneUrl string, prNumber int) (string, *github2.GithubService, *digger_config.DiggerConfig, graph.Graph[string, digger_config.Project], *string, *string, []string, error) {
 	slog.Info("Getting Digger config for PR",
@@ -616,7 +694,8 @@ func getDiggerConfigForPR(gh utils.GithubClientProvider, orgId uint, prLabels []
 	}
 
 	var prBranch string
-	prBranch, prCommitSha, _, _, err := ghService.GetBranchName(prNumber)
+	var targetBranch string
+	prBranch, prCommitSha, targetBranch, _, err := ghService.GetBranchName(prNumber)
 	if err != nil {
 		slog.Error("Error getting branch name for PR",
 			"prNumber", prNumber,
@@ -626,10 +705,20 @@ func getDiggerConfigForPR(gh utils.GithubClientProvider, orgId uint, prLabels []
 		return "", nil, nil, nil, nil, nil, nil, fmt.Errorf("error getting branch name")
 	}
 
+	// Target branch must be available - no fallback to repo default
+	if targetBranch == "" {
+		slog.Error("PR target branch is empty",
+			"prNumber", prNumber,
+			"repoFullName", repoFullName,
+		)
+		return "", nil, nil, nil, nil, nil, nil, fmt.Errorf("PR target branch is empty for PR #%d", prNumber)
+	}
+
 	slog.Debug("Retrieved PR details",
 		"prNumber", prNumber,
 		"branch", prBranch,
 		"commitSha", prCommitSha,
+		"targetBranch", targetBranch,
 	)
 
 	changedFiles, err := ghService.GetChangedFiles(prNumber)
@@ -684,15 +773,39 @@ func getDiggerConfigForPR(gh utils.GithubClientProvider, orgId uint, prLabels []
 	slog.Info("Loading config from repository",
 		"repoFullName", repoFullName,
 		"branch", prBranch,
+		"targetBranch", targetBranch,
 		"prNumber", prNumber,
 	)
 
-	diggerYmlStr, ghService, config, dependencyGraph, err := GetDiggerConfigForBranch(gh, installationId, repoFullName, repoOwner, repoName, cloneUrl, prBranch, changedFiles, taConfig)
+	// Check if PR is merged to determine if we should fallback
+	shouldFallback := false
+	isMerged, err := ghService.IsMerged(prNumber)
+	if err != nil {
+		slog.Warn("Could not check PR merge status, will not enable fallback",
+			"prNumber", prNumber,
+			"repoFullName", repoFullName,
+			"error", err,
+		)
+	} else {
+		shouldFallback = isMerged
+		slog.Debug("PR merge status checked",
+			"prNumber", prNumber,
+			"isMerged", isMerged,
+			"shouldFallback", shouldFallback,
+		)
+	}
+
+	// Use the fallback method with merge-based fallback logic
+	diggerYmlStr, ghService, config, dependencyGraph, err := GetDiggerConfigForBranchWithFallback(
+		gh, installationId, repoFullName, repoOwner, repoName, cloneUrl, 
+		prBranch, targetBranch, shouldFallback, changedFiles, taConfig,
+	)
 	if err != nil {
 		slog.Error("Error loading Digger config from repository",
 			"prNumber", prNumber,
 			"repoFullName", repoFullName,
 			"branch", prBranch,
+			"targetBranch", targetBranch,
 			"error", err,
 		)
 		return "", nil, nil, nil, nil, nil, nil, fmt.Errorf("error loading digger.yml: %v", err)

backend/controllers/github_pull_request.go

@@ -8,7 +8,6 @@ import (
 	"runtime/debug"
 	"slices"
 	"strconv"
-	"time"
 
 	"github.com/diggerhq/digger/backend/ci_backends"
 	config2 "github.com/diggerhq/digger/backend/config"
@@ -101,36 +100,6 @@ func handlePullRequestEvent(gh utils.GithubClientProvider, payload *github.PullR
 		return fmt.Errorf("error getting ghService to post error comment")
 	}
 
-	// here we check if pr was closed and automatic deletion is enabled, to avoid errors when
-	// pr is merged and the branch does not exist we handle that gracefully
-	if action == "closed" {
-		slog.Debug("Handling closed PR action", "prNumber", prNumber)
-		// we sleep for 1 second to give github time to delete the branch
-		time.Sleep(3 * time.Second)
-
-		branchName, _, _, _, err := ghService.GetBranchName(prNumber)
-		if err != nil {
-			slog.Error("Could not retrieve PR details", "prNumber", prNumber, "error", err)
-			utils.InitCommentReporter(ghService, prNumber, fmt.Sprintf(":x: Could not retrieve PR details, error: %v", err))
-			return fmt.Errorf("Could not retrieve PR details: %v", err)
-		}
-
-		branchExists, err := ghService.CheckBranchExists(branchName)
-		if err != nil {
-			slog.Error("Could not check if branch exists", "prNumber", prNumber, "branchName", branchName, "error", err)
-			utils.InitCommentReporter(ghService, prNumber, fmt.Sprintf(":x: Could not check if branch exists, error: %v", err))
-			return fmt.Errorf("Could not check if branch exists: %v", err)
-		}
-
-		if !branchExists {
-			slog.Info("Branch no longer exists, ignoring PR closed event",
-				"prNumber", prNumber,
-				"branchName", branchName,
-			)
-			return nil
-		}
-	}
-
 	if !slices.Contains([]string{"closed", "opened", "reopened", "synchronize", "converted_to_draft"}, action) {
 		slog.Info("Ignoring event with action not requiring processing", "action", action, "prNumber", prNumber)
 		return nil

libs/ci/github/github.go

@@ -859,4 +859,4 @@ func CheckIfShowProjectsComment(event interface{}) bool {
 		slog.Debug("show-projects comment detected")
 	}
 	return result
-}
+}