more logging of processes in process group if the lock file is found

Signed-off-by: reggie-k <regina.voloshin@codefresh.io>

Author: reggie-k

reposerver/repository/repository.go

@@ -2536,19 +2536,19 @@ func fetch(gitClient git.Client, targetRevisions []string) error {
 // removeStaleGitLocks best-effort removes common stale git lock files in the repository.
 // It is safe to call while holding the per-repo lock and before running any git commands.
 
-func removeStaleGitLock(repoRoot string) {
-	path := filepath.Join(repoRoot, ".git", "HEAD.lock")
-	log.Infof("Checking whether HEAD.lock exists %s", path)
-	if _, err := os.Stat(path); err == nil {
-		log.Warnf("HEAD.lock present in git repository %s, removing it", repoRoot)
-		if rmErr := os.Remove(path); rmErr != nil {
-			log.Errorf("Failed to remove git lock %s: %v", path, rmErr)
-		}
-	}
-}
+// func removeStaleGitLock(repoRoot string) {
+// 	path := filepath.Join(repoRoot, ".git", "HEAD.lock")
+// 	log.Infof("Checking whether HEAD.lock exists %s", path)
+// 	if _, err := os.Stat(path); err == nil {
+// 		log.Warnf("HEAD.lock present in git repository %s, removing it", repoRoot)
+// 		if rmErr := os.Remove(path); rmErr != nil {
+// 			log.Errorf("Failed to remove git lock %s: %v", path, rmErr)
+// 		}
+// 	}
+// }
 
 func checkoutRevision(gitClient git.Client, revision string, submoduleEnabled bool) error {
-	removeStaleGitLock(gitClient.Root())
+	// removeStaleGitLock(gitClient.Root())
 
 	err := gitClient.Init()
 	if err != nil {

reposerver/repository/repository_test.go

@@ -3016,28 +3016,28 @@ func TestInit(t *testing.T) {
 	initGitRepo(t, newGitRepoOptions{path: path.Join(dir, "repo2"), remote: "https://github.com/argo-cd/test-repo2", createPath: true, addEmptyCommit: false})
 }
 
-func TestRemoveStaleGitHeadLock(t *testing.T) {
-	dir := t.TempDir()
-	// create a fake repo structure with .git/HEAD.lock
-	gitDir := path.Join(dir, ".git")
-	require.NoError(t, os.MkdirAll(gitDir, 0o755))
-	headLock := path.Join(gitDir, "HEAD.lock")
-	require.NoError(t, os.WriteFile(headLock, []byte("test"), 0o644))
-
-	// sanity: lock exists before
-	_, err := os.Stat(headLock)
-	require.NoError(t, err)
+// func TestRemoveStaleGitHeadLock(t *testing.T) {
+// 	dir := t.TempDir()
+// 	// create a fake repo structure with .git/HEAD.lock
+// 	gitDir := path.Join(dir, ".git")
+// 	require.NoError(t, os.MkdirAll(gitDir, 0o755))
+// 	headLock := path.Join(gitDir, "HEAD.lock")
+// 	require.NoError(t, os.WriteFile(headLock, []byte("test"), 0o644))
 
-	removeStaleGitLock(dir)
+// 	// sanity: lock exists before
+// 	_, err := os.Stat(headLock)
+// 	require.NoError(t, err)
 
-	// lock should be gone after cleanup
-	_, err = os.Stat(headLock)
-	require.Error(t, err)
-	require.True(t, os.IsNotExist(err))
+// 	removeStaleGitLock(dir)
 
-	// calling again should be a no-op (no error)
-	removeStaleGitLock(dir)
-}
+// 	// lock should be gone after cleanup
+// 	_, err = os.Stat(headLock)
+// 	require.Error(t, err)
+// 	require.True(t, os.IsNotExist(err))
+
+// 	// calling again should be a no-op (no error)
+// 	removeStaleGitLock(dir)
+// }
 
 // TestCheckoutRevisionCanGetNonstandardRefs shows that we can fetch a revision that points to a non-standard ref. In
 // other words, we haven't regressed and caused this issue again: https://github.com/argoproj/argo-cd/issues/4935
@@ -3080,7 +3080,7 @@ func TestCheckoutRevisionPresentSkipFetch(t *testing.T) {
 
 	gitClient := &gitmocks.Client{}
 	gitClient.On("Init").Return(nil)
-	gitClient.On("Root").Return("<repo-root>")
+	// gitClient.On("Root").Return("<repo-root>")
 	gitClient.On("IsRevisionPresent", revision).Return(true)
 	gitClient.On("Checkout", revision, mock.Anything).Return("", nil)
 
@@ -3093,7 +3093,7 @@ func TestCheckoutRevisionNotPresentCallFetch(t *testing.T) {
 
 	gitClient := &gitmocks.Client{}
 	gitClient.On("Init").Return(nil)
-	gitClient.On("Root").Return("<repo-root>")
+	// gitClient.On("Root").Return("<repo-root>")
 	gitClient.On("IsRevisionPresent", revision).Return(false)
 	gitClient.On("Fetch", "").Return(nil)
 	gitClient.On("Checkout", revision, mock.Anything).Return("", nil)
@@ -3108,7 +3108,7 @@ func TestFetch(t *testing.T) {
 
 	gitClient := &gitmocks.Client{}
 	gitClient.On("Init").Return(nil)
-	gitClient.On("Root").Return("<repo-root>")
+	// gitClient.On("Root").Return("<repo-root>")
 	gitClient.On("IsRevisionPresent", revision1).Once().Return(true)
 	gitClient.On("IsRevisionPresent", revision2).Once().Return(false)
 	gitClient.On("Fetch", "").Return(nil)

reposerver/repository/testdata/helm-with-local-dependency/.argocd-helm-dep-up

@@ -0,0 +1 @@
+marker

util/exec/exec.go

@@ -190,13 +190,31 @@ func RunCommandExt(cmd *exec.Cmd, opts CmdOpts) (string, error) {
 			return
 		}
 		lockPath := filepath.Join(cmd.Dir, ".git", "HEAD.lock")
-		_, statErr := os.Stat(lockPath)
+		fileInfo, statErr := os.Stat(lockPath)
 		exists := statErr == nil
-		logCtx.WithFields(logrus.Fields{
+		fields := logrus.Fields{
 			"headLockPath":   lockPath,
 			"headLockExists": exists,
 			"where":          where,
-		}).Info("HEAD.lock status execId=" + execId)
+		}
+		if exists {
+			fields["headLockSize"] = fileInfo.Size()
+			fields["headLockMode"] = fileInfo.Mode().String()
+			fields["headLockModTime"] = fileInfo.ModTime()
+			fields["headLockIsDir"] = fileInfo.IsDir()
+
+			pgid, pgErr := syscall.Getpgid(cmd.Process.Pid)
+			if pgErr == nil && pgid > 0 {
+				out, _ := exec.Command(
+					"ps",
+					"-o", "pid,ppid,pgid,etime,comm,args",
+					"--no-headers",
+					"--pgroup", strconv.Itoa(pgid),
+				).CombinedOutput()
+				fields["processesInGroup"] = strings.TrimSpace(string(out))
+			}
+		}
+		logCtx.WithFields(fields).Info("HEAD.lock status")
 	}
 
 	var stdout bytes.Buffer
@@ -261,6 +279,7 @@ func RunCommandExt(cmd *exec.Cmd, opts CmdOpts) (string, error) {
 		if timeoutBehavior.ShouldWait {
 			select {
 			case <-done:
+				logHeadLockStatus("timeout-waited-done")
 			case <-fatalTimeoutCh:
 				// upgrades to fatal signal (default SIGKILL) if cmd does not respect the initial signal
 				if cmd.Process != nil {