Merge branch 'finalize-upload-endpoints-with-all-necessary-processing-5' into 'master'

Finalize upload endpoints with all necessary processing 5

Closes #5

See merge request !4

-DATABASE_URL=crud.db
+CONFIG=artshop.toml
+#DATABASE_URL=crud.db
+DATABASE_URL="mysql://artshop:123456@127.0.0.1/artshop"

@@ -4,3 +4,4 @@ Cargo.lock
 **/target
 /pkg
 /static/ui/
+/var

@@ -17,7 +17,7 @@ endef
 
 start:
 	systemfd --no-pid -s 0.0.0.0:3000 -- \
-		cargo watch -i static/ -s "PROFILE=$(PROFILE) make run"
+		cargo watch -i static/ -i var/ -s "PROFILE=$(PROFILE) make run"
 
 wasm:
 	$(call msg,BUILD WASM UI)
@@ -35,6 +35,22 @@ run: build wasm
 release:
 	docker build -t artshop -f build/Dockerfile .
 
+devdb:
+	docker network create mariadb-dev-network
+	docker run --detach --network mariadb-dev-network --name mariadb-dev \
+		-p 3306:3306 \
+		--env MARIADB_USER=artshop \
+		--env MARIADB_PASSWORD=123456 \
+		--env MARIADB_ROOT_PASSWORD=123456 mariadb:latest
+
+enterdb:
+	docker exec -it mariadb-dev mysql -D artshop -u artshop -p
+#	docker run -it --network mariadb-dev-network --rm mariadb:latest \
+#		mysql -h mariadb-dev -u artshop -p
+
+rootdb:
+	docker exec -it mariadb-dev mysql -p
+
 clean:
 	cargo clean
 	rm -Rf ./static/ui

+# This is the base namespace used for uuid generation.
+namespace = "artshop.shome.steffers.org"
+
+[database]
+# url = "./var/lib/artshop/database"
+
+[locations]
+upload = "/tmp/artshop/uploads"
+images = "./var/lib/artshop/images"

@@ -20,3 +20,15 @@ pub struct MarkdownDiffJson {
     pub id: i32,
     pub date_created: String,
 }
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct ImageJson {
+    pub upload_uuid  :Option<Vec<u8>>,
+    pub uuid         :Option<Vec<u8>>,
+    pub size         :i32,
+    pub dim_x        :Option<i32>,
+    pub dim_y        :Option<i32>,
+    pub mime_type    :String,
+    pub date_created :String,
+    pub date_updated :String
+}

@@ -59,3 +59,8 @@ web::block already for write actions.
 Simple explanation on technical terms synchronous, asynchronous, concurrent
 and parallel:
 [synchronous vs. asynchronous vs. concurrent vs. parallel](https://medium.com/plain-and-simple/synchronous-vs-asynchronous-vs-concurrent-vs-parallel-4342bfb8b9f2, 'synchronous vs. asynchronous vs. concurrent vs. parallel')
+
+# Docker mariadb preparation
+
+    GRANT ALL PRIVILEGES ON artshop.* TO 'artshop'@'%';
+    CREATE DATABASE artshop CHARACTER SET = 'utf8mb3' COLLATE = 'utf8mb3_general_ci';

--- This file should undo anything in `up.sql`
\ No newline at end of file
+-- This file should undo anything in `up.sql`
+DROP TABLE users;

 -- Your SQL goes here
-CREATE TABLE "users" (
-	id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+CREATE TABLE users (
+	id INTEGER PRIMARY KEY AUTO_INCREMENT NOT NULL,
 	name TEXT NOT NULL,
 	address TEXT NOT NULL,
 	date_created TEXT NOT NULL
 );
 
-INSERT INTO
-	"users"(name, address, date_created)
+INSERT INTO users
+	(name, address, date_created)
 VALUES
-	("John", "123 Av Q", "Today");
+	('John', '123 Av Q', 'Today');

 -- This file should undo anything in `up.sql`
-DROP INDEX "markdown_diffs_id";
-DROP TABLE "markdown_diffs";
-DROP TABLE "markdowns";
+DROP TABLE markdown_diffs;
+DROP TABLE markdowns;

-CREATE TABLE "markdowns" (
-	id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+CREATE TABLE markdowns (
+	id INTEGER PRIMARY KEY AUTO_INCREMENT NOT NULL,
 	name VARCHAR(256) NOT NULL,
 	content TEXT NOT NULL,
 	number_of_versions INTEGER NOT NULL DEFAULT (1),
@@ -13,7 +13,7 @@ CREATE TABLE "markdowns" (
 -- The date_created here should be set to the value of
 -- markdown.date_updated when the patch was created. This diff_id
 -- is always current last max diff_id for given markdown_id plus 1.
-CREATE TABLE "markdown_diffs" (
+CREATE TABLE markdown_diffs (
 	markdown_id INTEGER NOT NULL,
 	diff_id INTEGER NOT NULL,
 	diff BLOB NOT NULL,
@@ -21,84 +21,120 @@ CREATE TABLE "markdown_diffs" (
 	PRIMARY KEY (markdown_id, diff_id)
 );
 
-INSERT INTO
-	"markdowns"(name, content, date_created, date_updated)
+INSERT INTO markdowns
+	(name, content, date_created, date_updated)
 VALUES
-	( "md-example"
-        , "# Ein sehr schöner Titel
+	( 'md-example'
+        , "# Markdown Cheatsheat
 
-## Ein sinnloser Text
+## Überschriften
+---
 
-Hier kommt ganz viel Text der irgendwie auch was machen soll, aber Zeilen
-sollen auch im <pre> Eingabefeld automatisch umbrechen.
+# # <H1>
+## ## <H2>
+### ### <H3>
+#### #### <H4>
+##### ##### <H5>
+###### ###### <H6>
 
-Ein neuner Paragraph beginnt nach einer Leerzeile.  
-Ein Umbruch entsteht wie gewohnt durch 2 spaces am Ende einer
-Zeile.
+## Absätze und Umbrüche
+---
 
-## Fußnoten
+Ein einfacher Zeilenumbruch
+verändert den Textfluss nicht. Spaces             haben           auch keinen Einfluss auf den Textfluss. Es ist selten eine gute Idee große Abstände innerhalb eines Textes zu habe, sollte man diese aber wirklich brauchen kann man auf        inline html        zurückgreifen.
 
-Vllt. kann man sogar so was wie Fussnoten[^1] in den Markdown Text
-einbinden... diese kann man dann irgendwo einbauen...
+Leerzeilen erzeugen neue Paragraphen. Um im formatierten Text einen Zeilenumbruch zu erzeugen verwendet man zwei Spaces vor einem Zeilenumbruch im Eingabetext.  
+Dies führt nicht zu einem Paragraphen.
 
+## Hervorhebungen
 ---
 
-[^1]: Zum Beispiel so...
-
-[^2]: Oder so...
-
-## inline html ist im Moment auch ok.
+- *kursive (schwache) Hervorhebung*
+- **fette (starke) Hervorhebung**
+- ***kursiv und fette (sehr starke) Hervorhebung***
+- *schwache mit **eingebetteter starker** Hervorhebung*
+- **starke mit *eingebetteter schwacher* Hervorhebung**
+- ~~durchgestrichen~~
+- <u>unterstreichen nur mit HTML</u>
+- ~~*durchgestrichen kursiv*~~
+- **~~fett durchgestrichen~~**
+- *<u>kursiv unterstrichen</u>*
+- <u>**unterstrichen fett**</u>
+
+## Gedanken- und Binde--strich
+---
 
-<pre>Lustigerweise geht auch inline html</pre>
+Ein Einfaches Minus bildet im Text den Gedankenstrich *hyphen* (-). Zwei oder mehr Minus werden zu verschieden langen Bindestrichen *dash* (--, ---). In regulärem
+Text kommen zwei Minuszeichen hintereinander in der Regel nicht vor. In
+Programmcode, der in ASCII geschrieben ist allerdings schon. Will man also zwei
+Minuszeichen separat darstellen kann man diese in inline code packen (`--, ---`).
 
-## Listen for fun
+## Listen
+---
 
-- ein Liste
-    - mehr Liste
-    - diesmal als Subliste.
-- und was auch immer...
-    1. und nun Verschachtelt.
-        1. Numeriert.
-        2. huhuhu
-        3. wie bitte.
-    2. juhu
-- noch mehr Liste
+- erster Listeneintrag
+    - erster Unterlisteneintrag
+    - zweiter Unterlisteneintrag
+- zweiter Listeneintrag
+    1. erster nummerierter Listeneintrag
+        1. erster nummerierter Unterlisteneintrag
+        2. zweiter nummerierter Unterlisteneintrag
+        3. dritter nummerierter Unterlisteneintrag
+    2. zweiter nummerierter Listeneintrag
+- dritter Listeneintrag
+    - [x] erster Auswahllisteneintrag
+    - [ ] zweiter Auswahllisteneintrag
+    - [x] dritter Auswahllisteneintrag
+- vierter Listeneintrag
+    1. [ ] erster nummerierter Auswahllisteneintrag
+    2. [x] zweiter nummerierter Auswahllisteneintrag
+
+## Code Blöcke
+---
 
-## Preformated Text
+    Dies ist ein codeblock durch Einrückung.
+      In diesem werden    keine Formatierungen
+        vorgenommen.
 
-```Hier kommt der code```
+Mit backticks lassen sich Codeblöcke mit Sprachinformation
+erstellen. Theoretisch könnte für solche Böcke dann Syntax-Highliting eingebaut werden.
 
-Und hier der Paragraph mit `inline code` der auch sehr schön aussehen kann.
+```shell
+#!/bin/env sh
 
-## Hervorhebungen
+FOO="foo"
 
-Man kann Text auch sehr schön formatieren. So ist es z.B. möglich
-*Worte kursiv zu stellen* oder man kann **sie auch fett schreiben**.
-Als spezielles feature kann der von mir verwendete Parser auch
-~~Texte durchstreichen~~.
+function func() {
+  local BAR=bar
+}
+```
 
-Nur wenn man Text <u>unterstreichen</u> will muss man auf inline html
-zurückgreifen.
+Auch in den Fließtext lassen sich `inline code` Elemente einfügen um z.B. einzelne Kommandos hervorzuheben.
 
-## Blockquotes und horizontale Linie
+## Zitate und horizontale Linie
+---
 
-> Dies sollte jetzt als quote erkennbar sein.
+> Dies ist ein Zitat.
 >
->> Auch diese sind schachtelbar
+>> Zitate können verschachtelt sein.
 >
-> Und weiter gehts.
+> Wir können also zitieren was jemand zitiert hat.
+> Solange die Zeilen ohne Unterbrechung mit einem >
+> beginnen bleibt es ein Zitat
 
----
 
-> Aber dies ist ein neuer quote.
+> Sobald eine Zeile ohne führendes > auftaucht endet ein
+> Zitat.
 
 ## Links
+---
 
-Ein link kann inline geschrieben werden, so wie diese zu
+Ein Link kann inline geschrieben werden, so wie diese zu
 [Heise.de](https://heise.de/ 'Heise.de') oder als Referenz am Ende des Textes
 wie diese nach [Telepolis][lnk1].
 
-## Bilder koennte man auch einbinden.
+## Bilder
+---
 
 Wie Links lassen sich auch Bilder wie mein
 ![Gravatar](https://www.gravatar.com/avatar/fd016c954ec4ed3a4315eeed6c8b97b8)
@@ -106,36 +142,57 @@ in den Text ein.
 
 Im Fließtext sieht das allerdings ein bisschen dumm aus es sei denn man hat
 entsprechend angepasste styles. Besser scheint mir daher Bilder nur zwischen
-Paragraphen zu plazieren.
+Paragraphen zu platzieren.
 
 ![Gravatar](https://www.gravatar.com/avatar/fd016c954ec4ed3a4315eeed6c8b97b8)
 
 Etwas so wie hier.
 
-## Tabellen sollten auch gehen...
+## Tabellen
+---
 
 Die folgenden Beispiele kommen von [markdown.land][lnk2]:
 
-| Item         | Price     | # In stock |
-|--------------|-----------|------------|
-| Juicy Apples | 1.99      | *8*        |
-| Bananas      | **1.89**  | 5234       |
+| Artikel       | Preis     | Bestand    |
+|---------------|-----------|------------|
+| Saftige Äpfel | 1.99      | *8*        |
+| Bananen       | **1.89**  | 5234       |
 
 Man braucht sie nicht schön zu formatieren.
 
-Item | Price | # In stock
+Artikel | Preis | Bestand
 ---|---|---
-Juicy Apples | 1.99 | 739
-Bananas | 1.89 | 6
+Saftige Äpfel | 1.99 | 739
+Bananen | 1.89 | 6
 
 und die Spaltenausrichtung kann man auch einstellen:
 
-| Item         | Price | # In stock |
-|--------------|:-----:|-----------:|
-| Juicy Apples |  1.99 |        739 |
-| Bananas      |  1.8900 |          6 |
+| Artikel       | Preis   | Bestand    |
+|---------------|:-------:|-----------:|
+| Saftige Äpfel |  1.99   |        739 |
+| Bananen       |  1.8900 |          6 |
+
+## Fußnoten
+---
+
+Man kann auch verlinkte Fußnoten[^1] in den Text
+einbinden. Die Fußnote selber kann dann an beliebige stelle im Text stehen.
+
+---
+[^1]: Zum Beispiel so.
+
+[^2]: Diese Fußnote hat keine Verlinkung im Text.
+
+## HTML einbetten
+
+<ul>
+<li>
+<pre>Man kann auch direkt HTML tags einbetten,
+wie hier.</pre>
+</li>
+</ul>
 
 [lnk1]: https://heise.de/tp/ 'Telepolis'
-[lnk2]: https://markdown.land/markdown-table 'markdown.land'"
-	, "Today"
-	, "Today" );
+[lnk2]: https://arkdown.land/markdown-table 'markdown.land' "
+	, '2022-01-29 21:33:34.000'
+	, '2022-01-29 21:33:34.000' );

+-- This file should undo anything in `up.sql`
+DROP TABLE images;

+CREATE TABLE images (
+	id INTEGER PRIMARY KEY AUTO_INCREMENT NOT NULL,
+	-- identical uuid means identical file.
+	upload_uuid BLOB(16) UNIQUE,
+	uuid BLOB(16) UNIQUE,
+	size INTEGER NOT NULL,
+	dim_x INTEGER,
+	dim_y INTEGER,
+	mime_type VARCHAR(256) NOT NULL,
+	date_created TEXT NOT NULL,
+	date_updated TEXT NOT NULL
+);

@@ -15,14 +15,18 @@ anyhow = "1.0"
 artshop-common = { path = "../common" }
 async-std = "^1.10"
 chrono = "0.4.15"
-diesel = { version = "1.4.7", features = ["sqlite", "r2d2"]}
+diesel = { version = "1.4.7", features = ["mysql", "sqlite", "r2d2"]}
 diffy = "0.2"
 dotenv = "0.15.0"
 flate2 = "^1.0"
 futures = "^0.3"
+futures-util = { version = "0", features = ["std"] }
+image = "^0.23"
 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"
-uuid = { version = "^0.8", features = ["v4"] }
+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 { namespace :String
+                         , 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 namespace(&self) -> &str {
+        self.namespace.as_str()
+    }
+
+    pub fn upload_dir(&self) -> &str {
+        self.locations.upload.as_str()
+    }
+
+    pub fn images_dir(&self) -> &str {
+        self.locations.images.as_str()
+    }
+}

@@ -7,7 +7,7 @@ use r2d2;
 type ParentError = Option<Pin<Box<dyn std::error::Error>>>;
 
 #[derive(Debug)]
-pub(crate) struct Error {
+pub struct Error {
     source: ParentError,
     message: String,
 }
@@ -77,3 +77,11 @@ impl From<ParsePatchError> for Error {
         }
     }
 }
+
+impl From<uuid::Error> for Error {
+    fn from(source: uuid::Error) -> Self {
+        Self { source: Some(Box::pin(source))
+             , message: String::from("UUID error")
+        }
+    }
+}

 #[macro_use]
 extern crate diesel;
 
+mod config;
 mod error;
 mod models;
 mod routes;
 mod schema;
+mod uuid;
+mod upload_worker;
 
-use crate::routes::markdown::*;
-use crate::routes::other::*;
-use crate::routes::user::*;
+use models::image::Image;
+use routes::markdown::*;
+use routes::other::*;
+use routes::user::*;
+use routes::upload::*;
 
 use actix_web::{guard, web, App, HttpResponse, HttpServer};
+use async_std::channel::Sender;
 use diesel::r2d2::{self, ConnectionManager};
-use diesel::SqliteConnection;
+use diesel::MysqlConnection;
 use listenfd::ListenFd;
-use routes::markdown::get_markdown;
-use routes::upload::upload;
+use std::sync::Arc;
+use std::ops::Deref;
 
-pub(crate) type Pool = r2d2::Pool<ConnectionManager<SqliteConnection>>;
+pub(crate) type Pool = r2d2::Pool<ConnectionManager<MysqlConnection>>;
+
+#[derive(Clone)]
+pub struct AppData {
+    pub database_pool: Arc<Pool>,
+    pub tx_upload_worker: Sender<(Arc<Pool>, Image)>,
+}
 
 #[actix_rt::main]
 async fn main() -> std::io::Result<()> {
@@ -25,13 +37,20 @@ async fn main() -> std::io::Result<()> {
 
     dotenv::dotenv().ok();
 
+    println!("CONFIG: {:?}", config::CONFIG.deref());
+
+    let tx_upload_worker = upload_worker::launch();
+
     let database_url = std::env::var("DATABASE_URL").expect("NOT FOUND");
     let database_pool = Pool::builder()
         .build(ConnectionManager::new(database_url))
         .unwrap();
 
+    let database_pool = Arc::new(database_pool);
+    let app_data = AppData { database_pool, tx_upload_worker };
+
     let server = HttpServer::new(move || {
-        App::new() . data(database_pool.clone())
+        App::new() . data(app_data.clone())
                    . service(actix_files::Files::new("/static", "./static"))
                    . service( web::scope("/api/v0")
                             . service( web::resource("/upload")

+use std::sync::Arc;
+
+use crate::error::*;
+use crate::{schema::*, Pool};
+use diesel::{Connection, insert_into, delete, update};
+use diesel::prelude::*;
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, Serialize, Deserialize, Queryable, Identifiable)]
+pub struct Image {
+    pub id           :i32,
+    pub upload_uuid  :Option<Vec<u8>>,
+    pub uuid         :Option<Vec<u8>>,
+    pub size         :i32,
+    pub dim_x        :Option<i32>,
+    pub dim_y        :Option<i32>,
+    pub mime_type    :String,
+    pub date_created :String,
+    pub date_updated :String
+}
+
+#[derive(Debug, Insertable)]
+#[table_name = "images"]
+pub struct ImageNew<'a> {
+    pub upload_uuid  :Option<&'a [u8]>,
+    pub size         :i32,
+    pub mime_type    :&'a str,
+    pub date_created :&'a str,
+    pub date_updated :&'a str
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, AsChangeset)]
+#[table_name = "images"]
+pub struct Upload {
+    pub upload_uuid :Option<Vec<u8>>,
+    pub size        :i32,
+    pub mime_type   :String,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, AsChangeset)]
+#[table_name = "images"]
+#[changeset_options(treat_none_as_null = "true")]
+pub struct ImagePatch {
+    pub upload_uuid  :Option<Vec<u8>>,
+    pub uuid         :Option<Vec<u8>>,
+    pub size         :i32,
+    pub dim_x        :Option<i32>,
+    pub dim_y        :Option<i32>,
+    pub mime_type    :String,
+    pub date_updated :String
+}
+
+impl From<Image> for ImagePatch {
+    fn from(image: Image) -> Self {
+        let now = chrono::Local::now().naive_local();
+
+        Self { upload_uuid  :image.upload_uuid
+             , uuid         :image.uuid
+             , size         :image.size
+             , dim_x        :image.dim_x
+             , dim_y        :image.dim_y
+             , mime_type    :image.mime_type
+             , date_updated :format!("{}", now)
+        }
+    }
+}
+
+#[macro_export]
+macro_rules! upload_uuid {
+    ($u:expr) => {
+        match &$u.upload_uuid {
+            Some(uuid) => $crate::uuid::Uuid::try_from(uuid.as_slice()).ok(),
+            None       => None,
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! upload_filename {
+    ($u:expr) => {
+        $crate::upload_uuid!($u)
+            . and_then(|uuid| Some(format!( "{}/upload_{}"
+                                          , $crate::config::CONFIG.upload_dir()
+                                          , uuid )))
+    };
+}
+
+
+pub(crate) fn upload( pool: Arc<Pool>
+                    , item: Upload ) -> Result<Image> {
+    use crate::schema::images::dsl::*;
+    let db_connection = pool.get()?;
+
+    let now = chrono::Local::now().naive_local();
+    let new_image = ImageNew {
+        upload_uuid  : item.upload_uuid.as_deref(),
+        size         : item.size,
+        mime_type    : &item.mime_type,
+        date_created : &format!("{}", now),
+        date_updated : &format!("{}", now)
+    };
+
+    Ok(db_connection.transaction(|| {
+        insert_into(images) . values(&new_image)
+                            . execute(&db_connection)?;
+        images . order(id.desc())
+               . first::<Image>(&db_connection)
+    })?)
+}
+
+pub(crate) fn finalize( pool: Arc<Pool>
+                      , item: Image ) -> Result<Image> {
+    use crate::schema::images::dsl::*;
+
+    let db_connection = pool.get()?;
+    let item_uuid = item.uuid.clone();
+
+    match images . filter(uuid.eq(item_uuid))
+                 . first::<Image>(&db_connection) {
+        Ok(image) => {
+            delete(images.find(item.id)).execute(&db_connection)?;
+            Ok(image)
+        },
+        Err(_) => {
+            let image = images.find(item.id);
+            let patch = ImagePatch::from(item.clone());
+            update(image).set(&patch).execute(&db_connection)?;
+            Ok(item)
+        },
+    }
+}

-pub(crate) mod user;
+pub(crate) mod image;
 pub(crate) mod markdown;
+pub(crate) mod user;

-use crate::models::markdown;
-use crate::Pool;
+use crate::{models::markdown, AppData};
 
 use actix_web::{Error, HttpResponse, web};
 use anyhow::Result;
@@ -11,36 +10,40 @@ pub struct Patchset {
     patch: Option<i32>,
 }
 
-pub async fn get_markdowns(pool: web::Data<Pool>)
+pub async fn get_markdowns(app_data: web::Data<AppData>)
     -> Result<HttpResponse, Error>
 {
-    Ok( web::block(move || markdown::get_markdowns(pool.into_inner()))
+    let pool = app_data.database_pool.clone();
+
+    Ok( web::block(move || markdown::get_markdowns(pool))
       . await
       . map(|markdowns| HttpResponse::Ok().json(markdowns))
       . map_err(|_| HttpResponse::InternalServerError())?
       )
 }
 
-pub async fn get_markdown( pool: web::Data<Pool>
+pub async fn get_markdown( app_data: web::Data<AppData>
                          , name: web::Path<String>
                          , patch: web::Query<Patchset>
                          ) -> Result<HttpResponse, Error>
 {
-    let pool = pool.into_inner();
+    let pool = app_data.database_pool.clone();
     let name = name.into_inner();
     let patch = patch.into_inner();
 
-    Ok( web::block(move || markdown::get_markdown(pool, name.as_str(), patch.patch))
+    Ok( web::block(move || markdown::get_markdown( pool
+                                                 , name.as_str()
+                                                 , patch.patch) )
       . await
       . map(|markdowns| HttpResponse::Ok().json(markdowns))
       . map_err(|_| HttpResponse::InternalServerError())?
       )
 }
 
-pub async fn get_patches( pool: web::Data<Pool>
+pub async fn get_patches( app_data: web::Data<AppData>
                         , name: web::Path<String>
                         ) -> Result<HttpResponse, Error> {
-    let pool = pool.into_inner();
+    let pool = app_data.database_pool.clone();
     let name = name.into_inner();
 
     Ok( web::block(move || markdown::get_patches(pool, name.as_str()))
@@ -50,12 +53,12 @@ pub async fn get_patches( pool: web::Data<Pool>
       )
 }
 
-pub async fn update_markdown( pool: web::Data<Pool>
+pub async fn update_markdown( app_data: web::Data<AppData>
                             , name: web::Path<String>
                             , item: web::Json<MarkdownJson> )
     -> Result<HttpResponse, Error>
 {
-    let pool = pool.into_inner();
+    let pool = app_data.database_pool.clone();
     let name = name.into_inner();
     let item = item.into_inner();
 

 use actix_web::{Error, HttpResponse, web};
 use anyhow::Result;
-use futures::stream::StreamExt;
-use async_std::{fs::OpenOptions, io::WriteExt};
-use uuid::Uuid;
+use async_std::fs::DirBuilder;
+use futures::{stream::StreamExt, AsyncWriteExt};
+use async_std::fs::OpenOptions;
 
-pub async fn upload(mut body: web::Payload) -> Result<HttpResponse, Error>
+use crate::{AppData, models::image::{Upload, self}, upload_filename};
+use crate::config::CONFIG;
+use std::convert::TryFrom;
+
+pub async fn upload( app_data :web::Data<AppData>
+                   , mut body :web::Payload
+                   , request  :web::HttpRequest ) -> Result<HttpResponse, Error>
 {
+    let pool = app_data.database_pool.clone();
+    let worker = app_data.tx_upload_worker.clone();
+
+    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();
+    let mime_type = String::from( request.headers().get("content-type")
+                                . and_then(|h| Some(h.to_str().unwrap()))
+                                . unwrap() );
+
+    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();
-    output . create(true)
-           . write(true);
     let mut output = output
-                   . open(format!("/tmp/upload_{}", Uuid::new_v4()))
-                   . await
-                   . unwrap();
-
+                   . create(true)
+                   . write(true)
+                   . open(&upload_filename).await?;
     while let Some(item) = body.next().await {
-        output.write_all(&item?).await.unwrap();
+        output.write_all(&item?).await?;
     }
+    output.flush().await.unwrap();
 
-    Ok(HttpResponse::Ok().finish())
+    let pool_for_worker = pool.clone();
+    Ok( match web::block(move || image::upload(pool, upload)).await {
+        Ok(image) => {
+            // TODO handle this as error response...
+            worker.send((pool_for_worker, image.clone())).await.unwrap();
+            HttpResponse::Ok().json(image)
+        },
+        Err(_) => HttpResponse::InternalServerError().finish()
+    } )
 }

 use crate::models::user::{self, Action};
-use crate::Pool;
+use crate::AppData;
 
 use actix_web::{Error, HttpResponse, web};
 use anyhow::Result;
 
-pub async fn create_user( pool: web::Data<Pool>
+pub async fn create_user( app_data: web::Data<AppData>
                         , item: web::Json<user::UserJson> )
     -> Result<HttpResponse, Error>
 {
-    let pool = pool.into_inner();
+    let pool = app_data.database_pool.clone();
     let item = item.into_inner();
 
     Ok(web::block(move || user::create_user(pool, item))
@@ -21,19 +21,21 @@ pub async fn create_user( pool: web::Data<Pool>
        . map_err(|_| HttpResponse::InternalServerError())?)
 }
 
-pub async fn get_users(pool: web::Data<Pool>)
+pub async fn get_users(app_data: web::Data<AppData>)
     -> Result<HttpResponse, Error>
 {
-    Ok(web::block(move || user::get_users(pool.into_inner()))
+    let pool = app_data.database_pool.clone();
+
+    Ok(web::block(move || user::get_users(pool))
        . await
        . map(|users| HttpResponse::Ok().json(users))
        . map_err(|_| HttpResponse::InternalServerError())?)
 }
 
-pub async fn get_user(pool: web::Data<Pool>, id: web::Path<i32>)
+pub async fn get_user(app_data: web::Data<AppData>, id: web::Path<i32>)
     -> Result<HttpResponse, Error>
 {
-    let pool = pool.into_inner();
+    let pool = app_data.database_pool.clone();
     let id   = id.into_inner();
 
     Ok(web::block(move || user::get_user(pool, id))
@@ -42,10 +44,10 @@ pub async fn get_user(pool: web::Data<Pool>, id: web::Path<i32>)
        . map_err(|_| HttpResponse::InternalServerError())?)
 }
 
-pub async fn delete_user(pool: web::Data<Pool>, id: web::Path<i32>)
+pub async fn delete_user(app_data: web::Data<AppData>, id: web::Path<i32>)
     -> Result<HttpResponse, Error>
 {
-    let pool = pool.into_inner();
+    let pool = app_data.database_pool.clone();
     let id   = id.into_inner();
 
     Ok(web::block(move || user::delete_user(pool, id))
@@ -54,12 +56,12 @@ pub async fn delete_user(pool: web::Data<Pool>, id: web::Path<i32>)
        . map_err(|_| HttpResponse::InternalServerError())?)
 }
 
-pub async fn update_user( pool: web::Data<Pool>
+pub async fn update_user( app_data: web::Data<AppData>
                         , id:   web::Path<i32>
                         , item: web::Json<user::UserJson> )
     -> Result<HttpResponse, Error>
 {
-    let pool = pool.into_inner();
+    let pool = app_data.database_pool.clone();
     let id   = id.into_inner();
     let item = item.into_inner();
 

 table! {
-    markdown_diffs (markdown_id, diff_id) {
-        markdown_id -> Integer,
-        diff_id -> Integer,
-        diff -> Binary,
+    images (id) {
+        id -> Integer,
+        upload_uuid -> Nullable<Tinyblob>,
+        uuid -> Nullable<Tinyblob>,
+        size -> Integer,
+        dim_x -> Nullable<Integer>,
+        dim_y -> Nullable<Integer>,
+        mime_type -> Varchar,
         date_created -> Text,
+        date_updated -> Text,
     }
 }
 
 table! {
     markdowns (id) {
         id -> Integer,
-        name -> Text,
+        name -> Varchar,
         content -> Text,
         number_of_versions -> Integer,
         date_created -> Text,
@@ -19,6 +24,15 @@ table! {
 }
 
 table! {
+    markdown_diffs (markdown_id, diff_id) {
+        markdown_id -> Integer,
+        diff_id -> Integer,
+        diff -> Blob,
+        date_created -> Text,
+    }
+}
+
+table! {
     users (id) {
         id -> Integer,
         name -> Text,
@@ -28,7 +42,8 @@ table! {
 }
 
 allow_tables_to_appear_in_same_query!(
-    markdown_diffs,
+    images,
     markdowns,
+    markdown_diffs,
     users,
 );

+use std::{io::{SeekFrom, ErrorKind}, sync::Arc};
+use actix_web::web;
+use async_std::{ fs::{File, DirBuilder, copy, metadata, remove_file}
+               , channel::{Sender, Receiver, bounded}
+               , path::PathBuf
+               , io::Result };
+use futures::{ AsyncSeekExt, AsyncReadExt, FutureExt, StreamExt, select
+             , stream::FuturesUnordered};
+
+use crate::{models::image::{Image, finalize}, upload_filename, config::CONFIG, Pool};
+use crate::uuid::Uuid;
+
+use std::convert::TryFrom;
+use image::{io::Reader as ImageReader, GenericImageView};
+
+pub fn launch() -> Sender<(Arc<Pool>, Image)> {
+    let (tx_upload_worker, rx_upload_worker)
+        : (Sender<(Arc<Pool>, Image)>, Receiver<(Arc<Pool>, 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((pool, image)) => workers.push(worker(pool, image)),
+                    }
+                },
+                _result = workers.next() => {},
+            }
+        }
+
+        while workers.len() > 0 {
+            workers.next().await;
+        }
+    });
+
+    tx_upload_worker
+}
+
+
+async fn worker(pool :Arc<Pool>, mut 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 * 3 * 4096];
+    get_sample(&mut f, buf.as_mut()).await.unwrap();
+    let uuid = Uuid::get(CONFIG.namespace(), buf.as_mut());
+    let uuid_string = format!("{}", uuid);
+
+    let mut image_path = PathBuf::from(CONFIG.images_dir());
+    image_path.push(&uuid_string.as_str()[..2]);
+    image_path.push(&uuid_string.as_str()[..5]);
+
+    DirBuilder::new() . recursive(true)
+                      . create(&image_path)
+                      . await
+                      . unwrap();
+
+    image_path.push(&uuid_string);
+
+    image.upload_uuid = None;
+    image.uuid = Some(uuid.0.as_bytes().to_vec());
+
+    match metadata(&image_path).await {
+        Err(e) if e.kind() == ErrorKind::NotFound => {
+            copy(&upload_filename, &image_path).await.unwrap();
+
+            let img = ImageReader::open(&image_path).unwrap()
+                    . with_guessed_format().unwrap()
+                    . decode().unwrap();
+            let (dim_x, dim_y) = img.dimensions();
+
+            image.dim_x = Some(dim_x as i32);
+            image.dim_y = Some(dim_y as i32);
+        },
+        Err(e) => {
+            let e :Result<()> = Err(e);
+            e.unwrap();
+        },
+        Ok(_) => {},
+    }
+
+    remove_file(&upload_filename).await.unwrap();
+    web::block(move || finalize(pool, image)).await.unwrap();
+}
+
+async fn read_at( f   :&mut File
+                , pos :SeekFrom
+                , buf :&mut [u8]) -> std::io::Result<()> {
+    f.seek(pos).await?;
+    f.read_exact(buf).await
+}
+
+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;
+
+    read_at(f, SeekFrom::Start(0), &mut buf[0..chunk_size]).await?;
+    if file_len >= 2 * chunk_size as u64 {
+        read_at( f
+               , SeekFrom::End(-(chunk_size as i64))
+               , &mut buf[2*chunk_size..]).await?;
+    }
+    if file_len >= 3 * chunk_size as u64 {
+        read_at( f
+               , SeekFrom::Start((file_len-chunk_size as u64) / 2)
+               , &mut buf[chunk_size..2*chunk_size]).await?;
+    }
+
+    Ok(())
+}

+use std::{fmt::Display, convert::TryFrom};
+
+use crate::error::Error;
+
+#[derive(Clone,Copy,Debug)]
+pub struct Uuid(pub uuid::Uuid);
+
+impl Display for Uuid {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+macro_rules! ns {
+    ($n:expr) => {
+        uuid::Uuid::new_v5(&uuid::Uuid::NAMESPACE_DNS, $n.as_bytes())
+    }
+}
+
+impl Uuid {
+    pub fn get(ns: &str, buf: &mut [u8]) -> Self {
+        Self(uuid::Uuid::new_v5(&ns!(ns), buf))
+    }
+}
+
+impl TryFrom<&[u8]> for Uuid {
+    type Error = Error;
+
+    fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
+        Ok(Self(uuid::Uuid::from_slice(value)?))
+    }
+}