Fix extended-region scene rendering and delivery

crates/libremetaverse/tests/network_manager.rs

@@ -9,15 +9,16 @@ use libremetaverse::messages::linden::{
     EnableSimulatorMessage, EnableSimulatorMessageSimulatorInfoBlock,
 };
 use libremetaverse::packets::{
-    CompleteAgentMovementPacket, DisableSimulatorPacket, LogoutReplyPacket,
+    AgentThrottlePacket, CompleteAgentMovementPacket, DisableSimulatorPacket, LogoutReplyPacket,
     LogoutReplyPacketInventoryDataBlock, LogoutRequestPacket, Packet, PacketAckPacket,
     PacketAckPacketPacketsBlock, PacketType, RegionHandshakePacket, RegionHandshakeReplyPacket,
     SimStatsPacket, SimStatsPacketStatBlock, StartPingCheckPacket, UseCircuitCodePacket,
 };
 use libremetaverse::{
-    CapsEventDictionary, CapsEventQueueCallback, GridClient, Helpers, HttpCapsClient,
-    InventoryItem, LoginState, LoginStatus, NetworkManager, NetworkManagerDisconnectType,
-    NetworkManagerLoginResponseCallback, PacketEventDictionary, Simulator,
+    AgentThrottle, CapsEventDictionary, CapsEventQueueCallback, GridClient, Helpers,
+    HttpCapsClient, InventoryItem, LoginState, LoginStatus, NetworkManager,
+    NetworkManagerDisconnectType, NetworkManagerLoginResponseCallback, PacketEventDictionary,
+    Simulator,
 };
 use libremetaverse_structured_data::{OSD, OSDMap, OSDParser};
 use libremetaverse_types::compat::{
@@ -417,6 +418,7 @@ enum ServerCommand {
     Disable,
     ExpectEconomy,
     Handoff,
+    ExpectThrottle,
     ExpectLogout,
     LogoutReply(Vec<UUID>),
     Stop,
@@ -431,6 +433,7 @@ enum ServerReport {
     Logout(UUID, UUID),
     Movement(u32),
     Ping(u8),
+    Throttle(u32, Vec<u8>),
 }
 
 struct FakeServer {
@@ -650,6 +653,35 @@ fn spawn_fake_server() -> FakeServer {
                         break;
                     }
                 }
+                ServerCommand::ExpectThrottle => loop {
+                    let (length, _) = socket.recv_from(&mut buffer).expect("AgentThrottle");
+                    if packet_type(&buffer[..length]) != Some(PacketType::AgentThrottle) {
+                        continue;
+                    }
+                    let mut bytes = buffer[..length].to_vec();
+                    if bytes[0] & Helpers::MSG_ZEROCODED != 0 {
+                        let mut decoded = vec![0; 8192];
+                        let decoded_length = Helpers::zero_decode(
+                            Some(&bytes),
+                            i32::try_from(bytes.len()).unwrap(),
+                            Some(&mut decoded),
+                        )
+                        .unwrap();
+                        decoded.truncate(usize::try_from(decoded_length).unwrap());
+                        decoded[0] &= !Helpers::MSG_ZEROCODED;
+                        bytes = decoded;
+                    }
+                    let mut position = 0;
+                    let packet =
+                        AgentThrottlePacket::new_with_bytes_int32(bytes, &mut position).unwrap();
+                    report_sender
+                        .send(ServerReport::Throttle(
+                            packet.agent_data.circuit_code,
+                            packet.throttle.throttles,
+                        ))
+                        .unwrap();
+                    break;
+                },
                 ServerCommand::ExpectLogout => loop {
                     let (length, _) = socket.recv_from(&mut buffer).expect("LogoutRequest");
                     if packet_type(&buffer[..length]) != Some(PacketType::LogoutRequest) {
@@ -772,6 +804,46 @@ fn assert_reuse_preserves_connected_override(
     manager.set_connected(true);
 }
 
+#[test]
+fn grid_client_throttle_sender_writes_agent_throttle_to_the_simulator() {
+    let _network_guard = network_test_guard();
+    let server = spawn_fake_server();
+    let client = GridClient::new().expect("client");
+    let mut manager = NetworkManager::new(client.clone()).expect("manager");
+    manager.set_circuit_code(0x4455_6677);
+    let simulator = manager
+        .connect_with_ip_end_point_u_int64_boolean_uri_u_int32_u_int32(
+            server.endpoint,
+            0x1234,
+            true,
+            None,
+            256,
+            256,
+        )
+        .unwrap()
+        .expect("simulator");
+    assert_eq!(
+        server.reports.recv_timeout(Duration::from_secs(1)).unwrap(),
+        ServerReport::Circuit(0x4455_6677)
+    );
+    assert_eq!(
+        server.reports.recv_timeout(Duration::from_secs(1)).unwrap(),
+        ServerReport::HandshakeReply(0x1 | 0x2 | 0x4)
+    );
+
+    let throttle = AgentThrottle::new_with_grid_client(client).unwrap();
+    server.commands.send(ServerCommand::ExpectThrottle).unwrap();
+    throttle.set_with_simulator(Some(simulator)).unwrap();
+    assert_eq!(
+        server.reports.recv_timeout(Duration::from_secs(1)).unwrap(),
+        ServerReport::Throttle(0x4455_6677, throttle.to_bytes().unwrap())
+    );
+
+    manager
+        .shutdown_with_disconnect_type(NetworkManagerDisconnectType::ClientInitiated)
+        .unwrap();
+}
+
 #[test]
 fn fake_server_drives_circuit_handshake_ping_disable_and_disconnect_reasons() {
     let _network_guard = network_test_guard();