braidfs 0.0.94 → 0.0.96

package/index.js

@@ -378,7 +378,8 @@ async function sync_url(url) {
     if (!sync_url.cache) sync_url.cache = {}
     if (!sync_url.chain) sync_url.chain = Promise.resolve()
     if (!sync_url.cache[path]) {
-        var freed = false,
+        var self = {url},
+            freed = false,
             aborts = new Set(),
             braid_text_get_options = null
         var wait_promise = Promise.resolve()
@@ -398,9 +399,8 @@ async function sync_url(url) {
         if (!unsync_url.cache) unsync_url.cache = {}
         unsync_url.cache[path] = async () => {
             freed = true
-            for (let a of aborts) a.abort()
+            await self.disconnect?.()
             await wait_promise
-            if (braid_text_get_options) await braid_text.forget(url, braid_text_get_options)
 
             delete braid_text.cache[url]
             for (let f of await braid_text.get_files_for_key(url)) {
@@ -416,8 +416,6 @@ async function sync_url(url) {
     async function init() {
         if (freed) return
 
-        var self = {url}
-
         console.log(`sync_url: ${url}`)
 
         var resource = await braid_text.get_resource(url)
@@ -489,55 +487,6 @@ async function sync_url(url) {
             file_loop_pump()
         }
 
-        async function my_fetch(params) {
-            if (freed) return
-            try {
-                var a = new AbortController()
-                aborts.add(a)
-                return await braid_fetch(url, {
-                    signal: a.signal,
-                    headers: {
-                        "Merge-Type": "dt",
-                        "Content-Type": 'text/plain',
-                        ...(x => x && {Cookie: x})(config.cookies?.[new URL(url).hostname])
-                    },
-                    retry: { retryRes: r => r.status !== 401 && r.status !== 403 },
-                    ...params
-                })
-            } catch (e) {
-                if (freed) return
-                if (e?.name !== "AbortError") console.log(e)
-            } finally {
-                if (freed) return
-                aborts.delete(a)
-            }
-        }
-        
-        async function send_out(stuff) {
-            if (!is_external_link) return
-            if (freed) return
-
-            console.log(`send_out ${url} ${JSON.stringify(stuff, null, 4).slice(0, 1000)}`)
-
-            var r = await my_fetch({ method: "PUT", ...stuff })
-            if (freed) return
-
-            // the server has acknowledged this version,
-            // so add it to the fork point
-            if (r.ok) self.update_fork_point(stuff.version[0], stuff.parents)
-
-            // if we're not authorized,
-            if (r.status == 401 || r.status == 403) {
-                // and it's one of our versions (a local edit),
-                if (self.peer === braid_text.decode_version(stuff.version[0])[0]) {
-                    // then revert it
-                    console.log(`access denied: reverting local edits`)
-                    unsync_url(url)
-                    sync_url(url)
-                }
-            }
-        }
-
         await within_fiber(fullpath, async () => {
             if (freed) return
             var fullpath = await get_fullpath()
@@ -776,193 +725,254 @@ async function sync_url(url) {
             return frontier.sort()
         }
 
-        async function find_fork_point() {
-            if (freed) return
-            console.log(`[find_fork_point] url: ${url}`)
+        var waitTime = 1
+        var last_connect_timer = null
 
-            // see if remote has the fork point
-            if (self.fork_point) {
-                var r = await my_fetch({ method: "HEAD", version: self.fork_point })
-                if (freed) return
-                if (r.ok) {
-                    console.log(`[find_fork_point] it has our latest fork point, hooray!`)
-                    return self.fork_point
-                }
+        if (is_external_link) connect()
+        async function connect() {
+            if (freed) return
+            if (last_connect_timer) return
+
+            var closed = false
+            var prev_disconnect = self.disconnect
+            self.disconnect = async () => {
+                if (closed) return
+                closed = true
+                for (var a of aborts) a.abort()
+                aborts.clear()
+                if (braid_text_get_options) await braid_text.forget(url, braid_text_get_options)
+                braid_text_get_options = null
             }
-
-            // otherwise let's binary search for new fork point..
-            var bytes = resource.doc.toBytes()
-            var [_, events, __] = braid_text.dt_parse([...bytes])
-            events = events.map(x => x.join('-'))
-
-            var min = -1
-            var max = events.length
-            self.fork_point = []
-            while (min + 1 < max) {
-                var i = Math.floor((min + max)/2)
-                var version = [events[i]]
-
-                console.log(`min=${min}, max=${max}, i=${i}, version=${version}`)
-
-                var st = Date.now()
-                var r = await my_fetch({ method: "HEAD", version })
-                if (freed) return                
-                console.log(`fetched in ${Date.now() - st}`)
-
-                if (r.ok) {
-                    min = i
-                    self.fork_point = version
-                } else max = i
+            self.reconnect = connect
+
+            await prev_disconnect?.()
+            if (freed || closed) return
+
+            async function retry(e) {
+                if (freed || closed) return
+                var p = self.disconnect()
+
+                console.log(`reconnecting in ${waitTime}s: ${url} after error: ${e}`)
+                last_connect_timer = setTimeout(async () => {
+                    await p
+                    last_connect_timer = null
+                    connect()
+                }, waitTime * 1000)
+                waitTime = Math.min(waitTime + 1, 3)
             }
-            console.log(`[find_fork_point] settled on: ${JSON.stringify(self.fork_point)}`)
-            self.signal_file_needs_writing(true)
-            return self.fork_point
-        }
-
-        var initial_connect_done
-        var initial_connect_promise = new Promise(done => initial_connect_done = done)
 
-        if (is_external_link) find_fork_point().then(async fork_point => {
-            if (freed) return                
-            await send_new_stuff(fork_point)
-            if (freed) return                
-            connect(fork_point)
-        })
-        
-        function connect(fork_point) {
-            if (freed) return                
-            let a = new AbortController()
-            aborts.add(a)
-            self.reconnect = () => {
-                if (freed) return
-                console.log(`reconnecting ${url}`)
+            var initial_connect_done
+            var initial_connect_promise = new Promise(done => initial_connect_done = done)
 
-                aborts.delete(a)
-                a.abort()
-                connect(fork_point)
+            async function my_fetch(params) {
+                if (freed || closed) return
+                try {
+                    var a = new AbortController()
+                    aborts.add(a)
+                    return await braid_fetch(url, {
+                        signal: a.signal,
+                        headers: {
+                            "Merge-Type": "dt",
+                            "Content-Type": 'text/plain',
+                            ...(x => x && {Cookie: x})(config.cookies?.[new URL(url).hostname])
+                        },
+                        retry: { retryRes: r => r.status !== 401 && r.status !== 403 },
+                        ...params
+                    })
+                } catch (e) {
+                    if (freed || closed) return
+                    if (e?.name !== "AbortError") console.log(e)
+                } finally {
+                    if (freed || closed) return
+                    aborts.delete(a)
+                }
             }
-
-            console.log(`connecting to ${url}`)
-            braid_fetch(url, {
-                signal: a.signal,
-                headers: {
-                    "Merge-Type": "dt",
-                    Accept: 'text/plain',
-                    ...(x => x && {Cookie: x})(config.cookies?.[new URL(url).hostname]),
-                },
-                subscribe: true,
-                retry: {
-                    retryRes: () => true,
-                    onRes: (res) => {
-                        if (res.status !== 209)
-                            return log_error(`Can't sync ${url} -- got bad response ${res.status} from server (expected 209)`)
-
-                        console.log(`connected to ${url}`)
-                        console.log(`  editable = ${res.headers.get('editable')}`)
-
-                        self.file_read_only = res.headers.get('editable') === 'false'
-                        self.signal_file_needs_writing()
+            
+            async function send_out(stuff) {
+                if (freed || closed) return
+
+                console.log(`send_out ${url} ${JSON.stringify(stuff, null, 4).slice(0, 1000)}`)
+
+                var r = await my_fetch({ method: "PUT", ...stuff })
+                if (freed || closed) return
+
+                // the server has acknowledged this version,
+                // so add it to the fork point
+                if (r.ok) self.update_fork_point(stuff.version[0], stuff.parents)
+
+                // if we're not authorized,
+                if (r.status == 401 || r.status == 403) {
+                    // and it's one of our versions (a local edit),
+                    if (self.peer === braid_text.decode_version(stuff.version[0])[0]) {
+                        // then revert it
+                        console.log(`access denied: reverting local edits`)
+                        unsync_url(url)
+                        sync_url(url)
                     }
-                },
-                heartbeats: 120,
-                parents: async () => {
-                    if (freed) return
-                    var x = fork_point || await find_fork_point()
-                    if (freed) return
-                    fork_point = null
-                    return x
-                },
-                peer: self.peer
-            }).then(x => {
-                if (freed) return
-                if (x.status !== 209) throw new Error(`unexpected status: ${x.status}`)
-                initial_connect_done()
-                x.subscribe(async update => {
-                    if (freed) return
-                    console.log(`got external update about ${url}`)
+                }
+            }
 
-                    if (update.body) update.body = update.body_text
-                    if (update.patches) for (let p of update.patches) p.content = p.content_text
+            async function find_fork_point() {
+                if (freed || closed) return
+                console.log(`[find_fork_point] url: ${url}`)
 
-                    // console.log(`update: ${JSON.stringify(update, null, 4)}`)
-                    if (update.version.length === 0) return
-                    if (update.version.length !== 1) throw 'unexpected'
+                // see if remote has the fork point
+                if (self.fork_point) {
+                    var r = await my_fetch({ method: "HEAD", version: self.fork_point })
+                    if (freed || closed) return
+                    if (r.ok) return console.log(`[find_fork_point] it has our latest fork point, hooray!`)
+                }
 
-                    await wait_on(braid_text.put(url, { ...update, peer: self.peer, merge_type: 'dt' }))
-                    if (freed) return
+                // otherwise let's binary search for new fork point..
+                var bytes = resource.doc.toBytes()
+                var [_, events, __] = braid_text.dt_parse([...bytes])
+                events = events.map(x => x.join('-'))
+
+                var min = -1
+                var max = events.length
+                self.fork_point = []
+                while (min + 1 < max) {
+                    var i = Math.floor((min + max)/2)
+                    var version = [events[i]]
+
+                    console.log(`min=${min}, max=${max}, i=${i}, version=${version}`)
+
+                    var st = Date.now()
+                    var r = await my_fetch({ method: "HEAD", version })
+                    if (freed || closed) return
+                    console.log(`fetched in ${Date.now() - st}`)
+
+                    if (r.ok) {
+                        min = i
+                        self.fork_point = version
+                    } else max = i
+                }
+                console.log(`[find_fork_point] settled on: ${JSON.stringify(self.fork_point)}`)
+                self.signal_file_needs_writing(true)
+            }
 
-                    // the server is giving us this version,
-                    // so it must have it,
-                    // so let's add it to our fork point
-                    self.update_fork_point(update.version[0], update.parents)
+            await find_fork_point()
+            if (freed || closed) return
 
-                    self.signal_file_needs_writing()
-                }, e => (e?.name !== "AbortError") && console.log(e))
-            }).catch(e => (e?.name !== "AbortError") && console.log(e))
-        }
+            await send_new_stuff()
+            if (freed || closed) return
 
-        // send it stuff we have but it doesn't't
-        async function send_new_stuff(fork_point) {
-            if (freed) return
-            var q = []
-            var in_flight = new Map()
-            var max_in_flight = 10
-            var send_pump_lock = 0
-
-            async function send_pump() {
-                send_pump_lock++
-                if (send_pump_lock > 1) return
-                try {
-                    if (freed) return
-                    if (in_flight.size >= max_in_flight) return
-                    if (!q.length) {
-                        var frontier = self.fork_point
-                        for (var u of in_flight.values())
-                            frontier = extend_frontier(frontier, u.version[0], u.parents)
-
-                        var options = {
-                            parents: frontier,
-                            merge_type: 'dt',
-                            peer: self.peer,
-                            subscribe: u => u.version.length && q.push(u)
+            console.log(`connecting to ${url}`)
+            let a = new AbortController()
+            aborts.add(a)
+            try {
+                var res = await braid_fetch(url, {
+                    signal: a.signal,
+                    headers: {
+                        "Merge-Type": "dt",
+                        Accept: 'text/plain',
+                        ...(x => x && {Cookie: x})(config.cookies?.[new URL(url).hostname]),
+                    },
+                    subscribe: true,
+                    heartbeats: 120,
+                    parents: self.fork_point,
+                    peer: self.peer
+                })
+            } catch (e) { return retry(e) }
+            if (freed || closed) return
+
+            if (res.status < 200 || res.status >= 300) return retry(new Error(`unexpected status: ${res.status}`))
+
+            if (res.status !== 209)
+                return log_error(`Can't sync ${url} -- got bad response ${res.status} from server (expected 209)`)
+
+            console.log(`connected to ${url}`)
+            console.log(`  editable = ${res.headers.get('editable')}`)
+
+            self.file_read_only = res.headers.get('editable') === 'false'
+            self.signal_file_needs_writing()
+            
+            initial_connect_done()
+            res.subscribe(async update => {
+                if (freed || closed) return
+                console.log(`got external update about ${url}`)
+
+                if (update.body) update.body = update.body_text
+                if (update.patches) for (let p of update.patches) p.content = p.content_text
+
+                // console.log(`update: ${JSON.stringify(update, null, 4)}`)
+                if (update.version.length === 0) return
+                if (update.version.length !== 1) throw 'unexpected'
+
+                await wait_on(braid_text.put(url, { ...update, peer: self.peer, merge_type: 'dt' }))
+                if (freed || closed) return
+
+                // the server is giving us this version,
+                // so it must have it,
+                // so let's add it to our fork point
+                self.update_fork_point(update.version[0], update.parents)
+
+                self.signal_file_needs_writing()
+            }, retry)
+
+            // send it stuff we have but it doesn't't
+            async function send_new_stuff() {
+                if (freed || closed) return
+                var q = []
+                var in_flight = new Map()
+                var max_in_flight = 10
+                var send_pump_lock = 0
+
+                async function send_pump() {
+                    send_pump_lock++
+                    if (send_pump_lock > 1) return
+                    try {
+                        if (freed || closed) return
+                        if (in_flight.size >= max_in_flight) return
+                        if (!q.length) {
+                            var frontier = self.fork_point
+                            for (var u of in_flight.values())
+                                frontier = extend_frontier(frontier, u.version[0], u.parents)
+
+                            var options = {
+                                parents: frontier,
+                                merge_type: 'dt',
+                                peer: self.peer,
+                                subscribe: u => u.version.length && q.push(u)
+                            }
+                            await braid_text.get(url, options)
+                            await braid_text.forget(url, options)
                         }
-                        await braid_text.get(url, options)
-                        await braid_text.forget(url, options)
-                    }
-                    while (q.length && in_flight.size < max_in_flight) {
-                        let u = q.shift()
-                        in_flight.set(u.version[0], u);
-                        (async () => {
-                            await initial_connect_promise
-                            if (freed) return
-                            await send_out({...u, peer: self.peer})
-                            if (freed) return
-                            in_flight.delete(u.version[0])
-                            setTimeout(send_pump, 0)
-                        })()
+                        while (q.length && in_flight.size < max_in_flight) {
+                            let u = q.shift()
+                            in_flight.set(u.version[0], u);
+                            (async () => {
+                                await initial_connect_promise
+                                if (freed || closed) return
+                                await send_out({...u, peer: self.peer})
+                                if (freed || closed) return
+                                in_flight.delete(u.version[0])
+                                setTimeout(send_pump, 0)
+                            })()
+                        }
+                    } finally {
+                        var retry = send_pump_lock > 1
+                        send_pump_lock = 0
+                        if (retry) setTimeout(send_pump, 0)
                     }
-                } finally {
-                    var retry = send_pump_lock > 1
-                    send_pump_lock = 0
-                    if (retry) setTimeout(send_pump, 0)
                 }
-            }
 
-            var initial_stuff = true
-            await wait_on(braid_text.get(url, braid_text_get_options = {
-                parents: fork_point,
-                merge_type: 'dt',
-                peer: self.peer,
-                subscribe: async (u) => {
-                    if (freed) return
-                    if (u.version.length) {
-                        self.signal_file_needs_writing()
-                        if (initial_stuff || in_flight.size < max_in_flight) q.push(u)
-                        send_pump()
-                    }
-                },
-            }))
-            initial_stuff = false
+                var initial_stuff = true
+                await wait_on(braid_text.get(url, braid_text_get_options = {
+                    parents: self.fork_point,
+                    merge_type: 'dt',
+                    peer: self.peer,
+                    subscribe: async (u) => {
+                        if (freed || closed) return
+                        if (u.version.length) {
+                            self.signal_file_needs_writing()
+                            if (initial_stuff || in_flight.size < max_in_flight) q.push(u)
+                            send_pump()
+                        }
+                    },
+                }))
+                initial_stuff = false
+            }
         }
 
         // for config and errors file, listen for web changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "braidfs",
-  "version": "0.0.94",
+  "version": "0.0.96",
   "description": "braid technology synchronizing files and webpages",
   "author": "Braid Working Group",
   "repository": "braid-org/braidfs",