update delete && readme

Author: nopestack

Cargo.lock

@@ -14,6 +14,7 @@ bincode = "1.3.3"
 chrono = { version = "0.4.31", features = ["serde"] }
 clap = { version = "4.4.16", features = ["derive"] }
 futures = "0.3.30"
+hex = { version = "0.4.3", features = ["serde"] }
 hyper = { version = "1.1.0", features = ["full"] }
 hyper-util = { version = "0.1.2", features = ["tokio", "server-auto", "http1"] }
 reqwest = { version = "0.11.23", features = ["multipart", "json"] }

Cargo.toml

@@ -35,4 +35,8 @@ target/release/mach
 ```
 
 ### Roadmap
-TBD
+- Improved test coverage
+- TLS/SSL support
+- IPFS storage backend
+- Inter-function calls
+- Inter server function calls

README.md

@@ -1,8 +1,12 @@
 use std::net::SocketAddr;
 
 use crate::{
-    api::{routes::call::CallRequest, API_VERSION},
+    api::{
+        routes::{call::CallRequest, upload::UploadResponse},
+        API_VERSION,
+    },
     exec::task::TaskResult,
+    storage::FnEntry,
 };
 
 use super::routes::{get::GetResponse, list::ListResponse};
@@ -30,7 +34,7 @@ impl Client {
     }
 
     /// Gets detailed information about a function
-    pub async fn get(&self, addr: SocketAddr, fn_id: &str) -> anyhow::Result<GetResponse> {
+    pub async fn get(&self, addr: SocketAddr, fn_id: &uuid::Uuid) -> anyhow::Result<GetResponse> {
         let url = format!("http://{addr}/{API_VERSION}/functions/{fn_id}");
 
         let response = self.r_client.get(url).send().await?;
@@ -43,12 +47,12 @@ impl Client {
     pub async fn call(
         &mut self,
         addr: SocketAddr,
-        fn_name: &str,
+        id: &uuid::Uuid,
         args: Vec<u8>,
     ) -> anyhow::Result<TaskResult> {
-        let call_url = format!("http://{addr}/{API_VERSION}/functions/{fn_name}");
+        let call_url = format!("http://{addr}/{API_VERSION}/functions/{id}");
         let call_request = CallRequest {
-            function: fn_name.to_string(),
+            id: id.to_owned(),
             args,
         };
 
@@ -70,7 +74,7 @@ impl Client {
         addr: SocketAddr,
         fn_name: &str,
         fn_data: Vec<u8>,
-    ) -> anyhow::Result<()> {
+    ) -> anyhow::Result<UploadResponse> {
         let form = reqwest::multipart::Form::new();
         let part = reqwest::multipart::Part::bytes(fn_data)
             .file_name(fn_name.to_string())
@@ -80,18 +84,21 @@ impl Client {
 
         let upload_url = format!("http://{addr}/{API_VERSION}/functions");
 
-        self.r_client
+        let raw_response = self
+            .r_client
             .post(upload_url)
             .multipart(form)
             .send()
             .await?;
 
-        Ok(())
+        let response = raw_response.json::<UploadResponse>().await?;
+
+        Ok(response)
     }
 
     /// Deletes a function from the server
-    pub async fn delete(&mut self, addr: SocketAddr, fn_name: &str) -> anyhow::Result<()> {
-        let delete_url = format!("http://{addr}/{API_VERSION}/functions/{fn_name}");
+    pub async fn delete(&mut self, addr: SocketAddr, fn_id: &uuid::Uuid) -> anyhow::Result<()> {
+        let delete_url = format!("http://{addr}/{API_VERSION}/functions/{fn_id}");
 
         self.r_client.delete(delete_url).send().await?;
 

src/api/client.rs

@@ -104,11 +104,17 @@ mod tests {
         server.run().await.unwrap();
 
         let server_addr = server.local_addr();
-        let fn_id = TEST_WASM_NAME;
-        let fn_id = fn_id.replace(".wasm", "");
 
-        let api_client = ApiClient::new().unwrap();
-        let response = api_client.get(server_addr, &fn_id).await.unwrap();
+        let fn_file = read_file_to_bytes("tests/fixtures/hello.wasm").unwrap();
+        let fn_name = "hello_1.wasm";
+
+        let mut api_client = ApiClient::new().unwrap();
+        let response = api_client
+            .upload(server_addr, fn_name, fn_file)
+            .await
+            .unwrap();
+
+        let response = api_client.get(server_addr, &response.id).await.unwrap();
 
         assert!(!response.fn_data.is_empty());
 
@@ -120,12 +126,13 @@ mod tests {
         let mut server = setup_server().await;
         server.run().await.unwrap();
 
-        let non_existent_fn_id = "non_existent_function";
-
         let server_addr = server.local_addr();
 
         let api_client = ApiClient::new().unwrap();
-        let response = api_client.get(server_addr, non_existent_fn_id).await;
+
+        let fn_id = uuid::Uuid::new_v4();
+
+        let response = api_client.get(server_addr, &fn_id).await;
         assert!(response.is_err());
 
         server.stop();
@@ -138,14 +145,21 @@ mod tests {
 
         let server_addr = server.local_addr();
 
-        let fn_id = TEST_WASM_NAME;
-        let fn_id = fn_id.replace(".wasm", "");
+        let fn_file = read_file_to_bytes("tests/fixtures/hello.wasm").unwrap();
+        let fn_name = "hello_1.wasm";
 
         let mut api_client = ApiClient::new().unwrap();
-        let response = api_client.call(server_addr, &fn_id, vec![]).await.unwrap();
+        let response = api_client
+            .upload(server_addr, fn_name, fn_file)
+            .await
+            .unwrap();
 
-        let expected_response = "Hello, world!\n";
+        let response = api_client
+            .call(server_addr, &response.id, vec![])
+            .await
+            .unwrap();
 
+        let expected_response = "Hello, world!\n";
         assert_eq!(response.stdout, expected_response);
 
         server.stop();
@@ -157,34 +171,38 @@ mod tests {
         server.run().await.unwrap();
 
         let server_addr = server.local_addr();
-        let invalid_fn_name = "non_existent_function";
 
-        let mut api_client = ApiClient::new().unwrap();
-        let response = api_client.call(server_addr, invalid_fn_name, vec![]).await;
+        let fn_id = uuid::Uuid::new_v4();
 
+        let mut api_client = ApiClient::new().unwrap();
+        let response = api_client.call(server_addr, &fn_id, vec![]).await;
         assert!(response.is_err());
 
         server.stop();
     }
 
     #[tokio::test]
-    #[ignore]
     async fn test_delete_functions() {
-        // let mut server = setup_server().await;
-        // server.run().await.unwrap();
-        //
-        // let server_addr = server.local_addr();
-        //
-        // let fn_file = read_file_to_bytes("tests/fixtures/hello.wasm").unwrap();
-        //
-        // let fn_id = TEST_WASM_NAME;
-        // let fn_id = fn_id.replace(".wasm", "");
-        //
-        // let mut api_client = ApiClient::new().unwrap();
-        // let response = api_client.upload(server_addr, &fn_id, fn_file).await;
-        //
-        // assert!(response.is_ok());
-        //
-        // server.stop();
+        let mut server = setup_server().await;
+        server.run().await.unwrap();
+
+        let server_addr = server.local_addr();
+
+        let fn_file = read_file_to_bytes("tests/fixtures/hello.wasm").unwrap();
+        let fn_name = "hello_1.wasm";
+
+        let mut api_client = ApiClient::new().unwrap();
+
+        let response = api_client
+            .upload(server_addr, fn_name, fn_file)
+            .await
+            .unwrap();
+
+        api_client.delete(server_addr, &response.id).await.unwrap();
+
+        let get_response = api_client.get(server_addr, &response.id).await;
+        assert!(get_response.is_err());
+
+        server.stop();
     }
 }

src/api/mod.rs

@@ -9,7 +9,7 @@ use crate::storage::FnStorage;
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct CallRequest {
-    pub function: String,
+    pub id: uuid::Uuid,
     pub args: Vec<u8>,
 }
 
@@ -23,7 +23,7 @@ where
     T: TaskExecutor + 'static,
 {
     let mut state = state.write().await;
-    let module = state.storage_backend.load(&req.function).await?;
+    let module = state.storage_backend.load(&req.id).await?;
 
     let task = Task {
         id: uuid::Uuid::new_v4(),

src/api/routes/call.rs

@@ -3,12 +3,12 @@ use axum::extract::{Path, State};
 use crate::{
     api::{ApiError, SharedServerState},
     exec::TaskExecutor,
-    storage::FnStorage,
+    storage::{FnId, FnStorage},
 };
 
 #[tracing::instrument]
 pub async fn delete_handler<F, T>(
-    Path(fn_id): Path<String>,
+    Path(fn_id): Path<FnId>,
     State(state): State<SharedServerState<F, T>>,
 ) -> Result<(), ApiError>
 where

src/api/routes/delete.rs

@@ -18,7 +18,7 @@ pub struct GetResponse {
 
 #[tracing::instrument]
 pub async fn get_handler<F, T>(
-    Path(fn_id): Path<String>,
+    Path(fn_id): Path<uuid::Uuid>,
     State(state): State<SharedServerState<F, T>>,
 ) -> Result<Json<GetResponse>, ApiError>
 where

src/api/routes/get.rs

@@ -1,4 +1,8 @@
-use axum::extract::{Multipart, State};
+use axum::{
+    extract::{Multipart, State},
+    Json,
+};
+use serde::{Deserialize, Serialize};
 
 use crate::{
     api::{ApiError, SharedServerState},
@@ -12,12 +16,22 @@ use std::{io, path::Path};
 use tokio::{fs::File, io::BufWriter};
 use tokio_util::io::StreamReader;
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct UploadResponse {
+    /// Unique identifier for the function
+    pub id: uuid::Uuid,
+    /// Display name for the function
+    pub name: String,
+    /// Cecksum of the function file
+    pub hash: String,
+}
+
 /// Handler that accepts a multipart form upload and streams each field to a file.
 #[tracing::instrument]
 pub async fn upload_handler<F, T>(
     State(state): State<SharedServerState<F, T>>,
     mut multipart: Multipart,
-) -> Result<(), ApiError>
+) -> Result<Json<UploadResponse>, ApiError>
 where
     F: FnStorage + 'static,
     T: TaskExecutor + 'static,
@@ -45,10 +59,23 @@ where
             hash: fn_hash,
         };
 
-        state.write().await.storage_backend.save(fn_entry).await?;
+        let response = UploadResponse {
+            id: fn_entry.id,
+            name: fn_entry.name.clone(),
+            hash: hex::encode(fn_entry.hash.clone()),
+        };
+
+        state
+            .write()
+            .await
+            .storage_backend
+            .save(fn_entry.clone())
+            .await?;
+
+        return Ok(Json(response));
     }
 
-    Ok(())
+    Err(ApiError::Other("received no files".to_string()))
 }
 
 async fn stream_to_file<S, E>(path: &Path, file_name: &str, stream: S) -> anyhow::Result<Vec<u8>>