feat: Initial clean release of CHM

packages/utils/fs.ts

@@ -0,0 +1,115 @@
+import { GlobOptionsWithFileTypesFalse, sync } from 'glob';
+import { readFileSync } from 'fs';
+import { readFile, stat, utimes, writeFile } from 'fs/promises';
+import { removeSync } from 'fs-extra';
+import { getSecureRandomString } from './crypto';
+import { Second } from './time';
+
+// Wraps glob.sync but with good default options so that it works across
+// platforms and with consistent sorting.
+export const globSync = (pattern: string | string[], options: GlobOptionsWithFileTypesFalse) => {
+	let output = sync(pattern, options);
+	output = output.map(f => f.replace(/\\/g, '/'));
+	output.sort();
+	return output;
+};
+
+// ------------------------------------------------------------------------------------------------
+// This is a relatively crude system for "locking" files. It does so by regularly updating the
+// timestamp of a file. If the file hasn't been updated for more than x seconds, it means the lock
+// is stale and the file can be considered unlocked.
+//
+// This is good enough for our use case, to detect if a profile is already being used by a running
+// instance of Joplin.
+// ------------------------------------------------------------------------------------------------
+
+interface FileLockerOptions {
+	interval?: number;
+}
+
+export class FileLocker {
+
+	private filePath_ = '';
+	private lockId_ = getSecureRandomString(64);
+	private interval_: ReturnType<typeof setInterval> | null = null;
+	private options_: FileLockerOptions;
+
+	public constructor(filePath: string, options: FileLockerOptions|null = null) {
+		this.options_ = {
+			interval: 10 * Second,
+			...options,
+		};
+
+		this.filePath_ = filePath;
+	}
+
+	public get options() {
+		return this.options_;
+	}
+
+	public async lock() {
+		if (!(await this.canLock())) return false;
+
+		await writeFile(this.filePath_, this.lockId_, 'utf8');
+
+		this.interval_ = setInterval(() => {
+			void this.updateLock();
+		}, this.options_.interval);
+
+		return true;
+	}
+
+	private async canLock() {
+		try {
+			const s = await stat(this.filePath_);
+			return Date.now() - s.mtime.getTime() > (this.options_.interval as number);
+		} catch (error) {
+			const e = error as NodeJS.ErrnoException;
+			if (e.code === 'ENOENT') return true;
+			e.message = `Could not find out if this file can be locked: ${this.filePath_}`;
+			return e;
+		}
+	}
+
+	// We want the unlock operation to be synchronous because it may be performed when the app
+	// is closing.
+	public unlockSync() {
+		this.stopMonitoring_();
+
+		try {
+			if (readFileSync(this.filePath_, 'utf8') === this.lockId_) removeSync(this.filePath_);
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+		}
+	}
+
+	private async updateLock() {
+		try {
+			if (!this.interval_) return;
+			if (await readFile(this.filePath_, 'utf8') !== this.lockId_) {
+				this.stopMonitoring_();
+				return;
+			}
+
+			// The locker may have been released while the ownership check was pending.
+			if (!this.interval_) return;
+			const now = new Date();
+			await utimes(this.filePath_, now, now);
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+				this.stopMonitoring_();
+				return;
+			}
+
+			throw error;
+		}
+	}
+
+	public stopMonitoring_() {
+		if (this.interval_) {
+			clearInterval(this.interval_);
+			this.interval_ = null;
+		}
+	}
+
+}