diff --git a/packages/cultnet-py/src/cultnet_py/transport.py b/packages/cultnet-py/src/cultnet_py/transport.py index 3130c15a..1ce9a21f 100644 --- a/packages/cultnet-py/src/cultnet_py/transport.py +++ b/packages/cultnet-py/src/cultnet_py/transport.py @@ -531,11 +531,12 @@ class CultNetRudpSession: self._fragment_sets_evicted = 0 def create_connect(self, now_ms: int = 0, payload: bytes = b"") -> CultNetRudpPacket: - self._ensure_reliable_capacity(1) # A session that has had a peer starts a new generation: nothing it - # learned from that peer describes the one this Connect reaches. + # learned from that peer describes the one this Connect reaches, and + # what it still owed that peer no longer takes room in the queue. if self._connect_sequence is not None: self.reset_peer_state() + self._ensure_reliable_capacity(1) self._ended = False packet = self._create_packet( CultNetRudpPacketType.CONNECT, @@ -576,8 +577,8 @@ class CultNetRudpSession: # generation, forgets the peer and accepts a new one. if self.connect_repeats(packet): return self._answer_repeated_connect(packet, now_ms) - self._ensure_reliable_capacity(1) self.reset_peer_state() + self._ensure_reliable_capacity(1) self._seed_received(packet.sequence) self._last_received_at_ms = now_ms self._connect_sequence = packet.sequence diff --git a/packages/cultnet-py/tests/test_rudp_connect_generation.py b/packages/cultnet-py/tests/test_rudp_connect_generation.py index 77c3556f..63d21dc7 100644 --- a/packages/cultnet-py/tests/test_rudp_connect_generation.py +++ b/packages/cultnet-py/tests/test_rudp_connect_generation.py @@ -122,6 +122,26 @@ class CultNetRudpConnectGenerationTests(unittest.TestCase): client.receive(accept, 1) self.assertFalse(client.connected, "an Accept revived an abandoned Connect") + def test_a_full_queue_owed_to_a_vanished_peer_does_not_refuse_a_new_generation(self) -> None: + def bounded(initial_sequence: int) -> CultNetRudpSession: + return CultNetRudpSession( + CultNetRudpSessionOptions( + connection_id=CONNECTION_ID, initial_sequence=initial_sequence, max_pending_reliable_packets=1 + ) + ) + + server = bounded(500) + server.accept_connect(session(1).create_connect(0), 0) + self.assertEqual(server.outstanding_reliable_packet_count, 1, "the Accept is owed and never acknowledged") + following = session(9).create_connect(1) + server.accept_connect(following, 1) + self.assertTrue(server.connect_repeats(following)) + + client = bounded(1) + client.create_connect(0) + client.create_connect(1) + self.assertEqual(client.outstanding_reliable_packet_count, 1, "only the new Connect is owed") + def test_a_duplicate_accept_does_not_reseed_the_watermark(self) -> None: client, server = session(1), session(500) _, accept = handshake(client, server) diff --git a/packages/cultnet-rs/src/rudp.rs b/packages/cultnet-rs/src/rudp.rs index 9ab0472a..1da422dd 100644 --- a/packages/cultnet-rs/src/rudp.rs +++ b/packages/cultnet-rs/src/rudp.rs @@ -426,12 +426,13 @@ impl CultNetRudpSession { } pub fn create_connect(&mut self, now_ms: u64, payload: Vec) -> Result { - self.ensure_reliable_capacity(1)?; // A session that has had a peer starts a new generation: nothing it - // learned from that peer describes the one this Connect reaches. + // learned from that peer describes the one this Connect reaches, and + // what it still owed that peer no longer takes room in the queue. if self.connect_sequence.is_some() { self.reset_peer_state(); } + self.ensure_reliable_capacity(1)?; let packet = self.create_packet( CultNetRudpPacketType::Connect, "control", @@ -486,8 +487,8 @@ impl CultNetRudpSession { .unwrap_or_else(|| self.create_ack())); } - self.ensure_reliable_capacity(1)?; self.reset_peer_state(); + self.ensure_reliable_capacity(1)?; self.seed_received(packet.sequence); self.last_received_at_ms = Some(now_ms); self.connect_sequence = Some(packet.sequence); diff --git a/packages/cultnet-rs/tests/rudp_connect_generation.rs b/packages/cultnet-rs/tests/rudp_connect_generation.rs index 21a81d48..2327ec53 100644 --- a/packages/cultnet-rs/tests/rudp_connect_generation.rs +++ b/packages/cultnet-rs/tests/rudp_connect_generation.rs @@ -215,6 +215,32 @@ fn an_accept_for_an_abandoned_connect_does_not_connect_the_session() -> Result<( Ok(()) } +/// What a session still owed a vanished peer does not keep the next peer out: +/// a new generation drops it before the queue is asked for room. +#[test] +fn a_full_queue_owed_to_a_vanished_peer_does_not_refuse_a_new_generation() -> Result<()> { + let bounded = |initial_sequence: u32| { + CultNetRudpSession::new(CultNetRudpSessionOptions { + connection_id: CONNECTION_ID, + initial_sequence, + resend_delay_ms: 250, + max_pending_reliable_packets: Some(1), + }) + }; + let mut server = bounded(500); + server.accept_connect(&session(1).create_connect(0, Vec::new())?, 0, Vec::new())?; + assert_eq!(server.outstanding_reliable_packet_count(), 1, "the Accept is owed and never acknowledged"); + let next = session(9).create_connect(1, Vec::new())?; + server.accept_connect(&next, 1, Vec::new())?; + assert!(server.connect_repeats(&next)); + + let mut client = bounded(1); + client.create_connect(0, Vec::new())?; + client.create_connect(1, Vec::new())?; + assert_eq!(client.outstanding_reliable_packet_count(), 1, "only the new Connect is owed"); + Ok(()) +} + /// An Accept counts once: a duplicate of the one honoured does not seed the /// watermark again. #[test] diff --git a/packages/cultnet-ts/src/rudp.ts b/packages/cultnet-ts/src/rudp.ts index d5b0b700..ca928c24 100644 --- a/packages/cultnet-ts/src/rudp.ts +++ b/packages/cultnet-ts/src/rudp.ts @@ -281,12 +281,13 @@ export class CultNetRudpSession { } createConnect(nowMs = 0, payload = new Uint8Array()): CultNetRudpPacket { - this.#ensureReliableCapacity(1); // A session that has had a peer starts a new generation: nothing it learned - // from that peer describes the one this Connect reaches. + // from that peer describes the one this Connect reaches, and what it still + // owed that peer no longer takes room in the queue. if (this.#connectSequence !== undefined) { this.resetPeerState(); } + this.#ensureReliableCapacity(1); this.#ended = false; const packet = this.#createPacket({ packetType: "connect", @@ -324,8 +325,8 @@ export class CultNetRudpSession { if (this.connectRepeats(packet)) { return this.#answerRepeatedConnect(packet, nowMs); } - this.#ensureReliableCapacity(1); this.resetPeerState(); + this.#ensureReliableCapacity(1); this.#seedReceived(packet.sequence); this.#lastReceivedAtMs = nowMs; this.#connectSequence = packet.sequence; diff --git a/packages/cultnet-ts/test/rudp-connect-generation.test.ts b/packages/cultnet-ts/test/rudp-connect-generation.test.ts index 8f72beca..2170205a 100644 --- a/packages/cultnet-ts/test/rudp-connect-generation.test.ts +++ b/packages/cultnet-ts/test/rudp-connect-generation.test.ts @@ -117,6 +117,21 @@ test("an Accept for an abandoned Connect does not connect the session", () => { assert.equal(client.connected, false, "an Accept revived an abandoned Connect"); }); +test("a full queue owed to a vanished peer does not refuse a new generation", () => { + const bounded = (initialSequence: number) => new CultNetRudpSession({ connectionId, initialSequence, maxPendingReliablePackets: 1 }); + const server = bounded(500); + server.acceptConnect(session(1).createConnect(0), 0); + assert.equal(server.outstandingReliablePacketCount, 1, "the Accept is owed and never acknowledged"); + const next = session(9).createConnect(1); + server.acceptConnect(next, 1); + assert.equal(server.connectRepeats(next), true); + + const client = bounded(1); + client.createConnect(0); + client.createConnect(1); + assert.equal(client.outstandingReliablePacketCount, 1, "only the new Connect is owed"); +}); + test("a duplicate Accept does not reseed the watermark", () => { const client = session(1); const server = session(500); diff --git a/src/GameCult.Networking/CultNetTransport.cs b/src/GameCult.Networking/CultNetTransport.cs index f37ce540..2c704747 100644 --- a/src/GameCult.Networking/CultNetTransport.cs +++ b/src/GameCult.Networking/CultNetTransport.cs @@ -1026,11 +1026,12 @@ namespace GameCult.Networking /// public CultNetRudpPacket CreateConnect(long nowMs = 0, byte[]? payload = null) { - EnsureReliableCapacity(1); // A session that has had a peer starts a new generation: nothing it learned from that - // peer describes the one this Connect reaches. + // peer describes the one this Connect reaches, and what it still owed that peer no + // longer takes room in the queue. if (_connectSequence.HasValue) ResetPeerState(); + EnsureReliableCapacity(1); _ended = false; var packet = CreatePacket(CultNetRudpPacketType.Connect, "control", payload ?? Array.Empty(), reliable: true, ordered: true, sequenced: false); _connectSequence = packet.Sequence; @@ -1069,8 +1070,8 @@ namespace GameCult.Networking if (ConnectRepeats(packet)) return AnswerRepeatedConnect(packet, nowMs); - EnsureReliableCapacity(1); ResetPeerState(); + EnsureReliableCapacity(1); SeedReceived(packet.Sequence); _connectSequence = packet.Sequence; _connected = true; diff --git a/tests/GameCult.Networking.Tests/CultNetRudpConnectGenerationTests.cs b/tests/GameCult.Networking.Tests/CultNetRudpConnectGenerationTests.cs index fb436af4..63cfea76 100644 --- a/tests/GameCult.Networking.Tests/CultNetRudpConnectGenerationTests.cs +++ b/tests/GameCult.Networking.Tests/CultNetRudpConnectGenerationTests.cs @@ -178,6 +178,29 @@ namespace GameCult.Networking.Tests Assert.That(client.Connected, Is.False, "an Accept revived an abandoned Connect"); } + [Test] + public void AFullQueueOwedToAVanishedPeerDoesNotRefuseANewGeneration() + { + static CultNetRudpSession Bounded(uint initialSequence) => new CultNetRudpSession(new CultNetRudpSessionOptions + { + ConnectionId = ConnectionId, + InitialSequence = initialSequence, + MaxPendingReliablePackets = 1 + }); + + var server = Bounded(500); + server.AcceptConnect(Session(1).CreateConnect(0), 0); + Assert.That(server.OutstandingReliablePacketCount, Is.EqualTo(1), "the Accept is owed and never acknowledged"); + var next = Session(9).CreateConnect(1); + server.AcceptConnect(next, 1); + Assert.That(server.ConnectRepeats(next), Is.True); + + var client = Bounded(1); + client.CreateConnect(0); + client.CreateConnect(1); + Assert.That(client.OutstandingReliablePacketCount, Is.EqualTo(1), "only the new Connect is owed"); + } + [Test] public void ADuplicateAcceptDoesNotReseedTheWatermark() {