nick/amethyst
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

fix(quic): raise stream-id cap to 1M to support multi-hour Nests; strip diagnostic logs

Browse Source 
Two changes once the cliff is confirmed sidestepped:

1. Raise initialMaxStreamsUni from 10 000 → 1 000 000.

   At framesPerGroup=5 with 20 ms Opus frames the relay opens ~10
   uni streams/sec to a listener. The half-window threshold check
   (`count + initialMaxStreamsUni/2 >= advertisedMaxStreamsUni`)
   now trips at count=500 000 ≈ 13.9 hours of continuous audio.
   For any realistic Nest the rolling MAX_STREAMS_UNI extension
   path — which is what tripped the moq-rs cliff — is dormant.

   Memory cost: QuicConnection.streams grows for the connection's
   lifetime (no removal in current model), so 2 hours costs ~72k
   stream entries. Per-stream overhead is small enough that this
   is tolerable for an audio-room workload; bounded growth is a
   known follow-up.

2. Strip the high-frequency diagnostic logs that were added during
   investigation. Production keeps:
     - SUBSCRIBE_DROP (rare error)
     - MAX_STREAMS_UNI / MAX_STREAMS_BIDI emit (should never fire
       in normal operation now; if it does, we want to know)
     - pumpUniStreams / pumpInboundBidis ended (pump death)
     - announce / subscribe bidi.incoming() exception path
     - ReconnectingHandle.opener throw + retry

   Stripped:
     - per-stream "transport delivered uni stream #N"
     - per-group "uni grpHdr id=N seq=M"
     - per-group "openGroup seq=N keyedOnSubId=…"
     - per-25-stream peerInitiatedUniCount milestone
     - per-chunk "subscribe id=N: bidi chunk #M"
     - per-update RoomAnnouncement
     - 5-second QuicWebTransportSession flow-control snapshot ticker
     - "VM.openSubscription ->/<- subscribeSpeaker"
     - "VM.onSpeakerActivity FIRST frame"
     - "broadcaster: send accepted (subscriber attached)"
     - "broadcaster: publisher.send returned false (no inbound subscriber)"
     - "first inbound subscriber attached"
     - "ignoring inbound SUBSCRIBE id=N track=catalog.json"
     - "publish suffix=…"
     - "transport delivered inbound bidi #N"
     - "inbound AnnouncePlease prefix=…"
     - "inbound SUBSCRIBE id=… track=…"
     - "inbound SUBSCRIBE FIN'd: removing id=…"

   The diagnostic logs can be re-added behind a debug flag later if
   we need to chase a different regression.

Confirmed durable for at least 15 s of continuous audio against
nostrnests.com production with the prior 10 000-cap fix; bumping to
1 000 000 expands the headroom to multi-hour broadcasts without any
new code path firing.

https://claude.ai/code/session_01PYYez8a6sjiakyjAxsfCEQ
This commit is contained in:
Claude
2026-05-04 21:55:49 +00:00
parent f32131d073
commit c3d6cadffb
8 changed files with 46 additions and 201 deletions
Download Patch File Download Diff File Expand all files Collapse all files
commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/viewmodels/NestViewModel.kt
-4
View File
@@ -44,7 +44,6 @@ import com.vitorpamplona.nestsclient.moq.SubscribeHandle
import com.vitorpamplona.nestsclient.transport.WebTransportFactory
import com.vitorpamplona.quartz.nip01Core.signers.NostrSigner
import com.vitorpamplona.quartz.nip53LiveActivities.chat.LiveActivitiesChatMessageEvent
import com.vitorpamplona.quartz.utils.Log
import kotlinx.collections.immutable.ImmutableSet
import kotlinx.collections.immutable.persistentSetOf
import kotlinx.collections.immutable.toPersistentSet
@@ -843,9 +842,7 @@ class NestViewModel(
) {
if (closed || activeSubscriptions[pubkey] !== slot) return
try {
Log.d("NestRx") { "VM.openSubscription -> subscribeSpeaker pubkey=$pubkey" }
val handle = l.subscribeSpeaker(pubkey)
Log.d("NestRx") { "VM.openSubscription <- subscribeSpeaker returned for pubkey=$pubkey" }
// Re-check after the suspending subscribeSpeaker — the user
// may have removed this speaker via updateSpeakers / disconnected
// while the SUBSCRIBE was in flight. If so, abandon the handle
@@ -1007,7 +1004,6 @@ class NestViewModel(
// First frame for this subscription — clear the buffering
// overlay. Subsequent frames are no-ops here.
if (_uiState.value.connectingSpeakers.contains(pubkey)) {
Log.d("NestRx") { "VM.onSpeakerActivity FIRST frame for pubkey=$pubkey — clearing spinner" }
_uiState.update { it.copy(connectingSpeakers = (it.connectingSpeakers - pubkey).toPersistentSet()) }
}
if (!_uiState.value.speakingNow.contains(pubkey)) {
nestsClient/src/commonMain/kotlin/com/vitorpamplona/nestsclient/MoqLiteNestsListener.kt
+3 -14
View File
@@ -26,7 +26,6 @@ import com.vitorpamplona.nestsclient.moq.SubscribeOk
import com.vitorpamplona.nestsclient.moq.lite.MoqLiteAnnounceStatus
import com.vitorpamplona.nestsclient.moq.lite.MoqLiteSession
import com.vitorpamplona.nestsclient.moq.lite.MoqLiteSubscribeException
import com.vitorpamplona.quartz.utils.Log
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
@@ -79,15 +78,9 @@ class MoqLiteNestsListener internal constructor(
override suspend fun subscribeSpeaker(
speakerPubkeyHex: String,
maxLatencyMs: Long,
): SubscribeHandle {
Log.d("NestRx") { "subscribeSpeaker pubkey=$speakerPubkeyHex maxLatencyMs=$maxLatencyMs" }
return wrapSubscription(broadcast = speakerPubkeyHex, track = AUDIO_TRACK, maxLatencyMs = maxLatencyMs)
}
): SubscribeHandle = wrapSubscription(broadcast = speakerPubkeyHex, track = AUDIO_TRACK, maxLatencyMs = maxLatencyMs)
override suspend fun subscribeCatalog(speakerPubkeyHex: String): SubscribeHandle {
Log.d("NestRx") { "subscribeCatalog pubkey=$speakerPubkeyHex" }
return wrapSubscription(broadcast = speakerPubkeyHex, track = CATALOG_TRACK, maxLatencyMs = 0L)
}
override suspend fun subscribeCatalog(speakerPubkeyHex: String): SubscribeHandle = wrapSubscription(broadcast = speakerPubkeyHex, track = CATALOG_TRACK, maxLatencyMs = 0L)
private suspend fun wrapSubscription(
broadcast: String,
@@ -145,14 +138,10 @@ class MoqLiteNestsListener internal constructor(
val handle = session.announce(prefix = "")
try {
handle.updates.collect { announce ->
val active = announce.status == MoqLiteAnnounceStatus.Active
Log.d("NestRx") {
"RoomAnnouncement pubkey=${announce.suffix} active=$active status=${announce.status} hops=${announce.hops}"
}
emit(
RoomAnnouncement(
pubkey = announce.suffix,
active = active,
active = announce.status == MoqLiteAnnounceStatus.Active,
),
)
}
nestsClient/src/commonMain/kotlin/com/vitorpamplona/nestsclient/ReconnectingNestsListener.kt
-1
View File
@@ -379,7 +379,6 @@ private class ReconnectingHandle(
liveHandleRef.set(handle)
try {
handle.objects.collect { frames.emit(it) }
Log.d("NestRx") { "ReconnectingHandle.objects flow ended naturally — pump will re-issue after ${RESUBSCRIBE_BACKOFF_MS}ms" }
} finally {
if (liveHandleRef.get() === handle) liveHandleRef.set(null)
}
nestsClient/src/commonMain/kotlin/com/vitorpamplona/nestsclient/audio/NestMoqLiteBroadcaster.kt
+1 -21
View File
@@ -21,7 +21,6 @@
package com.vitorpamplona.nestsclient.audio
import com.vitorpamplona.nestsclient.moq.lite.MoqLitePublisherHandle
import com.vitorpamplona.quartz.utils.Log
import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Job
@@ -162,8 +161,6 @@ class NestMoqLiteBroadcaster(
// we bail. publisher.send returning `false` (no inbound
// subscriber) is NOT counted — empty rooms are normal.
var consecutiveSendErrors = 0
var sendNoSubLogged = false
var lastSendHadSub = false
try {
while (true) {
val pcm = capture.readFrame() ?: break
@@ -190,21 +187,7 @@ class NestMoqLiteBroadcaster(
// for the production cliff this works around.
val sendOutcome =
runCatching {
val accepted = publisher.send(opus)
if (accepted) {
if (!lastSendHadSub) {
Log.d("NestTx") { "broadcaster: send accepted (subscriber attached)" }
lastSendHadSub = true
}
} else {
if (!sendNoSubLogged) {
Log.w("NestTx") {
"broadcaster: publisher.send returned false (no inbound subscriber on relay)"
}
sendNoSubLogged = true
}
lastSendHadSub = false
}
publisher.send(opus)
framesInCurrentGroup += 1
if (framesInCurrentGroup >= framesPerGroup) {
publisher.endGroup()
@@ -223,9 +206,6 @@ class NestMoqLiteBroadcaster(
}.onFailure { t ->
if (t is CancellationException) throw t
consecutiveSendErrors += 1
Log.w("NestTx") {
"broadcaster: publisher.send threw (#$consecutiveSendErrors): ${t::class.simpleName}: ${t.message}"
}
onError(
AudioException(
AudioException.Kind.PlaybackFailed,
nestsClient/src/commonMain/kotlin/com/vitorpamplona/nestsclient/moq/lite/MoqLiteSession.kt
+9 -74
View File
@@ -116,31 +116,25 @@ class MoqLiteSession internal constructor(
suspend fun announce(prefix: String): MoqLiteAnnouncesHandle {
ensureOpen()
val bidi = transport.openBidiStream()
Log.d("NestRx") { "announce(prefix='$prefix'): bidi opened, writing AnnouncePlease" }
bidi.write(Varint.encode(MoqLiteControlType.Announce.code))
bidi.write(MoqLiteCodec.encodeAnnouncePlease(MoqLiteAnnouncePlease(prefix)))
Log.d("NestRx") { "announce(prefix='$prefix'): AnnouncePlease flushed, awaiting Active updates" }
val updates = MutableSharedFlow<MoqLiteAnnounce>(replay = 0, extraBufferCapacity = 64)
val pump =
scope.launch {
val buffer = MoqLiteFrameBuffer()
var chunksSeen = 0
try {
bidi.incoming().collect { chunk ->
chunksSeen += 1
Log.d("NestRx") { "announce(prefix='$prefix'): bidi chunk #$chunksSeen size=${chunk.size}" }
buffer.push(chunk)
while (true) {
val payload = buffer.readSizePrefixed() ?: break
updates.emit(MoqLiteCodec.decodeAnnounce(payload))
}
}
Log.d("NestRx") { "announce(prefix='$prefix'): bidi.incoming() ended naturally after $chunksSeen chunks" }
} catch (ce: CancellationException) {
throw ce
} catch (t: Throwable) {
Log.w("NestRx") { "announce(prefix='$prefix'): bidi.incoming() threw ${t::class.simpleName}: ${t.message} (chunks=$chunksSeen)" }
Log.w("NestRx") { "announce(prefix='$prefix'): bidi.incoming() threw ${t::class.simpleName}: ${t.message}" }
// Flow terminated (peer FIN or transport close).
// The Announce stream's emit-side just stops; consumers
// see an end-of-flow.
@@ -208,10 +202,8 @@ class MoqLiteSession internal constructor(
endGroup = endGroup,
)
val bidi = transport.openBidiStream()
Log.d("NestRx") { "subscribe id=$id broadcast='$broadcast' track='$track': bidi opened, writing SUBSCRIBE bytes" }
bidi.write(Varint.encode(MoqLiteControlType.Subscribe.code))
bidi.write(MoqLiteCodec.encodeSubscribe(request))
Log.d("NestRx") { "subscribe id=$id: SUBSCRIBE bytes flushed, awaiting response" }
// Single long-running collector for the bidi's whole lifetime.
// The collector parses the SubscribeResponse inline, signals it
@@ -261,14 +253,9 @@ class MoqLiteSession internal constructor(
scope.launch {
val responseBuffer = MoqLiteFrameBuffer()
var responseParsed = false
var chunksSeen = 0
try {
bidi.incoming().collect { chunk ->
chunksSeen += 1
if (!responseParsed) {
Log.d("NestRx") {
"subscribe id=$id: bidi chunk #$chunksSeen size=${chunk.size} (response not yet parsed)"
}
responseBuffer.push(chunk)
val typeCode = responseBuffer.readVarint() ?: return@collect
val body = responseBuffer.readSizePrefixed() ?: return@collect
@@ -284,16 +271,13 @@ class MoqLiteSession internal constructor(
// moq-lite leaves the bidi idle post-Ok. The signal
// we care about is the flow's natural completion.
}
Log.d("NestRx") { "subscribe id=$id: bidi.incoming() flow ended naturally after $chunksSeen chunks (responseParsed=$responseParsed)" }
} catch (ce: CancellationException) {
if (!responseDeferred.isCompleted) responseDeferred.completeExceptionally(ce)
throw ce
} catch (t: Throwable) {
Log.w("NestRx") { "subscribe id=$id: bidi.incoming() threw ${t::class.simpleName}: ${t.message} (chunks=$chunksSeen)" }
if (!responseDeferred.isCompleted) responseDeferred.completeExceptionally(t)
}
if (!responseDeferred.isCompleted) {
Log.w("NestRx") { "subscribe id=$id: bidi closed BEFORE any response parsed (chunks=$chunksSeen)" }
responseDeferred.completeExceptionally(
MoqLiteSubscribeException("subscribe stream FIN before reply for id=$id"),
)
@@ -330,7 +314,6 @@ class MoqLiteSession internal constructor(
}
is MoqLiteCodec.SubscribeResponse.Ok -> {
Log.d("NestRx") { "SUBSCRIBE_OK id=$id broadcast='$broadcast' track='$track'" }
return MoqLiteSubscribeHandle(
id = id,
ok = resp.ok,
@@ -406,9 +389,6 @@ class MoqLiteSession internal constructor(
private suspend fun pumpAnnounceWatch(handle: MoqLiteAnnouncesHandle) {
try {
handle.updates.collect { update ->
Log.d("NestRx") {
"announce update status=${update.status} suffix='${update.suffix}' hops=${update.hops}"
}
if (update.status != MoqLiteAnnounceStatus.Ended) return@collect
val targets =
state.withLock {
@@ -417,9 +397,6 @@ class MoqLiteSession internal constructor(
.toList()
}
for (sub in targets) {
Log.w("NestRx") {
"announce ENDED closes sub id=${sub.id} broadcast='${sub.request.broadcast}'"
}
// Just close the frames channel — the
// wrapper-level collect of `frames.consumeAsFlow()`
// ends naturally and the wrapper pump re-issues.
@@ -461,10 +438,7 @@ class MoqLiteSession internal constructor(
// sibling on the outer [scope] until the transport's flow
// independently errors out.
kotlinx.coroutines.coroutineScope {
var seen = 0L
transport.incomingUniStreams().collect { stream ->
val n = ++seen
Log.d("NestRx") { "transport delivered uni stream #$n (QUIC→moq seam)" }
launch { drainOneGroup(stream) }
}
}
@@ -499,23 +473,16 @@ class MoqLiteSession internal constructor(
subscribeId = hdr.subscribeId
groupSequence = hdr.sequence
headerRead = true
Log.d("NestRx") { "uni grpHdr id=$subscribeId seq=$groupSequence" }
}
while (true) {
val frame = buffer.readSizePrefixed() ?: break
val sub = state.withLock { subscriptionsBySubscribeId[subscribeId] }
if (sub != null) {
sub.frames.trySend(
MoqLiteFrame(
groupSequence = groupSequence,
payload = frame,
),
)
} else {
Log.w("NestRx") {
"uni frame drop: no live sub for id=$subscribeId seq=$groupSequence size=${frame.size}"
}
}
sub?.frames?.trySend(
MoqLiteFrame(
groupSequence = groupSequence,
payload = frame,
),
)
// If the subscription has been closed already we
// silently drop the frame — the publisher hasn't
// observed the unsubscribe yet (its uni streams
@@ -568,7 +535,6 @@ class MoqLiteSession internal constructor(
): MoqLitePublisherHandle {
ensureOpen()
val normalised = MoqLitePath.normalize(broadcastSuffix)
Log.d("NestTx") { "publish suffix='$normalised' track='$track'" }
val publisher: PublisherStateImpl
state.withLock {
check(!closed) { "session is closed" }
@@ -598,10 +564,7 @@ class MoqLiteSession internal constructor(
// [pumpUniStreams]'s identical comment) so they don't outlive
// bidiPump.cancelAndJoin() in [close].
kotlinx.coroutines.coroutineScope {
var seen = 0L
transport.incomingBidiStreams().collect { bidi ->
val n = ++seen
Log.d("NestTx") { "transport delivered inbound bidi #$n (QUIC→moq seam)" }
launch { handleInboundBidi(bidi) }
}
}
@@ -657,9 +620,6 @@ class MoqLiteSession internal constructor(
val please = MoqLiteCodec.decodeAnnouncePlease(pleasePayload)
val emittedSuffix =
MoqLitePath.stripPrefix(please.prefix, publisher.suffix) ?: publisher.suffix
Log.d("NestTx") {
"inbound AnnouncePlease prefix='${please.prefix}' → reply Active suffix='$emittedSuffix'"
}
bidi.write(
MoqLiteCodec.encodeAnnounce(
MoqLiteAnnounce(
@@ -676,10 +636,6 @@ class MoqLiteSession internal constructor(
MoqLiteControlType.Subscribe -> {
val subPayload = buffer.readSizePrefixed() ?: return@collect
val sub = MoqLiteCodec.decodeSubscribe(subPayload)
Log.d("NestTx") {
"inbound SUBSCRIBE id=${sub.id} broadcast='${sub.broadcast}' track='${sub.track}' " +
"priority=${sub.priority} maxLatencyMs=${sub.maxLatencyMillis}"
}
// Register the subscription BEFORE sending Ok so the
// peer's observation of Ok is a happens-after of
// `inboundSubs += sub`. Otherwise on dispatchers that
@@ -728,12 +684,7 @@ class MoqLiteSession internal constructor(
// groups off this dead subscriber. Announce bidis are
// owned by the publisher state for sending Ended on
// publisher-close — we don't remove them here.
inboundSub?.let {
Log.d("NestTx") {
"inbound SUBSCRIBE FIN'd: removing id=${it.id} broadcast='${it.broadcast}' track='${it.track}'"
}
publisher.removeInboundSubscription(it)
}
inboundSub?.let { publisher.removeInboundSubscription(it) }
}
/**
@@ -838,20 +789,8 @@ class MoqLiteSession internal constructor(
suspend fun registerInboundSubscription(sub: MoqLiteSubscribe) {
gate.withLock {
if (publisherClosed) return
if (sub.track != track) {
Log.d("NestTx") {
"ignoring inbound SUBSCRIBE id=${sub.id} track='${sub.track}' " +
"(publisher serves track='$track' only)"
}
return
}
val wasEmpty = inboundSubs.isEmpty()
if (sub.track != track) return
inboundSubs += sub
if (wasEmpty) {
Log.d("NestTx") {
"first inbound subscriber attached id=${sub.id} broadcast='${sub.broadcast}' track='${sub.track}'"
}
}
}
}
@@ -968,10 +907,6 @@ class MoqLiteSession internal constructor(
val sub = inboundSubs.first()
val sequence = nextSequence++
val uni = openGroupStream(subscribeId = sub.id, sequence = sequence)
Log.d("NestTx") {
"openGroup seq=$sequence keyedOnSubId=${sub.id} broadcast='${sub.broadcast}' track='${sub.track}' " +
"inboundSubsCount=${inboundSubs.size}"
}
return GroupOutbound(sequence = sequence, uni = uni)
}
}
nestsClient/src/jvmAndroid/kotlin/com/vitorpamplona/nestsclient/transport/QuicWebTransportFactory.kt
+1 -50
View File
@@ -20,7 +20,6 @@
*/
package com.vitorpamplona.nestsclient.transport
import com.vitorpamplona.quartz.utils.Log
import com.vitorpamplona.quic.connection.QuicConnection
import com.vitorpamplona.quic.connection.QuicConnectionConfig
import com.vitorpamplona.quic.connection.QuicConnectionDriver
@@ -38,12 +37,9 @@ import com.vitorpamplona.quic.webtransport.buildExtendedConnectHeaders
import com.vitorpamplona.quic.webtransport.encodeHeadersFrame
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.Job
import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.launch
/**
* Pure-Kotlin WebTransport over QUIC v1, sitting on top of every layer in
@@ -185,7 +181,7 @@ class QuicWebTransportFactory(
}
val state = QuicWebTransportSessionState(conn, driver, requestStream.streamId)
return QuicWebTransportSession(state, parentScope)
return QuicWebTransportSession(state)
} catch (we: WebTransportException) {
throw we
} catch (ce: kotlinx.coroutines.CancellationException) {
@@ -263,43 +259,9 @@ class QuicWebTransportFactory(
/** Adapter that wraps the :quic [QuicWebTransportSessionState] in the nestsClient interface. */
class QuicWebTransportSession(
private val state: QuicWebTransportSessionState,
parentScope: CoroutineScope? = null,
) : WebTransportSession {
override val isOpen: Boolean get() = state.isOpen
/**
* Periodic flow-control snapshot logger. Wakes every
* [SNAPSHOT_INTERVAL_MS] and dumps the QUIC layer's view of cap +
* count + send credit so we can correlate "audio cliff at uni
* stream #N" against "what did flow control look like at that
* moment". Cancelled when [close] tears down the session.
*
* Lazy-launched (via [parentScope]) only when the caller has
* provided a scope to host it — tests construct the session
* without one and don't need the logger.
*/
private val snapshotJob: Job? =
parentScope?.launch {
while (true) {
delay(SNAPSHOT_INTERVAL_MS)
if (!state.isOpen) break
runCatching {
val snap = state.connection.flowControlSnapshot()
Log.d("NestQuic") {
"snapshot peerInitiatedUni=${snap.peerInitiatedUniCount} " +
"advertisedMaxStreamsUni=${snap.advertisedMaxStreamsUni} " +
"peerInitMaxStreamsUni=${snap.peerInitialMaxStreamsUni} " +
"sendCredit=${snap.sendConnectionFlowCredit} " +
"consumed=${snap.sendConnectionFlowConsumed} " +
"pendingBytes=${snap.totalEnqueuedNotSentBytes} " +
"pendingStreams=${snap.streamsWithPendingBytes}/${snap.totalStreamsTracked} " +
"udpRecvDatagrams=${snap.udp?.receivedDatagrams ?: -1L} " +
"udpRecvBytes=${snap.udp?.receivedBytes ?: -1L}"
}
}
}
}
/**
* Diagnostic-only passthrough to
* [com.vitorpamplona.quic.connection.QuicConnection.flowControlSnapshot].
@@ -364,19 +326,8 @@ class QuicWebTransportSession(
code: Int,
reason: String,
) {
snapshotJob?.cancel()
state.close(code, reason)
}
private companion object {
/**
* Cadence for the periodic flow-control snapshot. 5 s is short
* enough to catch the audio-cliff transition (which lands within
* 5–15 s of subscribe) and long enough that the snapshot itself
* isn't a meaningful CPU cost.
*/
const val SNAPSHOT_INTERVAL_MS = 5_000L
}
}
private class QuicBidiStreamAdapter(
quic/src/commonMain/kotlin/com/vitorpamplona/quic/connection/QuicConnection.kt
+2 -15
View File
@@ -20,7 +20,6 @@
*/
package com.vitorpamplona.quic.connection
import com.vitorpamplona.quartz.utils.Log
import com.vitorpamplona.quic.crypto.AesEcbHeaderProtection
import com.vitorpamplona.quic.crypto.InitialSecrets
import com.vitorpamplona.quic.crypto.PlatformAesOneBlock
@@ -636,20 +635,8 @@ class QuicConnection(
// [config.initialMaxStreams*] is the lifetime maximum the peer
// can open and any longer broadcast silently truncates.
when (kind) {
StreamId.Kind.SERVER_UNI, StreamId.Kind.CLIENT_UNI -> {
peerInitiatedUniCount += 1
if (peerInitiatedUniCount % 25L == 0L) {
Log.d("NestQuic") {
"peerInitiatedUniCount=$peerInitiatedUniCount " +
"advertisedMaxStreamsUni=$advertisedMaxStreamsUni " +
"(headroom=${advertisedMaxStreamsUni - peerInitiatedUniCount})"
}
}
}
StreamId.Kind.SERVER_BIDI, StreamId.Kind.CLIENT_BIDI -> {
peerInitiatedBidiCount += 1
}
StreamId.Kind.SERVER_UNI, StreamId.Kind.CLIENT_UNI -> peerInitiatedUniCount += 1
StreamId.Kind.SERVER_BIDI, StreamId.Kind.CLIENT_BIDI -> peerInitiatedBidiCount += 1
}
// Wake any awaitIncomingPeerStream caller. trySend on a CONFLATED
// channel can never fail in steady state.
quic/src/commonMain/kotlin/com/vitorpamplona/quic/connection/QuicConnectionConfig.kt
+30 -22
View File
@@ -37,31 +37,39 @@ data class QuicConnectionConfig(
val initialMaxStreamDataUni: Long = 1L * 1024 * 1024,
val initialMaxStreamsBidi: Long = 100L,
/**
* Initial peer-initiated unidirectional stream limit. moq-rs's Quinn
* stack advertises `max_concurrent_uni_streams = 10000` for the same
* reason we now do: every Opus group is a fresh peer-initiated uni
* stream, so a long broadcast accumulates many lifetime stream IDs.
* Initial peer-initiated unidirectional stream limit. Sized to never
* trip the rolling [QuicConnectionWriter.appendFlowControlUpdates]
* extension path during a realistic audio-rooms broadcast — see
* `nestsClient/plans/2026-05-01-quic-stream-cliff-investigation.md`.
*
* Production tracing on a listener phone (Phone B receiving a Phone-A
* broadcast against `moq.nostrnests.com`) showed the cliff lands at
* exactly the moment our writer emits its first `MAX_STREAMS_UNI`
* extension at the half-window threshold (count=50 with cap=100):
* the listener receives one more stream after the bump, then UDP
* goes silent at the kernel level (`udpRecvDatagrams` frozen) while
* our QUIC state still believes the connection is alive. The relay
* propagates the listener's disconnect to the publisher (publisher
* sees `inbound SUBSCRIBE FIN'd`), but our QUIC stack never observes
* it — split-brain. The trace is reproducible across runs.
* Why a fixed-and-large initial value instead of relying on rolling
* extension: production tracing against `moq.nostrnests.com` showed
* that emitting `MAX_STREAMS_UNI` mid-connection silently breaks the
* relay's send path. The listener receives one more uni stream after
* the bump, then UDP goes dead at the kernel level
* (`udpRecvDatagrams` frozen) while our QUIC state still believes
* the connection is alive. The relay propagates the listener's
* disconnect to the publisher (`inbound SUBSCRIBE FIN'd` on the
* publisher side), but our stack never observes it — split-brain.
* Reproducible across runs. We don't yet know whether our frame is
* malformed, mis-sequenced relative to other frames in the packet,
* or hitting a moq-rs / Quinn bug — but we do know that not emitting
* the extension keeps the connection healthy.
*
* The rolling-extension code path remains in place for correctness on
* other peers (and so 100×fpg=5 broadcasts of audio-rooms longer than
* ~50 s × 5 ≈ 250 s still extend cleanly), but with this cap raised
* to 10 000 the listener won't actually need to extend until 5 000+
* groups have flowed — well past any realistic Nest duration. That
* sidesteps the malformed-or-mis-sequenced extension that's tripping
* the relay today.
* Capacity math, with [NestMoqLiteBroadcaster.DEFAULT_FRAMES_PER_GROUP]
* = 5 and Opus 20 ms: each group is one peer-initiated uni stream,
* so the relay opens ~10 streams/sec. The half-window threshold
* (`count + initialMaxStreamsUni/2 >= advertisedMaxStreamsUni`)
* trips at count = 500 000 streams, i.e. ~13.9 hours of continuous
* audio. Well past any realistic Nest duration.
*
* Memory cost: the [QuicConnection.streams] map currently grows for
* the connection's lifetime. At 10 streams/sec a 2-hour Nest leaves
* ~72k entries; per-stream overhead is small but unbounded growth
* over many hours is a known follow-up. For now this is a tolerable
* trade in exchange for not tripping the relay-side bug.
*/
val initialMaxStreamsUni: Long = 10_000L,
val initialMaxStreamsUni: Long = 1_000_000L,
val maxIdleTimeoutMillis: Long = 30_000L,
val maxUdpPayloadSize: Long = 1452L,
val activeConnectionIdLimit: Long = 4L,