OCram85/code-server
Archived
1
0
Fork 0
Code Pull Requests 2 Activity

Merge commit 'be3e8236086165e5e45a5a10783823874b3f3ebd' as 'lib/vscode'

Browse Source
This commit is contained in:
Joe Previte
2020-12-15 15:52:33 -07:00
parent 6c5c22ea8e be3e823608
commit 41bee49d07
4649 changed files with 1311795 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

117
lib/vscode/extensions/vscode-test-resolver/src/download.ts Normal file
View File

@ -0,0 +1,117 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as https from 'https';
import * as fs from 'fs';
import * as path from 'path';
import * as cp from 'child_process';
import { parse as parseUrl } from 'url';
function ensureFolderExists(loc: string) {
if (!fs.existsSync(loc)) {
const parent = path.dirname(loc);
if (parent) {
ensureFolderExists(parent);
}
fs.mkdirSync(loc);
}
}
function getDownloadUrl(updateUrl: string, commit: string, platform: string, quality: string): string {
return `${updateUrl}/commit:${commit}/server-${platform}/${quality}`;
}
async function downloadVSCodeServerArchive(updateUrl: string, commit: string, quality: string, destDir: string): Promise<string> {
ensureFolderExists(destDir);
const platform = process.platform === 'win32' ? 'win32-x64' : process.platform === 'darwin' ? 'darwin' : 'linux-x64';
const downloadUrl = getDownloadUrl(updateUrl, commit, platform, quality);
return new Promise((resolve, reject) => {
console.log(`Downloading VS Code Server from: ${downloadUrl}`);
const requestOptions: https.RequestOptions = parseUrl(downloadUrl);
https.get(requestOptions, res => {
if (res.statusCode !== 302) {
reject('Failed to get VS Code server archive location');
}
const archiveUrl = res.headers.location;
if (!archiveUrl) {
reject('Failed to get VS Code server archive location');
return;
}
const archiveRequestOptions: https.RequestOptions = parseUrl(archiveUrl);
if (archiveUrl.endsWith('.zip')) {
const archivePath = path.resolve(destDir, `vscode-server-${commit}.zip`);
const outStream = fs.createWriteStream(archivePath);
outStream.on('close', () => {
resolve(archivePath);
});
https.get(archiveRequestOptions, res => {
res.pipe(outStream);
});
} else {
const zipPath = path.resolve(destDir, `vscode-server-${commit}.tgz`);
const outStream = fs.createWriteStream(zipPath);
https.get(archiveRequestOptions, res => {
res.pipe(outStream);
});
outStream.on('close', () => {
resolve(zipPath);
});
}
});
});
}
/**
* Unzip a .zip or .tar.gz VS Code archive
*/
function unzipVSCodeServer(vscodeArchivePath: string, extractDir: string) {
if (vscodeArchivePath.endsWith('.zip')) {
const tempDir = fs.mkdtempSync('vscode-server');
if (process.platform === 'win32') {
cp.spawnSync('powershell.exe', [
'-NoProfile',
'-ExecutionPolicy', 'Bypass',
'-NonInteractive',
'-NoLogo',
'-Command',
`Microsoft.PowerShell.Archive\\Expand-Archive -Path "${vscodeArchivePath}" -DestinationPath "${tempDir}"`
]);
} else {
cp.spawnSync('unzip', [vscodeArchivePath, '-d', `${tempDir}`]);
}
fs.renameSync(path.join(tempDir, process.platform === 'win32' ? 'vscode-server-win32-x64' : 'vscode-server-darwin'), extractDir);
} else {
// tar does not create extractDir by default
if (!fs.existsSync(extractDir)) {
fs.mkdirSync(extractDir);
}
cp.spawnSync('tar', ['-xzf', vscodeArchivePath, '-C', extractDir, '--strip-components', '1']);
}
}
export async function downloadAndUnzipVSCodeServer(updateUrl: string, commit: string, quality: string = 'stable', destDir: string): Promise<string> {
const extractDir = path.join(destDir, commit);
if (fs.existsSync(extractDir)) {
console.log(`Found ${extractDir}. Skipping download.`);
} else {
console.log(`Downloading VS Code Server ${quality} - ${commit} into ${extractDir}.`);
try {
const vscodeArchivePath = await downloadVSCodeServerArchive(updateUrl, commit, quality, destDir);
if (fs.existsSync(vscodeArchivePath)) {
unzipVSCodeServer(vscodeArchivePath, extractDir);
// Remove archive
fs.unlinkSync(vscodeArchivePath);
}
} catch (err) {
throw Error(`Failed to download and unzip VS Code ${quality} - ${commit}`);
}
}
return Promise.resolve(extractDir);
}

289
lib/vscode/extensions/vscode-test-resolver/src/extension.ts Normal file
View File

@ -0,0 +1,289 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as vscode from 'vscode';
import * as cp from 'child_process';
import * as path from 'path';
import * as fs from 'fs';
import * as os from 'os';
import * as net from 'net';
import { downloadAndUnzipVSCodeServer } from './download';
import { terminateProcess } from './util/processes';
let extHostProcess: cp.ChildProcess | undefined;
const enum CharCode {
Backspace = 8,
LineFeed = 10
}
let outputChannel: vscode.OutputChannel;
export function activate(context: vscode.ExtensionContext) {
function doResolve(_authority: string, progress: vscode.Progress<{ message?: string; increment?: number }>): Promise<vscode.ResolvedAuthority> {
const serverPromise = new Promise<vscode.ResolvedAuthority>(async (res, rej) => {
progress.report({ message: 'Starting Test Resolver' });
outputChannel = vscode.window.createOutputChannel('TestResolver');
let isResolved = false;
async function processError(message: string) {
outputChannel.appendLine(message);
if (!isResolved) {
isResolved = true;
outputChannel.show();
const result = await vscode.window.showErrorMessage(message, { modal: true }, ...getActions());
if (result) {
await result.execute();
}
rej(vscode.RemoteAuthorityResolverError.NotAvailable(message, true));
}
}
let lastProgressLine = '';
function processOutput(output: string) {
outputChannel.append(output);
for (let i = 0; i < output.length; i++) {
const chr = output.charCodeAt(i);
if (chr === CharCode.LineFeed) {
const match = lastProgressLine.match(/Extension host agent listening on (\d+)/);
if (match) {
isResolved = true;
res(new vscode.ResolvedAuthority('localhost', parseInt(match[1], 10))); // success!
}
lastProgressLine = '';
} else if (chr === CharCode.Backspace) {
lastProgressLine = lastProgressLine.substr(0, lastProgressLine.length - 1);
} else {
lastProgressLine += output.charAt(i);
}
}
}
const delay = getConfiguration('startupDelay');
if (typeof delay === 'number') {
let remaining = Math.ceil(delay);
outputChannel.append(`Delaying startup by ${remaining} seconds (configured by "testresolver.startupDelay").`);
while (remaining > 0) {
progress.report({ message: `Delayed resolving: Remaining ${remaining}s` });
await (sleep(1000));
remaining--;
}
}
if (getConfiguration('startupError') === true) {
processError('Test Resolver failed for testing purposes (configured by "testresolver.startupError").');
return;
}
const { updateUrl, commit, quality, serverDataFolderName, dataFolderName } = getProductConfiguration();
const commandArgs = ['--port=0', '--disable-telemetry'];
const env = getNewEnv();
const remoteDataDir = process.env['TESTRESOLVER_DATA_FOLDER'] || path.join(os.homedir(), serverDataFolderName || `${dataFolderName}-testresolver`);
env['VSCODE_AGENT_FOLDER'] = remoteDataDir;
outputChannel.appendLine(`Using data folder at ${remoteDataDir}`);
if (!commit) { // dev mode
const serverCommand = process.platform === 'win32' ? 'server.bat' : 'server.sh';
const vscodePath = path.resolve(path.join(context.extensionPath, '..', '..'));
const serverCommandPath = path.join(vscodePath, 'resources', 'server', 'bin-dev', serverCommand);
extHostProcess = cp.spawn(serverCommandPath, commandArgs, { env, cwd: vscodePath });
} else {
const serverCommand = process.platform === 'win32' ? 'server.cmd' : 'server.sh';
let serverLocation = env['VSCODE_REMOTE_SERVER_PATH']; // support environment variable to specify location of server on disk
if (!serverLocation) {
const serverBin = path.join(remoteDataDir, 'bin');
progress.report({ message: 'Installing VSCode Server' });
serverLocation = await downloadAndUnzipVSCodeServer(updateUrl, commit, quality, serverBin);
}
outputChannel.appendLine(`Using server build at ${serverLocation}`);
extHostProcess = cp.spawn(path.join(serverLocation, serverCommand), commandArgs, { env, cwd: serverLocation });
}
extHostProcess.stdout!.on('data', (data: Buffer) => processOutput(data.toString()));
extHostProcess.stderr!.on('data', (data: Buffer) => processOutput(data.toString()));
extHostProcess.on('error', (error: Error) => {
processError(`server failed with error:\n${error.message}`);
extHostProcess = undefined;
});
extHostProcess.on('close', (code: number) => {
processError(`server closed unexpectedly.\nError code: ${code}`);
extHostProcess = undefined;
});
context.subscriptions.push({
dispose: () => {
if (extHostProcess) {
terminateProcess(extHostProcess, context.extensionPath);
}
}
});
});
return serverPromise.then(serverAddr => {
return new Promise<vscode.ResolvedAuthority>(async (res, _rej) => {
const proxyServer = net.createServer(proxySocket => {
outputChannel.appendLine(`Proxy connection accepted`);
let remoteReady = true, localReady = true;
const remoteSocket = net.createConnection({ port: serverAddr.port });
let isDisconnected = getConfiguration('pause') === true;
vscode.workspace.onDidChangeConfiguration(_ => {
let newIsDisconnected = getConfiguration('pause') === true;
if (isDisconnected !== newIsDisconnected) {
outputChannel.appendLine(`Connection state: ${newIsDisconnected ? 'open' : 'paused'}`);
isDisconnected = newIsDisconnected;
if (!isDisconnected) {
outputChannel.appendLine(`Resume remote and proxy sockets.`);
if (remoteSocket.isPaused() && localReady) {
remoteSocket.resume();
}
if (proxySocket.isPaused() && remoteReady) {
proxySocket.resume();
}
} else {
outputChannel.appendLine(`Pausing remote and proxy sockets.`);
if (!remoteSocket.isPaused()) {
remoteSocket.pause();
}
if (!proxySocket.isPaused()) {
proxySocket.pause();
}
}
}
});
proxySocket.on('data', (data) => {
remoteReady = remoteSocket.write(data);
if (!remoteReady) {
proxySocket.pause();
}
});
remoteSocket.on('data', (data) => {
localReady = proxySocket.write(data);
if (!localReady) {
remoteSocket.pause();
}
});
proxySocket.on('drain', () => {
localReady = true;
if (!isDisconnected) {
remoteSocket.resume();
}
});
remoteSocket.on('drain', () => {
remoteReady = true;
if (!isDisconnected) {
proxySocket.resume();
}
});
proxySocket.on('close', () => {
outputChannel.appendLine(`Proxy socket closed, closing remote socket.`);
remoteSocket.end();
});
remoteSocket.on('close', () => {
outputChannel.appendLine(`Remote socket closed, closing proxy socket.`);
proxySocket.end();
});
context.subscriptions.push({
dispose: () => {
proxySocket.end();
remoteSocket.end();
}
});
});
proxyServer.listen(0, () => {
const port = (<net.AddressInfo>proxyServer.address()).port;
outputChannel.appendLine(`Going through proxy at port ${port}`);
res(new vscode.ResolvedAuthority('127.0.0.1', port));
});
context.subscriptions.push({
dispose: () => {
proxyServer.close();
}
});
});
});
}
vscode.workspace.registerRemoteAuthorityResolver('test', {
resolve(_authority: string): Thenable<vscode.ResolvedAuthority> {
return vscode.window.withProgress({
location: vscode.ProgressLocation.Notification,
title: 'Open TestResolver Remote ([details](command:vscode-testresolver.showLog))',
cancellable: false
}, (progress) => doResolve(_authority, progress));
}
});
vscode.commands.registerCommand('vscode-testresolver.newWindow', () => {
return vscode.commands.executeCommand('vscode.newWindow', { remoteAuthority: 'test+test' });
});
vscode.commands.registerCommand('vscode-testresolver.newWindowWithError', () => {
return vscode.commands.executeCommand('vscode.newWindow', { remoteAuthority: 'test+error' });
});
vscode.commands.registerCommand('vscode-testresolver.showLog', () => {
if (outputChannel) {
outputChannel.show();
}
});
}
type ActionItem = (vscode.MessageItem & { execute: () => void; });
function getActions(): ActionItem[] {
const actions: ActionItem[] = [];
const isDirty = vscode.workspace.textDocuments.some(d => d.isDirty) || vscode.workspace.workspaceFile && vscode.workspace.workspaceFile.scheme === 'untitled';
actions.push({
title: 'Retry',
execute: async () => {
await vscode.commands.executeCommand('workbench.action.reloadWindow');
}
});
if (!isDirty) {
actions.push({
title: 'Close Remote',
execute: async () => {
await vscode.commands.executeCommand('vscode.newWindow', { reuseWindow: true });
}
});
}
actions.push({
title: 'Ignore',
isCloseAffordance: true,
execute: async () => {
vscode.commands.executeCommand('vscode-testresolver.showLog'); // no need to wait
}
});
return actions;
}
export interface IProductConfiguration {
updateUrl: string;
commit: string;
quality: string;
dataFolderName: string;
serverDataFolderName?: string;
}
function getProductConfiguration(): IProductConfiguration {
const content = fs.readFileSync(path.join(vscode.env.appRoot, 'product.json')).toString();
return JSON.parse(content) as IProductConfiguration;
}
function getNewEnv(): { [x: string]: string | undefined } {
const env = { ...process.env };
delete env['ELECTRON_RUN_AS_NODE'];
return env;
}
function sleep(ms: number): Promise<void> {
return new Promise(resolve => {
setTimeout(resolve, ms);
});
}
function getConfiguration<T>(id: string): T | undefined {
return vscode.workspace.getConfiguration('testresolver').get<T>(id);
}

8
lib/vscode/extensions/vscode-test-resolver/src/typings/ref.d.ts vendored Normal file
View File

@ -0,0 +1,8 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
/// <reference path="../../../../src/vs/vscode.d.ts" />
/// <reference path="../../../../src/vs/vscode.proposed.d.ts" />
/// <reference types='@types/node'/>

37
lib/vscode/extensions/vscode-test-resolver/src/util/processes.ts Normal file
View File

@ -0,0 +1,37 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as cp from 'child_process';
import * as path from 'path';
export interface TerminateResponse {
success: boolean;
error?: any;
}
export function terminateProcess(p: cp.ChildProcess, extensionPath: string): TerminateResponse {
if (process.platform === 'win32') {
try {
const options: any = {
stdio: ['pipe', 'pipe', 'ignore']
};
cp.execFileSync('taskkill', ['/T', '/F', '/PID', p.pid.toString()], options);
} catch (err) {
return { success: false, error: err };
}
} else if (process.platform === 'darwin' || process.platform === 'linux') {
try {
const cmd = path.join(extensionPath, 'scripts', 'terminateProcess.sh');
const result = cp.spawnSync(cmd, [process.pid.toString()]);
if (result.error) {
return { success: false, error: result.error };
}
} catch (err) {
return { success: false, error: err };
}
} else {
p.kill('SIGKILL');
}
return { success: true };
}