287 lines
10 KiB
TypeScript
287 lines
10 KiB
TypeScript
import type { Logger } from "../tracing/logger";
|
|
import type { FileSystemOperations } from "./filesystem-operations";
|
|
import type { RelativePath } from "../sync-operations/types";
|
|
import type { SyncEventQueue } from "../sync-operations/sync-event-queue";
|
|
import { SafeFileSystemOperations } from "./safe-filesystem-operations";
|
|
import type { TextWithCursors } from "reconcile-text";
|
|
import { reconcile } from "reconcile-text";
|
|
import { isFileTypeMergable } from "../utils/is-file-type-mergable";
|
|
import { isBinary } from "../utils/is-binary";
|
|
import { buildConflictFileName } from "../utils/conflict-path";
|
|
import type { ServerConfig } from "../services/server-config";
|
|
|
|
export class FileOperations {
|
|
private readonly fs: SafeFileSystemOperations;
|
|
|
|
public constructor(
|
|
private readonly logger: Logger,
|
|
private readonly queue: SyncEventQueue,
|
|
fs: FileSystemOperations,
|
|
private readonly serverConfig: ServerConfig,
|
|
private readonly nativeLineEndings = "\n"
|
|
) {
|
|
this.fs = new SafeFileSystemOperations(fs, logger);
|
|
}
|
|
|
|
private static getParentDirAndFile(
|
|
path: RelativePath
|
|
): [RelativePath, RelativePath] {
|
|
const pathParts = path.split("/");
|
|
const fileName = pathParts.pop();
|
|
if (fileName == null || fileName === "") {
|
|
throw new Error(`Path '${path}' cannot be empty`);
|
|
}
|
|
|
|
return [pathParts.join("/"), fileName];
|
|
}
|
|
|
|
public async listFilesRecursively(
|
|
root: RelativePath | undefined = undefined
|
|
): Promise<RelativePath[]> {
|
|
return this.fs.listFilesRecursively(root);
|
|
}
|
|
|
|
public async read(path: RelativePath): Promise<Uint8Array> {
|
|
return this.fromNativeLineEndings(await this.fs.read(path));
|
|
}
|
|
|
|
/**
|
|
* Create a file at the specified path.
|
|
*
|
|
* If a file with the same name already exists, it is moved before creating the new one.
|
|
* Parent directories are created if necessary.
|
|
*/
|
|
public async create(
|
|
path: RelativePath,
|
|
newContent: Uint8Array
|
|
): Promise<void> {
|
|
await this.ensureClearPath(path);
|
|
return this.fs.write(path, this.toNativeLineEndings(newContent));
|
|
}
|
|
|
|
/**
|
|
* Ensure nothing sits at `path` so the caller can write to it.
|
|
*
|
|
* If a file is already there, it is moved aside to a `conflict-<uuid>-<name>`
|
|
* path in the same directory. The sync layer treats conflict-named files
|
|
* as invisible (see `isConflictPath`), so no events are enqueued and no
|
|
* document records are touched — any pre-existing record or pending
|
|
* events for the displaced path are left behind for the caller to
|
|
* overwrite as part of whatever operation prompted the displacement.
|
|
*
|
|
* Returns the conflict path the existing file was moved to, or `undefined`
|
|
* if the path was already clear.
|
|
*/
|
|
public async ensureClearPath(
|
|
path: RelativePath
|
|
): Promise<RelativePath | undefined> {
|
|
if (await this.fs.exists(path)) {
|
|
const conflictPath = FileOperations.buildConflictPath(path);
|
|
this.logger.debug(
|
|
`Displacing existing file at ${path} to '${conflictPath}' to make room`
|
|
);
|
|
|
|
this.queue.moveDocument(path, conflictPath);
|
|
await this.fs.rename(path, conflictPath, true);
|
|
return conflictPath;
|
|
}
|
|
|
|
await this.createParentDirectories(path);
|
|
return undefined;
|
|
}
|
|
|
|
/**
|
|
* Update the file at the given path.
|
|
*
|
|
* Performs a 3-way merge before writing if the file's content differs from `expectedContent`.
|
|
* Does not recreate the file if it no longer exists, returning an empty array instead.
|
|
*/
|
|
public async write(
|
|
path: RelativePath,
|
|
expectedContent: Uint8Array,
|
|
newContent: Uint8Array
|
|
): Promise<void> {
|
|
if (!(await this.fs.exists(path))) {
|
|
this.logger.debug(
|
|
`The caller assumed ${path} exists, but it no longer, so we wont recreate it`
|
|
);
|
|
return;
|
|
}
|
|
|
|
if (
|
|
!isFileTypeMergable(
|
|
path,
|
|
(await this.serverConfig.getConfig()).mergeableFileExtensions
|
|
) ||
|
|
isBinary(expectedContent) ||
|
|
isBinary(newContent)
|
|
) {
|
|
this.logger.debug(
|
|
`The expected content is not mergable, so we won't perform a 3-way merge, just overwrite it`
|
|
);
|
|
await this.fs.write(
|
|
path,
|
|
// `newContent` might not be binary so we still have to ensure the line endings are correct
|
|
this.toNativeLineEndings(newContent)
|
|
);
|
|
return;
|
|
}
|
|
|
|
let expectedText: string;
|
|
let newText: string;
|
|
try {
|
|
expectedText = new TextDecoder("utf-8", { fatal: true }).decode(
|
|
expectedContent
|
|
); // this comes from a previous read which must only have \n line endings
|
|
newText = new TextDecoder("utf-8", { fatal: true }).decode(
|
|
newContent
|
|
); // this comes from the server which stores text with \n line endings
|
|
} catch (decodeError) {
|
|
this.logger.warn(
|
|
`3-way merge aborted for ${path}: one of expected/new is not valid UTF-8 (${decodeError}); falling back to overwrite`
|
|
);
|
|
await this.fs.write(path, this.toNativeLineEndings(newContent));
|
|
return;
|
|
}
|
|
|
|
await this.fs.atomicUpdateText(
|
|
path,
|
|
({ text, cursors }: TextWithCursors): TextWithCursors => {
|
|
this.logger.debug(
|
|
`Performing a 3-way merge for ${path} with the expected content`
|
|
);
|
|
|
|
text = text.replaceAll(this.nativeLineEndings, "\n");
|
|
const merged = reconcile(
|
|
expectedText,
|
|
{ text, cursors },
|
|
newText
|
|
);
|
|
|
|
const resultText = merged.text.replaceAll(
|
|
"\n",
|
|
this.nativeLineEndings
|
|
);
|
|
|
|
return {
|
|
text: resultText,
|
|
cursors: merged.cursors
|
|
};
|
|
}
|
|
);
|
|
}
|
|
|
|
public async delete(path: RelativePath): Promise<void> {
|
|
if (await this.exists(path)) {
|
|
await this.fs.delete(path);
|
|
await this.deletingEmptyParentDirectoriesOfDeletedFile(path);
|
|
} else {
|
|
this.logger.debug(`No need to delete '${path}', it doesn't exist`);
|
|
}
|
|
}
|
|
|
|
public async getFileSize(path: RelativePath): Promise<number> {
|
|
return this.fs.getFileSize(path);
|
|
}
|
|
|
|
public async exists(path: RelativePath): Promise<boolean> {
|
|
return this.fs.exists(path);
|
|
}
|
|
|
|
// Returns the conflict path a displaced file was moved to, or undefined.
|
|
public async move(
|
|
oldPath: RelativePath,
|
|
newPath: RelativePath
|
|
): Promise<RelativePath | undefined> {
|
|
if (oldPath === newPath) {
|
|
return undefined;
|
|
}
|
|
|
|
const conflictPath = await this.ensureClearPath(newPath);
|
|
// Do the disk rename *before* updating the queue. If the rename
|
|
// throws (permissions, concurrent deletion, …), the queue still
|
|
// reflects the actual on-disk state instead of claiming the doc
|
|
// has already moved.
|
|
await this.fs.rename(oldPath, newPath);
|
|
this.queue.moveDocument(oldPath, newPath);
|
|
|
|
await this.deletingEmptyParentDirectoriesOfDeletedFile(oldPath);
|
|
return conflictPath;
|
|
}
|
|
|
|
|
|
public reset(): void {
|
|
this.fs.reset();
|
|
}
|
|
|
|
private async deletingEmptyParentDirectoriesOfDeletedFile(
|
|
path: RelativePath
|
|
): Promise<void> {
|
|
let directory = path;
|
|
// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
|
|
while (true) {
|
|
[directory] = FileOperations.getParentDirAndFile(directory);
|
|
if (directory.length === 0) {
|
|
break;
|
|
}
|
|
|
|
const remainingContent =
|
|
await this.fs.listFilesRecursively(directory);
|
|
if (remainingContent.length === 0) {
|
|
this.logger.debug(
|
|
`Folder (${directory}) is now empty, deleting`
|
|
);
|
|
await this.fs.delete(directory);
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private fromNativeLineEndings(content: Uint8Array): Uint8Array {
|
|
if (isBinary(content)) {
|
|
return content;
|
|
}
|
|
|
|
const decoder = new TextDecoder("utf-8");
|
|
let text = decoder.decode(content);
|
|
text = text.replaceAll(this.nativeLineEndings, "\n");
|
|
return new TextEncoder().encode(text);
|
|
}
|
|
|
|
private toNativeLineEndings(content: Uint8Array): Uint8Array {
|
|
if (isBinary(content)) {
|
|
return content;
|
|
}
|
|
|
|
const decoder = new TextDecoder("utf-8");
|
|
let text = decoder.decode(content);
|
|
text = text.replaceAll("\n", this.nativeLineEndings);
|
|
return new TextEncoder().encode(text);
|
|
}
|
|
|
|
private async createParentDirectories(path: string): Promise<void> {
|
|
const components = path.split("/");
|
|
if (components.length === 1) {
|
|
return;
|
|
}
|
|
for (let i = 1; i < components.length; i++) {
|
|
const parentDir = components.slice(0, i).join("/");
|
|
if (!(await this.fs.exists(parentDir))) {
|
|
await this.fs.createDirectory(parentDir);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Build a local-only conflict path for a file the client has to set aside.
|
|
* Format: `<dir>/conflict-<uuid>-<originalName>` — UUID makes collisions
|
|
* statistically impossible, so no disk probe / lock dance is needed.
|
|
*/
|
|
private static buildConflictPath(path: RelativePath): RelativePath {
|
|
const [directory, fileName] =
|
|
FileOperations.getParentDirAndFile(path);
|
|
const conflictName = buildConflictFileName(fileName);
|
|
return directory ? `${directory}/${conflictName}` : conflictName;
|
|
}
|
|
}
|