feat: simplify Call implementation and enable retry logic (#551)

* with_arg takes ref

* SendableCall methods take &self

* empty bytes

* fix doctests

* upgrade candid to 0.10.13

* Simplify Call implementation

Get rid of the ConfigurableCall trait and the CallWithArg, CallWithArgs, and CallWithRawArgs structs.
Instead, we now have a single Call struct that can be configured and executed using chainable methods.

* fix lint

* remove prelude mod

Author: lwshang

Cargo.toml

@@ -37,7 +37,7 @@ ic-cdk-timers = { path = "ic-cdk-timers", version = "0.12.0-alpha.1" }
 ic-response-codes = { path = "ic-response-codes", version = "0.1.0" }
 ic-management-canister-types = { path = "ic-management-canister-types", version = "0.1.0" }
 
-candid = "0.10.12"
+candid = "0.10.13"
 candid_parser = "0.1.4"
 futures = "0.3"
 hex = "0.4"

e2e-tests/src/bin/api.rs

@@ -2,7 +2,7 @@
 //! The [`inspect_message`] function defined below mandates that all the update/query entrypoints must start with "call_".
 
 use candid::Principal;
-use ic_cdk::{api::*, call::ConfigurableCall};
+use ic_cdk::api::*;
 
 #[export_name = "canister_update call_msg_arg_data"]
 fn call_msg_arg_data() {
@@ -19,7 +19,7 @@ fn call_msg_caller() {
 /// This entrypoint will call [`call_msg_deadline`] with both best-effort and guaranteed responses.
 #[ic_cdk::update]
 async fn call_msg_deadline_caller() {
-    use ic_cdk::call::{Call, SendableCall};
+    use ic_cdk::call::Call;
     // Call with best-effort responses.
     let reply1 = Call::new(canister_self(), "call_msg_deadline")
         .call_raw()

e2e-tests/src/bin/async.rs

@@ -1,5 +1,5 @@
 use candid::Principal;
-use ic_cdk::call::{Call, CallError, CallResult, SendableCall};
+use ic_cdk::call::{Call, CallError, CallResult};
 use ic_cdk::{query, update};
 use lazy_static::lazy_static;
 use std::sync::RwLock;

e2e-tests/src/bin/call.rs

@@ -1,6 +1,6 @@
 use candid::Encode;
 use ic_cdk::api::canister_self;
-use ic_cdk::call::{Call, ConfigurableCall, SendableCall};
+use ic_cdk::call::Call;
 use ic_cdk::update;
 
 /// A simple endpoint that takes empty arguments.
@@ -111,44 +111,44 @@ async fn call_echo_with_args() {
     let bytes = Encode!(&n).unwrap();
     // call*
     let res: u32 = Call::new(canister_self(), "echo")
-        .with_args((n,))
+        .with_args(&(n,))
         .call()
         .await
         .unwrap();
     assert_eq!(res, n);
     let res: (u32,) = Call::new(canister_self(), "echo")
-        .with_args((n,))
+        .with_args(&(n,))
         .call_tuple()
         .await
         .unwrap();
     assert_eq!(res.0, n);
     let res = Call::new(canister_self(), "echo")
-        .with_args((n,))
+        .with_args(&(n,))
         .call_raw()
         .await
         .unwrap();
     assert_eq!(res, bytes);
     Call::new(canister_self(), "echo")
-        .with_args((n,))
+        .with_args(&(n,))
         .call_oneway()
         .unwrap();
     // with*
     let res: (u32,) = Call::new(canister_self(), "echo")
-        .with_args((n,))
+        .with_args(&(n,))
         .with_guaranteed_response()
         .call_tuple()
         .await
         .unwrap();
     assert_eq!(res.0, n);
     let res: (u32,) = Call::new(canister_self(), "echo")
-        .with_args((n,))
+        .with_args(&(n,))
         .change_timeout(5)
         .call_tuple()
         .await
         .unwrap();
     assert_eq!(res.0, n);
     let res: (u32,) = Call::new(canister_self(), "echo")
-        .with_args((n,))
+        .with_args(&(n,))
         .with_cycles(1000)
         .call_tuple()
         .await
@@ -208,4 +208,35 @@ async fn call_echo_with_raw_args() {
     assert_eq!(res.0, n);
 }
 
+/// Retries the call until it succeeds.
+///
+/// Returns the number of retries.
+async fn retry(call_to_retry: Call<'_, '_>) -> u32 {
+    let mut retry = 0;
+    loop {
+        match call_to_retry.call_raw().await {
+            Ok(_) => break,
+            Err(_) => {
+                retry += 1;
+                continue;
+            }
+        }
+    }
+    retry
+}
+
+#[update]
+async fn retry_calls() {
+    let n: u32 = 1u32;
+    let call = Call::new(canister_self(), "foo");
+    assert_eq!(retry(call).await, 0);
+    let call_with_arg = Call::new(canister_self(), "echo").with_arg(n);
+    assert_eq!(retry(call_with_arg).await, 0);
+    let args = (n,);
+    let call_with_args = Call::new(canister_self(), "echo").with_args(&args);
+    assert_eq!(retry(call_with_args).await, 0);
+    let raw_args = Encode!(&n).unwrap();
+    let call_with_raw_args = Call::new(canister_self(), "echo").with_raw_args(&raw_args);
+    assert_eq!(retry(call_with_raw_args).await, 0);
+}
 fn main() {}

e2e-tests/src/bin/canister_info.rs

@@ -12,51 +12,51 @@ async fn info(canister_id: Principal) -> CanisterInfoResult {
         canister_id,
         num_requested_changes: Some(20),
     };
-    canister_info(request).await.unwrap()
+    canister_info(&request).await.unwrap()
 }
 
 #[ic_cdk::update]
 async fn canister_lifecycle() -> Principal {
-    let canister_id = create_canister(CreateCanisterArgs { settings: None }, 1_000_000_000_000)
+    let canister_id = create_canister(&CreateCanisterArgs { settings: None }, 1_000_000_000_000)
         .await
         .unwrap()
         .canister_id;
-    install_code(InstallCodeArgs {
+    install_code(&InstallCodeArgs {
         mode: Install,
         arg: vec![],
         wasm_module: vec![0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00],
         canister_id,
     })
     .await
     .unwrap();
-    uninstall_code(UninstallCodeArgs { canister_id })
+    uninstall_code(&UninstallCodeArgs { canister_id })
         .await
         .unwrap();
-    install_code(InstallCodeArgs {
+    install_code(&InstallCodeArgs {
         mode: Install,
         arg: vec![],
         wasm_module: vec![0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00],
         canister_id,
     })
     .await
     .unwrap();
-    install_code(InstallCodeArgs {
+    install_code(&InstallCodeArgs {
         mode: Reinstall,
         arg: vec![],
         wasm_module: vec![0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00],
         canister_id,
     })
     .await
     .unwrap();
-    install_code(InstallCodeArgs {
+    install_code(&InstallCodeArgs {
         mode: Upgrade(None),
         arg: vec![],
         wasm_module: vec![0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00],
         canister_id,
     })
     .await
     .unwrap();
-    update_settings(UpdateSettingsArgs {
+    update_settings(&UpdateSettingsArgs {
         settings: CanisterSettings {
             controllers: Some(vec![
                 ic_cdk::api::canister_self(),

e2e-tests/src/bin/chunk.rs

@@ -10,7 +10,7 @@ use ic_cdk::update;
 async fn call_create_canister() -> Principal {
     let arg = CreateCanisterArgs::default();
 
-    create_canister(arg, 1_000_000_000_000u128)
+    create_canister(&arg, 1_000_000_000_000u128)
         .await
         .unwrap()
         .canister_id
@@ -23,20 +23,20 @@ async fn call_upload_chunk(canister_id: Principal, chunk: Vec<u8>) -> Vec<u8> {
         chunk: chunk.to_vec(),
     };
 
-    upload_chunk(arg).await.unwrap().hash
+    upload_chunk(&arg).await.unwrap().hash
 }
 
 #[update]
 async fn call_stored_chunks(canister_id: Principal) -> Vec<Vec<u8>> {
     let arg = StoredChunksArgs { canister_id };
-    let hashes = stored_chunks(arg).await.unwrap();
+    let hashes = stored_chunks(&arg).await.unwrap();
     hashes.into_iter().map(|v| v.hash).collect()
 }
 
 #[update]
 async fn call_clear_chunk_store(canister_id: Principal) {
     let arg = ClearChunkStoreArgs { canister_id };
-    clear_chunk_store(arg).await.unwrap();
+    clear_chunk_store(&arg).await.unwrap();
 }
 
 #[update]
@@ -57,7 +57,7 @@ async fn call_install_chunked_code(
         wasm_module_hash,
         arg: vec![],
     };
-    install_chunked_code(arg).await.unwrap();
+    install_chunked_code(&arg).await.unwrap();
 }
 
 fn main() {}

e2e-tests/src/bin/http_request.rs

@@ -38,7 +38,7 @@ async fn get_without_transform() {
         transform: None,
     };
     let cycles = cycles_cost(&args);
-    let res = http_request(args, cycles).await.unwrap();
+    let res = http_request(&args, cycles).await.unwrap();
     assert_eq!(res.status, 200u32);
     assert_eq!(
         res.headers,
@@ -59,7 +59,7 @@ async fn post() {
         ..Default::default()
     };
     let cycles = cycles_cost(&args);
-    http_request(args, cycles).await.unwrap();
+    http_request(&args, cycles).await.unwrap();
 }
 
 /// Method is HEAD.
@@ -71,7 +71,7 @@ async fn head() {
         ..Default::default()
     };
     let cycles = cycles_cost(&args);
-    http_request(args, cycles).await.unwrap();
+    http_request(&args, cycles).await.unwrap();
 }
 
 /// The standard way to define a transform function.
@@ -101,7 +101,7 @@ async fn get_with_transform() {
         ..Default::default()
     };
     let cycles = cycles_cost(&args);
-    let res = http_request(args, cycles).await.unwrap();
+    let res = http_request(&args, cycles).await.unwrap();
     assert_eq!(res.status, 200u32);
     assert_eq!(
         res.headers,
@@ -134,7 +134,7 @@ async fn get_with_transform_closure() {
     };
     // The transform closure takes 40 bytes.
     let cycles = cycles_cost(&args) + 40 * 400 * 13;
-    let res = http_request_with_closure(args.clone(), cycles, transform)
+    let res = http_request_with_closure(&args, cycles, transform)
         .await
         .unwrap();
     assert_eq!(res.status, 200u32);