Concurrent upload processing

@@ -7,23 +7,20 @@ mod routes;
 mod schema;
 mod uuid;
 
-use crate::routes::markdown::*;
-use crate::routes::other::*;
-use crate::routes::user::*;
+use routes::markdown::*;
+use routes::other::*;
+use routes::user::*;
+use routes::upload::*;
 use crate::uuid::Uuid;
 
 use actix_web::{guard, web, App, HttpResponse, HttpServer};
-use async_std::channel::Receiver;
-use async_std::channel::Sender;
-use async_std::channel::bounded;
-use async_std::fs::File;
+use async_std::{ channel::{ Sender, bounded }
+               , fs::File };
 use diesel::r2d2::{self, ConnectionManager};
 use diesel::SqliteConnection;
-use futures::AsyncReadExt;
-use futures::AsyncSeekExt;
+use futures::{ AsyncReadExt, AsyncSeekExt, FutureExt, StreamExt, select
+             , stream::FuturesUnordered };
 use listenfd::ListenFd;
-use routes::markdown::get_markdown;
-use routes::upload::upload;
 use std::io::SeekFrom;
 use std::sync::Arc;
 
@@ -68,18 +65,34 @@ async fn main() -> std::io::Result<()> {
 
     dotenv::dotenv().ok();
 
-    let ( tx_upload_worker
-        , rx_upload_worker ) :( Sender<String>
-                              , Receiver<String> ) = bounded(32);
+    let (tx_upload_worker, rx_upload_worker) = bounded(32);
 
     let _upload_worker = actix_rt::spawn(async move {
-        while let Ok(filename) = rx_upload_worker.recv().await {
-            let mut f = File::open(&filename).await.unwrap();
-            let mut buf = vec!['.' as u8; 3 * 4096];
-            get_sample(&mut f, buf.as_mut()).await.unwrap();
-            println!("[UPLOAD WORKER] filename: {}", filename);
-            println!( "[UPLOAD WORKER] uuid: {}"
-                    , Uuid::get("some.unique.namespace", buf.as_mut()) );
+        let mut workers = FuturesUnordered::new();
+
+        loop {
+            select! {
+                filename = rx_upload_worker.recv().fuse() => {
+                    match filename {
+                        Err(_) => break,
+                        Ok(filename) => workers.push(async move {
+                            let mut f = File::open(&filename).await.unwrap();
+                            let mut buf = vec!['.' as u8; 3 * 4096];
+                            get_sample(&mut f, buf.as_mut()).await.unwrap();
+                            println!( "[UPLOAD WORKER] filename: {}"
+                                    , filename );
+                            println!( "[UPLOAD WORKER] uuid: {}"
+                                    , Uuid::get( "some.unique.namespace"
+                                               , buf.as_mut() ) );
+                        })
+                    }
+                },
+                _result = workers.next() => {},
+            }
+        }
+
+        while workers.len() > 0 {
+            workers.next().await;
         }
     });