braid-http 1.3.39 → 1.3.40

package/braid-http-client.js

@@ -307,9 +307,9 @@ async function braid_fetch (url, params = {}) {
                 // Now we run the original fetch....
 
                 // try multiplexing if the multiplex flag is set, and conditions are met
-                var mux_params = params.multiplex ?? braid_fetch.multiplex
+                var mux_params = params.multiplex ?? braid_fetch.enable_multiplex
                 if (mux_params !== false &&
-                    (params.headers.has('multiplexer') ||
+                    (params.headers.has('multiplex-at') ||
                     (params.headers.has('subscribe') &&
                         braid_fetch.subscription_counts?.[origin] >
                             (!mux_params ? 1 : (mux_params.after ?? 0))))) {
@@ -828,17 +828,19 @@ function parse_body (state) {
 // multiplex_fetch provides a fetch-like experience for HTTP requests
 // where the result is actually being sent over a separate multiplexed connection.
 async function multiplex_fetch(url, params, skip_multiplex_method) {
+    var multiplex_version = '1.0'
+
     var origin = new URL(url, typeof document !== 'undefined' ? document.baseURI : undefined).origin
 
     // the mux_key is the same as the origin, unless it is being overriden
     // (the overriding is done by the tests)
-    var mux_key = params.headers.get('multiplexer')?.split('/')[3] ?? origin
+    var mux_key = params.headers.get('multiplex-at')?.split('/')[3] ?? origin
 
     // create a new multiplexer if it doesn't exist for this origin
     if (!multiplex_fetch.multiplexers) multiplex_fetch.multiplexers = {}
     if (!multiplex_fetch.multiplexers[mux_key]) multiplex_fetch.multiplexers[mux_key] = (async () => {
         // make up a new multiplexer id (unless it is being overriden)
-        var multiplexer = params.headers.get('multiplexer')?.split('/')[3] ?? Math.random().toString(36).slice(2)
+        var multiplexer = params.headers.get('multiplex-at')?.split('/')[3] ?? Math.random().toString(36).slice(2)
 
         var streams = new Map()
         var mux_error = null
@@ -847,16 +849,16 @@ async function multiplex_fetch(url, params, skip_multiplex_method) {
             // attempt to establish a multiplexed connection
             try {
                 if (skip_multiplex_method) throw 'skip multiplex method'
-                var r = await braid_fetch(`${origin}/${multiplexer}`, {method: 'MULTIPLEX', headers: {'Multiplex-Version': '0.0.1'}, retry: true})
-                if (!r.ok || r.headers.get('Multiplex-Version') !== '0.0.1') throw 'bad'
+                var r = await braid_fetch(`${origin}/${multiplexer}`, {method: 'MULTIPLEX', headers: {'Multiplex-Version': multiplex_version}, retry: true})
+                if (!r.ok || r.headers.get('Multiplex-Version') !== multiplex_version) throw 'bad'
             } catch (e) {
                 // some servers don't like custom methods,
                 // so let's try with a custom header
                 try {
-                    r = await braid_fetch(`${origin}/.well-known/multiplex/${multiplexer}`, {method: 'POST', headers: {'Multiplex-Version': '0.0.1'}, retry: true})
+                    r = await braid_fetch(`${origin}/.well-known/multiplex/${multiplexer}`, {method: 'POST', headers: {'Multiplex-Version': multiplex_version}, retry: true})
 
                     if (!r.ok) throw new Error('status not ok: ' + r.status)
-                    if (r.headers.get('Multiplex-Version') !== '0.0.1') throw new Error('wrong multiplex version: ' + r.headers.get('Multiplex-Version') + ', expected 0.0.1')
+                    if (r.headers.get('Multiplex-Version') !== multiplex_version) throw new Error('wrong multiplex version: ' + r.headers.get('Multiplex-Version') + ', expected ' + multiplex_version)
                 } catch (e) {
                     // fallback to normal fetch if multiplexed connection fails
                     console.error(`Could not establish multiplexed connection.\nGot error: ${e}.\nFalling back to normal connection.`)
@@ -882,16 +884,16 @@ async function multiplex_fetch(url, params, skip_multiplex_method) {
             // if we already know the multiplexer is not working,
             // then fallback to normal fetch
             // (unless the user is specifically asking for multiplexing)
-            if ((await promise_done(mux_promise)) && (await mux_promise) === false && !params.headers.get('multiplexer'))
+            if ((await promise_done(mux_promise)) && (await mux_promise) === false && !params.headers.get('multiplex-at'))
                 return await normal_fetch(url, params)
 
             // make up a new stream id (unless it is being overriden)
-            var stream = params.headers.get('multiplexer')?.split('/')[4] ?? Math.random().toString(36).slice(2)
+            var stream = params.headers.get('multiplex-at')?.split('/')[4] ?? Math.random().toString(36).slice(2)
 
-            // add the multiplexer header without affecting the underlying params
+            // add the Multiplex-At header without affecting the underlying params
             var mux_headers = new Headers(params.headers)
-            mux_headers.set('Multiplexer', `/.well-known/multiplex/${multiplexer}/${stream}`)
-            mux_headers.set('Multiplex-Version', '0.0.1')
+            mux_headers.set('Multiplex-At', `/.well-known/multiplex/${multiplexer}/${stream}`)
+            mux_headers.set('Multiplex-Version', multiplex_version)
             params = {...params, headers: mux_headers}
 
             // setup a way to receive incoming data from the multiplexer
@@ -929,13 +931,13 @@ async function multiplex_fetch(url, params, skip_multiplex_method) {
                 stream_error = e
                 bytes_available()
                 try {
-                    var r = await braid_fetch(`${origin}${params.headers.get('multiplexer')}`, {
+                    var r = await braid_fetch(`${origin}${params.headers.get('multiplex-at')}`, {
                         method: 'DELETE',
-                        headers: { 'Multiplex-Version': '0.0.1' }, retry: true
+                        headers: { 'Multiplex-Version': multiplex_version }, retry: true
                     })
 
                     if (!r.ok) throw new Error('status not ok: ' + r.status)
-                    if (r.headers.get('Multiplex-Version') !== '0.0.1') throw new Error('wrong multiplex version: ' + r.headers.get('Multiplex-Version') + ', expected 0.0.1')
+                    if (r.headers.get('Multiplex-Version') !== multiplex_version) throw new Error('wrong multiplex version: ' + r.headers.get('Multiplex-Version') + ', expected ' + multiplex_version)
                 } catch (e) {
                     e = new Error(`Could not cancel multiplexed connection: ${e}`)
                     console.error('' + e)
@@ -957,9 +959,9 @@ async function multiplex_fetch(url, params, skip_multiplex_method) {
                 // fall back to as if it was a normal fetch
                 if (res.ok && res.status !== 293) return res
 
-                if (res.status !== 293) throw new Error('Could not establish multiplexed stream ' + params.headers.get('multiplexer') + ', got status: ' + res.status)
+                if (res.status !== 293) throw new Error('Could not establish multiplexed stream ' + params.headers.get('multiplex-at') + ', got status: ' + res.status)
 
-                if (res.headers.get('Multiplex-Version') !== '0.0.1') throw new Error('Could not establish multiplexed stream ' + params.headers.get('multiplexer') + ', got unknown version: ' + res.headers.get('Multiplex-Version'))
+                if (res.headers.get('Multiplex-Version') !== multiplex_version) throw new Error('Could not establish multiplexed stream ' + params.headers.get('multiplex-at') + ', got unknown version: ' + res.headers.get('Multiplex-Version'))
 
                 // we want to present the illusion that the connection is still open,
                 // and therefor closable with "abort",
@@ -1022,7 +1024,7 @@ async function multiplex_fetch(url, params, skip_multiplex_method) {
 
                 // add a convenience property for the user to know if
                 // this response is being multiplexed
-                res.multiplexer = params.headers.get('multiplexer')
+                res.is_multiplexed = true
 
                 // return the fake response object
                 return res
@@ -1038,7 +1040,7 @@ async function multiplex_fetch(url, params, skip_multiplex_method) {
     return await (await multiplex_fetch.multiplexers[mux_key])(url, params)
 }
 
-// waits on reader for chunks like: 123 bytes for stream ABC\r\n..123 bytes..
+// waits on reader for chunks like: 123 bytes for request ABC\r\n..123 bytes..
 // which would trigger cb("ABC", bytes)
 async function parse_multiplex_stream(reader, cb, on_error) {
     try {
@@ -1072,7 +1074,7 @@ async function parse_multiplex_stream(reader, cb, on_error) {
                     }
                     if (headerComplete) {
                         var headerStr = new TextDecoder().decode(buffers[0].slice(0, header_length))
-                        var m = headerStr.match(/^[\r\n]*((\d+) bytes for|close) stream ([A-Za-z0-9_-]+)\r\n$/)
+                        var m = headerStr.match(/^[\r\n]*((\d+) bytes for|close) request ([A-Za-z0-9_-]+)\r\n$/)
                         if (!m) throw new Error('invalid multiplex header')
                         stream_id = m[3]
 

package/braid-http-server.js

@@ -243,9 +243,10 @@ function braidify (req, res, next) {
     req.subscribe = subscribe
 
     // Multiplexer stuff
-    if (braidify.use_multiplexing &&
+    var multiplex_version = '1.0'
+    if ((braidify.enable_multiplex ?? true) &&
         (req.method === 'MULTIPLEX' || req.url.startsWith('/.well-known/multiplex/')) &&
-        req.headers['multiplex-version'] === '0.0.1') {
+        req.headers['multiplex-version'] === multiplex_version) {
 
         // let the caller know we're handling things
         req.is_multiplexer = res.is_multiplexer = true
@@ -262,6 +263,17 @@ function braidify (req, res, next) {
         if (!stream) {
             // maintain a Map of all the multiplexers
             if (!braidify.multiplexers) braidify.multiplexers = new Map()
+
+            // if this multiplexer already exists, respond with an error
+            if (braidify.multiplexers.has(multiplexer)) {
+                res.writeHead(409, 'Conflict', {'Content-Type': 'application/json'})
+                return res.end(JSON.stringify({
+                    error: 'Multiplexer already exists',
+                    message: `Cannot create duplicate multiplexer with ID '${multiplexer}'`,
+                    details: 'This multiplexer ID must be unique'
+                }))
+            }
+
             braidify.multiplexers.set(multiplexer, {streams: new Map(), res})
 
             // when the response closes,
@@ -274,7 +286,7 @@ function braidify (req, res, next) {
             // keep the connection open,
             // so people can send multiplexed data to it
             res.writeHead(200, 'OK', {
-                'Multiplex-Version': '0.0.1',
+                'Multiplex-Version': multiplex_version,
                 'Incremental': '?1',
                 'Cache-Control': 'no-cache',
                 'X-Accel-Buffering': 'no',
@@ -306,7 +318,7 @@ function braidify (req, res, next) {
             s()
 
             // let the requester know we succeeded
-            res.writeHead(200, 'OK', { 'Multiplex-Version': '0.0.1' })
+            res.writeHead(200, 'OK', { 'Multiplex-Version': multiplex_version })
             return res.end(``)
         }
     }
@@ -314,12 +326,12 @@ function braidify (req, res, next) {
     // a multiplexer header means the user wants to send the
     // results of this request to the provided multiplexer,
     // tagged with the given stream id
-    if (braidify.use_multiplexing &&
-        req.headers.multiplexer &&
-        req.headers['multiplex-version'] === '0.0.1') {
+    if ((braidify.enable_multiplex ?? true) &&
+        req.headers['multiplex-at'] &&
+        req.headers['multiplex-version'] === multiplex_version) {
 
         // parse the multiplexer id and stream id from the header
-        var [multiplexer, stream] = req.headers.multiplexer.split('/').slice(3)
+        var [multiplexer, stream] = req.headers['multiplex-at'].split('/').slice(3)
 
         // find the multiplexer object (contains a response object)
         var m = braidify.multiplexers?.get(multiplexer)
@@ -349,16 +361,16 @@ function braidify (req, res, next) {
             if (og_stream) {
                 og_stream.respond({
                     ':status': 293,
-                    Multiplexer: req.headers.multiplexer,
-                    'Multiplex-Version': '0.0.1',
+                    'Multiplex-At': req.headers['multiplex-at'],
+                    'Multiplex-Version': multiplex_version,
                     ...Object.fromEntries(cors_headers)
                 })
                 og_stream.write('Ok.')
                 og_stream.end()
             } else {
                 og_socket.write('HTTP/1.1 293 Responded via multiplexer\r\n')
-                og_socket.write(`Multiplexer: ${req.headers.multiplexer}\r\n`)
-                og_socket.write(`Multiplex-Version: 0.0.1\r\n`)
+                og_socket.write(`Multiplex-At: ${req.headers['multiplex-at']}\r\n`)
+                og_socket.write(`Multiplex-Version: ${multiplex_version}\r\n`)
                 cors_headers.forEach(([key, value]) =>
                     og_socket.write(`${key}: ${value}\r\n`))
                 og_socket.write('\r\n')
@@ -383,11 +395,11 @@ function braidify (req, res, next) {
 
                 try {
                     var len = Buffer.isBuffer(chunk) ? chunk.length : Buffer.byteLength(chunk, encoding)
-                    this.multiplexer.res.write(`${len} bytes for stream ${this.stream}\r\n`)
+                    this.multiplexer.res.write(`${len} bytes for request ${this.stream}\r\n`)
                     this.multiplexer.res.write(chunk, encoding, callback)
 
                     // console.log(`wrote:`)
-                    // console.log(`${len} bytes for stream /${this.stream}\r\n`)
+                    // console.log(`${len} bytes for request /${this.stream}\r\n`)
                     // if (Buffer.isBuffer(chunk)) console.log(new TextDecoder().decode(chunk))
                     // else console.log('STRING?: ' + chunk)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "braid-http",
-  "version": "1.3.39",
+  "version": "1.3.40",
   "description": "An implementation of Braid-HTTP for Node.js and Browsers",
   "scripts": {
     "test": "node test/server.js"