GH-3736: Use the system Git in electron.

packages/git/package.json

@@ -14,6 +14,7 @@
     "@types/p-queue": "^2.3.1",
     "diff": "^3.4.0",
     "dugite-extra": "0.1.9",
+    "find-git-exec": "^0.0.1-alpha.2",
     "find-git-repositories": "^0.1.0",
     "fs-extra": "^4.0.2",
     "moment": "^2.21.0",
@@ -33,6 +34,10 @@
       "backend": "lib/node/env/git-env-module",
       "backendElectron": "lib/electron-node/env/electron-git-env-module"
     },
+    {
+      "backend": "lib/node/init/git-init-module",
+      "backendElectron": "lib/electron-node/init/electron-git-init-module"
+    },
     {
       "frontend": "lib/browser/prompt/git-prompt-module",
       "frontendElectron": "lib/electron-browser/prompt/electron-git-prompt-module"

packages/git/src/electron-node/init/electron-git-init-module.ts

@@ -0,0 +1,24 @@
+/********************************************************************************
+ * Copyright (C) 2018 TypeFox and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { ContainerModule } from 'inversify';
+import { GitInit } from '../../node/init/git-init';
+import { ElectronGitInit } from './electron-git-init';
+
+export default new ContainerModule(bind => {
+    bind(ElectronGitInit).toSelf();
+    bind(GitInit).toService(ElectronGitInit);
+});

packages/git/src/electron-node/init/electron-git-init.ts

@@ -0,0 +1,67 @@
+/********************************************************************************
+ * Copyright (C) 2018 TypeFox and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { inject, injectable } from 'inversify';
+import findGit from 'find-git-exec';
+import { dirname } from 'path';
+import { pathExists } from 'fs-extra';
+import { ILogger } from '@theia/core/lib/common/logger';
+import { DefaultGitInit } from '../../node/init/git-init';
+
+/**
+ * The Git initializer for electron. If Git can be found on the `PATH`, it will be used instead of the embedded Git shipped with `dugite`.
+ */
+@injectable()
+export class ElectronGitInit extends DefaultGitInit {
+
+    @inject(ILogger)
+    protected readonly logger: ILogger;
+
+    async init(): Promise<void> {
+        const { env } = process;
+        if (typeof env.LOCAL_GIT_DIRECTORY !== 'undefined' || typeof env.GIT_EXEC_PATH !== 'undefined') {
+            await this.handleExternalNotFound('Cannot use Git from the PATH when the LOCAL_GIT_DIRECTORY or the GIT_EXEC_PATH environment variables are set.');
+        } else {
+            try {
+                const { execPath, path, version } = await findGit();
+                if (!!execPath && !!path && !!version) {
+                    // https://github.com/desktop/dugite/issues/111#issuecomment-323222834
+                    // Instead of the executable path, we need the root directory of Git.
+                    const dir = dirname(dirname(path));
+                    const [execPathOk, pathOk, dirOk] = await Promise.all([pathExists(execPath), pathExists(path), pathExists(dir)]);
+                    if (execPathOk && pathOk && dirOk) {
+                        process.env.LOCAL_GIT_DIRECTORY = dir;
+                        process.env.GIT_EXEC_PATH = execPath;
+                        this.logger.info(`Using Git [${version}] from the PATH. (${path})`);
+                        return;
+                    }
+                }
+                await this.handleExternalNotFound();
+            } catch (err) {
+                await this.handleExternalNotFound(err);
+            }
+        }
+    }
+
+    // tslint:disable-next-line:no-any
+    protected async handleExternalNotFound(err?: any): Promise<void> {
+        if (err) {
+            this.logger.error(err);
+        }
+        this.logger.info('Could not find Git on the PATH. Falling back to the embedded Git.');
+    }
+
+}

packages/git/src/node/dugite-git.ts

@@ -45,6 +45,7 @@ import { GitRepositoryManager } from './git-repository-manager';
 import { GitLocator } from './git-locator/git-locator-protocol';
 import { GitExecProvider } from './git-exec-provider';
 import { GitEnvProvider } from './env/git-env-provider';
+import { GitInit } from './init/git-init';
 
 /**
  * Parsing and converting raw Git output into Git model instances.
@@ -308,26 +309,39 @@ export class DugiteGit implements Git {
     @inject(GitEnvProvider)
     protected readonly envProvider: GitEnvProvider;
 
+    @inject(GitInit)
+    protected readonly gitInit: GitInit;
+
+    protected ready: Deferred<void> = new Deferred();
     protected gitEnv: Deferred<Object> = new Deferred();
 
     @postConstruct()
     protected init(): void {
         this.envProvider.getEnv().then(env => this.gitEnv.resolve(env));
+        this.gitInit.init()
+            .catch(err => {
+                this.logger.error('An error occurred during the Git initialization.', err);
+                this.ready.resolve();
+            })
+            .then(() => this.ready.resolve());
     }
 
     dispose(): void {
         this.locator.dispose();
         this.execProvider.dispose();
+        this.gitInit.dispose();
     }
 
     async clone(remoteUrl: string, options: Git.Options.Clone): Promise<Repository> {
+        await this.ready.promise;
         const { localUri, branch } = options;
         const [exec, env] = await Promise.all([this.execProvider.exec(), this.gitEnv.promise]);
         await clone(remoteUrl, this.getFsPath(localUri), { branch }, { exec, env });
         return { localUri };
     }
 
     async repositories(workspaceRootUri: string, options: Git.Options.Repositories): Promise<Repository[]> {
+        await this.ready.promise;
         const workspaceRootPath = this.getFsPath(workspaceRootUri);
         const repositories: Repository[] = [];
         const containingPath = await this.resolveContainingPath(workspaceRootPath);
@@ -353,13 +367,15 @@ export class DugiteGit implements Git {
     }
 
     async status(repository: Repository): Promise<WorkingDirectoryStatus> {
+        await this.ready.promise;
         const repositoryPath = this.getFsPath(repository);
         const [exec, env] = await Promise.all([this.execProvider.exec(), this.gitEnv.promise]);
         const dugiteStatus = await getStatus(repositoryPath, true, this.limit, { exec, env });
         return this.mapStatus(dugiteStatus, repository);
     }
 
     async add(repository: Repository, uri: string | string[]): Promise<void> {
+        await this.ready.promise;
         const paths = (Array.isArray(uri) ? uri : [uri]).map(FileUri.fsPath);
         const [exec, env] = await Promise.all([this.execProvider.exec(), this.gitEnv.promise]);
         return this.manager.run(repository, () =>
@@ -368,6 +384,7 @@ export class DugiteGit implements Git {
     }
 
     async unstage(repository: Repository, uri: string | string[], options?: Git.Options.Unstage): Promise<void> {
+        await this.ready.promise;
         const paths = (Array.isArray(uri) ? uri : [uri]).map(FileUri.fsPath);
         const treeish = options && options.treeish ? options.treeish : undefined;
         const where = options && options.reset ? options.reset : undefined;
@@ -382,6 +399,7 @@ export class DugiteGit implements Git {
     async branch(repository: Repository, options: Git.Options.BranchCommand.Create | Git.Options.BranchCommand.Rename | Git.Options.BranchCommand.Delete): Promise<void>;
     // tslint:disable-next-line:no-any
     async branch(repository: any, options: any): Promise<void | undefined | Branch | Branch[]> {
+        await this.ready.promise;
         const [exec, env] = await Promise.all([this.execProvider.exec(), this.gitEnv.promise]);
         const repositoryPath = this.getFsPath(repository);
         if (GitUtils.isBranchList(options)) {
@@ -407,6 +425,7 @@ export class DugiteGit implements Git {
     }
 
     async checkout(repository: Repository, options: Git.Options.Checkout.CheckoutBranch | Git.Options.Checkout.WorkingTreeFile): Promise<void> {
+        await this.ready.promise;
         const [exec, env] = await Promise.all([this.execProvider.exec(), this.gitEnv.promise]);
         return this.manager.run(repository, () => {
             const repositoryPath = this.getFsPath(repository);
@@ -422,6 +441,7 @@ export class DugiteGit implements Git {
     }
 
     async commit(repository: Repository, message?: string, options?: Git.Options.Commit): Promise<void> {
+        await this.ready.promise;
         const signOff = options && options.signOff;
         const amend = options && options.amend;
         const [exec, env] = await Promise.all([this.execProvider.exec(), this.gitEnv.promise]);
@@ -431,6 +451,7 @@ export class DugiteGit implements Git {
     }
 
     async fetch(repository: Repository, options?: Git.Options.Fetch): Promise<void> {
+        await this.ready.promise;
         const repositoryPath = this.getFsPath(repository);
         const r = await this.getDefaultRemote(repositoryPath, options ? options.remote : undefined);
         if (r) {
@@ -443,6 +464,7 @@ export class DugiteGit implements Git {
     }
 
     async push(repository: Repository, { remote, localBranch, remoteBranch, setUpstream, force }: Git.Options.Push = {}): Promise<void> {
+        await this.ready.promise;
         const repositoryPath = this.getFsPath(repository);
         const currentRemote = await this.getDefaultRemote(repositoryPath, remote);
         if (currentRemote === undefined) {
@@ -472,6 +494,7 @@ export class DugiteGit implements Git {
     }
 
     async pull(repository: Repository, { remote, branch, rebase }: Git.Options.Pull = {}): Promise<void> {
+        await this.ready.promise;
         const repositoryPath = this.getFsPath(repository);
         const currentRemote = await this.getDefaultRemote(repositoryPath, remote);
         if (currentRemote === undefined) {
@@ -496,6 +519,7 @@ export class DugiteGit implements Git {
     }
 
     async reset(repository: Repository, options: Git.Options.Reset): Promise<void> {
+        await this.ready.promise;
         const repositoryPath = this.getFsPath(repository);
         const mode = this.getResetMode(options.mode);
         const [exec, env] = await Promise.all([this.execProvider.exec(), this.gitEnv.promise]);
@@ -505,6 +529,7 @@ export class DugiteGit implements Git {
     }
 
     async merge(repository: Repository, options: Git.Options.Merge): Promise<void> {
+        await this.ready.promise;
         const repositoryPath = this.getFsPath(repository);
         const [exec, env] = await Promise.all([this.execProvider.exec(), this.gitEnv.promise]);
         return this.manager.run(repository, () =>
@@ -513,6 +538,7 @@ export class DugiteGit implements Git {
     }
 
     async show(repository: Repository, uri: string, options?: Git.Options.Show): Promise<string> {
+        await this.ready.promise;
         const encoding = options ? options.encoding || 'utf8' : 'utf8';
         const commitish = this.getCommitish(options);
         const repositoryPath = this.getFsPath(repository);
@@ -525,11 +551,13 @@ export class DugiteGit implements Git {
     }
 
     async remote(repository: Repository): Promise<string[]> {
+        await this.ready.promise;
         const repositoryPath = this.getFsPath(repository);
         return this.getRemotes(repositoryPath);
     }
 
     async exec(repository: Repository, args: string[], options?: Git.Options.Execution): Promise<GitResult> {
+        await this.ready.promise;
         const repositoryPath = this.getFsPath(repository);
         return this.manager.run(repository, async () => {
             const name = options && options.name ? options.name : '';
@@ -550,6 +578,7 @@ export class DugiteGit implements Git {
     }
 
     async diff(repository: Repository, options?: Git.Options.Diff): Promise<GitFileChange[]> {
+        await this.ready.promise;
         const args = ['diff', '--name-status', '-C', '-M', '-z'];
         args.push(this.mapRange((options || {}).range));
         if (options && options.uri) {
@@ -561,6 +590,7 @@ export class DugiteGit implements Git {
     }
 
     async log(repository: Repository, options?: Git.Options.Log): Promise<CommitWithChanges[]> {
+        await this.ready.promise;
         // If remaining commits should be calculated by the backend, then run `git rev-list --count ${fromRevision | HEAD~fromRevision}`.
         // How to use `mailmap` to map authors: https://www.kernel.org/pub/software/scm/git/docs/git-shortlog.html.
         const args = ['log'];
@@ -589,6 +619,7 @@ export class DugiteGit implements Git {
     }
 
     async blame(repository: Repository, uri: string, options?: Git.Options.Blame): Promise<GitFileBlame | undefined> {
+        await this.ready.promise;
         const args = ['blame', '--root', '--incremental'];
         const file = Path.relative(this.getFsPath(repository), this.getFsPath(uri));
         const repositoryPath = this.getFsPath(repository);
@@ -623,6 +654,7 @@ export class DugiteGit implements Git {
 
     // tslint:disable-next-line:no-any
     async lsFiles(repository: Repository, uri: string, options?: Git.Options.LsFiles): Promise<any> {
+        await this.ready.promise;
         const args = ['ls-files'];
         const file = Path.relative(this.getFsPath(repository), this.getFsPath(uri));
         if (options && options.errorUnmatch) {
@@ -645,6 +677,7 @@ export class DugiteGit implements Git {
     // TODO: akitta what about symlinks? What if the workspace root is a symlink?
     // Maybe, we should use `--show-cdup` here instead of `--show-toplevel` because `show-toplevel` dereferences symlinks.
     private async resolveContainingPath(repositoryPath: string): Promise<string | undefined> {
+        await this.ready.promise;
         // Do not log an error if we are not contained in a Git repository. Treat exit code 128 as a success too.
         const [exec, env] = await Promise.all([this.execProvider.exec(), this.gitEnv.promise]);
         const options = { successExitCodes: new Set([0, 128]), exec, env };
@@ -662,6 +695,7 @@ export class DugiteGit implements Git {
     }
 
     private async getRemotes(repositoryPath: string): Promise<string[]> {
+        await this.ready.promise;
         const [exec, env] = await Promise.all([this.execProvider.exec(), this.gitEnv.promise]);
         const result = await git(['remote'], repositoryPath, 'remote', { exec, env });
         const out = result.stdout || '';
@@ -677,6 +711,7 @@ export class DugiteGit implements Git {
     }
 
     private async getCurrentBranch(repositoryPath: string, localBranch?: string): Promise<Branch | string> {
+        await this.ready.promise;
         if (localBranch !== undefined) {
             return localBranch;
         }

packages/git/src/node/init/git-init-module.ts

@@ -0,0 +1,23 @@
+/********************************************************************************
+ * Copyright (C) 2018 TypeFox and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { ContainerModule } from 'inversify';
+import { GitInit, DefaultGitInit } from './git-init';
+
+export default new ContainerModule(bind => {
+    bind(DefaultGitInit).toSelf();
+    bind(GitInit).toService(DefaultGitInit);
+});