statebus 6.1.18 → 6.1.22

package/client.js

@@ -1,5 +1,6 @@
 (function () {
-    var unique_sockjs_string = '_connect_to_statebus_'
+    var websocket_prefix = (clientjs_option('websocket_path')
+                            || '_connect_to_statebus_')
 
     window.dom = window.dom || new Proxy({}, {
         get: function (o, k) { return o[k] },
@@ -36,9 +37,9 @@
         //     link.href = url
         //     url = link.href
         // }
-        console.log('opening websocket to', url)
-        return new WebSocket(url + '/' + unique_sockjs_string + '/websocket')
-        // return new SockJS(url + '/' + unique_sockjs_string)
+
+        return new WebSocket(url + '/' + websocket_prefix + '/websocket')
+        // return new SockJS(url + '/' + websocket_prefix)
     }
     function client_creds (server_url) {
         var me = bus.fetch('ls/me')
@@ -61,7 +62,7 @@
         var preprefix = prefix.slice(0,-1)
         var has_prefix = new RegExp('^' + preprefix)
         var is_absolute = /^https?:\/\//
-        var client_fetched_keys = new bus.Set()
+        var subscriptions = {}
         //if (url[url.length-1]=='/') url = url.substr(0,url.length-1)
         function add_prefix (key) {
             return is_absolute.test(key) ? key : preprefix + key }
@@ -90,27 +91,85 @@
         }
 
         bus(prefix).to_fetch  = function (key, t) {
-            try {
-                braid_fetch(url + rem_prefix(key),
-                            {
-                                method: 'get',
-                                subscribe: true,
-                                headers: {accept: 'application/json'}
-                            }
-                           ).andThen( x => {
-                               t.return({
-                                   key,
-                                   val: add_prefixes(JSON.parse(x.body))
-                               })
-                           })
-            } catch (e) {
-                console.error('Braid-HTTP network error:', e)
+            // Subscription can be in states:
+            // - connecting
+            // - connected
+            // - reconnect
+            // - reconnecting
+            // - aborted
+
+            // If we have an outstanding fetch running, then let's tell it to
+            // re-activate!
+            if (subscriptions[key]) {
+                // We should only be here if an existing subscription was
+                // aborted, but hasn't cleared yet.
+                console.assert(subscriptions[key].status === 'aborted',
+                               'Refetching a subscription of status '
+                               + subscriptions[key].status)
+
+                console.trace('foo')
+
+                // Let's tell it to reconnect when it tries to clear!
+                subscriptions[key].status = 'reconnect'
+            }
+
+            // Otherwise, create a new subscription
+            else
+                subscribe (key, t)
+
+            function subscribe (key, t) {
+                var aborter = new AbortController(),
+                    reconnect_attempts = 0
+
+                // Start the subscription!
+                braid_fetch(
+                    // URL
+                    url + rem_prefix(key),
+
+                    // Options
+                    {
+                        method: 'get',
+                        subscribe: true,
+                        headers: {accept: 'application/json'},
+                        signal: aborter.signal
+                    }
+                ).andThen( function (x) {
+                    // New update received!
+                    if (subscriptions[key].status === 'connecting') {
+                        console.log('%c[*] opened ' + key,
+                                    'color: blue')
+                        reconnect_attempts = 0
+                        subscriptions[key].status = 'connected'
+                    }
+
+                    // Return the update
+                    t.return({
+                        key: key,
+                        val: add_prefixes(JSON.parse(x.body))
+                    })
+                }).catch( function (e) {
+                    if (subscriptions[key].status === 'aborted') {
+                        // Then this fetch is over and done with!
+                        delete subscriptions[key]
+                        return
+                    }
+
+                    // Reconnect!
+                    setTimeout(function () { subscribe(key, t) },
+                               reconnect_attempts > 0 ? 5000 : 1500)
+                    subscriptions[key].status = 'reconnecting'
+                })
+
+                // Remember this subscription
+                subscriptions[key] = {
+                    aborter: aborter,
+                    status: 'connecting'
+                }
             }
-            client_fetched_keys.add(key)
         }
         bus(prefix).to_forget = function (key) {
-            // send({forget: key}),
-            client_fetched_keys.delete(key)
+            subscriptions[key].status = 'aborted'
+            subscriptions[key].aborter.abort()
         }
     }
 
@@ -452,11 +511,10 @@
         window.ignore_flashbacks = false
         if (statebus_server !== 'none') {
             if (clientjs_option('braid_mode')) {
-                console.log('We socket-free!')
+                console.log('Using Braid-HTTP!')
                 braid_http_mount ('/*', statebus_server)
             } else {
                 bus.net_mount ('/*', statebus_server)
-                console.log('We going websocket!')
             }
         }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "statebus",
-  "version": "6.1.18",
+  "version": "6.1.22",
   "description": "Synchronize state.",
   "main": "statebus.js",
   "scripts": {

package/server.js

@@ -1,6 +1,5 @@
 var fs = require('fs'),
     util = require('util')
-var unique_sockjs_string = '_connect_to_statebus_'
 
 // Import braidify if it's available
 try {
@@ -22,6 +21,7 @@ function default_options (bus) { return {
             certificate: 'certs/certificate',
             certificate_bundle: 'certs/certificate-bundle'},
     connections: {include_users: true, edit_others: true},
+    websocket_path: '_connect_to_statebus_',
     __secure: false
 }}
 
@@ -219,24 +219,25 @@ function import_server (bus, options)
             cbus.fetch(key, cb = (o) => {
                 var body = bus.to_http_body(o)
 
-                // // Return 404 if the value is undefined
-                // if (!body) {
-                //     console.log('no body! time to 404')
-                //     res.statusCode = 404
-                //     res.end()
-                // }
-
-                // Or if we're braid, send via subscription
-                // else
+                // If we're braiding, send via subscription
                 if (braidify)
+                    // Note: if body === undefined, we need to send the
+                    // equivalent of a 404.  This is missing in braid spec:
+                    // https://github.com/braid-org/braid-spec/issues/110
                     res.sendVersion({body: body || 'null'})
 
                 // Or just return the current version
-                else
-                    res.send(body)
+                else {
+                    if (body !== undefined)
+                        res.send(body)
+                    else {
+                        res.statusCode = 404
+                        res.end()
+                    }
+                }
 
-                // And shut down the connection if nothing's left to do
-                if (!braidify || !req.subscribe || !body)
+                // And shut down the connection if there's no subscription
+                if (!braidify || !req.subscribe)
                     end_it_all()
             })
         }
@@ -386,7 +387,8 @@ function import_server (bus, options)
         this.http_server.on('request',  // Install express
                             function (request, response) {
                                 // But express should ignore all sockjs requests
-                                if (!request.url.startsWith('/'+unique_sockjs_string+'/'))
+                                if (!request.url.startsWith(
+                                    '/' + bus.options.websocket_path + '/'))
                                     express_app(request, response)
                             })
 
@@ -586,7 +588,8 @@ function import_server (bus, options)
             }
         })
 
-        s.installHandlers(httpserver, {prefix:'/' + unique_sockjs_string})
+        // console.log('websocket listening on', '/' + bus.options.websocket_path)
+        s.installHandlers(httpserver, {prefix:'/' + bus.options.websocket_path})
     },
 
     make_websocket: function make_websocket (url) {
@@ -594,7 +597,7 @@ function import_server (bus, options)
         url = url.replace(/^istate:\/\//, 'ws://')
         url = url.replace(/^statei:\/\//, 'ws://')
         WebSocket = require('websocket').w3cwebsocket
-        return new WebSocket(url+'/'+unique_sockjs_string+'/websocket')
+        return new WebSocket(url + '/' + bus.options.websocket_path + '/websocket')
     },
     client_creds: function client_creds (server_url) {
         // Right now the server just creates a different random id each time

package/statebus.js

@@ -10,10 +10,12 @@
     // Fetch, Save, Forget, Delete
 
     function fetch (key, callback) {
+        if (typeof key !== 'string'
+            && !(typeof key === 'object' && typeof key.key === 'string'))
+            throw ('Error: fetch(key) called with key = '
+                   + JSON.stringify(key))
         key = key.key || key    // You can pass in an object instead of key
                                 // We should probably disable this in future
-        if (typeof key !== 'string')
-            throw ('Error: fetch(key) called with a non-string key: '+key)
         bogus_check(key)
 
         var called_from_reactive_funk = !callback