code-server/src/update.ts

import * as cp from "child_process";
import * as os from "os";
import * as path from "path";
import * as util from "util";
import * as zlib from 'zlib';

import { CancellationToken } from "vs/base/common/cancellation";
import * as pfs from "vs/base/node/pfs";
import { asJson, download } from "vs/base/node/request";
import { IConfigurationService } from "vs/platform/configuration/common/configuration";
import { IEnvironmentService } from "vs/platform/environment/common/environment";
import { ILogService } from "vs/platform/log/common/log";
import pkg from "vs/platform/product/node/package";
import { IRequestService } from "vs/platform/request/node/request";
import { State, UpdateType, StateType, AvailableForDownload } from "vs/platform/update/common/update";
import { AbstractUpdateService } from "vs/platform/update/electron-main/abstractUpdateService";

import { ipcMain } from "vs/server/src/ipc";
import { tmpdir } from "vs/server/src/util";
import { extract } from "vs/server/src/tar";

interface IUpdate {
	name: string;
}

export class UpdateService extends AbstractUpdateService {
	_serviceBrand: any;

	constructor(
		@IConfigurationService configurationService: IConfigurationService,
		@IEnvironmentService environmentService: IEnvironmentService,
		@IRequestService requestService: IRequestService,
		@ILogService logService: ILogService
	) {
		super(null, configurationService, environmentService, requestService, logService);
	}

	public async isLatestVersion(): Promise<boolean | undefined> {
		const latest = await this.getLatestVersion();
		return !latest || latest.name === pkg.codeServerVersion;
	}

	protected buildUpdateFeedUrl(): string {
		return "https://api.github.com/repos/cdr/code-server/releases/latest";
	}

	protected doQuitAndInstall(): void {
		ipcMain.relaunch();
	}

	protected async doCheckForUpdates(context: any): Promise<void> {
		if (this.state.type !== StateType.Idle) {
			return Promise.resolve();
		}
		this.setState(State.CheckingForUpdates(context));
		try {
			const update = await this.getLatestVersion();
			if (!update || !update.name || update.name === pkg.codeServerVersion) {
				this.setState(State.Idle(UpdateType.Archive));
			} else {
				this.setState(State.AvailableForDownload({
					version: update.name,
					productVersion: update.name,
				}));
			}
		} catch (error) {
			this.onRequestError(error, !!context);
		}
	}

	private async getLatestVersion(): Promise<IUpdate | null> {
		const data = await this.requestService.request({
			url: this.url,
			headers: {
				"User-Agent": "code-server",
			},
		}, CancellationToken.None);
		return asJson(data);
	}

	protected async doDownloadUpdate(state: AvailableForDownload): Promise<void> {
		this.setState(State.Updating(state.update));
		const target = os.platform();
		const releaseName = await this.buildReleaseName(state.update.version);
		const url = "https://github.com/cdr/code-server/releases/download/"
			+ `${state.update.version}/${releaseName}`
			+ `.${target === "darwin" ? "zip" : "tar.gz"}`;
		const downloadPath = path.join(tmpdir, `${state.update.version}-archive`);
		const extractPath = path.join(tmpdir, state.update.version);
		try {
			await pfs.mkdirp(tmpdir);
			const context = await this.requestService.request({ url }, CancellationToken.None);
			// Decompress the gzip as we download. If the gzip encoding is set then
			// the request service already does this.
			if (target !== "darwin" && context.res.headers["content-encoding"] !== "gzip") {
				context.stream = context.stream.pipe(zlib.createGunzip());
			}
			await download(downloadPath, context);
			await extract(downloadPath, extractPath, undefined, CancellationToken.None);
			const newBinary = path.join(extractPath, releaseName, "code-server");
			if (!pfs.exists(newBinary)) {
				throw new Error("No code-server binary in extracted archive");
			}
			await pfs.unlink(process.argv[0]); // Must unlink first to avoid ETXTBSY.
			await pfs.move(newBinary, process.argv[0]);
			this.setState(State.Ready(state.update));
		} catch (error) {
			this.onRequestError(error, true);
		}
		await Promise.all([downloadPath, extractPath].map((p) => pfs.rimraf(p)));
	}

	private onRequestError(error: Error, showNotification?: boolean): void {
		this.logService.error(error);
		const message: string | undefined = showNotification ? (error.message || error.toString()) : undefined;
		this.setState(State.Idle(UpdateType.Archive, message));
	}

	private async buildReleaseName(release: string): Promise<string> {
		let target: string = os.platform();
		if (target === "linux") {
			const result = await util.promisify(cp.exec)("ldd --version");
			if (result.stderr) {
				throw new Error(result.stderr);
			}
			if (result.stdout.indexOf("musl") !== -1) {
				target = "alpine";
			}
		}
		let arch = os.arch();
		if (arch === "x64") {
			arch = "x86_64";
		}
		return `code-server${release}-${target}-${arch}`;
	}
}