refactor: Upgrade to wstd 0.6.1

Author: tomasol

activity/fly-http/impl/src/app.rs

@@ -2,15 +2,14 @@ use crate::generated::exports::obelisk_flyio::activity_fly_http::apps;
 use crate::{API_BASE_URL, AppName, OrgSlug, request_with_api_token};
 use anyhow::anyhow;
 use serde::{Deserialize, Serialize};
-use wstd::http::request::JsonRequest as _;
-use wstd::http::{Client, Method, StatusCode};
+use wstd::http::{Body, Client, Method, StatusCode};
 use wstd::runtime::block_on;
 
 async fn get(app_name: AppName) -> Result<Option<apps::App>, anyhow::Error> {
     let request = request_with_api_token()?
         .method(Method::GET)
         .uri(format!("{API_BASE_URL}/apps/{app_name}"))
-        .body(wstd::io::empty())?;
+        .body(Body::empty())?;
     let mut response = Client::new().send(request).await?;
 
     if response.status().is_success() {
@@ -20,11 +19,9 @@ async fn get(app_name: AppName) -> Result<Option<apps::App>, anyhow::Error> {
         Ok(None)
     } else {
         let error_status = response.status();
-        let error_body = response.body_mut().bytes().await?;
-        Err(anyhow!(
-            "failed with status {error_status}: {}",
-            String::from_utf8_lossy(&error_body)
-        ))
+        let mut response = response.into_body();
+        let error_body = response.str_contents().await?;
+        Err(anyhow!("failed with status {error_status}: {error_body}",))
     }
 }
 
@@ -46,7 +43,7 @@ async fn put(org_slug: OrgSlug, app_name: AppName) -> Result<apps::App, anyhow::
     let post_request = request_with_api_token()?
         .method(Method::POST)
         .uri(format!("{API_BASE_URL}/apps"))
-        .json(&request_body)?;
+        .body(Body::from_json(&request_body)?)?;
 
     let mut response = client.send(post_request).await?;
 
@@ -64,14 +61,14 @@ async fn put(org_slug: OrgSlug, app_name: AppName) -> Result<apps::App, anyhow::
 
     // Investigate if the app already exists
     let original_post_status = response.status();
-    let original_post_error = response.into_body().bytes().await;
+    let mut response = response.into_body();
 
     if original_post_status == StatusCode::UNPROCESSABLE_ENTITY {
         // Prepare a GET request to check for the existing app.
         let get_request = request_with_api_token()?
             .method(Method::GET)
             .uri(format!("{API_BASE_URL}/apps/{app_name}"))
-            .body(wstd::io::empty())?;
+            .body(Body::empty())?;
 
         let mut get_response = client.send(get_request).await?;
 
@@ -108,19 +105,17 @@ async fn put(org_slug: OrgSlug, app_name: AppName) -> Result<apps::App, anyhow::
     }
     // The GET request failed, so the app doesn't exist.
     // The original error from the POST request is the true cause of failure.
+    let original_post_error = response.str_contents().await?;
     Err(anyhow!(
-        "failed with status {original_post_status}: {}",
-        original_post_error
-            .map(|vec| String::from_utf8_lossy(&vec).to_string())
-            .unwrap_or_else(|e| e.to_string())
+        "failed with status {original_post_status}: {original_post_error}",
     ))
 }
 
 async fn list(org_slug: OrgSlug) -> Result<Vec<apps::App>, anyhow::Error> {
     let request = request_with_api_token()?
         .method(Method::GET)
         .uri(format!("{API_BASE_URL}/apps?org_slug={org_slug}"))
-        .body(wstd::io::empty())?;
+        .body(Body::empty())?;
     let mut response = Client::new().send(request).await?;
 
     if response.status().is_success() {
@@ -132,11 +127,9 @@ async fn list(org_slug: OrgSlug) -> Result<Vec<apps::App>, anyhow::Error> {
         Ok(apps_response.apps)
     } else {
         let error_status = response.status();
-        let error_body = response.body_mut().bytes().await?;
-        Err(anyhow!(
-            "failed with status {error_status}: {}",
-            String::from_utf8_lossy(&error_body)
-        ))
+        let mut response = response.into_body();
+        let error_body = response.str_contents().await?;
+        Err(anyhow!("failed with status {error_status}: {error_body}",))
     }
 }
 
@@ -148,7 +141,7 @@ async fn delete(app_name: AppName, force: bool) -> Result<(), anyhow::Error> {
     let request = request_with_api_token()?
         .method(Method::DELETE)
         .uri(url)
-        .body(wstd::io::empty())?;
+        .body(Body::empty())?;
 
     let response = Client::new().send(request).await?;
     let status = response.status();
@@ -157,11 +150,9 @@ async fn delete(app_name: AppName, force: bool) -> Result<(), anyhow::Error> {
         Ok(())
     } else {
         let error_status = response.status();
-        let error_body = response.into_body().bytes().await?;
-        Err(anyhow!(
-            "failed with status {error_status}: {}",
-            String::from_utf8_lossy(&error_body)
-        ))
+        let mut response = response.into_body();
+        let error_body = response.str_contents().await?;
+        Err(anyhow!("failed with status {error_status}: {error_body}",))
     }
 }
 

activity/fly-http/impl/src/ips.rs

@@ -5,8 +5,7 @@ use crate::generated::obelisk_flyio::activity_fly_http::regions::Region;
 use crate::{API_BASE_URL, AppName, request_with_api_token};
 use anyhow::anyhow;
 use serde::{Deserialize, Deserializer, Serialize};
-use wstd::http::request::JsonRequest;
-use wstd::http::{Client, Method, StatusCode};
+use wstd::http::{Body, Client, Method, StatusCode};
 use wstd::runtime::block_on;
 
 async fn allocate_ip(app_name: AppName, request: ips::IpRequest) -> Result<String, anyhow::Error> {
@@ -44,32 +43,33 @@ async fn allocate_ip(app_name: AppName, request: ips::IpRequest) -> Result<Strin
     let request = request_with_api_token()?
         .method(Method::POST)
         .uri(format!("{API_BASE_URL}/apps/{app_name}/ip_assignments"))
-        .json(&body)?;
+        .header("content-type", "application/json")
+        .body(Body::from_json(&body)?)?;
 
-    let mut response = Client::new().send(request).await?;
+    let response = Client::new().send(request).await?;
+    let resp_status = response.status();
+    let mut response = response.into_body();
+    let response = response.str_contents().await?;
 
-    if response.status().is_success() {
+    if resp_status.is_success() {
         #[derive(Deserialize)]
         struct AssignIpResponse {
             ip: String,
         }
-        let assign_response: AssignIpResponse = response.body_mut().json().await?;
-        Ok(assign_response.ip)
+
+        let response: AssignIpResponse = serde_json::from_str(response)
+            .inspect_err(|_| eprintln!("cannot deserialize: {response}"))?;
+        Ok(response.ip)
     } else {
-        let error_status = response.status();
-        let error_body = response.body_mut().bytes().await?;
-        Err(anyhow!(
-            "failed with status {error_status}: {}",
-            String::from_utf8_lossy(&error_body)
-        ))
+        Err(anyhow!("failed with status {resp_status}: {response}",))
     }
 }
 
 async fn list_ips(app_name: AppName) -> Result<Vec<ips::IpDetail>, anyhow::Error> {
     let request = request_with_api_token()?
         .method(Method::GET)
         .uri(format!("{API_BASE_URL}/apps/{app_name}/ip_assignments"))
-        .body(wstd::io::empty())?;
+        .body(Body::empty())?;
 
     let mut response = Client::new().send(request).await?;
 
@@ -117,11 +117,9 @@ async fn list_ips(app_name: AppName) -> Result<Vec<ips::IpDetail>, anyhow::Error
         Ok(ip_details)
     } else {
         let error_status = response.status();
-        let error_body = response.body_mut().bytes().await?;
-        Err(anyhow!(
-            "failed with status {error_status}: {}",
-            String::from_utf8_lossy(&error_body)
-        ))
+        let mut response = response.into_body();
+        let error_body = response.str_contents().await?;
+        Err(anyhow!("failed with status {error_status}: {error_body}",))
     }
 }
 
@@ -131,7 +129,7 @@ async fn release_ip(app_name: AppName, ip: String) -> Result<(), anyhow::Error>
         .uri(format!(
             "{API_BASE_URL}/apps/{app_name}/ip_assignments/{ip}"
         ))
-        .body(wstd::io::empty())?;
+        .body(Body::empty())?;
 
     let response = Client::new().send(request).await?;
 
@@ -143,11 +141,9 @@ async fn release_ip(app_name: AppName, ip: String) -> Result<(), anyhow::Error>
             // Idempotency: if IP does not exist, return Ok, as this might be a retry.
             return Ok(());
         }
-        let error_body = response.into_body().bytes().await?;
-        Err(anyhow!(
-            "failed with status {error_status}: {}",
-            String::from_utf8_lossy(&error_body)
-        ))
+        let mut response = response.into_body();
+        let error_body = response.str_contents().await?;
+        Err(anyhow!("failed with status {error_status}: {error_body}",))
     }
 }