fix: recover when there is unreleased lock file

If a previous git invocation crashes, it is possible that an orphaned
lock file (e.g. shallow.lock) is left on the filesystem. This previously
caused git-sync to crash loop because the lock file is never deleted.

This change adds a check in sanityCheckRepo for the existence of a git
lock file. If the git lock file exists at this stage, then initRepo will
re-initialize the repository.

Author: sdowell

main.go

@@ -1227,6 +1227,19 @@ func (git *repoSync) removeStaleWorktrees() (int, error) {
 	return count, nil
 }
 
+func hasGitLockFile(gitRoot absPath) (bool, error) {
+	gitLockFiles := []string{"shallow.lock"}
+	for _, lockFile := range gitLockFiles {
+		_, err := os.Stat(gitRoot.Join(".git", lockFile).String())
+		if err == nil {
+			return true, nil
+		} else if !errors.Is(err, os.ErrNotExist) {
+			return false, err
+		}
+	}
+	return false, nil
+}
+
 // sanityCheckRepo tries to make sure that the repo dir is a valid git repository.
 func (git *repoSync) sanityCheckRepo(ctx context.Context) bool {
 	git.log.V(3).Info("sanity-checking git repo", "repo", git.root)
@@ -1258,6 +1271,16 @@ func (git *repoSync) sanityCheckRepo(ctx context.Context) bool {
 		return false
 	}
 
+	// Check if the repository contains an unreleased lock file. This can happen if
+	// a previous git invocation crashed.
+	if hasLock, err := hasGitLockFile(git.root); err != nil {
+		git.log.Error(err, "error calling stat on file", "path", git.root)
+		return false
+	} else if hasLock {
+		git.log.Error(nil, "repo contains lock file", "path", git.root)
+		return false
+	}
+
 	return true
 }
 

main_test.go

@@ -424,3 +424,42 @@ func TestTouch(t *testing.T) {
 		t.Errorf("touch(newfile) mtime %v is not after %v", newfileInfo.ModTime(), stamp)
 	}
 }
+
+func TestHasGitLockFile(t *testing.T) {
+	testCases := map[string]struct {
+		inputFilePath  []string
+		expectLockFile bool
+	}{
+		"missing .git directory": {
+			expectLockFile: false,
+		},
+		"has git directory but no lock files": {
+			inputFilePath:  []string{".git", "HEAD"},
+			expectLockFile: false,
+		},
+		"shallow.lock file": {
+			inputFilePath:  []string{".git", "shallow.lock"},
+			expectLockFile: true,
+		},
+	}
+
+	for name, tc := range testCases {
+		t.Run(name, func(t *testing.T) {
+			root := absPath(t.TempDir())
+
+			if len(tc.inputFilePath) > 0 {
+				if err := touch(root.Join(tc.inputFilePath...)); err != nil {
+					t.Fatal(err)
+				}
+			}
+
+			hasLock, err := hasGitLockFile(root)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if hasLock != tc.expectLockFile {
+				t.Fatalf("expected hasGitLockFile to return %v, but got %v", tc.expectLockFile, hasLock)
+			}
+		})
+	}
+}