Merge from vscode a5cf1da01d5db3d2557132be8d30f89c38019f6c (#8525)

* Merge from vscode a5cf1da01d5db3d2557132be8d30f89c38019f6c

* remove files we don't want

* fix hygiene

* update distro

* update distro

* fix hygiene

* fix strict nulls

* distro

* distro

* fix tests

* fix tests

* add another edit

* fix viewlet icon

* fix azure dialog

* fix some padding

* fix more padding issues

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

@@ -89,8 +89,8 @@ async function connectToRemoteExtensionHostAgent(options: ISimpleConnectionOptio
 			options.host,
 			options.port,
 			`reconnectionToken=${options.reconnectionToken}&reconnection=${options.reconnectionProtocol ? 'true' : 'false'}`,
-			(err: any, socket: ISocket) => {
-				if (err) {
+			(err: any, socket: ISocket | undefined) => {
+				if (err || !socket) {
 					options.logService.error(`${logPrefix} socketFactory.connect() failed. Error:`);
 					options.logService.error(err);
 					e(err);

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

@@ -8,10 +8,13 @@ import { Disposable, IDisposable, toDisposable } from 'vs/base/common/lifecycle'
 import { URI, UriComponents } from 'vs/base/common/uri';
 import { generateUuid } from 'vs/base/common/uuid';
 import { IChannel } from 'vs/base/parts/ipc/common/ipc';
-import { FileChangeType, FileDeleteOptions, FileOverwriteOptions, FileSystemProviderCapabilities, FileType, IFileChange, IFileSystemProvider, IStat, IWatchOptions, FileOpenOptions } from 'vs/platform/files/common/files';
+import { FileChangeType, FileDeleteOptions, FileOverwriteOptions, FileSystemProviderCapabilities, FileType, IFileChange, IStat, IWatchOptions, FileOpenOptions, IFileSystemProviderWithFileReadWriteCapability, FileWriteOptions, IFileSystemProviderWithFileReadStreamCapability, IFileSystemProviderWithFileFolderCopyCapability, FileReadStreamOptions, IFileSystemProviderWithOpenReadWriteCloseCapability } from 'vs/platform/files/common/files';
 import { VSBuffer } from 'vs/base/common/buffer';
 import { IRemoteAgentEnvironment } from 'vs/platform/remote/common/remoteAgentEnvironment';
 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';
 
 export const REMOTE_FILE_SYSTEM_CHANNEL_NAME = 'remotefilesystem';
 
@@ -20,7 +23,11 @@ export interface IFileChangeDto {
 	type: FileChangeType;
 }
 
-export class RemoteExtensionsFileSystemProvider extends Disposable implements IFileSystemProvider {
+export class RemoteFileSystemProvider extends Disposable implements
+	IFileSystemProviderWithFileReadWriteCapability,
+	IFileSystemProviderWithOpenReadWriteCloseCapability,
+	IFileSystemProviderWithFileReadStreamCapability,
+	IFileSystemProviderWithFileFolderCopyCapability {
 
 	private readonly session: string = generateUuid();
 
@@ -46,7 +53,7 @@ export class RemoteExtensionsFileSystemProvider extends Disposable implements IF
 	}
 
 	private registerListeners(): void {
-		this._register(this.channel.listen<IFileChangeDto[] | string>('filechange', [this.session])((eventsOrError) => {
+		this._register(this.channel.listen<IFileChangeDto[] | string>('filechange', [this.session])(eventsOrError => {
 			if (Array.isArray(eventsOrError)) {
 				const events = eventsOrError;
 				this._onDidChange.fire(events.map(event => ({ resource: URI.revive(event.resource), type: event.type })));
@@ -59,7 +66,9 @@ export class RemoteExtensionsFileSystemProvider extends Disposable implements IF
 
 	setCaseSensitive(isCaseSensitive: boolean) {
 		let capabilities = (
-			FileSystemProviderCapabilities.FileOpenReadWriteClose
+			FileSystemProviderCapabilities.FileReadWrite
+			| FileSystemProviderCapabilities.FileOpenReadWriteClose
+			| FileSystemProviderCapabilities.FileReadStream
 			| FileSystemProviderCapabilities.FileFolderCopy
 		);
 
@@ -97,10 +106,57 @@ export class RemoteExtensionsFileSystemProvider extends Disposable implements IF
 		return bytesRead;
 	}
 
+	async readFile(resource: URI): Promise<Uint8Array> {
+		const buff = <VSBuffer>await this.channel.call('readFile', [resource]);
+
+		return buff.buffer;
+	}
+
+	readFileStream(resource: URI, opts: FileReadStreamOptions, token?: CancellationToken): ReadableStreamEvents<Uint8Array> {
+		const stream = newWriteableStream<Uint8Array>(data => VSBuffer.concat(data.map(data => VSBuffer.wrap(data))).buffer);
+
+		// Reading as file stream goes through an event to the remote side
+		const listener = this.channel.listen<ReadableStreamEventPayload<VSBuffer>>('readFileStream', [resource, opts])(dataOrErrorOrEnd => {
+			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);
+
+				// Signal to the remote side that we no longer listen
+				listener.dispose();
+			}
+		});
+
+		// Support cancellation
+		if (token) {
+			Event.once(token.onCancellationRequested)(() => {
+
+				// Ensure to end the stream properly with an error
+				// to indicate the cancellation.
+				stream.end(canceled());
+
+				// Ensure to dispose the listener upon cancellation. This will
+				// bubble through the remote side as event and allows to stop
+				// reading the file.
+				listener.dispose();
+			});
+		}
+
+		return stream;
+	}
+
 	write(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number> {
 		return this.channel.call('write', [fd, pos, VSBuffer.wrap(data), offset, length]);
 	}
 
+	writeFile(resource: URI, content: Uint8Array, opts: FileWriteOptions): Promise<void> {
+		return this.channel.call('writeFile', [resource, VSBuffer.wrap(content), opts]);
+	}
+
 	delete(resource: URI, opts: FileDeleteOptions): Promise<void> {
 		return this.channel.call('delete', [resource, opts]);
 	}

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

@@ -5,13 +5,14 @@
 
 import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
 import { URI } from 'vs/base/common/uri';
+import { Event } from 'vs/base/common/event';
 
 export const ITunnelService = createDecorator<ITunnelService>('tunnelService');
 
 export interface RemoteTunnel {
 	readonly tunnelRemotePort: number;
 	readonly tunnelLocalPort: number;
-
+	readonly localAddress?: string;
 	dispose(): void;
 }
 
@@ -19,8 +20,11 @@ export interface ITunnelService {
 	_serviceBrand: undefined;
 
 	readonly tunnels: Promise<readonly RemoteTunnel[]>;
+	readonly onTunnelOpened: Event<RemoteTunnel>;
+	readonly onTunnelClosed: Event<number>;
 
-	openTunnel(remotePort: number): Promise<RemoteTunnel> | undefined;
+	openTunnel(remotePort: number, localPort?: number): Promise<RemoteTunnel> | undefined;
+	closeTunnel(remotePort: number): Promise<void>;
 }
 
 export function extractLocalHostUriMetaDataForPortMapping(uri: URI): { address: string, port: number } | undefined {

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

@@ -4,13 +4,19 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { ITunnelService, RemoteTunnel } from 'vs/platform/remote/common/tunnel';
+import { Event, Emitter } from 'vs/base/common/event';
 
 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<number> = new Emitter();
+	public onTunnelClosed: Event<number> = this._onTunnelClosed.event;
 	openTunnel(_remotePort: number): Promise<RemoteTunnel> | undefined {
 		return undefined;
 	}
+	async closeTunnel(_remotePort: number): Promise<void> {
+	}
 }