Use the extension path

Author: akshita31

src/CSharpExtDownloader.ts

@@ -20,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,7 +34,7 @@ export class CSharpExtDownloader {
             this.eventStream.post(new LogPlatformInfo(this.platformInfo));
             let runTimeDependencies = GetRunTimeDependenciesPackages(this.packageJSON);
             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/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

@@ -17,7 +17,8 @@ export class OmnisharpDownloader {
         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,7 +30,7 @@ export class OmnisharpDownloader {
             installationStage = 'getPackageInfo';
             let packages = GetPackagesFromVersion(version, this.packageJSON.runtimeDependencies, serverUrl, installPath);
             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/InstallablePackage.ts

@@ -5,7 +5,6 @@
 
 import { IPackage, Package } from "./Package";
 import { AbsolutePath } from "./AbsolutePath";
-import { getExtensionPath } from "../common";
 
 export class InstallablePackage implements IPackage{
     constructor(public description: string,
@@ -19,43 +18,42 @@ export class InstallablePackage implements IPackage{
         public platformId?: string) {
     }
 
-    public static getInstallablePackage(pkg: Package) {
+    public static getInstallablePackage(pkg: Package, extensionPath: string) {
         return new InstallablePackage(
             pkg.description,
             pkg.url,
             pkg.platforms,
             pkg.architectures,
-            getAbsoluteBinaries(pkg),
-            getAbsoluteInstallPath(pkg),
-            getAbsoluteInstallTestPath(pkg),
+            getAbsoluteBinaries(pkg, extensionPath),
+            getAbsoluteInstallPath(pkg, extensionPath),
+            getAbsoluteInstallTestPath(pkg, extensionPath),
             pkg.fallbackUrl,
             pkg.platformId
         );
     }
 }
 
-function getAbsoluteInstallTestPath(pkg: Package): AbsolutePath { 
+function getAbsoluteInstallTestPath(pkg: Package, extensionPath: string): AbsolutePath { 
     if (pkg.installTestPath) { 
-        return AbsolutePath.getAbsolutePath(getExtensionPath(), pkg.installTestPath);
+        return AbsolutePath.getAbsolutePath(extensionPath, pkg.installTestPath);
     } 
 
     return null; 
 } 
 
-function getAbsoluteBinaries(pkg: Package): AbsolutePath[] { 
-    let basePath = getAbsoluteInstallPath(pkg).path;
+function getAbsoluteBinaries(pkg: Package, extensionPath: string): AbsolutePath[] { 
+    let basePath = getAbsoluteInstallPath(pkg, extensionPath).path;
     if (pkg.binaries) { 
         return pkg.binaries.map(value => AbsolutePath.getAbsolutePath(basePath, value)); 
     } 
 
     return null; 
 } 
 
-function getAbsoluteInstallPath(pkg: Package): AbsolutePath { 
-    let basePath = getExtensionPath(); 
+function getAbsoluteInstallPath(pkg: Package, extensionPath: string): AbsolutePath { 
     if (pkg.installPath) { 
-        return AbsolutePath.getAbsolutePath(basePath, pkg.installPath);
+        return AbsolutePath.getAbsolutePath(extensionPath, pkg.installPath);
     } 
 
-    return new AbsolutePath(basePath); 
+    return new AbsolutePath(extensionPath); 
 } 

test/unitTests/OmnisharpPackageCreator.test.ts

@@ -5,7 +5,7 @@
 
 import { assert, should, expect } from "chai";
 import { SetBinaryAndGetPackage, GetPackagesFromVersion } from "../../src/omnisharp/OmnisharpPackageCreator";
-import { IPackage, Package } from "../../src/packageManager/Package";
+import { Package } from "../../src/packageManager/Package";
 import { testPackageJSON } from "./testAssets/testAssets";
 
 suite("GetOmnisharpPackage : Output package depends on the input package and other input parameters like serverUrl", () => {

test/unitTests/logging/TelemetryObserver.test.ts

@@ -7,7 +7,7 @@ import { TelemetryObserver } from '../../../src/observers/TelemetryObserver';
 import { PlatformInformation } from '../../../src/platform';
 import { PackageInstallation, InstallationFailure, InstallationSuccess, TestExecutionCountReport, TelemetryEventWithMeasures, OmnisharpDelayTrackerEventMeasures, OmnisharpStart } from '../../../src/omnisharp/loggingEvents';
 import { getNullTelemetryReporter } from '../testAssets/Fakes';
-import { IPackage } from '../../../src/packageManager/Package';
+import { Package } from '../../../src/packageManager/Package';
 import { PackageError } from '../../../src/packageManager/PackageError';
 
 const chai = require('chai');
@@ -71,7 +71,7 @@ suite('TelemetryReporterObserver', () => {
         });
 
         test(`Telemetry Props contains message and packageUrl if error is package error`, () => {
-            let error = new PackageError("someError", <IPackage>{ "description": "foo", "url": "someurl" });
+            let error = new PackageError("someError", <Package>{ "description": "foo", "url": "someurl" });
             let event = new InstallationFailure("someStage", error);
             observer.post(event);
             expect(property).to.have.property("error.message", error.message);