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

package/vscode/src/vs/workbench/contrib/remote/browser/remoteConnectionHealth.js

@@ -0,0 +1,166 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { remoteConnectionLatencyMeasurer, IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { isWeb } from 'vscode/vscode/vs/base/common/platform';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
+import { getRemoteName } from 'vscode/vscode/vs/platform/remote/common/remoteHosts';
+import { IBannerService } from 'vscode/vscode/vs/workbench/services/banner/browser/bannerService';
+import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
+import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
+import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
+import Severity$1 from 'vscode/vscode/vs/base/common/severity';
+import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+const REMOTE_UNSUPPORTED_CONNECTION_CHOICE_KEY = 'remote.unsupportedConnectionChoice';
+const BANNER_REMOTE_UNSUPPORTED_CONNECTION_DISMISSED_KEY = 'workbench.banner.remote.unsupportedConnection.dismissed';
+let InitialRemoteConnectionHealthContribution = class InitialRemoteConnectionHealthContribution {
+    constructor(_remoteAgentService, _environmentService, _telemetryService, bannerService, dialogService, openerService, hostService, storageService, productService) {
+        this._remoteAgentService = _remoteAgentService;
+        this._environmentService = _environmentService;
+        this._telemetryService = _telemetryService;
+        this.bannerService = bannerService;
+        this.dialogService = dialogService;
+        this.openerService = openerService;
+        this.hostService = hostService;
+        this.storageService = storageService;
+        this.productService = productService;
+        if (this._environmentService.remoteAuthority) {
+            this._checkInitialRemoteConnectionHealth();
+        }
+    }
+    async _confirmConnection() {
+        const { result, checkboxChecked } = await this.dialogService.prompt({
+            type: Severity$1.Warning,
+            message: ( localizeWithPath(
+                'vs/workbench/contrib/remote/browser/remoteConnectionHealth',
+                'unsupportedGlibcWarning',
+                "You are about to connect to an OS version that is unsupported by {0}.",
+                this.productService.nameLong
+            )),
+            buttons: [
+                {
+                    label: ( localizeWithPath(
+                        'vs/workbench/contrib/remote/browser/remoteConnectionHealth',
+                        { key: 'allow', comment: ['&& denotes a mnemonic'] },
+                        "&&Allow"
+                    )),
+                    run: () => 1
+                },
+                {
+                    label: ( localizeWithPath(
+                        'vs/workbench/contrib/remote/browser/remoteConnectionHealth',
+                        { key: 'learnMore', comment: ['&& denotes a mnemonic'] },
+                        "&&Learn More"
+                    )),
+                    run: async () => { await this.openerService.open('https://aka.ms/vscode-remote/faq/old-linux'); return 2 ; }
+                }
+            ],
+            cancelButton: {
+                run: () => 0
+            },
+            checkbox: {
+                label: ( localizeWithPath(
+                    'vs/workbench/contrib/remote/browser/remoteConnectionHealth',
+                    'remember',
+                    "Do not show again"
+                )),
+            }
+        });
+        if (result === 2 ) {
+            return await this._confirmConnection();
+        }
+        const allowed = result === 1 ;
+        if (allowed && checkboxChecked) {
+            this.storageService.store(`${REMOTE_UNSUPPORTED_CONNECTION_CHOICE_KEY}.${this._environmentService.remoteAuthority}`, allowed, 0 , 1 );
+        }
+        return allowed;
+    }
+    async _checkInitialRemoteConnectionHealth() {
+        try {
+            const environment = await this._remoteAgentService.getRawEnvironment();
+            if (environment && environment.isUnsupportedGlibc) {
+                let allowed = this.storageService.getBoolean(`${REMOTE_UNSUPPORTED_CONNECTION_CHOICE_KEY}.${this._environmentService.remoteAuthority}`, 0 );
+                if (allowed === undefined) {
+                    allowed = await this._confirmConnection();
+                }
+                if (allowed) {
+                    const bannerDismissedVersion = this.storageService.get(`${BANNER_REMOTE_UNSUPPORTED_CONNECTION_DISMISSED_KEY}`, 0 ) ?? '';
+                    const shouldShowBanner = bannerDismissedVersion.slice(0, bannerDismissedVersion.lastIndexOf('.')) !== this.productService.version.slice(0, this.productService.version.lastIndexOf('.'));
+                    if (shouldShowBanner) {
+                        const actions = [
+                            {
+                                label: ( localizeWithPath(
+                                    'vs/workbench/contrib/remote/browser/remoteConnectionHealth',
+                                    'unsupportedGlibcBannerLearnMore',
+                                    "Learn More"
+                                )),
+                                href: 'https://aka.ms/vscode-remote/faq/old-linux'
+                            }
+                        ];
+                        this.bannerService.show({
+                            id: 'unsupportedGlibcWarning.banner',
+                            message: ( localizeWithPath(
+                                'vs/workbench/contrib/remote/browser/remoteConnectionHealth',
+                                'unsupportedGlibcWarning.banner',
+                                "You are connected to an OS version that is unsupported by {0}.",
+                                this.productService.nameLong
+                            )),
+                            actions,
+                            icon: Codicon.warning,
+                            closeLabel: `Do not show again in v${this.productService.version}`,
+                            onClose: () => {
+                                this.storageService.store(`${BANNER_REMOTE_UNSUPPORTED_CONNECTION_DISMISSED_KEY}`, this.productService.version, 0 , 1 );
+                            }
+                        });
+                    }
+                }
+                else {
+                    this.hostService.openWindow({ forceReuseWindow: true, remoteAuthority: null });
+                    return;
+                }
+            }
+            this._telemetryService.publicLog2('remoteConnectionSuccess', {
+                web: isWeb,
+                connectionTimeMs: await this._remoteAgentService.getConnection()?.getInitialConnectionTimeMs(),
+                remoteName: getRemoteName(this._environmentService.remoteAuthority)
+            });
+            await this._measureExtHostLatency();
+        }
+        catch (err) {
+            this._telemetryService.publicLog2('remoteConnectionFailure', {
+                web: isWeb,
+                connectionTimeMs: await this._remoteAgentService.getConnection()?.getInitialConnectionTimeMs(),
+                remoteName: getRemoteName(this._environmentService.remoteAuthority),
+                message: err ? err.message : ''
+            });
+        }
+    }
+    async _measureExtHostLatency() {
+        const measurement = await remoteConnectionLatencyMeasurer.measure(this._remoteAgentService);
+        if (measurement === undefined) {
+            return;
+        }
+        this._telemetryService.publicLog2('remoteConnectionLatency', {
+            web: isWeb,
+            remoteName: getRemoteName(this._environmentService.remoteAuthority),
+            latencyMs: measurement.current
+        });
+    }
+};
+InitialRemoteConnectionHealthContribution = ( __decorate([
+    ( __param(0, IRemoteAgentService)),
+    ( __param(1, IWorkbenchEnvironmentService)),
+    ( __param(2, ITelemetryService)),
+    ( __param(3, IBannerService)),
+    ( __param(4, IDialogService)),
+    ( __param(5, IOpenerService)),
+    ( __param(6, IHostService)),
+    ( __param(7, IStorageService)),
+    ( __param(8, IProductService))
+], InitialRemoteConnectionHealthContribution));
+
+export { InitialRemoteConnectionHealthContribution };