Add Actix

.gitignore

@@ -16,6 +16,7 @@
 # Ignore aardwolf.toml
 aardwolf.toml
 aardwolf.log
+diesel.toml
 .config
 
 node_modules

.travis.yml

@@ -15,7 +15,18 @@ before_script:
   - diesel migration run
   - popd
 
+script:
+  - |
+    for project in 'aardwolf-models' 'aardwolf-types' 'aardwolf-actix' 'aardwolf-rocket' '.'; do
+      pushd $project
+      cargo build --verbose
+      cargo test --verbose
+      popd
+    done
+
 rust:
   - nightly
 
-cache: cargo
+cache:
+  cargo: true
+  timeout: 1000

Cargo.toml

@@ -7,40 +7,41 @@ description = "Powering connected social communities with free software."
 [workspace]
 members = [
     "aardwolf-models",
-    "aardwolf-rocket"
+    "aardwolf-types",
+    "aardwolf-rocket",
+    "aardwolf-actix"
 ]
 
 [features]
 default = ["simple-logging"]
-# Integrate with Systemd, includes Journald for logging. Conflicts with log-*
-# features.
-systemd = ["aardwolf-rocket/systemd"]
-# Use syslog for writing logs. Conflicts with use-systemd and log-* features.
-syslog = ["aardwolf-rocket/syslog"]
+rocket = ["aardwolf-rocket"]
+actix = ["aardwolf-actix"]
+
+
+[dependencies]
+config = "0.9.0"
+failure = "0.1"
+log = "0.4"
+yaml-rust = "0.3"
 # Use simple log files or stdout/stderr. Conflicts with use-systemd and
 # log-* features.
-simple-logging = ["aardwolf-rocket/simple-logging"]
+simple-logging = { version = "2.0", optional = true }
+# Use syslog for writing logs. Conflicts with use-systemd and log-* features.
+syslog = { version = "4.0", optional = true }
+# Integrate with Systemd, includes Journald for logging. Conflicts with log-*
+# features.
+systemd = { version = "0.4", optional = true }
 
-[dependencies]
-config = "0.8.0"
-failure = "0.1.1"
-r2d2 = "0.8"
-r2d2-diesel = "1.0"
-rocket = "0.3.17"
-rocket_codegen = "0.3.17"
-rocket_contrib = "0.3.17"
-yaml-rust = "0.3.5"
-log = "0.4.1"
+[dependencies.aardwolf-actix]
+version = "0.1"
+path = "aardwolf-actix"
+optional = true
 
 [dependencies.aardwolf-rocket]
 version = "0.1"
 path = "aardwolf-rocket"
+optional = true
 
 [dependencies.clap]
 version = "2.29"
 features = ["yaml"]
-
-[dependencies.diesel]
-version = "1.1"
-default-features = false
-features = ["postgres", "uuid", "chrono"]

aardwolf-actix/Cargo.toml

@@ -0,0 +1,34 @@
+[package]
+name = "aardwolf-actix"
+version = "0.1.0"
+authors = ["asonix <asonix@asonix.dog>"]
+edition = "2018"
+
+[dependencies]
+actix = "0.7"
+actix-web = "0.7"
+collection_macros = "0.2.0"
+config = "0.9.0"
+failure = "0.1"
+futures = "0.1"
+handlebars = "1.1"
+log = "0.4"
+r2d2 = "0.8"
+r2d2-diesel = "1.0"
+serde = "1.0"
+serde_derive = "1.0"
+serde_json = "1.0"
+
+[dependencies.aardwolf-models]
+version = "0.1"
+path = "../aardwolf-models"
+
+[dependencies.aardwolf-types]
+version = "0.1"
+path = "../aardwolf-types"
+features = ["use-actix"]
+
+[dependencies.diesel]
+version = "1.1"
+default-features = false
+features = ["postgres", "uuid", "chrono"]

aardwolf-actix/src/action.rs

@@ -0,0 +1,171 @@
+use std::marker::PhantomData;
+
+use aardwolf_types::{
+    error::AardwolfFail,
+    forms::traits::{DbAction, Validate},
+};
+use futures::future::Future;
+
+use crate::{
+    db::{DbActionError, PerformDbAction},
+    AppConfig,
+};
+
+pub trait Action<T, E>
+where
+    E: AardwolfFail,
+{
+    fn action(self, state: AppConfig) -> Box<dyn Future<Item = T, Error = E> + Send>;
+}
+
+pub struct ValidateWrapper<V, T, E>(V, PhantomData<T>, PhantomData<E>)
+where
+    V: Validate<T, E>,
+    E: AardwolfFail;
+
+impl<V, T, E> ValidateWrapper<V, T, E>
+where
+    V: Validate<T, E>,
+    E: AardwolfFail,
+{
+    pub fn new(validate: V) -> Self {
+        ValidateWrapper(validate, PhantomData, PhantomData)
+    }
+}
+
+impl<V, T, E> From<V> for ValidateWrapper<V, T, E>
+where
+    V: Validate<T, E>,
+    E: AardwolfFail,
+{
+    fn from(v: V) -> Self {
+        ValidateWrapper::new(v)
+    }
+}
+
+impl<V, T, E> Action<T, E> for ValidateWrapper<V, T, E>
+where
+    V: Validate<T, E>,
+    T: Send + 'static,
+    E: AardwolfFail,
+{
+    fn action(self, _: AppConfig) -> Box<dyn Future<Item = T, Error = E> + Send> {
+        use futures::future::IntoFuture;
+
+        Box::new(self.0.validate().into_future())
+    }
+}
+
+pub struct DbActionWrapper<D, T, E>(D, PhantomData<T>, PhantomData<E>)
+where
+    D: DbAction<T, E>,
+    E: AardwolfFail;
+
+impl<D, T, E> DbActionWrapper<D, T, E>
+where
+    D: DbAction<T, E>,
+    E: AardwolfFail,
+{
+    pub fn new(db_action: D) -> Self {
+        DbActionWrapper(db_action, PhantomData, PhantomData)
+    }
+}
+
+impl<D, T, E> From<D> for DbActionWrapper<D, T, E>
+where
+    D: DbAction<T, E>,
+    E: AardwolfFail,
+{
+    fn from(d: D) -> Self {
+        DbActionWrapper::new(d)
+    }
+}
+
+impl<D, T, E> Action<T, DbActionError<E>> for DbActionWrapper<D, T, E>
+where
+    D: DbAction<T, E> + Send + 'static,
+    T: Send + 'static,
+    E: AardwolfFail,
+{
+    fn action(
+        self,
+        state: AppConfig,
+    ) -> Box<dyn Future<Item = T, Error = DbActionError<E>> + Send> {
+        let fut = state
+            .db
+            .send(PerformDbAction::new(self.0))
+            .then(|res| match res {
+                Ok(item_res) => match item_res {
+                    Ok(item) => Ok(item),
+                    Err(e) => Err(e),
+                },
+                Err(e) => Err(DbActionError::from(e)),
+            });
+
+        Box::new(fut)
+    }
+}
+
+#[macro_export]
+macro_rules! perform {
+ ( $state:expr, $start:expr, $error_type:ty, [] ) => {{
+     use futures::future::IntoFuture;
+
+     (Ok($start) as Result<_, $error_type>).into_future()
+ }};
+ (
+     $state:expr,
+     $start:expr,
+     $error_type:ty,
+     [
+         ($wrapper:ty => $first:expr),
+         $(($wrappers:ty => $rest:expr),)*
+     ]
+ ) => {{
+     use $crate::action::Action;
+
+     let wrapper: $wrapper = $first.with($start).into();
+
+     let fut = wrapper.action($state.clone());
+
+     perform_inner!($state, $error_type, fut, [ $(($wrappers => $rest),)* ])
+ }};
+}
+
+macro_rules! perform_inner {
+    (
+        $state:expr,
+        $error_type:ty,
+        $first:expr,
+        []
+    ) => {{
+        use futures::future::IntoFuture;
+
+        $first
+            .into_future()
+            .from_err::<$error_type>()
+    }};
+    (
+        $state:expr,
+        $error_type:ty,
+        $first:expr,
+        [
+            ($wrapper:ty => $item:expr),
+            $(($wrappers:ty => $items:expr),)*
+        ]
+    ) => {{
+        use futures::future::IntoFuture;
+        use $crate::action::Action;
+
+        $first
+            .into_future()
+            .from_err::<$error_type>()
+            .and_then(move |item| {
+                let wrapper: $wrapper = $item.with(item).into();
+
+                let fut = wrapper.action($state.clone());
+
+                perform_inner!($state, $error_type, fut, [ $(($wrappers => $items),)* ])
+            })
+    }};
+}

aardwolf-actix/src/db/mod.rs

@@ -0,0 +1,27 @@
+use crate::actix::prelude::*;
+use diesel::pg::PgConnection;
+use r2d2::PooledConnection;
+use r2d2_diesel::ConnectionManager;
+
+mod perform_db_action;
+
+pub use self::perform_db_action::{DbActionError, PerformDbAction};
+
+pub type ManagedPgConn = ConnectionManager<PgConnection>;
+pub type Pool = r2d2::Pool<ManagedPgConn>;
+
+pub struct Db(Pool);
+
+impl Db {
+    pub fn new(pool: Pool) -> Self {
+        Db(pool)
+    }
+
+    fn get_connection(&self) -> Result<PooledConnection<ManagedPgConn>, r2d2::Error> {
+        self.0.get()
+    }
+}
+
+impl Actor for Db {
+    type Context = SyncContext<Self>;
+}