Introduce per user installation of modules and elevated global install as an option

package.json

@@ -925,6 +925,12 @@
 					"description": "Whether to check if Python is installed.",
 					"scope": "resource"
 				},
+				"python.globalModuleInstallation": {
+					"type": "boolean",
+					"default": false,
+					"description": "Whether to install Python modules globally.",
+					"scope": "resource"
+				},
 				"python.linting.enabled": {
 					"type": "boolean",
 					"default": true,
@@ -1547,6 +1553,7 @@
 		"reflect-metadata": "^0.1.10",
 		"rxjs": "^5.5.2",
 		"semver": "^5.4.1",
+		"sudo-prompt": "^8.0.0",
 		"tmp": "0.0.29",
 		"tree-kill": "^1.1.0",
 		"typescript-char": "^0.0.0",

pythonFiles/completion.py

@@ -198,7 +198,7 @@ def _serialize_completions(self, script, identifier=None, prefix=''):
             # we pass 'text' here only for fuzzy matcher
             if value:
                 _completion['snippet'] = '%s=${1:%s}$0' % (name, value)
-                _completion['text'] = '%s=%s' % (name, value)
+                _completion['text'] = '%s=' % (name)
             else:
                 _completion['snippet'] = '%s=$1$0' % name
                 _completion['text'] = name

src/client/common/configSettings.ts

@@ -27,6 +27,7 @@ export interface IPythonSettings {
     envFile: string;
     disablePromptForFeatures: string[];
     disableInstallationChecks: boolean;
+    globalModuleInstallation: boolean;
 }
 export interface ISortImportSettings {
     path: string;
@@ -147,6 +148,7 @@ export class PythonSettings extends EventEmitter implements IPythonSettings {
     public sortImports: ISortImportSettings;
     public workspaceSymbols: IWorkspaceSymbolSettings;
     public disableInstallationChecks: boolean;
+    public globalModuleInstallation: boolean;
 
     private workspaceRoot: vscode.Uri;
     private disposables: vscode.Disposable[] = [];
@@ -224,7 +226,10 @@ export class PythonSettings extends EventEmitter implements IPythonSettings {
         } else {
             this.linting = lintingSettings;
         }
+
         this.disableInstallationChecks = pythonSettings.get<boolean>('disableInstallationCheck') === true;
+        this.globalModuleInstallation = pythonSettings.get<boolean>('globalModuleInstallation') === true;
+
         // tslint:disable-next-line:no-backbone-get-set-outside-model no-non-null-assertion
         const sortImportSettings = systemVariables.resolveAny(pythonSettings.get<ISortImportSettings>('sortImports'))!;
         if (this.sortImports) {

src/client/common/helpers.ts

@@ -13,7 +13,7 @@ export function isNotInstalledError(error: Error): boolean {
         return true;
     }
 
-    const isModuleNoInstalledError = errorObj.code === 1 && error.message.indexOf('No module named') >= 0;
+    const isModuleNoInstalledError = error.message.indexOf('No module named') >= 0;
     return errorObj.code === 'ENOENT' || errorObj.code === 127 || isModuleNoInstalledError;
 }
 

src/client/common/installer/moduleInstaller.ts

@@ -1,27 +1,97 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
+// tslint:disable-next-line:no-require-imports no-var-requires
+const sudo = require('sudo-prompt');
+
+import * as fs from 'fs';
 import { injectable } from 'inversify';
-import { Uri } from 'vscode';
+import * as path from 'path';
+import * as vscode from 'vscode';
+import { IInterpreterLocatorService, INTERPRETER_LOCATOR_SERVICE, InterpreterType } from '../../interpreter/contracts';
 import { IServiceContainer } from '../../ioc/types';
 import { PythonSettings } from '../configSettings';
+import { STANDARD_OUTPUT_CHANNEL } from '../constants';
+import { IFileSystem } from '../platform/types';
 import { ITerminalService } from '../terminal/types';
-import { ExecutionInfo } from '../types';
+import { ExecutionInfo, IOutputChannel } from '../types';
 
 @injectable()
 export abstract class ModuleInstaller {
     constructor(protected serviceContainer: IServiceContainer) { }
-    public async installModule(name: string, resource?: Uri): Promise<void> {
+    public async installModule(name: string, resource?: vscode.Uri): Promise<void> {
         const executionInfo = await this.getExecutionInfo(name, resource);
         const terminalService = this.serviceContainer.get<ITerminalService>(ITerminalService);
 
         if (executionInfo.moduleName) {
-            const pythonPath = PythonSettings.getInstance(resource).pythonPath;
-            await terminalService.sendCommand(pythonPath, ['-m', 'pip'].concat(executionInfo.args));
+            const settings = PythonSettings.getInstance(resource);
+            const args = ['-m', 'pip'].concat(executionInfo.args);
+            const pythonPath = settings.pythonPath;
+
+            const locator = this.serviceContainer.get<IInterpreterLocatorService>(IInterpreterLocatorService, INTERPRETER_LOCATOR_SERVICE);
+            const fileSystem = this.serviceContainer.get<IFileSystem>(IFileSystem);
+            const interpreters = await locator.getInterpreters(resource);
+
+            const currentInterpreter = interpreters.length > 1
+                ? interpreters.filter(x => fileSystem.arePathsSame(x.path, pythonPath))[0]
+                : interpreters[0];
+
+            if (!currentInterpreter || currentInterpreter.type !== InterpreterType.Unknown) {
+                await terminalService.sendCommand(pythonPath, args);
+            } else if (settings.globalModuleInstallation) {
+                if (await this.isPathWritableAsync(path.dirname(pythonPath))) {
+                    await terminalService.sendCommand(pythonPath, args);
+                } else {
+                    this.elevatedInstall(pythonPath, args);
+                }
+            } else {
+                await terminalService.sendCommand(pythonPath, args.concat(['--user']));
+            }
         } else {
             await terminalService.sendCommand(executionInfo.execPath!, executionInfo.args);
         }
     }
-    public abstract isSupported(resource?: Uri): Promise<boolean>;
-    protected abstract getExecutionInfo(moduleName: string, resource?: Uri): Promise<ExecutionInfo>;
+    public abstract isSupported(resource?: vscode.Uri): Promise<boolean>;
+    protected abstract getExecutionInfo(moduleName: string, resource?: vscode.Uri): Promise<ExecutionInfo>;
+
+    private async isPathWritableAsync(directoryPath: string): Promise<boolean> {
+        const filePath = `${directoryPath}${path.sep}___vscpTest___`;
+        return new Promise<boolean>(resolve => {
+            fs.open(filePath, fs.constants.O_CREAT | fs.constants.O_RDWR, (error, fd) => {
+                if (!error) {
+                    fs.close(fd, (e) => {
+                        fs.unlink(filePath);
+                    });
+                }
+                return resolve(!error);
+            });
+        });
+    }
+
+    private elevatedInstall(execPath: string, args: string[]) {
+        const options = {
+            name: 'VS Code Python'
+        };
+        const outputChannel = this.serviceContainer.get<vscode.OutputChannel>(IOutputChannel, STANDARD_OUTPUT_CHANNEL);
+        const command = `"${execPath.replace(/\\/g, '/')}" ${args.join(' ')}`;
+
+        outputChannel.appendLine('');
+        outputChannel.appendLine(`[Elevated] ${command}`);
+
+        sudo.exec(command, options, (error, stdout, stderr) => {
+            if (error) {
+                vscode.window.showErrorMessage(error);
+            } else {
+                outputChannel.show();
+                if (stdout) {
+                    outputChannel.appendLine('');
+                    outputChannel.append(stdout);
+                }
+                if (stderr) {
+                    outputChannel.appendLine('');
+                    outputChannel.append(`Warning: ${stderr}`);
+                }
+            }
+        });
+    }
 }

src/client/common/serviceRegistry.ts

@@ -8,7 +8,10 @@ import { Installer } from './installer/installer';
 import { Logger } from './logger';
 import { PersistentStateFactory } from './persistentState';
 import { IS_64_BIT, IS_WINDOWS } from './platform/constants';
+import { FileSystem } from './platform/fileSystem';
 import { PathUtils } from './platform/pathUtils';
+import { PlatformService } from './platform/platformService';
+import { IFileSystem, IPlatformService } from './platform/types';
 import { CurrentProcess } from './process/currentProcess';
 import { TerminalService } from './terminal/service';
 import { ITerminalService } from './terminal/types';
@@ -25,4 +28,5 @@ export function registerTypes(serviceManager: IServiceManager) {
     serviceManager.addSingleton<IApplicationShell>(IApplicationShell, ApplicationShell);
     serviceManager.addSingleton<ICurrentProcess>(ICurrentProcess, CurrentProcess);
     serviceManager.addSingleton<IInstaller>(IInstaller, Installer);
+    serviceManager.addSingleton<IFileSystem>(IFileSystem, FileSystem);
 }

src/client/common/terminal/types.ts

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
-export const ITerminalService = Symbol('ITerminalCommandService');
+export const ITerminalService = Symbol('ITerminalService');
 
 export interface ITerminalService {
     sendCommand(command: string, args: string[]): Promise<void>;

src/client/formatters/baseFormatter.ts

@@ -88,7 +88,7 @@ export abstract class BaseFormatter {
         if (isNotInstalledError(error)) {
             const installer = this.serviceContainer.get<IInstaller>(IInstaller);
             const isInstalled = await installer.isInstalled(this.product, resource);
-            if (isInstalled) {
+            if (!isInstalled) {
                 customError += `\nYou could either install the '${this.Id}' formatter, turn it off or use another formatter.`;
                 installer.promptToInstall(this.product, resource).catch(ex => console.error('Python Extension: promptToInstall', ex));
             }

src/test/common/moduleInstaller.test.ts

@@ -8,13 +8,16 @@ import { PipInstaller } from '../../client/common/installer/pipInstaller';
 import { IModuleInstaller } from '../../client/common/installer/types';
 import { Logger } from '../../client/common/logger';
 import { PersistentStateFactory } from '../../client/common/persistentState';
+import { FileSystem } from '../../client/common/platform/fileSystem';
 import { PathUtils } from '../../client/common/platform/pathUtils';
-import { Architecture } from '../../client/common/platform/types';
+import { PlatformService } from '../../client/common/platform/platformService';
+import { Architecture, IFileSystem, IPlatformService } from '../../client/common/platform/types';
 import { CurrentProcess } from '../../client/common/process/currentProcess';
 import { IProcessService, IPythonExecutionFactory } from '../../client/common/process/types';
 import { ITerminalService } from '../../client/common/terminal/types';
 import { ICurrentProcess, IInstaller, ILogger, IPathUtils, IPersistentStateFactory, IsWindows } from '../../client/common/types';
 import { ICondaLocatorService, IInterpreterLocatorService, INTERPRETER_LOCATOR_SERVICE, InterpreterType } from '../../client/interpreter/contracts';
+import { PythonInterpreterLocatorService } from '../../client/interpreter/locators/index';
 import { updateSetting } from '../common';
 import { rootWorkspaceUri } from '../common';
 import { MockProvider } from '../interpreters/mocks';
@@ -60,6 +63,8 @@ suite('Module Installer', () => {
         ioc.serviceManager.addSingleton<ICondaLocatorService>(ICondaLocatorService, MockCondaLocator);
         ioc.serviceManager.addSingleton<IPathUtils>(IPathUtils, PathUtils);
         ioc.serviceManager.addSingleton<ICurrentProcess>(ICurrentProcess, CurrentProcess);
+        ioc.serviceManager.addSingleton<IFileSystem>(IFileSystem, FileSystem);
+        ioc.serviceManager.addSingleton<IPlatformService>(IPlatformService, PlatformService);
 
         ioc.registerMockProcessTypes();
         ioc.serviceManager.addSingleton<ITerminalService>(ITerminalService, MockTerminalService);
@@ -136,6 +141,9 @@ suite('Module Installer', () => {
     });
 
     test('Validate pip install arguments', async () => {
+        const mockInterpreterLocator = new MockProvider([{ path: await getCurrentPythonPath(), type: InterpreterType.Unknown }]);
+        ioc.serviceManager.addSingletonInstance<IInterpreterLocatorService>(IInterpreterLocatorService, mockInterpreterLocator, INTERPRETER_LOCATOR_SERVICE);
+
         const moduleName = 'xyz';
         const terminalService = ioc.serviceContainer.get<MockTerminalService>(ITerminalService);
 
@@ -148,10 +156,13 @@ suite('Module Installer', () => {
         const commandSent = await terminalService.commandSent;
         const commandParts = commandSent.split(' ');
         commandParts.shift();
-        expect(commandParts.join(' ')).equal(`-m pip install -U ${moduleName}`, 'Invalid command sent to terminal for installation.');
+        expect(commandParts.join(' ')).equal(`-m pip install -U ${moduleName} --user`, 'Invalid command sent to terminal for installation.');
     });
 
     test('Validate Conda install arguments', async () => {
+        const mockInterpreterLocator = new MockProvider([{ path: await getCurrentPythonPath(), type: InterpreterType.Conda }]);
+        ioc.serviceManager.addSingletonInstance<IInterpreterLocatorService>(IInterpreterLocatorService, mockInterpreterLocator, INTERPRETER_LOCATOR_SERVICE);
+
         const moduleName = 'xyz';
         const terminalService = ioc.serviceContainer.get<MockTerminalService>(ITerminalService);