Run git commands in dedicated renderer process

.eslintrc

@@ -20,6 +20,7 @@
     "MouseEvent": true,
     "IDBKeyRange": true,
     "beforeEach": true,
+    "after": true,
     "afterEach": true,
     "describe": true,
     "fdescribe": true,

lib/controllers/git-tab-controller.js

@@ -226,7 +226,7 @@ export default class GitTabController {
     const pathsToIgnore = [];
     const repository = this.getActiveRepository();
     for (const filePath of filePaths) {
-      if (await repository.pathHasMergeMarkers(filePath)) { // eslint-disable-line babel/no-await-in-loop
+      if (await repository.pathHasMergeMarkers(filePath)) { // eslint-disable-line no-await-in-loop
         const choice = atom.confirm({
           message: 'File contains merge markers: ',
           detailedMessage: `Do you still want to stage this file?\n${filePath}`,

lib/git-shell-out-strategy.js

@@ -2,14 +2,14 @@ import path from 'path';
 import os from 'os';
 
 import {CompositeDisposable} from 'event-kit';
-
 import {GitProcess} from 'dugite';
 import {parse as parseDiff} from 'what-the-diff';
 
 import GitPromptServer from './git-prompt-server';
 import AsyncQueue from './async-queue';
 import {getPackageRoot, getDugitePath, readFile, fileExists, writeFile, isFileExecutable} from './helpers';
 import GitTimingsView from './views/git-timings-view';
+import WorkerManager from './worker-manager';
 
 const LINE_ENDING_REGEX = /\r?\n/;
 
@@ -57,6 +57,7 @@ export default class GitShellOutStrategy {
     }
 
     this.prompt = options.prompt || (query => Promise.reject());
+    this.workerManager = options.workerManager;
   }
 
   /*
@@ -131,6 +132,7 @@ export default class GitShellOutStrategy {
       const options = {
         env,
         processCallback: child => {
+          // TODO: move callback to renderer process. send child.pid back to add cancel listener
           child.on('error', err => {
             console.warn('Error executing: ' + formattedArgs + ':');
             console.warn(err.stack);
@@ -156,51 +158,63 @@ export default class GitShellOutStrategy {
       if (process.env.PRINT_GIT_TIMES) {
         console.time(`git:${formattedArgs}`);
       }
-      return new Promise(resolve => {
+      return new Promise(async (resolve, reject) => {
         timingMarker.mark('nexttick');
-        setImmediate(() => {
-          timingMarker.mark('execute');
-          resolve(GitProcess.exec(args, this.workingDir, options)
-            .then(({stdout, stderr, exitCode}) => {
-              timingMarker.finalize();
-              if (process.env.PRINT_GIT_TIMES) {
-                console.timeEnd(`git:${formattedArgs}`);
-              }
-              if (gitPromptServer) {
-                gitPromptServer.terminate();
-              }
-              subscriptions.dispose();
-
-              if (diagnosticsEnabled) {
-                const headerStyle = 'font-weight: bold; color: blue;';
-
-                console.groupCollapsed(`git:${formattedArgs}`);
-                console.log('%cexit status%c %d', headerStyle, 'font-weight: normal; color: black;', exitCode);
-                console.log('%cstdout', headerStyle);
-                console.log(stdout);
-                console.log('%cstderr', headerStyle);
-                console.log(stderr);
-                console.groupEnd();
-              }
-
-              if (exitCode) {
-                const err = new GitError(
-                  `${formattedArgs} exited with code ${exitCode}\nstdout: ${stdout}\nstderr: ${stderr}`,
-                );
-                err.code = exitCode;
-                err.stdErr = stderr;
-                err.stdOut = stdout;
-                err.command = formattedArgs;
-                return Promise.reject(err);
-              }
-              return stdout;
-            }));
-        });
+        timingMarker.mark('execute');
+
+        const {stdout, stderr, exitCode} = await this.executeGitCommand(args, options);
+        timingMarker.finalize();
+        if (process.env.PRINT_GIT_TIMES) {
+          console.timeEnd(`git:${formattedArgs}`);
+        }
+        if (gitPromptServer) {
+          gitPromptServer.terminate();
+        }
+        subscriptions.dispose();
+
+        if (diagnosticsEnabled) {
+          const headerStyle = 'font-weight: bold; color: blue;';
+
+          console.groupCollapsed(`git:${formattedArgs}`);
+          console.log('%cexit status%c %d', headerStyle, 'font-weight: normal; color: black;', exitCode);
+          console.log('%cstdout', headerStyle);
+          console.log(stdout);
+          console.log('%cstderr', headerStyle);
+          console.log(stderr);
+          console.groupEnd();
+        }
+
+        if (exitCode) {
+          const err = new GitError(
+            `${formattedArgs} exited with code ${exitCode}\nstdout: ${stdout}\nstderr: ${stderr}`,
+          );
+          err.code = exitCode;
+          err.stdErr = stderr;
+          err.stdOut = stdout;
+          err.command = formattedArgs;
+          reject(err);
+        }
+        resolve(stdout);
       });
     }, {parallel: !writeOperation});
     /* eslint-enable no-console */
   }
 
+  executeGitCommand(args, options) {
+    const timeSent = performance.now(); // TODO: move to manager
+    if (process.env.ATOM_GITHUB_INLINE_GIT_EXEC) {
+      return GitProcess.exec(args, this.workingDir, options);
+    } else {
+      const workerManager = this.workerManager || WorkerManager.getInstance();
+      return workerManager.request({
+        args,
+        workingDir: this.workingDir,
+        options,
+        timeSent,
+      });
+    }
+  }
+
   /**
    * Execute a git command that may create a commit. If the command fails because the GPG binary was invoked and unable
    * to acquire a passphrase (because the pinentry program attempted to use a tty), retry with a `GitPromptServer`.

lib/renderer-process-manager.js

@@ -0,0 +1,136 @@
+import path from 'path';
+
+import {remote, ipcRenderer as ipc} from 'electron';
+const {BrowserWindow} = remote;
+import {Emitter} from 'event-kit';
+import {autobind} from 'core-decorators';
+
+import {getPackageRoot} from './helpers';
+
+export default class RendererProcessManager {
+  static instance = null;
+
+  static getInstance() {
+    if (!this.instance) {
+      this.instance = new RendererProcessManager();
+    }
+    return this.instance;
+  }
+
+  static reset() {
+    if (this.instance) { this.instance.destroy(); }
+    this.instance = null;
+  }
+
+  constructor() {
+    this.hostWebContentsId = remote.getCurrentWebContents().id;
+    this.activeRenderer = null;
+    this.renderers = new Set();
+    this.createNewRenderer();
+  }
+
+  @autobind
+  createNewRenderer(previousOperationCount = 0, previousLimit = 10) {
+    let newLimit = 10;
+    if (previousOperationCount === previousLimit && Math.random() < 0.85) {
+      newLimit = Math.min(previousLimit * 2, 100);
+    }
+    this.activeRenderer = new RendererProcess(this.hostWebContentsId, newLimit, {
+      onDying: (operationCount, limit) => { this.createNewRenderer(operationCount, limit); },
+      onDestroyed: renderer => { this.renderers.delete(renderer); },
+    });
+    this.renderers.add(this.activeRenderer);
+  }
+
+  async request(data) {
+    await this.activeRenderer.getReadyPromise();
+    return this.activeRenderer.send(data);
+  }
+
+  destroy() {
+    this.renderers.forEach(renderer => renderer.destroy());
+  }
+}
+
+class RendererProcess {
+  constructor(hostWebContentsId, limit, {onDying, onDestroyed}) {
+    this.hostWebContentsId = hostWebContentsId;
+    this.onDying = onDying;
+    this.onDestroyed = onDestroyed;
+    this.resolveByOperationId = new Map();
+    this.operationId = 0;
+    this.dying = false;
+
+    this.win = new BrowserWindow({show: !!process.env.ATOM_GITHUB_SHOW_RENDERER_WINDOW});
+    this.win.webContents.openDevTools();
+    this.childWebContentsId = this.win.webContents.id;
+    this.channelName = `message-${this.childWebContentsId}`;
+
+    this.emitter = new Emitter();
+    this.registerListeners();
+
+    const htmlPath = path.join(getPackageRoot(), 'lib', 'renderer.html');
+    const rendererJsPath = path.join(getPackageRoot(), 'lib', 'renderer.js');
+    this.win.loadURL(
+      `file://${htmlPath}?js=${rendererJsPath}&hostWebContentsId=${this.hostWebContentsId}&limit=${limit}`,
+    );
+
+    this.readyPromise = new Promise(resolve => { this.resolveReady = resolve; });
+  }
+
+  registerListeners() {
+    ipc.on(this.channelName, this.handleMessages);
+    this.emitter.on('renderer-ready', this.handleRendererReady);
+    this.emitter.on('git-data', this.handleGitDataReceived);
+    this.emitter.on('slow-spawns', this.handleDying);
+  }
+
+  @autobind
+  handleMessages(event, {type, data}) {
+    this.emitter.emit(type, data);
+  }
+
+  @autobind
+  handleRendererReady() {
+    this.resolveReady();
+  }
+
+  @autobind
+  handleGitDataReceived({operationId, results, average}) {
+    const resolve = this.resolveByOperationId.get(operationId);
+    resolve(results);
+    this.resolveByOperationId.delete(operationId);
+
+    if (this.dying && this.resolveByOperationId.size === 0) {
+      this.destroy();
+      this.onDestroyed(this);
+    }
+  }
+
+  @autobind
+  handleDying({operationCount, limit}) {
+    if (this.dying) { return; }
+    this.dying = true;
+    this.onDying(operationCount, limit);
+  }
+
+  send(data) {
+    return new Promise(resolve => {
+      this.resolveByOperationId.set(++this.operationId, resolve);
+      this.win.webContents.send(`message-${this.childWebContentsId}`, {
+        type: 'git-exec',
+        data: {...data, operationId: this.operationId},
+      });
+    });
+  }
+
+  getReadyPromise() {
+    return this.readyPromise;
+  }
+
+  destroy() {
+    ipc.removeListener(this.channelName, this.handleMessages);
+    this.emitter.dispose();
+    this.win.destroy();
+  }
+}

lib/renderer.html

@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title></title>
+    <script type="text/javascript">
+      const qs = require('querystring')
+      const jsPath = qs.parse(window.location.search.substr(1)).js
+      require(jsPath)
+    </script>
+  </head>
+  <body>
+    <h1>GitHub Package Git Execution Window</h1>
+    <p>
+      Hi there! This renderer window is used by the GitHub pacakge to execute Git commands in the background.
+    </p>
+  </body>
+</html>