190 lines
7.4 KiB
JavaScript
190 lines
7.4 KiB
JavaScript
/* ============================================================================
|
||
* p2p-client.js — this device's side of peer-to-peer sharing
|
||
* (docs/p2p-architecture.md flows 2–3). window.P2PClient.
|
||
*
|
||
* start({ getSettings, getProfile }) called once from app.js boot()
|
||
* changed() a save/delete happened → re-report soon
|
||
* device() { deviceId, secret } or null
|
||
* authHeaders() { 'X-Device': … } for other P2P calls
|
||
*
|
||
* What it does, in order, each sync:
|
||
* 1. registers the device once (localStorage ytpDevice)
|
||
* 2. reconciles DeviceDB with the files really in OPFS (a record without a
|
||
* file is dropped; a file without a record is added as 'unhashed')
|
||
* 3. hashes 'unhashed' files and files not re-checked for 30 days, one at a
|
||
* time in hash-worker.js
|
||
* 4. reports the FULL holdings list (empty when sharing is off), answers the
|
||
* server's range challenges, and marks accepted files 'verified'
|
||
* P2P is ON by default: sharing runs unless settings.p2pShare === false or the
|
||
* server says P2P is disabled.
|
||
* ========================================================================== */
|
||
(function () {
|
||
'use strict';
|
||
|
||
const KEY = 'ytpDevice';
|
||
const REHASH_MS = 30 * 24 * 3600_000;
|
||
const RESYNC_MS = 6 * 3600_000;
|
||
let hooks = { getSettings: () => ({}), getProfile: () => '' };
|
||
let serverCfg = null;
|
||
let running = null;
|
||
let again = false;
|
||
let timer = null;
|
||
let lastSync = 0;
|
||
|
||
function device() {
|
||
try {
|
||
const d = JSON.parse(localStorage.getItem(KEY) || 'null');
|
||
return d && /^dev_[0-9a-f]{16}$/.test(d.deviceId) && /^[0-9a-f]{64}$/.test(d.secret) ? d : null;
|
||
} catch { return null; }
|
||
}
|
||
const authHeaders = () => { const d = device(); return d ? { 'X-Device': d.deviceId + '.' + d.secret } : {}; };
|
||
|
||
async function config() {
|
||
if (serverCfg) return serverCfg;
|
||
try {
|
||
const j = await (await fetch('/api/p2p/config')).json();
|
||
if (j && j.ok) serverCfg = j;
|
||
} catch { /* offline — try again next sync */ }
|
||
return serverCfg;
|
||
}
|
||
|
||
async function ensureDevice() {
|
||
const have = device();
|
||
if (have) return have;
|
||
const r = await fetch('/api/p2p/device', {
|
||
method: 'POST', headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify({ fingerprint: window.getFingerprint ? window.getFingerprint() : '', profile: hooks.getProfile() || '' }),
|
||
});
|
||
const j = await r.json();
|
||
if (!j || !j.ok) throw new Error((j && j.error) || 'device registration failed');
|
||
const d = { deviceId: j.deviceId, secret: j.secret };
|
||
try { localStorage.setItem(KEY, JSON.stringify(d)); } catch { /* storage blocked */ }
|
||
return d;
|
||
}
|
||
|
||
function hashInWorker(name) {
|
||
return new Promise((resolve) => {
|
||
let w;
|
||
try { w = new Worker('/hash-worker.js'); } catch { resolve(null); return; }
|
||
w.onmessage = (e) => { w.terminate(); resolve(e.data && e.data.ok ? e.data : null); };
|
||
w.onerror = () => { w.terminate(); resolve(null); };
|
||
w.postMessage({ name });
|
||
});
|
||
}
|
||
|
||
async function sha256Range(videoId, offset, length) {
|
||
const bytes = window.OPFS && window.OPFS.readRange ? await window.OPFS.readRange(videoId, offset, length) : null;
|
||
if (!bytes) return null;
|
||
return window.Sha256.hex(bytes);
|
||
}
|
||
|
||
// DeviceDB ⇄ OPFS. Returns the records that describe a real file.
|
||
async function reconcile() {
|
||
const files = await window.OPFS.listVideos({ strict: true });
|
||
const byId = new Map(files.map((f) => [f.id, f]));
|
||
const recs = await window.DeviceDB.listFiles();
|
||
const out = [];
|
||
for (const r of recs) {
|
||
const f = byId.get(r.videoId);
|
||
if (!f) { await window.DeviceDB.deleteFile(r.videoId); continue; }
|
||
if (f.size !== r.size && r.size) { r.cid = null; r.state = 'unhashed'; r.size = f.size; await window.DeviceDB.putFile(r); }
|
||
r.name = f.name;
|
||
out.push(r);
|
||
byId.delete(r.videoId);
|
||
}
|
||
for (const f of byId.values()) {
|
||
if (String(f.id).startsWith('edit_')) continue; // edited cuts are never shared
|
||
const r = { videoId: f.id, cid: null, size: f.size, savedAt: Date.now(), lastCheckedAt: 0, state: 'unhashed' };
|
||
await window.DeviceDB.putFile(r);
|
||
out.push({ ...r, name: f.name });
|
||
}
|
||
return out;
|
||
}
|
||
|
||
async function hashPending(recs) {
|
||
const now = Date.now();
|
||
for (const r of recs) {
|
||
if (r.state !== 'unhashed' && now - (r.lastCheckedAt || 0) < REHASH_MS) continue;
|
||
const h = await hashInWorker(r.name);
|
||
if (!h) continue;
|
||
const changedCid = h.sha256 !== r.cid;
|
||
r.cid = h.sha256;
|
||
r.size = h.size;
|
||
r.lastCheckedAt = Date.now();
|
||
if (changedCid || r.state === 'unhashed') r.state = 'unverified';
|
||
await window.DeviceDB.putFile(r);
|
||
}
|
||
}
|
||
|
||
async function report(recs, dev) {
|
||
const share = hooks.getSettings().p2pShare !== false;
|
||
const items = recs.filter((r) => r.cid).map((r) => ({ cid: r.cid, size: r.size, videoId: r.videoId }));
|
||
const r = await fetch('/api/p2p/holdings', {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json', 'X-Device': dev.deviceId + '.' + dev.secret },
|
||
body: JSON.stringify({ share, items: share ? items : [], profile: hooks.getProfile() || '' }),
|
||
});
|
||
if (r.status === 401) { try { localStorage.removeItem(KEY); } catch { /* ignore */ } return null; }
|
||
const j = await r.json();
|
||
if (!j || !j.ok) return null;
|
||
const accepted = new Set(j.accepted || []);
|
||
for (const rec of recs) {
|
||
if (rec.cid && accepted.has(rec.cid) && rec.state !== 'verified') { rec.state = 'verified'; await window.DeviceDB.putFile(rec); }
|
||
}
|
||
const answers = [];
|
||
for (const ch of j.challenges || []) {
|
||
const rec = recs.find((x) => x.cid === ch.cid);
|
||
if (!rec) continue;
|
||
const hex = await sha256Range(rec.videoId, ch.offset, ch.length);
|
||
if (hex) answers.push({ ...ch, sha256: hex });
|
||
}
|
||
if (answers.length) {
|
||
await fetch('/api/p2p/challenge', {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json', 'X-Device': dev.deviceId + '.' + dev.secret },
|
||
body: JSON.stringify({ answers }),
|
||
}).catch(() => {});
|
||
}
|
||
return j;
|
||
}
|
||
|
||
async function syncOnce() {
|
||
if (!window.OPFS || !window.OPFS.isSupported() || !window.DeviceDB || !window.Sha256) return null;
|
||
if (navigator.onLine === false) return null;
|
||
const cfg = await config();
|
||
if (!cfg || !cfg.enabled) return null;
|
||
const dev = await ensureDevice();
|
||
const recs = await reconcile();
|
||
await hashPending(recs);
|
||
const res = await report(recs, dev);
|
||
lastSync = Date.now();
|
||
return res;
|
||
}
|
||
|
||
// One sync at a time; a request during a sync schedules exactly one more.
|
||
function sync() {
|
||
if (running) { again = true; return running; }
|
||
running = syncOnce().catch(() => null).finally(() => {
|
||
running = null;
|
||
if (again) { again = false; sync(); }
|
||
});
|
||
return running;
|
||
}
|
||
|
||
function changed() {
|
||
clearTimeout(timer);
|
||
timer = setTimeout(sync, 5000);
|
||
}
|
||
|
||
function start(h) {
|
||
hooks = { ...hooks, ...(h || {}) };
|
||
const idle = window.requestIdleCallback || ((fn) => setTimeout(fn, 1));
|
||
setTimeout(() => idle(() => sync()), 8000);
|
||
document.addEventListener('visibilitychange', () => {
|
||
if (document.visibilityState === 'visible' && Date.now() - lastSync > RESYNC_MS) sync();
|
||
});
|
||
}
|
||
|
||
window.P2PClient = { start, changed, sync, device, authHeaders, config };
|
||
}());
|