feat: Add serialization traits to Status (dfinity#498)

Author: bitdivine

CHANGELOG.md

@@ -10,6 +10,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 * Changed the return type of `stored_chunks` to a struct.
 * Added a prime256v1-based `Identity` impl to complement the ed25519 and secp256k1 `Identity` impls.
+* Added serde and candid serialization traits to the `Status` type.
 
 ## [0.32.0] - 2024-01-18
 

Cargo.lock

@@ -43,6 +43,7 @@ simple_asn1 = "0.6.1"
 thiserror = { workspace = true }
 time = { workspace = true }
 url = "2.1.0"
+lazy_static = "1.4"
 
 [dependencies.hyper]
 version = "0.14"
@@ -76,6 +77,7 @@ web-sys = { version = "0.3", features = ["Window"], optional = true }
 
 [dev-dependencies]
 serde_json = "1.0.79"
+candid = { workspace = true, features = ["value"]}
 
 [target.'cfg(not(target_family = "wasm"))'.dev-dependencies]
 tokio = { version = "1.24.2", features = ["full"] }

ic-agent/Cargo.toml

@@ -1,14 +1,19 @@
 //! A [`Transport`] that connects using a [`reqwest`] client.
 #![cfg(feature = "reqwest")]
 
+use futures_util::StreamExt;
 use ic_transport_types::RejectResponse;
+use lazy_static::lazy_static;
 pub use reqwest;
-
-use futures_util::StreamExt;
 use reqwest::{
     header::{HeaderMap, CONTENT_TYPE},
     Body, Client, Method, Request, StatusCode,
 };
+use serde_cbor::Value;
+use std::fs::{File, OpenOptions};
+use std::io::{self, prelude::*};
+use std::sync::Arc;
+use std::{collections::BTreeMap, sync::Mutex};
 
 use crate::{
     agent::{
@@ -20,6 +25,30 @@ use crate::{
     AgentError, RequestId,
 };
 
+struct GlobalFile {
+    file: Mutex<File>,
+}
+
+// Create a lazy static instance of the global file
+lazy_static! {
+    static ref GLOBAL_FILE: Arc<GlobalFile> = {
+        let file = OpenOptions::new()
+            .create(true)
+            .write(true)
+            .append(true)
+            .open("results.txt")
+            .unwrap();
+
+        Arc::new(GlobalFile {
+            file: Mutex::new(file),
+        })
+    };
+}
+
+fn write_to_global_file(tree: BTreeMap<&&str, i32>) {
+    let mut file = GLOBAL_FILE.file.lock().unwrap();
+    writeln!(file, "{:?}", tree).expect("Write failed");
+}
 /// A [`Transport`] using [`reqwest`] to make HTTP calls to the Internet Computer.
 #[derive(Debug)]
 pub struct ReqwestTransport {
@@ -139,6 +168,26 @@ impl ReqwestTransport {
         let headers = request_result.1;
         let body = request_result.2;
 
+        if let Some(timestamps) = headers.get("timestamps") {
+            let mut all_timestamps: Vec<_> = timestamps
+                .to_str()
+                .unwrap()
+                .split(", ")
+                .into_iter()
+                .collect();
+            let decoded_data: Value =
+                serde_cbor::from_reader(std::io::Cursor::new(body.clone().to_vec()))
+                    .expect("Failed to decode CBOR");
+            let own_timestamp = extract_timestamp(&decoded_data);
+            all_timestamps.push(own_timestamp.as_str());
+            let mut btree_map: BTreeMap<&&str, i32> = BTreeMap::new();
+            for value in all_timestamps.iter() {
+                let entry = btree_map.entry(value).or_insert(0);
+                *entry += 1;
+            }
+            write_to_global_file(btree_map);
+        }
+
         // status == OK means we have an error message for call requests
         // see https://internetcomputer.org/docs/current/references/ic-interface-spec#http-call
         if status == StatusCode::OK && endpoint.ends_with("call") {
@@ -166,6 +215,34 @@ impl ReqwestTransport {
     }
 }
 
+fn extract_timestamp(value: &Value) -> String {
+    match value {
+        Value::Map(map) => {
+            let signatures = map
+                .get(&Value::Text("signatures".into()))
+                .expect("unexpected cbor body");
+            match signatures {
+                Value::Array(array) => match &array[0] {
+                    Value::Map(map) => {
+                        let value = map
+                            .get(&Value::Text("timestamp".to_string()))
+                            .expect("unexpected cbor body");
+                        match value {
+                            Value::Integer(integer_value) => {
+                                return integer_value.to_string();
+                            }
+                            _ => panic!("unexpected cbor body"),
+                        }
+                    }
+                    _ => panic!("unexpected cbor body"),
+                },
+                _ => panic!("unexpected cbor body"),
+            }
+        }
+        _ => panic!("unexpected cbor body"),
+    }
+}
+
 impl Transport for ReqwestTransport {
     fn call(
         &self,
@@ -201,7 +278,7 @@ impl Transport for ReqwestTransport {
 
     fn query(&self, effective_canister_id: Principal, envelope: Vec<u8>) -> AgentFuture<Vec<u8>> {
         Box::pin(async move {
-            let endpoint = format!("canister/{effective_canister_id}/query");
+            let endpoint = format!("canister/{effective_canister_id}/certified_query");
             self.execute(Method::POST, &endpoint, Some(envelope)).await
         })
     }

ic-agent/src/agent/http_transport/reqwest_transport.rs

@@ -1,11 +1,15 @@
 //! Types for interacting with the status endpoint of a replica. See [`Status`] for details.
 
+use candid::{CandidType, Deserialize};
+use serde::Serialize;
 use std::{collections::BTreeMap, fmt::Debug};
 
 /// Value returned by the status endpoint of a replica. This is a loose mapping to CBOR values.
 /// Because the agent should not return [`serde_cbor::Value`] directly across API boundaries,
 /// we reimplement it as [`Value`] here.
-#[derive(Debug, Ord, PartialOrd, Eq, PartialEq, Clone, Hash)]
+#[derive(
+    Debug, Ord, PartialOrd, Eq, PartialEq, Clone, Hash, CandidType, Serialize, Deserialize,
+)]
 pub enum Value {
     /// See [`Null`](serde_cbor::Value::Null).
     Null,
@@ -40,7 +44,7 @@ impl std::fmt::Display for Value {
 
 /// The structure returned by [`super::Agent::status`], containing the information returned
 /// by the status endpoint of a replica.
-#[derive(Debug, Ord, PartialOrd, PartialEq, Eq)]
+#[derive(Debug, Ord, PartialOrd, PartialEq, Eq, CandidType, Deserialize, Serialize)]
 pub struct Status {
     /// Optional. The precise git revision of the Internet Computer Protocol implementation.
     pub impl_version: Option<String>,
@@ -55,6 +59,47 @@ pub struct Status {
     pub values: BTreeMap<String, Box<Value>>,
 }
 
+#[test]
+fn can_serilaize_status_as_json() {
+    let status = Status {
+        impl_version: None,
+        replica_health_status: None,
+        root_key: None,
+        values: BTreeMap::new(),
+    };
+    let expected_json =
+        r#"{"impl_version":null,"replica_health_status":null,"root_key":null,"values":{}}"#;
+    let actual_json = serde_json::to_string(&status).expect("Failed to serialize as JSON");
+    assert_eq!(expected_json, actual_json);
+}
+#[test]
+fn can_serialize_status_as_idl() {
+    use candid::types::value::IDLValue;
+    use candid::{Encode, IDLArgs, Result as CandidResult, TypeEnv};
+    let status = Status {
+        impl_version: Some("Foo".to_string()),
+        replica_health_status: None,
+        root_key: None,
+        values: BTreeMap::new(),
+    };
+    // Expresses data as IDLValue.  Then use .to_string() to convert to text-form candid.
+    // TODO: This function has been added to the Candid library and will be available in the next
+    // release.  Then, this definition here can be deleted.
+    pub fn try_from_candid_type<T>(data: &T) -> CandidResult<IDLValue>
+    where
+        T: CandidType,
+    {
+        let blob = Encode!(data)?;
+        let args = IDLArgs::from_bytes_with_types(&blob, &TypeEnv::default(), &[T::ty()])?;
+        Ok(args.args[0].clone())
+    }
+    let expected_idl = "record {\n  values = vec {};\n  replica_health_status = null;\n  impl_version = opt \"Foo\";\n  root_key = null;\n}";
+    let actual_idl = try_from_candid_type(&status)
+        .expect("Failed to convert to idl")
+        .to_string();
+    assert_eq!(expected_idl, actual_idl);
+}
+
 impl std::fmt::Display for Status {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.write_str("{\n")?;