Use the refactoring the C# dependencies

Author: akshita31

src/CSharpExtDownloader.ts

@@ -6,44 +6,31 @@
 import { PlatformInformation } from './platform';
 import { PackageInstallation, LogPlatformInfo, InstallationSuccess } from './omnisharp/loggingEvents';
 import { EventStream } from './EventStream';
-import { DownloadAndInstallPackages } from './packageManager/PackageManager';
-import { Package } from './packageManager/Package';
+import { downloadAndInstallPackages1 } from './packageManager/PackageManager';
 import { NetworkSettingsProvider } from './NetworkSettings';
+import { getRuntimeDependenciesPackages } from './tools/RuntimeDependencyPackageUtils';
+import { AbsolutePathPackage } from './packageManager/AbsolutePathPackage';
+import { filterPackages } from './packageManager/PackageFilterer';
 
-/*
- * Class used to download the runtime dependencies of the C# Extension
- */
-export class CSharpExtDownloader {
-
-    public constructor(
-        private networkSettingsProvider: NetworkSettingsProvider,
-        private eventStream: EventStream,
-        private packageJSON: any,
-        private platformInfo: PlatformInformation,
-        private extensionPath: string) {
-    }
-
-    public async installRuntimeDependencies(): Promise<boolean> {
-        this.eventStream.post(new PackageInstallation("C# dependencies"));
-
+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);
+    if (packagesToInstall && packagesToInstall.length > 0) {
+        eventStream.post(new PackageInstallation("C# dependencies"));
         try {
             // Display platform information and RID
-            this.eventStream.post(new LogPlatformInfo(this.platformInfo));
-            let runTimeDependencies = GetRunTimeDependenciesPackages(this.packageJSON);
-            await DownloadAndInstallPackages(runTimeDependencies, this.networkSettingsProvider, this.platformInfo, this.eventStream, this.extensionPath);
-            this.eventStream.post(new InstallationSuccess());
+            eventStream.post(new LogPlatformInfo(platformInfo));
+            await downloadAndInstallPackages1(packagesToInstall, networkSettingsProvider, eventStream);
+            eventStream.post(new InstallationSuccess());
             return true;
         }
         catch (error) {
             return false;
         }
     }
-}
 
-export function GetRunTimeDependenciesPackages(packageJSON: any): Package[] {
-    if (packageJSON.runtimeDependencies) {
-        return JSON.parse(JSON.stringify(<Package[]>packageJSON.runtimeDependencies));
-    }
+    //All the required packages are already downloaded and installed
+    return true;
+}
 
-    throw new Error("No runtime dependencies found");
-}

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;
 

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';
@@ -39,6 +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';
 
 export async function activate(context: vscode.ExtensionContext): Promise<CSharpExtensionExports> {
 
@@ -159,7 +159,6 @@ 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();
+    return installRuntimeDependencies(extension.packageJSON, extension.extensionPath, networkSettingsProvider, eventStream, platformInfo);
 }
 

src/packageManager/PackageManager.ts

@@ -21,7 +21,6 @@ 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) {
@@ -59,3 +58,39 @@ export async function DownloadAndInstallPackages(packages: Package[], provider:
     }
 }
 
+export async function downloadAndInstallPackages1(packages: AbsolutePathPackage[], provider: NetworkSettingsProvider, eventStream: EventStream) {
+    if (packages) {
+        for (let pkg of packages) {
+            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) { }
+            }
+        }
+    }
+}

src/tools/GetRuntimeDependencyWithId.ts renamed to 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");
 }

tasks/offlinePackagingTasks.ts

@@ -20,8 +20,8 @@ import { Logger } from '../src/logger';
 import { PlatformInformation } from '../src/platform';
 import { DownloadAndInstallPackages } from '../src/packageManager/PackageManager';
 import NetworkSettings from '../src/NetworkSettings';
-import { GetRunTimeDependenciesPackages } from '../src/CSharpExtDownloader';
 import { commandLineOptions } from '../tasks/commandLineArguments';
+import { getRuntimeDependenciesPackages } from '../src/tools/RuntimeDependencyPackageUtils';
 
 gulp.task('vsix:offline:package', async () => {
     del.sync(vscodeignorePath);
@@ -89,7 +89,7 @@ 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 provider = () => new NetworkSettings(undefined, undefined);
     await DownloadAndInstallPackages(runTimeDependencies, provider, platformInfo, eventStream, codeExtensionPath);
     await debugUtil.CoreClrDebugUtil.writeEmptyFile(debuggerUtil.installCompleteFilePath());