Fix: disable https in the proxy client if the http flag is true.

rs/https_outcalls/adapter/src/rpc_server.rs

@@ -137,11 +137,17 @@ impl CanisterHttp {
         http_connector
             .set_connect_timeout(Some(Duration::from_secs(self.http_connect_timeout_secs)));
 
+        let builder = HttpsConnectorBuilder::new()
+            .with_native_roots()
+            .expect("Failed to set native roots");
+
+        #[cfg(not(feature = "http"))]
+        let builder = builder.https_only();
+        #[cfg(feature = "http")]
+        let builder = builder.https_or_http();
+
         Client::builder(TokioExecutor::new()).build::<_, Full<Bytes>>(
-            HttpsConnectorBuilder::new()
-                .with_native_roots()
-                .expect("Failed to set native roots")
-                .https_only()
+            builder
                 .enable_all_versions()
                 .wrap_connector(SocksConnector {
                     proxy_addr,

rs/rust_canisters/proxy_canister/BUILD.bazel

@@ -5,19 +5,22 @@ package(default_visibility = ["//visibility:public"])
 
 rust_library(
     name = "lib",
+    testonly = True,
     srcs = ["src/lib.rs"],
     crate_name = "proxy_canister",
     version = "0.1.0",
     deps = [
         # Keep sorted.
         "//rs/types/management_canister_types",
         "@crate_index//:candid",
+        "@crate_index//:ic_cdk_0_17_1",
         "@crate_index//:serde",
     ],
 )
 
 rust_canister(
     name = "proxy_canister",
+    testonly = True,
     srcs = ["src/main.rs"],
     proc_macro_deps = ["@crate_index//:ic_cdk_macros_0_17_1"],
     service_file = ":empty.did",

rs/rust_canisters/proxy_canister/src/lib.rs

@@ -8,6 +8,7 @@
 use std::time::Duration;
 
 use candid::{CandidType, Deserialize};
+use ic_cdk::api::call::RejectionCode;
 use ic_management_canister_types_private::{
     BoundedHttpHeaders, HttpHeader, HttpMethod, Payload, TransformContext,
 };
@@ -61,6 +62,12 @@ pub struct RemoteHttpResponse {
     pub body: String,
 }
 
+#[derive(Clone, Debug, CandidType, Deserialize)]
+pub struct ResponseWithRefundedCycles {
+    pub result: Result<RemoteHttpResponse, (RejectionCode, String)>,
+    pub refunded_cycles: u64,
+}
+
 #[derive(Clone, Debug, CandidType, Deserialize)]
 pub struct RemoteHttpStressResponse {
     pub response: RemoteHttpResponse,

rs/rust_canisters/proxy_canister/src/main.rs

@@ -16,6 +16,7 @@ use ic_management_canister_types_private::{
 };
 use proxy_canister::{
     RemoteHttpRequest, RemoteHttpResponse, RemoteHttpStressRequest, RemoteHttpStressResponse,
+    ResponseWithRefundedCycles,
 };
 use std::cell::RefCell;
 use std::collections::HashMap;
@@ -117,14 +118,13 @@ async fn run_continuous_request_loop(request: RemoteHttpRequest) {
     });
 }
 
-#[update]
-async fn send_request(
+async fn make_http_request_with_refund_callback(
     request: RemoteHttpRequest,
-) -> Result<RemoteHttpResponse, (RejectionCode, String)> {
+) -> (Result<RemoteHttpResponse, (RejectionCode, String)>, u64) {
     let RemoteHttpRequest { request, cycles } = request;
     let request_url = request.url.clone();
     println!("send_request making IC call.");
-    match ic_cdk::api::call::call_raw(
+    let result = match ic_cdk::api::call::call_raw(
         Principal::management_canister(),
         "http_request",
         &request.encode(),
@@ -163,7 +163,25 @@ async fn send_request(
             });
             Err((r, m))
         }
-    }
+    };
+    let refund = ic_cdk::api::call::msg_cycles_refunded();
+    (result, refund)
+}
+
+#[update]
+async fn send_request(
+    request: RemoteHttpRequest,
+) -> Result<RemoteHttpResponse, (RejectionCode, String)> {
+    let (result, _) = make_http_request_with_refund_callback(request).await;
+    result
+}
+
+#[update]
+async fn send_request_and_retrieve_refund(
+    request: RemoteHttpRequest,
+) -> ResponseWithRefundedCycles {
+    let (result, refunded_cycles) = make_http_request_with_refund_callback(request).await;
+    ResponseWithRefundedCycles{result, refunded_cycles}
 }
 
 #[query]