Migrate to Deno (#86)

Big bang migration to Deno 🤯
2022-10-10 14:50:21 +02:00
parent 78f83c70d8
commit 561aa6891f
287 changed files with 4577 additions and 25087 deletions
@@ -0,0 +1,191 @@
+// 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 { FileData, FileEncoding, SpacePrimitives } from "./space_primitives.ts";
+import { Plug } from "../../plugos/plug.ts";
+import { mime } from "https://deno.land/x/mimetypes@v1.0.0/mod.ts";
+import { base64Decode, base64Encode } from "../../plugos/base64.ts";
+
+function lookupContentType(path: string): string {
+  return mime.getType(path) || "application/octet-stream";
+}
+
+export class DiskSpacePrimitives implements SpacePrimitives {
+  rootPath: string;
+
+  constructor(rootPath: string) {
+    this.rootPath = Deno.realPathSync(rootPath);
+  }
+
+  safePath(p: string): string {
+    const realPath = path.resolve(p);
+    if (!realPath.startsWith(this.rootPath)) {
+      throw Error(`Path ${p} is not in the space`);
+    }
+    return realPath;
+  }
+
+  filenameToPath(pageName: string) {
+    return this.safePath(path.join(this.rootPath, pageName));
+  }
+
+  pathToFilename(fullPath: string): string {
+    return fullPath.substring(this.rootPath.length + 1);
+  }
+
+  async readFile(
+    name: string,
+    encoding: FileEncoding,
+  ): Promise<{ data: FileData; meta: FileMeta }> {
+    const localPath = this.filenameToPath(name);
+    try {
+      const s = await Deno.stat(localPath);
+      let data: FileData | null = null;
+      const contentType = lookupContentType(name);
+      switch (encoding) {
+        case "string":
+          data = await Deno.readTextFile(localPath);
+          break;
+        case "dataurl":
+          {
+            const f = await Deno.open(localPath, { read: true });
+            const buf = base64Encode(await readAll(f));
+            Deno.close(f.rid);
+
+            data = `data:${contentType};base64,${buf}`;
+          }
+          break;
+        case "arraybuffer":
+          {
+            const f = await Deno.open(localPath, { read: true });
+            const buf = await readAll(f);
+            Deno.close(f.rid);
+
+            data = buf.buffer;
+          }
+          break;
+      }
+      return {
+        data,
+        meta: {
+          name: name,
+          lastModified: s.mtime!.getTime(),
+          perm: "rw",
+          size: s.size,
+          contentType: contentType,
+        },
+      };
+    } catch (e) {
+      // console.error("Error while reading file", name, e);
+      throw Error(`Could not read file ${name}`);
+    }
+  }
+
+  async writeFile(
+    name: string,
+    encoding: FileEncoding,
+    data: FileData,
+    selfUpdate?: boolean,
+  ): Promise<FileMeta> {
+    let localPath = this.filenameToPath(name);
+    try {
+      // Ensure parent folder exists
+      await Deno.mkdir(path.dirname(localPath), { recursive: true });
+
+      // Actually write the file
+      switch (encoding) {
+        case "string":
+          await Deno.writeTextFile(localPath, data as string);
+          break;
+        case "dataurl":
+          await Deno.writeFile(
+            localPath,
+            base64Decode((data as string).split(",")[1]),
+          );
+          break;
+        case "arraybuffer":
+          await Deno.writeFile(localPath, new Uint8Array(data as ArrayBuffer));
+          break;
+      }
+
+      // Fetch new metadata
+      const s = await Deno.stat(localPath);
+      return {
+        name: name,
+        size: s.size,
+        contentType: lookupContentType(name),
+        lastModified: s.mtime!.getTime(),
+        perm: "rw",
+      };
+    } catch (e) {
+      console.error("Error while writing file", name, e);
+      throw Error(`Could not write ${name}`);
+    }
+  }
+
+  async getFileMeta(name: string): Promise<FileMeta> {
+    const localPath = this.filenameToPath(name);
+    try {
+      const s = await Deno.stat(localPath);
+      return {
+        name: name,
+        size: s.size,
+        contentType: lookupContentType(name),
+        lastModified: s.mtime!.getTime(),
+        perm: "rw",
+      };
+    } catch (e) {
+      // console.error("Error while getting page meta", pageName, e);
+      throw Error(`Could not get meta for ${name}`);
+    }
+  }
+
+  async deleteFile(name: string): Promise<void> {
+    const localPath = this.filenameToPath(name);
+    await Deno.remove(localPath);
+  }
+
+  async fetchFileList(): Promise<FileMeta[]> {
+    const fileList: FileMeta[] = [];
+
+    const walkPath = async (dir: string) => {
+      for await (const file of Deno.readDir(dir)) {
+        if (file.name.startsWith(".")) {
+          continue;
+        }
+        const fullPath = path.join(dir, file.name);
+        let s = await Deno.stat(fullPath);
+        if (file.isDirectory) {
+          await walkPath(fullPath);
+        } else {
+          if (!file.name.startsWith(".")) {
+            fileList.push({
+              name: this.pathToFilename(fullPath),
+              size: s.size,
+              contentType: lookupContentType(fullPath),
+              lastModified: s.mtime!.getTime(),
+              perm: "rw",
+            });
+          }
+        }
+      }
+    };
+    await walkPath(this.rootPath);
+    return fileList;
+  }
+
+  // Plugs
+  invokeFunction(
+    plug: Plug<any>,
+    env: string,
+    name: string,
+    args: any[],
+  ): Promise<any> {
+    return plug.invoke(name, args);
+  }
+
+  proxySyscall(plug: Plug<any>, name: string, args: any[]): Promise<any> {
+    return plug.syscall(name, args);
+  }
+}