Prove RUDP reordering across runtimes
This commit is contained in:
parent
d6f5ee28b0
commit
436654de75
9 changed files with 276 additions and 32 deletions
|
|
@ -180,6 +180,11 @@ Current progress:
|
|||
dropped data packet in both directions between TypeScript and C#/Kotlin/Python/Rust.
|
||||
The drops happen below the transport connection through a UDP bridge, so the
|
||||
recovery is RUDP resend/ack behavior, not application-level retry.
|
||||
- The same harness now proves reliable ordered `schema` delivery survives
|
||||
reordered data packets in both directions between TypeScript and
|
||||
C#/Kotlin/Python/Rust. The bridge delays one packet below the transport, sends
|
||||
the following packet first, and then releases the held packet; delivered frames
|
||||
still surface in sequence.
|
||||
- TypeScript, C#, Rust, Python, and Kotlin now share the first RUDP
|
||||
fragmentation implementation: the session can split oversized reliable
|
||||
ordered payloads into fragment packets, reassemble them before delivery, and
|
||||
|
|
@ -190,8 +195,8 @@ Current progress:
|
|||
C#/Kotlin/Python/Rust one-shot UDP peers.
|
||||
- The remaining parity work is to deepen Python's server-side use of its port
|
||||
and move each runtime's existing TCP/LiteNetLib/WebSocket bodies behind those
|
||||
ports, then broaden RUDP interop into the full loss, reordering,
|
||||
reconnect, backpressure, and schema-message matrix.
|
||||
ports, then broaden RUDP interop into reconnect, backpressure, and the wider
|
||||
schema-message matrix.
|
||||
|
||||
## RUDP Packet Contract V0
|
||||
|
||||
|
|
|
|||
|
|
@ -320,6 +320,11 @@ class CultNetRudpSession:
|
|||
del now_ms
|
||||
self._require_connection(packet)
|
||||
self._apply_acknowledgements(packet)
|
||||
expected_sequence_if_uninitialized = (
|
||||
packet.sequence
|
||||
if self._highest_received_sequence is None
|
||||
else self._highest_received_sequence + 1
|
||||
)
|
||||
|
||||
if packet.packet_type == CultNetRudpPacketType.ACCEPT:
|
||||
self._remember_received(packet.sequence)
|
||||
|
|
@ -350,7 +355,11 @@ class CultNetRudpSession:
|
|||
frame, ordered, next_sequence = reassembled
|
||||
if not ordered:
|
||||
return CultNetRudpReceiveResult(delivered=(frame,))
|
||||
return CultNetRudpReceiveResult(delivered=tuple(self._deliver_ordered(frame, next_sequence)))
|
||||
return CultNetRudpReceiveResult(
|
||||
delivered=tuple(
|
||||
self._deliver_ordered(frame, next_sequence, expected_sequence_if_uninitialized)
|
||||
)
|
||||
)
|
||||
|
||||
def create_ack(self) -> CultNetRudpPacket:
|
||||
return self._create_packet(CultNetRudpPacketType.ACK, "control", b"")
|
||||
|
|
@ -472,11 +481,16 @@ class CultNetRudpSession:
|
|||
max(sequences) + 1,
|
||||
)
|
||||
|
||||
def _deliver_ordered(self, frame: CultNetRudpDeliveredFrame, next_after_frame: int) -> list[CultNetRudpDeliveredFrame]:
|
||||
def _deliver_ordered(
|
||||
self,
|
||||
frame: CultNetRudpDeliveredFrame,
|
||||
next_after_frame: int,
|
||||
expected_sequence_if_uninitialized: int,
|
||||
) -> list[CultNetRudpDeliveredFrame]:
|
||||
next_sequence = self._ordered_next_sequence_by_channel.get(frame.channel_id)
|
||||
if next_sequence is None:
|
||||
self._ordered_next_sequence_by_channel[frame.channel_id] = next_after_frame
|
||||
return [frame, *self._drain_ordered(frame.channel_id)]
|
||||
next_sequence = min(expected_sequence_if_uninitialized, frame.sequence)
|
||||
self._ordered_next_sequence_by_channel[frame.channel_id] = next_sequence
|
||||
if frame.sequence < next_sequence:
|
||||
return []
|
||||
if frame.sequence > next_sequence:
|
||||
|
|
|
|||
|
|
@ -256,6 +256,7 @@ class CultNetRudpSession(options: CultNetRudpSessionOptions) {
|
|||
val ignoredNow = nowMs
|
||||
requireConnection(packet)
|
||||
applyAcknowledgements(packet)
|
||||
val expectedSequenceIfUninitialized = (highestReceivedSequence ?: (packet.sequence - 1)) + 1
|
||||
when (packet.packetType) {
|
||||
CultNetRudpPacketType.Accept -> {
|
||||
rememberReceived(packet.sequence)
|
||||
|
|
@ -278,7 +279,7 @@ class CultNetRudpSession(options: CultNetRudpSessionOptions) {
|
|||
rememberReceived(packet.sequence)
|
||||
if (duplicate) return CultNetRudpReceiveResult()
|
||||
val reassembled = reassemble(packet) ?: return CultNetRudpReceiveResult()
|
||||
return CultNetRudpReceiveResult(delivered = if (reassembled.ordered) deliverOrdered(reassembled.frame, reassembled.nextSequence) else listOf(reassembled.frame))
|
||||
return CultNetRudpReceiveResult(delivered = if (reassembled.ordered) deliverOrdered(reassembled.frame, reassembled.nextSequence, expectedSequenceIfUninitialized) else listOf(reassembled.frame))
|
||||
}
|
||||
|
||||
fun createAck(): CultNetRudpPacket = createPacket(CultNetRudpPacketType.Ack, "control", ByteArray(0))
|
||||
|
|
@ -364,11 +365,13 @@ class CultNetRudpSession(options: CultNetRudpSessionOptions) {
|
|||
return ReassembledFrame(CultNetRudpDeliveredFrame(buffer.channelId, payload, sequences.minOrNull() ?: packet.sequence), buffer.ordered, (sequences.maxOrNull() ?: packet.sequence) + 1)
|
||||
}
|
||||
|
||||
private fun deliverOrdered(frame: CultNetRudpDeliveredFrame, nextSequenceAfterFrame: Long): List<CultNetRudpDeliveredFrame> {
|
||||
val next = orderedNextSequenceByChannel[frame.channelId]
|
||||
if (next == null) {
|
||||
orderedNextSequenceByChannel[frame.channelId] = nextSequenceAfterFrame
|
||||
return listOf(frame) + drainOrdered(frame.channelId)
|
||||
private fun deliverOrdered(
|
||||
frame: CultNetRudpDeliveredFrame,
|
||||
nextSequenceAfterFrame: Long,
|
||||
expectedSequenceIfUninitialized: Long,
|
||||
): List<CultNetRudpDeliveredFrame> {
|
||||
val next = orderedNextSequenceByChannel[frame.channelId] ?: minOf(expectedSequenceIfUninitialized, frame.sequence).also {
|
||||
orderedNextSequenceByChannel[frame.channelId] = it
|
||||
}
|
||||
if (frame.sequence < next) return emptyList()
|
||||
if (frame.sequence > next) {
|
||||
|
|
@ -596,6 +599,7 @@ private fun rudpServeOnce(options: Map<String, String>) {
|
|||
val bindPort = options["bind-port"]?.toInt() ?: 0
|
||||
val expectedClientPayload = (options["client-payload"] ?: "ts-kotlin-client-state").toByteArray(StandardCharsets.UTF_8)
|
||||
val serverPayload = (options["server-payload"] ?: "kotlin-server-state").toByteArray(StandardCharsets.UTF_8)
|
||||
val serverExtraPayload = options["server-extra-payload"]?.toByteArray(StandardCharsets.UTF_8)
|
||||
val maxFragmentBytes = options["max-fragment-bytes"]?.toInt()
|
||||
val socket = DatagramSocket(bindPort, InetAddress.getByName(bindHost)).also { it.soTimeout = 20 }
|
||||
CultNetRudpSocketTransportConnection(
|
||||
|
|
@ -614,6 +618,9 @@ private fun rudpServeOnce(options: Map<String, String>) {
|
|||
if (frame != null) {
|
||||
requireRudpFrame(frame, "schema", expectedClientPayload)
|
||||
transport.send("schema", serverPayload)
|
||||
if (serverExtraPayload != null) {
|
||||
transport.send("schema", serverExtraPayload)
|
||||
}
|
||||
pollRudpAfterSend(transport, 250)
|
||||
println("""{"status":"ok"}""")
|
||||
return
|
||||
|
|
|
|||
|
|
@ -466,6 +466,9 @@ fn rudp_serve_once(options: &BTreeMap<String, String>) -> Result<()> {
|
|||
.get("server-payload")
|
||||
.map(|value| value.as_bytes().to_vec())
|
||||
.unwrap_or_else(|| b"rust-server-state".to_vec());
|
||||
let server_extra_payload = options
|
||||
.get("server-extra-payload")
|
||||
.map(|value| value.as_bytes().to_vec());
|
||||
let max_fragment_bytes = options
|
||||
.get("max-fragment-bytes")
|
||||
.map(|value| value.parse::<u32>())
|
||||
|
|
@ -498,6 +501,9 @@ fn rudp_serve_once(options: &BTreeMap<String, String>) -> Result<()> {
|
|||
));
|
||||
}
|
||||
transport.send("schema", server_payload.clone())?;
|
||||
if let Some(extra_payload) = &server_extra_payload {
|
||||
transport.send("schema", extra_payload.clone())?;
|
||||
}
|
||||
poll_rudp_after_send(&mut transport, Duration::from_millis(250))?;
|
||||
print_json(&serde_json::json!({ "status": "ok" }))?;
|
||||
return Ok(());
|
||||
|
|
|
|||
|
|
@ -277,6 +277,10 @@ impl CultNetRudpSession {
|
|||
) -> Result<CultNetRudpReceiveResult> {
|
||||
self.require_connection(packet)?;
|
||||
self.apply_acknowledgements(packet);
|
||||
let expected_sequence_if_uninitialized = self
|
||||
.highest_received_sequence
|
||||
.map(|sequence| sequence + 1)
|
||||
.unwrap_or(packet.sequence);
|
||||
|
||||
if packet.packet_type == CultNetRudpPacketType::Accept {
|
||||
self.remember_received(packet.sequence);
|
||||
|
|
@ -335,7 +339,7 @@ impl CultNetRudpSession {
|
|||
});
|
||||
};
|
||||
let delivered = if ordered {
|
||||
self.deliver_ordered(frame, next_sequence)
|
||||
self.deliver_ordered(frame, next_sequence, expected_sequence_if_uninitialized)
|
||||
} else {
|
||||
vec![frame]
|
||||
};
|
||||
|
|
@ -548,18 +552,21 @@ impl CultNetRudpSession {
|
|||
&mut self,
|
||||
frame: CultNetRudpDeliveredFrame,
|
||||
next_sequence_after_frame: u32,
|
||||
expected_sequence_if_uninitialized: u32,
|
||||
) -> Vec<CultNetRudpDeliveredFrame> {
|
||||
let channel_id = frame.channel_id.clone();
|
||||
let Some(next) = self
|
||||
let next = if let Some(next) = self
|
||||
.ordered_next_sequence_by_channel
|
||||
.get(&channel_id)
|
||||
.copied()
|
||||
else {
|
||||
self.ordered_next_sequence_by_channel
|
||||
.insert(channel_id.clone(), next_sequence_after_frame);
|
||||
let mut delivered = vec![frame];
|
||||
delivered.extend(self.drain_ordered(&channel_id));
|
||||
return delivered;
|
||||
{
|
||||
next
|
||||
} else {
|
||||
self.ordered_next_sequence_by_channel.insert(
|
||||
channel_id.clone(),
|
||||
expected_sequence_if_uninitialized.min(frame.sequence),
|
||||
);
|
||||
expected_sequence_if_uninitialized.min(frame.sequence)
|
||||
};
|
||||
|
||||
if frame.sequence < next {
|
||||
|
|
|
|||
|
|
@ -240,6 +240,9 @@ export class CultNetRudpSession {
|
|||
receive(packet: CultNetRudpPacket, nowMs = 0): CultNetRudpReceiveResult {
|
||||
this.#requireConnection(packet);
|
||||
this.#applyAcknowledgements(packet);
|
||||
const expectedSequenceIfUninitialized = this.#highestReceivedSequence === undefined
|
||||
? packet.sequence
|
||||
: this.#highestReceivedSequence + 1;
|
||||
|
||||
if (packet.packetType === "accept") {
|
||||
this.#rememberReceived(packet.sequence);
|
||||
|
|
@ -283,7 +286,7 @@ export class CultNetRudpSession {
|
|||
return { delivered: [reassembled.frame] };
|
||||
}
|
||||
|
||||
return { delivered: this.#deliverOrdered(reassembled.frame, reassembled.nextSequence) };
|
||||
return { delivered: this.#deliverOrdered(reassembled.frame, reassembled.nextSequence, expectedSequenceIfUninitialized) };
|
||||
}
|
||||
|
||||
createAck(): CultNetRudpPacket {
|
||||
|
|
@ -449,14 +452,15 @@ export class CultNetRudpSession {
|
|||
};
|
||||
}
|
||||
|
||||
#deliverOrdered(frame: CultNetRudpDeliveredFrame, nextSequence: number): CultNetRudpDeliveredFrame[] {
|
||||
const next = this.#orderedNextSequenceByChannel.get(frame.channelId);
|
||||
#deliverOrdered(
|
||||
frame: CultNetRudpDeliveredFrame,
|
||||
nextSequence: number,
|
||||
expectedSequenceIfUninitialized: number,
|
||||
): CultNetRudpDeliveredFrame[] {
|
||||
let next = this.#orderedNextSequenceByChannel.get(frame.channelId);
|
||||
if (next === undefined) {
|
||||
this.#orderedNextSequenceByChannel.set(frame.channelId, nextSequence);
|
||||
return [
|
||||
frame,
|
||||
...this.#drainOrdered(frame.channelId),
|
||||
];
|
||||
next = Math.min(expectedSequenceIfUninitialized, frame.sequence);
|
||||
this.#orderedNextSequenceByChannel.set(frame.channelId, next);
|
||||
}
|
||||
|
||||
if (frame.sequence < next) {
|
||||
|
|
|
|||
|
|
@ -81,6 +81,7 @@ interface RudpServerInteropPeerSpec {
|
|||
interface RudpServerSpawnOptions {
|
||||
clientPayload?: string;
|
||||
serverPayload?: string;
|
||||
serverExtraPayload?: string;
|
||||
maxFragmentBytes?: number;
|
||||
}
|
||||
|
||||
|
|
@ -138,6 +139,8 @@ from cultnet_py import (
|
|||
|
||||
expected_client_payload = os.environ.get("RUDP_CLIENT_PAYLOAD", "client-state").encode()
|
||||
server_payload = os.environ.get("RUDP_SERVER_PAYLOAD", "python-state").encode()
|
||||
server_extra_payload_raw = os.environ.get("RUDP_SERVER_EXTRA_PAYLOAD")
|
||||
server_extra_payload = server_extra_payload_raw.encode() if server_extra_payload_raw else None
|
||||
max_fragment_bytes_raw = os.environ.get("RUDP_MAX_FRAGMENT_BYTES")
|
||||
max_fragment_bytes = int(max_fragment_bytes_raw) if max_fragment_bytes_raw else None
|
||||
|
||||
|
|
@ -166,6 +169,8 @@ while time.time() < deadline:
|
|||
transport.close()
|
||||
raise SystemExit(f"unexpected RUDP frame: {frame.channel_id!r} {frame.payload!r}")
|
||||
transport.send("schema", server_payload)
|
||||
if server_extra_payload is not None:
|
||||
transport.send("schema", server_extra_payload)
|
||||
print("OK", flush=True)
|
||||
ack_deadline = time.time() + 0.25
|
||||
while time.time() < ack_deadline:
|
||||
|
|
@ -1166,6 +1171,123 @@ test("CultNet RUDP reliable schema response survives one dropped server data pac
|
|||
}
|
||||
});
|
||||
|
||||
test("CultNet RUDP reliable schema delivery survives reordered client data packets across runtimes", async () => {
|
||||
for (const peer of rudpServerInteropPeers()) {
|
||||
await peer.build();
|
||||
const serverPeer = peer.spawn();
|
||||
const clientSocket = await bindUdpSocket();
|
||||
const lossyBridge = await createRudpLossyBridge({
|
||||
remoteHost: "127.0.0.1",
|
||||
remotePort: await serverPeer.ready,
|
||||
shouldDelayClientPacket: (wire) => {
|
||||
const packet = decodeRudpPacket(wire);
|
||||
return packet.packetType === "data"
|
||||
&& packet.channelId === "schema"
|
||||
&& Buffer.from(packet.payload ?? []).equals(Buffer.from(peer.clientPayload));
|
||||
},
|
||||
});
|
||||
let client: CultNetRudpSocketTransportConnection | undefined;
|
||||
|
||||
try {
|
||||
client = new CultNetRudpSocketTransportConnection({
|
||||
runtimeId: `ts-reordered-${peer.name.replace(/\W/g, "").toLowerCase()}-rudp-interop`,
|
||||
socket: clientSocket,
|
||||
mode: "client",
|
||||
remoteHost: "127.0.0.1",
|
||||
remotePort: lossyBridge.port,
|
||||
connectionId: peer.connectionId,
|
||||
initialSequence: 1,
|
||||
resendDelayMs: 25,
|
||||
resendPollMs: 5,
|
||||
});
|
||||
|
||||
const receivedFrame = once(client, "frame");
|
||||
client.connect(Buffer.from(peer.joinPayload));
|
||||
await waitFor(() => client?.connected === true, `TypeScript RUDP client to complete ${peer.name} handshake through reorder bridge`);
|
||||
client.send("schema", Buffer.from(peer.clientPayload));
|
||||
client.send("schema", Buffer.from(`${peer.clientPayload}:second`));
|
||||
|
||||
const [frame] = await withTimeout(receivedFrame, 2_000, `${peer.name} RUDP response frame after reordered client data packets`);
|
||||
assert.equal(frame.channelId, "schema");
|
||||
assert.deepEqual(Buffer.from(frame.payload), Buffer.from(peer.expectedPayload));
|
||||
assert.equal(lossyBridge.delayedClientPackets, 1, `${peer.name} bridge should delay exactly one client data packet`);
|
||||
|
||||
const [exitCode] = await withTimeout(once(serverPeer.child, "exit"), 2_000, `${peer.name} RUDP peer exit after reordered delivery`);
|
||||
assert.equal(exitCode, 0, serverPeer.stderr.join(""));
|
||||
} finally {
|
||||
if (client) {
|
||||
client.close();
|
||||
} else {
|
||||
clientSocket.close();
|
||||
}
|
||||
lossyBridge.close();
|
||||
if (serverPeer.child.exitCode === null && !serverPeer.child.killed) {
|
||||
serverPeer.child.kill("SIGTERM");
|
||||
await once(serverPeer.child, "exit").catch(() => undefined);
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
test("CultNet RUDP reliable schema response survives reordered server data packets across runtimes", async () => {
|
||||
for (const peer of rudpServerInteropPeers()) {
|
||||
await peer.build();
|
||||
const serverPeer = peer.spawn({
|
||||
serverExtraPayload: `${peer.expectedPayload}:second`,
|
||||
});
|
||||
const clientSocket = await bindUdpSocket();
|
||||
const lossyBridge = await createRudpLossyBridge({
|
||||
remoteHost: "127.0.0.1",
|
||||
remotePort: await serverPeer.ready,
|
||||
shouldDelayServerPacket: (wire) => {
|
||||
const packet = decodeRudpPacket(wire);
|
||||
return packet.packetType === "data"
|
||||
&& packet.channelId === "schema"
|
||||
&& Buffer.from(packet.payload ?? []).equals(Buffer.from(peer.expectedPayload));
|
||||
},
|
||||
});
|
||||
let client: CultNetRudpSocketTransportConnection | undefined;
|
||||
|
||||
try {
|
||||
client = new CultNetRudpSocketTransportConnection({
|
||||
runtimeId: `ts-server-reordered-${peer.name.replace(/\W/g, "").toLowerCase()}-rudp-interop`,
|
||||
socket: clientSocket,
|
||||
mode: "client",
|
||||
remoteHost: "127.0.0.1",
|
||||
remotePort: lossyBridge.port,
|
||||
connectionId: peer.connectionId,
|
||||
initialSequence: 1,
|
||||
resendDelayMs: 25,
|
||||
resendPollMs: 5,
|
||||
});
|
||||
|
||||
const receivedFrame = once(client, "frame");
|
||||
client.connect(Buffer.from(peer.joinPayload));
|
||||
await waitFor(() => client?.connected === true, `TypeScript RUDP client to complete ${peer.name} handshake through server reorder bridge`);
|
||||
client.send("schema", Buffer.from(peer.clientPayload));
|
||||
|
||||
const [frame] = await withTimeout(receivedFrame, 2_000, `${peer.name} RUDP response frame after reordered server data packets`);
|
||||
assert.equal(frame.channelId, "schema");
|
||||
assert.deepEqual(Buffer.from(frame.payload), Buffer.from(peer.expectedPayload));
|
||||
assert.equal(lossyBridge.delayedServerPackets, 1, `${peer.name} bridge should delay exactly one server data packet`);
|
||||
|
||||
const [exitCode] = await withTimeout(once(serverPeer.child, "exit"), 2_000, `${peer.name} RUDP peer exit after server reorder`);
|
||||
assert.equal(exitCode, 0, serverPeer.stderr.join(""));
|
||||
} finally {
|
||||
if (client) {
|
||||
client.close();
|
||||
} else {
|
||||
clientSocket.close();
|
||||
}
|
||||
lossyBridge.close();
|
||||
if (serverPeer.child.exitCode === null && !serverPeer.child.killed) {
|
||||
serverPeer.child.kill("SIGTERM");
|
||||
await once(serverPeer.child, "exit").catch(() => undefined);
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
test("CultNet RUDP fragmented schema frames cross runtime boundaries", async () => {
|
||||
for (const peer of rudpServerInteropPeers()) {
|
||||
await peer.build();
|
||||
|
|
@ -1378,6 +1500,7 @@ function spawnPythonRudpPeer(options: RudpServerSpawnOptions = {}): RunningPytho
|
|||
PYTHONPATH: cultcachePySrc,
|
||||
...(options.clientPayload ? { RUDP_CLIENT_PAYLOAD: options.clientPayload } : {}),
|
||||
...(options.serverPayload ? { RUDP_SERVER_PAYLOAD: options.serverPayload } : {}),
|
||||
...(options.serverExtraPayload ? { RUDP_SERVER_EXTRA_PAYLOAD: options.serverExtraPayload } : {}),
|
||||
...(options.maxFragmentBytes ? { RUDP_MAX_FRAGMENT_BYTES: String(options.maxFragmentBytes) } : {}),
|
||||
},
|
||||
stdio: ["ignore", "pipe", "pipe"],
|
||||
|
|
@ -1430,6 +1553,7 @@ function spawnRustRudpServer(options: RudpServerSpawnOptions = {}): RunningPytho
|
|||
"--bind-host", "127.0.0.1",
|
||||
...(options.clientPayload ? ["--client-payload", options.clientPayload] : []),
|
||||
...(options.serverPayload ? ["--server-payload", options.serverPayload] : []),
|
||||
...(options.serverExtraPayload ? ["--server-extra-payload", options.serverExtraPayload] : []),
|
||||
...(options.maxFragmentBytes ? ["--max-fragment-bytes", String(options.maxFragmentBytes)] : []),
|
||||
], {
|
||||
cwd: cultnetRsRoot,
|
||||
|
|
@ -1487,6 +1611,7 @@ function spawnCSharpRudpServer(options: RudpServerSpawnOptions = {}): RunningPyt
|
|||
"--bind-host", "127.0.0.1",
|
||||
...(options.clientPayload ? ["--client-payload", options.clientPayload] : []),
|
||||
...(options.serverPayload ? ["--server-payload", options.serverPayload] : []),
|
||||
...(options.serverExtraPayload ? ["--server-extra-payload", options.serverExtraPayload] : []),
|
||||
...(options.maxFragmentBytes ? ["--max-fragment-bytes", String(options.maxFragmentBytes)] : []),
|
||||
], {
|
||||
cwd: cultLibRoot,
|
||||
|
|
@ -1545,6 +1670,7 @@ function spawnKotlinRudpServer(options: RudpServerSpawnOptions = {}): RunningPyt
|
|||
"--bind-host", "127.0.0.1",
|
||||
...(options.clientPayload ? ["--client-payload", options.clientPayload] : []),
|
||||
...(options.serverPayload ? ["--server-payload", options.serverPayload] : []),
|
||||
...(options.serverExtraPayload ? ["--server-extra-payload", options.serverExtraPayload] : []),
|
||||
...(options.maxFragmentBytes ? ["--max-fragment-bytes", String(options.maxFragmentBytes)] : []),
|
||||
], {
|
||||
cwd: cultLibRoot,
|
||||
|
|
@ -1686,6 +1812,8 @@ interface RudpLossyBridge {
|
|||
port: number;
|
||||
readonly droppedClientPackets: number;
|
||||
readonly droppedServerPackets: number;
|
||||
readonly delayedClientPackets: number;
|
||||
readonly delayedServerPackets: number;
|
||||
close(): void;
|
||||
}
|
||||
|
||||
|
|
@ -1694,12 +1822,46 @@ async function createRudpLossyBridge(options: {
|
|||
remotePort: number;
|
||||
shouldDropClientPacket?: (wire: Buffer) => boolean;
|
||||
shouldDropServerPacket?: (wire: Buffer) => boolean;
|
||||
shouldDelayClientPacket?: (wire: Buffer) => boolean;
|
||||
shouldDelayServerPacket?: (wire: Buffer) => boolean;
|
||||
}): Promise<RudpLossyBridge> {
|
||||
const socket = dgram.createSocket("udp4");
|
||||
const remote = { address: options.remoteHost, port: options.remotePort };
|
||||
let client: { address: string; port: number } | undefined;
|
||||
let droppedClientPackets = 0;
|
||||
let droppedServerPackets = 0;
|
||||
let delayedClientPackets = 0;
|
||||
let delayedServerPackets = 0;
|
||||
let heldClientWire: Buffer | undefined;
|
||||
let heldServerWire: Buffer | undefined;
|
||||
let heldClientTimer: NodeJS.Timeout | undefined;
|
||||
let heldServerTimer: NodeJS.Timeout | undefined;
|
||||
|
||||
const flushHeldClient = () => {
|
||||
if (!heldClientWire) {
|
||||
return;
|
||||
}
|
||||
const wire = heldClientWire;
|
||||
heldClientWire = undefined;
|
||||
if (heldClientTimer) {
|
||||
clearTimeout(heldClientTimer);
|
||||
heldClientTimer = undefined;
|
||||
}
|
||||
socket.send(wire, remote.port, remote.address);
|
||||
};
|
||||
|
||||
const flushHeldServer = () => {
|
||||
if (!heldServerWire || !client) {
|
||||
return;
|
||||
}
|
||||
const wire = heldServerWire;
|
||||
heldServerWire = undefined;
|
||||
if (heldServerTimer) {
|
||||
clearTimeout(heldServerTimer);
|
||||
heldServerTimer = undefined;
|
||||
}
|
||||
socket.send(wire, client.port, client.address);
|
||||
};
|
||||
|
||||
socket.on("message", (wire, sender) => {
|
||||
if (sender.address === remote.address && sender.port === remote.port) {
|
||||
|
|
@ -1707,8 +1869,15 @@ async function createRudpLossyBridge(options: {
|
|||
droppedServerPackets += 1;
|
||||
return;
|
||||
}
|
||||
if (delayedServerPackets === 0 && options.shouldDelayServerPacket?.(wire)) {
|
||||
delayedServerPackets += 1;
|
||||
heldServerWire = Buffer.from(wire);
|
||||
heldServerTimer = setTimeout(flushHeldServer, 25);
|
||||
return;
|
||||
}
|
||||
if (client) {
|
||||
socket.send(wire, client.port, client.address);
|
||||
flushHeldServer();
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
|
@ -1718,8 +1887,15 @@ async function createRudpLossyBridge(options: {
|
|||
droppedClientPackets += 1;
|
||||
return;
|
||||
}
|
||||
if (delayedClientPackets === 0 && options.shouldDelayClientPacket?.(wire)) {
|
||||
delayedClientPackets += 1;
|
||||
heldClientWire = Buffer.from(wire);
|
||||
heldClientTimer = setTimeout(flushHeldClient, 25);
|
||||
return;
|
||||
}
|
||||
|
||||
socket.send(wire, remote.port, remote.address);
|
||||
flushHeldClient();
|
||||
});
|
||||
|
||||
await new Promise<void>((resolveBind, rejectBind) => {
|
||||
|
|
@ -1738,7 +1914,19 @@ async function createRudpLossyBridge(options: {
|
|||
get droppedServerPackets() {
|
||||
return droppedServerPackets;
|
||||
},
|
||||
get delayedClientPackets() {
|
||||
return delayedClientPackets;
|
||||
},
|
||||
get delayedServerPackets() {
|
||||
return delayedServerPackets;
|
||||
},
|
||||
close() {
|
||||
if (heldClientTimer) {
|
||||
clearTimeout(heldClientTimer);
|
||||
}
|
||||
if (heldServerTimer) {
|
||||
clearTimeout(heldServerTimer);
|
||||
}
|
||||
socket.close();
|
||||
},
|
||||
};
|
||||
|
|
|
|||
|
|
@ -724,6 +724,9 @@ namespace GameCult.Networking
|
|||
{
|
||||
RequireConnection(packet);
|
||||
ApplyAcknowledgements(packet);
|
||||
var expectedSequenceIfUninitialized = _highestReceivedSequence.HasValue
|
||||
? _highestReceivedSequence.Value + 1
|
||||
: packet.Sequence;
|
||||
|
||||
if (packet.PacketType == CultNetRudpPacketType.Accept)
|
||||
{
|
||||
|
|
@ -774,7 +777,7 @@ namespace GameCult.Networking
|
|||
return new CultNetRudpReceiveResult
|
||||
{
|
||||
Delivered = reassembled.Ordered
|
||||
? DeliverOrdered(reassembled.Frame, reassembled.NextSequence)
|
||||
? DeliverOrdered(reassembled.Frame, reassembled.NextSequence, expectedSequenceIfUninitialized)
|
||||
: new[] { reassembled.Frame }
|
||||
};
|
||||
}
|
||||
|
|
@ -972,12 +975,15 @@ namespace GameCult.Networking
|
|||
};
|
||||
}
|
||||
|
||||
private IReadOnlyList<CultNetRudpDeliveredFrame> DeliverOrdered(CultNetRudpDeliveredFrame frame, uint nextSequenceAfterFrame)
|
||||
private IReadOnlyList<CultNetRudpDeliveredFrame> DeliverOrdered(
|
||||
CultNetRudpDeliveredFrame frame,
|
||||
uint nextSequenceAfterFrame,
|
||||
uint expectedSequenceIfUninitialized)
|
||||
{
|
||||
if (!_orderedNextSequenceByChannel.TryGetValue(frame.ChannelId, out var next))
|
||||
{
|
||||
_orderedNextSequenceByChannel[frame.ChannelId] = nextSequenceAfterFrame;
|
||||
return new[] { frame }.Concat(DrainOrdered(frame.ChannelId)).ToArray();
|
||||
next = Math.Min(expectedSequenceIfUninitialized, frame.Sequence);
|
||||
_orderedNextSequenceByChannel[frame.ChannelId] = next;
|
||||
}
|
||||
|
||||
if (frame.Sequence < next)
|
||||
|
|
|
|||
|
|
@ -589,6 +589,9 @@ static void RudpServeOnce(Dictionary<string, string> options)
|
|||
var serverPayload = Ascii(options.TryGetValue("server-payload", out var configuredServerPayload)
|
||||
? configuredServerPayload
|
||||
: "csharp-server-state");
|
||||
var serverExtraPayload = options.TryGetValue("server-extra-payload", out var configuredServerExtraPayload)
|
||||
? Ascii(configuredServerExtraPayload)
|
||||
: null;
|
||||
var maxFragmentBytes = options.TryGetValue("max-fragment-bytes", out var configuredMaxFragmentBytes)
|
||||
? int.Parse(configuredMaxFragmentBytes, CultureInfo.InvariantCulture)
|
||||
: (int?)null;
|
||||
|
|
@ -622,6 +625,10 @@ static void RudpServeOnce(Dictionary<string, string> options)
|
|||
{
|
||||
RequireRudpFrameBytes(frame, "schema", expectedClientPayload);
|
||||
transport.Send("schema", serverPayload);
|
||||
if (serverExtraPayload != null)
|
||||
{
|
||||
transport.Send("schema", serverExtraPayload);
|
||||
}
|
||||
PollRudpAfterSend(transport, TimeSpan.FromMilliseconds(250));
|
||||
WriteJsonLine(new { status = "ok" });
|
||||
return;
|
||||
|
|
|
|||
Loading…
Reference in a new issue