Merge from vscode a234f13c45b40a0929777cb440ee011b7549eed2 (#8911)

* Merge from vscode a234f13c45b40a0929777cb440ee011b7549eed2

* update distro

* fix layering

* update distro

* fix tests

src/vs/platform/remote/common/remoteAgentFileSystemChannel.ts

@@ -15,6 +15,7 @@ import { OperatingSystem } from 'vs/base/common/platform';
 import { newWriteableStream, ReadableStreamEvents, ReadableStreamEventPayload } from 'vs/base/common/stream';
 import { CancellationToken } from 'vs/base/common/cancellation';
 import { canceled } from 'vs/base/common/errors';
+import { toErrorMessage } from 'vs/base/common/errorMessage';
 
 export const REMOTE_FILE_SYSTEM_CHANNEL_NAME = 'remotefilesystem';
 
@@ -32,13 +33,13 @@ export class RemoteFileSystemProvider extends Disposable implements
 	private readonly session: string = generateUuid();
 
 	private readonly _onDidChange = this._register(new Emitter<readonly IFileChange[]>());
-	readonly onDidChangeFile: Event<readonly IFileChange[]> = this._onDidChange.event;
+	readonly onDidChangeFile = this._onDidChange.event;
 
-	private _onDidWatchErrorOccur: Emitter<string> = this._register(new Emitter<string>());
-	readonly onDidErrorOccur: Event<string> = this._onDidWatchErrorOccur.event;
+	private _onDidWatchErrorOccur = this._register(new Emitter<string>());
+	readonly onDidErrorOccur = this._onDidWatchErrorOccur.event;
 
 	private readonly _onDidChangeCapabilities = this._register(new Emitter<void>());
-	readonly onDidChangeCapabilities: Event<void> = this._onDidChangeCapabilities.event;
+	readonly onDidChangeCapabilities = this._onDidChangeCapabilities.event;
 
 	private _capabilities!: FileSystemProviderCapabilities;
 	get capabilities(): FileSystemProviderCapabilities { return this._capabilities; }
@@ -117,14 +118,29 @@ export class RemoteFileSystemProvider extends Disposable implements
 
 		// Reading as file stream goes through an event to the remote side
 		const listener = this.channel.listen<ReadableStreamEventPayload<VSBuffer>>('readFileStream', [resource, opts])(dataOrErrorOrEnd => {
+
+			// data
 			if (dataOrErrorOrEnd instanceof VSBuffer) {
-
-				// data: forward into the stream
 				stream.write(dataOrErrorOrEnd.buffer);
-			} else {
+			}
 
-				// error / end: always end the stream on errors too
-				stream.end(dataOrErrorOrEnd === 'end' ? undefined : dataOrErrorOrEnd);
+			// end or error
+			else {
+				if (dataOrErrorOrEnd === 'end') {
+					stream.end();
+				} else {
+
+					// Since we receive data through a IPC channel, it is likely
+					// that the error was not serialized, or only partially. To
+					// ensure our API use is correct, we convert the data to an
+					// error here to forward it properly.
+					let error = dataOrErrorOrEnd;
+					if (!(error instanceof Error)) {
+						error = new Error(toErrorMessage(error));
+					}
+
+					stream.end(error);
+				}
 
 				// Signal to the remote side that we no longer listen
 				listener.dispose();

src/vs/platform/remote/common/remoteAuthorityResolver.ts

@@ -17,8 +17,13 @@ export interface ResolvedOptions {
 	readonly extensionHostEnv?: { [key: string]: string | null };
 }
 
+export interface TunnelDescription {
+	remoteAddress: { port: number, host: string };
+	localAddress: string;
+}
 export interface TunnelInformation {
-	environmentTunnels?: { remoteAddress: { port: number, host: string }, localAddress: string }[];
+	environmentTunnels?: TunnelDescription[];
+	hideCandidatePorts?: boolean;
 }
 
 export interface ResolverResult {

src/vs/platform/remote/common/tunnel.ts

@@ -20,7 +20,7 @@ export interface RemoteTunnel {
 
 export interface TunnelOptions {
 	remoteAddress: { port: number, host: string };
-	localPort?: number;
+	localAddressPort?: number;
 	label?: string;
 }
 

src/vs/platform/remote/common/tunnelService.ts

@@ -1,26 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the Source EULA. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { ITunnelService, RemoteTunnel, ITunnelProvider } from 'vs/platform/remote/common/tunnel';
-import { Event, Emitter } from 'vs/base/common/event';
-import { IDisposable } from 'vs/base/common/lifecycle';
-
-export class NoOpTunnelService implements ITunnelService {
-	_serviceBrand: undefined;
-
-	public readonly tunnels: Promise<readonly RemoteTunnel[]> = Promise.resolve([]);
-	private _onTunnelOpened: Emitter<RemoteTunnel> = new Emitter();
-	public onTunnelOpened: Event<RemoteTunnel> = this._onTunnelOpened.event;
-	private _onTunnelClosed: Emitter<{ host: string, port: number }> = new Emitter();
-	public onTunnelClosed: Event<{ host: string, port: number }> = this._onTunnelClosed.event;
-	openTunnel(_remoteHost: string, _remotePort: number): Promise<RemoteTunnel> | undefined {
-		return undefined;
-	}
-	async closeTunnel(_remoteHost: string, _remotePort: number): Promise<void> {
-	}
-	setTunnelProvider(provider: ITunnelProvider | undefined): IDisposable {
-		throw new Error('Method not implemented.');
-	}
-}