Posting a file with tedge http post --file

Signed-off-by: Didier Wenzek <[email protected]>

Author: didier-wenzek

crates/core/tedge/src/cli/http/cli.rs

@@ -1,13 +1,17 @@
+use crate::cli::http::command::HttpAction;
 use crate::cli::http::command::HttpCommand;
 use crate::command::BuildCommand;
 use crate::command::BuildContext;
 use crate::command::Command;
 use crate::ConfigError;
 use anyhow::anyhow;
 use anyhow::Error;
+use camino::Utf8PathBuf;
 use certificate::CloudRootCerts;
+use clap::Args;
 use reqwest::blocking;
 use reqwest::Identity;
+use std::fs::File;
 use tedge_config::OptionalConfig;
 use tedge_config::ProfileName;
 
@@ -18,8 +22,9 @@ pub enum TEdgeHttpCli {
         /// Target URI
         uri: String,
 
-        /// Content to post
-        content: String,
+        /// Content to send
+        #[command(flatten)]
+        content: Content,
 
         /// Optional c8y cloud profile
         #[clap(long)]
@@ -31,8 +36,9 @@ pub enum TEdgeHttpCli {
         /// Target URI
         uri: String,
 
-        /// Content to post
-        content: String,
+        /// Content to send
+        #[command(flatten)]
+        content: Content,
 
         /// Optional c8y cloud profile
         #[clap(long)]
@@ -60,6 +66,40 @@ pub enum TEdgeHttpCli {
     },
 }
 
+#[derive(Args, Clone, Debug)]
+#[group(required = true, multiple = false)]
+pub struct Content {
+    /// Content to send
+    #[arg(name = "content")]
+    arg2: Option<String>,
+
+    /// Content to send
+    #[arg(long)]
+    data: Option<String>,
+
+    /// File which content is sent
+    #[arg(long)]
+    file: Option<Utf8PathBuf>,
+}
+
+impl TryFrom<Content> for blocking::Body {
+    type Error = std::io::Error;
+
+    fn try_from(content: Content) -> Result<Self, Self::Error> {
+        let body: blocking::Body = if let Some(data) = content.arg2 {
+            data.into()
+        } else if let Some(data) = content.data {
+            data.into()
+        } else if let Some(file) = content.file {
+            File::open(file)?.into()
+        } else {
+            "".into()
+        };
+
+        Ok(body)
+    }
+}
+
 impl BuildCommand for TEdgeHttpCli {
     fn build_command(self, context: BuildContext) -> Result<Box<dyn Command>, ConfigError> {
         let config = context.load_config()?;
@@ -79,27 +119,20 @@ impl BuildCommand for TEdgeHttpCli {
         };
 
         let url = format!("{protocol}://{host}:{port}{uri}");
-        let verb_url = format!("{} {url}", self.verb());
         let identity = config.http.client.auth.identity()?;
         let client = http_client(config.cloud_root_certs(), identity.as_ref())?;
 
-        let request = match self {
-            TEdgeHttpCli::Post { content, .. } => client
-                .post(url)
-                .header("Accept", "application/json")
-                .header("Content-Type", "application/json")
-                .body(content),
-            TEdgeHttpCli::Put { content, .. } => client
-                .put(url)
-                .header("Content-Type", "application/json")
-                .body(content),
-            TEdgeHttpCli::Get { .. } => client.get(url).header("Accept", "application/json"),
-            TEdgeHttpCli::Delete { .. } => client.delete(url),
+        let action = match self {
+            TEdgeHttpCli::Post { content, .. } => HttpAction::Post(content),
+            TEdgeHttpCli::Put { content, .. } => HttpAction::Put(content),
+            TEdgeHttpCli::Get { .. } => HttpAction::Get,
+            TEdgeHttpCli::Delete { .. } => HttpAction::Delete,
         };
 
         Ok(HttpCommand {
-            url: verb_url,
-            request,
+            client,
+            url,
+            action,
         }
         .into_boxed())
     }
@@ -115,15 +148,6 @@ impl TEdgeHttpCli {
         }
     }
 
-    fn verb(&self) -> &str {
-        match self {
-            TEdgeHttpCli::Post { .. } => "POST",
-            TEdgeHttpCli::Put { .. } => "PUT",
-            TEdgeHttpCli::Get { .. } => "GET",
-            TEdgeHttpCli::Delete { .. } => "DELETE",
-        }
-    }
-
     fn c8y_profile(&self) -> Option<&ProfileName> {
         match self {
             TEdgeHttpCli::Post { profile, .. }

crates/core/tedge/src/cli/http/command.rs

@@ -1,35 +1,73 @@
+use crate::cli::http::cli::Content;
 use crate::command::Command;
 use crate::log::MaybeFancy;
 use anyhow::Error;
 use reqwest::blocking;
 
 pub struct HttpCommand {
+    /// HTTP client
+    pub client: blocking::Client,
+
     /// Target url
     pub url: String,
 
-    /// HTTP request
-    pub request: blocking::RequestBuilder,
+    /// Action
+    pub action: HttpAction,
+}
+
+pub enum HttpAction {
+    Post(Content),
+    Put(Content),
+    Get,
+    Delete,
 }
 
 impl Command for HttpCommand {
     fn description(&self) -> String {
-        self.url.clone()
+        let verb = match self.action {
+            HttpAction::Post(_) => "POST",
+            HttpAction::Put(_) => "PUT",
+            HttpAction::Get => "GET",
+            HttpAction::Delete => "DELETE",
+        };
+        format!("{verb} {}", self.url)
     }
 
     fn execute(&self) -> Result<(), MaybeFancy<Error>> {
-        Ok(self.send()?)
+        let request = self.request()?;
+        HttpCommand::send(request)?;
+        Ok(())
     }
 }
 
 impl HttpCommand {
-    fn send(&self) -> Result<(), Error> {
-        if let Some(request) = self.request.try_clone() {
-            let http_result = request.send()?;
-            let http_response = http_result.error_for_status()?;
-            let bytes = http_response.bytes()?.to_vec();
-            let content = String::from_utf8(bytes)?;
-            println!("{content}");
-        }
+    fn request(&self) -> Result<blocking::RequestBuilder, Error> {
+        let client = &self.client;
+        let url = &self.url;
+        let request = match &self.action {
+            HttpAction::Post(content) => client
+                .post(url)
+                .header("Accept", "application/json")
+                .header("Content-Type", "application/json")
+                .body(blocking::Body::try_from(content.clone())?),
+            HttpAction::Put(content) => client
+                .put(url)
+                .header("Content-Type", "application/json")
+                .body(blocking::Body::try_from(content.clone())?),
+            HttpAction::Get => client.get(url).header("Accept", "application/json"),
+            HttpAction::Delete => client.delete(url),
+        };
+
+        Ok(request)
+    }
+
+    fn send(request: blocking::RequestBuilder) -> Result<(), Error> {
+        let http_result = request.send()?;
+        let http_response = http_result.error_for_status()?;
+        let bytes = http_response.bytes()?.to_vec();
+        let content = String::from_utf8(bytes)?;
+
+        println!("{content}");
         Ok(())
     }
 }