Some more changes

Author: akshita31

src/CSharpExtDownloader.ts renamed to src/InstallRuntimeDependencies.ts

@@ -6,22 +6,20 @@
 import { PlatformInformation } from './platform';
 import { PackageInstallation, LogPlatformInfo, InstallationSuccess } from './omnisharp/loggingEvents';
 import { EventStream } from './EventStream';
-import { downloadAndInstallPackages1 } from './packageManager/PackageManager';
+import { downloadAndInstallPackages } from './packageManager/downloadAndInstallPackages';
 import { NetworkSettingsProvider } from './NetworkSettings';
 import { getRuntimeDependenciesPackages } from './tools/RuntimeDependencyPackageUtils';
-import { AbsolutePathPackage } from './packageManager/AbsolutePathPackage';
-import { filterPackages } from './packageManager/PackageFilterer';
+import { getAbsolutePathPackagesToInstall } from './packageManager/getAbsolutePathPackagesToInstall';
 
 export async function installRuntimeDependencies(packageJSON: any, extensionPath: string, networkSettingsProvider: NetworkSettingsProvider, eventStream: EventStream, platformInfo: PlatformInformation): Promise<boolean>{
     let runTimeDependencies = getRuntimeDependenciesPackages(packageJSON);
-    let absolutePathPackages = runTimeDependencies.map(pkg => AbsolutePathPackage.getAbsolutePathPackage(pkg, extensionPath));
-    let packagesToInstall = await filterPackages(absolutePathPackages, platformInfo);
+    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 downloadAndInstallPackages1(packagesToInstall, networkSettingsProvider, eventStream);
+            await downloadAndInstallPackages(packagesToInstall, networkSettingsProvider, eventStream);
             eventStream.post(new InstallationSuccess());
             return true;
         }

src/main.ts

@@ -38,7 +38,7 @@ import { CSharpExtensionId } from './constants/CSharpExtensionId';
 import { OpenURLObserver } from './observers/OpenURLObserver';
 import { activateRazorExtension } from './razor/razor';
 import { RazorLoggerObserver } from './observers/RazorLoggerObserver';
-import { installRuntimeDependencies } from './CSharpExtDownloader';
+import { installRuntimeDependencies } from './InstallRuntimeDependencies';
 
 export async function activate(context: vscode.ExtensionContext): Promise<CSharpExtensionExports> {
 

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> {

src/packageManager/PackageManager.ts renamed to src/packageManager/downloadAndInstallPackages.ts

@@ -3,63 +3,21 @@
  *  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) {
-        eventStream.post(new PackageInstallStart());
-        for (let pkg of filteredPackages) {
-            let installationStage = "touchBeginFile";
-            try {
-                mkdirpSync(pkg.installPath.value);
-                await touchInstallFile(pkg.installPath, InstallFileType.Begin);
-                installationStage = 'downloadAndInstallPackages';
-                let buffer = await DownloadFile(pkg.description, eventStream, provider, pkg.url, pkg.fallbackUrl);
-                await InstallZip(buffer, pkg.description, pkg.installPath, pkg.binaries, eventStream);
-                installationStage = 'touchLockFile';
-                await touchInstallFile(pkg.installPath, InstallFileType.Lock);
-            }
-            catch (error) {
-                eventStream.post(new InstallationFailure(installationStage, error));
-                if (error instanceof NestedError) {
-                    let packageError = new PackageError(error.message, pkg, error.err);
-                    eventStream.post(new InstallationFailure(installationStage, packageError));
-                    throw packageError;
-                }
-                else {
-                    eventStream.post(new InstallationFailure(installationStage, error));
-                    throw error;
-                }
-            }
-            finally {
-                try {
-                    if (installFileExists(pkg.installPath, InstallFileType.Begin)) {
-                        await deleteInstallFile(pkg.installPath, InstallFileType.Begin);
-                    }
-                }
-                catch (error) { }
-            }
-        }
-    }
-}
-
-export async function downloadAndInstallPackages1(packages: AbsolutePathPackage[], provider: NetworkSettingsProvider, eventStream: EventStream) {
+export async function downloadAndInstallPackages(packages: AbsolutePathPackage[], provider: NetworkSettingsProvider, eventStream: EventStream) {
     if (packages) {
+        eventStream.post(new PackageInstallStart());
         for (let pkg of packages) {
             let installationStage = "touchBeginFile";
             try {
@@ -85,7 +43,7 @@ export async function downloadAndInstallPackages1(packages: AbsolutePathPackage[
             }
             finally {
                 try {
-                    if (installFileExists(pkg.installPath, InstallFileType.Begin)) {
+                    if (await installFileExists(pkg.installPath, InstallFileType.Begin)) {
                         await deleteInstallFile(pkg.installPath, InstallFileType.Begin);
                     }
                 }

src/packageManager/getAbsolutePathPackagesToInstall.ts

@@ -0,0 +1,14 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 { filterPackages } from "./PackageFilterer";
+import { Package } from "./Package";
+
+export async function getAbsolutePathPackagesToInstall(packages: Package[], platformInfo: PlatformInformation, extensionPath: string): Promise<AbsolutePathPackage[]> {
+    let absolutePathPackages = packages.map(pkg => AbsolutePathPackage.getAbsolutePathPackage(pkg, extensionPath));
+    return filterPackages(absolutePathPackages, platformInfo);
+}

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 { 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);
@@ -90,8 +91,9 @@ async function install(platformInfo: PlatformInformation, packageJSON: any) {
     eventStream.subscribe(stdoutObserver.post);
     const debuggerUtil = new debugUtil.CoreClrDebugUtil(path.resolve('.'));
     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());
 }