Move more code to /common/

src/vs/code/electron-main/app.ts

@@ -68,7 +68,7 @@ import { homedir } from 'os';
 import { join, sep } from 'vs/base/common/path';
 import { localize } from 'vs/nls';
 import { REMOTE_HOST_SCHEME } from 'vs/platform/remote/common/remoteHosts';
-import { REMOTE_FILE_SYSTEM_CHANNEL_NAME } from 'vs/platform/remote/node/remoteAgentFileSystemChannel';
+import { REMOTE_FILE_SYSTEM_CHANNEL_NAME } from 'vs/platform/remote/common/remoteAgentFileSystemChannel';
 import { ResolvedAuthority } from 'vs/platform/remote/common/remoteAuthorityResolver';
 import { SnapUpdateService } from 'vs/platform/update/electron-main/updateService.snap';
 import { IStorageMainService, StorageMainService } from 'vs/platform/storage/node/storageMainService';

src/vs/platform/remote/browser/remoteAuthorityResolverService.ts

+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { ResolvedAuthority, IRemoteAuthorityResolverService } from 'vs/platform/remote/common/remoteAuthorityResolver';
+
+export class RemoteAuthorityResolverService implements IRemoteAuthorityResolverService {
+
+	_serviceBrand: any;
+
+	constructor() {
+	}
+
+	resolveAuthority(authority: string): Promise<ResolvedAuthority> {
+		if (authority.indexOf(':') >= 0) {
+			const pieces = authority.split(':');
+			return Promise.resolve({ authority, host: pieces[0], port: parseInt(pieces[1], 10) });
+		}
+		return Promise.resolve({ authority, host: authority, port: 80 });
+	}
+
+	setResolvedAuthority(resolvedAuthority: ResolvedAuthority) {
+		throw new Error(`Not implemented`);
+	}
+
+	setResolvedAuthorityError(authority: string, err: any): void {
+		throw new Error(`Not implemented`);
+	}
+}

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

@@ -9,6 +9,7 @@ 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, FileWriteOptions, IFileChange, IFileSystemProvider, IStat, IWatchOptions } from 'vs/platform/files/common/files';
+import { VSBuffer } from 'vs/base/common/buffer';
 
 export const REMOTE_FILE_SYSTEM_CHANNEL_NAME = 'remotefilesystem';
 
@@ -71,20 +72,17 @@ export class RemoteExtensionsFileSystemProvider extends Disposable implements IF
 
 	// --- forwarding calls
 
-	private static _asBuffer(data: Uint8Array): Buffer {
-		return Buffer.isBuffer(data) ? data : Buffer.from(data.buffer, data.byteOffset, data.byteLength);
-	}
-
 	stat(resource: URI): Promise<IStat> {
 		return this._channel.call('stat', [resource]);
 	}
 
-	readFile(resource: URI): Promise<Uint8Array> {
-		return this._channel.call('readFile', [resource]);
+	async readFile(resource: URI): Promise<Uint8Array> {
+		const buff = <VSBuffer>await this._channel.call('readFile', [resource]);
+		return buff.buffer;
 	}
 
 	writeFile(resource: URI, content: Uint8Array, opts: FileWriteOptions): Promise<void> {
-		const contents = RemoteExtensionsFileSystemProvider._asBuffer(content);
+		const contents = VSBuffer.wrap(content);
 		return this._channel.call('writeFile', [resource, contents, opts]);
 	}
 

src/vs/workbench/electron-browser/main.ts

@@ -47,7 +47,7 @@ import { FileService2 } from 'vs/workbench/services/files2/common/fileService2';
 import { IFileService } from 'vs/platform/files/common/files';
 import { DiskFileSystemProvider } from 'vs/workbench/services/files2/electron-browser/diskFileSystemProvider';
 import { IChannel } from 'vs/base/parts/ipc/common/ipc';
-import { REMOTE_FILE_SYSTEM_CHANNEL_NAME, RemoteExtensionsFileSystemProvider } from 'vs/platform/remote/node/remoteAgentFileSystemChannel';
+import { REMOTE_FILE_SYSTEM_CHANNEL_NAME, RemoteExtensionsFileSystemProvider } from 'vs/platform/remote/common/remoteAgentFileSystemChannel';
 
 class CodeRendererMain extends Disposable {
 

src/vs/workbench/services/remote/common/abstractRemoteAgentService.ts

+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as nls from 'vs/nls';
+import { Disposable } from 'vs/base/common/lifecycle';
+import { IChannel, IServerChannel, getDelayedChannel } from 'vs/base/parts/ipc/common/ipc';
+import { Client } from 'vs/base/parts/ipc/common/ipc.net';
+import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+import { connectRemoteAgentManagement, IConnectionOptions, IWebSocketFactory } from 'vs/platform/remote/common/remoteAgentConnection';
+import { IRemoteAgentConnection, IRemoteAgentService } from 'vs/workbench/services/remote/common/remoteAgentService';
+import { IRemoteAuthorityResolverService } from 'vs/platform/remote/common/remoteAuthorityResolver';
+import { LifecyclePhase } from 'vs/platform/lifecycle/common/lifecycle';
+import { RemoteAgentConnectionContext, IRemoteAgentEnvironment } from 'vs/platform/remote/common/remoteAgentEnvironment';
+import { IWorkbenchContribution, IWorkbenchContributionsRegistry, Extensions } from 'vs/workbench/common/contributions';
+import { Registry } from 'vs/platform/registry/common/platform';
+import { RemoteExtensionEnvironmentChannelClient } from 'vs/workbench/services/remote/common/remoteAgentEnvironmentChannel';
+import { INotificationService } from 'vs/platform/notification/common/notification';
+
+export abstract class AbstractRemoteAgentService extends Disposable implements IRemoteAgentService {
+
+	_serviceBrand: any;
+
+	private _environment: Promise<IRemoteAgentEnvironment | null> | null;
+
+	constructor(
+		@IEnvironmentService protected readonly _environmentService: IEnvironmentService
+	) {
+		super();
+	}
+
+	abstract getConnection(): IRemoteAgentConnection | null;
+
+	getEnvironment(bail?: boolean): Promise<IRemoteAgentEnvironment | null> {
+		if (!this._environment) {
+			const connection = this.getConnection();
+			if (connection) {
+				const client = new RemoteExtensionEnvironmentChannelClient(connection.getChannel('remoteextensionsenvironment'));
+				this._environment = client.getEnvironmentData(connection.remoteAuthority, this._environmentService.extensionDevelopmentLocationURI);
+			} else {
+				this._environment = Promise.resolve(null);
+			}
+		}
+		return bail ? this._environment : this._environment.then(undefined, () => null);
+	}
+}
+
+export class RemoteAgentConnection extends Disposable implements IRemoteAgentConnection {
+
+	readonly remoteAuthority: string;
+	private _connection: Promise<Client<RemoteAgentConnectionContext>> | null;
+
+	constructor(
+		remoteAuthority: string,
+		private _commit: string | undefined,
+		private _webSocketFactory: IWebSocketFactory,
+		private _environmentService: IEnvironmentService,
+		private _remoteAuthorityResolverService: IRemoteAuthorityResolverService
+	) {
+		super();
+		this.remoteAuthority = remoteAuthority;
+		this._connection = null;
+	}
+
+	getChannel<T extends IChannel>(channelName: string): T {
+		return <T>getDelayedChannel(this._getOrCreateConnection().then(c => c.getChannel(channelName)));
+	}
+
+	registerChannel<T extends IServerChannel<RemoteAgentConnectionContext>>(channelName: string, channel: T): void {
+		this._getOrCreateConnection().then(client => client.registerChannel(channelName, channel));
+	}
+
+	private _getOrCreateConnection(): Promise<Client<RemoteAgentConnectionContext>> {
+		if (!this._connection) {
+			this._connection = this._createConnection();
+		}
+		return this._connection;
+	}
+
+	private async _createConnection(): Promise<Client<RemoteAgentConnectionContext>> {
+		const options: IConnectionOptions = {
+			isBuilt: this._environmentService.isBuilt,
+			commit: this._commit,
+			webSocketFactory: this._webSocketFactory,
+			addressProvider: {
+				getAddress: async () => {
+					const { host, port } = await this._remoteAuthorityResolverService.resolveAuthority(this.remoteAuthority);
+					return { host, port };
+				}
+			}
+		};
+		const connection = await connectRemoteAgentManagement(options, this.remoteAuthority, `renderer`);
+		this._register(connection);
+		return connection.client;
+	}
+}
+
+class RemoteConnectionFailureNotificationContribution implements IWorkbenchContribution {
+
+	constructor(
+		@IRemoteAgentService remoteAgentService: IRemoteAgentService,
+		@INotificationService notificationService: INotificationService,
+	) {
+		// Let's cover the case where connecting to fetch the remote extension info fails
+		remoteAgentService.getEnvironment(true)
+			.then(undefined, err => notificationService.error(nls.localize('connectionError', "Failed to connect to the remote extension host agent (Error: {0})", err ? err.message : '')));
+	}
+
+}
+
+const workbenchRegistry = Registry.as<IWorkbenchContributionsRegistry>(Extensions.Workbench);
+workbenchRegistry.registerWorkbenchContribution(RemoteConnectionFailureNotificationContribution, LifecyclePhase.Ready);

src/vs/workbench/services/remote/common/remoteAgentService.ts

@@ -15,7 +15,7 @@ export interface IRemoteAgentService {
 	_serviceBrand: any;
 
 	getConnection(): IRemoteAgentConnection | null;
-	getEnvironment(): Promise<IRemoteAgentEnvironment | null>;
+	getEnvironment(bail?: boolean): Promise<IRemoteAgentEnvironment | null>;
 }
 
 export interface IRemoteAgentConnection {

src/vs/workbench/services/remote/electron-browser/remoteAgentServiceImpl.ts

@@ -3,120 +3,29 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { Disposable } from 'vs/base/common/lifecycle';
-import { IChannel, IServerChannel, getDelayedChannel } from 'vs/base/parts/ipc/common/ipc';
-import { Client } from 'vs/base/parts/ipc/common/ipc.net';
 import { IEnvironmentService } from 'vs/platform/environment/common/environment';
-import { connectRemoteAgentManagement, IConnectionOptions } from 'vs/platform/remote/common/remoteAgentConnection';
 import { IWindowConfiguration } from 'vs/platform/windows/common/windows';
-import { IRemoteAgentConnection, IRemoteAgentService } from 'vs/workbench/services/remote/common/remoteAgentService';
+import { IRemoteAgentConnection } from 'vs/workbench/services/remote/common/remoteAgentService';
 import { IRemoteAuthorityResolverService } from 'vs/platform/remote/common/remoteAuthorityResolver';
-import { LifecyclePhase } from 'vs/platform/lifecycle/common/lifecycle';
-import { RemoteAgentConnectionContext, IRemoteAgentEnvironment } from 'vs/platform/remote/common/remoteAgentEnvironment';
-import { IWorkbenchContribution, IWorkbenchContributionsRegistry, Extensions } from 'vs/workbench/common/contributions';
-import { Registry } from 'vs/platform/registry/common/platform';
-import { RemoteExtensionEnvironmentChannelClient } from 'vs/workbench/services/remote/common/remoteAgentEnvironmentChannel';
-import { INotificationService } from 'vs/platform/notification/common/notification';
-import { localize } from 'vs/nls';
 import product from 'vs/platform/product/node/product';
 import { nodeWebSocketFactory } from 'vs/platform/remote/node/nodeWebSocketFactory';
+import { AbstractRemoteAgentService, RemoteAgentConnection } from 'vs/workbench/services/remote/common/abstractRemoteAgentService';
 
-export class RemoteAgentService extends Disposable implements IRemoteAgentService {
-
-	_serviceBrand: any;
+export class RemoteAgentService extends AbstractRemoteAgentService {
 
 	private readonly _connection: IRemoteAgentConnection | null = null;
-	private _environment: Promise<IRemoteAgentEnvironment | null> | null;
 
-	constructor(
-		{ remoteAuthority }: IWindowConfiguration,
-		@IEnvironmentService private readonly _environmentService: IEnvironmentService,
+	constructor({ remoteAuthority }: IWindowConfiguration,
+		@IEnvironmentService environmentService: IEnvironmentService,
 		@IRemoteAuthorityResolverService remoteAuthorityResolverService: IRemoteAuthorityResolverService
 	) {
-		super();
+		super(environmentService);
 		if (remoteAuthority) {
-			this._connection = this._register(new RemoteAgentConnection(remoteAuthority, _environmentService, remoteAuthorityResolverService));
+			this._connection = this._register(new RemoteAgentConnection(remoteAuthority, product.commit, nodeWebSocketFactory, environmentService, remoteAuthorityResolverService));
 		}
 	}
 
 	getConnection(): IRemoteAgentConnection | null {
 		return this._connection;
 	}
-
-	getEnvironment(bail?: boolean): Promise<IRemoteAgentEnvironment | null> {
-		if (!this._environment) {
-			const connection = this.getConnection();
-			if (connection) {
-				const client = new RemoteExtensionEnvironmentChannelClient(connection.getChannel('remoteextensionsenvironment'));
-				this._environment = client.getEnvironmentData(connection.remoteAuthority, this._environmentService.extensionDevelopmentLocationURI);
-			} else {
-				this._environment = Promise.resolve(null);
-			}
-		}
-		return bail ? this._environment : this._environment.then(undefined, () => null);
-	}
 }
-
-class RemoteAgentConnection extends Disposable implements IRemoteAgentConnection {
-
-	readonly remoteAuthority: string;
-	private _connection: Promise<Client<RemoteAgentConnectionContext>> | null;
-
-	constructor(
-		remoteAuthority: string,
-		private _environmentService: IEnvironmentService,
-		private _remoteAuthorityResolverService: IRemoteAuthorityResolverService
-	) {
-		super();
-		this.remoteAuthority = remoteAuthority;
-		this._connection = null;
-	}
-
-	getChannel<T extends IChannel>(channelName: string): T {
-		return <T>getDelayedChannel(this._getOrCreateConnection().then(c => c.getChannel(channelName)));
-	}
-
-	registerChannel<T extends IServerChannel<RemoteAgentConnectionContext>>(channelName: string, channel: T): void {
-		this._getOrCreateConnection().then(client => client.registerChannel(channelName, channel));
-	}
-
-	private _getOrCreateConnection(): Promise<Client<RemoteAgentConnectionContext>> {
-		if (!this._connection) {
-			this._connection = this._createConnection();
-		}
-		return this._connection;
-	}
-
-	private async _createConnection(): Promise<Client<RemoteAgentConnectionContext>> {
-		const options: IConnectionOptions = {
-			isBuilt: this._environmentService.isBuilt,
-			commit: product.commit,
-			webSocketFactory: nodeWebSocketFactory,
-			addressProvider: {
-				getAddress: async () => {
-					const { host, port } = await this._remoteAuthorityResolverService.resolveAuthority(this.remoteAuthority);
-					return { host, port };
-				}
-			}
-		};
-		const connection = await connectRemoteAgentManagement(options, this.remoteAuthority, `renderer`);
-		this._register(connection);
-		return connection.client;
-	}
-}
-
-class RemoteConnectionFailureNotificationContribution implements IWorkbenchContribution {
-
-	constructor(
-		@IRemoteAgentService remoteAgentService: RemoteAgentService,
-		@INotificationService notificationService: INotificationService,
-	) {
-		// Let's cover the case where connecting to fetch the remote extension info fails
-		remoteAgentService.getEnvironment(true)
-			.then(undefined, err => notificationService.error(localize('connectionError', "Failed to connect to the remote extension host agent (Error: {0})", err ? err.message : '')));
-	}
-
-}
-
-const workbenchRegistry = Registry.as<IWorkbenchContributionsRegistry>(Extensions.Workbench);
-workbenchRegistry.registerWorkbenchContribution(RemoteConnectionFailureNotificationContribution, LifecyclePhase.Ready);
\ No newline at end of file