relay: sender: client: added route to signal successfull download to relay

src/cli/args.rs

@@ -113,10 +113,16 @@ impl Args {
                             Ok(_) => match receiver::download_file(&res, overwrite).await {
                                 Ok(_) => {
                                     info!("Download complete");
-                                    let _ = match receiver::signal_success(&res.body.ip).await {
+                                    receiver::signal_success_relay(
-                                        Ok(_) => Ok(()),
+                                        relay.as_deref().unwrap_or("http://0.0.0.0:8000"),
-                                        Err(err) => Err(err),
+                                        name.as_deref().unwrap_or("None"),
-                                    };
+                                    )
+                                    .await?;
+                                    let _ =
+                                        match receiver::signal_success_sender(&res.body.ip).await {
+                                            Ok(_) => Ok(()),
+                                            Err(err) => Err(err),
+                                        };
                                 }
                                 Err(err) => error!(err),
                             },

src/receiver/client.rs

@@ -74,7 +74,19 @@ pub async fn ping_sender(sender: &String) -> Result<bool> {
     }
 }
 
-pub async fn signal_success(sender: &String) -> Result<()> {
+pub async fn signal_success_relay(relay: &str, name: &str) -> Result<()> {
+    let hashed_name = Sha256::digest(name.as_bytes());
+    let hashed_string = hex::encode(hashed_name);
+    debug!("Signaling success to {:#?}", relay);
+    let client = Client::new();
+    let _ = client
+        .post(format!("{}/download_success/{}", relay, hashed_string))
+        .send()
+        .await?;
+    Ok(())
+}
+
+pub async fn signal_success_sender(sender: &String) -> Result<()> {
     debug!("Signaling shutdown to {:#?}", sender);
     let client = Client::new();
     let _ = client

src/relay/server.rs

@@ -54,6 +54,7 @@ pub async fn start_server(port: Option<&i32>, listen_addr: Option<&String>) {
         .route("/status", get(status))
         .route("/upload", post(upload_info))
         .route("/download/:name", get(download_info))
+        .route("/download_success/:name", post(download_success))
         .with_state(shared_state)
         .layer(SecureClientIpSource::ConnectInfo.into_extension());
     let listener = tokio::net::TcpListener::bind(format!("{}:{}", app_host, app_port).to_string())
@@ -134,6 +135,52 @@ async fn status() -> impl IntoResponse {
     (StatusCode::OK, Json(response))
 }
 
+async fn download_success(
+    State(shared_state): State<AppState>,
+    Path(name): Path<String>,
+) -> impl IntoResponse {
+    let mut data = shared_state.data.lock().unwrap();
+    if let Some(index) = data.iter().position(|request| request.body.name == name) {
+        debug!("Found Transfer by name '{name}'");
+        data.remove(index);
+        debug!("Transfer deleted");
+        return (
+            StatusCode::OK,
+            Json(json!({
+                "message": "transfer deleted"
+            })),
+        );
+    } else {
+        warn!("couldn't find transfer-name: {}", name);
+        return (
+            StatusCode::NOT_FOUND,
+            Json(json!({
+                "message": "transfer not found"
+            })),
+        );
+    }
+    // match data.iter().find(|request| request.body.name == name) {
+    //     Some(request) => {
+    //         debug!("Found transfer name.");
+    //         return (
+    //             StatusCode::OK,
+    //             Json(json!({
+    //                 "message" : "transfer deleted"
+    //             })),
+    //         );
+    //     }
+    //     None => {
+    //         warn!("couldn't find transfer-name: {}", name);
+    //         return (
+    //             StatusCode::NOT_FOUND,
+    //             Json(json!({
+    //                 "message" : "transfer not found"
+    //             })),
+    //         );
+    //     }
+    // }
+}
+
 async fn shutdown_signal() {
     let ctrl_c = async {
         signal::ctrl_c()

src/sender/client.rs

@@ -26,7 +26,7 @@ pub async fn send_info(relay: &str, file: &str) -> Result<String> {
 
     let client = Client::new();
     let res = client
-        .post(relay.to_string() + "/upload")
+        .post(format!("{}/upload", relay))
         .json(&map)
         .send()
         .await?;