improbe config and upload informations handling

+CONFIG=artshop.toml
 DATABASE_URL=crud.db

+[database]
+# url = "./var/lib/artshop/database"
+
+[locations]
+upload = "/tmp/artshop/uploads"
+images = "./var/lib/artshop/images"

@@ -22,8 +22,10 @@ flate2 = "^1.0"
 futures = "^0.3"
 futures-util = { version = "0", features = ["std"] }
 listenfd = "0.3"
+once_cell = "^1.9"
 r2d2 = "0.8.9"
 serde = { version = "^1.0", features = ["derive"] }
 serde_derive = "1.0"
 serde_json = "1.0"
+toml = "^0.5"
 uuid = { version = "^0.8", features = ["v4", "v5"] }

+use std::fs::File;
+use std::io::Read;
+use once_cell::sync::Lazy;
+use serde::Deserialize;
+
+#[derive(Debug, Deserialize)]
+struct Database { url :Option<String> }
+
+#[derive(Debug, Deserialize)]
+struct Locations { upload :String
+                 , images :String }
+
+#[derive(Debug, Deserialize)]
+pub(crate) struct Config { database  :Database
+                         , locations :Locations }
+
+pub(crate) static CONFIG :Lazy<Config> = Lazy::new(|| Config::load());
+
+impl Config {
+    pub fn load() -> Config {
+        let filename = std::env::var("CONFIG").unwrap();
+
+        let mut buffer = vec![];
+        let mut file = File::open(filename).unwrap();
+
+        file.read_to_end(&mut buffer).unwrap();
+        let mut config :Config = toml::from_slice(&buffer).unwrap();
+
+        config.database.url = match config.database.url {
+            Some(url) => Some(url),
+            None => std::env::var("DATABASE_URL").ok()
+        };
+
+        config
+    }
+
+    pub fn upload_dir(&self) -> &str {
+        self.locations.upload.as_str()
+    }
+
+    pub fn images_dir(&self) -> &str {
+        self.locations.images.as_str()
+    }
+}

 #[macro_use]
 extern crate diesel;
 
+mod config;
 mod error;
 mod models;
 mod routes;
 mod schema;
 mod uuid;
-mod upload;
+mod upload_worker;
 
-use async_std::channel::Receiver;
 use models::image::Image;
 use routes::markdown::*;
 use routes::other::*;
 use routes::user::*;
 use routes::upload::*;
-use crate::upload::get_sample;
-use crate::uuid::Uuid;
 
 use actix_web::{guard, web, App, HttpResponse, HttpServer};
-use async_std::{ channel::{ Sender, bounded }
-               , fs::File };
+use async_std::channel::Sender;
 use diesel::r2d2::{self, ConnectionManager};
 use diesel::SqliteConnection;
-use futures::{ FutureExt, StreamExt, select
-             , stream::FuturesUnordered };
 use listenfd::ListenFd;
-use std::convert::TryFrom;
 use std::sync::Arc;
+use std::ops::Deref;
 
 pub(crate) type Pool = r2d2::Pool<ConnectionManager<SqliteConnection>>;
 
@@ -42,39 +37,9 @@ async fn main() -> std::io::Result<()> {
 
     dotenv::dotenv().ok();
 
-    let (tx_upload_worker, rx_upload_worker)
-        : (Sender<Image>, Receiver<Image>) = bounded(32);
+    println!("CONFIG: {:?}", config::CONFIG.deref());
 
-    let _upload_worker = actix_rt::spawn(async move {
-        let mut workers = FuturesUnordered::new();
-
-        loop {
-            select! {
-                filename = rx_upload_worker.recv().fuse() => {
-                    match filename {
-                        Err(_) => break,
-                        Ok(upload) => workers.push(async move {
-                            let upload_uuid = Uuid::try_from(upload.upload_uuid.unwrap()).unwrap();
-                            let upload_filename = format!("/tmp/upload_{}", upload_uuid);
-                            let mut f = File::open(&upload_filename).await.unwrap();
-                            let mut buf = vec!['.' as u8; 3 * 4096];
-                            get_sample(&mut f, buf.as_mut()).await.unwrap();
-                            println!( "[UPLOAD WORKER] filename: {}"
-                                    , upload_filename );
-                            println!( "[UPLOAD WORKER] uuid: {}"
-                                    , Uuid::get( "some.unique.namespace"
-                                               , buf.as_mut() ) );
-                        })
-                    }
-                },
-                _result = workers.next() => {},
-            }
-        }
-
-        while workers.len() > 0 {
-            workers.next().await;
-        }
-    });
+    let tx_upload_worker = upload_worker::launch();
 
     let database_url = std::env::var("DATABASE_URL").expect("NOT FOUND");
     let database_pool = Pool::builder()

@@ -37,6 +37,27 @@ pub struct Upload {
     pub mime_type    :String,
 }
 
+#[macro_export]
+macro_rules! upload_uuid {
+    ($u:expr) => {
+        match &$u.upload_uuid {
+            Some(uuid) => Uuid::try_from(uuid.as_slice()).ok(),
+            None       => None,
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! upload_filename {
+    ($u:expr) => {
+        upload_uuid!($u).and_then(|uuid|
+                                  Some(format!( "{}/upload_{}"
+                                              , CONFIG.upload_dir()
+                                              , uuid)))
+    };
+}
+
+
 pub(crate) fn upload( pool: Arc<Pool>
                     , item: Upload ) -> Result<Image> {
     use crate::schema::images::dsl::*;

 use actix_web::{Error, HttpResponse, web};
 use anyhow::Result;
+use async_std::fs::DirBuilder;
 use futures::stream::StreamExt;
 use async_std::{fs::OpenOptions, io::WriteExt};
-use uuid::Uuid;
+use crate::uuid::Uuid;
 
-use crate::{AppData, models::image::{Upload, self}};
+use crate::{AppData, models::image::{Upload, self}, upload_filename, upload_uuid};
+use crate::config::CONFIG;
+use std::convert::TryFrom;
 
 pub async fn upload( app_data :web::Data<AppData>
                    , mut body :web::Payload
@@ -13,8 +16,7 @@ pub async fn upload( app_data :web::Data<AppData>
     let pool = app_data.database_pool.clone();
     let worker = app_data.tx_upload_worker.clone();
 
-    let random_uuid = Uuid::new_v4();
-    let upload_uuid = Some(random_uuid.as_bytes().to_vec());
+    let upload_uuid = Some(uuid::Uuid::new_v4().as_bytes().to_vec());
     let size = request.headers().get("content-length")
              . and_then(|h| Some(h.to_str().unwrap().parse::<i32>()))
              . unwrap().unwrap();
@@ -22,23 +24,26 @@ pub async fn upload( app_data :web::Data<AppData>
                                 . and_then(|h| Some(h.to_str().unwrap()))
                                 . unwrap() );
 
-    let upload_filename = format!("/tmp/upload_{}", random_uuid);
+    let upload = Upload {
+        upload_uuid,
+        size,
+        mime_type
+    };
+
+    DirBuilder::new() . recursive(true)
+                      . create(CONFIG.upload_dir())
+                      . await?;
+
+    let upload_filename = upload_filename!(upload).unwrap();
     let mut output = OpenOptions::new();
     let mut output = output
                    . create(true)
                    . write(true)
                    . open(&upload_filename).await?;
-
     while let Some(item) = body.next().await {
         output.write_all(&item?).await?;
     }
 
-    let upload = Upload {
-        upload_uuid,
-        size,
-        mime_type
-    };
-
     Ok( match web::block(move || image::upload(pool, upload)).await {
         Ok(image) => {
             // TODO handle this as error response...

 use std::io::SeekFrom;
-use async_std::fs::File;
-use futures::{AsyncSeekExt, AsyncReadExt};
+use async_std::{fs::File, channel::{Sender, Receiver, bounded}};
+use futures::{ AsyncSeekExt, AsyncReadExt, FutureExt, StreamExt, select
+             , stream::FuturesUnordered};
 
+use crate::{models::image::Image, upload_filename, upload_uuid};
+use crate::uuid::Uuid;
+
+use std::convert::TryFrom;
+use crate::config::CONFIG;
+
+pub fn launch() -> Sender<Image> {
+    let (tx_upload_worker, rx_upload_worker)
+        : (Sender<Image>, Receiver<Image>) = bounded(32);
+
+    actix_rt::spawn(async move {
+        let mut workers = FuturesUnordered::new();
+
+        loop {
+            select! {
+                image = rx_upload_worker.recv().fuse() => {
+                    match image {
+                        Err(_) => break,
+                        Ok(image) => workers.push(worker(image)),
+                    }
+                },
+                _result = workers.next() => {},
+            }
+        }
+
+        while workers.len() > 0 {
+            workers.next().await;
+        }
+    });
+
+    tx_upload_worker
+}
+
+
+async fn worker(image :Image) {
+    let upload_filename = upload_filename!(image).unwrap();
+    let mut f = File::open(&upload_filename).await.unwrap();
+    let mut buf = vec!['.' as u8; 3 * 4096];
+    get_sample(&mut f, buf.as_mut()).await.unwrap();
+    println!( "[upload worker] filename: {}"
+            , upload_filename );
+    println!( "[upload worker] uuid: {}"
+            , Uuid::get( "some.unique.namespace"
+                       , buf.as_mut() ) );
+}
 
 async fn read_at( f   :&mut File
-                    , pos :SeekFrom
-                    , buf :&mut [u8]) -> std::io::Result<()> {
+                , pos :SeekFrom
+                , buf :&mut [u8]) -> std::io::Result<()> {
     f.seek(pos).await?;
     f.read_exact(buf).await
 }
 
-pub async fn get_sample( f   :&mut File
+async fn get_sample( f   :&mut File
                        , buf :&mut [u8]) -> std::io::Result<()> {
     let file_len = f.metadata().await?.len();
     let chunk_size = buf.len() / 3;

@@ -23,10 +23,10 @@ impl Uuid {
     }
 }
 
-impl TryFrom<Vec<u8>> for Uuid {
+impl TryFrom<&[u8]> for Uuid {
     type Error = Error;
 
-    fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {
-        Ok(Self(uuid::Uuid::from_slice(value.as_slice())?))
+    fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
+        Ok(Self(uuid::Uuid::from_slice(value)?))
     }
 }