braid-http 1.3.45 → 1.3.47

package/braid-http-client.js

@@ -1,4 +1,3 @@
-// var peer = Math.random().toString(36).substr(2)
 
 // ***************************
 // http
@@ -316,7 +315,7 @@ async function braid_fetch (url, params = {}) {
                     (params.headers.has('subscribe') &&
                         braid_fetch.subscription_counts?.[origin] >
                             (!mux_params ? 1 : (mux_params.after ?? 0))))) {
-                    res = await multiplex_fetch(url, params, mux_params?.via === 'POST')
+                    res = await multiplex_fetch(url, params, mux_params)
                 } else
                     res = await normal_fetch(url, params)
 
@@ -833,7 +832,7 @@ 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) {
+async function multiplex_fetch(url, params, mux_params) {
     var multiplex_version = '1.0'
 
     var origin = new URL(url, typeof document !== 'undefined' ? document.baseURI : undefined).origin
@@ -848,31 +847,69 @@ async function multiplex_fetch(url, params, skip_multiplex_method) {
         async () => {
             // make up a new multiplexer id (unless it is being overriden)
             var multiplexer = params.headers.get('multiplex-through')?.split('/')[3]
-                ?? Math.random().toString(36).slice(2)
+                ?? random_base64url(Math.ceil((mux_params?.id_bits ?? 72) / 6))
 
             var requests = new Map()
             var mux_error = null
+            var try_deleting = new Set()
+
+            function cleanup(e, stay_dead) {
+                // the multiplexer stream has died.. let everyone know..
+                mux_error = e
+                if (!stay_dead) delete multiplex_fetch.multiplexers[mux_key]
+                for (var f of requests.values()) f()
+            }
+
+            async function try_deleting_request(request) {
+                if (!try_deleting.has(request)) {
+                    try_deleting.add(request)
+                    try {
+                        var r = await braid_fetch(`${origin}/.well-known/multiplexer/${multiplexer}/${request}`, {
+                            method: 'DELETE',
+                            headers: { 'Multiplex-Version': multiplex_version },
+                            retry: true
+                        })
+
+                        if (!r.ok) throw new Error('status not ok: ' + r.status)
+                        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 request: ${e}`)
+                        console.error('' + e)
+                        throw e
+                    } finally { try_deleting.delete(request) }
+                }
+            }
 
             var mux_promise = (async () => {
                 // attempt to establish a multiplexed connection
                 try {
-                    if (skip_multiplex_method) throw 'skip multiplex method'
+                    if (mux_params?.via === 'POST') throw 'skip multiplex method'
                     var r = await braid_fetch(`${origin}/${multiplexer}`, {
                         method: 'MULTIPLEX',
                         headers: {'Multiplex-Version': multiplex_version},
                         retry: true
                     })
+                    if (r.status === 409) {
+                        var e = await r.json()
+                        if (e.error === 'Multiplexer already exists') return cleanup(new Error(e.error))
+                    }
                     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
+                    // so let's try with a well-known url
                     try {
                         r = await braid_fetch(`${origin}/.well-known/multiplexer/${multiplexer}`,
                                               {method: 'POST',
                                                headers: {'Multiplex-Version': multiplex_version},
                                                retry: true})
-
+                        if (r.status === 409) {
+                            var e = await r.json()
+                            if (e.error === 'Multiplexer already exists') return cleanup(new Error(e.error))
+                        }
                         if (!r.ok) throw new Error('status not ok: ' + r.status)
                         if (r.headers.get('Multiplex-Version') !== multiplex_version)
                             throw new Error('wrong multiplex version: '
@@ -882,7 +919,7 @@ async function multiplex_fetch(url, params, skip_multiplex_method) {
                         // fallback to normal fetch if multiplexed connection fails
                         console.error(`Could not establish multiplexer.\n`
                                       + `Got error: ${e}.\nFalling back to normal connection.`)
-                        return false
+                        return cleanup(e, true)
                     }
                 }
 
@@ -890,40 +927,17 @@ async function multiplex_fetch(url, params, skip_multiplex_method) {
                 // and send messages to the appropriate requests
                 var try_deleting = new Set()
                 parse_multiplex_stream(r.body.getReader(), async (request, bytes) => {
-                    if (requests.has(request)) {
-                        requests.get(request)(bytes)
-                    } else if (!try_deleting.has(request)) {
-                        try_deleting.add(request)
-                        try {
-                            await braid_fetch(`${origin}/.well-known/multiplexer/${multiplexer}/${request}`, {
-                                method: 'DELETE',
-                                headers: { 'Multiplex-Version': multiplex_version },
-                                retry: true
-                            })
-                        } finally { try_deleting.delete(request) }
-                    }
-                }, e => {
-                    // the multiplexer stream has died.. let everyone know..
-                    mux_error = e
-                    for (var f of requests.values()) f()
-                    delete multiplex_fetch.multiplexers[mux_key]
-                })
+                    if (requests.has(request)) requests.get(request)(bytes)
+                    else try_deleting_request(request)
+                }, e => cleanup(e))
             })()
 
             // return a "fetch" for this multiplexer
             return async (url, params) => {
 
-                // 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('multiplex-through'))
-                    return await normal_fetch(url, params)
-
                 // make up a new request id (unless it is being overriden)
                 var request = params.headers.get('multiplex-through')?.split('/')[4]
-                    ?? Math.random().toString(36).slice(2)
+                    ?? random_base64url(Math.ceil((mux_params?.id_bits ?? 72) / 6))
 
                 // add the Multiplex-Through header without affecting the underlying params
                 var mux_headers = new Headers(params.headers)
@@ -963,22 +977,7 @@ async function multiplex_fetch(url, params, skip_multiplex_method) {
                     requests.delete(request)
                     request_error = e
                     bytes_available()
-                    try {
-                        var r = await braid_fetch(`${origin}${params.headers.get('multiplex-through')}`, {
-                            method: 'DELETE',
-                            headers: { 'Multiplex-Version': multiplex_version }, retry: true
-                        })
-
-                        if (!r.ok) throw new Error('status not ok: ' + r.status)
-                        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 request: ${e}`)
-                        console.error('' + e)
-                        throw e
-                    }
+                    await try_deleting_request(request)
                 }
 
                 // do the underlying fetch
@@ -1218,6 +1217,10 @@ async function promise_done(promise) {
     return ret !== pending
 }
 
+function random_base64url(n) {
+    return [...crypto.getRandomValues(new Uint8Array(n))].map(x => 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'[x % 64]).join('')
+}
+
 // ****************************
 // Exports
 // ****************************

package/package.json

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