fix: Remove HashMap for names (#624)

# Motivation

Using Rust API, it is not possible to create multiple results with the
same name as the result is encoded with a HashMap.
If multiple results have the same name, the values have the same key,
and only a single element is got back.

# Description

Replace HashMap by Vec for result creation.

# Testing

It will be tested as part of the load balancer.

Author: lemaitre-aneo

packages/rust/armonik/src/client/agent.rs

@@ -1,5 +1,3 @@
-use std::collections::HashMap;
-
 use futures::{Stream, StreamExt};
 use snafu::ResultExt;
 
@@ -40,11 +38,11 @@ where
         token: impl Into<String>,
         session_id: impl Into<String>,
         names: impl std::iter::IntoIterator<Item = impl Into<String>>,
-    ) -> Result<HashMap<String, ResultMetaData>, super::RequestError> {
+    ) -> Result<Vec<ResultMetaData>, super::RequestError> {
         Ok(self
             .call(create_results_metadata::Request {
                 communication_token: token.into(),
-                names: names.into_collect(),
+                results: names.into_iter().map(|name| name.into().into()).collect(),
                 session_id: session_id.into(),
             })
             .await?
@@ -57,13 +55,13 @@ where
         token: impl Into<String>,
         session_id: impl Into<String>,
         results: impl std::iter::IntoIterator<Item = (impl Into<String>, impl Into<Vec<u8>>)>,
-    ) -> Result<HashMap<String, ResultMetaData>, super::RequestError> {
+    ) -> Result<Vec<ResultMetaData>, super::RequestError> {
         Ok(self
             .call(create_results::Request {
                 communication_token: token.into(),
                 results: results
                     .into_iter()
-                    .map(|(name, data)| (name.into(), data.into()))
+                    .map(|(name, data)| (name.into(), data.into()).into())
                     .collect(),
                 session_id: session_id.into(),
             })
@@ -267,8 +265,6 @@ where
 #[cfg(test)]
 #[serial_test::serial(agent)]
 mod tests {
-    use std::collections::HashMap;
-
     use crate::Client;
 
     // Named methods
@@ -346,7 +342,7 @@ mod tests {
             .call(crate::agent::create_results_metadata::Request {
                 communication_token: String::from("token"),
                 session_id: String::from("session-id"),
-                names: Vec::new(),
+                results: Vec::new(),
             })
             .await
             .unwrap();
@@ -362,7 +358,7 @@ mod tests {
             .call(crate::agent::create_results::Request {
                 communication_token: String::from("token"),
                 session_id: String::from("session-id"),
-                results: HashMap::new(),
+                results: Vec::new(),
             })
             .await
             .unwrap();

packages/rust/armonik/src/client/results.rs

@@ -83,7 +83,7 @@ where
         &mut self,
         session_id: impl Into<String>,
         results: impl IntoIterator<Item = create_metadata::RequestItem>,
-    ) -> Result<HashMap<String, Raw>, super::RequestError> {
+    ) -> Result<Vec<Raw>, super::RequestError> {
         Ok(self
             .call(create_metadata::Request {
                 results: results.into_collect(),
@@ -98,7 +98,7 @@ where
         &mut self,
         session_id: impl Into<String>,
         results: impl IntoIterator<Item = create::RequestItem>,
-    ) -> Result<HashMap<String, Raw>, super::RequestError> {
+    ) -> Result<Vec<Raw>, super::RequestError> {
         Ok(self
             .call(create::Request {
                 results: results.into_collect(),

packages/rust/armonik/src/objects/agent/create_results.rs

@@ -1,50 +1,52 @@
-use std::collections::HashMap;
-
 use super::ResultMetaData;
 
 use crate::api::v3;
 
+/// Result to create with data.
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct RequestItem {
+    /// The name of the result to create.
+    pub name: String,
+    /// The data associated to the result to create.
+    pub data: Vec<u8>,
+}
+
+impl<K: Into<String>, V: Into<Vec<u8>>> From<(K, V)> for RequestItem {
+    fn from((name, data): (K, V)) -> Self {
+        Self {
+            name: name.into(),
+            data: data.into(),
+        }
+    }
+}
+
+super::super::impl_convert!(
+  struct RequestItem = v3::agent::create_results_request::ResultCreate {
+      name,
+      data,
+  }
+);
+
 /// Request for creating results with data.
 #[derive(Debug, Clone, Default, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Request {
     /// Communication token received by the worker during task processing.
     pub communication_token: String,
     /// Results to create.
-    pub results: HashMap<String, Vec<u8>>,
+    pub results: Vec<RequestItem>,
     /// The session in which create results.
     pub session_id: String,
 }
 
-impl From<Request> for v3::agent::CreateResultsRequest {
-    fn from(value: Request) -> Self {
-        Self {
-            communication_token: value.communication_token,
-            results: value
-                .results
-                .into_iter()
-                .map(|(name, data)| v3::agent::create_results_request::ResultCreate { name, data })
-                .collect(),
-            session_id: value.session_id,
-        }
+super::super::impl_convert!(
+    struct Request = v3::agent::CreateResultsRequest {
+        communication_token,
+        list results,
+        session_id,
     }
-}
-
-impl From<v3::agent::CreateResultsRequest> for Request {
-    fn from(value: v3::agent::CreateResultsRequest) -> Self {
-        Self {
-            communication_token: value.communication_token,
-            results: value
-                .results
-                .into_iter()
-                .map(|result| (result.name, result.data))
-                .collect(),
-            session_id: value.session_id,
-        }
-    }
-}
-
-super::super::impl_convert!(req Request : v3::agent::CreateResultsRequest);
+);
 
 /// Response for creating results without data.
 #[derive(Debug, Clone, Default)]
@@ -53,36 +55,12 @@ pub struct Response {
     /// Communication token received by the worker during task processing.
     pub communication_token: String,
     /// The list of ResultMetaData results that were created.
-    pub results: HashMap<String, ResultMetaData>,
-}
-
-impl From<Response> for v3::agent::CreateResultsResponse {
-    fn from(value: Response) -> Self {
-        Self {
-            communication_token: value.communication_token,
-            results: value
-                .results
-                .into_iter()
-                .map(|(name, result)| {
-                    debug_assert_eq!(name, result.name);
-                    result.into()
-                })
-                .collect(),
-        }
-    }
+    pub results: Vec<ResultMetaData>,
 }
 
-impl From<v3::agent::CreateResultsResponse> for Response {
-    fn from(value: v3::agent::CreateResultsResponse) -> Self {
-        Self {
-            communication_token: value.communication_token,
-            results: value
-                .results
-                .into_iter()
-                .map(|result| (result.name.clone(), result.into()))
-                .collect(),
-        }
+super::super::impl_convert!(
+    struct Response = v3::agent::CreateResultsResponse{
+        communication_token,
+        list results,
     }
-}
-
-super::super::impl_convert!(req Response : v3::agent::CreateResultsResponse);
+);

packages/rust/armonik/src/objects/agent/create_results_metadata.rs

@@ -1,54 +1,46 @@
-use std::collections::HashMap;
-
 use super::ResultMetaData;
 
 use crate::api::v3;
 
+/// Result to create without data.
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct RequestItem {
+    /// The name of the result to create.
+    pub name: String,
+}
+
+impl<T: Into<String>> From<T> for RequestItem {
+    fn from(value: T) -> Self {
+        Self { name: value.into() }
+    }
+}
+
+super::super::impl_convert!(
+  struct RequestItem = v3::agent::create_results_meta_data_request::ResultCreate {
+      name,
+  }
+);
+
 /// Request for creating results without data.
 #[derive(Debug, Clone, Default, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Request {
     /// Communication token received by the worker during task processing.
     pub communication_token: String,
     /// The list of names for the results to create.
-    pub names: Vec<String>,
+    pub results: Vec<RequestItem>,
     /// The session in which create results.
     pub session_id: String,
 }
 
-impl From<Request> for v3::agent::CreateResultsMetaDataRequest {
-    fn from(value: Request) -> Self {
-        Self {
-            communication_token: value.communication_token,
-            results: value
-                .names
-                .into_iter()
-                .map(
-                    |result| v3::agent::create_results_meta_data_request::ResultCreate {
-                        name: result,
-                    },
-                )
-                .collect(),
-            session_id: value.session_id,
-        }
+super::super::impl_convert!(
+    struct Request = v3::agent::CreateResultsMetaDataRequest {
+        communication_token,
+        list results,
+        session_id,
     }
-}
-
-impl From<v3::agent::CreateResultsMetaDataRequest> for Request {
-    fn from(value: v3::agent::CreateResultsMetaDataRequest) -> Self {
-        Self {
-            communication_token: value.communication_token,
-            names: value
-                .results
-                .into_iter()
-                .map(|result| result.name)
-                .collect(),
-            session_id: value.session_id,
-        }
-    }
-}
-
-super::super::impl_convert!(req Request : v3::agent::CreateResultsMetaDataRequest);
+);
 
 /// Response for creating results without data.
 #[derive(Debug, Clone, Default)]
@@ -57,36 +49,12 @@ pub struct Response {
     /// Communication token received by the worker during task processing.
     pub communication_token: String,
     /// The list of ResultMetaData results that were created.
-    pub results: HashMap<String, ResultMetaData>,
+    pub results: Vec<ResultMetaData>,
 }
 
-impl From<Response> for v3::agent::CreateResultsMetaDataResponse {
-    fn from(value: Response) -> Self {
-        Self {
-            communication_token: value.communication_token,
-            results: value
-                .results
-                .into_iter()
-                .map(|(k, v)| {
-                    debug_assert_eq!(k, v.name);
-                    v.into()
-                })
-                .collect(),
-        }
+super::super::impl_convert!(
+    struct Response = v3::agent::CreateResultsMetaDataResponse {
+        communication_token,
+        list results,
     }
-}
-
-impl From<v3::agent::CreateResultsMetaDataResponse> for Response {
-    fn from(value: v3::agent::CreateResultsMetaDataResponse) -> Self {
-        Self {
-            communication_token: value.communication_token,
-            results: value
-                .results
-                .into_iter()
-                .map(|result| (result.name.clone(), result.into()))
-                .collect(),
-        }
-    }
-}
-
-super::super::impl_convert!(req Response : v3::agent::CreateResultsMetaDataResponse);
+);

packages/rust/armonik/src/objects/results/create.rs

@@ -1,5 +1,3 @@
-use std::collections::HashMap;
-
 use super::Raw;
 
 use crate::api::v3;
@@ -16,6 +14,16 @@ pub struct RequestItem {
     pub manual_deletion: bool,
 }
 
+impl<K: Into<String>, V: Into<Vec<u8>>> From<(K, V)> for RequestItem {
+    fn from((name, data): (K, V)) -> Self {
+        Self {
+            name: name.into(),
+            data: data.into(),
+            manual_deletion: false,
+        }
+    }
+}
+
 super::super::impl_convert!(
   struct RequestItem = v3::results::create_results_request::ResultCreate {
       name,
@@ -46,34 +54,11 @@ super::super::impl_convert!(
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Response {
     /// The list of raw results that were created.
-    pub results: HashMap<String, Raw>,
+    pub results: Vec<Raw>,
 }
 
-impl From<Response> for v3::results::CreateResultsResponse {
-    fn from(value: Response) -> Self {
-        Self {
-            results: value
-                .results
-                .into_iter()
-                .map(|(name, result)| {
-                    debug_assert_eq!(name, result.name);
-                    result.into()
-                })
-                .collect(),
-        }
-    }
-}
-
-impl From<v3::results::CreateResultsResponse> for Response {
-    fn from(value: v3::results::CreateResultsResponse) -> Self {
-        Self {
-            results: value
-                .results
-                .into_iter()
-                .map(|result| (result.name.clone(), result.into()))
-                .collect(),
-        }
+super::super::impl_convert!(
+    struct Response = v3::results::CreateResultsResponse {
+        list results,
     }
-}
-
-super::super::impl_convert!(req Response : v3::results::CreateResultsResponse);
+);