braidfs 0.0.134 → 0.0.136

package/index.js

@@ -604,6 +604,12 @@ function sync_url(url) {
 
                         self.file_mtimeNs_str = '' + stat.mtimeNs
                         await save_meta()
+                        if (freed) return
+
+                        if (self.file_read_only !== null && await is_read_only(fullpath) !== self.file_read_only) {
+                            if (freed) return
+                            await set_read_only(fullpath, self.file_read_only)
+                        }
                     } catch (e) {
                         if (e.code === 'ENOENT') return null
                         throw e
@@ -648,11 +654,23 @@ function sync_url(url) {
                     ...(x => x && { Cookie: x })(config.cookies?.[new URL(url).hostname])
                 },
                 on_pre_connect: () => reconnect_rate_limiter.get_turn(url),
-                on_res: res => {
+                on_res: async res => {
                     if (freed) return
                     reconnect_rate_limiter.on_conn(url)
                     self.file_read_only = res.headers.get('editable') === 'false'
                     console.log(`connected to ${url}${self.file_read_only ? ' (readonly)' : ''}`)
+
+                    await within_fiber(fullpath, async () => {
+                        var fullpath = await get_fullpath()
+                        if (freed) return
+
+                        try {
+                            if (await is_read_only(fullpath) !== self.file_read_only) {
+                                if (freed) return
+                                await set_read_only(fullpath, self.file_read_only)
+                            }
+                        } catch (e) {}
+                    })
                 },
                 on_unauthorized: async () => {
                     console.log(`access denied: reverting local edits`)
@@ -1156,24 +1174,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,
@@ -1187,6 +1222,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,
@@ -1225,7 +1262,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.134",
+  "version": "0.0.136",
   "description": "braid technology synchronizing files and webpages",
   "author": "Braid Working Group",
   "repository": "braid-org/braidfs",