braid-blob 0.0.1 → 0.0.3

package/README.md

@@ -1,2 +1,12 @@
 # braid-blob
 Blob Synchronization libraries over Braid-HTTP
+
+## Testing
+
+### to run unit tests:
+first run the test server:
+
+    npm install
+    node test/server.js
+
+then open http://localhost:8889/test.html, and the boxes should turn green as the tests pass.

package/index.js

@@ -1,153 +1,118 @@
 
 var {http_server: braidify, free_cors} = require('braid-http'),
     fs = require('fs'),
-    path = require('path'),
-    port = 8888
+    path = require('path')
 
 var braid_blob = {
-    storage_base: './braid-blob-files',
+    db_folder: './braid-blob-db',
     cache: {}
 }
 
-// Helper function to normalize URL and create host-specific path
-function get_storage_path(req) {
-    // Get host from request headers, default to localhost if not present
-    const host = req.headers.host || `localhost:${port}`;
-    // Remove protocol and normalize, similar to index.js
-    let normalized_host = host.replace(/^https?:\/\//, '');
-    // Remove any double slashes that might occur
-    normalized_host = normalized_host.replace(/\/+/g, '/');
-    // Ensure path doesn't start with a slash (since we'll join with storage_base)
-    if (normalized_host.startsWith('/')) normalized_host = normalized_host.substring(1);
-    // Combine host and URL for storage path
-    const combined_path = `${normalized_host}${req.url}`;
-    // Remove any double slashes that might result from concatenation
-    return combined_path.replace(/\/+/g, '/');
-}
-
-var subscriptions = {};
-
-// Create a hash key for subscriptions based on peer and URL
-var hash = (req) => JSON.stringify([req.headers.peer, req.url]);
+var key_to_subs = {}
 
 braid_blob.serve = async (req, res, options = {}) => {
-    if (!options.filename) options.filename = path.join(braid_blob.storage_base, get_storage_path(req))
+    if (!options.key) options.key = decodeURIComponent(req.url.split('?')[0])
 
-    braidify(req, res)
 
-    // Enable CORS
-    free_cors(res);
+    braidify(req, res)
+    if (res.is_multiplexer) return
 
     // Handle OPTIONS request
     if (req.method === 'OPTIONS') return res.end();
 
-    const filename = options.filename
-
-    if (req.method === 'GET') {
-        // Handle GET request for binary files
-        if (req.subscribe) {
-            // Start a subscription for future updates. Also ensure a file exists with an early timestamp.
-            res.startSubscription({ onClose: () => delete subscriptions[hash(req)] });
-            subscriptions[hash(req)] = res;
-            try {
-                const dir = path.dirname(filename);
-                if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-                if (!fs.existsSync(filename)) {
-                    // Create an empty file and set mtime to early timestamp (e.g., epoch + 1ms)
-                    fs.writeFileSync(filename, Buffer.alloc(0));
-                    const early = new Date(1);
-                    fs.utimesSync(filename, early, early);
-                }
-            } catch (e) {
-                console.log(`Error ensuring file on subscribe ${filename}: ${e.message}`);
-            }
-        } else {
-            res.statusCode = 200;
-        }
+    // consume PUT body
+    var body = req.method === 'PUT' && await slurp(req)
 
-        // Read binary file and send it in response
+    await within_fiber(options.key, async () => {
+        const filename = `${braid_blob.db_folder}/${encode_filename(options.key)}`
+        
         try {
-            if (fs.existsSync(filename)) {
-                const stat = fs.statSync(filename);
-                // console.log(stat.mtimeMs)
-                const fileData = fs.readFileSync(filename);
-                // Restore original timestamps to prevent mtime changes from file system read operations
-                fs.utimesSync(filename, stat.atime, stat.mtime);
-                res.setHeader('Last-Modified-Ms', String(Math.round(Number(stat.mtimeMs))));
-
-                // Check if client has a local file timestamp that's newer or equal
-                const localTimestampHeader = req.headers['x-local-file-timestamp'];
-                const serverTimestamp = Math.round(Number(stat.mtimeMs));
-                const localTimestamp = localTimestampHeader ? Math.round(Number(localTimestampHeader)) : undefined;
-
-                if (localTimestamp !== undefined && serverTimestamp <= localTimestamp) {
-                    console.log(`Skipping update for ${req.url}: server timestamp ${serverTimestamp} <= local timestamp ${localTimestamp}`);
-                    // Don't send the file data, just send headers and empty response
-                    res.sendUpdate({ body: Buffer.alloc(0), version: [String(serverTimestamp)] });
-                } else {
-                    // Send the file data as normal (when no local timestamp header or server is newer)
-                    res.sendUpdate({ body: fileData, version: [String(Math.round(Number(stat.mtimeMs)))] });
-                }
-            } else {
-                // File doesn't exist on server, return empty response
-                // It cannot reach this point if request is subscribed to!
-                res.statusCode = 404;
-                res.end("File not found");
-            }
-        } catch (err) {
-            console.log(`Error reading binary file ${filename}: ${err.message}`);
-            res.statusCode = 500;
-            res.end("Internal server error");
+            var our_v = Math.round((await fs.promises.stat(filename)).mtimeMs)
+        } catch (e) {
+            var our_v = 0
         }
 
-        if (!req.subscribe) res.end();
-    } else if (req.method === 'PUT') {
-        // Handle PUT request to update binary files
-        let body = [];
-        req.on('data', chunk => body.push(chunk));
-        req.on('end', () => {
-            body = Buffer.concat(body);
-
-            try {
-                // Ensure directory exists
-                const dir = path.dirname(filename);
-                if (!fs.existsSync(dir)) {
-                    fs.mkdirSync(dir, { recursive: true });
-                }
-                
+        if (req.method === 'GET') {
+            // Handle GET request for binary files
+            res.setHeader('Current-Version', `"${our_v}"`)
+
+            if (!req.subscribe)
+                return res.end(!our_v ? '' : await fs.promises.readFile(filename))
+
+            // Start a subscription for future updates.
+            if (!key_to_subs[options.key]) key_to_subs[options.key] = new Map()
+            var peer = req.peer || Math.random().toString(36).slice(2)
+            key_to_subs[options.key].set(peer, res)
+
+            res.startSubscription({ onClose: () => {
+                key_to_subs[options.key].delete(peer)
+                if (!key_to_subs[options.key].size)
+                    delete key_to_subs[options.key]
+            }})
+
+            if (!req.parents || 1*req.parents[0] < our_v)
+                return res.sendUpdate({
+                    version: [`"${our_v}"`],
+                    body: !our_v ? '' : await fs.promises.readFile(filename)
+                })
+            else res.write('\n\n') // get it to send headers
+        } else if (req.method === 'PUT') {
+            // Handle PUT request to update binary files
+
+            // Ensure directory exists
+            await fs.promises.mkdir(path.dirname(filename), { recursive: true })
+
+            var their_v = req.version && 1*req.version[0]
+            if (typeof their_v != 'number') their_v = 0
+            
+            if (their_v > our_v) {
                 // Write the file
-                fs.writeFileSync(filename, body);
+                await fs.promises.writeFile(filename, body)
+                await fs.promises.utimes(filename, new Date(their_v), new Date(their_v))
 
-                // Get timestamp from header or use current time
-                const timestamp = req.headers['x-timestamp'] ? Math.round(Number(req.headers['x-timestamp']) ): Number(Date.now());
-                // console.log(timestamp)
-                const mtimeSeconds = timestamp / 1000;
-                fs.utimesSync(filename, mtimeSeconds, mtimeSeconds);
-                // console.log(fs.statSync(filename).mtimeMs);
-                // console.log(`Binary file written: ${filename}`);
+                // Notify all subscriptions of the update (except the peer which made the PUT request itself)
+                if (key_to_subs[options.key])
+                    for (var [peer, sub] of key_to_subs[options.key].entries())
+                        if (peer !== req.peer)
+                            sub.sendUpdate({ body, version: [`"${their_v}"`] })
+
+                res.setHeader("Version", `"${their_v}"`)
+            } else res.setHeader("Version", `"${our_v}"`)
+            res.end('')
+        }
+    })
+}
 
-                const stat = fs.statSync(filename);
+function encode_filename(filename) {
+    // Swap all "!" and "/" characters
+    let swapped = filename.replace(/[!/]/g, (match) => (match === "!" ? "/" : "!"))
 
-                // Notify all subscriptions of the update (except the peer which made the PUT request itself)
-                for (var k in subscriptions) {
-                    var [peer, url] = JSON.parse(k);
-                    // console.log(req.headers.peer)
-                    if (peer !== req.headers.peer && url === req.url) {
-                        subscriptions[k].sendUpdate({ body, version: [String(Math.round(Number(stat.mtimeMs)))] });
-                    }
-                }
-
-                res.setHeader('Last-Modified', new Date(Math.round(Number(stat.mtimeMs))).toUTCString());
-                res.setHeader('Last-Modified-Ms', String(Math.round(Number(stat.mtimeMs))));
-                res.statusCode = 200;
-                res.end();
-            } catch (err) {
-                console.log(`Error writing binary file ${filename}: ${err.message}`);
-                res.statusCode = 500;
-                res.end("Internal server error");
-            }
-        });
-    }
+    // Encode the filename using encodeURIComponent()
+    let encoded = encodeURIComponent(swapped)
+
+    return encoded
+}
+
+function within_fiber(id, func) {
+    if (!within_fiber.chains) within_fiber.chains = {}
+    var prev = within_fiber.chains[id] || Promise.resolve()
+    var curr = prev.then(async () => {
+        try {
+            return await func()
+        } finally {
+            if (within_fiber.chains[id] === curr)
+                delete within_fiber.chains[id]
+        }
+    })
+    return within_fiber.chains[id] = curr
+}
+
+async function slurp(req) {
+    return await new Promise(done => {
+        var chunks = []
+        req.on('data', chunk => chunks.push(chunk))
+        req.on('end', () => done(Buffer.concat(chunks)))
+    })
 }
 
 module.exports = braid_blob

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "braid-blob",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Library for collaborative blobs over http using braid.",
   "author": "Braid Working Group",
   "repository": "braid-org/braid-blob",
   "homepage": "https://braid.org",
   "dependencies": {
-    "braid-http": "~1.3.81"
+    "braid-http": "~1.3.82"
   }
 }