src/vs/workbench/api/common/extHostTunnelService.ts
294 LOC · 94 covered · 200 uncovered · 17 ranges · 46 concepts · 1 introducers · 39 tests
File neighbourhood
The centred file is linked to every concept that introduces one of its ranges, every test that runs code from the file, and the gray connector concepts standing between those tests and the file's own introducer concepts. Undirected links join concepts to every file where they introduce source and concepts to the tests they introduce; arrows show specialization between the displayed concepts and bridge only concepts omitted from this view. Concept colors match the source ranges below; connector concepts have no source color and are shown in gray.
Focused file, its introducer and connector concepts, their introduced files, and tests that run code from the file
In the embedded map, ordinary wheel input scrolls the page; use the visible controls to zoom and drag to pan. Open the full-screen map for canvas navigation: wheel pans, Ctrl/Command plus wheel zooms, and arrow keys pan when this region is focused. On touch screens, open the full-screen map to pan or pinch. If JavaScript or WebGL is unavailable, use the related-file, concept, and source links on this page.
Graph controls are ready.
Interactive rendering requires JavaScript and WebGL. Use the related-file, concept, and source links on this page while the interactive map is unavailable.
1
>
/*---------------------------------------------------------------------------------------------
extHostTunnelService.ts ×17
2
>
* Copyright (c) Microsoft Corporation. All rights reserved.
3
>
* Licensed under the MIT License. See License.txt in the project root for license information.
4
>
*--------------------------------------------------------------------------------------------*/
5
>
6
>
import { CancellationToken } from '../../../base/common/cancellation.js';
7
>
import { Emitter } from '../../../base/common/event.js';
8
>
import { Disposable, IDisposable, toDisposable } from '../../../base/common/lifecycle.js';
9
>
import * as nls from '../../../nls.js';
10
>
import { IExtensionDescription } from '../../../platform/extensions/common/extensions.js';
11
>
import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
12
>
import { ILogService } from '../../../platform/log/common/log.js';
13
>
import { DisposableTunnel, ProvidedOnAutoForward, ProvidedPortAttributes, RemoteTunnel, TunnelCreationOptions, TunnelOptions, TunnelPrivacyId } from '../../../platform/tunnel/common/tunnel.js';
14
>
import { ExtHostTunnelServiceShape, MainContext, MainThreadTunnelServiceShape, PortAttributesSelector, TunnelDto } from './extHost.protocol.js';
15
>
import { IExtHostInitDataService } from './extHostInitDataService.js';
16
>
import { IExtHostRpcService } from './extHostRpcService.js';
17
>
import * as types from './extHostTypes.js';
18
>
import { CandidatePort } from '../../services/remote/common/tunnelModel.js';
19
>
import * as vscode from 'vscode';
20
>
21
>
class ExtensionTunnel extends DisposableTunnel implements vscode.Tunnel { }
22
>
23
>
export namespace TunnelDtoConverter {
24
>
export function fromApiTunnel(tunnel: vscode.Tunnel): TunnelDto {
25
return {
26
remoteAddress: tunnel.remoteAddress,
27
localAddress: tunnel.localAddress,
28
public: !!tunnel.public,
29
privacy: tunnel.privacy ?? (tunnel.public ? TunnelPrivacyId.Public : TunnelPrivacyId.Private),
30
protocol: tunnel.protocol
31
};
32
}
33
>
export function fromServiceTunnel(tunnel: RemoteTunnel): TunnelDto {
extHostTunnelService.ts ×17
34
return {
35
remoteAddress: {
36
host: tunnel.tunnelRemoteHost,
37
port: tunnel.tunnelRemotePort
38
},
39
localAddress: tunnel.localAddress,
40
public: tunnel.privacy !== TunnelPrivacyId.ConstantPrivate && tunnel.privacy !== TunnelPrivacyId.ConstantPrivate,
41
privacy: tunnel.privacy,
42
protocol: tunnel.protocol
43
};
44
}
46
>
47
>
export interface Tunnel extends vscode.Disposable {
48
>
remote: { port: number; host: string };
49
>
localAddress: string;
50
>
}
51
>
52
>
export interface IExtHostTunnelService extends ExtHostTunnelServiceShape {
53
>
readonly _serviceBrand: undefined;
54
>
openTunnel(extension: IExtensionDescription, forward: TunnelOptions): Promise<vscode.Tunnel | undefined>;
55
>
getTunnels(): Promise<vscode.TunnelDescription[]>;
56
>
onDidChangeTunnels: vscode.Event<void>;
57
>
setTunnelFactory(provider: vscode.RemoteAuthorityResolver | undefined, managedRemoteAuthority: vscode.ManagedResolvedAuthority | undefined): Promise<IDisposable>;
58
>
registerPortsAttributesProvider(portSelector: PortAttributesSelector, provider: vscode.PortAttributesProvider): IDisposable;
59
>
registerTunnelProvider(provider: vscode.TunnelProvider, information: vscode.TunnelInformation): Promise<IDisposable>;
60
>
hasTunnelProvider(): Promise<boolean>;
61
>
}
62
>
63
>
export const IExtHostTunnelService = createDecorator<IExtHostTunnelService>('IExtHostTunnelService');
64
>
65
>
export class ExtHostTunnelService extends Disposable implements IExtHostTunnelService {
66
>
readonly _serviceBrand: undefined;
67
>
protected readonly _proxy: MainThreadTunnelServiceShape;
68
>
private _forwardPortProvider: ((tunnelOptions: TunnelOptions, tunnelCreationOptions: TunnelCreationOptions, token?: vscode.CancellationToken) => Thenable<vscode.Tunnel | undefined> | undefined) | undefined;
69
>
private _showCandidatePort: (host: string, port: number, detail: string) => Thenable<boolean> = () => { return Promise.resolve(true); };
70
>
private _extensionTunnels: Map<string, Map<number, { tunnel: vscode.Tunnel; disposeListener: IDisposable }>> = new Map();
71
>
private _onDidChangeTunnels: Emitter<void> = this._register(new Emitter<void>());
72
>
onDidChangeTunnels: vscode.Event<void> = this._onDidChangeTunnels.event;
73
>
74
>
private _providerHandleCounter: number = 0;
75
>
private _portAttributesProviders: Map<number, { provider: vscode.PortAttributesProvider; selector: PortAttributesSelector }> = new Map();
76
>
77
>
constructor(
78
@IExtHostRpcService extHostRpc: IExtHostRpcService,
79
@IExtHostInitDataService initData: IExtHostInitDataService,
80
@ILogService protected readonly logService: ILogService
81
) {
82
super();
83
this._proxy = extHostRpc.getProxy(MainContext.MainThreadTunnelService);
84
}
86
>
async openTunnel(extension: IExtensionDescription, forward: TunnelOptions): Promise<vscode.Tunnel | undefined> {
87
this.logService.trace(`ForwardedPorts: (ExtHostTunnelService) ${extension.identifier.value} called openTunnel API for ${forward.remoteAddress.host}:${forward.remoteAddress.port}.`);
88
const tunnel = await this._proxy.$openTunnel(forward, extension.displayName);
89
if (tunnel) {
90
const disposableTunnel: vscode.Tunnel = new ExtensionTunnel(tunnel.remoteAddress, tunnel.localAddress, () => {
91
return this._proxy.$closeTunnel(tunnel.remoteAddress);
92
});
93
this._register(disposableTunnel);
94
return disposableTunnel;
95
}
96
return undefined;
97
}
99
>
async getTunnels(): Promise<vscode.TunnelDescription[]> {
100
return this._proxy.$getTunnels();
101
}
103
return this._providerHandleCounter++;
104
}
106
>
registerPortsAttributesProvider(portSelector: PortAttributesSelector, provider: vscode.PortAttributesProvider): vscode.Disposable {
107
if (portSelector.portRange === undefined && portSelector.commandPattern === undefined) {
108
this.logService.error('PortAttributesProvider must specify either a portRange or a commandPattern');
109
}
110
const providerHandle = this.nextPortAttributesProviderHandle();
111
this._portAttributesProviders.set(providerHandle, { selector: portSelector, provider });
112
113
this._proxy.$registerPortsAttributesProvider(portSelector, providerHandle);
114
return new types.Disposable(() => {
115
this._portAttributesProviders.delete(providerHandle);
116
this._proxy.$unregisterPortsAttributesProvider(providerHandle);
117
});
118
}
120
>
async $providePortAttributes(handles: number[], ports: number[], pid: number | undefined, commandLine: string | undefined, cancellationToken: vscode.CancellationToken): Promise<ProvidedPortAttributes[]> {
121
const providedAttributes: { providedAttributes: vscode.PortAttributes | null | undefined; port: number }[] = [];
122
for (const handle of handles) {
123
const provider = this._portAttributesProviders.get(handle);
124
if (!provider) {
125
return [];
126
}
127
providedAttributes.push(...(await Promise.all(ports.map(async (port) => {
128
let providedAttributes: vscode.PortAttributes | null | undefined;
129
try {
130
providedAttributes = await provider.provider.providePortAttributes({ port, pid, commandLine }, cancellationToken);
131
} catch (e) {
132
// Call with old signature for breaking API change
133
providedAttributes = await (provider.provider.providePortAttributes as unknown as (port: number, pid: number | undefined, commandLine: string | undefined, token: vscode.CancellationToken) => vscode.ProviderResult<vscode.PortAttributes>)(port, pid, commandLine, cancellationToken);
134
}
135
return { providedAttributes, port };
136
}))));
137
}
138
139
const allAttributes = <{ providedAttributes: vscode.PortAttributes; port: number }[]>providedAttributes.filter(attribute => !!attribute.providedAttributes);
140
141
return (allAttributes.length > 0) ? allAttributes.map(attributes => {
142
return {
143
autoForwardAction: <ProvidedOnAutoForward><unknown>attributes.providedAttributes.autoForwardAction,
144
port: attributes.port
145
};
146
}) : [];
147
}
149
>
async $registerCandidateFinder(_enable: boolean): Promise<void> { }
150
>
151
>
registerTunnelProvider(provider: vscode.TunnelProvider, information: vscode.TunnelInformation): Promise<IDisposable> {
152
if (this._forwardPortProvider) {
153
throw new Error('A tunnel provider has already been registered. Only the first tunnel provider to be registered will be used.');
154
}
155
this._forwardPortProvider = async (tunnelOptions: TunnelOptions, tunnelCreationOptions: TunnelCreationOptions) => {
156
const result = await provider.provideTunnel(tunnelOptions, tunnelCreationOptions, CancellationToken.None);
157
return result ?? undefined;
158
};
159
160
const tunnelFeatures = information.tunnelFeatures ? {
161
elevation: !!information.tunnelFeatures?.elevation,
162
privacyOptions: information.tunnelFeatures?.privacyOptions,
163
protocol: information.tunnelFeatures.protocol === undefined ? true : information.tunnelFeatures.protocol,
164
} : undefined;
165
166
this._proxy.$setTunnelProvider(tunnelFeatures, true);
167
return Promise.resolve(toDisposable(() => {
168
this._forwardPortProvider = undefined;
169
this._proxy.$setTunnelProvider(undefined, false);
170
}));
171
}
173
>
hasTunnelProvider(): Promise<boolean> {
174
return this._proxy.$hasTunnelProvider();
175
}
177
>
/**
178
>
* Applies the tunnel metadata and factory found in the remote authority
179
>
* resolver to the tunnel system.
180
>
*
181
>
* `managedRemoteAuthority` should be be passed if the resolver returned on.
182
>
* If this is the case, the tunnel cannot be connected to via a websocket from
183
>
* the share process, so a synethic tunnel factory is used as a default.
184
>
*/
185
>
async setTunnelFactory(provider: vscode.RemoteAuthorityResolver | undefined, managedRemoteAuthority: vscode.ManagedResolvedAuthority | undefined): Promise<IDisposable> {
186
// Do not wait for any of the proxy promises here.
187
// It will delay startup and there is nothing that needs to be waited for.
188
if (provider) {
189
if (provider.candidatePortSource !== undefined) {
190
this._proxy.$setCandidatePortSource(provider.candidatePortSource);
191
}
192
if (provider.showCandidatePort) {
193
this._showCandidatePort = provider.showCandidatePort;
194
this._proxy.$setCandidateFilter();
195
}
196
const tunnelFactory = provider.tunnelFactory ?? (managedRemoteAuthority ? this.makeManagedTunnelFactory(managedRemoteAuthority) : undefined);
197
if (tunnelFactory) {
198
this._forwardPortProvider = tunnelFactory;
199
let privacyOptions = provider.tunnelFeatures?.privacyOptions ?? [];
200
if (provider.tunnelFeatures?.public && (privacyOptions.length === 0)) {
201
privacyOptions = [
202
{
203
id: 'private',
204
label: nls.localize('tunnelPrivacy.private', "Private"),
205
themeIcon: 'lock'
206
},
207
{
208
id: 'public',
209
label: nls.localize('tunnelPrivacy.public', "Public"),
210
themeIcon: 'eye'
211
}
212
];
213
}
214
215
const tunnelFeatures = provider.tunnelFeatures ? {
216
elevation: !!provider.tunnelFeatures?.elevation,
217
public: !!provider.tunnelFeatures?.public,
218
privacyOptions,
219
protocol: true
220
} : undefined;
221
222
this._proxy.$setTunnelProvider(tunnelFeatures, !!provider.tunnelFactory);
223
}
224
} else {
225
this._forwardPortProvider = undefined;
226
}
227
return toDisposable(() => {
228
this._forwardPortProvider = undefined;
229
});
230
}
232
>
protected makeManagedTunnelFactory(_authority: vscode.ManagedResolvedAuthority): vscode.RemoteAuthorityResolver['tunnelFactory'] {
233
return undefined; // may be overridden
234
}
236
>
async $closeTunnel(remote: { host: string; port: number }, silent?: boolean): Promise<void> {
237
if (this._extensionTunnels.has(remote.host)) {
238
const hostMap = this._extensionTunnels.get(remote.host)!;
239
if (hostMap.has(remote.port)) {
240
if (silent) {
241
hostMap.get(remote.port)!.disposeListener.dispose();
242
}
243
await hostMap.get(remote.port)!.tunnel.dispose();
244
hostMap.delete(remote.port);
245
}
246
}
247
}
249
>
async $onDidTunnelsChange(): Promise<void> {
250
this._onDidChangeTunnels.fire();
251
}
253
>
async $forwardPort(tunnelOptions: TunnelOptions, tunnelCreationOptions: TunnelCreationOptions): Promise<TunnelDto | string | undefined> {
254
if (this._forwardPortProvider) {
255
try {
256
this.logService.trace('ForwardedPorts: (ExtHostTunnelService) Getting tunnel from provider.');
257
const providedPort = this._forwardPortProvider(tunnelOptions, tunnelCreationOptions,);
258
this.logService.trace('ForwardedPorts: (ExtHostTunnelService) Got tunnel promise from provider.');
259
if (providedPort !== undefined) {
260
const tunnel = await providedPort;
261
this.logService.trace('ForwardedPorts: (ExtHostTunnelService) Successfully awaited tunnel from provider.');
262
if (tunnel === undefined) {
263
this.logService.error('ForwardedPorts: (ExtHostTunnelService) Resolved tunnel is undefined');
264
return undefined;
265
}
266
if (!this._extensionTunnels.has(tunnelOptions.remoteAddress.host)) {
267
this._extensionTunnels.set(tunnelOptions.remoteAddress.host, new Map());
268
}
269
const disposeListener = this._register(tunnel.onDidDispose(() => {
270
this.logService.trace('ForwardedPorts: (ExtHostTunnelService) Extension fired tunnel\'s onDidDispose.');
271
return this._proxy.$closeTunnel(tunnel.remoteAddress);
272
}));
273
this._extensionTunnels.get(tunnelOptions.remoteAddress.host)!.set(tunnelOptions.remoteAddress.port, { tunnel, disposeListener });
274
return TunnelDtoConverter.fromApiTunnel(tunnel);
275
} else {
276
this.logService.trace('ForwardedPorts: (ExtHostTunnelService) Tunnel is undefined');
277
}
278
} catch (e) {
279
this.logService.trace('ForwardedPorts: (ExtHostTunnelService) tunnel provider error');
280
if (e instanceof Error) {
281
return e.message;
282
}
283
}
284
}
285
return undefined;
286
}
288
>
async $applyCandidateFilter(candidates: CandidatePort[]): Promise<CandidatePort[]> {
289
const filter = await Promise.all(candidates.map(candidate => this._showCandidatePort(candidate.host, candidate.port, candidate.detail ?? '')));
290
const result = candidates.filter((candidate, index) => filter[index]);
291
this.logService.trace(`ForwardedPorts: (ExtHostTunnelService) filtered from ${candidates.map(port => port.port).join(', ')} to ${result.map(port => port.port).join(', ')}`);
292
return result;
293
}