fix: started putting integration tests into on folder

Author: conblem

src/api/metrics.rs

@@ -28,7 +28,7 @@ lazy_static! {
     .unwrap();
 }
 
-pub(super) enum MetricsConfig {
+pub(crate) enum MetricsConfig {
     Borrowed(&'static str),
     Owned(FullPath),
 }
@@ -69,6 +69,7 @@ where
     type Output = O;
 }
 
+//todo: fix this
 fn hihi<I>(
     http_req_histogram: &'static HistogramVec,
     http_status_counter: &'static IntCounterVec,
@@ -116,7 +117,7 @@ where
     }
 }
 
-pub(super) fn metrics_wrapper<F>(
+pub(crate) fn metrics_wrapper<F>(
     filter: F,
 ) -> impl Filter<Extract = (WarpResponse,), Error = Rejection> + Clone + Send + 'static
 where
@@ -168,7 +169,7 @@ fn metrics_handler() -> WarpResponse {
 
 const METRICS_PATH: &str = "metrics";
 
-pub(super) fn metrics(
+pub(crate) fn metrics(
 ) -> impl Filter<Extract = impl Reply, Error = Rejection> + Clone + Send + 'static {
     warp::path(METRICS_PATH)
         .and(warp::get())

src/api/mod.rs

@@ -20,7 +20,7 @@ use crate::facade::{CertFacade, DomainFacade};
 mod metrics;
 mod proxy;
 mod routes;
-mod tls;
+pub mod tls;
 
 lazy_static! {
     static ref TCP_TOTAL_CONNECTION_COUNTER: IntCounterVec = register_int_counter_vec!(
@@ -81,7 +81,7 @@ where
     }
 }
 
-pub async fn new<F>(
+pub(crate) async fn new<F>(
     (http, http_proxy): Listener,
     (https, https_proxy): Listener,
     (prom, prom_proxy): Listener,

src/api/proxy.rs

@@ -32,7 +32,7 @@ impl<T: RemoteAddr> RemoteAddr for ProxyStream<T> {
     }
 }
 
-pub(super) fn wrap(
+pub(crate) fn wrap(
     listener: TcpListener,
     proxy: ProxyProtocol,
 ) -> impl Stream<
@@ -84,7 +84,7 @@ where
     }
 }
 
-pub(super) struct ProxyStream<T> {
+struct ProxyStream<T> {
     stream: T,
     data: Option<Vec<u8>>,
     start_of_data: usize,

src/api/routes.rs

@@ -50,7 +50,7 @@ async fn update_handler<F>(
 const REGISTER_PATH: &str = "register";
 const UPDATE_PATH: &str = "update";
 
-pub(super) fn routes<F>(
+pub(crate) fn routes<F>(
     facade: F,
 ) -> impl Filter<Extract = impl Reply, Error = Rejection> + Clone + Send + 'static
 where

src/api/tls.rs

@@ -13,7 +13,7 @@ use tracing::{error, info};
 use crate::facade::{Cert, CertFacade};
 use crate::util::to_u64;
 
-pub(super) fn wrap<L, I, S, F>(
+pub fn wrap<L, I, S, F>(
     listener: L,
     facade: F,
 ) -> impl Stream<
@@ -102,72 +102,3 @@ impl<F: CertFacade> Acceptor<F> {
         Ok(TlsAcceptor::from(server_config))
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use futures_util::{future, stream, StreamExt};
-    use rustls::{
-        Certificate, ClientConfig, RootCertStore, ServerCertVerified, ServerCertVerifier, TLSError,
-    };
-    use std::sync::Arc;
-    use tokio::io::{AsyncReadExt, AsyncWriteExt};
-    use tokio::net::{TcpListener, TcpStream};
-    use tokio_rustls::webpki::DNSNameRef;
-    use tokio_rustls::TlsConnector;
-
-    use super::wrap;
-    use crate::facade::tests::TestFacade;
-
-    struct TestVerifier;
-
-    impl ServerCertVerifier for TestVerifier {
-        fn verify_server_cert(
-            &self,
-            _roots: &RootCertStore,
-            presented_certs: &[Certificate],
-            dns_name: DNSNameRef<'_>,
-            _ocsp_response: &[u8],
-        ) -> Result<ServerCertVerified, TLSError> {
-            let domain = DNSNameRef::try_from_ascii_str("acme-dns-rust.com")
-                .unwrap()
-                .to_owned();
-            assert_eq!(domain, dns_name.to_owned());
-            assert!(presented_certs.first().is_some());
-            Ok(ServerCertVerified::assertion())
-        }
-    }
-
-    #[tokio::test]
-    async fn test() {
-        let server = TcpListener::bind("127.0.0.1:0").await.unwrap();
-        let addr = server.local_addr().unwrap();
-
-        let server_future = tokio::spawn(async move {
-            let server = server.accept().await.unwrap().0;
-            let server = stream::iter(vec![Ok(future::ready(Ok(server)))]);
-            let mut acceptor = wrap(server, TestFacade::default());
-
-            let mut conn = acceptor.next().await.unwrap().unwrap().await.unwrap();
-            let mut actual = String::new();
-            conn.read_to_string(&mut actual).await.unwrap();
-            assert_eq!("Test", actual);
-        });
-
-        let client_future = tokio::spawn(async move {
-            let client = TcpStream::connect(addr).await.unwrap();
-            let mut client_config = ClientConfig::new();
-            client_config
-                .dangerous()
-                .set_certificate_verifier(Arc::new(TestVerifier {}));
-
-            let connector = TlsConnector::from(Arc::new(client_config));
-
-            let domain = DNSNameRef::try_from_ascii_str("acme-dns-rust.com").unwrap();
-            let mut conn = connector.connect(domain, client).await.unwrap();
-            conn.write_all("Test".as_ref()).await.unwrap();
-            conn.write(&[]).await.unwrap();
-        });
-
-        tokio::try_join!(server_future, client_future).unwrap();
-    }
-}

src/facade/cert.rs

@@ -6,7 +6,7 @@ use tracing::info;
 use uuid::Uuid;
 
 use super::domain::{Domain, DomainFacadeInternal};
-use super::DatabaseFacade;
+use super::{DatabaseFacade, InMemoryFacade};
 use crate::util::{now, to_i64, HOUR};
 
 #[derive(sqlx::Type, Debug, PartialEq, Clone)]
@@ -18,9 +18,9 @@ pub enum State {
 
 #[derive(FromRow, Debug, Clone)]
 pub struct Cert {
-    pub(crate) id: String,
-    pub(crate) update: i64,
-    pub(crate) state: State,
+    pub id: String,
+    pub update: i64,
+    pub state: State,
     pub cert: Option<String>,
     pub private: Option<String>,
     #[sqlx(rename = "domain_id")]
@@ -194,40 +194,31 @@ impl CertFacade for DatabaseFacade<Postgres> {
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use anyhow::Result;
-    use async_trait::async_trait;
-
-    use super::super::tests::TestFacade;
-    use super::{Cert, CertFacade};
-
-    #[async_trait]
-    impl CertFacade for TestFacade {
-        async fn first_cert(&self) -> Result<Option<Cert>, sqlx::Error> {
-            let certs = self.certs.lock();
-            Ok(certs.values().next().map(Clone::clone))
-        }
+#[async_trait]
+impl CertFacade for InMemoryFacade {
+    async fn first_cert(&self) -> Result<Option<Cert>, sqlx::Error> {
+        let certs = self.certs.lock();
+        Ok(certs.values().next().map(Clone::clone))
+    }
 
-        async fn update_cert(&self, cert: &Cert) -> Result<(), sqlx::Error> {
-            let mut certs = self.certs.lock();
-            *certs.get_mut(&cert.id).unwrap() = cert.clone();
+    async fn update_cert(&self, cert: &Cert) -> Result<(), sqlx::Error> {
+        let mut certs = self.certs.lock();
+        *certs.get_mut(&cert.id).unwrap() = cert.clone();
 
-            Ok(())
-        }
+        Ok(())
+    }
 
-        async fn create_cert(&self, cert: &Cert) -> Result<(), sqlx::Error> {
-            self.certs.lock().insert(cert.id.clone(), cert.clone());
+    async fn create_cert(&self, cert: &Cert) -> Result<(), sqlx::Error> {
+        self.certs.lock().insert(cert.id.clone(), cert.clone());
 
-            Ok(())
-        }
+        Ok(())
+    }
 
-        async fn start_cert(&self) -> Result<Option<Cert>> {
-            unimplemented!()
-        }
+    async fn start_cert(&self) -> Result<Option<Cert>> {
+        unimplemented!()
+    }
 
-        async fn stop_cert(&self, _memory_cert: &mut Cert) -> Result<(), sqlx::Error> {
-            unimplemented!()
-        }
+    async fn stop_cert(&self, _memory_cert: &mut Cert) -> Result<(), sqlx::Error> {
+        unimplemented!()
     }
 }

src/facade/mod.rs

@@ -5,9 +5,12 @@ mod domain;
 
 pub use cert::{Cert, CertFacade, State};
 pub use domain::{Domain, DomainDTO, DomainFacade};
+use parking_lot::Mutex;
+use std::collections::HashMap;
+use std::sync::Arc;
 
 #[derive(Debug)]
-pub(super) struct DatabaseFacade<DB: Database> {
+pub struct DatabaseFacade<DB: Database> {
     pool: Pool<DB>,
 }
 
@@ -25,43 +28,8 @@ impl From<PgPool> for DatabaseFacade<Postgres> {
     }
 }
 
-#[cfg(test)]
-pub(super) mod tests {
-    use parking_lot::Mutex;
-    use std::collections::HashMap;
-    use std::fs::read_to_string;
-    use std::path::Path;
-    use std::sync::Arc;
-
-    use super::{Cert, State};
-    use crate::util::{now, to_i64};
-
-    #[derive(Clone)]
-    pub struct TestFacade {
-        pub certs: Arc<Mutex<HashMap<String, Cert>>>,
-        //domains: Mutex<HashMap<String, Domain>>,
-    }
-
-    impl Default for TestFacade {
-        fn default() -> Self {
-            let cert = read_to_string(Path::new(file!()).with_file_name("cert.crt"));
-            let private = read_to_string(Path::new(file!()).with_file_name("key.key"));
-
-            let cert = Cert {
-                id: "1".to_owned(),
-                update: to_i64(&now()),
-                state: State::Ok,
-                cert: Some(cert.unwrap()),
-                private: Some(private.unwrap()),
-                domain: "acme-dns-rust.com".to_owned(),
-            };
-
-            let mut certs = HashMap::new();
-            certs.insert("1".to_owned(), cert);
-
-            TestFacade {
-                certs: Arc::new(Mutex::new(certs)),
-            }
-        }
-    }
+#[derive(Clone, Default)]
+pub struct InMemoryFacade {
+    certs: Arc<Mutex<HashMap<String, Cert>>>,
+    //domains: Mutex<HashMap<String, Domain>>,
 }

src/lib.rs

@@ -0,0 +1,88 @@
+use anyhow::Result;
+use futures_util::TryFutureExt;
+use sqlx::migrate::Migrator;
+use sqlx::postgres::{PgConnectOptions, PgPoolOptions};
+use sqlx::PgPool;
+use std::env;
+use std::str::FromStr;
+use std::sync::Arc;
+use tokio::runtime::Runtime;
+use tokio::signal::ctrl_c;
+use tracing::{debug, info, Instrument};
+
+use acme::DatabasePersist;
+use cert::CertManager;
+use dns::{DatabaseAuthority, DNS};
+use facade::DatabaseFacade;
+
+mod acme;
+pub mod api;
+mod cert;
+mod config;
+mod dns;
+pub mod facade;
+pub mod util;
+
+static MIGRATOR: Migrator = sqlx::migrate!("migrations/postgres");
+
+#[tracing::instrument(err)]
+pub fn run() -> Result<()> {
+    let config_path = env::args().nth(1);
+    let config = config::load_config(config_path)?;
+
+    let runtime = Arc::new(Runtime::new()?);
+    debug!("Created runtime");
+
+    // Async closure cannot be move, if runtime gets moved into it
+    // it gets dropped inside an async call
+    let fut = async {
+        debug!("Running in runtime");
+
+        let pool = setup_database(&config.general.db).await?;
+        let facade = DatabaseFacade::from(pool.clone());
+        let authority =
+            DatabaseAuthority::new(facade.clone(), &config.general.name, config.records);
+        let dns = DNS::new(&config.general.dns, authority);
+
+        let api = &config.api;
+        let api = api::new(
+            api.http.clone(),
+            api.https.clone(),
+            api.prom.clone(),
+            facade.clone(),
+        );
+
+        let persist = DatabasePersist::new(pool, &runtime);
+        let cert_manager = CertManager::new(facade, persist, config.general.acme, &runtime)
+            .and_then(CertManager::spawn);
+
+        info!("Starting API Cert Manager and DNS");
+        tokio::select! {
+            res = api => res,
+            res = cert_manager => res,
+            res = dns.spawn() => res,
+            res = ctrl_c() => {
+                res?;
+                info!("Ctrl C pressed");
+                Ok(())
+            }
+        }
+    };
+
+    runtime.block_on(fut.in_current_span())
+}
+
+#[tracing::instrument(skip(db))]
+async fn setup_database(db: &str) -> Result<PgPool, sqlx::Error> {
+    debug!("Starting DB Setup");
+    let options = PgConnectOptions::from_str(db)?;
+    let pool = PgPoolOptions::new()
+        .max_connections(5)
+        .connect_with(options)
+        .await?;
+    debug!(?pool, "Created DB pool");
+
+    MIGRATOR.run(&pool).await?;
+    info!("Ran migration");
+    Ok(pool)
+}