Common execution for python tool or module (microsoft#468)

Fixes microsoft#456

Author: DonJayamanne

src/client/common/process/pythonToolService.ts

@@ -0,0 +1,40 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { inject, injectable } from 'inversify';
+import { Uri } from 'vscode';
+import { IServiceContainer } from '../../ioc/types';
+import { ExecutionInfo } from '../types';
+import { IEnvironmentVariablesProvider } from '../variables/types';
+import { ExecutionResult, IProcessService, IPythonExecutionFactory, IPythonToolExecutionService, ObservableExecutionResult, SpawnOptions } from './types';
+
+@injectable()
+export class PythonToolExecutionService implements IPythonToolExecutionService {
+ constructor( @inject(IServiceContainer) private serviceContainer: IServiceContainer) { }
+ public async execObservable(executionInfo: ExecutionInfo, options: SpawnOptions, resource: Uri): Promise<ObservableExecutionResult<string>> {
+ if (options.env) {
+ throw new Error('Environment variables are not supported');
+ }
+ if (executionInfo.moduleName && executionInfo.moduleName.length > 0) {
+ const pythonExecutionService = await this.serviceContainer.get<IPythonExecutionFactory>(IPythonExecutionFactory).create(resource);
+ return pythonExecutionService.execModuleObservable(executionInfo.moduleName, executionInfo.args, options);
+ } else {
+ const env = await this.serviceContainer.get<IEnvironmentVariablesProvider>(IEnvironmentVariablesProvider).getEnvironmentVariables(resource);
+ const processService = this.serviceContainer.get<IProcessService>(IProcessService);
+ return processService.execObservable(executionInfo.execPath!, executionInfo.args, { ...options, env });
+ }
+ }
+ public async exec(executionInfo: ExecutionInfo, options: SpawnOptions, resource: Uri): Promise<ExecutionResult<string>> {
+ if (options.env) {
+ throw new Error('Environment variables are not supported');
+ }
+ if (executionInfo.moduleName && executionInfo.moduleName.length > 0) {
+ const pythonExecutionService = await this.serviceContainer.get<IPythonExecutionFactory>(IPythonExecutionFactory).create(resource);
+ return pythonExecutionService.execModule(executionInfo.moduleName!, executionInfo.args, options);
+ } else {
+ const env = await this.serviceContainer.get<IEnvironmentVariablesProvider>(IEnvironmentVariablesProvider).getEnvironmentVariables(resource);
+ const processService = this.serviceContainer.get<IProcessService>(IProcessService);
+ return processService.exec(executionInfo.execPath!, executionInfo.args, { ...options, env });
+ }
+ }
+}

src/client/common/process/serviceRegistry.ts

@@ -5,10 +5,12 @@ import { IServiceManager } from '../../ioc/types';
 import { BufferDecoder } from './decoder';
 import { ProcessService } from './proc';
 import { PythonExecutionFactory } from './pythonExecutionFactory';
-import { IBufferDecoder, IProcessService, IPythonExecutionFactory } from './types';
+import { PythonToolExecutionService } from './pythonToolService';
+import { IBufferDecoder, IProcessService, IPythonExecutionFactory, IPythonToolExecutionService } from './types';
 
 export function registerTypes(serviceManager: IServiceManager) {
  serviceManager.addSingleton<IBufferDecoder>(IBufferDecoder, BufferDecoder);
  serviceManager.addSingleton<IProcessService>(IProcessService, ProcessService);
  serviceManager.addSingleton<IPythonExecutionFactory>(IPythonExecutionFactory, PythonExecutionFactory);
+ serviceManager.addSingleton<IPythonToolExecutionService>(IPythonToolExecutionService, PythonToolExecutionService);
 }

src/client/common/process/types.ts

@@ -4,6 +4,7 @@
 import { ChildProcess, SpawnOptions as ChildProcessSpawnOptions } from 'child_process';
 import * as Rx from 'rxjs';
 import { CancellationToken, Uri } from 'vscode';
+import { ExecutionInfo } from '../types';
 import { EnvironmentVariables } from '../variables/types';
 
 export const IBufferDecoder = Symbol('IBufferDecoder');
@@ -69,3 +70,10 @@ export class StdErrError extends Error {
 export interface IExecutionEnvironmentVariablesService {
  getEnvironmentVariables(resource?: Uri): Promise<EnvironmentVariables | undefined>;
 }
+
+export const IPythonToolExecutionService = Symbol('IPythonToolRunnerService');
+
+export interface IPythonToolExecutionService {
+ execObservable(executionInfo: ExecutionInfo, options: SpawnOptions, resource: Uri): Promise<ObservableExecutionResult<string>>;
+ exec(executionInfo: ExecutionInfo, options: SpawnOptions, resource: Uri): Promise<ExecutionResult<string>>;
+}

src/client/formatters/baseFormatter.ts

@@ -4,6 +4,7 @@ import * as vscode from 'vscode';
 import { OutputChannel, TextEdit, Uri } from 'vscode';
 import { STANDARD_OUTPUT_CHANNEL } from '../common/constants';
 import { isNotInstalledError } from '../common/helpers';
+import { IPythonToolExecutionService } from '../common/process/types';
 import { IProcessService, IPythonExecutionFactory } from '../common/process/types';
 import { IInstaller, IOutputChannel, Product } from '../common/types';
 import { IEnvironmentVariablesProvider } from '../common/variables/types';
@@ -53,21 +54,11 @@ export abstract class BaseFormatter {
  return [];
  }
 
- let executionPromise: Promise<string>;
  const executionInfo = this.helper.getExecutionInfo(this.product, args, document.uri);
- // Check if required to run as a module or executable.
- if (executionInfo.moduleName) {
- executionPromise = this.serviceContainer.get<IPythonExecutionFactory>(IPythonExecutionFactory).create(document.uri)
- .then(pythonExecutionService => pythonExecutionService.execModule(executionInfo.moduleName!, executionInfo.args.concat([filePath]), { cwd, throwOnStdErr: true, token }))
- .then(output => output.stdout);
- } else {
- const executionService = this.serviceContainer.get<IProcessService>(IProcessService);
- executionPromise = this.serviceContainer.get<IEnvironmentVariablesProvider>(IEnvironmentVariablesProvider).getEnvironmentVariables(document.uri)
- .then(env => executionService.exec(executionInfo.execPath!, executionInfo.args.concat([filePath]), { cwd, env, throwOnStdErr: true, token }))
- .then(output => output.stdout);
- }
-
- const promise = executionPromise
+ executionInfo.args.push(filePath);
+ const pythonToolsExecutionService = this.serviceContainer.get<IPythonToolExecutionService>(IPythonToolExecutionService);
+ const promise = pythonToolsExecutionService.exec(executionInfo, { cwd, throwOnStdErr: true, token }, document.uri)
+ .then(output => output.stdout)
  .then(data => {
  if (token && token.isCancellationRequested) {
  return [] as TextEdit[];

src/client/linters/baseLinter.ts

@@ -1,8 +1,9 @@
 import * as path from 'path';
-import { CancellationToken, OutputChannel, TextDocument, Uri } from 'vscode';
 import * as vscode from 'vscode';
+import { CancellationToken, OutputChannel, TextDocument, Uri } from 'vscode';
 import { IPythonSettings, PythonSettings } from '../common/configSettings';
 import '../common/extensions';
+import { IPythonToolExecutionService } from '../common/process/types';
 import { ExecutionResult, IProcessService, IPythonExecutionFactory } from '../common/process/types';
 import { ExecutionInfo, IInstaller, ILogger, Product } from '../common/types';
 import { IEnvironmentVariablesProvider } from '../common/variables/types';
@@ -117,19 +118,9 @@ export abstract class BaseLinter {
  protected async run(args: string[], document: vscode.TextDocument, cancellation: vscode.CancellationToken, regEx: string = REGEX): Promise<ILintMessage[]> {
  const executionInfo = this.helper.getExecutionInfo(this.product, args, document.uri);
  const cwd = this.getWorkspaceRootPath(document);
- let executionPromise: Promise<ExecutionResult<string>>;
-
- // Check if required to run as a module or executable.
- if (executionInfo.moduleName) {
- const pythonExecutionService = await this.serviceContainer.get<IPythonExecutionFactory>(IPythonExecutionFactory).create(document.uri);
- executionPromise = pythonExecutionService.execModule(executionInfo.moduleName!, executionInfo.args, { cwd, mergeStdOutErr: true, token: cancellation });
- } else {
- const env = await this.serviceContainer.get<IEnvironmentVariablesProvider>(IEnvironmentVariablesProvider).getEnvironmentVariables(document.uri);
- const executionService = this.serviceContainer.get<IProcessService>(IProcessService);
- executionPromise = executionService.exec(executionInfo.execPath!, executionInfo.args, { cwd, env, token: cancellation, mergeStdOutErr: true });
- }
+ const pythonToolsExecutionService = this.serviceContainer.get<IPythonToolExecutionService>(IPythonToolExecutionService);
  try {
- const result = await executionPromise;
+ const result = await pythonToolsExecutionService.exec(executionInfo, {cwd, token: cancellation, mergeStdOutErr: true}, document.uri);
  this.displayLinterResultHeader(result.stdout);
  return await this.parseMessages(result.stdout, document, cancellation, regEx);
  } catch (error) {

src/client/unittests/common/runner.ts

@@ -3,17 +3,19 @@ import { CancellationToken, OutputChannel, Uri } from 'vscode';
 import { IPythonSettings, PythonSettings } from '../../common/configSettings';
 import { ErrorUtils } from '../../common/errors/errorUtils';
 import { ModuleNotInstalledError } from '../../common/errors/moduleNotInstalledError';
+import { IPythonToolExecutionService } from '../../common/process/types';
 import {
  IProcessService,
  IPythonExecutionFactory,
  IPythonExecutionService,
  ObservableExecutionResult,
  SpawnOptions
 } from '../../common/process/types';
+import { ExecutionInfo } from '../../common/types';
 import { IEnvironmentVariablesProvider } from '../../common/variables/types';
 import { IServiceContainer } from '../../ioc/types';
 import { NOSETEST_PROVIDER, PYTEST_PROVIDER, UNITTEST_PROVIDER } from './constants';
-import { TestProvider } from './types';
+import { ITestsHelper, TestProvider } from './types';
 
 export type Options = {
  workspaceFolder: Uri;
@@ -36,21 +38,17 @@ export async function run(serviceContainer: IServiceContainer, testProvider: Tes
  // Unit tests have a special way of being executed
  const pythonServiceFactory = serviceContainer.get<IPythonExecutionFactory>(IPythonExecutionFactory);
  pythonExecutionServicePromise = pythonServiceFactory.create(options.workspaceFolder);
- promise = pythonExecutionServicePromise.then(executionService => {
- return executionService.execObservable(options.args, { ...spawnOptions });
- });
- } else if (testExecutablePath) {
- const processService = serviceContainer.get<IProcessService>(IProcessService);
- const envVarsService = serviceContainer.get<IEnvironmentVariablesProvider>(IEnvironmentVariablesProvider);
- promise = envVarsService.getEnvironmentVariables(options.workspaceFolder).then(executionService => {
- return processService.execObservable(testExecutablePath, options.args, { ...spawnOptions });
- });
+ promise = pythonExecutionServicePromise.then(executionService => executionService.execObservable(options.args, { ...spawnOptions }));
  } else {
- const pythonServiceFactory = serviceContainer.get<IPythonExecutionFactory>(IPythonExecutionFactory);
- pythonExecutionServicePromise = pythonServiceFactory.create(options.workspaceFolder);
- promise = pythonExecutionServicePromise.then(executionService => {
- return executionService.execModuleObservable(moduleName, options.args, { ...spawnOptions });
- });
+ const pythonToolsExecutionService = serviceContainer.get<IPythonToolExecutionService>(IPythonToolExecutionService);
+ const testHelper = serviceContainer.get<ITestsHelper>(ITestsHelper);
+ const executionInfo: ExecutionInfo = {
+ execPath: testExecutablePath,
+ args: options.args,
+ moduleName: testExecutablePath && testExecutablePath.length > 0 ? undefined : moduleName,
+ product: testHelper.parseProduct(testProvider)
+ };
+ promise = pythonToolsExecutionService.execObservable(executionInfo, spawnOptions, options.workspaceFolder);
  }
 
  return promise.then(result => {

src/client/unittests/common/testUtils.ts

@@ -55,6 +55,16 @@ export class TestsHelper implements ITestsHelper {
  }
  }
  }
+ public parseProduct(provider: TestProvider): UnitTestProduct {
+ switch (provider) {
+ case 'nosetest': return Product.nosetest;
+ case 'pytest': return Product.pytest;
+ case 'unittest': return Product.unittest;
+ default: {
+ throw new Error(`Unknown Test Provider ${provider}`);
+ }
+ }
+ }
  public getSettingsPropertyNames(product: UnitTestProduct): TestSettingsPropertyNames {
  const id = this.parseProviderName(product);
  switch (id) {

src/client/unittests/common/types.ts

@@ -156,6 +156,7 @@ export const ITestsHelper = Symbol('ITestsHelper');
 
 export interface ITestsHelper {
  parseProviderName(product: UnitTestProduct): TestProvider;
+ parseProduct(provider: TestProvider): UnitTestProduct;
  getSettingsPropertyNames(product: Product): TestSettingsPropertyNames;
  flattenTestFiles(testFiles: TestFile[]): Tests;
  placeTestFilesIntoFolders(tests: Tests): void;

src/test/serviceRegistry.ts

@@ -10,8 +10,9 @@ import { PathUtils } from '../client/common/platform/pathUtils';
 import { BufferDecoder } from '../client/common/process/decoder';
 import { ProcessService } from '../client/common/process/proc';
 import { PythonExecutionFactory } from '../client/common/process/pythonExecutionFactory';
+import { PythonToolExecutionService } from '../client/common/process/pythonToolService';
 import { registerTypes as processRegisterTypes } from '../client/common/process/serviceRegistry';
-import { IBufferDecoder, IProcessService, IPythonExecutionFactory } from '../client/common/process/types';
+import { IBufferDecoder, IProcessService, IPythonExecutionFactory, IPythonToolExecutionService } from '../client/common/process/types';
 import { registerTypes as commonRegisterTypes } from '../client/common/serviceRegistry';
 import { GLOBAL_MEMENTO, ICurrentProcess, IDisposableRegistry, ILogger, IMemento, IOutputChannel, IPathUtils, Is64Bit, IsWindows, WORKSPACE_MEMENTO } from '../client/common/types';
 import { registerTypes as variableRegisterTypes } from '../client/common/variables/serviceRegistry';
@@ -86,6 +87,7 @@ export class IocContainer {
  this.serviceManager.addSingleton<IProcessService>(IOriginalProcessService, ProcessService);
  this.serviceManager.addSingleton<IProcessService>(IProcessService, MockProcessService);
  this.serviceManager.addSingleton<IPythonExecutionFactory>(IPythonExecutionFactory, PythonExecutionFactory);
+ this.serviceManager.addSingleton<IPythonToolExecutionService>(IPythonToolExecutionService, PythonToolExecutionService);
  }
 
  public registerMockProcess() {