fix: refactorings

Author: conblem

Cargo.lock

@@ -26,6 +26,7 @@ futures-util = "0.3"
 rustls = "0.18"
 tokio-rustls = "0.14"
 toml = "0.5"
+anyhow = "1.0"
 
 [features]
 default = ["postgres"]

Cargo.toml

@@ -4,7 +4,7 @@ use sqlx::{Pool, Postgres};
 use tokio::runtime::Handle;
 use tokio::stream::StreamExt;
 
-use crate::util::to_i64;
+use crate::util::{error, to_i64};
 
 #[derive(Clone)]
 pub struct DatabasePersist {
@@ -41,11 +41,7 @@ impl Persist for DatabasePersist {
                 .bind(value)
                 .execute(&self.pool);
 
-        self.handle
-            .block_on(query)
-            .map_err(|err| acme_lib::Error::from(err.to_string()))?;
-
-        Ok(())
+        self.handle.block_on(query).map(|_| ()).map_err(error)
     }
 
     fn get<'a>(&self, key: &PersistKey<'a>) -> acme_lib::Result<Option<Vec<u8>>> {
@@ -59,10 +55,9 @@ impl Persist for DatabasePersist {
                 .fetch(&self.pool);
 
         match self.handle.block_on(rows.try_next()) {
-            Ok(Some(row)) => row.try_get("value"),
-            Ok(None) => return Ok(None),
-            Err(e) => return Err(acme_lib::Error::from(e.to_string())),
+            Ok(Some(row)) => row.try_get("value").map_err(error),
+            Ok(None) => Ok(None),
+            Err(e) => Err(error(e)),
         }
-        .map_err(|err| acme_lib::Error::from(err.to_string()))
     }
 }

src/acme.rs

@@ -1,3 +1,4 @@
+use anyhow::{anyhow, Error, Result};
 use futures_util::future::OptionFuture;
 use futures_util::stream::TryStream;
 use futures_util::FutureExt;
@@ -7,7 +8,6 @@ use rustls::internal::pemfile::{certs, pkcs8_private_keys};
 use rustls::{NoClientAuth, ServerConfig};
 use sqlx::PgPool;
 use std::io::Cursor;
-use std::io::ErrorKind;
 use std::ops::Deref;
 use std::sync::Arc;
 use tokio::io::{AsyncRead, AsyncWrite};
@@ -17,7 +17,6 @@ use warp::{http::Response, reply, serve, Filter, Rejection, Reply};
 
 use crate::cert::{Cert, CertFacade};
 use crate::domain::{Domain, DomainFacade};
-use crate::util::Error;
 
 struct Acceptor {
     pool: PgPool,
@@ -34,35 +33,30 @@ impl Acceptor {
         }
     }
 
-    fn create_server_config(
-        db_cert: &mut Cert,
-    ) -> Result<Arc<ServerConfig>, Error<std::io::Error>> {
+    fn create_server_config(db_cert: &mut Cert) -> Result<Arc<ServerConfig>> {
         let (private, cert) = match (&mut db_cert.private, &mut db_cert.cert) {
             (Some(ref mut private), Some(ref mut cert)) => (private, cert),
-            _ => return Err(Error::from("Cert has no Cert or Private")),
+            _ => return Err(anyhow!("Cert has no Cert or Private")),
         };
 
         let mut private = Cursor::new(private);
         let mut privates = pkcs8_private_keys(&mut private)
-            .map_err(|_| Error::msg(ErrorKind::InvalidInput, "Private is invalid"))?;
+            .map_err(|_| anyhow!("Private is invalid {:?}", private))?;
         let private = privates
             .pop()
-            .ok_or_else(|| Error::from("Private Vec is empty"))?;
+            .ok_or_else(|| anyhow!("Private Vec is empty {:?}", privates))?;
 
         let mut cert = Cursor::new(cert);
-        let cert =
-            certs(&mut cert).map_err(|_| Error::msg(ErrorKind::InvalidInput, "Cert is invalid"))?;
+        let cert = certs(&mut cert).map_err(|_| anyhow!("Cert is invalid {:?}", cert))?;
 
         let mut config = ServerConfig::new(NoClientAuth::new());
-        config
-            .set_single_cert(cert, private)
-            .map_err(|_| Error::from("Couldn't configure Config with Cert and Private"))?;
+        config.set_single_cert(cert, private)?;
         config.set_protocols(&["h2".into(), "http/1.1".into()]);
 
         Ok(Arc::new(config))
     }
 
-    async fn load_cert(&self) -> Result<TlsAcceptor, Box<dyn std::error::Error + Send + Sync>> {
+    async fn load_cert(&self) -> Result<TlsAcceptor> {
         let new_cert = CertFacade::first_cert(&self.pool).await?;
 
         // could probably be improved
@@ -83,10 +77,8 @@ impl Acceptor {
 fn stream(
     listener: TcpListener,
     pool: PgPool,
-) -> impl TryStream<
-    Ok = impl AsyncRead + AsyncWrite + Send + Unpin + 'static,
-    Error = Box<dyn std::error::Error + Send + Sync>,
-> + Send {
+) -> impl TryStream<Ok = impl AsyncRead + AsyncWrite + Send + Unpin + 'static, Error = Error> + Send
+{
     let acceptor = Acceptor::new(pool);
     let acceptor_stream =
         futures_util::stream::unfold(acceptor, |acc| async { Some((acc.load_cert().await, acc)) });
@@ -130,7 +122,7 @@ impl Api {
         http: Option<A>,
         https: Option<A>,
         pool: PgPool,
-    ) -> tokio::io::Result<Self> {
+    ) -> Result<Self> {
         let http = OptionFuture::from(http.map(TcpListener::bind)).map(Option::transpose);
         let https = OptionFuture::from(https.map(TcpListener::bind)).map(Option::transpose);
 
@@ -139,7 +131,7 @@ impl Api {
         Ok(Api { http, https, pool })
     }
 
-    pub async fn spawn(self) -> Result<(), Box<dyn std::error::Error>> {
+    pub async fn spawn(self) -> Result<()> {
         let pool = self.pool.clone();
         let routes = warp::path("register")
             .and(warp::post())

src/api.rs

@@ -1,7 +1,6 @@
 use acme_lib::{create_p384_key, Directory, DirectoryUrl};
+use anyhow::{anyhow, Context, Result};
 use sqlx::{Executor, FromRow, PgPool, Postgres};
-use std::error::Error;
-use std::io::ErrorKind;
 use std::time::Duration;
 use tokio::time::Interval;
 use uuid::Uuid;
@@ -93,7 +92,7 @@ impl CertFacade {
         Ok(())
     }
 
-    pub async fn start(pool: &PgPool) -> Result<Option<Cert>, sqlx::Error> {
+    pub async fn start(pool: &PgPool) -> Result<Option<Cert>> {
         let mut transaction = pool.begin().await?;
 
         let cert = CertFacade::first_cert(&mut transaction).await?;
@@ -155,11 +154,7 @@ pub struct CertManager {
 }
 
 impl CertManager {
-    pub async fn new(
-        pool: PgPool,
-        persist: DatabasePersist,
-        acme: String,
-    ) -> Result<Self, Box<dyn Error>> {
+    pub async fn new(pool: PgPool, persist: DatabasePersist, acme: String) -> Result<Self> {
         let directory = tokio::task::spawn_blocking(move || {
             Directory::from_url(persist, DirectoryUrl::Other(&acme))
         })
@@ -173,19 +168,8 @@ impl CertManager {
         // use constant
         tokio::time::interval(Duration::from_secs(3600))
     }
-}
-
-fn error(kind: ErrorKind, message: &str) -> std::io::Error {
-    let error: Box<dyn Error + Send + Sync> = From::from(message.to_string());
-    std::io::Error::new(kind, error)
-}
-
-fn other_error(message: &str) -> std::io::Error {
-    error(ErrorKind::Other, message)
-}
 
-impl CertManager {
-    pub async fn spawn(self) -> Result<(), Box<dyn Error>> {
+    pub async fn spawn(self) -> Result<()> {
         tokio::spawn(async move {
             let mut interval = CertManager::interval();
             loop {
@@ -205,10 +189,12 @@ impl CertManager {
         Ok(())
     }
 
-    async fn test(&self) -> Result<(), Box<dyn Error>> {
+    async fn test(&self) -> Result<()> {
+        // maybe context is not needed here
         let mut memory_cert = CertFacade::start(&self.pool)
-            .await?
-            .ok_or_else(|| other_error("Cert not found"))?;
+            .await
+            .context("Start failed")?
+            .ok_or_else(|| anyhow!("Start did not return cert"))?;
 
         // todo: improve
         let mut domain = DomainFacade::find_by_id(&self.pool, &memory_cert.domain)
@@ -225,7 +211,7 @@ impl CertManager {
         let mut auths = order.authorizations()?;
         let call = auths
             .pop()
-            .ok_or_else(|| other_error("couldn't unpack auths"))?
+            .ok_or_else(|| anyhow!("couldn't unpack auths"))?
             .dns_challenge();
         let proof = call.dns_proof();
 

src/cert.rs

@@ -1,6 +1,6 @@
+use anyhow::Result;
 use serde::Deserialize;
 use std::collections::HashMap;
-use std::error::Error;
 use std::fs::File;
 use std::io::Read;
 
@@ -34,7 +34,7 @@ pub struct Config {
 const DEFAULT_CONFIG_PATH: &str = "config.toml";
 
 // is not async so we can use it to load settings for tokio runtime
-pub fn config(config_path: Option<String>) -> Result<Config, Box<dyn Error>> {
+pub fn config(config_path: Option<String>) -> Result<Config> {
     let config_path = config_path.as_deref().unwrap_or(DEFAULT_CONFIG_PATH);
     let mut file = File::open(config_path)?;
     let mut bytes = vec![];