Add the install.lock for each dependency

Author: akshita31

src/CSharpExtDownloader.ts

@@ -3,9 +3,8 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import * as util from './common';
 import { PlatformInformation } from './platform';
-import { PackageInstallation, LogPlatformInfo, InstallationSuccess, InstallationFailure } from './omnisharp/loggingEvents';
+import { PackageInstallation, LogPlatformInfo, InstallationSuccess } from './omnisharp/loggingEvents';
 import { EventStream } from './EventStream';
 import { DownloadAndInstallPackages } from './packageManager/PackageManager';
 import { Package } from './packageManager/Package';
@@ -26,30 +25,18 @@ export class CSharpExtDownloader {
 
     public async installRuntimeDependencies(): Promise<boolean> {
         this.eventStream.post(new PackageInstallation("C# dependencies"));
-        let installationStage = 'touchBeginFile';
 
         try {
-            await util.touchInstallFile(util.InstallFileType.Begin);
             // Display platform information and RID
             this.eventStream.post(new LogPlatformInfo(this.platformInfo));
             let runTimeDependencies = GetRunTimeDependenciesPackages(this.packageJSON);
-            installationStage = 'downloadAndInstallPackages';
             await DownloadAndInstallPackages(runTimeDependencies, this.networkSettingsProvider, this.platformInfo, this.eventStream, this.extensionPath);
-            installationStage = 'touchLockFile';
-            await util.touchInstallFile(util.InstallFileType.Lock);
             this.eventStream.post(new InstallationSuccess());
             return true;
         }
         catch (error) {
-            this.eventStream.post(new InstallationFailure(installationStage, error));
             return false;
         }
-        finally {
-            try {
-                util.deleteInstallFile(util.InstallFileType.Begin);
-            }
-            catch (error) { }
-        }
     }
 }
 

src/common.ts

@@ -7,6 +7,7 @@ import * as cp from 'child_process';
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
+import { AbsolutePath } from './packageManager/AbsolutePath';
 
 let extensionPath: string;
 
@@ -129,18 +130,18 @@ export enum InstallFileType {
     Lock
 }
 
-function getInstallFilePath(type: InstallFileType): string {
+export  function getInstallFilePath(folderPath: AbsolutePath, type: InstallFileType): string {
     let installFile = 'install.' + InstallFileType[type];
-    return path.resolve(getExtensionPath(), installFile);
+    return path.resolve(folderPath.value, installFile);
 }
 
-export async function installFileExists(type: InstallFileType): Promise<boolean> {
-    return fileExists(getInstallFilePath(type));
+export async function installFileExists(folderPath: AbsolutePath, type: InstallFileType): Promise<boolean> {
+    return fileExists(getInstallFilePath(folderPath, type));
 }
 
-export async function touchInstallFile(type: InstallFileType): Promise<void> {
+export async function touchInstallFile(folderPath: AbsolutePath, type: InstallFileType): Promise<void> {
     return new Promise<void>((resolve, reject) => {
-        fs.writeFile(getInstallFilePath(type), '', err => {
+        fs.writeFile(getInstallFilePath(folderPath, type), '', err => {
             if (err) {
                 reject(err);
                 return;
@@ -151,9 +152,9 @@ export async function touchInstallFile(type: InstallFileType): Promise<void> {
     });
 }
 
-export async function deleteInstallFile(type: InstallFileType): Promise<void> {
+export async function deleteInstallFile(folderPath: AbsolutePath, type: InstallFileType): Promise<void> {
     return new Promise<void>((resolve, reject) => {
-        fs.unlink(getInstallFilePath(type), err => {
+        fs.unlink(getInstallFilePath(folderPath, type), err => {
             if (err) {
                 reject(err);
                 return;

src/coreclr-debug/activate.ts

@@ -11,6 +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';
 
 let _debugUtil: CoreClrDebugUtil = null;
 
@@ -112,7 +113,7 @@ interface AdapterExecutableCommand {
 // The default extension manifest calls this command as the adapterExecutableCommand
 // If the debugger components have not finished downloading, the proxy displays an error message to the user
 // Else it will launch the debug adapter
-export async function getAdapterExecutionCommand(platformInfo: PlatformInformation, eventStream: EventStream): Promise<AdapterExecutableCommand> {
+export async function getAdapterExecutionCommand(platformInfo: PlatformInformation, eventStream: EventStream, packageJSON: any, extensionPath: string): Promise<AdapterExecutableCommand> {
     let util = new CoreClrDebugUtil(common.getExtensionPath());
 
     // Check for .debugger folder. Handle if it does not exist.
@@ -125,7 +126,14 @@ export async function getAdapterExecutionCommand(platformInfo: PlatformInformati
         // 4. install.complete is created
 
         // install.Lock does not exist, need to wait for packages to finish downloading.
-        let installLock: boolean = await common.installFileExists(common.InstallFileType.Lock);
+        let installLock = false;
+        let debuggerPackage = getRuntimeDependencyPackageWithId("Debugger", packageJSON, platformInfo, extensionPath);
+        if (debuggerPackage && debuggerPackage.installPath)
+        {
+            installLock = await common.installFileExists(debuggerPackage.installPath, common.InstallFileType.Lock);
+        }
+        
+        //todo: check if the debugger install.lock is present
         if (!installLock) {
             eventStream.post(new DebuggerNotInstalledFailure());
             throw new Error('The C# extension is still downloading packages. Please see progress in the output window below.');

src/features/commands.ts

@@ -23,7 +23,7 @@ import reportIssue from './reportIssue';
 import { IMonoResolver } from '../constants/IMonoResolver';
 import { getDotnetInfo } from '../utils/getDotnetInfo';
 
-export default function registerCommands(server: OmniSharpServer, platformInfo: PlatformInformation, eventStream: EventStream, optionProvider: OptionProvider, monoResolver: IMonoResolver): CompositeDisposable {
+export default function registerCommands(server: OmniSharpServer, platformInfo: PlatformInformation, eventStream: EventStream, optionProvider: OptionProvider, monoResolver: IMonoResolver, packageJSON: any, extensionPath: string): CompositeDisposable {
     let disposable = new CompositeDisposable();
     disposable.add(vscode.commands.registerCommand('o.restart', () => restartOmniSharp(server)));
     disposable.add(vscode.commands.registerCommand('o.pickProjectAndStart', async () => pickProjectAndStart(server, optionProvider)));
@@ -47,8 +47,8 @@ export default function registerCommands(server: OmniSharpServer, platformInfo:
     disposable.add(vscode.commands.registerCommand('csharp.listRemoteProcess', async (args) => RemoteAttachPicker.ShowAttachEntries(args, platformInfo)));
 
     // Register command for adapter executable command.
-    disposable.add(vscode.commands.registerCommand('csharp.coreclrAdapterExecutableCommand', async (args) => getAdapterExecutionCommand(platformInfo, eventStream)));
-    disposable.add(vscode.commands.registerCommand('csharp.clrAdapterExecutableCommand', async (args) => getAdapterExecutionCommand(platformInfo, eventStream)));
+    disposable.add(vscode.commands.registerCommand('csharp.coreclrAdapterExecutableCommand', async (args) => getAdapterExecutionCommand(platformInfo, eventStream, packageJSON, extensionPath)));
+    disposable.add(vscode.commands.registerCommand('csharp.clrAdapterExecutableCommand', async (args) => getAdapterExecutionCommand(platformInfo, eventStream, packageJSON, extensionPath)));
     disposable.add(vscode.commands.registerCommand('csharp.reportIssue', async () => reportIssue(vscode, eventStream, getDotnetInfo, platformInfo.isValidPlatformForMono(), optionProvider.GetLatestOptions(), monoResolver)));
 
     return new CompositeDisposable(disposable);

src/main.ts

@@ -159,14 +159,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> {
-    return util.installFileExists(util.InstallFileType.Lock)
-        .then(exists => {
-            if (!exists) {
-                const downloader = new CSharpExtDownloader(networkSettingsProvider, eventStream, extension.packageJSON, platformInfo, extension.extensionPath);
-                return downloader.installRuntimeDependencies();
-            } else {
-                return true;
-            }
-        });
+    const downloader = new CSharpExtDownloader(networkSettingsProvider, eventStream, extension.packageJSON, platformInfo, extension.extensionPath);
+    return downloader.installRuntimeDependencies();
 }
 

src/omnisharp/extension.ts

@@ -98,7 +98,7 @@ export async function activate(context: vscode.ExtensionContext, packageJSON: an
         localDisposables = null;
     }));
 
-    disposables.add(registerCommands(server, platformInfo, eventStream, optionProvider, omnisharpMonoResolver));
+    disposables.add(registerCommands(server, platformInfo, eventStream, optionProvider, omnisharpMonoResolver, packageJSON, extensionPath));
 
     if (!context.workspaceState.get<boolean>('assetPromptDisabled')) {
         disposables.add(server.onServerStart(() => {

src/packageManager/AbsolutePathPackage.ts

@@ -8,7 +8,9 @@ import { IPackage } from "./IPackage";
 import { AbsolutePath } from "./AbsolutePath";
 
 export class AbsolutePathPackage implements IPackage{
-    constructor(public description: string,
+    
+    constructor(public Id: string,
+        public description: string,
         public url: string,
         public platforms: string[],
         public architectures: string[],
@@ -21,6 +23,7 @@ export class AbsolutePathPackage implements IPackage{
 
     public static getAbsolutePathPackage(pkg: Package, extensionPath: string) {
         return new AbsolutePathPackage(
+            pkg.Id,
             pkg.description,
             pkg.url,
             pkg.platforms,

src/packageManager/IPackage.ts

@@ -4,6 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 export interface IPackage {
+    Id: string;
     description: string;
     url: string;
     fallbackUrl?: string;

src/packageManager/PackageFilterer.ts

@@ -15,7 +15,7 @@ export async function filterPackages(packages: AbsolutePathPackage[], platformIn
     return filterAlreadyInstalledPackages(platformPackages);
 }
 
-function filterPlatformPackages(packages: AbsolutePathPackage[], platformInfo: PlatformInformation) {
+export function filterPlatformPackages(packages: AbsolutePathPackage[], platformInfo: PlatformInformation) {
     if (packages) {
         return packages.filter(pkg => {
             if (pkg.architectures && pkg.architectures.indexOf(platformInfo.architecture) === -1) {
@@ -36,13 +36,13 @@ function filterPlatformPackages(packages: AbsolutePathPackage[], platformInfo: P
 
 async function filterAlreadyInstalledPackages(packages: AbsolutePathPackage[]): Promise<AbsolutePathPackage[]> {
     return filterAsync(packages, async (pkg: AbsolutePathPackage) => {
-        //If the file is present at the install test path then filter it
-        let testPath = pkg.installTestPath;
+        //If the install.Lock file is present for this package then do not install it again
+        let testPath = util.getInstallFilePath(pkg.installPath, util.InstallFileType.Lock);
         if (!testPath) {
-            //if there is no testPath specified then we will not filter it
+            //if there is no testPath then we will not filter it
             return true;
         }
 
-        return !(await util.fileExists(testPath.value));
+        return !(await util.fileExists(testPath));
       });
 }

src/packageManager/PackageManager.ts

@@ -13,24 +13,41 @@ import { EventStream } from '../EventStream';
 import { NetworkSettingsProvider } from "../NetworkSettings";
 import { filterPackages } from "./PackageFilterer";
 import { AbsolutePathPackage } from "./AbsolutePathPackage";
+import { touchInstallFile, InstallFileType, deleteInstallFile } from "../common";
+import { InstallationFailure } from "../omnisharp/loggingEvents";
+import { mkdirpSync } from "fs-extra";
 
-export async function DownloadAndInstallPackages(packages: Package[], provider: NetworkSettingsProvider, platformInfo: PlatformInformation, eventStream: EventStream, extensionPath: string) {
+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) {
         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) {
-                    throw new PackageError(error.message, pkg, error.err);
+                    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 {
+                await deleteInstallFile(pkg.installPath, InstallFileType.Begin);
+            }
         }
     }
 }