11239959086

Committed 08 Oct 2024 04:44PM UTC coverage: 41.728% (+0.02%) from 41.712%

Build # 11239959086

Build Type

push

github

Committed by

web-flow

Commit Message

Revert "Update to Electron v30 (#25948)" (#25955)

This reverts commit a4e6db8d5.

Run Details

8804 of 25826 branches covered (34.09%)

Branch coverage included in aggregate %.

0 of 1 new or added line in 1 file covered. (0.0%)

1 existing line in 1 file now uncovered.

30730 of 68916 relevant lines covered (44.59%)

14.55 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/extensions/azurecore/src/azureResource/services/terminalService.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 azdata from 'azdata';
import * as vscode from 'vscode';
import * as nls from 'vscode-nls';
import axios, { AxiosRequestConfig, AxiosResponse } from 'axios';
import * as WS from 'ws';

import { IAzureTerminalService } from '../interfaces';
import { AzureAccount, Tenant } from 'azurecore';
import { Logger } from '../../utils/Logger';

const localize = nls.loadMessageBundle();


const handleNeverUsed = async (): Promise<void> => {
        const neverUsedString = localize('azure.coudTerminal.neverUsed', "If you have not launched Azure Cloud Shell from this account before, please visit https://shell.azure.com/ to get started. Once you are set up, you can use AzureCloud Shell directly in Azure Data Studio.");
        enum TerminalOption {
                OPEN_SITE,
                OK
        }
        interface TerminalMessageItem extends vscode.MessageItem {
                action: TerminalOption;
        }

        const openAzureShellButton: TerminalMessageItem = {
                action: TerminalOption.OPEN_SITE,
                title: localize('azure.cloudTerminal.openAzureShell', "Open Azure Shell")
        };

        const okButton: TerminalMessageItem = {
                action: TerminalOption.OK,
                title: localize('azure.cloudTerminal.ok', "OK")
        };

        const option = await vscode.window.showInformationMessage<TerminalMessageItem>(neverUsedString, openAzureShellButton, okButton);

        if (option?.action === TerminalOption.OPEN_SITE) {
                void vscode.env.openExternal(vscode.Uri.parse('https://aka.ms/AA83f8f'));
        }
};

type CloudConsoleSettingsResponse = {
        properties?: {
                preferredShellType?: string,
                preferredLocation?: string
        }
}

type CloudConsoleRequestResponse = {
        properties?: {
                provisioningState: string,
                uri: string
        }
}

export class AzureTerminalService implements IAzureTerminalService {
        private readonly apiVersion = '?api-version=2018-10-01';

        public constructor(context: vscode.ExtensionContext) {

        }

        public async getOrCreateCloudConsole(account: AzureAccount, tenant: Tenant): Promise<void> {
                const token = await azdata.accounts.getAccountSecurityToken(account, tenant.id, azdata.AzureResource.MicrosoftResourceManagement);
                if (!token) {
                        throw new Error('Did not receive security token when creating cloud console');
                }
                const settings: AxiosRequestConfig = {
                        headers: {
                                'Accept': 'application/json',
                                'Content-Type': 'application/json',
                                'Authorization': `Bearer ${token.token}`
                        },
                        validateStatus: () => true
                };

                const metadata = account.properties.providerSettings;
                const userSettingsUri = this.getConsoleUserSettingsUri(metadata.settings.armResource.endpoint);

                let userSettingsResult: AxiosResponse<CloudConsoleSettingsResponse>;
                try {
                        userSettingsResult = await axios.get(userSettingsUri, settings);
                } catch (ex) {// Log as info as exception is handled
                        Logger.info(ex, ex.response);
                        await handleNeverUsed();
                        return;
                }

                const preferredShell = userSettingsResult.data?.properties?.preferredShellType ?? 'bash';
                const preferredLocation = userSettingsResult.data?.properties?.preferredLocation;

                const consoleRequestUri = this.getConsoleRequestUri(metadata.settings.armResource.endpoint);
                if (preferredLocation) {
                        settings.headers!['x-ms-console-preferred-location'] = preferredLocation;
                }

                let provisionResult: AxiosResponse<CloudConsoleRequestResponse>;
                try {
                        provisionResult = await axios.put(consoleRequestUri, {}, settings);
                } catch (ex) {// Log as info as exception is handled
                        Logger.info(ex, ex.response);
                        await handleNeverUsed();
                        return;
                }

                if (provisionResult.data?.properties?.provisioningState !== 'Succeeded') {
                        throw new Error(JSON.stringify(provisionResult.data));
                }
                const consoleUri = provisionResult.data.properties.uri;

                return this.createTerminal(consoleUri, token.token, account.displayInfo.displayName, preferredShell);
        }


        private async createTerminal(provisionedUri: string, token: string, accountDisplayName: string, preferredShell: string): Promise<void> {
                class ShellType implements vscode.QuickPickItem {
                        constructor(public readonly label: string, public readonly value: string) {
                        }
                }

                const shells = [new ShellType('PowerShell', 'pwsh'), new ShellType('Bash', 'bash')];
                const idx = shells.findIndex(s => s.value === preferredShell);

                const prefShell = shells.splice(idx, 1);
                shells.unshift(prefShell[0]);

                let shell = await vscode.window.showQuickPick(shells, {
                        canPickMany: false,
                        placeHolder: localize('azure.selectShellType', "Select Bash or PowerShell for Azure Cloud Shell")
                });

                if (!shell) {
                        void vscode.window.showErrorMessage(localize('azure.shellTypeRequired', "You must pick a shell type"));
                        return;
                }

                const terminalName = localize('azure.cloudShell', "Azure Cloud Shell (Preview) {0} ({1})", shell.label, accountDisplayName);

                const azureTerminal = new AzureTerminal(provisionedUri, token, shell.value);
                const terminal = vscode.window.createTerminal({
                        name: terminalName,
                        pty: azureTerminal
                });

                terminal.show();
        }

        public getConsoleRequestUri(armEndpoint: string): string {
                return `${armEndpoint}/providers/Microsoft.Portal/consoles/default${this.apiVersion}`;
        }

        public getConsoleUserSettingsUri(armEndpoint: string): string {
                return `${armEndpoint}/providers/Microsoft.Portal/userSettings/cloudconsole${this.apiVersion}`;
        }
}

type TerminalResponse = {
        socketUri?: string | undefined;
        error?: {
                message: string
        }
}

class AzureTerminal implements vscode.Pseudoterminal {
        private readonly writeEmitter: vscode.EventEmitter<string>;
        public readonly onDidWrite: vscode.Event<string>;

        private socket: WS | undefined = undefined;
        private intervalTimer: NodeJS.Timer | undefined = undefined;
        private terminalDimensions: vscode.TerminalDimensions | undefined;

        constructor(private readonly consoleUri: string, private readonly token: string, private shell: string) {
                this.writeEmitter = new vscode.EventEmitter<string>();
                this.onDidWrite = this.writeEmitter.event;
        }

        handleInput(data: string): void {
                this.socket?.send(data);
        }

        async open(initialDimensions: vscode.TerminalDimensions): Promise<void> {
                await this.setDimensions(initialDimensions);
        }

        close(): void {
                if (!this.socket) { return; }

                this.socket.removeAllListeners('open');
                this.socket.removeAllListeners('message');
                this.socket.removeAllListeners('close');

                this.socket.close();

                if (this.intervalTimer) {
                        clearInterval(this.intervalTimer);
                }
        }

        private areSameDimensions(oldDimensions: vscode.TerminalDimensions | undefined, newDimensions: vscode.TerminalDimensions): boolean {
                return oldDimensions?.columns === newDimensions.columns && oldDimensions?.rows === newDimensions.rows;
        }

        async setDimensions(dimensions: vscode.TerminalDimensions): Promise<void> {
                if (!dimensions || this.areSameDimensions(this.terminalDimensions, dimensions)) {
                        return;
                }
                this.terminalDimensions = dimensions;
                return this.resetTerminalSize();
        }

        private async resetTerminalSize(): Promise<void> {
                try {
                        // Close the shell before this and restablish a new connection
                        this.close();

                        const terminalUri = await this.establishTerminal(this.terminalDimensions);
                        if (!terminalUri) {
                                return;
                        }
                        this.socket = new WS(terminalUri);

                        this.socket.on('message', (data: WS.Data) => {
                                // Write to the console
                                this.writeEmitter.fire(data.toString());
                        });

                        this.socket.on('close', () => {
                                this.writeEmitter.fire(localize('azure.shellClosed', "Shell closed.\n"));
                                this.close();
                        });

                        // Keep alives
                        this.intervalTimer = setInterval(() => {
                                this.socket?.ping();
                        }, 5000);
                } catch (ex) {
                        Logger.error(ex);
                }
        }


        private async establishTerminal(dimensions: vscode.TerminalDimensions | undefined): Promise<string | undefined> {
                let terminalResult: AxiosResponse<TerminalResponse>;
                try {
                        const url = dimensions ?
                                `${this.consoleUri}/terminals?rows=${dimensions.rows}&cols=${dimensions.columns}&shell=${this.shell}`
                                : `${this.consoleUri}/terminals?shell=${this.shell}`;
                        terminalResult = await axios.post(url, undefined, {
                                headers: {
                                        'Accept': 'application/json',
                                        'Content-Type': 'application/json',
                                        'Authorization': `Bearer ${this.token}`
                                }
                        });
                } catch (ex) {
                        Logger.info(`Error establishing terminal. ${ex}, ${ex.response}`);
                        await handleNeverUsed();
                        return undefined;
                }

                const terminalUri = terminalResult.data?.socketUri;

                if (terminalResult.data.error) {
                        void vscode.window.showErrorMessage(terminalResult.data.error.message);
                }

                if (!terminalUri) {
                        throw Error(JSON.stringify(terminalResult.data));
                }

                return terminalUri;
        }
}

1	/*---------------------------------------------------------------------------------------------
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	import * as azdata from 'azdata';	×
6	import * as vscode from 'vscode';	×
7	import * as nls from 'vscode-nls';	×
8	import axios, { AxiosRequestConfig, AxiosResponse } from 'axios';	×
9	import * as WS from 'ws';	×
10
11	import { IAzureTerminalService } from '../interfaces';
12	import { AzureAccount, Tenant } from 'azurecore';
13	import { Logger } from '../../utils/Logger';	×
14
15	const localize = nls.loadMessageBundle();	×
16
17
18	const handleNeverUsed = async (): Promise<void> => {	×
19	const neverUsedString = localize('azure.coudTerminal.neverUsed', "If you have not launched Azure Cloud Shell from this account before, please visit https://shell.azure.com/ to get started. Once you are set up, you can use AzureCloud Shell directly in Azure Data Studio.");	×
20	enum TerminalOption {	×
21	OPEN_SITE,	×
22	OK	×
23	}
24	interface TerminalMessageItem extends vscode.MessageItem {
25	action: TerminalOption;
26	}
27
28	const openAzureShellButton: TerminalMessageItem = {	×
29	action: TerminalOption.OPEN_SITE,
30	title: localize('azure.cloudTerminal.openAzureShell', "Open Azure Shell")
31	};
32
33	const okButton: TerminalMessageItem = {	×
34	action: TerminalOption.OK,
35	title: localize('azure.cloudTerminal.ok', "OK")
36	};
37
38	const option = await vscode.window.showInformationMessage<TerminalMessageItem>(neverUsedString, openAzureShellButton, okButton);	×
39
40	if (option?.action === TerminalOption.OPEN_SITE) {	×
41	void vscode.env.openExternal(vscode.Uri.parse('https://aka.ms/AA83f8f'));	×
42	}
43	};
44
45	type CloudConsoleSettingsResponse = {
46	properties?: {
47	preferredShellType?: string,
48	preferredLocation?: string
49	}
50	}
51
52	type CloudConsoleRequestResponse = {
53	properties?: {
54	provisioningState: string,
55	uri: string
56	}
57	}
58
59	export class AzureTerminalService implements IAzureTerminalService {	×
60	private readonly apiVersion = '?api-version=2018-10-01';	×
61
62	public constructor(context: vscode.ExtensionContext) {
63
64	}
65
66	public async getOrCreateCloudConsole(account: AzureAccount, tenant: Tenant): Promise<void> {
67	const token = await azdata.accounts.getAccountSecurityToken(account, tenant.id, azdata.AzureResource.MicrosoftResourceManagement);	×
68	if (!token) {	×
69	throw new Error('Did not receive security token when creating cloud console');	×
70	}
71	const settings: AxiosRequestConfig = {	×
72	headers: {
73	'Accept': 'application/json',
74	'Content-Type': 'application/json',
75	'Authorization': `Bearer ${token.token}`
76	},
77	validateStatus: () => true	×
78	};
79
80	const metadata = account.properties.providerSettings;	×
81	const userSettingsUri = this.getConsoleUserSettingsUri(metadata.settings.armResource.endpoint);	×
82
83	let userSettingsResult: AxiosResponse<CloudConsoleSettingsResponse>;
84	try {	×
85	userSettingsResult = await axios.get(userSettingsUri, settings);	×
86	} catch (ex) {// Log as info as exception is handled
87	Logger.info(ex, ex.response);	×
88	await handleNeverUsed();	×
89	return;	×
90	}
91
92	const preferredShell = userSettingsResult.data?.properties?.preferredShellType ?? 'bash';	×
93	const preferredLocation = userSettingsResult.data?.properties?.preferredLocation;	×
94
95	const consoleRequestUri = this.getConsoleRequestUri(metadata.settings.armResource.endpoint);	×
96	if (preferredLocation) {	×
97	settings.headers!['x-ms-console-preferred-location'] = preferredLocation;	×
98	}
99
100	let provisionResult: AxiosResponse<CloudConsoleRequestResponse>;
101	try {	×
102	provisionResult = await axios.put(consoleRequestUri, {}, settings);	×
103	} catch (ex) {// Log as info as exception is handled
104	Logger.info(ex, ex.response);	×
105	await handleNeverUsed();	×
106	return;	×
107	}
108
109	if (provisionResult.data?.properties?.provisioningState !== 'Succeeded') {	×
110	throw new Error(JSON.stringify(provisionResult.data));	×
111	}
112	const consoleUri = provisionResult.data.properties.uri;	×
113
114	return this.createTerminal(consoleUri, token.token, account.displayInfo.displayName, preferredShell);	×
115	}
116
117
118	private async createTerminal(provisionedUri: string, token: string, accountDisplayName: string, preferredShell: string): Promise<void> {
119	class ShellType implements vscode.QuickPickItem {
120	constructor(public readonly label: string, public readonly value: string) {	×
121	}
122	}
123
124	const shells = [new ShellType('PowerShell', 'pwsh'), new ShellType('Bash', 'bash')];	×
125	const idx = shells.findIndex(s => s.value === preferredShell);	×
126
127	const prefShell = shells.splice(idx, 1);	×
128	shells.unshift(prefShell[0]);	×
129
130	let shell = await vscode.window.showQuickPick(shells, {	×
131	canPickMany: false,
132	placeHolder: localize('azure.selectShellType', "Select Bash or PowerShell for Azure Cloud Shell")
133	});
134
135	if (!shell) {	×
136	void vscode.window.showErrorMessage(localize('azure.shellTypeRequired', "You must pick a shell type"));	×
137	return;	×
138	}
139
140	const terminalName = localize('azure.cloudShell', "Azure Cloud Shell (Preview) {0} ({1})", shell.label, accountDisplayName);	×
141
142	const azureTerminal = new AzureTerminal(provisionedUri, token, shell.value);	×
143	const terminal = vscode.window.createTerminal({	×
144	name: terminalName,
145	pty: azureTerminal
146	});
147
148	terminal.show();	×
149	}
150
151	public getConsoleRequestUri(armEndpoint: string): string {
152	return `${armEndpoint}/providers/Microsoft.Portal/consoles/default${this.apiVersion}`;	×
153	}
154
155	public getConsoleUserSettingsUri(armEndpoint: string): string {
156	return `${armEndpoint}/providers/Microsoft.Portal/userSettings/cloudconsole${this.apiVersion}`;	×
157	}
158	}
159
160	type TerminalResponse = {
161	socketUri?: string \| undefined;
162	error?: {
163	message: string
164	}
165	}
166
167	class AzureTerminal implements vscode.Pseudoterminal {
168	private readonly writeEmitter: vscode.EventEmitter<string>;
169	public readonly onDidWrite: vscode.Event<string>;
170
171	private socket: WS \| undefined = undefined;	×
NEW 172	private intervalTimer: NodeJS.Timer \| undefined = undefined;	×
173	private terminalDimensions: vscode.TerminalDimensions \| undefined;
174
175	constructor(private readonly consoleUri: string, private readonly token: string, private shell: string) {	×
176	this.writeEmitter = new vscode.EventEmitter<string>();	×
177	this.onDidWrite = this.writeEmitter.event;	×
178	}
179
180	handleInput(data: string): void {
181	this.socket?.send(data);	×
182	}
183
184	async open(initialDimensions: vscode.TerminalDimensions): Promise<void> {
185	await this.setDimensions(initialDimensions);	×
186	}
187
188	close(): void {
189	if (!this.socket) { return; }	×
190
191	this.socket.removeAllListeners('open');	×
192	this.socket.removeAllListeners('message');	×
193	this.socket.removeAllListeners('close');	×
194
195	this.socket.close();	×
196
197	if (this.intervalTimer) {	×
198	clearInterval(this.intervalTimer);	×
199	}
200	}
201
202	private areSameDimensions(oldDimensions: vscode.TerminalDimensions \| undefined, newDimensions: vscode.TerminalDimensions): boolean {
203	return oldDimensions?.columns === newDimensions.columns && oldDimensions?.rows === newDimensions.rows;	×
204	}
205
206	async setDimensions(dimensions: vscode.TerminalDimensions): Promise<void> {
207	if (!dimensions \|\| this.areSameDimensions(this.terminalDimensions, dimensions)) {	×
208	return;	×
209	}
210	this.terminalDimensions = dimensions;	×
211	return this.resetTerminalSize();	×
212	}
213
214	private async resetTerminalSize(): Promise<void> {
215	try {	×
216	// Close the shell before this and restablish a new connection
217	this.close();	×
218
219	const terminalUri = await this.establishTerminal(this.terminalDimensions);	×
220	if (!terminalUri) {	×
221	return;	×
222	}
223	this.socket = new WS(terminalUri);	×
224
225	this.socket.on('message', (data: WS.Data) => {	×
226	// Write to the console
227	this.writeEmitter.fire(data.toString());	×
228	});
229
230	this.socket.on('close', () => {	×
231	this.writeEmitter.fire(localize('azure.shellClosed', "Shell closed.\n"));	×
232	this.close();	×
233	});
234
235	// Keep alives
236	this.intervalTimer = setInterval(() => {	×
237	this.socket?.ping();	×
238	}, 5000);
239	} catch (ex) {
240	Logger.error(ex);	×
241	}
242	}
243
244
245	private async establishTerminal(dimensions: vscode.TerminalDimensions \| undefined): Promise<string \| undefined> {
246	let terminalResult: AxiosResponse<TerminalResponse>;
247	try {	×
248	const url = dimensions ?	×
249	`${this.consoleUri}/terminals?rows=${dimensions.rows}&cols=${dimensions.columns}&shell=${this.shell}`	×
250	: `${this.consoleUri}/terminals?shell=${this.shell}`;
251	terminalResult = await axios.post(url, undefined, {	×
252	headers: {
253	'Accept': 'application/json',
254	'Content-Type': 'application/json',
255	'Authorization': `Bearer ${this.token}`
256	}
257	});
258	} catch (ex) {
259	Logger.info(`Error establishing terminal. ${ex}, ${ex.response}`);	×
260	await handleNeverUsed();	×
261	return undefined;	×
262	}
263
264	const terminalUri = terminalResult.data?.socketUri;	×
265
266	if (terminalResult.data.error) {	×
267	void vscode.window.showErrorMessage(terminalResult.data.error.message);	×
268	}
269
270	if (!terminalUri) {	×
271	throw Error(JSON.stringify(terminalResult.data));	×
272	}
273
274	return terminalUri;	×
275	}
276	}

microsoft / azuredatastudio / 11239959086

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous