Merge pull request #2711 from akshita31/refactor_downloads

akshita31 · web-flow · commit 799416de5b6b · 2018-11-28T14:56:02.000-08:00
Allow to control what is posted to the event stream based on if there are any downloads
diff --git a/src/CSharpExtDownloader.ts b/src/CSharpExtDownloader.ts
diff --git a/src/InstallRuntimeDependencies.ts b/src/InstallRuntimeDependencies.ts
@@ -0,0 +1,33 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { PlatformInformation } from './platform';
+import { PackageInstallation, LogPlatformInfo, InstallationSuccess } from './omnisharp/loggingEvents';
+import { EventStream } from './EventStream';
+import { getRuntimeDependenciesPackages } from './tools/RuntimeDependencyPackageUtils';
+import { getAbsolutePathPackagesToInstall } from './packageManager/getAbsolutePathPackagesToInstall';
+import IInstallDependencies from './packageManager/IInstallDependencies';
+
+export async function installRuntimeDependencies(packageJSON: any, extensionPath: string, installDependencies: IInstallDependencies, eventStream: EventStream, platformInfo: PlatformInformation): Promise<boolean>{
+    let runTimeDependencies = getRuntimeDependenciesPackages(packageJSON);
+    let packagesToInstall = await getAbsolutePathPackagesToInstall(runTimeDependencies, platformInfo, extensionPath);
+    if (packagesToInstall && packagesToInstall.length > 0) {
+        eventStream.post(new PackageInstallation("C# dependencies"));
+        try {
+            // Display platform information and RID
+            eventStream.post(new LogPlatformInfo(platformInfo));
+            await installDependencies(packagesToInstall);
+            eventStream.post(new InstallationSuccess());
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+
+    //All the required packages are already downloaded and installed
+    return true;
+}
+
diff --git a/src/coreclr-debug/activate.ts b/src/coreclr-debug/activate.ts
@@ -11,7 +11,7 @@ import { PlatformInformation } from './../platform';
 import { DebuggerPrerequisiteWarning, DebuggerPrerequisiteFailure, DebuggerNotInstalledFailure } from '../omnisharp/loggingEvents';
 import { EventStream } from '../EventStream';
 import CSharpExtensionExports from '../CSharpExtensionExports';
-import { getRuntimeDependencyPackageWithId } from '../tools/GetRuntimeDependencyWithId';
+import { getRuntimeDependencyPackageWithId } from '../tools/RuntimeDependencyPackageUtils';
 
 let _debugUtil: CoreClrDebugUtil = null;
 
diff --git a/src/main.ts b/src/main.ts
@@ -10,7 +10,6 @@ import * as vscode from 'vscode';
 
 import { ActivationFailure, ActiveTextEditorChanged } from './omnisharp/loggingEvents';
 import { WarningMessageObserver } from './observers/WarningMessageObserver';
-import { CSharpExtDownloader } from './CSharpExtDownloader';
 import { CsharpChannelObserver } from './observers/CsharpChannelObserver';
 import { CsharpLoggerObserver } from './observers/CsharpLoggerObserver';
 import { DotNetChannelObserver } from './observers/DotnetChannelObserver';
@@ -28,7 +27,7 @@ import TelemetryReporter from 'vscode-extension-telemetry';
 import { addJSONProviders } from './features/json/jsonContributions';
 import { ProjectStatusBarObserver } from './observers/ProjectStatusBarObserver';
 import CSharpExtensionExports from './CSharpExtensionExports';
-import { vscodeNetworkSettingsProvider, NetworkSettingsProvider } from './NetworkSettings';
+import { vscodeNetworkSettingsProvider } from './NetworkSettings';
 import { ErrorMessageObserver } from './observers/ErrorMessageObserver';
 import OptionProvider from './observers/OptionProvider';
 import DotNetTestChannelObserver from './observers/DotnetTestChannelObserver';
@@ -39,6 +38,10 @@ import { CSharpExtensionId } from './constants/CSharpExtensionId';
 import { OpenURLObserver } from './observers/OpenURLObserver';
 import { activateRazorExtension } from './razor/razor';
 import { RazorLoggerObserver } from './observers/RazorLoggerObserver';
+import { AbsolutePathPackage } from './packageManager/AbsolutePathPackage';
+import { downloadAndInstallPackages } from './packageManager/downloadAndInstallPackages';
+import IInstallDependencies from './packageManager/IInstallDependencies';
+import { installRuntimeDependencies } from './InstallRuntimeDependencies';
 
 export async function activate(context: vscode.ExtensionContext): Promise<CSharpExtensionExports> {
 
@@ -116,7 +119,8 @@ export async function activate(context: vscode.ExtensionContext): Promise<CSharp
     eventStream.subscribe(telemetryObserver.post);
 
     let networkSettingsProvider = vscodeNetworkSettingsProvider(vscode);
-    let runtimeDependenciesExist = await ensureRuntimeDependencies(extension, eventStream, platformInfo, networkSettingsProvider);
+    let installDependencies: IInstallDependencies = (dependencies: AbsolutePathPackage[]) => downloadAndInstallPackages(dependencies, networkSettingsProvider, eventStream);
+    let runtimeDependenciesExist = await ensureRuntimeDependencies(extension, eventStream, platformInfo, installDependencies);
 
     // activate language services
     let langServicePromise = OmniSharp.activate(context, extension.packageJSON, platformInfo, networkSettingsProvider, eventStream, optionProvider, extension.extensionPath);
@@ -158,8 +162,7 @@ export async function activate(context: vscode.ExtensionContext): Promise<CSharp
     };
 }
 
-async function ensureRuntimeDependencies(extension: vscode.Extension<CSharpExtensionExports>, eventStream: EventStream, platformInfo: PlatformInformation, networkSettingsProvider: NetworkSettingsProvider): Promise<boolean> {
-    const downloader = new CSharpExtDownloader(networkSettingsProvider, eventStream, extension.packageJSON, platformInfo, extension.extensionPath);
-    return downloader.installRuntimeDependencies();
+async function ensureRuntimeDependencies(extension: vscode.Extension<CSharpExtensionExports>, eventStream: EventStream, platformInfo: PlatformInformation, installDependencies: IInstallDependencies): Promise<boolean> {
+    return installRuntimeDependencies(extension.packageJSON, extension.extensionPath, installDependencies, eventStream, platformInfo);
 }
 
diff --git a/src/omnisharp/OmnisharpDownloader.ts b/src/omnisharp/OmnisharpDownloader.ts
@@ -8,8 +8,10 @@ import { PlatformInformation } from '../platform';
 import { PackageInstallation, LogPlatformInfo, InstallationSuccess, InstallationFailure, LatestBuildDownloadStart } from './loggingEvents';
 import { EventStream } from '../EventStream';
 import { NetworkSettingsProvider } from '../NetworkSettings';
-import { DownloadAndInstallPackages } from '../packageManager/PackageManager';
+import { downloadAndInstallPackages } from '../packageManager/downloadAndInstallPackages';
 import { DownloadFile } from '../packageManager/FileDownloader';
+import { getRuntimeDependenciesPackages } from '../tools/RuntimeDependencyPackageUtils';
+import { getAbsolutePathPackagesToInstall } from '../packageManager/getAbsolutePathPackagesToInstall';
 
 export class OmnisharpDownloader {
 
@@ -22,21 +24,15 @@ export class OmnisharpDownloader {
     }
 
     public async DownloadAndInstallOmnisharp(version: string, serverUrl: string, installPath: string) {
-        this.eventStream.post(new PackageInstallation(`OmniSharp Version = ${version}`));
-        let installationStage = '';
-
-        try {
+        let runtimeDependencies = getRuntimeDependenciesPackages(this.packageJSON);
+        let omniSharpPackages = GetPackagesFromVersion(version, runtimeDependencies, serverUrl, installPath);
+        let packagesToInstall = await getAbsolutePathPackagesToInstall(omniSharpPackages, this.platformInfo, this.extensionPath);
+        if (packagesToInstall && packagesToInstall.length > 0) {
+            this.eventStream.post(new PackageInstallation(`OmniSharp Version = ${version}`));
             this.eventStream.post(new LogPlatformInfo(this.platformInfo));
-            installationStage = 'getPackageInfo';
-            let packages = GetPackagesFromVersion(version, this.packageJSON.runtimeDependencies, serverUrl, installPath);
-            installationStage = 'downloadAndInstallPackages';
-            await DownloadAndInstallPackages(packages, this.networkSettingsProvider, this.platformInfo, this.eventStream, this.extensionPath);
+            await downloadAndInstallPackages(packagesToInstall, this.networkSettingsProvider, this.eventStream);
             this.eventStream.post(new InstallationSuccess());
         }
-        catch (error) {
-            this.eventStream.post(new InstallationFailure(installationStage, error));
-            throw error;// throw the error up to the server
-        }
     }
 
     public async GetLatestVersion(serverUrl: string, latestVersionFileServerPath: string): Promise<string> {
diff --git a/src/packageManager/IInstallDependencies.ts b/src/packageManager/IInstallDependencies.ts
@@ -0,0 +1,10 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { AbsolutePathPackage } from "./AbsolutePathPackage";
+
+export default interface IInstallDependencies {
+    (packages: AbsolutePathPackage[]): Promise<void>;
+}
diff --git a/src/packageManager/PackageFilterer.ts b/src/packageManager/PackageFilterer.ts
@@ -10,7 +10,7 @@ import { AbsolutePathPackage } from "./AbsolutePathPackage";
 
 const { filterAsync } = require('node-filter-async');
 
-export async function filterPackages(packages: AbsolutePathPackage[], platformInfo: PlatformInformation): Promise<AbsolutePathPackage[]> {
+export async function getNotInstalledPackagesForPlatform(packages: AbsolutePathPackage[], platformInfo: PlatformInformation): Promise<AbsolutePathPackage[]> {
     let platformPackages = filterPlatformPackages(packages, platformInfo);
     return filterAlreadyInstalledPackages(platformPackages);
 }
diff --git a/src/packageManager/downloadAndInstallPackages.ts b/src/packageManager/downloadAndInstallPackages.ts
@@ -3,28 +3,22 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { PlatformInformation } from "../platform";
-import { Package } from './Package';
 import { PackageError } from './PackageError';
 import { NestedError } from "../NestedError";
 import { DownloadFile } from './FileDownloader';
 import { InstallZip } from './ZipInstaller';
 import { EventStream } from '../EventStream';
 import { NetworkSettingsProvider } from "../NetworkSettings";
-import { filterPackages } from "./PackageFilterer";
 import { AbsolutePathPackage } from "./AbsolutePathPackage";
 import { touchInstallFile, InstallFileType, deleteInstallFile, installFileExists } from "../common";
 import { InstallationFailure } from "../omnisharp/loggingEvents";
 import { mkdirpSync } from "fs-extra";
 import { PackageInstallStart } from "../omnisharp/loggingEvents";
 
-export async function DownloadAndInstallPackages(packages: Package[], provider: NetworkSettingsProvider, platformInfo: PlatformInformation, eventStream: EventStream, extensionPath: string): Promise<void> {
-    let absolutePathPackages = packages.map(pkg => AbsolutePathPackage.getAbsolutePathPackage(pkg, extensionPath));
-    let filteredPackages = await filterPackages(absolutePathPackages, platformInfo);
-
-    if (filteredPackages) {
+export async function downloadAndInstallPackages(packages: AbsolutePathPackage[], provider: NetworkSettingsProvider, eventStream: EventStream) {
+    if (packages) {
         eventStream.post(new PackageInstallStart());
-        for (let pkg of filteredPackages) {
+        for (let pkg of packages) {
             let installationStage = "touchBeginFile";
             try {
                 mkdirpSync(pkg.installPath.value);
@@ -49,7 +43,7 @@ export async function DownloadAndInstallPackages(packages: Package[], provider:
             }
             finally {
                 try {
-                    if (installFileExists(pkg.installPath, InstallFileType.Begin)) {
+                    if (await installFileExists(pkg.installPath, InstallFileType.Begin)) {
                         await deleteInstallFile(pkg.installPath, InstallFileType.Begin);
                     }
                 }
@@ -58,4 +52,3 @@ export async function DownloadAndInstallPackages(packages: Package[], provider:
         }
     }
 }
-
diff --git a/src/packageManager/getAbsolutePathPackagesToInstall.ts b/src/packageManager/getAbsolutePathPackagesToInstall.ts
@@ -0,0 +1,19 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { PlatformInformation } from "../platform";
+import { AbsolutePathPackage } from "./AbsolutePathPackage";
+import { getNotInstalledPackagesForPlatform } from "./PackageFilterer";
+import { Package } from "./Package";
+
+export async function getAbsolutePathPackagesToInstall(packages: Package[], platformInfo: PlatformInformation, extensionPath: string): Promise<AbsolutePathPackage[]> {
+    if (packages && packages.length>0)
+    {
+        let absolutePathPackages = packages.map(pkg => AbsolutePathPackage.getAbsolutePathPackage(pkg, extensionPath));
+        return getNotInstalledPackagesForPlatform(absolutePathPackages, platformInfo);
+    }
+
+    return [];
+}
diff --git a/src/tools/RuntimeDependencyPackageUtils.ts b/src/tools/RuntimeDependencyPackageUtils.ts
@@ -5,12 +5,19 @@
 
 import { PlatformInformation } from '../platform';
 import { AbsolutePathPackage } from '../packageManager/AbsolutePathPackage';
-import { GetRunTimeDependenciesPackages } from '../CSharpExtDownloader';
 import { filterPlatformPackages } from '../packageManager/PackageFilterer';
+import { Package } from '../packageManager/Package';
 
 export function getRuntimeDependencyPackageWithId(packageId: string, packageJSON: any, platformInfo: PlatformInformation, extensionPath: string): AbsolutePathPackage {
-    let runtimeDependencies = GetRunTimeDependenciesPackages(packageJSON);
+    let runtimeDependencies = getRuntimeDependenciesPackages(packageJSON);
     let absolutePathPackages = runtimeDependencies.map(pkg => AbsolutePathPackage.getAbsolutePathPackage(pkg, extensionPath));
     let platformSpecificPackage = filterPlatformPackages(absolutePathPackages, platformInfo);
     return platformSpecificPackage.find(pkg => pkg.id == packageId);
+}
+
+export function getRuntimeDependenciesPackages(packageJSON: any): Package[] {
+    if (packageJSON.runtimeDependencies) {
+        return JSON.parse(JSON.stringify(<Package[]>packageJSON.runtimeDependencies));
+    }
+    throw new Error("No runtime dependencies found");
 }
diff --git a/tasks/offlinePackagingTasks.ts b/tasks/offlinePackagingTasks.ts
@@ -18,10 +18,11 @@ import { EventStream } from '../src/EventStream';
 import { getPackageJSON } from '../tasks/packageJson';
 import { Logger } from '../src/logger';
 import { PlatformInformation } from '../src/platform';
-import { DownloadAndInstallPackages } from '../src/packageManager/PackageManager';
+import { downloadAndInstallPackages } from '../src/packageManager/downloadAndInstallPackages';
 import NetworkSettings from '../src/NetworkSettings';
-import { GetRunTimeDependenciesPackages } from '../src/CSharpExtDownloader';
 import { commandLineOptions } from '../tasks/commandLineArguments';
+import { getRuntimeDependenciesPackages } from '../src/tools/RuntimeDependencyPackageUtils';
+import { getAbsolutePathPackagesToInstall } from '../src/packageManager/getAbsolutePathPackagesToInstall';
 
 gulp.task('vsix:offline:package', async () => {
     del.sync(vscodeignorePath);
@@ -89,9 +90,10 @@ async function install(platformInfo: PlatformInformation, packageJSON: any) {
     let stdoutObserver = new CsharpLoggerObserver(logger);
     eventStream.subscribe(stdoutObserver.post);
     const debuggerUtil = new debugUtil.CoreClrDebugUtil(path.resolve('.'));
-    let runTimeDependencies = GetRunTimeDependenciesPackages(packageJSON);
+    let runTimeDependencies = getRuntimeDependenciesPackages(packageJSON);
+    let packagesToInstall = await getAbsolutePathPackagesToInstall(runTimeDependencies, platformInfo, codeExtensionPath);
     let provider = () => new NetworkSettings(undefined, undefined);
-    await DownloadAndInstallPackages(runTimeDependencies, provider, platformInfo, eventStream, codeExtensionPath);
+    await downloadAndInstallPackages(packagesToInstall, provider, eventStream);
     await debugUtil.CoreClrDebugUtil.writeEmptyFile(debuggerUtil.installCompleteFilePath());
 }
 
diff --git a/test/unitTests/InstallRuntimeDependencies.test.ts b/test/unitTests/InstallRuntimeDependencies.test.ts
diff --git a/test/unitTests/Packages/PackageFilterer.test.ts b/test/unitTests/Packages/PackageFilterer.test.ts
diff --git a/test/unitTests/Packages/PackageManager.test.ts b/test/unitTests/Packages/PackageManager.test.ts
diff --git a/test/unitTests/Packages/downloadAndInstallPackages.test.ts b/test/unitTests/Packages/downloadAndInstallPackages.test.ts

Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ import { AbsolutePathPackage } from "./AbsolutePathPackage";`
`10`	`10`
`11`	`11`	`const { filterAsync } = require('node-filter-async');`
`12`	`12`
`13`		`-export async function filterPackages(packages: AbsolutePathPackage[], platformInfo: PlatformInformation): Promise<AbsolutePathPackage[]> {`
	`13`	`+export async function getNotInstalledPackagesForPlatform(packages: AbsolutePathPackage[], platformInfo: PlatformInformation): Promise<AbsolutePathPackage[]> {`
`14`	`14`	`let platformPackages = filterPlatformPackages(packages, platformInfo);`
`15`	`15`	`return filterAlreadyInstalledPackages(platformPackages);`
`16`	`16`	`}`