Removed any (locally) hardcoded values

src/main.rs

@@ -1,5 +1,5 @@
 use axum::{
-    extract::BodyStream,
+    extract::{BodyStream, Extension},
     http::StatusCode,
     response::IntoResponse,
     routing::{get_service, post},
@@ -16,6 +16,8 @@ use tokio_util::io::StreamReader;
 use tower_http::{auth::RequireAuthorizationLayer, services::ServeDir, trace::TraceLayer};
 use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
 
+const STATIC_DIR_NAME: &str = "static";
+
 #[tokio::main]
 async fn main() {
     // Enable tracing
@@ -30,8 +32,9 @@ async fn main() {
     // Get required variables from env vars
     let api_key = std::env::var("API_KEY").expect("No API_KEY was provided.");
     let data_dir = std::env::var("DATA_DIR").expect("No DATA_DIR was provided.");
+    let static_dir = format!("{}/{}", data_dir, STATIC_DIR_NAME);
 
-    std::fs::create_dir_all(&data_dir).unwrap();
+    std::fs::create_dir_all(&static_dir);
 
     let app = Router::new()
         .route(
@@ -39,17 +42,16 @@ async fn main() {
             post(post_deploy).layer(RequireAuthorizationLayer::bearer(&api_key)),
         )
         // The fallback option is to serve the actual static files
-        .fallback(
-            get_service(ServeDir::new(format!("{}/static", data_dir))).handle_error(
-                |error: std::io::Error| async move {
-                    (
-                        StatusCode::INTERNAL_SERVER_ERROR,
-                        format!("Unhandled internal error: {}", error),
-                    )
-                },
-            ),
-        )
-        .layer(TraceLayer::new_for_http());
+        .fallback(get_service(ServeDir::new(static_dir)).handle_error(
+            |error: std::io::Error| async move {
+                (
+                    StatusCode::INTERNAL_SERVER_ERROR,
+                    format!("Unhandled internal error: {}", error),
+                )
+            },
+        ))
+        .layer(TraceLayer::new_for_http())
+        .layer(Extension(data_dir));
 
     let addr = SocketAddr::from(([0, 0, 0, 0], 3000));
     tracing::debug!("listening on {}", addr);
@@ -59,17 +61,19 @@ async fn main() {
         .unwrap();
 }
 
-async fn post_deploy(res: BodyStream) -> impl IntoResponse {
+async fn post_deploy(Extension(data_dir): Extension<String>, res: BodyStream) -> impl IntoResponse {
     // This converts a stream into something that implements AsyncRead, which we can then use to
     // asynchronously write the file to disk
     let mut read =
         StreamReader::new(res.map_err(|axum_err| std::io::Error::new(ErrorKind::Other, axum_err)));
-    let mut file = tokio::fs::File::create("test.archive.gz").await.unwrap();
-    tokio::io::copy(&mut read, &mut file).await.unwrap();
+    let uuid = uuid::Uuid::new_v4();
+    let file_path = Path::new(&data_dir).join(uuid.as_hyphenated().to_string());
+    let mut file = tokio::fs::File::create(&file_path).await.unwrap();
+    tokio::io::copy(&mut read, &mut file).await;
 
     // Extract the contents of the tarball synchronously
-    match tokio::task::spawn_blocking(|| {
-        let file = match std::fs::File::open("test.archive.gz") {
+    match tokio::task::spawn_blocking(move || {
+        let file = match std::fs::File::open(file_path) {
             Ok(v) => v,
             Err(_) => return StatusCode::INTERNAL_SERVER_ERROR,
         };
@@ -84,9 +88,10 @@ async fn post_deploy(res: BodyStream) -> impl IntoResponse {
         };
 
         // Extract each entry into the output directory
+        let static_dir = Path::new(&data_dir).join(STATIC_DIR_NAME);
         for entry_res in entries {
             if let Ok(mut entry) = entry_res {
-                if let Err(_) = entry.unpack_in("static") {
+                if let Err(_) = entry.unpack_in(&static_dir) {
                     return StatusCode::INTERNAL_SERVER_ERROR;
                 }
 
@@ -102,8 +107,7 @@ async fn post_deploy(res: BodyStream) -> impl IntoResponse {
         let mut items = vec![];
 
         // Start by populating the vec with the initial files
-        let base_path = Path::new("static");
-        let iter = match base_path.read_dir() {
+        let iter = match static_dir.read_dir() {
             Ok(v) => v,
             Err(_) => return StatusCode::INTERNAL_SERVER_ERROR,
         };
@@ -115,7 +119,7 @@ async fn post_deploy(res: BodyStream) -> impl IntoResponse {
             let item = items.pop().unwrap();
             tracing::debug!("{:?}", item);
 
-            if !paths.contains(item.strip_prefix("static/").unwrap()) {
+            if !paths.contains(item.strip_prefix(&static_dir).unwrap()) {
                 if item.is_dir() {
                     std::fs::remove_dir_all(item);
                 } else {