diff options
Diffstat (limited to 'packages/meshbay-hub')
4 files changed, 404 insertions, 3 deletions
diff --git a/packages/meshbay-hub/src/meshbay_hub/static/file-utils.js b/packages/meshbay-hub/src/meshbay_hub/static/file-utils.js index 294455a..585558f 100644 --- a/packages/meshbay-hub/src/meshbay_hub/static/file-utils.js +++ b/packages/meshbay-hub/src/meshbay_hub/static/file-utils.js @@ -48,6 +48,11 @@ const CHUNK_SIZE = 1024 * 1024; // fragmented MP4. A stream that arrives in gulps has no margin for a network // that hesitates, and looks like a hang while it is quiet. const PIPELINE_WINDOW = 8; +// A leased download with at least this much left opens the transport's extra +// connections (`lanes` in transport.js). Below it the handshakes, half a second +// to a second each, cost more than they save; lanes already open are used +// whatever the size. +const LANE_MIN_CHUNKS = 64; // The most this code will ever collect in the page. // @@ -392,10 +397,24 @@ async function pipelinedDownload(transport, gekKey, fileId, totalChunks, onChunk let nextSend = fromChunk, nextRecv = fromChunk; const inflight = new Array(totalChunks); + // Chunk i goes over lane i modulo the lanes open at that moment, two chunks + // in flight per lane so none waits on the slowest. Order is restored below, + // where each chunk is awaited by its index. A lane that fails a request is + // dropped and the chunk asked for again on the main connection, which has + // the retries and the reconnect. const fire = () => { - while (nextSend < totalChunks && nextSend - nextRecv < PIPELINE_WINDOW) { - inflight[nextSend] = _fetchChunkResilient(transport, fileId, nextSend, tr, - signal); + const lanes = (tr && transport.lanes) + ? transport.lanes(totalChunks - nextRecv >= LANE_MIN_CHUNKS) : [transport]; + const depth = Math.max(PIPELINE_WINDOW, 2 * lanes.length); + while (nextSend < totalChunks && nextSend - nextRecv < depth) { + const index = nextSend; + const lane = lanes[index % lanes.length]; + inflight[index] = lane === transport + ? _fetchChunkResilient(transport, fileId, index, tr, signal) + : lane.fetchChunk(fileId, index, tr).catch(() => { + transport.dropLane(lane); + return _fetchChunkResilient(transport, fileId, index, tr, signal); + }); nextSend++; } }; diff --git a/packages/meshbay-hub/src/meshbay_hub/static/transport.js b/packages/meshbay-hub/src/meshbay_hub/static/transport.js index e995ffe..ee6645f 100644 --- a/packages/meshbay-hub/src/meshbay_hub/static/transport.js +++ b/packages/meshbay-hub/src/meshbay_hub/static/transport.js @@ -436,6 +436,25 @@ const JOIN_REFUSALS = { */ const LEASE_WATCHDOG_MS = 60000; +// How many connections a large download is spread over, this one included. +// +// One WebRTC connection carries 5 to 6 MB/s at 22 ms whatever the line can do: +// the browser receives on a UDP socket with a 64 KB kernel buffer, a burst +// overflows it, and the node's SCTP sender halves its window at every loss. +// The ceiling is per connection, so the way past it is more connections, and +// they have to be separate peer connections: several channels on one share +// its socket, its association and its window. Measured against a browser, +// one sender: 1 connection 5 to 6 MB/s, 4 about 19, 8 between 27 and 34, and +// 16 no more than that (the node's sender is one Python process). +const DOWNLOAD_LANES = 8; +// A lane left unused this long is closed: each one is a peer connection the +// node holds open. +const LANE_IDLE_MS = 30000; +// After a lane failed to open, how long before another is tried. `lanes()` is +// asked at every chunk, and without this a node that refuses would be sent an +// offer per chunk. +const LANE_RETRY_MS = 30000; + class Lease { constructor(transport, tr, kind, bytes, chunks, onState) { this.transport = transport; @@ -566,6 +585,15 @@ class MeshBayTransport { this._inFlightUploads = new Set(); // tr → Lease. A transfer's slot on the node, from the client's side. this._leases = new Map(); + // The extra connections a large download is spread over (see `lanes`). + // `_lane` is true on those connections themselves, which open none of + // their own and are closed rather than reconnected. + this._lanes = []; + this._lanesOpening = 0; + this._lanesUsedAt = 0; + this._lanesTimer = 0; + this._laneRetryAt = 0; + this._lane = false; // Set once close() runs — stops the automatic reconnect from firing on a // connection the caller tore down on purpose (leaving the group, page // unload), which would otherwise race back in right as everything else @@ -1433,6 +1461,9 @@ class MeshBayTransport { */ _reconnect() { if (this._closed) return Promise.resolve(); + // A lane that failed is dropped: the download falls back to the main + // connection and `lanes` opens another. + if (this._lane) { this.close(); return Promise.resolve(); } if (!this._reconnectPromise) { this._reconnectPromise = this._reconnectLoop().finally(() => { this._reconnectPromise = null; @@ -1550,6 +1581,72 @@ class MeshBayTransport { return lease; } + /** + * The connections a leased download may read over: this one first, then + * every lane that is open right now. + * + * With `open`, the missing lanes are opened in the background, and they join + * the answer of a later call: a download starts on this connection at once + * and widens as they land. A lane is this connection again (same node, same + * group, same identity, same device), so the node serves a chunk request on + * it under a lease this connection opened (docs/MESHBAY_DESIGN.md §5.5). + * The lease itself, and everything else, stays here. + */ + lanes(open = false) { + if (this._lane || this._closed) return [this]; + for (const lane of this._lanes.filter((l) => !l.connected)) this.dropLane(lane); + if (open || this._lanes.length) { + this._lanesUsedAt = Date.now(); + if (!this._lanesTimer) { + this._lanesTimer = setInterval(() => { + if (Date.now() - this._lanesUsedAt > LANE_IDLE_MS) this._closeLanes(); + }, LANE_IDLE_MS / 2); + } + } + if (open && this._connected && Date.now() >= this._laneRetryAt) { + while (this._lanes.length + this._lanesOpening < DOWNLOAD_LANES - 1) { + this._openLane(); + } + } + return [this, ...this._lanes]; + } + + async _openLane() { + this._lanesOpening += 1; + const lane = new MeshBayTransport(this._hubUrl, this._lastToken); + lane._lane = true; + try { + const args = this._connectArgs; + const token = this._onNeedToken ? await this._onNeedToken() : this._lastToken; + await lane.connect(args.nodeId, token, args.groupId, this._gekRaw, + this._identity, args.bundleKey, args.username, + args.userId, undefined, undefined, + args.joinNodePk, args.nodePk); + // Closed, or gone idle, while this one was negotiating. + if (this._closed || !this._lanesTimer) lane.close(); + else this._lanes.push(lane); + } catch (e) { + console.warn('[MeshBay] could not open a download lane:', e && e.message); + this._laneRetryAt = Date.now() + LANE_RETRY_MS; + lane.close(); + } finally { + this._lanesOpening -= 1; + } + } + + /** Close one lane, e.g. one that failed a request. */ + dropLane(lane) { + const at = this._lanes.indexOf(lane); + if (at >= 0) this._lanes.splice(at, 1); + lane.close(); + } + + _closeLanes() { + clearInterval(this._lanesTimer); + this._lanesTimer = 0; + for (const lane of this._lanes.splice(0)) lane.close(); + } + /** Re-ask for every live lease. Called after a reconnect. */ _reopenTransfers() { for (const lease of this._leases.values()) { @@ -1638,6 +1735,7 @@ class MeshBayTransport { // only skips reconnecting because of this flag, not because "closed" is // absent from its own trigger condition. this._closed = true; + this._closeLanes(); document.removeEventListener('visibilitychange', this._onVisibilityWake); this._wakeReconnect(); if (this._diagCleanup) { this._diagCleanup(); this._diagCleanup = null; } diff --git a/packages/meshbay-hub/tests/harness/download_lanes_harness.mjs b/packages/meshbay-hub/tests/harness/download_lanes_harness.mjs new file mode 100644 index 0000000..4f9b1da --- /dev/null +++ b/packages/meshbay-hub/tests/harness/download_lanes_harness.mjs @@ -0,0 +1,179 @@ +// Run the SHIPPED `pipelinedDownload` over the SHIPPED `MeshBayTransport.lanes` +// against a fake clock and a fake node, and see which connection carried which +// chunk. +// +// What is modelled is the node and the network: `connect` (where an offer is +// made) and `fetchChunk` (a megabyte that takes time). The lanes, the pipeline, +// the retry path and the idle close are the shipped code, the first by +// executing transport.js whole and the second lifted out of file-utils.js as +// text. +// +// Usage: node download_lanes_harness.mjs <file-utils.js> <transport sources> <json> +import { readFileSync } from 'fs'; +import { delimiter } from 'path'; + +const utils = readFileSync(process.argv[2], 'utf8'); +const transportSrc = process.argv[3].split(delimiter) + .map((p) => readFileSync(p, 'utf8')).join('\n'); +const { + chunks = 200, + tr = 'lease', + connectMs = 800, + chunkMs = 150, + refuseLanes = false, // every lane's connect fails + failLaneAfter = -1, // the first lane to open fails every request after this many + closeAt = -1, // close the main connection at this time +} = JSON.parse(process.argv[4] || '{}'); + +for (const level of ['log', 'warn', 'error', 'info', 'debug']) { + console[level] = (...args) => process.stderr.write(args.join(' ') + '\n'); +} + +// A download that fails leaves the chunks still in flight to reject with nobody +// waiting on them, which a browser logs and Node would die of. +process.on('unhandledRejection', () => {}); + +// ── The clock ──────────────────────────────────────────────────────────────── + +let now = 0; +let nextId = 1; +let timers = []; +globalThis.setTimeout = (fn, ms) => { + const t = { at: now + (ms || 0), fn, id: nextId++ }; + timers.push(t); + return t.id; +}; +globalThis.setInterval = (fn, ms) => { + const t = { at: now + ms, fn, id: nextId++, every: ms }; + timers.push(t); + return t.id; +}; +globalThis.clearTimeout = (id) => { timers = timers.filter((t) => t.id !== id); }; +globalThis.clearInterval = globalThis.clearTimeout; +Date.now = () => now; +const flush = async () => { for (let i = 0; i < 50; i++) await Promise.resolve(); }; +async function run(until) { + await flush(); + while (timers.length) { + const due = timers.reduce((a, b) => (b.at < a.at ? b : a)); + if (due.at > until) break; + if (due.every) due.at += due.every; + else timers = timers.filter((t) => t !== due); + now = Math.max(now, due.every ? due.at - due.every : due.at); + due.fn(); + await flush(); + } + now = until; +} +const sleep = (ms) => new Promise((r) => setTimeout(r, ms)); + +// ── The shipped transport, with a node behind it ───────────────────────────── + +globalThis.window = globalThis; +globalThis.addEventListener = () => {}; +globalThis.removeEventListener = () => {}; +globalThis.location = { hash: '' }; +globalThis.document = { + addEventListener() {}, removeEventListener() {}, visibilityState: 'visible', +}; +new Function(transportSrc)(); +const Transport = window.MeshBayTransport; + +let offers = 0; +let inFlight = 0; +let peakInFlight = 0; +let nextName = 1; +const servedBy = []; // chunk index -> the connections asked for it, in order +const connectArgs = []; +const opened = []; + +Transport.prototype.connect = async function connect(...args) { + offers += 1; + this.name = `lane${nextName++}`; + connectArgs.push(args); + opened.push(this); + await sleep(connectMs); + if (refuseLanes) throw new Error('Node is at its peer-connection limit'); + this._connected = true; + this.asked = 0; +}; +Transport.prototype.fetchChunk = async function fetchChunk(fileId, index, lease) { + (servedBy[index] = servedBy[index] || []).push(this.name); + this.asked = (this.asked || 0) + 1; + inFlight += 1; + peakInFlight = Math.max(peakInFlight, inFlight); + try { + await sleep(chunkMs); + if (!this._connected) throw new Error('Transport closed'); + if (this.name === 'lane1' && failLaneAfter >= 0 && this.asked > failLaneAfter) { + throw new Error('Response timeout'); + } + return { ct: new Uint8Array([index & 255]), nonce: index, tr: lease }; + } finally { + inFlight -= 1; + } +}; + +const main = new Transport('https://hub.invalid', 'token'); +main.name = 'main'; +main._connected = true; +main._lastToken = 'token'; +main._gekRaw = new Uint8Array(32); +main._identity = { the: 'identity' }; +main._connectArgs = { + nodeId: 'node', groupId: 'group', bundleKey: 'bundle', username: 'u', + userId: 'uid', joinCode: 'never-again', joinNodePk: '', nodePk: 'pk', +}; + +// ── The shipped pipeline ───────────────────────────────────────────────────── + +const constant = (name) => utils.match(new RegExp(`^const ${name} = [^;]+;`, 'm'))[0]; +const from = utils.indexOf('const CHUNK_RETRY_ATTEMPTS'); +const to = utils.indexOf('async function downloadEntry'); +const { pipelinedDownload } = new Function('window', 't', ` + ${constant('PIPELINE_WINDOW')} + ${constant('LANE_MIN_CHUNKS')} + ${utils.slice(from, utils.lastIndexOf('/**', to))} + return { pipelinedDownload };`)( + { MeshBayCrypto: { decryptChunkBin: async (_k, _f, index) => new Uint8Array([index & 255]) } }, + (key) => key); + +const written = []; +const writable = { write: async (bytes) => { written.push(bytes[0]); } }; +let outcome = 'pending'; +pipelinedDownload(main, 'gek', 'f'.repeat(64), chunks, null, writable, null, tr) + .then(() => { outcome = 'done'; }, (err) => { outcome = `failed: ${err.message}`; }); + +let lanesLeftOpenByClose = null; +if (closeAt >= 0) { + await run(closeAt); + main.close(); + await run(closeAt + 2 * connectMs); + lanesLeftOpenByClose = opened.filter((lane) => !lane._closed).length; +} +// Long enough for any download here, then past the idle close. +await run(240000); + +const inOrder = written.every((b, i) => b === (i & 255)); +const carried = {}; +for (const names of servedBy) { + const last = names[names.length - 1]; + carried[last] = (carried[last] || 0) + 1; +} +process.stdout.write(JSON.stringify({ + outcome, offers, peakInFlight, carried, + written: written.length, inOrder, + retried: servedBy.filter((names) => names.length > 1).length, + lanesAfterIdle: main._lanes.length, + // What a lane was connected with: the group, the identity and the key of the + // main connection, and never its join code. + laneArgs: connectArgs.length ? { + groupId: connectArgs[0][2], sameGek: connectArgs[0][3] === main._gekRaw, + sameIdentity: connectArgs[0][4] === main._identity, + joinCode: connectArgs[0][8] === undefined ? null : connectArgs[0][8], + nodePk: connectArgs[0][11], + } : null, + lanesLeftOpenByClose, + lanesLeftOpen: opened.filter((lane) => !lane._closed).length, + timersLeft: timers.length, +})); diff --git a/packages/meshbay-hub/tests/test_download_lanes.py b/packages/meshbay-hub/tests/test_download_lanes.py new file mode 100644 index 0000000..f133f5c --- /dev/null +++ b/packages/meshbay-hub/tests/test_download_lanes.py @@ -0,0 +1,105 @@ +""" +A large download is spread over several connections to its node. + +One WebRTC connection carries 5 to 6 MB/s at 22 ms on a line that carries 47: +the browser's UDP socket has a 64 KB kernel buffer, a burst overflows it, and +the node's SCTP sender halves its window at every loss. The ceiling is per +connection, so `MeshBayTransport.lanes` opens more of them and +`pipelinedDownload` sends chunk i over lane i modulo their number. + +These run the shipped lanes (transport.js, executed whole) under the shipped +pipeline (lifted out of file-utils.js as text) against a fake clock and a fake +node. See harness/download_lanes_harness.mjs. +""" + +import json +import os +import shutil +import subprocess +from pathlib import Path + +import pytest +from spa_source import classic_scripts + +STATIC = Path(__file__).resolve().parents[1] / "src" / "meshbay_hub" / "static" +FILE_UTILS = STATIC / "file-utils.js" +HARNESS = Path(__file__).parent / "harness" / "download_lanes_harness.mjs" + +pytestmark = pytest.mark.skipif( + shutil.which("node") is None or not FILE_UTILS.exists(), + reason="node or the SPA sources are not available") + + +def _run(**cfg) -> dict: + transport = os.pathsep.join( + str(STATIC / name) for name in classic_scripts() + if name.startswith("transport")) + proc = subprocess.run( + ["node", str(HARNESS), str(FILE_UTILS), transport, json.dumps(cfg)], + capture_output=True, text=True, encoding="utf-8") + assert proc.returncode == 0, proc.stderr + return json.loads(proc.stdout) + + +def test_a_large_download_runs_over_eight_connections_in_order(): + out = _run(chunks=200) + assert out["outcome"] == "done" + assert out["written"] == 200 and out["inOrder"] + assert out["offers"] == 7, "seven lanes beside the connection already open" + lanes = {k: v for k, v in out["carried"].items() if k != "main"} + assert len(lanes) == 7 and min(lanes.values()) >= 15, out["carried"] + # It starts on the main connection without waiting for the lanes. + assert out["carried"]["main"] > max(lanes.values()) + assert out["peakInFlight"] == 16, "two chunks in flight per connection" + + +def test_a_lane_is_the_main_connection_again_and_never_a_join(): + args = _run(chunks=200)["laneArgs"] + assert args == {"groupId": "group", "sameGek": True, "sameIdentity": True, + "joinCode": None, "nodePk": "pk"} + + +def test_a_small_download_opens_nothing(): + out = _run(chunks=10) + assert out["outcome"] == "done" and out["offers"] == 0 + assert out["peakInFlight"] == 8 + + +def test_a_read_without_a_lease_opens_nothing(): + """A preview or a track is not a transfer, and the node would count each + lane's read against that lane's own leaseless ceiling.""" + out = _run(chunks=200, tr="") + assert out["outcome"] == "done" and out["offers"] == 0 + assert out["carried"] == {"main": 200} + + +def test_a_lane_that_fails_is_dropped_and_its_chunks_asked_again(): + out = _run(chunks=200, failLaneAfter=3) + assert out["outcome"] == "done" + assert out["written"] == 200 and out["inOrder"] + assert out["retried"] >= 1 + assert out["carried"]["lane1"] <= 3 + assert out["offers"] == 8, "the dropped lane is replaced, once" + + +def test_a_node_that_refuses_lanes_costs_one_round_of_offers(): + """`lanes` is asked at every chunk: without the retry delay a refusing node + would be sent an offer per chunk.""" + out = _run(chunks=200, refuseLanes=True) + assert out["outcome"] == "done" + assert out["carried"] == {"main": 200} + assert out["offers"] == 7 + + +def test_idle_lanes_are_closed(): + out = _run(chunks=200) + assert out["lanesAfterIdle"] == 0 and out["lanesLeftOpen"] == 0 + assert out["timersLeft"] == 0, "the idle timer outlived the lanes" + + +@pytest.mark.parametrize("close_at", [400, 1500]) +def test_closing_the_connection_closes_its_lanes(close_at): + """At 400 ms the lanes are still negotiating, at 1500 they are carrying.""" + out = _run(chunks=2000, closeAt=close_at) + assert out["lanesLeftOpenByClose"] == 0 + assert out["offers"] == 7, "a closed connection opened more lanes" |