Support using dual OmniSharp servers to improve handling of .csproj and project.json

gulpfile.js

@@ -15,10 +15,13 @@ const vsce = require('vsce');
 const debugUtil = require('./out/coreclr-debug/util.js');
 const debugInstall = require('./out/coreclr-debug/install.js');
 const fs_extra = require('fs-extra-promise');
-const omnisharpDownload = require('./out/omnisharp/download');
+const omnisharp = require('./out/omnisharp/omnisharp');
+const download = require('./out/omnisharp/download');
+const platform = require('./out/platform');
 const child_process = require('child_process');
 
-const OmniSharpVersion = omnisharpDownload.OmniSharpVersion;
+const Flavor = omnisharp.Flavor;
+const Platform = platform.Platform;
 
 /// used in offline packaging run so does not clean .vsix
 function clean() {
@@ -31,9 +34,9 @@ gulp.task('clean', ['omnisharp:clean',  'debugger:clean', 'package:clean'], () =
 });
 
 /// Omnisharp Tasks
-function installOmnisharp(omnisharpAssetName) {
-    const logFunction = (message) => { console.log(message); };
-    return omnisharpDownload.downloadOmnisharp(logFunction, omnisharpAssetName);
+function installOmnisharp(flavor, platform) {
+    const logger = (message) => { console.log(message); };
+    return download.go(flavor, platform, logger);
 }
 
 function cleanOmnisharp() {
@@ -45,8 +48,10 @@ gulp.task('omnisharp:clean', () => {
 });
 
 gulp.task('omnisharp:install', ['omnisharp:clean'], () => {
-    var asset = gulpUtil.env.asset || omnisharpDownload.getOmnisharpAssetName();
-    return installOmnisharp(asset);
+    const flavor = gulpUtil.env.flavor || Flavor.CoreCLR;
+    const platform = gulpUtil.env.platform || platform.getCurrentPlatform();
+
+    return installOmnisharp(flavor, platform);
 });
 
 /// Debugger Tasks
@@ -97,11 +102,11 @@ function doPackageSync(packageName) {
     }
 }
 
-function doOfflinePackage(runtimeId, omnisharpAsset, packageName) {
+function doOfflinePackage(runtimeId, flavor, platform, packageName) {
     return clean().then(() => {
         return installDebugger(runtimeId);
     }).then(() => {
-        return installOmnisharp(omnisharpAsset);
+        return installOmnisharp(flavor, platform);
     }).then(() => {
         doPackageSync(packageName + '-' + runtimeId + '.vsix');
     });
@@ -122,21 +127,21 @@ gulp.task('package:offline', ['clean'], () => {
     var packageName = name + '.' + version;
 
     var packages = [];
-    packages.push({rid: 'win7-x64', omni: `omnisharp-${OmniSharpVersion}-win-x64-net451.zip`});
-    packages.push({rid: 'osx.10.11-x64', omni: `omnisharp-${OmniSharpVersion}-osx-x64-netcoreapp1.0.tar.gz`});
-    packages.push({rid: 'centos.7-x64', omni: `omnisharp-${OmniSharpVersion}-centos-x64-netcoreapp1.0.tar.gz`});
-    packages.push({rid: 'debian.8-x64', omni: `omnisharp-${OmniSharpVersion}-debian-x64-netcoreapp1.0.tar.gz`});
-    packages.push({rid: 'fedora.23-x64', omni: `omnisharp-${OmniSharpVersion}-fedora-x64-netcoreapp1.0.tar.gz`});
-    packages.push({rid: 'opensuse.13.2-x64', omni: `omnisharp-${OmniSharpVersion}-opensuse-x64-netcoreapp1.0.tar.gz`});
-    packages.push({rid: 'rhel.7.2-x64', omni: `omnisharp-${OmniSharpVersion}-rhel-x64-netcoreapp1.0.tar.gz`});
-    packages.push({rid: 'ubuntu.14.04-x64', omni: `omnisharp-${OmniSharpVersion}-ubuntu14-x64-netcoreapp1.0.tar.gz`});
-    packages.push({rid: 'ubuntu.16.04-x64', omni: `omnisharp-${OmniSharpVersion}-ubuntu16-x64-netcoreapp1.0.tar.gz`});
+    packages.push({rid: 'win7-x64', flavor: Flavor.Desktop, platform: Platform.Windows});
+    packages.push({rid: 'osx.10.11-x64', flavor: Flavor.CoreCLR, platform: Platform.OSX});
+    packages.push({rid: 'centos.7-x64', flavor: Flavor.CoreCLR, platform: Platform.CentOS});
+    packages.push({rid: 'debian.8-x64', flavor: Flavor.CoreCLR, platform: Platform.Debian});
+    packages.push({rid: 'fedora.23-x64', flavor: Flavor.CoreCLR, platform: Platform.Fedora});
+    packages.push({rid: 'opensuse.13.2-x64', flavor: Flavor.CoreCLR, platform: Platform.OpenSUSE});
+    packages.push({rid: 'rhel.7.2-x64', flavor: Flavor.CoreCLR, platform: Platform.RHEL});
+    packages.push({rid: 'ubuntu.14.04-x64', flavor: Flavor.CoreCLR, platform: Platform.Ubuntu14});
+    packages.push({rid: 'ubuntu.16.04-x64', flavor: Flavor.CoreCLR, platform: Platform.Ubuntu16});
 
     var promise = Promise.resolve();
 
-    packages.forEach(pair => {
+    packages.forEach(data => {
         promise = promise.then(() => {
-            return doOfflinePackage(pair.rid, pair.omni, packageName);
+            return doOfflinePackage(data.rid, data.flavor, data.platform, packageName);
         })
     });
 

package.json

@@ -1,7 +1,7 @@
 {
   "name": "csharp",
   "publisher": "ms-vscode",
-  "version": "1.3.0",
+  "version": "1.3.0-beta1",
   "description": "C# for Visual Studio Code (powered by OmniSharp).",
   "displayName": "C#",
   "author": "Microsoft Corporation",

src/coreclr-debug/activate.ts

@@ -11,7 +11,7 @@ import * as path from 'path';
 import TelemetryReporter from 'vscode-extension-telemetry';
 import { CoreClrDebugUtil } from './util';
 import * as debugInstall from './install';
-import { SupportedPlatform, getSupportedPlatform } from './../utils';
+import { Platform, getCurrentPlatform } from './../platform';
 
 let _reporter: TelemetryReporter = null;
 let _channel: vscode.OutputChannel = null;
@@ -114,21 +114,21 @@ function getPlatformRuntimeId() : string {
         case 'darwin':
             return 'osx.10.11-x64';
         case 'linux':
-            switch (getSupportedPlatform())
+            switch (getCurrentPlatform())
             {
-                case SupportedPlatform.CentOS:
+                case Platform.CentOS:
                     return 'centos.7-x64';
-                case SupportedPlatform.Fedora:
+                case Platform.Fedora:
                     return 'fedora.23-x64';
-                case SupportedPlatform.OpenSUSE:
+                case Platform.OpenSUSE:
                     return 'opensuse.13.2-x64';
-                case SupportedPlatform.RHEL:
+                case Platform.RHEL:
                     return 'rhel.7-x64';
-                case SupportedPlatform.Debian:
+                case Platform.Debian:
                     return 'debian.8-x64';
-                case SupportedPlatform.Ubuntu14:
+                case Platform.Ubuntu14:
                     return 'ubuntu.14.04-x64';
-                case SupportedPlatform.Ubuntu16:
+                case Platform.Ubuntu16:
                     return 'ubuntu.16.04-x64';
                 default:
                     throw Error('Error: Unsupported linux platform');

src/features/commands.ts

@@ -7,7 +7,7 @@
 
 import {OmnisharpServer} from '../omnisharp/server';
 import * as serverUtils from '../omnisharp/utils';
-import findLaunchTargets from '../omnisharp/launchTargetFinder';
+import {findLaunchTargets} from '../omnisharp/launcher';
 import * as cp from 'child_process';
 import * as fs from 'fs-extra-promise';
 import * as path from 'path';
@@ -47,7 +47,7 @@ function pickProjectAndStart(server: OmnisharpServer) {
         let currentPath = server.getSolutionPathOrFolder();
         if (currentPath) {
             for (let target of targets) {
-                if (target.target.fsPath === currentPath) {
+                if (target.target === currentPath) {
                     target.label = `\u2713 ${target.label}`;
                 }
             }
@@ -56,9 +56,9 @@ function pickProjectAndStart(server: OmnisharpServer) {
         return vscode.window.showQuickPick(targets, {
             matchOnDescription: true,
             placeHolder: `Select 1 of ${targets.length} projects`
-        }).then(target => {
-            if (target) {
-                return server.restart(target.target.fsPath);
+        }).then(launchTarget => {
+            if (launchTarget) {
+                return server.restart(launchTarget);
             }
         });
     });

src/features/status.ts

@@ -90,6 +90,13 @@ export function reportDocumentStatus(server: OmnisharpServer): vscode.Disposable
 		render();
 	}));
 
+	disposables.push(server.onBeforeServerInstall(() => {
+		defaultStatus.text = '$(flame) Installing OmniSharp...';
+		defaultStatus.command = 'o.showOutput';
+		defaultStatus.color = '';
+		render();
+	}));
+
 	disposables.push(server.onBeforeServerStart(path => {
 		defaultStatus.text = '$(flame) Starting...';
 		defaultStatus.command = 'o.showOutput';

src/omnisharp/download.ts

@@ -3,6 +3,11 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
+ /*
+ * Note that this file intentionally does not import 'vscode' as the code within is intended
+ * to be usable outside of VS Code. 
+ */
+
 'use strict';
 
 import * as fs from 'fs-extra-promise';
@@ -11,46 +16,70 @@ import * as https from 'https';
 import * as stream from 'stream';
 import * as tmp from 'tmp';
 import {parse} from 'url';
-import {SupportedPlatform, getSupportedPlatform} from '../utils';
+import {Flavor, getInstallDirectory} from './omnisharp';
+import {Platform} from '../platform';
 import {getProxyAgent} from '../proxy';
 
 const decompress = require('decompress');
 
 const BaseDownloadUrl = 'https://omnisharpdownload.blob.core.windows.net/ext';
-const DefaultInstallLocation = path.join(__dirname, '../.omnisharp');
-export const OmniSharpVersion = '1.9-beta11';
+const OmniSharpVersion = '1.9-beta12';
 
 tmp.setGracefulCleanup();
 
-export function getOmnisharpAssetName(): string {
-    switch (getSupportedPlatform()) {
-        case SupportedPlatform.Windows:
-            return `omnisharp-${OmniSharpVersion}-win-x64-net451.zip`;
-        case SupportedPlatform.OSX:
-            return `omnisharp-${OmniSharpVersion}-osx-x64-netcoreapp1.0.tar.gz`;
-        case SupportedPlatform.CentOS:
-            return `omnisharp-${OmniSharpVersion}-centos-x64-netcoreapp1.0.tar.gz`;
-        case SupportedPlatform.Debian:
-            return `omnisharp-${OmniSharpVersion}-debian-x64-netcoreapp1.0.tar.gz`;
-        case SupportedPlatform.Fedora:
-            return `omnisharp-${OmniSharpVersion}-fedora-x64-netcoreapp1.0.tar.gz`;
-        case SupportedPlatform.OpenSUSE:
-            return `omnisharp-${OmniSharpVersion}-opensuse-x64-netcoreapp1.0.tar.gz`;
-        case SupportedPlatform.RHEL:
-            return `omnisharp-${OmniSharpVersion}-rhel-x64-netcoreapp1.0.tar.gz`;
-        case SupportedPlatform.Ubuntu14:
-            return `omnisharp-${OmniSharpVersion}-ubuntu14-x64-netcoreapp1.0.tar.gz`;
-        case SupportedPlatform.Ubuntu16:
-            return `omnisharp-${OmniSharpVersion}-ubuntu16-x64-netcoreapp1.0.tar.gz`;
-
-        default:
-            if (process.platform === 'linux') {
-                throw new Error(`Unsupported linux distribution`);
-            }
-            else {
-                throw new Error(`Unsupported platform: ${process.platform}`);
-            }
+function getDownloadFileName(flavor: Flavor, platform: Platform): string {
+    let fileName = `omnisharp-${OmniSharpVersion}-`;
+
+    if (flavor === Flavor.CoreCLR) {
+        switch (platform) {
+            case Platform.Windows:
+                fileName += 'win-x64-netcoreapp1.0.zip';
+                break;
+            case Platform.OSX:
+                fileName += 'osx-x64-netcoreapp1.0.tar.gz';
+                break;
+            case Platform.CentOS:
+                fileName += 'centos-x64-netcoreapp1.0.tar.gz';
+                break;
+            case Platform.Debian:
+                fileName += 'debian-x64-netcoreapp1.0.tar.gz';
+                break;
+            case Platform.Fedora:
+                fileName += 'fedora-x64-netcoreapp1.0.tar.gz';
+                break;
+            case Platform.OpenSUSE:
+                fileName += 'opensuse-x64-netcoreapp1.0.tar.gz';
+                break;
+            case Platform.RHEL:
+                fileName += 'rhel-x64-netcoreapp1.0.tar.gz';
+                break;
+            case Platform.Ubuntu14:
+                fileName += 'ubuntu14-x64-netcoreapp1.0.tar.gz';
+                break;
+            case Platform.Ubuntu16:
+                fileName += 'ubuntu16-x64-netcoreapp1.0.tar.gz';
+                break;
+
+            default:
+                if (process.platform === 'linux') {
+                    throw new Error(`Unsupported linux distribution`);
+                }
+                else {
+                    throw new Error(`Unsupported platform: ${process.platform}`);
+                }
+        }
+    }
+    else if (flavor === Flavor.Desktop) {
+        fileName += 'win-x64-net451.zip';
     }
+    else if (flavor === Flavor.Mono) {
+        fileName += 'mono.tar.gz';
+    }
+    else {
+        throw new Error(`Unexpected OmniSharp flavor specified: ${flavor}`);
+    }
+
+    return fileName;
 }
 
 function download(urlString: string, proxy?: string, strictSSL?: boolean): Promise<stream.Readable> {
@@ -79,14 +108,20 @@ function download(urlString: string, proxy?: string, strictSSL?: boolean): Promi
     });
 }
 
-export function downloadOmnisharp(log: (message: string) => void, omnisharpAssetName?: string, proxy?: string, strictSSL?: boolean) {
+export function go(flavor: Flavor, platform: Platform, log?: (message: string) => void, proxy?: string, strictSSL?: boolean) {
     return new Promise<boolean>((resolve, reject) => {
-        log(`[INFO] Installing to ${DefaultInstallLocation}`);
+        log = log || (_ => { });
+
+        log(`Flavor: ${flavor}, Platform: ${platform}`);
+
+        const fileName = getDownloadFileName(flavor, platform);
+        const installDirectory = getInstallDirectory(flavor);
+
+        log(`[INFO] Installing OmniSharp to ${installDirectory}`);
 
-        const assetName = omnisharpAssetName || getOmnisharpAssetName();
-        const urlString = `${BaseDownloadUrl}/${assetName}`;
+        const urlString = `${BaseDownloadUrl}/${fileName}`;
 
-        log(`[INFO] Attempting to download ${assetName}...`);
+        log(`[INFO] Attempting to download ${fileName}...`);
 
         return download(urlString, proxy, strictSSL)
             .then(inStream => {
@@ -108,7 +143,7 @@ export function downloadOmnisharp(log: (message: string) => void, omnisharpAsset
                         log(`[INFO] Download complete!`);
                         log(`[INFO] Decompressing...`);
 
-                        return decompress(tmpPath, DefaultInstallLocation)
+                        return decompress(tmpPath, installDirectory)
                             .then(files => {
                                 log(`[INFO] Done! ${files.length} files unpacked.`);
                                 return resolve(true);