Initial commit

Co-Authored-By: Eric Tuvesson <eric.tuvesson@gmail.com>
Co-Authored-By: mikaeltellhed <2311083+mikaeltellhed@users.noreply.github.com>
Co-Authored-By: kotte <14197736+mrtamagotchi@users.noreply.github.com>
Co-Authored-By: Anders Larsson <64838990+anders-topp@users.noreply.github.com>
Co-Authored-By: Johan  <4934465+joolsus@users.noreply.github.com>
Co-Authored-By: Tore Knudsen <18231882+torekndsn@users.noreply.github.com>
Co-Authored-By: victoratndl <99176179+victoratndl@users.noreply.github.com>

packages/noodl-git/src/core/client.ts

@@ -0,0 +1,175 @@
+import { ChildProcess } from 'child_process';
+import { GitError as DugiteError } from 'dugite';
+import { IGitSpawnExecutionOptions } from 'dugite/build/lib/git-process';
+
+import { getGitPath } from '../paths';
+import * as ClientExec from './client/client-exec';
+import * as ClientSpawn from './client/client-spawn';
+import { IGitRunOptions } from './client/common';
+import { IGitResult } from './git-error';
+import { withTrampolineEnv } from './trampoline/trampoline-environment';
+
+/**
+ * Return an array of command line arguments for network operation that override
+ * the default git configuration values provided by local, global, or system
+ * level git configs.
+ *
+ * These arguments should be inserted before the subcommand, i.e in
+ * the case of `git pull` these arguments needs to go before the `pull`
+ * argument.
+ *
+ * This should be used on the commands where we want to use
+ * the trampoline server.
+ *
+ * @param repository the local repository associated with the command, to check
+ *                   local, global and system config for an existing value.
+ *                   If `null` if provided (for example, when cloning a new
+ *                   repository), this function will check global and system
+ *                   config for an existing `protocol.version` setting
+ */
+export async function gitNetworkArguments(_repositoryDir: string | null): Promise<ReadonlyArray<string>> {
+  const baseArgs = [
+    // Explicitly unset any defined credential helper, we rely on our
+    // own askpass for authentication.
+    '-c',
+    'credential.helper='
+  ];
+
+  return baseArgs;
+}
+
+export interface GitExecutionOptions extends IGitSpawnExecutionOptions {
+  /**
+   * The exit codes which indicate success to the
+   * caller. Unexpected exit codes will be logged and an
+   * error thrown. Defaults to 0 if undefined.
+   */
+  readonly successExitCodes?: ReadonlySet<number>;
+
+  /**
+   * The git errors which are expected by the caller. Unexpected errors will
+   * be logged and an error thrown.
+   */
+  readonly expectedErrors?: ReadonlySet<DugiteError>;
+
+  /**
+   * An optional string or buffer which will be written to
+   * the child process stdin stream immediately immediately
+   * after spawning the process.
+   */
+  readonly stdin?: string | Buffer;
+
+  /**
+   * The encoding to use when writing to stdin, if the stdin
+   * parameter is a string.
+   */
+  readonly stdinEncoding?: BufferEncoding;
+
+  /**
+   * While this is true; it will spawn the process instead which
+   * results in that we can handle more of the output from the
+   * process.
+   * Otherwise the data will be cut off.
+   *
+   * Default: true
+   */
+  readonly spawn?: boolean;
+
+  /**
+   * The size the output buffer to allocate to the spawned process. Set this
+   * if you are anticipating a large amount of output.
+   *
+   * If not specified, this will be 10MB (10485760 bytes) which should be
+   * enough for most Git operations.
+   */
+  readonly maxBuffer?: number;
+
+  /**
+   * Should the process output be checked for errors?
+   * Can be very slow when there's lost of output
+   *
+   * If not specified, this defaults to true
+   */
+  readonly parseErrors?: boolean;
+
+  /**
+   * An optional callback which will be invoked with the child
+   * process instance after spawning the git process.
+   *
+   * Note that if the stdin parameter was specified the stdin
+   * stream will be closed by the time this callback fires.
+   */
+  readonly processCallback?: (process: ChildProcess) => void;
+
+  readonly processDataCallback?: (chunk: Buffer) => void;
+}
+
+/**
+ * Shell out to git with the given arguments, at the given path.
+ *
+ * @param args             The arguments to pass to `git`.
+ *
+ * @param path             The working directory path for the execution of the
+ *                         command.
+ *
+ * @param name             The name for the command based on its caller's
+ *                         context. This will be used for performance
+ *                         measurements and debugging.
+ *
+ * @param options          Configuration options for the execution of git,
+ *                         see GitExecutionOptions for more information.
+ *
+ * Returns the result. If the command exits with a code not in
+ * `successExitCodes` or an error not in `expectedErrors`, a `GitError` will be
+ * thrown.
+ */
+export async function git(
+  args: string[],
+  path: string,
+  name: string,
+  options?: GitExecutionOptions
+): Promise<IGitResult> {
+  return withTrampolineEnv(async (env) => {
+    const enableLogging = !!localStorage.getItem('git-output');
+    const enableTraceLogging = !!localStorage.getItem('git-trace');
+
+    if (enableLogging) {
+      console.groupCollapsed(`[${name}] git ${args.join(' ')}`);
+      console.log('path', path);
+      console.log('args', args);
+      console.log('options', options);
+      console.groupEnd();
+    }
+
+    if (!process.env.LOCAL_GIT_DIRECTORY) {
+      process.env.LOCAL_GIT_DIRECTORY = getGitPath();
+    }
+
+    const runOptions: IGitRunOptions = {
+      name,
+      path,
+      args,
+      enableLogging,
+      options: {
+        ...(options || {}),
+        env: {
+          // Add the input envs
+          ...(options?.env || {}),
+
+          // Add the trampoline env
+          ...env,
+
+          // Add extra envs
+          GIT_TERMINAL_PROMPT: '0',
+          GIT_TRACE: enableTraceLogging ? '1' : '0'
+        }
+      }
+    };
+
+    if (options?.spawn) {
+      return await ClientSpawn.execute(runOptions);
+    }
+
+    return await ClientExec.execute(runOptions);
+  });
+}