dev: LocalDiskStorageController with upload method

Begin work on LocalDiskStorageController in the `puterfs` extension.
This replaces LocalDiskStorageStrategy and LocalDiskStorageService from
the core. The `upload()` method is implemented to verify that it's
working.

This commit by itself will break other storage strategies. The next step
is to allow extensions to register storage controllers for puterfs. Part
of that work is done in this commit by emitting an event to register
storage controllers, but this commit does not include a way to
configure/select storage controllers.

Author: KernelDeimos

extensions/puterfs/PuterFSProvider.js

@@ -97,8 +97,9 @@ const {
 } = extension.import('fs').util;
 
 export default class PuterFSProvider {
-    constructor ({ fsEntryController }) {
+    constructor ({ fsEntryController, storageController }) {
         this.fsEntryController = fsEntryController;
+        this.storageController = storageController;
         this.name = 'puterfs';
     }
 
@@ -943,7 +944,7 @@ export default class PuterFSProvider {
         const state_upload = storage.create_upload();
 
         try {
-            await state_upload.run({
+            await this.storageController.upload({
                 uid: uuid,
                 file,
                 storage_meta: { bucket, bucket_region },

extensions/puterfs/main.js

@@ -19,18 +19,45 @@
 
 import FSEntryController from './fsentries/FSEntryController.js';
 import PuterFSProvider from './PuterFSProvider.js';
+import LocalDiskStorageController from './storage/LocalDiskStorageController.js';
+import ProxyStorageController from './storage/ProxyStorageController.js';
 
 const fsEntryController = new FSEntryController();
+const storageController = new ProxyStorageController();
 
-extension.on('init', () => {
+extension.on('init', async () => {
     fsEntryController.init();
+
+    // Keep track of possible storage strategies for puterfs here
+    const storageStrategies = {
+        'flat-files': new LocalDiskStorageController(),
+    };
+
+    // Emit the "create storage strategies" event
+    const event = {
+        createStorageStrategy (name, implementation) {
+            storageStrategies[name] = implementation;
+        },
+    };
+    // Awaiting the event ensures all the storage strategies are registered
+    await extension.emit('puterfs.storage.create', event);
+
+    // Not we can select the configured strategy
+    const storageToUse = storageStrategies['flat-files'];
+    storageController.setDelegate(storageToUse);
+
+    // The StorageController may need to await some asynchronous operations
+    // before it's ready to be used.
+    await storageController.init();
+
 });
 
 extension.on('create.filesystem-types', event => {
     event.createFilesystemType('puterfs', {
         mount ({ path }) {
             return new PuterFSProvider({
                 fsEntryController,
+                storageController,
             });
         },
     });

extensions/puterfs/storage/LocalDiskStorageController.js

@@ -0,0 +1,65 @@
+import putility from '@heyputer/putility';
+import fs from 'node:fs';
+import path_ from 'node:path';
+
+const {
+    progress_stream,
+    size_limit_stream,
+} = extension.import('core').util.streamutil;
+
+export default class LocalDiskStorageController {
+    constructor () {
+        this.path = path_.join(process.cwd(), '/storage');
+    }
+
+    async init () {
+        await fs.promises.mkdir(this.path, { recursive: true });
+    }
+
+    async upload ({ uid, file, storage_api }) {
+        const { progress_tracker } = storage_api;
+
+        if ( file.buffer ) {
+            const path = this.#getPath(uid);
+            await fs.promises.writeFile(path, file.buffer);
+
+            progress_tracker.set_total(file.buffer.length);
+            progress_tracker.set(file.buffer.length);
+            return;
+        }
+
+        let stream = file.stream;
+        stream = progress_stream(stream, {
+            total: file.size,
+            progress_callback: evt => {
+                progress_tracker.set_total(file.size);
+                progress_tracker.set(evt.uploaded);
+            },
+        });
+        stream = size_limit_stream(stream, {
+            limit: file.size,
+        });
+
+        const writePromise = new putility.libs.promise.TeePromise();
+        const path = this.#getPath(uid);
+        const write_stream = fs.createWriteStream(path);
+
+        write_stream.on('error', () => writePromise.reject());
+        write_stream.on('finish', () => writePromise.resolve());
+
+        stream.pipe(write_stream);
+
+        // @ts-ignore (it's wrong about this)
+        await writePromise;
+    }
+    copy () {
+    }
+    delete () {
+    }
+    read () {
+    }
+
+    #getPath (key) {
+        return path_.join(this.path, key);
+    }
+}

extensions/puterfs/storage/ProxyStorageController.js

@@ -0,0 +1,24 @@
+export default class {
+    constructor (delegate) {
+        this.delegate = delegate ?? null;
+    }
+    setDelegate (delegate) {
+        this.delegate = delegate;
+    }
+
+    init (...a) {
+        return this.delegate.init(...a);
+    }
+    upload (...a) {
+        return this.delegate.upload(...a);
+    }
+    copy (...a) {
+        return this.delegate.copy(...a);
+    }
+    delete (...a) {
+        return this.delegate.delete(...a);
+    }
+    read (...a) {
+        return this.delegate.read(...a);
+    }
+}