[WARP] Add network container

This is going to be disabled by default on this upcoming stable, however users may enable it once we deploy the public server. The data from the server is done through `Container::fetch_functions` independent of the nonblocking function lookup functions.

The sidebar has been updated to drive fetching so that when users navigate to a new function the fetcher will kick off. This fetcher operates on a separate thread, in the event of a user navigating to many functions before the current fetch has completed they all will be batched together in a single fetch.

Networked container currently is limited to just function prototypes, other type information separate from the function object will be omitted.

Author: emesare

Cargo.lock

@@ -24,6 +24,7 @@ thiserror = "2.0"
 ar = { git = "https://github.com/mdsteele/rust-ar" }
 tempdir = "0.3.7"
 regex = "1.11"
+reqwest = { version = "0.12", features = ["blocking", "json", "multipart"] }
 
 # For reports
 minijinja = "2.10.2"

plugins/warp/Cargo.toml

@@ -204,6 +204,29 @@ def BNWARPContainerCommitSource(
 	return _BNWARPContainerCommitSource(container, source)
 
 
+# -------------------------------------------------------
+# _BNWARPContainerFetchFunctions
+
+_BNWARPContainerFetchFunctions = core.BNWARPContainerFetchFunctions
+_BNWARPContainerFetchFunctions.restype = None
+_BNWARPContainerFetchFunctions.argtypes = [
+		ctypes.POINTER(BNWARPContainer),
+		ctypes.POINTER(BNWARPTarget),
+		ctypes.POINTER(BNWARPTypeGUID),
+		ctypes.c_ulonglong,
+	]
+
+
+# noinspection PyPep8Naming
+def BNWARPContainerFetchFunctions(
+		container: ctypes.POINTER(BNWARPContainer), 
+		target: ctypes.POINTER(BNWARPTarget), 
+		guids: ctypes.POINTER(BNWARPTypeGUID), 
+		count: int
+		) -> None:
+	return _BNWARPContainerFetchFunctions(container, target, guids, count)
+
+
 # -------------------------------------------------------
 # _BNWARPContainerGetFunctionsWithGUID
 

plugins/warp/api/python/_warpcore.py

@@ -305,6 +305,13 @@ def remove_types(self, source: Source, guids: List[TypeGUID]) -> bool:
             core_guids[i] = guids[i].uuid
         return warpcore.BNWARPContainerRemoveTypes(self.handle, source.uuid, core_guids, count)
 
+    def fetch_functions(self, target: WarpTarget, guids: List[FunctionGUID]):
+        count = len(guids)
+        core_guids = (warpcore.BNWARPFunctionGUID * count)()
+        for i in range(count):
+            core_guids[i] = guids[i].uuid
+        warpcore.BNWARPContainerFetchFunctions(self.handle, target.handle, core_guids, count)
+
     def get_sources_with_function_guid(self, target: WarpTarget, guid: FunctionGUID) -> List[Source]:
         count = ctypes.c_size_t()
         sources = warpcore.BNWARPContainerGetSourcesWithFunctionGUID(self.handle, target.handle, guid.uuid, count)

plugins/warp/api/python/warp.py

@@ -249,6 +249,16 @@ bool Container::RemoveTypes(const Source &source, const std::vector<TypeGUID> &g
     return result;
 }
 
+void Container::FetchFunctions(const Target &target, const std::vector<FunctionGUID> &guids) const
+{
+    size_t count = guids.size();
+    BNWARPFunctionGUID *apiGuids = new BNWARPFunctionGUID[count];
+    for (size_t i = 0; i < count; i++)
+        apiGuids[i] = *guids[i].Raw();
+    BNWARPContainerFetchFunctions(m_object, target.m_object, apiGuids, count);
+    delete[] apiGuids;
+}
+
 std::vector<Source> Container::GetSourcesWithFunctionGUID(const Target& target, const FunctionGUID &guid) const
 {
     size_t count;

plugins/warp/api/warp.cpp

@@ -354,6 +354,8 @@ namespace Warp {
 
 		bool RemoveTypes(const Source &source, const std::vector<TypeGUID> &guids) const;
 
+		void FetchFunctions(const Target& target, const std::vector<FunctionGUID> &guids) const;
+
 		std::vector<Source> GetSourcesWithFunctionGUID(const Target& target, const FunctionGUID &guid) const;
 
 		std::vector<Source> GetSourcesWithTypeGUID(const TypeGUID &guid) const;

plugins/warp/api/warp.h

@@ -108,6 +108,8 @@ extern "C"
     WARP_FFI_API bool BNWARPContainerRemoveFunctions(BNWARPContainer* container, const BNWARPTarget* target, const BNWARPSource* source, BNWARPFunction** functions, size_t count);
     WARP_FFI_API bool BNWARPContainerRemoveTypes(BNWARPContainer* container, const BNWARPSource* source, BNWARPTypeGUID* types, size_t count);
 
+    WARP_FFI_API void BNWARPContainerFetchFunctions(BNWARPContainer* container, BNWARPTarget* target, const BNWARPTypeGUID* guids, size_t count);
+    
     WARP_FFI_API BNWARPSource* BNWARPContainerGetSourcesWithFunctionGUID(BNWARPContainer* container, const BNWARPTarget* target, const BNWARPFunctionGUID* guid, size_t* count);
     WARP_FFI_API BNWARPSource* BNWARPContainerGetSourcesWithTypeGUID(BNWARPContainer* container, const BNWARPTypeGUID* guid, size_t* count);
     WARP_FFI_API BNWARPFunction** BNWARPContainerGetFunctionsWithGUID(BNWARPContainer* container, const BNWARPTarget* target, const BNWARPSource* source, const BNWARPFunctionGUID* guid, size_t* count);

plugins/warp/api/warpcore.h

@@ -208,6 +208,19 @@ pub trait Container: Send + Sync + Display + Debug {
         functions: &[Function],
     ) -> ContainerResult<()>;
 
+    /// Fetches WARP information for the associated functions.
+    ///
+    /// Typically, a container that resides only in memory has nothing to fetch, so the default implementation
+    /// will do nothing. This function is blocking, so assume it will take a few seconds for a container
+    /// that intends to fetch over the network.
+    fn fetch_functions(
+        &mut self,
+        _target: &Target,
+        _functions: &[FunctionGUID],
+    ) -> ContainerResult<()> {
+        Ok(())
+    }
+
     /// Get the sources that contain a type with the given [`TypeGUID`].
     fn sources_with_type_guid(&self, guid: &TypeGUID) -> ContainerResult<Vec<SourceId>>;