wenay-common2 1.0.69 → 1.0.70

package/replay/socket-replay.test.ts

@@ -0,0 +1,199 @@
+// ============================================================
+//  replay/socket-replay.test.ts
+//
+//  Слой B через НАСТОЯЩИЙ Socket.IO localhost WebSocket:
+//  зеркало стора по replay-линии (keyframe + seq-дельты).
+//  Запуск:
+//      npx ts-node replay/socket-replay.test.ts
+// ============================================================
+
+import express from 'express'
+import {createServer} from 'http'
+import type {AddressInfo} from 'net'
+import {Server as SocketIOServer} from 'socket.io'
+import {io} from 'socket.io-client'
+import {listen as createListenPair} from '../src/Common/events/Listen'
+import {createRpcClientHub} from '../src/Common/rcp/rpc-clientHub'
+import {createRpcServerAuto} from '../src/Common/rcp/rpc-server-auto'
+import {createStore, StorePatch} from '../src/Common/Observe/store'
+import {flushReactive} from '../src/Common/Observe/reactive'
+import {exposeStoreReplay, syncStoreReplay} from '../src/Common/Observe/store-replay'
+import {ReplayRemote} from '../src/Common/events/replay-index'
+
+let fails = 0
+const ok = (condition: any, message: string) => {
+    if (!condition) { fails++; console.log('  FAIL', message) }
+    else console.log('  OK  ', message)
+}
+const delay = (ms: number) => new Promise<void>(r => setTimeout(r, ms))
+const json = (v: any) => JSON.stringify(v)
+
+async function waitFor(label: string, cond: () => boolean) {
+    for (let i = 0; i < 120; i++) {
+        if (cond()) return
+        await delay(25)
+    }
+    throw new Error(`timeout: ${label}`)
+}
+
+type World = {
+    units: Record<string, {hp: number, x: number}>
+    tick: number
+}
+
+async function startRealServer(object: object) {
+    const app = express()
+    const httpServer = createServer(app)
+    const ioServer = new SocketIOServer(httpServer, {maxHttpBufferSize: 1e8})
+    ioServer.on('connection', socket => {
+        const [disconnect, disconnectListen] = createListenPair<[]>()
+        socket.on('disconnect', () => disconnect())
+        createRpcServerAuto({
+            socket: {
+                emit: (key, data) => socket.emit(key, data),
+                on: (key, cb) => socket.on(key, cb),
+            },
+            socketKey: 'replay-store',
+            object,
+            disconnectListen,
+        })
+    })
+    await new Promise<void>((resolve, reject) => {
+        httpServer.once('error', reject)
+        httpServer.listen(0, '127.0.0.1', resolve)
+    })
+    const port = (httpServer.address() as AddressInfo).port
+    console.log(`  [server] listening on 127.0.0.1:${port}`)
+    return {
+        port,
+        close: () => new Promise<void>(resolve => {
+            ioServer.close()
+            httpServer.close(() => resolve())
+        }),
+    }
+}
+
+async function startRealClient<T extends object>(port: number) {
+    const hub = createRpcClientHub(
+        () => io(`http://127.0.0.1:${port}`, {transports: ['websocket'], forceNew: true}),
+        r => ({api: r<T>('replay-store')}) as const,
+    )
+    const clients = await hub.setToken(null)
+    await clients.api.readyStrict()
+    return {
+        client: clients.api,
+        close: () => hub.socket?.disconnect?.(),
+    }
+}
+
+async function main() {
+    console.log('\n[socket-replay] store mirror over a real Socket.IO wire')
+
+    const backend = createStore<World>({units: {alpha: {hp: 100, x: 0}}, tick: 0}, {drain: 'micro'})
+    const exposed = exposeStoreReplay(backend, {history: 6})
+
+    // счётчики серверной цены: pull-ов быть не должно, keyframe — только по fallback
+    const counters = {get: 0, since: 0, keyframe: 0}
+    const facade = {
+        ...exposed.api,
+        get: (mask?: any) => { counters.get++; return exposed.api.get(mask) },
+        replay: {
+            ...exposed.api.replay,
+            since: (s: number) => { counters.since++; return exposed.api.replay.since(s) },
+            keyframe: () => { counters.keyframe++; return exposed.api.replay.keyframe() },
+        },
+    }
+
+    type Client = Awaited<ReturnType<typeof startRealClient<typeof facade>>>
+    const server = await startRealServer(facade)
+    let c1: Client | null = null
+    let c2: Client | null = null
+
+    try {
+        // ============ свежий клиент: keyframe + live ============
+        c1 = await startRealClient<typeof facade>(server.port)
+        const deep1 = c1.client.func as any
+        const remote1: ReplayRemote<[StorePatch]> = {
+            line: deep1.replay.line,
+            since: (s: number) => deep1.replay.since(s),
+            keyframe: () => deep1.replay.keyframe(),
+        }
+        const mirror = createStore<World>({units: {}, tick: -1})
+        let lastSeq = -1
+        const sub = syncStoreReplay(mirror, remote1, {onSeq: s => lastSeq = s})
+        await sub.ready
+        ok(json(mirror.state) == json(backend.snapshot()), 'fresh client converged via keyframe over the wire')
+        ok(counters.keyframe == 1 && counters.since == 0, 'exactly one keyframe request, no tail request')
+
+        backend.state.units['beta'] = {hp: 50, x: 5}
+        backend.state.tick = 1
+        await flushReactive(backend.state)
+        await waitFor('live patches over wire', () => mirror.state.tick == 1 && 'beta' in mirror.state.units)
+        ok(json(mirror.state) == json(backend.snapshot()), 'live patches keep the wire mirror converged')
+        ok(counters.get == 0, 'pure push: server get() was never pulled')
+
+        // ============ обрыв связи, изменения в оффлайне ============
+        sub()
+        c1.close()
+        c1 = null
+        await delay(30)
+
+        backend.state.units['alpha'].hp = 75
+        await flushReactive(backend.state)
+        backend.state.tick = 2
+        await flushReactive(backend.state)
+
+        // ============ реконнект с since → только хвост ============
+        const kfBefore = counters.keyframe
+        c2 = await startRealClient<typeof facade>(server.port)
+        const deep2 = c2.client.func as any
+        const remote2: ReplayRemote<[StorePatch]> = {
+            line: deep2.replay.line,
+            since: (s: number) => deep2.replay.since(s),
+            keyframe: () => deep2.replay.keyframe(),
+        }
+        let tailPatches = 0
+        const sub2 = syncStoreReplay(mirror, remote2, {
+            since: lastSeq,
+            onSeq: s => { lastSeq = s; tailPatches++ },
+        })
+        await sub2.ready
+        ok(json(mirror.state) == json(backend.snapshot()), 'reconnect with since converged over the wire')
+        ok(counters.keyframe == kfBefore, 'reconnect did NOT cost a snapshot — tail of patches sufficed')
+        ok(tailPatches == 2, `tail was exactly the missed patches (got ${tailPatches})`)
+
+        // ============ долгий оффлайн → журнал (history: 6) вытеснен → keyframe ============
+        sub2()
+        for (let i = 3; i <= 30; i++) {
+            backend.state.tick = i
+            await flushReactive(backend.state)
+        }
+        let resyncDeliveries = 0
+        const sub3 = syncStoreReplay(mirror, remote2, {
+            since: lastSeq,
+            onSeq: s => { lastSeq = s; resyncDeliveries++ },
+        })
+        await sub3.ready
+        ok(json(mirror.state) == json(backend.snapshot()), 'evicted journal → fresh keyframe converged')
+        ok(counters.keyframe == kfBefore + 1, 'fallback took exactly one fresh keyframe')
+        ok(resyncDeliveries == 1, `no backlog: 28 missed patches collapsed into 1 keyframe (got ${resyncDeliveries})`)
+
+        // live после fallback продолжает идти
+        backend.state.tick = 31
+        await flushReactive(backend.state)
+        await waitFor('live after fallback', () => mirror.state.tick == 31)
+        ok(true, 'live stream continues after keyframe recovery')
+        sub3()
+
+        console.log(fails ? `\n${fails} FAILED` : '\nall passed')
+    } finally {
+        c1?.close()
+        c2?.close()
+        await delay(20)
+        exposed.close()
+        await server.close()
+    }
+    if (fails) process.exit(1)
+}
+
+main().catch(e => { console.error(e); process.exit(1) })

package/replay/staleness.test.ts

@@ -0,0 +1,176 @@
+// ============================================================
+//  replay/staleness.test.ts
+//
+//  Вотчдог тухлости: продьюсер (withReplayListen {staleMs, onStale},
+//  isStale()/lastTs()) и клиент (replaySubscribe {staleMs, onStale,
+//  skewMs}, off.isStale()/off.lastTs()). Сценарии: молчащая линия
+//  (edge в обе стороны, не будильник); холодная линия без таймера;
+//  ленивые геттеры без onStale; тухлый keyframe — stale сразу по
+//  доставке; НЕТ флапа на историческом хвосте since-catch-up;
+//  допуск skewMs; снятие таймеров off()/close().
+//  Запуск:
+//      npx ts-node replay/staleness.test.ts
+// ============================================================
+
+import {replayListen, exposeReplay, replaySubscribe, StaleInfo, ReplayRemote} from '../src/Common/events/replay-index'
+
+let fails = 0
+const ok = (condition: any, message: string) => {
+    if (!condition) { fails++; console.log('  FAIL', message) }
+    else console.log('  OK  ', message)
+}
+const delay = (ms: number) => new Promise<void>(r => setTimeout(r, ms))
+const edgesOf = (list: StaleInfo[]) => list.map(i => i.stale ? 'T' : 'F').join(',')
+
+async function main() {
+    console.log('\n[staleness] producer: silent line, edge-triggered both directions')
+    {
+        const edges: StaleInfo[] = []
+        const [emit, listen] = replayListen<[number]>({history: 8, staleMs: 40, onStale: i => edges.push(i)})
+        emit(1)
+        ok(!listen.isStale() && listen.lastTs() > 0, 'fresh right after emit')
+        await delay(100)
+        ok(edgesOf(edges) == 'T', `fresh->stale fired exactly once, not a repeating alarm (${edgesOf(edges)})`)
+        ok(listen.isStale(), 'isStale() agrees while silent')
+        ok(edges[0].age >= 40 && edges[0].lastTs == listen.lastTs(), 'edge info carries lastTs/age')
+        emit(2)
+        ok(edgesOf(edges) == 'T,F', 'stale->fresh fired on the reviving emit')
+        ok(!listen.isStale(), 'fresh again')
+        await delay(100)
+        ok(edgesOf(edges) == 'T,F,T', 'goes stale again after the next silence')
+        listen.close()
+    }
+
+    console.log('\n[staleness] producer: cold line stays free')
+    {
+        const edges: StaleInfo[] = []
+        const [, listen] = replayListen<[number]>({history: 8, staleMs: 30, onStale: i => edges.push(i)})
+        await delay(90)
+        ok(edges.length == 0, 'no events ever -> watchdog never armed, no edges')
+        ok(!listen.isStale() && listen.lastTs() == 0, 'cold line is not stale (freshness unknown, not expired)')
+        listen.close()
+    }
+
+    console.log('\n[staleness] producer: lazy getters without onStale (no timer needed)')
+    {
+        const [emit, listen] = replayListen<[number]>({history: 8, staleMs: 30})
+        emit(1)
+        await delay(70)
+        ok(listen.isStale(), 'isStale() computes lazily, no onStale installed')
+        emit(2)
+        ok(!listen.isStale(), 'revives on emit')
+        listen.close()
+    }
+
+    console.log('\n[staleness] producer: close() disarms the watchdog')
+    {
+        const edges: StaleInfo[] = []
+        const [emit, listen] = replayListen<[number]>({history: 8, staleMs: 30, onStale: i => edges.push(i)})
+        emit(1)
+        listen.close()
+        await delay(90)
+        ok(edges.length == 0, 'no stale edge after close()')
+    }
+
+    console.log('\n[staleness] client: silent line over the wire shape (arrival gap)')
+    {
+        const [emit, listen] = replayListen<[number]>({history: 8})
+        const remote = exposeReplay(listen) as unknown as ReplayRemote<[number]>
+        const edges: StaleInfo[] = []
+        const seen: number[] = []
+        const sub = replaySubscribe(remote, v => seen.push(v), {staleMs: 40, onStale: i => edges.push(i)})
+        await sub.ready
+        emit(1)
+        ok(!sub.isStale() && sub.lastTs() == listen.lastTs(), 'fresh after delivery, lastTs mirrors the envelope')
+        await delay(100)
+        ok(edgesOf(edges) == 'T', `silent wire -> one stale edge (${edgesOf(edges)})`)
+        ok(sub.isStale(), 'off.isStale() agrees')
+        emit(2)
+        ok(edgesOf(edges) == 'T,F' && seen.join(',') == '1,2', 'delivery revives: fresh edge once, data intact')
+        await delay(100)
+        ok(edgesOf(edges) == 'T,F,T', 'stale again after the next silence')
+        sub()
+        emit(3)
+        await delay(100)
+        ok(edgesOf(edges) == 'T,F,T', 'off() disarms the client watchdog — no edges after unsubscribe')
+        listen.close()
+    }
+
+    console.log('\n[staleness] client: dead producer at connect (silent from birth)')
+    {
+        const [, listen] = replayListen<[number]>({history: 8})
+        const remote = exposeReplay(listen) as unknown as ReplayRemote<[number]>
+        const edges: StaleInfo[] = []
+        const sub = replaySubscribe(remote, () => {}, {staleMs: 40, onStale: i => edges.push(i)})
+        await sub.ready
+        await delay(100)
+        ok(edgesOf(edges) == 'T', 'no envelope ever -> stale from the subscribe-time arrival gap')
+        const lazy = replaySubscribe(remote, () => {}, {staleMs: 40})
+        await lazy.ready
+        await delay(80)
+        ok(lazy.isStale(), 'isStale() works lazily without onStale (no timer)')
+        sub(); lazy()
+        listen.close()
+    }
+
+    console.log('\n[staleness] client: stale keyframe reported IMMEDIATELY at delivery')
+    {
+        let state = 7
+        // часы продьюсера «остановились» 500 мс назад — keyframe приедет сейчас, но с старым ts
+        const producerNow = () => Date.now() - 500
+        const [, listen] = replayListen<[number]>({history: 8, current: () => [state], now: producerNow})
+        const remote = exposeReplay(listen) as unknown as ReplayRemote<[number]>
+        const edges: StaleInfo[] = []
+        const seen: number[] = []
+        const sub = replaySubscribe(remote, v => seen.push(v), {staleMs: 100, onStale: i => edges.push(i)})
+        await sub.ready
+        ok(seen.join(',') == '7', 'keyframe delivered')
+        ok(edgesOf(edges) == 'T', 'stale edge right after catch-up — no staleMs of waiting')
+        ok(sub.isStale() && sub.lastTs() <= Date.now() - 500 + 5, 'lastTs is the old producer ts')
+        sub()
+        listen.close()
+    }
+
+    console.log('\n[staleness] client: historical since-tail does NOT flap')
+    {
+        let t = Date.now() - 300
+        const [emit, listen] = replayListen<[number]>({history: 16, now: () => t})
+        emit(1); emit(2); emit(3)          // старый хвост (ts на 300 мс в прошлом)
+        t = Date.now()
+        emit(4); emit(5)                   // голова свежая
+        const remote = exposeReplay(listen) as unknown as ReplayRemote<[number]>
+        const edges: StaleInfo[] = []
+        const seen: number[] = []
+        const sub = replaySubscribe(remote, v => seen.push(v), {since: 0, staleMs: 100, onStale: i => edges.push(i)})
+        await sub.ready
+        ok(seen.join(',') == '1,2,3,4,5', 'full tail replayed')
+        ok(edges.length == 0, 'old tail ts never flapped stale mid-catch-up; head is fresh -> no edge at all')
+        ok(!sub.isStale(), 'fresh after handover')
+        sub()
+        listen.close()
+    }
+
+    console.log('\n[staleness] client: skewMs tolerance for producer/client clock disagreement')
+    {
+        let state = 1
+        const skewedNow = () => Date.now() - 80   // продьюсер отстаёт на 80 мс
+        const [, listen] = replayListen<[number]>({history: 8, current: () => [state], now: skewedNow})
+        const remote = exposeReplay(listen) as unknown as ReplayRemote<[number]>
+        const strict: StaleInfo[] = []
+        const s1 = replaySubscribe(remote, () => {}, {staleMs: 50, onStale: i => strict.push(i)})
+        await s1.ready
+        ok(edgesOf(strict) == 'T', 'skewMs=0: an 80ms-old ts trips the 50ms threshold at delivery')
+        s1()
+        const tolerant: StaleInfo[] = []
+        const s2 = replaySubscribe(remote, () => {}, {staleMs: 50, skewMs: 100, onStale: i => tolerant.push(i)})
+        await s2.ready
+        ok(tolerant.length == 0, 'skewMs=100 absorbs the clock offset — no false stale')
+        s2()
+        listen.close()
+    }
+
+    console.log(fails ? `\n${fails} FAILED` : '\nall passed')
+    if (fails) process.exit(1)
+}
+
+main().catch(e => { console.error(e); process.exit(1) })

package/replay/store-replay.test.ts

@@ -0,0 +1,151 @@
+import {createStore} from '../src/Common/Observe/store'
+import {flushReactive} from '../src/Common/Observe/reactive'
+import {exposeStoreReplay, syncStoreReplay} from '../src/Common/Observe/store-replay'
+import {ReplayRemote} from '../src/Common/events/replay-index'
+
+let fails = 0
+const ok = (condition: any, message: string) => {
+    if (!condition) { fails++; console.log('  FAIL', message) }
+    else console.log('  OK  ', message)
+}
+const delay = (ms: number) => new Promise<void>(r => setTimeout(r, ms))
+const json = (v: any) => JSON.stringify(v)
+
+type World = {
+    units: Record<string, {hp: number, x: number}>
+    tick: number
+}
+
+// in-proc «провод»: методы становятся async с задержкой — как настоящий RPC
+function makeRemote(exposed: ReturnType<typeof exposeStoreReplay<World>>, lag = 15) {
+    const counters = {since: 0, keyframe: 0}
+    const remote: ReplayRemote<any> = {
+        line: exposed.replay.line,
+        since: async (s: number) => { counters.since++; await delay(lag); return exposed.replay.getSince(s) ?? null },
+        keyframe: async () => { counters.keyframe++; await delay(lag); return exposed.replay.keyframe() ?? null },
+    }
+    return {remote, counters}
+}
+
+const ascendingUnique = (seqs: number[]) => seqs.every((s, i) => i == 0 || s > seqs[i - 1])
+
+async function main() {
+    console.log('\n[store-replay] fresh mirror: keyframe as root patch')
+    {
+        const backend = createStore<World>({units: {a: {hp: 100, x: 0}}, tick: 0})
+        const exposed = exposeStoreReplay(backend, {history: 100})
+        const {remote, counters} = makeRemote(exposed)
+        const mirror = createStore<World>({units: {}, tick: -1})
+        const seqs: number[] = []
+        const sub = syncStoreReplay(mirror, remote, {onSeq: s => seqs.push(s)})
+        await sub.ready
+        ok(json(mirror.state) == json(backend.snapshot()), 'since<0 → keyframe → mirror equals backend')
+        ok(counters.keyframe == 1 && counters.since == 0, 'keyframe requested exactly once, no tail call')
+
+        backend.state.units['b'] = {hp: 50, x: 5}
+        backend.state.tick = 1
+        await flushReactive(backend.state)
+        await delay(5)
+        ok(json(mirror.state) == json(backend.snapshot()), 'live patches keep mirror converged')
+        ok(ascendingUnique(seqs), `delivered seqs strictly ascending: ${seqs.join(',')}`)
+        sub()
+        exposed.close()
+    }
+
+    console.log('\n[store-replay] reconnect with since → tail only, no snapshot')
+    {
+        const backend = createStore<World>({units: {a: {hp: 100, x: 0}}, tick: 0})
+        const exposed = exposeStoreReplay(backend, {history: 100})
+        const {remote} = makeRemote(exposed)
+        const mirror = createStore<World>({units: {}, tick: -1})
+        const sub = syncStoreReplay(mirror, remote)
+        await sub.ready
+        sub()  // «обрыв связи»
+
+        backend.state.units['a'].hp = 75
+        backend.state.units['c'] = {hp: 10, x: 9}
+        await flushReactive(backend.state)
+        backend.state.tick = 2
+        await flushReactive(backend.state)
+
+        const {remote: remote2, counters: counters2} = makeRemote(exposed)
+        const sub2 = syncStoreReplay(mirror, remote2, {since: sub.seq()})
+        await sub2.ready
+        ok(json(mirror.state) == json(backend.snapshot()), 'reconnect via since converges')
+        ok(counters2.keyframe == 0 && counters2.since == 1, 'reconnect cost = tail of patches, NOT a snapshot')
+        sub2()
+        exposed.close()
+    }
+
+    console.log('\n[store-replay] long offline → journal evicted → fresh keyframe, no backlog')
+    {
+        const backend = createStore<World>({units: {}, tick: 0})
+        const exposed = exposeStoreReplay(backend, {history: 3})
+        const {remote} = makeRemote(exposed)
+        const mirror = createStore<World>({units: {}, tick: -1})
+        const sub = syncStoreReplay(mirror, remote)
+        await sub.ready
+        sub()
+
+        for (let i = 1; i <= 20; i++) {
+            backend.state.tick = i
+            await flushReactive(backend.state)
+        }
+        let applied = 0
+        const {remote: remote2, counters: counters2} = makeRemote(exposed)
+        const counting: ReplayRemote<any> = {...remote2, line: {on: (cb: any) => remote2.line.on((ev: any) => { applied++; cb(ev) })}}
+        const sub2 = syncStoreReplay(mirror, counting, {since: sub.seq()})
+        await sub2.ready
+        ok(json(mirror.state) == json(backend.snapshot()), 'evicted → keyframe fallback converges')
+        ok(counters2.keyframe == 1, 'fallback took exactly one fresh keyframe')
+        ok(applied == 0, 'NO backlog: 20 offline patches never traveled')
+        sub2()
+        exposed.close()
+    }
+
+    console.log('\n[store-replay] events racing the catch-up window (async handover)')
+    {
+        const backend = createStore<World>({units: {a: {hp: 1, x: 1}}, tick: 0})
+        const exposed = exposeStoreReplay(backend, {history: 100})
+        const {remote} = makeRemote(exposed, 30)
+        const mirror = createStore<World>({units: {}, tick: -1})
+        const seqs: number[] = []
+        const sub = syncStoreReplay(mirror, remote, {onSeq: s => seqs.push(s)})
+        // мутации ВО ВРЕМЯ ожидания keyframe: попадут и в снапшот, и в live-очередь
+        backend.state.tick = 1
+        await flushReactive(backend.state)
+        backend.state.units['a'].hp = 2
+        await flushReactive(backend.state)
+        await sub.ready
+        backend.state.tick = 3
+        await flushReactive(backend.state)
+        await delay(5)
+        ok(json(mirror.state) == json(backend.snapshot()), 'overlap keyframe/queue converges')
+        ok(ascendingUnique(seqs), `no seq delivered twice: ${seqs.join(',')}`)
+        sub()
+        exposed.close()
+    }
+
+    console.log('\n[store-replay] seq from another server life → keyframe resets the line down')
+    {
+        const backend = createStore<World>({units: {z: {hp: 9, x: 9}}, tick: 100})
+        const exposed = exposeStoreReplay(backend, {history: 100})  // свежий сервер: head мал
+        const {remote, counters} = makeRemote(exposed)
+        const mirror = createStore<World>({units: {}, tick: -1})
+        const sub = syncStoreReplay(mirror, remote, {since: 99999})
+        await sub.ready
+        ok(json(mirror.state) == json(backend.snapshot()), 'future seq → keyframe fallback')
+        ok(counters.keyframe == 1, 'keyframe taken once')
+        backend.state.tick = 101
+        await flushReactive(backend.state)
+        await delay(5)
+        ok(mirror.state.tick == 101, 'live events AFTER the reset are not muted by the stale big seq')
+        sub()
+        exposed.close()
+    }
+
+    console.log(fails ? `\n${fails} FAILED` : '\nall passed')
+    if (fails) process.exit(1)
+}
+
+main().catch(e => { console.error(e); process.exit(1) })