@gitkraken/core-gitlens 0.12.0 → 0.14.0

package/dist/git-cli/exec/git.js

@@ -1,3 +1,4 @@
+import { chunkByStringLength } from "../../utils/iterable.js";
 import { getScopedCounter } from "../../utils/counter.js";
 import { CancellationError, getAbortSignalId, isCancellationError } from "../../utils/cancellation.js";
 import { getDurationMilliseconds, hrtime } from "../../utils/hrtime.js";
@@ -7,11 +8,12 @@ import { defer } from "../../utils/promise.js";
 import { arePathsEqual, dirname as dirname$1, isAbsolute as isAbsolute$1, isDescendant, joinPaths, normalizePath } from "../../utils/path.js";
 import { GitWarnings, WorkspaceUntrustedError, getGitWarning } from "../../git/errors.js";
 import { gitFeaturesByVersion } from "../../git/features.js";
+import { getChangesForCommand, leadingCommand } from "./commandClassifier.js";
 import { CancelledRunError, RunError, endStdin, fsExists, runSpawn } from "../../utils/env/node/exec.js";
 import { compare, fromString } from "../../utils/version.js";
-import { getChangesForCommand, leadingCommand } from "./commandClassifier.js";
 import { EventLoopMonitor } from "./eventLoopMonitor.js";
 import { GitQueue, getPrimaryGitCommand, inferGitCommandPriority } from "./gitQueue.js";
+import { KeyedSequencer, isConfigCommand, isIndexWriteCommand, retryWhileConfigLocked, retryWhileIndexLocked } from "./indexLock.js";
 import { resolve } from "path";
 import { spawn } from "child_process";
 import * as process from "process";
@@ -22,6 +24,15 @@ const queueWaitAnnotationThreshold = 100;
 /** Below this, a measured event-loop stall isn't worth annotating — see {@link EventLoopMonitor}. */
 const eventLoopDelayAnnotationThreshold = 500;
 const maxGitCliLength = 3e4;
+/**
+* Splits `paths` into `:(literal)` pathspec batches that each fit the command-line length limit after `prefix`, so a
+* folder named like a glob (`[id]/`) doesn't match its siblings.
+*/
+function batchLiteralPathspecs(paths, prefix) {
+	const perArgOverhead = 3;
+	const prefixLength = [...prefix, "--"].reduce((sum, arg) => sum + arg.length + perArgOverhead, 0);
+	return chunkByStringLength(paths.map((p) => `:(literal)${p}`), maxGitCliLength - prefixLength, perArgOverhead);
+}
 const gitConfigsBranch = ["-c", "color.branch=false"];
 const gitConfigsDiff = [
 	"-c",
@@ -418,6 +429,10 @@ var Git = class {
 	pendingCommands = /* @__PURE__ */ new Map();
 	/** Queue for throttling background git operations */
 	_queue;
+	/** Orders the index-writing runs of each checkout, so they don't race for its `index.lock` */
+	_indexWrites = new KeyedSequencer();
+	/** The spawn behind every non-streaming run — a field only so tests can substitute it */
+	_runSpawn = runSpawn;
 	/** Detects event-loop stalls while at least one git command is in flight */
 	_eventLoopMonitor = new EventLoopMonitor();
 	/** Count of git commands currently in flight, across both the exec and streaming paths */
@@ -440,7 +455,9 @@ var Git = class {
 	* to its own `notifyChanged` from its constructor — including when it's handed a pre-built `Git` via
 	* `options.git`, so a host-supplied instance gets bound too. With nothing bound, `notify` is a no-op.
 	* `repoPaths` holds more than one path only for a `-C`-scoped shared-state verb: the `-C` target, then the
-	* caller's own `cwd`.
+	* caller's own `cwd`. `sharedPaths` names the paths that were not run in but share the repository, which
+	* hear only the part of `changes` every worktree sees (the caller's `cwd`, when the verb also changed
+	* something local to the `-C` target).
 	*/
 	bindChangeNotifier(fn) {
 		this._changeNotifier = fn;
@@ -601,10 +618,7 @@ var Git = class {
 		const cwd = normalizePath(options.cwd);
 		if (command.pathOverride != null && cwd !== ranIn && (command.sharedChanges.length || !command.changes.length)) {
 			if (command.sharedChanges.length === command.changes.length) this._changeNotifier([ranIn, cwd], command.changes);
-			else {
-				this._changeNotifier([ranIn], command.changes);
-				this._changeNotifier([cwd], command.sharedChanges);
-			}
+			else this._changeNotifier([ranIn], command.changes, [cwd]);
 			return;
 		}
 		this._changeNotifier([ranIn], command.changes);
@@ -616,19 +630,20 @@ var Git = class {
 		const start = hrtime();
 		const startEpochMs = Date.now();
 		gitCommand = `[${options.cwd}] ${gitCommand}`;
-		const { cancellation, configs, correlationKey, errors: errorHandling, encoding, expectedExitCodes, runLocally: _, selfMaintenance, slownessCategory, ...opts } = options;
-		const defaultTimeout = this.options.gitTimeout ?? 6e4;
+		const { beforeIndexLockRetry, cancellation, configs, correlationKey, errors: errorHandling, encoding, expectedExitCodes, runLocally: _, selfMaintenance, slownessCategory, ...opts } = options;
+		const runTimeout = opts.timeout ?? this.options.gitTimeout ?? 6e4;
 		const runOpts = {
 			...opts,
-			timeout: opts.timeout === 0 || defaultTimeout === 0 ? void 0 : opts.timeout ?? defaultTimeout,
+			timeout: runTimeout === 0 ? void 0 : runTimeout,
 			encoding: (encoding ?? "utf8") === "utf8" ? "utf8" : "buffer",
 			decode: this.options.decode,
 			env: this.buildEnv(options.env),
 			quiet: errorHandling === "ignore"
 		};
-		const unshared = options?.stdin != null || options?.env != null && Object.keys(options.env).length > 0;
+		const unshared = options?.stdin != null || options?.env != null && Object.keys(options.env).length > 0 || beforeIndexLockRetry != null;
 		const cacheKey = `${correlationKey !== void 0 ? `${correlationKey}:` : ""}${unshared ? `${unsharedRunCounter.next()}:` : ""}${cancellation != null ? `${getAbortSignalId(cancellation)}:` : ""}${gitCommand}`;
 		let execStart;
+		let hookFailure;
 		let waiting;
 		let promise = this.pendingCommands.get(cacheKey)?.promise;
 		if (promise == null) {
@@ -639,15 +654,27 @@ var Git = class {
 				cwd: options.cwd,
 				promise
 			});
+			const writesIndex = isIndexWriteCommand(args);
+			const checkoutKey = writesIndex && options.cwd != null && runOpts.env?.GIT_INDEX_FILE == null ? this.resolveNotifyPath(options.cwd, leadingCommand(args).pathOverride) : void 0;
 			args.unshift("-c", "core.quotepath=false", "-c", "color.ui=false", ...configs ?? emptyArray);
 			if (process.platform === "win32") args.unshift("-c", "core.longpaths=true");
 			if (cancellation != null) runOpts.cancellation = cancellation;
 			const priority = options.priority ?? inferGitCommandPriority(args);
 			const gitPath = await this.path();
-			this._queue.run(priority, () => {
+			const spawnQueued = () => this._queue.run(priority, () => {
 				execStart = hrtime();
-				return runSpawn(gitPath, args, encoding ?? "utf8", runOpts);
-			}, cancellation).then(deferred.fulfill, (e) => deferred.cancel(e instanceof Error ? e : new Error(String(e)))).finally(() => {
+				return this._runSpawn(gitPath, args, encoding ?? "utf8", runOpts);
+			}, cancellation);
+			const beforeRetry = beforeIndexLockRetry != null ? async (lockError) => {
+				try {
+					await beforeIndexLockRetry(lockError);
+				} catch (ex) {
+					if (ex !== lockError) hookFailure = { error: ex };
+					throw ex;
+				}
+			} : void 0;
+			const spawnWithRetry = writesIndex ? () => retryWhileIndexLocked(spawnQueued, cancellation, beforeRetry) : isConfigCommand(args) ? () => retryWhileConfigLocked(spawnQueued, cancellation) : spawnQueued;
+			(checkoutKey != null ? this._indexWrites.run(checkoutKey, cancellation, spawnWithRetry) : spawnWithRetry()).then(deferred.fulfill, (e) => deferred.cancel(e instanceof Error ? e : new Error(String(e)))).finally(() => {
 				if (this.pendingCommands.get(cacheKey)?.promise === deferred.promise) this.pendingCommands.delete(cacheKey);
 			}).catch(() => {});
 		} else {
@@ -681,6 +708,10 @@ var Git = class {
 				}
 			};
 		} catch (ex) {
+			if (hookFailure != null) {
+				exception = hookFailure.error instanceof Error ? hookFailure.error : new Error(String(hookFailure.error));
+				throw hookFailure.error;
+			}
 			if (expectedExitCodes?.length && ex instanceof RunError && !(ex instanceof CancelledRunError)) {
 				const code = toExitCode(ex.code);
 				if (code != null && expectedExitCodes.includes(code)) return {
@@ -858,11 +889,24 @@ var Git = class {
 		}
 		return void cleanup();
 	}
+	/**
+	* Resolves the git dir (and common dir, for a linked worktree) of `cwd`.
+	*
+	* Resolves `undefined` when `cwd` is not in a repository: git reported so, or `cwd` doesn't exist. Any
+	* other failure (unsafe ownership, a timeout or cancellation, a missing git binary) rejects.
+	*/
 	async rev_parse__git_dir(cwd) {
-		const result = await this.run({
-			cwd,
-			errors: "ignore"
-		}, "rev-parse", "--git-dir", "--git-common-dir");
+		let result;
+		try {
+			result = await this.run({
+				cwd,
+				errors: "throw"
+			}, "rev-parse", "--git-dir", "--git-common-dir");
+		} catch (ex) {
+			if (ex instanceof GitError && GitWarnings.notARepository.test(ex.stderr ?? "")) return void 0;
+			if (!await fsExists(cwd)) return void 0;
+			throw ex;
+		}
 		if (!result.stdout) return void 0;
 		let [dotGitPath, commonDotGitPath] = result.stdout.split("\n").map((r) => r.trimStart());
 		if (!isAbsolute$1(dotGitPath)) dotGitPath = joinPaths(cwd, dotGitPath);
@@ -913,7 +957,7 @@ var Git = class {
 					errors: "ignore"
 				}, "rev-parse", "--is-bare-repository");
 				if (result.stdout.trim() === "true") {
-					const result = await this.rev_parse__git_dir(cwd);
+					const result = await this.rev_parse__git_dir(cwd).catch(() => void 0);
 					const repoPath = result?.commonPath ?? result?.path;
 					if (repoPath?.length) return [true, repoPath];
 				}
@@ -1003,6 +1047,6 @@ function defaultExceptionHandler(ex, cwd, start) {
 	throw ex;
 }
 //#endregion
-export { Git, GitError, GitErrors, GitWarnings, classifySearchError, classifySigningError, defaultExceptionHandler, getGitCommandError, gitConfigsBranch, gitConfigsDiff, gitConfigsLog, gitConfigsLogWithFiles, gitConfigsLogWithSignatures, gitConfigsPull, gitConfigsStatus, inferSigningFormatFromError, maxGitCliLength, slowCallWarningThreshold };
+export { Git, GitError, GitErrors, GitWarnings, batchLiteralPathspecs, classifySearchError, classifySigningError, defaultExceptionHandler, getGitCommandError, gitConfigsBranch, gitConfigsDiff, gitConfigsLog, gitConfigsLogWithFiles, gitConfigsLogWithSignatures, gitConfigsPull, gitConfigsStatus, inferSigningFormatFromError, maxGitCliLength, slowCallWarningThreshold };
 
 //# sourceMappingURL=git.js.map