code-server-2/upload.ts

import { exec } from "child_process";
import { appendFile } from "fs";
import { promisify } from "util";
import { logger } from "@coder/logger";
import { escapePath } from "@coder/protocol";
import { NotificationService, INotificationService, ProgressService, IProgressService, IProgress, Severity } from "./fill/notification";

export interface IURI {
	readonly path: string;
	readonly fsPath: string;
	readonly scheme: string;
}

/**
 * Represents an uploadable directory, so we can query for existing files once.
 */
interface IUploadableDirectory {
	existingFiles: string[];
	filesToUpload: Map<string, File>;
	preparePromise?: Promise<void>;
}

/**
 * There doesn't seem to be a provided type for entries, so here is an
 * incomplete version.
 */
interface IEntry {
	name: string;
	isFile: boolean;
	file: (cb: (file: File) => void) => void;
	createReader: () => ({
		readEntries: (cb: (entries: Array<IEntry>) => void) => void;
	});
}

/**
 * Handles file uploads.
 */
export class Upload {
	private readonly maxParallelUploads = 100;
	private readonly readSize = 32000; // ~32kb max while reading in the file.
	private readonly packetSize = 32000; // ~32kb max when writing.
	private readonly logger = logger.named("Upload");
	private readonly currentlyUploadingFiles = new Map<string, File>();
	private readonly queueByDirectory = new Map<string, IUploadableDirectory>();
	private progress: IProgress | undefined;
	private uploadPromise: Promise<string[]> | undefined;
	private resolveUploadPromise: (() => void) | undefined;
	private finished = 0;
	private uploadedFilePaths = <string[]>[];
	private total = 0;

	public constructor(
		private _notificationService: INotificationService,
		private _progressService: IProgressService,
	) {}

	public set notificationService(service: INotificationService) {
		this._notificationService = service;
	}

	public get notificationService(): INotificationService {
		return this._notificationService;
	}

	public set progressService(service: IProgressService) {
		this._progressService = service;
	}

	public get progressService(): IProgressService {
		return this._progressService;
	}

	/**
	 * Upload dropped files. This will try to upload everything it can. Errors
	 * will show via notifications. If an upload operation is ongoing, the files
	 * will be added to that operation.
	 */
	public async uploadDropped(event: DragEvent, uploadDir: IURI): Promise<string[]> {
		this.addDirectory(uploadDir.path);
		await this.queueFiles(event, uploadDir);
		this.logger.debug( // -1 so we don't include the uploadDir itself.
			`Uploading ${this.queueByDirectory.size - 1} directories and ${this.total} files`,
		);
		await this.prepareDirectories();
		if (!this.uploadPromise) {
			this.uploadPromise = this.progressService.start("Uploading files...", (progress) => {
				return new Promise((resolve): void => {
					this.progress = progress;
					this.resolveUploadPromise = (): void => {
						const uploaded = this.uploadedFilePaths;
						this.uploadPromise = undefined;
						this.resolveUploadPromise = undefined;
						this.uploadedFilePaths = [];
						this.finished = 0;
						this.total = 0;
						resolve(uploaded);
					};
				});
			}, () => {
				this.cancel();
			});
		}
		this.uploadFiles();

		return this.uploadPromise;
	}

	/**
	 * Cancel all file uploads.
	 */
	public async cancel(): Promise<void> {
		this.currentlyUploadingFiles.clear();
		this.queueByDirectory.clear();
	}

	/**
	 * Create directories and get existing files.
	 * On failure, show the error and remove the failed directory from the queue.
	 */
	private async prepareDirectories(): Promise<void> {
		await Promise.all(Array.from(this.queueByDirectory).map(([path, dir]) => {
			if (!dir.preparePromise) {
				dir.preparePromise = this.prepareDirectory(path, dir);
			}

			return dir.preparePromise;
		}));
	}

	/**
	 * Create a directory and get existing files.
	 * On failure, show the error and remove the directory from the queue.
	 */
	private async prepareDirectory(path: string, dir: IUploadableDirectory): Promise<void> {
		await Promise.all([
			promisify(exec)(`mkdir -p ${escapePath(path)}`).catch((error) => {
				const message = error.message.toLowerCase();
				if (message.includes("file exists")) {
					throw new Error(`Unable to create directory at ${path} because a file exists there`);
				}
				throw new Error(error.message || `Unable to upload ${path}`);
			}),
			// Only get files, so we don't show an override option that will just
			// fail anyway.
			promisify(exec)(`find ${escapePath(path)} -maxdepth 1 -not -type d`).then((stdio) => {
				dir.existingFiles = stdio.stdout.split("\n");
			}),
		]).catch((error) => {
			this.queueByDirectory.delete(path);
			this.notificationService.error(error);
		});
	}

	/**
	 * Upload as many files as possible. When finished, resolve the upload promise.
	 */
	private uploadFiles(): void {
		const finishFileUpload = (path: string): void => {
			++this.finished;
			this.currentlyUploadingFiles.delete(path);
			this.progress!.report(Math.floor((this.finished / this.total) * 100));
			this.uploadFiles();
		};
		while (this.queueByDirectory.size > 0 && this.currentlyUploadingFiles.size < this.maxParallelUploads) {
			const [dirPath, dir] = this.queueByDirectory.entries().next().value;
			if (dir.filesToUpload.size === 0) {
				this.queueByDirectory.delete(dirPath);
				continue;
			}
			const [filePath, item] = dir.filesToUpload.entries().next().value;
			this.currentlyUploadingFiles.set(filePath, item);
			dir.filesToUpload.delete(filePath);
			this.uploadFile(filePath, item, dir.existingFiles).then(() => {
				finishFileUpload(filePath);
			}).catch((error) => {
				this.notificationService.error(error);
				finishFileUpload(filePath);
			});
		}
		if (this.queueByDirectory.size === 0 && this.currentlyUploadingFiles.size === 0) {
			this.resolveUploadPromise!();
		}
	}

	/**
	 * Upload a file.
	 */
	private async uploadFile(path: string, file: File, existingFiles: string[]): Promise<void> {
		if (existingFiles.includes(path)) {
			const shouldOverwrite = await new Promise((resolve): void => {
				this.notificationService.prompt(
					Severity.Error,
					`${path} already exists. Overwrite?`,
					[{
						label: "Yes",
						run: (): void => resolve(true),
					}, {
						label: "No",
						run: (): void => resolve(false),
					}],
					() => resolve(false),
				);
			});
			if (!shouldOverwrite) {
				return;
			}
		}
		await new Promise(async (resolve, reject): Promise<void> => {
			let readOffset = 0;
			const reader = new FileReader();
			const seek = (): void => {
				const slice = file.slice(readOffset, readOffset + this.readSize);
				readOffset += this.readSize;
				reader.readAsArrayBuffer(slice);
			};

			const rm = async (): Promise<void> => {
				await promisify(exec)(`rm -f ${escapePath(path)}`);
			};

			await rm();

			const load = async (): Promise<void> => {
				const buffer = new Uint8Array(reader.result as ArrayBuffer);
				let bufferOffset = 0;

				while (bufferOffset <= buffer.length) {
					// Got canceled while sending data.
					if (!this.currentlyUploadingFiles.has(path)) {
						await rm();

						return resolve();
					}
					const data = buffer.slice(bufferOffset, bufferOffset + this.packetSize);

					try {
						await promisify(appendFile)(path, data);
					} catch (error) {
						await rm();

						const message = error.message.toLowerCase();
						if (message.includes("no space")) {
							return reject(new Error("You are out of disk space"));
						} else if (message.includes("is a directory")) {
							return reject(new Error(`Unable to upload ${path} because there is a directory there`));
						}

						return reject(new Error(error.message || `Unable to upload ${path}`));
					}

					bufferOffset += this.packetSize;
				}

				if (readOffset >= file.size) {
					this.uploadedFilePaths.push(path);

					return resolve();
				}

				seek();
			};

			reader.addEventListener("load", load);

			seek();
		});
	}

	/**
	 * Queue files from a drop event. We have to get the files first; we can't do
	 * it in tandem with uploading or the entries will disappear.
	 */
	private async queueFiles(event: DragEvent, uploadDir: IURI): Promise<void> {
		if (!event.dataTransfer || !event.dataTransfer.items) {
			return;
		}
		const promises: Array<Promise<void>> = [];
		for (let i = 0; i < event.dataTransfer.items.length; i++) {
			const item = event.dataTransfer.items[i];
			if (typeof item.webkitGetAsEntry === "function") {
				promises.push(this.traverseItem(item.webkitGetAsEntry(), uploadDir.fsPath).catch(this.notificationService.error));
			} else {
				const file = item.getAsFile();
				if (file) {
					this.addFile(uploadDir.fsPath, uploadDir.fsPath + "/" + file.name, file);
				}
			}
		}
		await Promise.all(promises);
	}

	/**
	 * Traverses an entry and add files to the queue.
	 */
	private async traverseItem(entry: IEntry, parentPath: string): Promise<void> {
		if (entry.isFile) {
			return new Promise<void>((resolve): void => {
				entry.file((file) => {
					this.addFile(
						parentPath,
						parentPath + "/" + file.name,
						file,
					);
					resolve();
				});
			});
		}

		parentPath += "/" + entry.name;
		this.addDirectory(parentPath);

		await new Promise((resolve): void => {
			const promises: Array<Promise<void>> = [];
			const dirReader = entry.createReader();
			// According to the spec, readEntries() must be called until it calls
			// the callback with an empty array.
			const readEntries = (): void => {
				dirReader.readEntries((entries) => {
					if (entries.length === 0) {
						Promise.all(promises).then(resolve).catch((error) => {
							this.notificationService.error(error);
							resolve();
						});
					} else {
						promises.push(...entries.map((child) => this.traverseItem(child, parentPath)));
						readEntries();
					}
				});
			};
			readEntries();
		});
	}

	/**
	 * Add a file to the queue.
	 */
	private addFile(parentPath: string, path: string, file: File): void {
		++this.total;
		this.addDirectory(parentPath);
		this.queueByDirectory.get(parentPath)!.filesToUpload.set(path, file);
	}

	/**
	 * Add a directory to the queue.
	 */
	private addDirectory(path: string): void {
		if (!this.queueByDirectory.has(path)) {
			this.queueByDirectory.set(path, {
				existingFiles: [],
				filesToUpload: new Map(),
			});
		}
	}
}

// Global instance.
export const upload = new Upload(new NotificationService(), new ProgressService());