file-server: implement more of the fs api and unit tests, and even stats.isDirectory(), etc.

Author: williamstein

src/packages/conat/core/client.ts

@@ -1133,7 +1133,11 @@ export class Client extends EventEmitter {
     return new Proxy(
       {},
       {
-        get: (_, name) => {
+        get: (target, name) => {
+          const s = target[String(name)];
+          if (s !== undefined) {
+            return s;
+          }
           if (typeof name !== "string") {
             return undefined;
           }

src/packages/conat/files/fs.ts

@@ -4,18 +4,20 @@ import { conat } from "@cocalc/conat/client";
 export interface Filesystem {
   appendFile: (path: string, data: string | Buffer, encoding?) => Promise<void>;
   chmod: (path: string, mode: string | number) => Promise<void>;
+  constants: () => Promise<{ [key: string]: number }>;
   copyFile: (src: string, dest: string) => Promise<void>;
   cp: (src: string, dest: string, options?) => Promise<void>;
   exists: (path: string) => Promise<void>;
   link: (existingPath: string, newPath: string) => Promise<void>;
+  lstat: (path: string) => Promise<IStats>;
   mkdir: (path: string, options?) => Promise<void>;
   readFile: (path: string, encoding?: any) => Promise<string | Buffer>;
   readdir: (path: string) => Promise<string[]>;
   realpath: (path: string) => Promise<string>;
   rename: (oldPath: string, newPath: string) => Promise<void>;
   rm: (path: string, options?) => Promise<void>;
   rmdir: (path: string, options?) => Promise<void>;
-  stat: (path: string) => Promise<Stats>;
+  stat: (path: string) => Promise<IStats>;
   symlink: (target: string, path: string) => Promise<void>;
   truncate: (path: string, len?: number) => Promise<void>;
   unlink: (path: string) => Promise<void>;
@@ -27,7 +29,7 @@ export interface Filesystem {
   writeFile: (path: string, data: string | Buffer) => Promise<void>;
 }
 
-export interface Stats {
+interface IStats {
   dev: number;
   ino: number;
   mode: number;
@@ -48,6 +50,48 @@ export interface Stats {
   birthtime: Date;
 }
 
+class Stats {
+  dev: number;
+  ino: number;
+  mode: number;
+  nlink: number;
+  uid: number;
+  gid: number;
+  rdev: number;
+  size: number;
+  blksize: number;
+  blocks: number;
+  atimeMs: number;
+  mtimeMs: number;
+  ctimeMs: number;
+  birthtimeMs: number;
+  atime: Date;
+  mtime: Date;
+  ctime: Date;
+  birthtime: Date;
+
+  constructor(private constants: { [key: string]: number }) {}
+
+  isSymbolicLink = () =>
+    (this.mode & this.constants.S_IFMT) === this.constants.S_IFLNK;
+
+  isFile = () => (this.mode & this.constants.S_IFMT) === this.constants.S_IFREG;
+
+  isDirectory = () =>
+    (this.mode & this.constants.S_IFMT) === this.constants.S_IFDIR;
+
+  isBlockDevice = () =>
+    (this.mode & this.constants.S_IFMT) === this.constants.S_IFBLK;
+
+  isCharacterDevice = () =>
+    (this.mode & this.constants.S_IFMT) === this.constants.S_IFCHR;
+
+  isFIFO = () => (this.mode & this.constants.S_IFMT) === this.constants.S_IFIFO;
+
+  isSocket = () =>
+    (this.mode & this.constants.S_IFMT) === this.constants.S_IFSOCK;
+}
+
 interface Options {
   service: string;
   client?: Client;
@@ -64,18 +108,24 @@ export async function fsServer({ service, fs, client }: Options) {
       async chmod(path: string, mode: string | number) {
         await (await fs(this.subject)).chmod(path, mode);
       },
+      async constants(): Promise<{ [key: string]: number }> {
+        return await (await fs(this.subject)).constants();
+      },
       async copyFile(src: string, dest: string) {
         await (await fs(this.subject)).copyFile(src, dest);
       },
       async cp(src: string, dest: string, options?) {
         await (await fs(this.subject)).cp(src, dest, options);
       },
       async exists(path: string) {
-        await (await fs(this.subject)).exists(path);
+        return await (await fs(this.subject)).exists(path);
       },
       async link(existingPath: string, newPath: string) {
         await (await fs(this.subject)).link(existingPath, newPath);
       },
+      async lstat(path: string): Promise<IStats> {
+        return await (await fs(this.subject)).lstat(path);
+      },
       async mkdir(path: string, options?) {
         await (await fs(this.subject)).mkdir(path, options);
       },
@@ -89,35 +139,35 @@ export async function fsServer({ service, fs, client }: Options) {
         return await (await fs(this.subject)).realpath(path);
       },
       async rename(oldPath: string, newPath: string) {
-        return await (await fs(this.subject)).rename(oldPath, newPath);
+        await (await fs(this.subject)).rename(oldPath, newPath);
       },
       async rm(path: string, options?) {
-        return await (await fs(this.subject)).rm(path, options);
+        await (await fs(this.subject)).rm(path, options);
       },
       async rmdir(path: string, options?) {
-        return await (await fs(this.subject)).rmdir(path, options);
+        await (await fs(this.subject)).rmdir(path, options);
       },
-      async stat(path: string): Promise<Stats> {
+      async stat(path: string): Promise<IStats> {
         return await (await fs(this.subject)).stat(path);
       },
       async symlink(target: string, path: string) {
-        return await (await fs(this.subject)).symlink(target, path);
+        await (await fs(this.subject)).symlink(target, path);
       },
       async truncate(path: string, len?: number) {
-        return await (await fs(this.subject)).truncate(path, len);
+        await (await fs(this.subject)).truncate(path, len);
       },
       async unlink(path: string) {
-        return await (await fs(this.subject)).unlink(path);
+        await (await fs(this.subject)).unlink(path);
       },
       async utimes(
         path: string,
         atime: number | string | Date,
         mtime: number | string | Date,
       ) {
-        return await (await fs(this.subject)).utimes(path, atime, mtime);
+        await (await fs(this.subject)).utimes(path, atime, mtime);
       },
       async writeFile(path: string, data: string | Buffer) {
-        return await (await fs(this.subject)).writeFile(path, data);
+        await (await fs(this.subject)).writeFile(path, data);
       },
     },
   );
@@ -130,5 +180,30 @@ export function fsClient({
   client?: Client;
   subject: string;
 }) {
-  return (client ?? conat()).call<Filesystem>(subject);
+  let call = (client ?? conat()).call<Filesystem>(subject);
+
+  let constants: any = null;
+  const stat0 = call.stat.bind(call);
+  call.stat = async (path: string) => {
+    const s = await stat0(path);
+    constants = constants ?? (await call.constants());
+    const stats = new Stats(constants);
+    for (const k in s) {
+      stats[k] = s[k];
+    }
+    return stats;
+  };
+
+  const lstat0 = call.lstat.bind(call);
+  call.lstat = async (path: string) => {
+    const s = await lstat0(path);
+    constants = constants ?? (await call.constants());
+    const stats = new Stats(constants);
+    for (const k in s) {
+      stats[k] = s[k];
+    }
+    return stats;
+  };
+
+  return call;
 }

src/packages/file-server/conat/test/local-path.test.ts

@@ -3,38 +3,102 @@ import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "path";
 import { fsClient } from "@cocalc/conat/files/fs";
+import { randomId } from "@cocalc/conat/names";
 
 let tempDir;
 beforeAll(async () => {
   tempDir = await mkdtemp(join(tmpdir(), "cocalc-local-path"));
 });
 
 describe("use the simple fileserver", () => {
-  let service;
+  const service = `fs-${randomId()}`;
+  let server;
   it("creates the simple fileserver service", async () => {
-    service = await localPathFileserver({ service: "fs", path: tempDir });
+    server = await localPathFileserver({ service, path: tempDir });
   });
 
   const project_id = "6b851643-360e-435e-b87e-f9a6ab64a8b1";
   let fs;
   it("create a client", () => {
-    fs = fsClient({ subject: `fs.project-${project_id}` });
+    fs = fsClient({ subject: `${service}.project-${project_id}` });
   });
 
-  it("checks appendFile works", async () => {
+  it("appendFile works", async () => {
+    await fs.writeFile("a", "");
     await fs.appendFile("a", "foo");
     expect(await fs.readFile("a", "utf8")).toEqual("foo");
   });
 
-  it("checks chmod works", async () => {
+  it("chmod works", async () => {
     await fs.writeFile("b", "hi");
     await fs.chmod("b", 0o755);
     const s = await fs.stat("b");
     expect(s.mode.toString(8)).toBe("100755");
   });
 
+  it("constants work", async () => {
+    const constants = await fs.constants();
+    expect(constants.O_RDONLY).toBe(0);
+    expect(constants.O_WRONLY).toBe(1);
+    expect(constants.O_RDWR).toBe(2);
+  });
+
+  it("copyFile works", async () => {
+    await fs.writeFile("c", "hello");
+    await fs.copyFile("c", "d.txt");
+    expect(await fs.readFile("d.txt", "utf8")).toEqual("hello");
+  });
+
+  it("cp works on a directory", async () => {
+    await fs.mkdir("folder");
+    await fs.writeFile("folder/a.txt", "hello");
+    await fs.cp("folder", "folder2", { recursive: true });
+    expect(await fs.readFile("folder2/a.txt", "utf8")).toEqual("hello");
+  });
+
+  it("exists works", async () => {
+    expect(await fs.exists("does-not-exist")).toBe(false);
+    await fs.writeFile("does-exist", "");
+    expect(await fs.exists("does-exist")).toBe(true);
+  });
+
+  it("creating a hard link works", async () => {
+    await fs.writeFile("source", "the source");
+    await fs.link("source", "target");
+    expect(await fs.readFile("target", "utf8")).toEqual("the source");
+    // hard link, not symlink
+    expect(await fs.realpath("target")).toBe("target");
+
+    await fs.appendFile("source", " and more");
+    expect(await fs.readFile("target", "utf8")).toEqual("the source and more");
+  });
+
+  it("mkdir works", async () => {
+    await fs.mkdir("xyz");
+    const s = await fs.stat("xyz");
+    expect(s.isDirectory()).toBe(true);
+  });
+
+  it("creating a symlink works", async () => {
+    await fs.writeFile("source1", "the source");
+    await fs.symlink("source1", "target1");
+    expect(await fs.readFile("target1", "utf8")).toEqual("the source");
+    // symlink, not hard
+    expect(await fs.realpath("target1")).toBe("source1");
+    await fs.appendFile("source1", " and more");
+    expect(await fs.readFile("target1", "utf8")).toEqual("the source and more");
+    const stats = await fs.stat("target1");
+    expect(stats.isSymbolicLink()).toBe(false);
+
+    const lstats = await fs.lstat("target1");
+    expect(lstats.isSymbolicLink()).toBe(true);
+
+    const stats0 = await fs.stat("source1");
+    expect(stats0.isSymbolicLink()).toBe(false);
+  });
+
   it("closes the service", () => {
-    service.close();
+    server.close();
   });
 });
 

src/packages/file-server/fs/sandbox.ts

@@ -15,8 +15,10 @@ import {
   appendFile,
   chmod,
   cp,
+  constants,
   copyFile,
   link,
+  lstat,
   readdir,
   readFile,
   realpath,
@@ -56,6 +58,10 @@ export class SandboxedFilesystem {
     await chmod(this.safeAbsPath(path), mode);
   };
 
+  constants = async (): Promise<{ [key: string]: number }> => {
+    return constants;
+  };
+
   copyFile = async (src: string, dest: string) => {
     await copyFile(this.safeAbsPath(src), this.safeAbsPath(dest));
   };
@@ -86,6 +92,10 @@ export class SandboxedFilesystem {
     });
   };
 
+  lstat = async (path: string) => {
+    return await lstat(this.safeAbsPath(path));
+  };
+
   mkdir = async (path: string, options?) => {
     await mkdir(this.safeAbsPath(path), options);
   };

src/packages/frontend/conat/client.ts

@@ -46,6 +46,7 @@ import {
   deleteRememberMe,
   setRememberMe,
 } from "@cocalc/frontend/misc/remember-me";
+import { fsClient } from "@cocalc/conat/files/fs";
 
 export interface ConatConnectionStatus {
   state: "connected" | "disconnected";
@@ -515,6 +516,8 @@ export class ConatClient extends EventEmitter {
   };
 
   refCacheInfo = () => refCacheInfo();
+
+  fsClient = (subject: string) => fsClient({ subject, client: this.conat() });
 }
 
 function setDeleted({ project_id, path, deleted }) {