Skip to content

Commit db1c20e

Browse files
alexr00alexr00
committed
Tunnel API renames
1 parent d548002 commit db1c20e

12 files changed

Lines changed: 56 additions & 58 deletions

File tree

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

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -18,7 +18,7 @@ export interface ResolvedOptions {
1818
}
1919

2020
export interface TunnelInformation {
21-
detectedTunnels?: { remote: { port: number, host: string }, localAddress: string }[];
21+
environmentTunnels?: { remoteAddress: { port: number, host: string }, localAddress: string }[];
2222
}
2323

2424
export interface ResolverResult {

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

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -19,9 +19,9 @@ export interface RemoteTunnel {
1919
}
2020

2121
export interface TunnelOptions {
22-
remote: { port: number, host: string };
22+
remoteAddress: { port: number, host: string };
2323
localPort?: number;
24-
name?: string;
24+
label?: string;
2525
}
2626

2727
export interface ITunnelProvider {

‎src/vs/vscode.proposed.d.ts‎

Lines changed: 14 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -34,15 +34,18 @@ declare module 'vscode' {
3434
}
3535

3636
export interface TunnelOptions {
37-
remote: { port: number, host: string };
38-
localPort?: number;
39-
name?: string;
37+
remoteAddress: { port: number, host: string };
38+
// The desired local port. If this port can't be used, then another will be chosen.
39+
localAddressPort?: number;
40+
label?: string;
4041
}
4142

4243
export interface Tunnel {
43-
remote: { port: number, host: string };
44+
remoteAddress: { port: number, host: string };
45+
//The complete local address(ex. localhost:1234)
4446
localAddress: string;
45-
onDispose: Event<void>;
47+
// Implementers of Tunnel should fire onDidDispose when dispose is called.
48+
onDidDispose: Event<void>;
4649
dispose(): void;
4750
}
4851

@@ -52,10 +55,10 @@ declare module 'vscode' {
5255
export interface TunnelInformation {
5356
/**
5457
* Tunnels that are detected by the extension. The remotePort is used for display purposes.
55-
* The localAddress should be the complete local address(ex. localhost:1234) for connecting to the port. Tunnels provided through
58+
* The localAddress should be the complete local address (ex. localhost:1234) for connecting to the port. Tunnels provided through
5659
* detected are read-only from the forwarded ports UI.
5760
*/
58-
detectedTunnels?: { remote: { port: number, host: string }, localAddress: string }[];
61+
environmentTunnels?: { remoteAddress: { port: number, host: string }, localAddress: string }[];
5962
}
6063

6164
export type ResolverResult = ResolvedAuthority & ResolvedOptions & TunnelInformation;
@@ -74,16 +77,16 @@ declare module 'vscode' {
7477
* When not implemented, the core will use its default forwarding logic.
7578
* When implemented, the core will use this to forward ports.
7679
*/
77-
forwardPort?(tunnelOptions: TunnelOptions): Thenable<Tunnel> | undefined;
80+
tunnelFactory?: (tunnelOptions: TunnelOptions) => Thenable<Tunnel> | undefined;
7881
}
7982

8083
export namespace workspace {
8184
/**
8285
* Forwards a port. If the current resolver implements RemoteAuthorityResolver:forwardPort then that will be used to make the tunnel.
83-
* By default, makeTunnel only support localhost; however, RemoteAuthorityResolver:forwardPort can be used to support other ips.
84-
* @param forward The `localPort` is a suggestion only. If that port is not available another will be chosen.
86+
* By default, openTunnel only support localhost; however, RemoteAuthorityResolver:tunnelFactory can be used to support other ips.
87+
* @param tunnelOptions The `localPort` is a suggestion only. If that port is not available another will be chosen.
8588
*/
86-
export function makeTunnel(forward: TunnelOptions): Thenable<Tunnel>;
89+
export function openTunnel(tunnelOptions: TunnelOptions): Thenable<Tunnel>;
8790
}
8891

8992
export interface ResourceLabelFormatter {

‎src/vs/workbench/api/browser/mainThreadTunnelService.ts‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -4,10 +4,10 @@
44
*--------------------------------------------------------------------------------------------*/
55

66
import { MainThreadTunnelServiceShape, IExtHostContext, MainContext, ExtHostContext, ExtHostTunnelServiceShape } from 'vs/workbench/api/common/extHost.protocol';
7-
import { TunnelOptions, TunnelDto } from 'vs/workbench/api/common/extHostTunnelService';
7+
import { TunnelDto } from 'vs/workbench/api/common/extHostTunnelService';
88
import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
99
import { IRemoteExplorerService } from 'vs/workbench/services/remote/common/remoteExplorerService';
10-
import { ITunnelProvider, ITunnelService } from 'vs/platform/remote/common/tunnel';
10+
import { ITunnelProvider, ITunnelService, TunnelOptions } from 'vs/platform/remote/common/tunnel';
1111

1212
@extHostNamedCustomer(MainContext.MainThreadTunnelService)
1313
export class MainThreadTunnelService implements MainThreadTunnelServiceShape {
@@ -22,7 +22,7 @@ export class MainThreadTunnelService implements MainThreadTunnelServiceShape {
2222
}
2323

2424
async $openTunnel(tunnelOptions: TunnelOptions): Promise<TunnelDto | undefined> {
25-
const tunnel = await this.remoteExplorerService.forward(tunnelOptions.remote, tunnelOptions.localPort, tunnelOptions.name);
25+
const tunnel = await this.remoteExplorerService.forward(tunnelOptions.remoteAddress, tunnelOptions.localPort, tunnelOptions.label);
2626
if (tunnel) {
2727
return TunnelDto.fromServiceTunnel(tunnel);
2828
}
@@ -44,11 +44,11 @@ export class MainThreadTunnelService implements MainThreadTunnelServiceShape {
4444
if (forward) {
4545
return forward.then(tunnel => {
4646
return {
47-
tunnelRemotePort: tunnel.remote.port,
48-
tunnelRemoteHost: tunnel.remote.host,
47+
tunnelRemotePort: tunnel.remoteAddress.port,
48+
tunnelRemoteHost: tunnel.remoteAddress.host,
4949
localAddress: tunnel.localAddress,
5050
dispose: () => {
51-
this._proxy.$closeTunnel({ host: tunnel.remote.host, port: tunnel.remote.port });
51+
this._proxy.$closeTunnel({ host: tunnel.remoteAddress.host, port: tunnel.remoteAddress.port });
5252
}
5353
};
5454
});

‎src/vs/workbench/api/common/extHost.api.impl.ts‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -714,9 +714,9 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
714714
onWillRenameFiles: (listener: (e: vscode.FileWillRenameEvent) => any, thisArg?: any, disposables?: vscode.Disposable[]) => {
715715
return extHostFileSystemEvent.getOnWillRenameFileEvent(extension)(listener, thisArg, disposables);
716716
},
717-
makeTunnel: (forward: vscode.TunnelOptions) => {
717+
openTunnel: (forward: vscode.TunnelOptions) => {
718718
checkProposedApiEnabled(extension);
719-
return extHostTunnelService.makeTunnel(forward);
719+
return extHostTunnelService.openTunnel(forward);
720720
}
721721
};
722722

‎src/vs/workbench/api/common/extHost.protocol.ts‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -47,7 +47,8 @@ import { createExtHostContextProxyIdentifier as createExtId, createMainContextPr
4747
import * as search from 'vs/workbench/services/search/common/search';
4848
import { SaveReason } from 'vs/workbench/common/editor';
4949
import { ExtensionActivationReason } from 'vs/workbench/api/common/extHostExtensionActivator';
50-
import { TunnelOptions, TunnelDto } from 'vs/workbench/api/common/extHostTunnelService';
50+
import { TunnelDto } from 'vs/workbench/api/common/extHostTunnelService';
51+
import { TunnelOptions } from 'vs/platform/remote/common/tunnel';
5152

5253
export interface IEnvironment {
5354
isExtensionDevelopmentDebug: boolean;

‎src/vs/workbench/api/common/extHostExtensionService.ts‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -662,7 +662,7 @@ export abstract class AbstractExtHostExtensionService implements ExtHostExtensio
662662
value: {
663663
authority,
664664
options,
665-
tunnelInformation: { detectedTunnels: result.detectedTunnels }
665+
tunnelInformation: { environmentTunnels: result.environmentTunnels }
666666
}
667667
};
668668
} catch (err) {

‎src/vs/workbench/api/common/extHostTunnelService.ts‎

Lines changed: 6 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -6,27 +6,20 @@
66
import { ExtHostTunnelServiceShape } from 'vs/workbench/api/common/extHost.protocol';
77
import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
88
import * as vscode from 'vscode';
9-
import { RemoteTunnel } from 'vs/platform/remote/common/tunnel';
9+
import { RemoteTunnel, TunnelOptions } from 'vs/platform/remote/common/tunnel';
1010
import { IDisposable } from 'vs/base/common/lifecycle';
1111

12-
export interface TunnelOptions {
13-
remote: { port: number, host: string };
14-
localPort?: number;
15-
name?: string;
16-
closeable?: boolean;
17-
}
18-
1912
export interface TunnelDto {
20-
remote: { port: number, host: string };
13+
remoteAddress: { port: number, host: string };
2114
localAddress: string;
2215
}
2316

2417
export namespace TunnelDto {
2518
export function fromApiTunnel(tunnel: vscode.Tunnel): TunnelDto {
26-
return { remote: tunnel.remote, localAddress: tunnel.localAddress };
19+
return { remoteAddress: tunnel.remoteAddress, localAddress: tunnel.localAddress };
2720
}
2821
export function fromServiceTunnel(tunnel: RemoteTunnel): TunnelDto {
29-
return { remote: { host: tunnel.tunnelRemoteHost, port: tunnel.tunnelRemotePort }, localAddress: tunnel.localAddress };
22+
return { remoteAddress: { host: tunnel.tunnelRemoteHost, port: tunnel.tunnelRemotePort }, localAddress: tunnel.localAddress };
3023
}
3124
}
3225

@@ -37,15 +30,15 @@ export interface Tunnel extends vscode.Disposable {
3730

3831
export interface IExtHostTunnelService extends ExtHostTunnelServiceShape {
3932
readonly _serviceBrand: undefined;
40-
makeTunnel(forward: TunnelOptions): Promise<vscode.Tunnel | undefined>;
33+
openTunnel(forward: TunnelOptions): Promise<vscode.Tunnel | undefined>;
4134
setForwardPortProvider(provider: vscode.RemoteAuthorityResolver | undefined): Promise<IDisposable>;
4235
}
4336

4437
export const IExtHostTunnelService = createDecorator<IExtHostTunnelService>('IExtHostTunnelService');
4538

4639
export class ExtHostTunnelService implements IExtHostTunnelService {
4740
_serviceBrand: undefined;
48-
async makeTunnel(forward: TunnelOptions): Promise<vscode.Tunnel | undefined> {
41+
async openTunnel(forward: TunnelOptions): Promise<vscode.Tunnel | undefined> {
4942
return undefined;
5043
}
5144
async $findCandidatePorts(): Promise<{ host: string, port: number; detail: string; }[]> {

‎src/vs/workbench/api/node/extHostTunnelService.ts‎

Lines changed: 13 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -13,16 +13,17 @@ import { exec } from 'child_process';
1313
import * as resources from 'vs/base/common/resources';
1414
import * as fs from 'fs';
1515
import { isLinux } from 'vs/base/common/platform';
16-
import { IExtHostTunnelService, TunnelOptions, TunnelDto } from 'vs/workbench/api/common/extHostTunnelService';
16+
import { IExtHostTunnelService, TunnelDto } from 'vs/workbench/api/common/extHostTunnelService';
1717
import { asPromise } from 'vs/base/common/async';
1818
import { Event, Emitter } from 'vs/base/common/event';
19+
import { TunnelOptions } from 'vs/platform/remote/common/tunnel';
1920

2021
class ExtensionTunnel implements vscode.Tunnel {
2122
private _onDispose: Emitter<void> = new Emitter();
22-
onDispose: Event<void> = this._onDispose.event;
23+
onDidDispose: Event<void> = this._onDispose.event;
2324

2425
constructor(
25-
public readonly remote: { port: number; host: string; },
26+
public readonly remoteAddress: { port: number; host: string; },
2627
public readonly localAddress: string,
2728
private readonly _dispose: () => void) { }
2829

@@ -48,11 +49,11 @@ export class ExtHostTunnelService extends Disposable implements IExtHostTunnelSe
4849
this.registerCandidateFinder();
4950
}
5051
}
51-
async makeTunnel(forward: TunnelOptions): Promise<vscode.Tunnel | undefined> {
52+
async openTunnel(forward: TunnelOptions): Promise<vscode.Tunnel | undefined> {
5253
const tunnel = await this._proxy.$openTunnel(forward);
5354
if (tunnel) {
54-
const disposableTunnel: vscode.Tunnel = new ExtensionTunnel(tunnel.remote, tunnel.localAddress, () => {
55-
return this._proxy.$closeTunnel(tunnel.remote);
55+
const disposableTunnel: vscode.Tunnel = new ExtensionTunnel(tunnel.remoteAddress, tunnel.localAddress, () => {
56+
return this._proxy.$closeTunnel(tunnel.remoteAddress);
5657
});
5758
this._register(disposableTunnel);
5859
return disposableTunnel;
@@ -65,8 +66,8 @@ export class ExtHostTunnelService extends Disposable implements IExtHostTunnelSe
6566
}
6667

6768
async setForwardPortProvider(provider: vscode.RemoteAuthorityResolver | undefined): Promise<IDisposable> {
68-
if (provider && provider.forwardPort) {
69-
this._forwardPortProvider = provider.forwardPort;
69+
if (provider && provider.tunnelFactory) {
70+
this._forwardPortProvider = provider.tunnelFactory;
7071
await this._proxy.$setTunnelProvider();
7172
} else {
7273
this._forwardPortProvider = undefined;
@@ -91,11 +92,11 @@ export class ExtHostTunnelService extends Disposable implements IExtHostTunnelSe
9192
const providedPort = this._forwardPortProvider!(tunnelOptions);
9293
if (providedPort !== undefined) {
9394
return asPromise(() => providedPort).then(tunnel => {
94-
if (!this._extensionTunnels.has(tunnelOptions.remote.host)) {
95-
this._extensionTunnels.set(tunnelOptions.remote.host, new Map());
95+
if (!this._extensionTunnels.has(tunnelOptions.remoteAddress.host)) {
96+
this._extensionTunnels.set(tunnelOptions.remoteAddress.host, new Map());
9697
}
97-
this._extensionTunnels.get(tunnelOptions.remote.host)!.set(tunnelOptions.remote.port, tunnel);
98-
this._register(tunnel.onDispose(() => this._proxy.$closeTunnel(tunnel.remote)));
98+
this._extensionTunnels.get(tunnelOptions.remoteAddress.host)!.set(tunnelOptions.remoteAddress.port, tunnel);
99+
this._register(tunnel.onDidDispose(() => this._proxy.$closeTunnel(tunnel.remoteAddress)));
99100
return Promise.resolve(TunnelDto.fromApiTunnel(tunnel));
100101
});
101102
}

‎src/vs/workbench/services/extensions/electron-browser/extensionService.ts‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -473,7 +473,7 @@ export class ExtensionService extends AbstractExtensionService implements IExten
473473

474474
// set the resolved authority
475475
this._remoteAuthorityResolverService.setResolvedAuthority(resolvedAuthority.authority, resolvedAuthority.options);
476-
this._remoteExplorerService.addDetected(resolvedAuthority.tunnelInformation?.detectedTunnels);
476+
this._remoteExplorerService.addEnvironmentTunnels(resolvedAuthority.tunnelInformation?.environmentTunnels);
477477

478478
// monitor for breakage
479479
const connection = this._remoteAgentService.getConnection();

0 commit comments

Comments
 (0)