cultmesh-rs: a receipt session accepts writes only on a reliable, non-sequenced channel; a test pins that a reconnect starts a fresh session
Some checks failed
CultMesh QUIC native / Build win32-x64 (pull_request) Has been skipped
CultMesh QUIC native / Build linux-x64 (pull_request) Has been skipped
CultMesh QUIC native / Release native binaries (pull_request) Has been skipped
CultMesh portability and performance / ubuntu-latest reactive semantics and leases (pull_request) Failing after 10m5s
CultMesh QUIC native / Verify committed binaries match SHA256SUMS (pull_request) Successful in 1m8s

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
Libby 2026-11-08 17:00:48 +00:00
commit e4b67a9e0b
2 changed files with 96 additions and 4 deletions

View file

@ -755,10 +755,11 @@ where
}
if packet.packet_type == CultNetRudpPacketType::Data
&& packet.channel_id == "schema"
&& !packet.reliable
&& (!packet.reliable || (packet.sequenced && self.receipts(key)))
{
// A receipt session's write that could be lost without trace cannot be answered once: it is
// refused on the reliable channel, never applied. Anything else unreliable is dropped as before.
// A receipt session's write that could be lost without trace (unreliable, or on a sequenced channel
// that drops superseded packets) cannot be answered once: it is refused, never applied. Anything
// else unreliable is dropped as before.
return self.refuse_unreliable_write(key, &packet.payload);
}
let payload_charge = if packet.packet_type == CultNetRudpPacketType::Data {
@ -1006,7 +1007,7 @@ where
})
}
/// Refuses a put or delete that arrived on an unreliable channel of a receipt session with
/// Refuses a put or delete that arrived on an unreliable or sequenced channel of a receipt session with
/// `message_invalid` (`details.field` `channel`) naming its id. Nothing is remembered or applied: the id
/// stays free for the same write sent reliably.
fn refuse_unreliable_write(

View file

@ -2922,6 +2922,97 @@ fn a_disconnected_or_server_ended_session_frees_its_remembered_writes() -> Resul
Ok(())
}
/// Receipts need a channel that is reliable and not sequenced: a reliable-sequenced write is refused like an
/// unreliable one, a reliable-unordered write is admitted, and a legacy session's sequenced write is left alone.
#[test]
fn only_reliable_non_sequenced_writes_are_accepted_on_a_receipt_session() -> Result<()> {
let sink = Sink::default();
let mut server = server(Default::default(), Clock::new(70_000), sink.clone(), Source::default())?;
let mut peer = RawPeer::connect(&mut server, 248)?;
peer.send(&receipt_hello())?;
server.poll_once()?;
let send_with = |peer: &mut RawPeer, server: &mut Server, id: &str, ordered: bool, sequenced: bool| -> Result<Vec<CultNetMessage>> {
let payload = encode_cultnet_message_to_vec(&put(id, "note:1", vec![1]), CultNetWireContract::CultNetSchemaV0)?;
let packets = peer.session.send_many(
"schema",
payload,
cultnet_rs::CultNetRudpSendOptions { reliable: true, ordered, sequenced, now_ms: 3, reliable_expire_after_ms: None },
Some(1200),
)?;
for packet in &packets {
peer.send_packet(packet)?;
}
server.poll_once()?;
let mut answers = Vec::new();
for packet in peer.drain() {
for frame in peer.session.receive(&packet, 4)?.delivered {
answers.push(decode_cultnet_message_from_slice(&frame.payload, CultNetWireContract::CultNetSchemaV0)?);
}
}
Ok(answers)
};
let sequenced = send_with(&mut peer, &mut server, "s1", false, true)?;
let refusals: Vec<_> = sequenced.iter().filter(|a| matches!(a, CultNetMessage::ErrorV1 { .. })).collect();
assert_eq!(refusals.len(), 1, "the sequenced write is answered: {sequenced:?}");
assert_eq!(refusal_of(refusals[0]), (Some(CultNetErrorCode::MessageInvalid), Some("s1".into())));
assert_eq!(
error_text_and_field(refusals[0]),
("message_invalid: receipt sessions require the reliable channel".into(), Some("channel".into()))
);
assert_eq!(sink.0.lock().unwrap().receipts.len(), 0, "nothing was applied");
let unordered = send_with(&mut peer, &mut server, "s1", false, false)?;
assert!(unordered.contains(&admitted("s1", "note:1")), "reliable unordered is accepted, and the id was not consumed: {unordered:?}");
// A fresh peer: an ordered stream waits on the sequence numbers the refused packet used.
let mut ordered_peer = RawPeer::connect(&mut server, 251)?;
ordered_peer.send(&receipt_hello())?;
server.poll_once()?;
let ordered = send_with(&mut ordered_peer, &mut server, "o1", true, false)?;
assert!(ordered.contains(&admitted("o1", "note:1")), "reliable ordered is accepted: {ordered:?}");
assert_eq!(sink.0.lock().unwrap().receipts.len(), 2);
let legacy_sink = Sink::default();
let mut legacy_server: Server = CultMeshRudpDocumentServer::new(
UdpSocket::bind("127.0.0.1:0")?,
legacy_sink.clone(),
Source::default(),
Clock::new(70_000),
Default::default(),
)?;
let mut legacy = RawPeer::connect(&mut legacy_server, 249)?;
let none = send_with(&mut legacy, &mut legacy_server, "l1", false, true)?;
assert!(none.is_empty(), "a legacy session is sent nothing: {none:?}");
assert_eq!(legacy_sink.0.lock().unwrap().receipts.len(), 1, "and its reliable-sequenced write is applied as before");
Ok(())
}
/// A Connect that does not repeat the accepted one is a new client session: it starts with nothing remembered, so
/// the id a receipt session already used is a new write on it, and the old session's entries leave the budget.
#[test]
fn a_reconnect_is_a_new_receipt_session_that_remembers_nothing_of_the_old() -> Result<()> {
let options = CultMeshRudpDocumentServerOptions { max_remembered_write_bytes: 65, ..Default::default() };
let sink = Sink::default();
let mut server = server(options, Clock::new(70_000), sink.clone(), Source::default())?;
let target = server.local_addr()?;
let shared = UdpSocket::bind("127.0.0.1:0")?;
let twin = shared.try_clone()?;
let mut first = client_on(shared, target, 250, 50_000)?;
connect(&mut server, &mut [&mut first])?;
send_reliable(&mut first, &receipt_hello())?;
send_reliable(&mut first, &put("m1", "note:a", vec![1]))?;
assert_eq!(frames_after(&mut server, &mut first, 2)?[1], admitted("m1", "note:a"));
let mut restarted = client_on(twin, target, 250, 7)?;
connect(&mut server, &mut [&mut restarted])?;
assert_eq!(server.session_count(), 1);
send_reliable(&mut restarted, &receipt_hello())?;
send_reliable(&mut restarted, &put("m1", "note:b", vec![2]))?;
let answers = frames_after(&mut server, &mut restarted, 2)?;
assert_eq!(answers[1], admitted("m1", "note:b"), "same id, other content: a new write on a new session, within a one-entry budget");
assert_eq!(sink.0.lock().unwrap().receipts.len(), 2);
Ok(())
}
/// A session that never declared the capability gets no refusal for an unreliable write: it is dropped as before.
#[test]
fn an_unreliable_write_on_a_legacy_session_is_dropped_silently() -> Result<()> {