Merge pull request #2403 from akshita31/absolute_package

Using absolute path and installable package classes

Author: akshita31

src/CSharpExtDownloader.ts

@@ -10,7 +10,6 @@ import { EventStream } from './EventStream';
 import { DownloadAndInstallPackages } from './packageManager/PackageManager';
 import { Package } from './packageManager/Package';
 import { NetworkSettingsProvider } from './NetworkSettings';
-import { ResolveFilePaths } from './packageManager/PackageFilePathResolver';
 
 /*
  * Class used to download the runtime dependencies of the C# Extension
@@ -21,7 +20,8 @@ export class CSharpExtDownloader {
         private networkSettingsProvider: NetworkSettingsProvider,
         private eventStream: EventStream,
         private packageJSON: any,
-        private platformInfo: PlatformInformation) {
+        private platformInfo: PlatformInformation,
+        private extensionPath: string) {
     }
 
     public async installRuntimeDependencies(): Promise<boolean> {
@@ -33,9 +33,8 @@ export class CSharpExtDownloader {
             // Display platform information and RID
             this.eventStream.post(new LogPlatformInfo(this.platformInfo));
             let runTimeDependencies = GetRunTimeDependenciesPackages(this.packageJSON);
-            runTimeDependencies.forEach(pkg => ResolveFilePaths(pkg));
             installationStage = 'downloadAndInstallPackages';
-            await DownloadAndInstallPackages(runTimeDependencies, this.networkSettingsProvider, this.platformInfo, this.eventStream);
+            await DownloadAndInstallPackages(runTimeDependencies, this.networkSettingsProvider, this.platformInfo, this.eventStream, this.extensionPath);
             installationStage = 'touchLockFile';
             await util.touchInstallFile(util.InstallFileType.Lock);
             this.eventStream.post(new InstallationSuccess());

src/features/structureProvider.ts

@@ -1,3 +1,8 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
 import { FoldingRangeProvider, TextDocument, FoldingContext, CancellationToken, FoldingRange, FoldingRangeKind } from "vscode";
 import AbstractSupport from './abstractProvider';
 import { blockStructure } from "../omnisharp/utils";

src/main.ts

@@ -112,7 +112,7 @@ export async function activate(context: vscode.ExtensionContext): Promise<CSharp
     let runtimeDependenciesExist = await ensureRuntimeDependencies(extension, eventStream, platformInfo, networkSettingsProvider);
 
     // activate language services
-    let omniSharpPromise = OmniSharp.activate(context, extension.packageJSON, platformInfo, networkSettingsProvider, eventStream, optionProvider);
+    let omniSharpPromise = OmniSharp.activate(context, extension.packageJSON, platformInfo, networkSettingsProvider, eventStream, optionProvider, extension.extensionPath);
 
     // register JSON completion & hover providers for project.json
     context.subscriptions.push(addJSONProviders());
@@ -142,7 +142,7 @@ async function ensureRuntimeDependencies(extension: vscode.Extension<CSharpExten
     return util.installFileExists(util.InstallFileType.Lock)
         .then(exists => {
             if (!exists) {
-                const downloader = new CSharpExtDownloader(networkSettingsProvider, eventStream, extension.packageJSON, platformInfo);
+                const downloader = new CSharpExtDownloader(networkSettingsProvider, eventStream, extension.packageJSON, platformInfo, extension.extensionPath);
                 return downloader.installRuntimeDependencies();
             } else {
                 return true;

src/omnisharp/OmnisharpDownloader.ts

@@ -10,15 +10,15 @@ import { EventStream } from '../EventStream';
 import { NetworkSettingsProvider } from '../NetworkSettings';
 import { DownloadAndInstallPackages } from '../packageManager/PackageManager';
 import { DownloadFile } from '../packageManager/FileDownloader';
-import { ResolveFilePaths } from '../packageManager/PackageFilePathResolver';
 
 export class OmnisharpDownloader {
 
     public constructor(
         private networkSettingsProvider: NetworkSettingsProvider,
         private eventStream: EventStream,
         private packageJSON: any,
-        private platformInfo: PlatformInformation) {
+        private platformInfo: PlatformInformation,
+        private extensionPath: string) {
     }
 
     public async DownloadAndInstallOmnisharp(version: string, serverUrl: string, installPath: string) {
@@ -29,9 +29,8 @@ export class OmnisharpDownloader {
             this.eventStream.post(new LogPlatformInfo(this.platformInfo));
             installationStage = 'getPackageInfo';
             let packages = GetPackagesFromVersion(version, this.packageJSON.runtimeDependencies, serverUrl, installPath);
-            packages.forEach(pkg => ResolveFilePaths(pkg));
             installationStage = 'downloadAndInstallPackages';
-            await DownloadAndInstallPackages(packages, this.networkSettingsProvider, this.platformInfo, this.eventStream);
+            await DownloadAndInstallPackages(packages, this.networkSettingsProvider, this.platformInfo, this.eventStream, this.extensionPath);
             this.eventStream.post(new InstallationSuccess());
         }
         catch (error) {

src/omnisharp/extension.ts

@@ -38,14 +38,14 @@ import { StructureProvider } from '../features/structureProvider';
 
 export let omnisharp: OmniSharpServer;
 
-export async function activate(context: vscode.ExtensionContext, packageJSON: any, platformInfo: PlatformInformation, provider: NetworkSettingsProvider, eventStream: EventStream, optionProvider: OptionProvider) {
+export async function activate(context: vscode.ExtensionContext, packageJSON: any, platformInfo: PlatformInformation, provider: NetworkSettingsProvider, eventStream: EventStream, optionProvider: OptionProvider, extensionPath: string) {
     const documentSelector: vscode.DocumentSelector = {
         language: 'csharp',
         scheme: 'file' // only files from disk
     };
 
     const options = optionProvider.GetLatestOptions();
-    const server = new OmniSharpServer(vscode, provider, packageJSON, platformInfo, eventStream, optionProvider);
+    const server = new OmniSharpServer(vscode, provider, packageJSON, platformInfo, eventStream, optionProvider, extensionPath);
     omnisharp = server;
     const advisor = new Advisor(server); // create before server is started
     const disposables = new CompositeDisposable();

src/omnisharp/server.ts

@@ -91,9 +91,9 @@ export class OmniSharpServer {
     private updateProjectDebouncer = new Subject<ObservableEvents.ProjectModified>();
     private firstUpdateProject: boolean;
 
-    constructor(private vscode: vscode, networkSettingsProvider: NetworkSettingsProvider, private packageJSON: any, private platformInfo: PlatformInformation, private eventStream: EventStream, private optionProvider: OptionProvider) {
+    constructor(private vscode: vscode, networkSettingsProvider: NetworkSettingsProvider, private packageJSON: any, private platformInfo: PlatformInformation, private eventStream: EventStream, private optionProvider: OptionProvider, extensionPath: string) {
         this._requestQueue = new RequestQueueCollection(this.eventStream, 8, request => this._makeRequest(request));
-        let downloader = new OmnisharpDownloader(networkSettingsProvider, this.eventStream, this.packageJSON, platformInfo);
+        let downloader = new OmnisharpDownloader(networkSettingsProvider, this.eventStream, this.packageJSON, platformInfo, extensionPath);
         this._omnisharpManager = new OmnisharpManager(downloader, platformInfo);
         this.updateProjectDebouncer.debounceTime(1500).subscribe((event) => { this.updateProjectInfo(); });
         this.firstUpdateProject = true;

src/packageManager/AbsolutePath.ts

@@ -0,0 +1,18 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { isAbsolute, resolve } from "path";
+
+export class AbsolutePath{
+    constructor(public value: string) {
+        if (!isAbsolute(value)) {
+            throw new Error("The path must be absolute");
+        }
+    }
+
+    public static getAbsolutePath(...pathSegments: string[]): AbsolutePath {
+        return new AbsolutePath(resolve(...pathSegments));
+    }
+}

src/packageManager/AbsolutePathPackage.ts

@@ -0,0 +1,60 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Package } from "./Package";
+import { IPackage } from "./IPackage";
+import { AbsolutePath } from "./AbsolutePath";
+
+export class AbsolutePathPackage implements IPackage{
+    constructor(public description: string,
+        public url: string,
+        public platforms: string[],
+        public architectures: string[],
+        public binaries: AbsolutePath[],
+        public installPath?: AbsolutePath,
+        public installTestPath?: AbsolutePath, 
+        public fallbackUrl?: string,
+        public platformId?: string) {
+    }
+
+    public static getAbsolutePathPackage(pkg: Package, extensionPath: string) {
+        return new AbsolutePathPackage(
+            pkg.description,
+            pkg.url,
+            pkg.platforms,
+            pkg.architectures,
+            getAbsoluteBinaries(pkg, extensionPath),
+            getAbsoluteInstallPath(pkg, extensionPath),
+            getAbsoluteInstallTestPath(pkg, extensionPath),
+            pkg.fallbackUrl,
+            pkg.platformId
+        );
+    }
+}
+
+function getAbsoluteInstallTestPath(pkg: Package, extensionPath: string): AbsolutePath { 
+    if (pkg.installTestPath) { 
+        return AbsolutePath.getAbsolutePath(extensionPath, pkg.installTestPath);
+    } 
+ 
+    return null; 
+} 
+ 
+function getAbsoluteBinaries(pkg: Package, extensionPath: string): AbsolutePath[] { 
+    let basePath = getAbsoluteInstallPath(pkg, extensionPath).value;
+    if (pkg.binaries) { 
+        return pkg.binaries.map(value => AbsolutePath.getAbsolutePath(basePath, value)); 
+    } 
+ 
+    return null; 
+} 
+ 
+function getAbsoluteInstallPath(pkg: Package, extensionPath: string): AbsolutePath { 
+    if (pkg.installPath) { 
+        return AbsolutePath.getAbsolutePath(extensionPath, pkg.installPath);
+    } 
+ 
+    return new AbsolutePath(extensionPath); 
+} 

src/packageManager/IPackage.ts

@@ -0,0 +1,13 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+export interface IPackage {
+    description: string;
+    url: string;
+    fallbackUrl?: string;
+    platforms: string[];
+    architectures: string[];
+    platformId?: string;
+}

src/packageManager/Package.ts

@@ -3,15 +3,10 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-export interface Package {
-    description: string;
-    url: string;
-    fallbackUrl?: string;
+import { IPackage } from "./IPackage";
+
+export interface Package extends IPackage{
     installPath?: string;
-    platforms: string[];
-    architectures: string[];
     binaries: string[];
-    platformId?: string;
-    // Path to use to test if the package has already been installed
     installTestPath?: string;
 }