Complete first release candidate audit (#107)

crates/libremetaverse/src/client_core.rs

@@ -117,6 +117,8 @@ struct ClientRuntime {
     agent_throttle_sender: Mutex<Option<Arc<dyn crate::udp_transport::AgentThrottleSender>>>,
     http_caps_client: Mutex<crate::caps_http::HttpCapsClient>,
     caps_rate_limiter: Mutex<crate::caps_http::CapsRateLimiter>,
+    utilization_statistics: Mutex<crate::stats::UtilizationStatistics>,
+    throttle: Mutex<crate::AgentThrottle>,
     network_manager: Mutex<std::sync::Weak<crate::network_manager::NetworkManagerInner>>,
     agent_manager: Mutex<std::sync::Weak<crate::agent_manager::AgentManagerInner>>,
     object_manager: Mutex<Option<Arc<crate::object_manager::ObjectManagerInner>>>,
@@ -169,6 +171,11 @@ impl ClientRuntime {
             agent_throttle_sender: Mutex::new(None),
             http_caps_client: Mutex::new(http_caps_client),
             caps_rate_limiter: Mutex::new(caps_rate_limiter),
+            utilization_statistics: Mutex::new(
+                crate::stats::UtilizationStatistics::new()
+                    .expect("utilization statistics construction is infallible"),
+            ),
+            throttle: Mutex::new(crate::AgentThrottle::default()),
             network_manager: Mutex::new(std::sync::Weak::new()),
             agent_manager: Mutex::new(std::sync::Weak::new()),
             object_manager: Mutex::new(None),
@@ -651,6 +658,10 @@ impl GridClient {
         self.agent_manager.as_deref_mut().expect("agent manager")
     }
 
+    pub(crate) fn native_agent_manager(&self) -> Result<crate::AgentManager, crate::Error> {
+        crate::agent_manager::AgentManager::native_new(Some(Arc::new(self.clone())))
+    }
+
     pub(crate) fn cached_agent_manager_inner(
         &self,
     ) -> Option<Arc<crate::agent_manager::AgentManagerInner>> {
@@ -1142,6 +1153,38 @@ impl GridClient {
             .unwrap_or_else(std::sync::PoisonError::into_inner) = value;
     }
 
+    pub(crate) fn native_stats(&self) -> crate::stats::UtilizationStatistics {
+        self.runtime
+            .utilization_statistics
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner)
+            .clone()
+    }
+
+    pub(crate) fn native_set_stats(&self, value: crate::stats::UtilizationStatistics) {
+        *self
+            .runtime
+            .utilization_statistics
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner) = value;
+    }
+
+    pub(crate) fn native_throttle(&self) -> crate::AgentThrottle {
+        self.runtime
+            .throttle
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner)
+            .clone()
+    }
+
+    pub(crate) fn native_set_throttle(&self, value: crate::AgentThrottle) {
+        *self
+            .runtime
+            .throttle
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner) = value;
+    }
+
     pub(crate) fn shutdown(&self) -> Result<(), ClientCoreError> {
         self.runtime.shutdown()
     }
@@ -1181,14 +1224,115 @@ impl Drop for GridClient {
 }
 
 impl crate::IGridClient for GridClient {
+    fn ais_client(&self) -> crate::InventoryAISClient {
+        self.native_ais_client()
+            .unwrap_or_else(|_| panic!("failed to construct InventoryAISClient"))
+    }
+
+    fn appearance(&self) -> crate::AppearanceManager {
+        self.native_appearance()
+            .unwrap_or_else(|_| panic!("failed to construct AppearanceManager"))
+    }
+
+    fn assets(&self) -> crate::AssetManager {
+        self.native_assets()
+            .unwrap_or_else(|_| panic!("failed to construct AssetManager"))
+    }
+
+    fn avatars(&self) -> crate::AvatarManager {
+        self.native_avatars()
+            .unwrap_or_else(|_| panic!("failed to construct AvatarManager"))
+    }
+
+    fn directory(&self) -> crate::DirectoryManager {
+        self.native_directory()
+            .unwrap_or_else(|_| panic!("failed to construct DirectoryManager"))
+    }
+
+    fn environment(&self) -> crate::EnvironmentManager {
+        self.native_environment()
+            .unwrap_or_else(|_| panic!("failed to construct EnvironmentManager"))
+    }
+
+    fn estate(&self) -> crate::EstateTools {
+        self.native_estate()
+            .unwrap_or_else(|_| panic!("failed to construct EstateTools"))
+    }
+
+    fn friends(&self) -> crate::FriendsManager {
+        self.native_friends()
+            .unwrap_or_else(|_| panic!("failed to construct FriendsManager"))
+    }
+
+    fn grid(&self) -> crate::GridManager {
+        self.native_grid()
+            .unwrap_or_else(|_| panic!("failed to construct GridManager"))
+    }
+
+    fn groups(&self) -> crate::GroupManager {
+        self.native_groups()
+    }
+
     fn http_caps_client(&self) -> crate::caps_http::HttpCapsClient {
         self.native_http_caps_client()
     }
 
+    fn interest_list(&self) -> crate::InterestListManager {
+        self.native_interest_list()
+            .unwrap_or_else(|_| panic!("failed to construct InterestListManager"))
+    }
+
+    fn inventory(&self) -> crate::InventoryManager {
+        self.native_inventory()
+            .unwrap_or_else(|_| panic!("failed to construct InventoryManager"))
+    }
+
+    fn marketplace(&self) -> crate::marketplace::MarketplaceManager {
+        self.native_marketplace()
+    }
+
+    fn network(&self) -> crate::NetworkManager {
+        self.native_network()
+            .unwrap_or_else(|_| panic!("failed to construct NetworkManager"))
+    }
+
+    fn objects(&self) -> crate::ObjectManager {
+        self.native_objects()
+            .unwrap_or_else(|_| panic!("failed to construct ObjectManager"))
+    }
+
+    fn parcels(&self) -> crate::ParcelManager {
+        self.native_parcels()
+            .unwrap_or_else(|_| panic!("failed to construct ParcelManager"))
+    }
+
+    fn self_(&self) -> crate::AgentManager {
+        self.native_agent_manager()
+            .unwrap_or_else(|_| panic!("failed to construct AgentManager"))
+    }
+
     fn settings(&self) -> Settings {
         self.settings.clone()
     }
 
+    fn sound(&self) -> crate::SoundManager {
+        self.native_sound()
+            .unwrap_or_else(|_| panic!("failed to construct SoundManager"))
+    }
+
+    fn stats(&self) -> crate::stats::UtilizationStatistics {
+        self.native_stats()
+    }
+
+    fn terrain(&self) -> crate::TerrainManager {
+        self.native_terrain()
+            .unwrap_or_else(|_| panic!("failed to construct TerrainManager"))
+    }
+
+    fn throttle(&self) -> crate::AgentThrottle {
+        self.native_throttle()
+    }
+
     fn time_provider(&self) -> TimeProvider {
         self.time_provider.clone()
     }