@codingame/monaco-vscode-remote-agent-service-override 3.2.3 → 4.1.0

package/vscode/src/vs/workbench/services/remote/common/abstractRemoteAgentService.js

@@ -1,179 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { getDelayedChannel } from 'vscode/vscode/vs/base/parts/ipc/common/ipc';
-import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
-import { connectRemoteAgentManagement } from 'vscode/vscode/vs/platform/remote/common/remoteAgentConnection';
-import { IRemoteAuthorityResolverService } from 'vscode/vscode/vs/platform/remote/common/remoteAuthorityResolver';
-import { RemoteExtensionEnvironmentChannelClient } from './remoteAgentEnvironmentChannel.js';
-import { Emitter } from 'vscode/vscode/vs/base/common/event';
-import { ISignService } from 'vscode/vscode/vs/platform/sign/common/sign';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService';
-import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
-import { IRemoteSocketFactoryService } from 'vscode/vscode/vs/platform/remote/common/remoteSocketFactoryService';
-
-let AbstractRemoteAgentService = class AbstractRemoteAgentService extends Disposable {
-    constructor(remoteSocketFactoryService, userDataProfileService, _environmentService, productService, _remoteAuthorityResolverService, signService, logService) {
-        super();
-        this.remoteSocketFactoryService = remoteSocketFactoryService;
-        this.userDataProfileService = userDataProfileService;
-        this._environmentService = _environmentService;
-        this._remoteAuthorityResolverService = _remoteAuthorityResolverService;
-        if (this._environmentService.remoteAuthority) {
-            this._connection = this._register(( new RemoteAgentConnection(
-                this._environmentService.remoteAuthority,
-                productService.commit,
-                productService.quality,
-                this.remoteSocketFactoryService,
-                this._remoteAuthorityResolverService,
-                signService,
-                logService
-            )));
-        }
-        else {
-            this._connection = null;
-        }
-        this._environment = null;
-    }
-    getConnection() {
-        return this._connection;
-    }
-    getEnvironment() {
-        return this.getRawEnvironment().then(undefined, () => null);
-    }
-    getRawEnvironment() {
-        if (!this._environment) {
-            this._environment = this._withChannel(async (channel, connection) => {
-                const env = await RemoteExtensionEnvironmentChannelClient.getEnvironmentData(channel, connection.remoteAuthority, this.userDataProfileService.currentProfile.isDefault ? undefined : this.userDataProfileService.currentProfile.id);
-                this._remoteAuthorityResolverService._setAuthorityConnectionToken(connection.remoteAuthority, env.connectionToken);
-                return env;
-            }, null);
-        }
-        return this._environment;
-    }
-    getExtensionHostExitInfo(reconnectionToken) {
-        return this._withChannel((channel, connection) => RemoteExtensionEnvironmentChannelClient.getExtensionHostExitInfo(channel, connection.remoteAuthority, reconnectionToken), null);
-    }
-    getDiagnosticInfo(options) {
-        return this._withChannel(channel => RemoteExtensionEnvironmentChannelClient.getDiagnosticInfo(channel, options), undefined);
-    }
-    updateTelemetryLevel(telemetryLevel) {
-        return this._withTelemetryChannel(channel => RemoteExtensionEnvironmentChannelClient.updateTelemetryLevel(channel, telemetryLevel), undefined);
-    }
-    logTelemetry(eventName, data) {
-        return this._withTelemetryChannel(channel => RemoteExtensionEnvironmentChannelClient.logTelemetry(channel, eventName, data), undefined);
-    }
-    flushTelemetry() {
-        return this._withTelemetryChannel(channel => RemoteExtensionEnvironmentChannelClient.flushTelemetry(channel), undefined);
-    }
-    getRoundTripTime() {
-        return this._withTelemetryChannel(async (channel) => {
-            const start = Date.now();
-            await RemoteExtensionEnvironmentChannelClient.ping(channel);
-            return Date.now() - start;
-        }, undefined);
-    }
-    _withChannel(callback, fallback) {
-        const connection = this.getConnection();
-        if (!connection) {
-            return Promise.resolve(fallback);
-        }
-        return connection.withChannel('remoteextensionsenvironment', (channel) => callback(channel, connection));
-    }
-    _withTelemetryChannel(callback, fallback) {
-        const connection = this.getConnection();
-        if (!connection) {
-            return Promise.resolve(fallback);
-        }
-        return connection.withChannel('telemetry', (channel) => callback(channel, connection));
-    }
-};
-AbstractRemoteAgentService = ( __decorate([
-    ( __param(0, IRemoteSocketFactoryService)),
-    ( __param(1, IUserDataProfileService)),
-    ( __param(2, IWorkbenchEnvironmentService)),
-    ( __param(3, IProductService)),
-    ( __param(4, IRemoteAuthorityResolverService)),
-    ( __param(5, ISignService)),
-    ( __param(6, ILogService))
-], AbstractRemoteAgentService));
-class RemoteAgentConnection extends Disposable {
-    constructor(remoteAuthority, _commit, _quality, _remoteSocketFactoryService, _remoteAuthorityResolverService, _signService, _logService) {
-        super();
-        this._commit = _commit;
-        this._quality = _quality;
-        this._remoteSocketFactoryService = _remoteSocketFactoryService;
-        this._remoteAuthorityResolverService = _remoteAuthorityResolverService;
-        this._signService = _signService;
-        this._logService = _logService;
-        this._onReconnecting = this._register(( new Emitter()));
-        this.onReconnecting = this._onReconnecting.event;
-        this._onDidStateChange = this._register(( new Emitter()));
-        this.onDidStateChange = this._onDidStateChange.event;
-        this.remoteAuthority = remoteAuthority;
-        this._connection = null;
-    }
-    getChannel(channelName) {
-        return getDelayedChannel(this._getOrCreateConnection().then(c => c.getChannel(channelName)));
-    }
-    withChannel(channelName, callback) {
-        const channel = this.getChannel(channelName);
-        const result = callback(channel);
-        return result;
-    }
-    registerChannel(channelName, channel) {
-        this._getOrCreateConnection().then(client => client.registerChannel(channelName, channel));
-    }
-    async getInitialConnectionTimeMs() {
-        try {
-            await this._getOrCreateConnection();
-        }
-        catch {
-        }
-        return this._initialConnectionMs;
-    }
-    _getOrCreateConnection() {
-        if (!this._connection) {
-            this._connection = this._createConnection();
-        }
-        return this._connection;
-    }
-    async _createConnection() {
-        let firstCall = true;
-        const options = {
-            commit: this._commit,
-            quality: this._quality,
-            addressProvider: {
-                getAddress: async () => {
-                    if (firstCall) {
-                        firstCall = false;
-                    }
-                    else {
-                        this._onReconnecting.fire(undefined);
-                    }
-                    const { authority } = await this._remoteAuthorityResolverService.resolveAuthority(this.remoteAuthority);
-                    return { connectTo: authority.connectTo, connectionToken: authority.connectionToken };
-                }
-            },
-            remoteSocketFactoryService: this._remoteSocketFactoryService,
-            signService: this._signService,
-            logService: this._logService,
-            ipcLogger: null
-        };
-        let connection;
-        const start = Date.now();
-        try {
-            connection = this._register(await connectRemoteAgentManagement(options, this.remoteAuthority, `renderer`));
-        }
-        finally {
-            this._initialConnectionMs = Date.now() - start;
-        }
-        connection.protocol.onDidDispose(() => {
-            connection.dispose();
-        });
-        this._register(connection.onDidStateChange(e => this._onDidStateChange.fire(e)));
-        return connection.client;
-    }
-}
-
-export { AbstractRemoteAgentService };

package/vscode/src/vs/workbench/services/remote/common/remoteAgentEnvironmentChannel.js

@@ -1,54 +0,0 @@
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { revive } from 'vscode/vscode/vs/base/common/marshalling';
-
-class RemoteExtensionEnvironmentChannelClient {
-    static async getEnvironmentData(channel, remoteAuthority, profile) {
-        const args = {
-            remoteAuthority,
-            profile
-        };
-        const data = await channel.call('getEnvironmentData', args);
-        return {
-            pid: data.pid,
-            connectionToken: data.connectionToken,
-            appRoot: URI.revive(data.appRoot),
-            settingsPath: URI.revive(data.settingsPath),
-            logsPath: URI.revive(data.logsPath),
-            extensionHostLogsPath: URI.revive(data.extensionHostLogsPath),
-            globalStorageHome: URI.revive(data.globalStorageHome),
-            workspaceStorageHome: URI.revive(data.workspaceStorageHome),
-            localHistoryHome: URI.revive(data.localHistoryHome),
-            userHome: URI.revive(data.userHome),
-            os: data.os,
-            arch: data.arch,
-            marks: data.marks,
-            useHostProxy: data.useHostProxy,
-            profiles: revive(data.profiles),
-            isUnsupportedGlibc: data.isUnsupportedGlibc
-        };
-    }
-    static async getExtensionHostExitInfo(channel, remoteAuthority, reconnectionToken) {
-        const args = {
-            remoteAuthority,
-            reconnectionToken
-        };
-        return channel.call('getExtensionHostExitInfo', args);
-    }
-    static getDiagnosticInfo(channel, options) {
-        return channel.call('getDiagnosticInfo', options);
-    }
-    static updateTelemetryLevel(channel, telemetryLevel) {
-        return channel.call('updateTelemetryLevel', { telemetryLevel });
-    }
-    static logTelemetry(channel, eventName, data) {
-        return channel.call('logTelemetry', { eventName, data });
-    }
-    static flushTelemetry(channel) {
-        return channel.call('flushTelemetry');
-    }
-    static async ping(channel) {
-        await channel.call('ping');
-    }
-}
-
-export { RemoteExtensionEnvironmentChannelClient };

package/vscode/src/vs/workbench/services/remote/common/remoteExtensionsScanner.js

@@ -1,73 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService';
-import { RemoteExtensionsScannerChannelName } from 'vscode/vscode/vs/platform/remote/common/remoteExtensionsScanner';
-import { language } from 'vscode/vscode/vs/base/common/platform';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
-import { IRemoteUserDataProfilesService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/remoteUserDataProfiles';
-import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { IActiveLanguagePackService } from 'vscode/vscode/vs/workbench/services/localization/common/locale';
-
-let RemoteExtensionsScannerService = class RemoteExtensionsScannerService {
-    constructor(remoteAgentService, environmentService, userDataProfileService, remoteUserDataProfilesService, logService, activeLanguagePackService) {
-        this.remoteAgentService = remoteAgentService;
-        this.environmentService = environmentService;
-        this.userDataProfileService = userDataProfileService;
-        this.remoteUserDataProfilesService = remoteUserDataProfilesService;
-        this.logService = logService;
-        this.activeLanguagePackService = activeLanguagePackService;
-    }
-    whenExtensionsReady() {
-        return this.withChannel(channel => channel.call('whenExtensionsReady'), undefined);
-    }
-    async scanExtensions() {
-        try {
-            const languagePack = await this.activeLanguagePackService.getExtensionIdProvidingCurrentLocale();
-            return await this.withChannel(async (channel) => {
-                const profileLocation = this.userDataProfileService.currentProfile.isDefault ? undefined : (await this.remoteUserDataProfilesService.getRemoteProfile(this.userDataProfileService.currentProfile)).extensionsResource;
-                const scannedExtensions = await channel.call('scanExtensions', [language, profileLocation, this.environmentService.extensionDevelopmentLocationURI, languagePack]);
-                scannedExtensions.forEach((extension) => {
-                    extension.extensionLocation = URI.revive(extension.extensionLocation);
-                });
-                return scannedExtensions;
-            }, []);
-        }
-        catch (error) {
-            this.logService.error(error);
-            return [];
-        }
-    }
-    async scanSingleExtension(extensionLocation, isBuiltin) {
-        try {
-            return await this.withChannel(async (channel) => {
-                const extension = await channel.call('scanSingleExtension', [extensionLocation, isBuiltin, language]);
-                if (extension !== null) {
-                    extension.extensionLocation = URI.revive(extension.extensionLocation);
-                }
-                return extension;
-            }, null);
-        }
-        catch (error) {
-            this.logService.error(error);
-            return null;
-        }
-    }
-    withChannel(callback, fallback) {
-        const connection = this.remoteAgentService.getConnection();
-        if (!connection) {
-            return Promise.resolve(fallback);
-        }
-        return connection.withChannel(RemoteExtensionsScannerChannelName, (channel) => callback(channel));
-    }
-};
-RemoteExtensionsScannerService = ( __decorate([
-    ( __param(0, IRemoteAgentService)),
-    ( __param(1, IWorkbenchEnvironmentService)),
-    ( __param(2, IUserDataProfileService)),
-    ( __param(3, IRemoteUserDataProfilesService)),
-    ( __param(4, ILogService)),
-    ( __param(5, IActiveLanguagePackService))
-], RemoteExtensionsScannerService));
-
-export { RemoteExtensionsScannerService };

package/vscode/src/vs/workbench/services/tunnel/browser/tunnelService.js

@@ -1,36 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { AbstractTunnelService, isTunnelProvider } from 'vscode/vscode/vs/platform/tunnel/common/tunnel';
-import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
-
-let TunnelService = class TunnelService extends AbstractTunnelService {
-    constructor(logService, environmentService, configurationService) {
-        super(logService, configurationService);
-        this.environmentService = environmentService;
-    }
-    isPortPrivileged(_port) {
-        return false;
-    }
-    retainOrCreateTunnel(tunnelProvider, remoteHost, remotePort, _localHost, localPort, elevateIfNeeded, privacy, protocol) {
-        const existing = this.getTunnelFromMap(remoteHost, remotePort);
-        if (existing) {
-            ++existing.refcount;
-            return existing.value;
-        }
-        if (isTunnelProvider(tunnelProvider)) {
-            return this.createWithProvider(tunnelProvider, remoteHost, remotePort, localPort, elevateIfNeeded, privacy, protocol);
-        }
-        return undefined;
-    }
-    canTunnel(uri) {
-        return super.canTunnel(uri) && !!this.environmentService.remoteAuthority;
-    }
-};
-TunnelService = ( __decorate([
-    ( __param(0, ILogService)),
-    ( __param(1, IWorkbenchEnvironmentService)),
-    ( __param(2, IConfigurationService))
-], TunnelService));
-
-export { TunnelService };