1
0
silverbullet/common/spaces/disk_space_primitives.ts

176 lines
4.9 KiB
TypeScript
Raw Normal View History

// import { mkdir, readdir, readFile, stat, unlink, writeFile } from "fs/promises";
import { path } from "../deps.ts";
import { readAll } from "../deps.ts";
import { FileMeta } from "../types.ts";
import { SpacePrimitives } from "./space_primitives.ts";
import { mime } from "https://deno.land/x/mimetypes@v1.0.0/mod.ts";
import { walk } from "https://deno.land/std@0.165.0/fs/walk.ts";
2022-09-12 12:50:37 +00:00
function lookupContentType(path: string): string {
return mime.getType(path) || "application/octet-stream";
2022-09-12 12:50:37 +00:00
}
2023-01-14 11:04:51 +00:00
function normalizeForwardSlashPath(path: string) {
return path.replaceAll("\\", "/");
}
2023-01-13 14:41:29 +00:00
const excludedFiles = ["data.db", "data.db-journal", "sync.json"];
export class DiskSpacePrimitives implements SpacePrimitives {
rootPath: string;
2023-05-29 07:53:49 +00:00
constructor(rootPath: string) {
this.rootPath = Deno.realPathSync(rootPath);
}
2022-04-29 16:54:27 +00:00
safePath(p: string): string {
const realPath = path.resolve(p);
2022-04-29 16:54:27 +00:00
if (!realPath.startsWith(this.rootPath)) {
throw Error(`Path ${p} is not in the space`);
}
return realPath;
}
2022-09-12 12:50:37 +00:00
filenameToPath(pageName: string) {
return this.safePath(path.join(this.rootPath, pageName));
}
2022-09-12 12:50:37 +00:00
pathToFilename(fullPath: string): string {
return fullPath.substring(this.rootPath.length + 1);
}
2022-09-12 12:50:37 +00:00
async readFile(
name: string,
): Promise<{ data: Uint8Array; meta: FileMeta }> {
2022-09-12 12:50:37 +00:00
const localPath = this.filenameToPath(name);
try {
const s = await Deno.stat(localPath);
const contentType = lookupContentType(name);
const f = await Deno.open(localPath, { read: true });
const data = await readAll(f);
Deno.close(f.rid);
return {
2022-09-12 12:50:37 +00:00
data,
meta: {
2022-09-12 12:50:37 +00:00
name: name,
lastModified: s.mtime!.getTime(),
2022-05-17 09:53:17 +00:00
perm: "rw",
2022-09-12 12:50:37 +00:00
size: s.size,
contentType: contentType,
},
};
2022-10-15 17:02:56 +00:00
} catch {
// console.error("Error while reading file", name, e);
throw Error("Not found");
}
}
2022-09-12 12:50:37 +00:00
async writeFile(
name: string,
data: Uint8Array,
_selfUpdate?: boolean,
lastModified?: number,
2022-09-12 12:50:37 +00:00
): Promise<FileMeta> {
2022-10-10 16:19:08 +00:00
const localPath = this.filenameToPath(name);
try {
2022-03-23 14:41:12 +00:00
// Ensure parent folder exists
await Deno.mkdir(path.dirname(localPath), { recursive: true });
2022-03-23 14:41:12 +00:00
const file = await Deno.open(localPath, {
write: true,
create: true,
truncate: true,
});
2022-03-23 14:41:12 +00:00
// Actually write the file
await Deno.write(file.rid, data);
if (lastModified) {
console.log("Seting mtime to", new Date(lastModified));
await Deno.futime(file.rid, new Date(), new Date(lastModified));
}
file.close();
2022-09-12 12:50:37 +00:00
2022-03-23 14:41:12 +00:00
// Fetch new metadata
const s = await Deno.stat(localPath);
return {
2022-09-12 12:50:37 +00:00
name: name,
size: s.size,
contentType: lookupContentType(name),
lastModified: s.mtime!.getTime(),
2022-05-17 09:53:17 +00:00
perm: "rw",
};
} catch (e) {
2022-09-12 12:50:37 +00:00
console.error("Error while writing file", name, e);
throw Error(`Could not write ${name}`);
}
}
2022-09-12 12:50:37 +00:00
async getFileMeta(name: string): Promise<FileMeta> {
const localPath = this.filenameToPath(name);
try {
const s = await Deno.stat(localPath);
return {
2022-09-12 12:50:37 +00:00
name: name,
size: s.size,
contentType: lookupContentType(name),
lastModified: s.mtime!.getTime(),
2022-05-17 09:53:17 +00:00
perm: "rw",
};
2022-10-15 17:02:56 +00:00
} catch {
2022-06-28 12:14:15 +00:00
// console.error("Error while getting page meta", pageName, e);
2022-09-12 12:50:37 +00:00
throw Error(`Could not get meta for ${name}`);
}
}
2022-09-12 12:50:37 +00:00
async deleteFile(name: string): Promise<void> {
const localPath = this.filenameToPath(name);
await Deno.remove(localPath);
}
2022-09-12 12:50:37 +00:00
async fetchFileList(): Promise<FileMeta[]> {
const allFiles: FileMeta[] = [];
for await (
const file of walk(this.rootPath, {
includeDirs: false,
// Exclude hidden directories
2022-11-29 07:50:09 +00:00
skip: [
// Dynamically builds a regexp that matches hidden directories INSIDE the rootPath
// (but if the rootPath is hidden, it stil lists files inside of it, fixing #130)
new RegExp(`^${escapeRegExp(this.rootPath)}.*\\/\\..+$`),
],
})
) {
const fullPath = file.path;
try {
const s = await Deno.stat(fullPath);
2023-01-13 14:41:29 +00:00
const name = fullPath.substring(this.rootPath.length + 1);
if (excludedFiles.includes(name)) {
continue;
}
allFiles.push({
2023-01-14 11:04:51 +00:00
name: normalizeForwardSlashPath(name),
lastModified: s.mtime!.getTime(),
contentType: mime.getType(fullPath) || "application/octet-stream",
size: s.size,
perm: "rw",
});
} catch (e: any) {
if (e instanceof Deno.errors.NotFound) {
// Ignore, temporariy file already deleted by the time we got here
} else {
console.error("Failed to stat", fullPath, e);
}
}
}
return allFiles;
}
}
2022-11-29 07:50:09 +00:00
function escapeRegExp(string: string) {
return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string
}