Function enqueueProjectSync

src/node/runtime/SSHRuntime.ts:162–211

(
  projectKey: string,
  abortSignal: AbortSignal | undefined,
  fn: () => Promise<void>
)

const sharedProjectSyncTails = new Map<string, Promise<void>>();

async function enqueueProjectSync(
  projectKey: string,
  abortSignal: AbortSignal | undefined,
  fn: () => Promise<void>
): Promise<void> {
  const previous = sharedProjectSyncTails.get(projectKey) ?? Promise.resolve();
  let releaseCurrent: (() => void) | undefined;
  const current = new Promise<void>((resolve) => {
    releaseCurrent = resolve;
  });
  const tail = previous.then(
    () => current,
    () => current
  );
  sharedProjectSyncTails.set(projectKey, tail);
  void tail.finally(() => {
    if (sharedProjectSyncTails.get(projectKey) === tail) {
      sharedProjectSyncTails.delete(projectKey);
    }
  });

  let onAbort: (() => void) | undefined;
  const waitForPrevious = previous.catch(() => undefined);
  const waitForTurn = abortSignal
    ? Promise.race([
        waitForPrevious,
        new Promise<never>((_, reject) => {
          onAbort = () => reject(new Error(OPERATION_ABORTED_ERROR));
          if (abortSignal.aborted) {
            onAbort();
            return;
          }
          abortSignal.addEventListener("abort", onAbort, { once: true });
        }),
      ])
    : waitForPrevious;

  try {
    await waitForTurn;
    if (abortSignal?.aborted) {
      throw new Error(OPERATION_ABORTED_ERROR);
    }
    await fn();
  } finally {
    if (onAbort) {
      abortSignal?.removeEventListener("abort", onAbort);
    }
    releaseCurrent?.();
  }
}

function isGitConfigLockConflict(message: string): boolean {
  return /could not lock config file/i.test(message);