feat: use read_state rather than request_status

.github/workflows/ic-ref.yml

@@ -16,7 +16,7 @@ jobs:
         include:
           - build: linux-stable
             ghc: '8.8.4'
-            spec: 'release-0.11'
+            spec: 'release-0.13'
             os: ubuntu-latest
             rust: stable
 
@@ -75,7 +75,7 @@ jobs:
           mkdir -p $HOME/bin
           cd ic-ref/impl
           cabal update
-          cabal install -w ghc-${{ matrix.ghc }} --overwrite-policy=always  --installdir=$HOME/bin
+          cabal install exe:ic-ref -w ghc-${{ matrix.ghc }} --overwrite-policy=always  --installdir=$HOME/bin
 
       - name: Build universal-canister
         run: |

ic-agent/Cargo.toml

@@ -21,6 +21,7 @@ delay = "0.3.0"
 hex = "0.4.0"
 ic-types = { path = "../ic-types", version = "0.1", features = [ "serde" ] }
 leb128 = "0.2.4"
+mime = "0.3.16"
 openssl = "0.10.24"
 rand = "0.7.2"
 reqwest = { version = "0.10.4", features = [ "blocking", "json", "rustls-tls" ] }

ic-agent/src/agent/agent_error.rs

@@ -1,4 +1,8 @@
+use crate::hash_tree::Label;
 use crate::RequestIdError;
+use leb128::read;
+use std::fmt::{Debug, Display, Formatter};
+use std::str::Utf8Error;
 use thiserror::Error;
 
 #[derive(Error, Debug)]
@@ -36,12 +40,8 @@ pub enum AgentError {
         reject_message: String,
     },
 
-    #[error(r#"The replica returned an HTTP Error: status code {status}"#)]
-    HttpError {
-        status: u16,
-        content_type: Option<String>,
-        content: Vec<u8>,
-    },
+    #[error("The replica returned an HTTP Error: {0}")]
+    HttpError(HttpErrorPayload),
 
     #[error("HTTP Authentication cannot be used in a non-secure URL (either HTTPS or localhost)")]
     CannotUseAuthenticationOnNonSecureUrl(),
@@ -60,6 +60,24 @@ pub enum AgentError {
 
     #[error("A tool returned a custom error: {0}")]
     CustomError(#[from] Box<dyn Send + Sync + std::error::Error>),
+
+    #[error("Error reading LEB128 value: {0}")]
+    Leb128ReadError(#[from] read::Error),
+
+    #[error("Error in UTF-8 string: {0}")]
+    Utf8ReadError(#[from] Utf8Error),
+
+    #[error("The lookup path ({0:?}) is absent in the certificate.")]
+    LookupPathAbsent(Vec<Label>),
+
+    #[error("The lookup path ({0:?}) is unknown in the certificate.")]
+    LookupPathUnknown(Vec<Label>),
+
+    #[error("The lookup path ({0:?}) does not make sense for the certificate.")]
+    LookupPathError(Vec<Label>),
+
+    #[error("The request status ({1}) at path {0:?} is invalid.")]
+    InvalidRequestStatus(Vec<Label>, String),
 }
 
 impl PartialEq for AgentError {
@@ -69,3 +87,65 @@ impl PartialEq for AgentError {
         format!("{:?}", self) == format!("{:?}", other)
     }
 }
+
+pub struct HttpErrorPayload {
+    pub status: u16,
+    pub content_type: Option<String>,
+    pub content: Vec<u8>,
+}
+
+impl HttpErrorPayload {
+    fn fmt_human_readable(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
+        match self {
+            HttpErrorPayload {
+                status,
+                content_type,
+                content,
+            } if is_plain_text_utf8(content_type) => {
+                f.write_fmt(format_args!(
+                    "Http Error: status {}, content type {:?}, content: {}",
+                    status,
+                    content_type.as_ref().unwrap(),
+                    String::from_utf8(content.to_vec()).unwrap_or_else(|from_utf8_err| format!(
+                        "(unable to decode content: {:#?})",
+                        from_utf8_err
+                    ))
+                ))?;
+            }
+            HttpErrorPayload {
+                status,
+                content_type,
+                content,
+            } => {
+                f.write_fmt(format_args!(
+                    "Http Error: status {}, content type {:?}, content: {:?}",
+                    status,
+                    content_type.as_ref().unwrap(),
+                    content
+                ))?;
+            }
+        }
+        Ok(())
+    }
+}
+
+impl Debug for HttpErrorPayload {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
+        self.fmt_human_readable(f)
+    }
+}
+
+impl Display for HttpErrorPayload {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
+        self.fmt_human_readable(f)
+    }
+}
+
+fn is_plain_text_utf8(content_type: &Option<String>) -> bool {
+    // text/plain is also sometimes returned by the replica (or ic-ref),
+    // depending on where in the stack the error happens.
+    matches!(
+        content_type.as_ref().and_then(|s|s.parse::<mime::Mime>().ok()),
+        Some(mt) if mt == mime::TEXT_PLAIN || mt == mime::TEXT_PLAIN_UTF_8
+    )
+}

ic-agent/src/agent/agent_test.rs

@@ -1,12 +1,9 @@
 use crate::agent::replica_api::{CallReply, QueryResponse};
-use crate::agent::response::{Replied, RequestStatusResponse};
 use crate::agent::{AgentConfig, Status};
 use crate::export::Principal;
 use crate::{Agent, AgentError};
-use delay::Delay;
 use mockito::mock;
 use std::collections::BTreeMap;
-use std::time::Duration;
 
 #[test]
 fn query() -> Result<(), AgentError> {
@@ -93,45 +90,6 @@ fn query_rejected() -> Result<(), AgentError> {
     Ok(())
 }
 
-#[test]
-fn call() -> Result<(), AgentError> {
-    let blob = Vec::from("Hello World");
-    let response = QueryResponse::Replied {
-        reply: CallReply { arg: blob.clone() },
-    };
-
-    let submit_mock = mock("POST", "/api/v1/submit").with_status(200).create();
-    let status_mock = mock("POST", "/api/v1/read")
-        .with_status(200)
-        .with_header("content-type", "application/cbor")
-        .with_body(serde_cbor::to_vec(&response)?)
-        .create();
-
-    let agent = Agent::builder().with_url(&mockito::server_url()).build()?;
-
-    let mut runtime = tokio::runtime::Runtime::new().expect("Unable to create a runtime");
-    let result = runtime.block_on(async {
-        let request_id = agent
-            .update(&Principal::management_canister(), "greet")
-            .with_arg(&[])
-            .call()
-            .await?;
-        agent.request_status_raw(&request_id, None).await
-    });
-
-    submit_mock.assert();
-    status_mock.assert();
-
-    assert_eq!(
-        result?,
-        RequestStatusResponse::Replied {
-            reply: Replied::CallReplied(blob)
-        }
-    );
-
-    Ok(())
-}
-
 #[test]
 fn call_error() -> Result<(), AgentError> {
     let submit_mock = mock("POST", "/api/v1/submit").with_status(500).create();
@@ -154,50 +112,6 @@ fn call_error() -> Result<(), AgentError> {
     Ok(())
 }
 
-#[test]
-fn call_rejected() -> Result<(), AgentError> {
-    let response: QueryResponse = QueryResponse::Rejected {
-        reject_code: 1234,
-        reject_message: "Rejected Message".to_string(),
-    };
-
-    let submit_mock = mock("POST", "/api/v1/submit").with_status(200).create();
-    let status_mock = mock("POST", "/api/v1/read")
-        .with_status(200)
-        .with_header("content-type", "application/cbor")
-        .with_body(serde_cbor::to_vec(&response)?)
-        .create();
-
-    let agent = Agent::new(AgentConfig {
-        url: mockito::server_url(),
-        ..Default::default()
-    })?;
-
-    let mut runtime = tokio::runtime::Runtime::new().expect("Unable to create a runtime");
-    let result = runtime.block_on(async {
-        agent
-            .update(&Principal::management_canister(), "greet")
-            .call_and_wait(Delay::timeout(Duration::from_millis(100)))
-            .await
-    });
-
-    match result {
-        Err(AgentError::ReplicaError {
-            reject_code: code,
-            reject_message: msg,
-        }) => {
-            assert_eq!(code, 1234);
-            assert_eq!(msg, "Rejected Message");
-        }
-        result => unreachable!("{:?}", result),
-    }
-
-    submit_mock.assert();
-    status_mock.assert();
-
-    Ok(())
-}
-
 #[test]
 fn status() -> Result<(), AgentError> {
     let ic_api_version = "1.2.3".to_string();