braidfs 0.0.133 → 0.0.135

package/index.js

@@ -141,6 +141,10 @@ You can run it with:
 async function main() {
     process.on("unhandledRejection", (x) => console.log(`unhandledRejection: ${x.stack}`))
     process.on("uncaughtException", (x) => console.log(`uncaughtException: ${x.stack}`))
+
+    await braid_text.db_folder_init()
+    await braid_blob.init()
+
     require('http').createServer(async (req, res) => {
         try {
             // console.log(`${req.method} ${req.url}`)
@@ -216,45 +220,44 @@ async function main() {
         console.log(`daemon started on port ${config.port}`)
         console.log('!! only accessible from localhost !!')
 
-        sync_url('.braidfs/config').then(() => {
-            braid_text.get('.braidfs/config', {
-                subscribe: async update => {
-                    let prev = config
+        sync_url('.braidfs/config')
+        braid_text.get('.braidfs/config', {
+            subscribe: async update => {
+                let prev = config
 
-                    let x = await braid_text.get('.braidfs/config')
-                    try {
-                        config = JSON.parse(x)
-
-                        // did anything get deleted?
-                        var old_syncs = Object.entries(prev.sync).filter(x => x[1]).map(x => normalize_url(x[0]).replace(/^https?:\/\//, ''))
-                        var new_syncs = new Set(Object.entries(config.sync).filter(x => x[1]).map(x => normalize_url(x[0]).replace(/^https?:\/\//, '')))
-                        for (let url of old_syncs.filter(x => !new_syncs.has(x)))
-                            unsync_url(url)
-
-                        // sync all the new stuff
-                        for (let x of Object.entries(config.sync)) if (x[1]) sync_url(x[0])
-
-                        // if any auth stuff has changed,
-                        // have the appropriate connections reconnect
-                        let changed = new Set()
-                        // any old domains no longer exist?
-                        for (let domain of Object.keys(prev.cookies ?? {}))
-                            if (!config.cookies?.[domain]) changed.add(domain)
-                        // any new domains not like the old?
-                        for (let [domain, v] of Object.entries(config.cookies ?? {}))
-                            if (!prev.cookies?.[domain]
-                                || JSON.stringify(prev.cookies[domain]) !== JSON.stringify(v))
-                                changed.add(domain)
-                        // ok, have every domain which has changed reconnect
-                        for (let [path, x] of Object.entries(sync_url.cache))
-                            if (changed.has(path.split(/\//)[0].split(/:/)[0]))
-                                (await x).reconnect?.()
-                    } catch (e) {
-                        if (x !== '') console.log(`warning: config file is currently invalid.`)
-                        return
-                    }
+                let x = await braid_text.get('.braidfs/config')
+                try {
+                    config = JSON.parse(x)
+
+                    // did anything get deleted?
+                    var old_syncs = Object.entries(prev.sync).filter(x => x[1]).map(x => normalize_url(x[0]).replace(/^https?:\/\//, ''))
+                    var new_syncs = new Set(Object.entries(config.sync).filter(x => x[1]).map(x => normalize_url(x[0]).replace(/^https?:\/\//, '')))
+                    for (let url of old_syncs.filter(x => !new_syncs.has(x)))
+                        unsync_url(url)
+
+                    // sync all the new stuff
+                    for (let x of Object.entries(config.sync)) if (x[1]) sync_url(x[0])
+
+                    // if any auth stuff has changed,
+                    // have the appropriate connections reconnect
+                    let changed = new Set()
+                    // any old domains no longer exist?
+                    for (let domain of Object.keys(prev.cookies ?? {}))
+                        if (!config.cookies?.[domain]) changed.add(domain)
+                    // any new domains not like the old?
+                    for (let [domain, v] of Object.entries(config.cookies ?? {}))
+                        if (!prev.cookies?.[domain]
+                            || JSON.stringify(prev.cookies[domain]) !== JSON.stringify(v))
+                            changed.add(domain)
+                    // ok, have every domain which has changed reconnect
+                    for (let [path, x] of Object.entries(sync_url.cache))
+                        if (changed.has(path.split(/\//)[0].split(/:/)[0]))
+                            (await x).reconnect?.()
+                } catch (e) {
+                    if (x !== '') console.log(`warning: config file is currently invalid.`)
+                    return
                 }
-            })
+            }
         })
         sync_url('.braidfs/errors')
 
@@ -413,15 +416,12 @@ function unsync_url(url) {
     delete unsync_url.cache[url]
 }
 
-async function sync_url(url) {
+function sync_url(url) {
     // normalize url by removing any trailing /index/index/
     var normalized_url = normalize_url(url),
         wasnt_normal = normalized_url != url
     url = normalized_url
 
-    await braid_text.db_folder_init()
-    await braid_blob.init()
-
     var is_external_link = url.match(/^https?:\/\//),
         path = is_external_link ? url.replace(/^https?:\/\//, '') : url,
         fullpath = `${sync_base}/${path}`,
@@ -480,7 +480,6 @@ async function sync_url(url) {
             } else throw new Error(`unknown merge-type: ${self.merge_type}`)
         })()
     }
-    return
 
     async function detect_merge_type() {
         // special case for .braidfs/config and .braidfs/error
@@ -1157,24 +1156,41 @@ function ReconnectRateLimiter(get_wait_time) {
 async function fetch_http2(url, options = {}) {
     if (!fetch_http2.sessions) {
         fetch_http2.sessions = new Map()
-        process.on("exit", () => fetch_http2.sessions.forEach(s => s.close()))
+        process.on("exit", () => fetch_http2.sessions.forEach(s => s.session.close()))
     }
 
     var u = new URL(url)
     if (u.protocol !== "https:") return fetch(url, options)
 
     try {
-        var session = fetch_http2.sessions.get(u.origin)
-        if (!session || session.closed) {
-            session = require("http2").connect(u.origin, {
+        var sessionInfo = fetch_http2.sessions.get(u.origin)
+        if (!sessionInfo || sessionInfo.session.closed) {
+            var session = require("http2").connect(u.origin, {
                 rejectUnauthorized: options.rejectUnauthorized !== false,
             })
-            session.on("error", () => fetch_http2.sessions.delete(u.origin))
-            session.on("close", () => fetch_http2.sessions.delete(u.origin))
-            fetch_http2.sessions.set(u.origin, session)
+            sessionInfo = { session, pendingRejects: new Set() }
+
+            session.on("error", (e) => {
+                for (var f of sessionInfo.pendingRejects) f(e)
+                fetch_http2.sessions.delete(u.origin)
+            })
+            session.on("close", () => {
+                var e = new Error('Session closed')
+                for (var f of sessionInfo.pendingRejects) f(e)
+                fetch_http2.sessions.delete(u.origin)
+            })
+            fetch_http2.sessions.set(u.origin, sessionInfo)
         }
 
+        var session = sessionInfo.session
+
         return await new Promise((resolve, reject) => {
+            sessionInfo.pendingRejects.add(reject)
+
+            var responseTimeout = setTimeout(() => {
+                stream.destroy(new Error('Response timeout'))
+            }, options.responseTimeout || 10000)
+
             var stream = session.request({
                 ":method": options.method || "GET",
                 ":path": u.pathname + u.search,
@@ -1188,6 +1204,8 @@ async function fetch_http2(url, options = {}) {
                 { once: true })
 
             stream.on("response", headers => {
+                clearTimeout(responseTimeout)
+                sessionInfo.pendingRejects.delete(reject)
                 var status = +headers[":status"]
                 resolve({
                     ok: status >= 200 && status < 300,
@@ -1226,7 +1244,11 @@ async function fetch_http2(url, options = {}) {
                 })
             })
 
-            stream.on("error", reject)
+            stream.on("error", (err) => {
+                clearTimeout(responseTimeout)
+                sessionInfo.pendingRejects.delete(reject)
+                reject(err)
+            })
 
             var body = options.body
             if (!body) return stream.end()

package/package.json

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