Enable download and usage of latest version of omnisharp

package.json

@@ -367,7 +367,7 @@
             "null"
           ],
           "default": null,
-          "description": "Specifies how to acquire the OmniSharp to use. Can be one of \"latest\", a specific version number, or the absolute path to a local OmniSharp folder."
+          "description": "Specifies the path to OmniSharp. This can be the absolute path to an OmniSharp executable, a specific version number, or \"latest\". If a version number or \"latest\" is specified, the appropriate version of OmniSharp will be downloaded on your behalf."
         },
         "omnisharp.useMono": {
           "type": "boolean",

src/OmnisharpDownload.Helper.ts

@@ -3,16 +3,16 @@
 * Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
 import * as vscode from 'vscode';
-import { PackageManager, Status, PackageError, Package } from './packages';
+import { Status, PackageError } from './packages';
 import { PlatformInformation } from './platform';
 import { Logger } from './logger';
 import TelemetryReporter from 'vscode-extension-telemetry';
 
-export async function GetDependenciesAndDownloadPackages(packages: Package[], status: Status, platformInfo: PlatformInformation, packageManager: PackageManager, logger: Logger) {
+export function GetNetworkDependencies() {
     const config = vscode.workspace.getConfiguration();
     const proxy = config.get<string>('http.proxy');
     const strictSSL = config.get('http.proxyStrictSSL', true);
-    await packageManager.DownloadPackages(logger, status, proxy, strictSSL);
+    return { Proxy: proxy, StrictSSL: strictSSL };
 }
 
 export function SetStatus() {
@@ -31,13 +31,9 @@ export function SetStatus() {
     return { StatusItem: statusItem, Status: status };
 }
 
-export async function GetAndLogPlatformInformation(logger: Logger): Promise<PlatformInformation> {
-    let platformInfo = await PlatformInformation.GetCurrent();
-
+export function LogPlatformInformation(logger: Logger, platformInfo: PlatformInformation) {
     logger.appendLine(`Platform: ${platformInfo.toString()}`);
     logger.appendLine();
-
-    return platformInfo;
 }
 
 export function ReportInstallationError(logger: Logger, error, telemetryProps: any, installationStage: string) {
@@ -60,6 +56,7 @@ export function ReportInstallationError(logger: Logger, error, telemetryProps: a
         errorMessage = error.toString();
     }
 
+    logger.appendLine();
     logger.appendLine(`Failed at stage: ${installationStage}`);
     logger.appendLine(errorMessage);
 }

src/omnisharp/OmnisharpDownloader.ts

@@ -4,69 +4,96 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as vscode from 'vscode';
-import { PackageManager, Package } from '../packages';
+import { PackageManager, Package, Status } from '../packages';
 import { PlatformInformation } from '../platform';
 import { Logger } from '../logger';
 import TelemetryReporter from 'vscode-extension-telemetry';
-import { GetPackagesFromVersion } from './OmnisharpPackageCreator';
-import { GetDependenciesAndDownloadPackages, SetStatus, GetAndLogPlatformInformation, ReportInstallationError, SendInstallationTelemetry } from '../OmnisharpDownload.Helper';
+import { GetPackagesFromVersion, GetVersionFilePackage } from './OmnisharpPackageCreator';
+import { SetStatus, LogPlatformInformation, ReportInstallationError, SendInstallationTelemetry, GetNetworkDependencies } from '../OmnisharpDownload.Helper';
 
 export class OmnisharpDownloader {
+    private status: Status;
+    private statusItem: vscode.StatusBarItem;
+    private proxy: string;
+    private strictSSL: boolean;
+    private packageManager: PackageManager;
+    private telemetryProps: any;
+
     public constructor(
         private channel: vscode.OutputChannel,
         private logger: Logger,
         private packageJSON: any,
+        private platformInfo: PlatformInformation,
         private reporter?: TelemetryReporter) {
+
+        let statusObject = SetStatus();
+        this.status = statusObject.Status;
+        this.statusItem = statusObject.StatusItem;
+
+        let networkObject = GetNetworkDependencies();
+        this.proxy = networkObject.Proxy;
+        this.strictSSL = networkObject.StrictSSL;
+
+        this.telemetryProps = {};
+        this.packageManager = new PackageManager(this.platformInfo, this.packageJSON);
     }
 
     public async DownloadAndInstallOmnisharp(version: string, serverUrl: string, installPath: string) {
         if (!version) {
             throw new Error('Invalid version');
         }
 
-        this.logger.append('Installing Omnisharp Packages...');
+        this.logger.appendLine('Installing Omnisharp Packages...');
         this.logger.appendLine();
         this.channel.show();
 
-        let statusObject = SetStatus();
-        let status = statusObject.Status;
-        let statusItem = statusObject.StatusItem;
-
-        let telemetryProps: any = {};
         let installationStage = '';
-        let platformInfo: PlatformInformation;
 
         if (this.reporter) {
             this.reporter.sendTelemetryEvent("AcquisitionStart");
         }
 
         try {
-            installationStage = 'getPlatformInfo';
-            platformInfo = await GetAndLogPlatformInformation(this.logger);
+            LogPlatformInformation(this.logger, this.platformInfo);
 
             installationStage = 'getPackageInfo';
             let packages: Package[] = GetPackagesFromVersion(version, this.packageJSON.runtimeDependencies, serverUrl, installPath);
 
             installationStage = 'downloadPackages';
-            let packageManager = new PackageManager(platformInfo, this.packageJSON);
+
             // Specify the packages that the package manager needs to download
-            packageManager.SetVersionPackagesForDownload(packages);
-            await GetDependenciesAndDownloadPackages(packages,status, platformInfo, packageManager, this.logger);
+            this.packageManager.SetVersionPackagesForDownload(packages);
+            await this.packageManager.DownloadPackages(this.logger, this.status, this.proxy, this.strictSSL);
 
             this.logger.appendLine();
 
             installationStage = 'installPackages';
-            await packageManager.InstallPackages(this.logger, status);
+            await this.packageManager.InstallPackages(this.logger, this.status);
 
             installationStage = 'completeSuccess';
         }
-
         catch (error) {
-            ReportInstallationError(this.logger, error, telemetryProps, installationStage);
+            ReportInstallationError(this.logger, error, this.telemetryProps, installationStage);
             throw error;// throw the error up to the server
         }
         finally {
-            SendInstallationTelemetry(this.logger, this.reporter, telemetryProps, installationStage, platformInfo, statusItem);
+            SendInstallationTelemetry(this.logger, this.reporter, this.telemetryProps, installationStage, this.platformInfo, this.statusItem);
+        }
+    }
+
+    public async GetLatestVersion(serverUrl: string, versionFilePathInServer): Promise<string> {
+        let installationStage = 'getLatestVersionInfoFile';
+        try {
+            this.logger.appendLine('Getting latest build information...');
+            this.logger.appendLine();
+            //The package manager needs a package format to download, hence we form a package for the latest version file
+            let filePackage = GetVersionFilePackage(serverUrl, versionFilePathInServer);
+            //Fetch the latest version information from the file
+            return await this.packageManager.GetLatestVersionFromFile(this.logger, this.status, this.proxy, this.strictSSL, filePackage);
+        }
+        catch (error) {
+            ReportInstallationError(this.logger, error, this.telemetryProps, installationStage);
+            throw error;
         }
     }
 }

src/omnisharp/OmnisharpManager.ts

@@ -20,36 +20,42 @@ export class OmnisharpManager {
         private reporter?: TelemetryReporter) {
     }
 
-    public async GetOmnisharpPath(omnisharpPath: string, useMono: boolean, serverUrl: string, installPath: string, extensionPath: string, platformInfo: PlatformInformation): Promise<string> {
+    public async GetOmnisharpPath(omnisharpPath: string, useMono: boolean, serverUrl: string, versionFilePathInServer: string, installPath: string, extensionPath: string, platformInfo: PlatformInformation): Promise<string> {
         // Looks at the options path, installs the dependencies and returns the path to be loaded by the omnisharp server
-        // To Do : Add the functionality for the latest option
-
+        let downloader = new OmnisharpDownloader(this.channel, this.logger, this.packageJSON, platformInfo, this.reporter);
         if (path.isAbsolute(omnisharpPath)) {
             if (await util.fileExists(omnisharpPath)) {
                 return omnisharpPath;
             }
             else {
-                throw new Error('Invalid path specified');
+                throw new Error('The system could not find the specified path');
             }
         }
-        //If the path is not a valid path on disk, treat it as a version 
-        return await this.InstallVersionAndReturnLaunchPath(omnisharpPath, useMono, serverUrl, installPath, extensionPath, platformInfo);
+        else if (omnisharpPath == "latest") {
+            return await this.LatestInstallAndReturnLaunchPath(downloader, useMono, serverUrl, versionFilePathInServer, installPath, extensionPath, platformInfo);
+        }
+
+        //If the path is neither a valid path on disk not the string "latest", treat it as a version 
+        return await this.InstallVersionAndReturnLaunchPath(downloader, omnisharpPath, useMono, serverUrl, installPath, extensionPath, platformInfo);
     }
 
-    public async InstallVersionAndReturnLaunchPath(version: string, useMono: boolean, serverUrl: string, installPath: string, extensionPath: string, platformInfo: PlatformInformation) {
+    public async LatestInstallAndReturnLaunchPath(downloader: OmnisharpDownloader, useMono: boolean, serverUrl: string, versionFilePathInServer: string, installPath: string, extensionPath: string, platformInfo: PlatformInformation) {
+        let version = await downloader.GetLatestVersion(serverUrl, versionFilePathInServer);
+        return await this.InstallVersionAndReturnLaunchPath(downloader, version, useMono, serverUrl, installPath, extensionPath, platformInfo);
+    }
+
+    public async InstallVersionAndReturnLaunchPath(downloader: OmnisharpDownloader, version: string, useMono: boolean, serverUrl: string, installPath: string, extensionPath: string, platformInfo: PlatformInformation) {
         if (semver.valid(version)) {
-            let downloader = new OmnisharpDownloader(this.channel, this.logger, this.packageJSON, this.reporter);
             await downloader.DownloadAndInstallOmnisharp(version, serverUrl, installPath);
-
-            return await GetLaunchPathForVersion(platformInfo, version, installPath, extensionPath, useMono);
+            return GetLaunchPathForVersion(platformInfo, version, installPath, extensionPath, useMono);
         }
         else {
             throw new Error('Invalid omnisharp version specified');
         }
     }
 }
 
-export async function GetLaunchPathForVersion(platformInfo: PlatformInformation, version: string, installPath: string, extensionPath: string, useMono: boolean) {
+export function GetLaunchPathForVersion(platformInfo: PlatformInformation, version: string, installPath: string, extensionPath: string, useMono: boolean) {
     if (!version) {
         throw new Error('Invalid Version');
     }

src/omnisharp/OmnisharpPackageCreator.ts

@@ -55,4 +55,11 @@ function GetPackageFromArchitecture(inputPackage: Package, serverUrl: string, ve
     };
 
     return versionPackage;
-}
+}
+
+export function GetVersionFilePackage(serverUrl: string, pathInServer: string): Package {
+    return <Package>{
+        "description": "Latest version information file",
+        "url": `${serverUrl}/${pathInServer}`
+    };
+}

src/omnisharp/server.ts

@@ -274,9 +274,10 @@ export class OmniSharpServer {
                 let serverUrl = "https://roslynomnisharp.blob.core.windows.net";
                 let installPath = ".omnisharp/experimental";
                 let extensionPath = utils.getExtensionPath();
+                let versionFilePathInServer = 'releases/versioninfo.txt';
                 let manager = new OmnisharpManager(this._csharpChannel, this._csharpLogger, this._packageJSON, this._reporter);
                 let platformInfo = await PlatformInformation.GetCurrent();
-                launchPath = await manager.GetOmnisharpPath(this._options.path, this._options.useMono, serverUrl, installPath, extensionPath, platformInfo);
+                launchPath = await manager.GetOmnisharpPath(this._options.path, this._options.useMono, serverUrl, versionFilePathInServer,installPath, extensionPath, platformInfo);
             }
             catch (error) {
                 this._logger.appendLine('Error occured in loading omnisharp from omnisharp.path');

src/packages.ts

@@ -78,11 +78,7 @@ export class PackageManager {
                 this.allPackages = <Package[]>this.packageJSON.runtimeDependencies;
 
                 // Convert relative binary paths to absolute
-                for (let pkg of this.allPackages) {
-                    if (pkg.binaries) {
-                        pkg.binaries = pkg.binaries.map(value => path.resolve(getBaseInstallPath(pkg), value));
-                    }
-                }
+                resolvePackageBinaries(this.allPackages);
 
                 resolve(this.allPackages);
             }
@@ -111,6 +107,33 @@ export class PackageManager {
 
     public SetVersionPackagesForDownload(packages: Package[]) {
         this.allPackages = packages;
+        resolvePackageBinaries(this.allPackages);
+    }
+
+    public async GetLatestVersionFromFile(logger: Logger, status: Status, proxy: string, strictSSL: boolean, filePackage: Package): Promise<string> {
+        try {
+            let latestVersion: string;
+            await maybeDownloadPackage(filePackage, logger, status, proxy, strictSSL);
+            if (filePackage.tmpFile) {
+                latestVersion = fs.readFileSync(filePackage.tmpFile.name, 'utf8');
+                //Delete the temporary file created
+                filePackage.tmpFile.removeCallback();
+            }
+
+            return latestVersion;
+        }
+        catch (error) {
+            throw new Error(`Could not download the latest version file due to ${error.toString()}`);
+        }
+    }
+}
+
+function resolvePackageBinaries(packages: Package[]) {
+    // Convert relative binary paths to absolute
+    for (let pkg of packages) {
+        if (pkg.binaries) {
+            pkg.binaries = pkg.binaries.map(value => path.resolve(getBaseInstallPath(pkg), value));
+        }
     }
 }
 

test/unitTests/OmnisharpDownloader.test.ts

@@ -10,6 +10,7 @@ import { should } from 'chai';
 import { Logger } from '../../src/logger';
 import { OmnisharpDownloader } from '../../src/omnisharp/OmnisharpDownloader';
 import { rimraf } from 'async-file';
+import { PlatformInformation } from '../../src/platform';
 
 const tmp = require('tmp');
 const chai = require("chai");
@@ -19,7 +20,7 @@ let expect = chai.expect;
 suite("DownloadAndInstallExperimentalVersion : Gets the version packages, downloads and installs them", () => {
     let tmpDir = null;
     const version = "1.2.3";
-    const downloader = GetOmnisharpDownloader();
+    const downloader = GetTestOmnisharpDownloader();
     const serverUrl = "https://roslynomnisharp.blob.core.windows.net";
     const installPath = ".omnisharp/experimental/";
 
@@ -57,10 +58,10 @@ suite("DownloadAndInstallExperimentalVersion : Gets the version packages, downlo
     });
 });
 
-function GetOmnisharpDownloader() {
+function GetTestOmnisharpDownloader() {
     let channel = vscode.window.createOutputChannel('Experiment Channel');
     let logger = new Logger(text => channel.append(text));
-    return new OmnisharpDownloader(channel, logger, GetTestPackageJSON(), null);
+    return new OmnisharpDownloader(channel, logger, GetTestPackageJSON(), new PlatformInformation("win32", "x86"), null);
 }
 
 //Since we need only the runtime dependencies of packageJSON for the downloader create a testPackageJSON