braidfs 0.0.97 → 0.0.100

package/index.js

@@ -4,6 +4,8 @@ var { diff_main } = require(`${__dirname}/diff.js`),
     braid_text = require("braid-text"),
     braid_fetch = require('braid-http').fetch
 
+braid_fetch.set_fetch(fetch_http2)
+
 var sync_base = `${require('os').homedir()}/http`,
     braidfs_config_dir = `${sync_base}/.braidfs`,
     braidfs_config_file = `${braidfs_config_dir}/config`,
@@ -14,7 +16,8 @@ var temp_folder = `${braidfs_config_dir}/temp`
 
 var config = null,
     watcher_misses = 0,
-    reconnect_rate_limiter = new ReconnectRateLimiter()
+    reconnect_rate_limiter = new ReconnectRateLimiter(() =>
+        config?.reconnect_delay_ms ?? 3000)
 
 if (require('fs').existsSync(sync_base)) {
     try {
@@ -40,6 +43,7 @@ if (require('fs').existsSync(sync_base)) {
         cookies: { 'example.com': 'secret_pass' },
         port: 45678,
         scan_interval_ms: 1000 * 20,
+        reconnect_delay_ms: 1000 * 3
     }
     require('fs').mkdirSync(braidfs_config_dir, { recursive: true })
     require('fs').writeFileSync(braidfs_config_file, JSON.stringify(config, null, 4))
@@ -322,7 +326,10 @@ async function scan_files() {
     scan_files.running = true
     while (scan_files.do_again) {
         scan_files.do_again = false
-        console.log(`scan files..`)
+        var timestamp = new Date().toLocaleTimeString(
+            'en-US', {minute: '2-digit', second: '2-digit', hour: '2-digit'}
+        )
+        console.log(`scan files.. `, timestamp)
         if (await f(sync_base))
             on_watcher_miss(`scanner picked up a change that the watcher should have gotten`, false)
     }
@@ -823,7 +830,7 @@ async function sync_url(url) {
                     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!`)
+                        if (r.ok) return console.log(`[find_fork_point] "${url.split('/').pop()}" has our latest fork point, hooray!`)
                     }
 
                     // otherwise let's binary search for new fork point..
@@ -881,8 +888,8 @@ async function sync_url(url) {
                 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')}`)
+                console.log(`connected to ${url}`.padEnd(70, ' ')
+                            + `(editable: ${res.headers.get('editable')})`)
 
                 reconnect_rate_limiter.on_conn(url)
 
@@ -1010,7 +1017,7 @@ async function ensure_path(path) {
     }
 }
 
-function ReconnectRateLimiter(wait_time = 1000) {
+function ReconnectRateLimiter(get_wait_time) {
     var self = {}
 
     self.conns = new Map() // Map<host, Set<url>>
@@ -1027,7 +1034,7 @@ function ReconnectRateLimiter(wait_time = 1000) {
         var now = Date.now()
         var my_last_turn = () => self.conns.size === 0 ? self.last_turn : self.qs[0].last_turn
 
-        while (self.qs.length && now >= my_last_turn() + wait_time) {
+        while (self.qs.length && now >= my_last_turn() + get_wait_time()) {
             var x = self.qs.shift()
             if (!x.turns.length) {
                 self.host_to_q.delete(x.host)
@@ -1041,7 +1048,7 @@ function ReconnectRateLimiter(wait_time = 1000) {
 
         if (self.qs.length)
             self.timer = setTimeout(process, Math.max(0,
-                my_last_turn() + wait_time - now))
+                my_last_turn() + get_wait_time() - now))
     }
 
     self.get_turn = async (url) => {
@@ -1090,6 +1097,98 @@ function ReconnectRateLimiter(wait_time = 1000) {
     return self
 }
 
+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()))
+    }
+
+    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, {
+                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)
+        }
+
+        return await new Promise((resolve, reject) => {
+            var stream = session.request({
+                ":method": options.method || "GET",
+                ":path": u.pathname + u.search,
+                ":scheme": "https",
+                ":authority": u.host,
+                ...Object.fromEntries(options.headers || []),
+            })
+
+            options.signal?.addEventListener("abort",
+                () => stream.destroy(new Error("Request aborted")),
+                { once: true })
+
+            stream.on("response", headers => {
+                var status = +headers[":status"]
+                resolve({
+                    ok: status >= 200 && status < 300,
+                    status,
+                    statusText: "",
+                    headers: new Headers(Object.fromEntries(
+                        Object.entries(headers).filter(([k]) =>
+                            typeof k === "string" && !k.startsWith(":")))),
+                    body: new ReadableStream({
+                        start(ctrl) {
+                            stream.on("data", x => ctrl.enqueue(new Uint8Array(x)))
+                            stream.on("end", () => ctrl.close())
+                            stream.on("error", err => ctrl.error(err))
+                        },
+                        cancel() { stream.destroy() },
+                    }),
+                    bodyUsed: false,
+                    async _consumeBody() {
+                        this.bodyUsed = true
+                        var chunks = []
+                        var reader = this.body.getReader()
+
+                        while (true) {
+                            var { done, value } = await reader.read()
+                            if (done) break
+                            chunks.push(value)
+                        }
+                        return Buffer.concat(chunks.map((c) => (Buffer.isBuffer(c) ? c : Buffer.from(c))))
+                    },
+                    async text() { return (await this._consumeBody()).toString() },
+                    async json() { return JSON.parse(await this.text()) },
+                    async arrayBuffer() {
+                        var b = await this._consumeBody()
+                        return b.buffer.slice(b.byteOffset, b.byteOffset + b.byteLength)
+                    },
+                })
+            })
+
+            stream.on("error", reject)
+
+            var body = options.body
+            if (!body) return stream.end()
+
+            if (body instanceof Uint8Array || Buffer.isBuffer(body)) stream.end(body)
+            else if (body instanceof Blob) body.arrayBuffer()
+                .then((b) => stream.end(Buffer.from(b)))
+                .catch(reject)
+            else stream.end(typeof body === "string" ? body : JSON.stringify(body))
+        })
+    } catch (err) {
+        if (err.code?.includes("HTTP2") || err.message?.includes("HTTP/2")) {
+            console.log("HTTP/2 failed, falling back to HTTP/1.1:", err.message)
+            return fetch(url, options)
+        }
+        throw err
+    }
+}
+
 ////////////////////////////////
 
 function normalize_url(url) {

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "braidfs",
-  "version": "0.0.97",
+  "version": "0.0.100",
   "description": "braid technology synchronizing files and webpages",
   "author": "Braid Working Group",
   "repository": "braid-org/braidfs",
   "homepage": "https://braid.org",
   "dependencies": {
-    "braid-http": "^1.3.75",
+    "braid-http": "^1.3.76",
     "braid-text": "^0.2.30",
     "chokidar": "^3.6.0"
   },