micropelago/domani
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Don't return Box from constructors

Browse Source
This commit is contained in:
Brian Picciano 2023-06-29 16:54:55 +02:00
parent 0b22801503
commit bd96581c6a
8 changed files with 142 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

87
src/domain/acme/manager.rs
View File

@ -24,55 +24,62 @@ pub trait Manager: Sync + Send {
) -> Result<(PrivateKey, Vec<Certificate>), GetCertificateError>;
}
struct ManagerImpl {
pub struct ManagerImpl {
store: Box<dyn acme::store::Store>,
account: sync::Arc<acme2::Account>,
}
pub async fn new(
store: Box<dyn acme::store::Store>,
contact_email: &str,
) -> Result<Box<dyn Manager>, unexpected::Error> {
let dir = acme2::DirectoryBuilder::new(LETS_ENCRYPT_URL.to_string())
.build()
.await
.or_unexpected_while("creating acme2 directory builder")?;
impl ManagerImpl {
pub async fn new<Store: acme::store::Store + 'static>(
store: Store,
contact_email: &str,
) -> Result<Self, unexpected::Error> {
let dir = acme2::DirectoryBuilder::new(LETS_ENCRYPT_URL.to_string())
.build()
.await
.or_unexpected_while("creating acme2 directory builder")?;
let mut contact = String::from("mailto:");
contact.push_str(contact_email);
let mut contact = String::from("mailto:");
contact.push_str(contact_email);
let mut builder = acme2::AccountBuilder::new(dir);
builder.contact(vec![contact]);
builder.terms_of_service_agreed(true);
let mut builder = acme2::AccountBuilder::new(dir);
builder.contact(vec![contact]);
builder.terms_of_service_agreed(true);
match store.get_account_key() {
Ok(account_key) => {
builder.private_key(
(&account_key)
.try_into()
.or_unexpected_while("parsing private key")?,
);
match store.get_account_key() {
Ok(account_key) => {
builder.private_key(
(&account_key)
.try_into()
.or_unexpected_while("parsing private key")?,
);
}
Err(acme::store::GetAccountKeyError::NotFound) => (),
Err(acme::store::GetAccountKeyError::Unexpected(err)) => {
return Err(err.into_unexpected())
}
}
Err(acme::store::GetAccountKeyError::NotFound) => (),
Err(acme::store::GetAccountKeyError::Unexpected(err)) => return Err(err.into_unexpected()),
let account = builder
.build()
.await
.or_unexpected_while("building account")?;
let account_key: acme::PrivateKey = account
.private_key()
.as_ref()
.try_into()
.or_unexpected_while("parsing private key back out")?;
store
.set_account_key(&account_key)
.or_unexpected_while("storing account key")?;
Ok(Self {
store: Box::from(store),
account,
})
}
let account = builder
.build()
.await
.or_unexpected_while("building account")?;
let account_key: acme::PrivateKey = account
.private_key()
.as_ref()
.try_into()
.or_unexpected_while("parsing private key back out")?;
store
.set_account_key(&account_key)
.or_unexpected_while("storing account key")?;
Ok(Box::new(ManagerImpl { store, account }))
}
impl Manager for ManagerImpl {

37
src/domain/acme/store.rs
View File

@ -66,28 +66,29 @@ struct StoredPKeyCert {
cert: Vec<Certificate>,
}
struct FSStore {
pub struct FSStore {
dir_path: path::PathBuf,
}
pub fn new(dir_path: &path::Path) -> Result<Box<dyn Store>, unexpected::Error> {
vec![
dir_path,
dir_path.join("http01_challenge_keys").as_ref(),
dir_path.join("certificates").as_ref(),
]
.iter()
.map(|dir| {
fs::create_dir_all(dir).map_unexpected_while(|| format!("creating dir {}", dir.display()))
})
.try_collect()?;
Ok(Box::new(FSStore {
dir_path: dir_path.into(),
}))
}
impl FSStore {
pub fn new(dir_path: &path::Path) -> Result<Self, unexpected::Error> {
vec![
dir_path,
dir_path.join("http01_challenge_keys").as_ref(),
dir_path.join("certificates").as_ref(),
]
.iter()
.map(|dir| {
fs::create_dir_all(dir)
.map_unexpected_while(|| format!("creating dir {}", dir.display()))
})
.try_collect()?;
Ok(Self {
dir_path: dir_path.into(),
})
}
fn account_key_path(&self) -> path::PathBuf {
self.dir_path.join("account.key")
}

40
src/domain/checker.rs
View File

@ -36,27 +36,27 @@ pub struct DNSChecker {
client: tokio::sync::Mutex<AsyncClient>,
}
pub async fn new(
target_a: net::Ipv4Addr,
resolver_addr: &str,
) -> Result<DNSChecker, NewDNSCheckerError> {
let resolver_addr = resolver_addr
.parse()
.map_err(|_| NewDNSCheckerError::InvalidResolverAddress)?;
let stream = udp::UdpClientStream::<tokio::net::UdpSocket>::new(resolver_addr);
let (client, bg) = AsyncClient::connect(stream).await.or_unexpected()?;
tokio::spawn(bg);
Ok(DNSChecker {
target_a,
client: tokio::sync::Mutex::new(client),
})
}
impl DNSChecker {
pub async fn new(
target_a: net::Ipv4Addr,
resolver_addr: &str,
) -> Result<Self, NewDNSCheckerError> {
let resolver_addr = resolver_addr
.parse()
.map_err(|_| NewDNSCheckerError::InvalidResolverAddress)?;
let stream = udp::UdpClientStream::<tokio::net::UdpSocket>::new(resolver_addr);
let (client, bg) = AsyncClient::connect(stream).await.or_unexpected()?;
tokio::spawn(bg);
Ok(Self {
target_a,
client: tokio::sync::Mutex::new(client),
})
}
pub async fn check_domain(
&self,
domain: &domain::Name,

16
src/domain/config.rs
View File

@ -45,18 +45,18 @@ pub trait Store: Sync + Send {
fn all_domains(&self) -> Result<Vec<domain::Name>, unexpected::Error>;
}
struct FSStore {
pub struct FSStore {
dir_path: PathBuf,
}
pub fn new(dir_path: &Path) -> io::Result<Box<dyn Store>> {
fs::create_dir_all(dir_path)?;
Ok(Box::new(FSStore {
dir_path: dir_path.into(),
}))
}
impl FSStore {
pub fn new(dir_path: &Path) -> io::Result<Self> {
fs::create_dir_all(dir_path)?;
Ok(Self {
dir_path: dir_path.into(),
})
}
fn config_dir_path(&self, domain: &domain::Name) -> PathBuf {
self.dir_path.join(domain.as_str())
}

20
src/domain/manager.rs
View File

@ -176,18 +176,22 @@ async fn sync_origins(origin_store: &dyn origin::store::Store, canceller: Cancel
}
}
pub fn new(
pub fn new<
OriginStore: origin::store::Store + 'static,
DomainConfigStore: config::Store + 'static,
AcmeManager: acme::manager::Manager + 'static,
>(
task_stack: &mut util::TaskStack<unexpected::Error>,
origin_store: Box<dyn origin::store::Store>,
domain_config_store: Box<dyn config::Store>,
origin_store: OriginStore,
domain_config_store: DomainConfigStore,
domain_checker: checker::DNSChecker,
acme_manager: Option<Box<dyn acme::manager::Manager>>,
acme_manager: Option<AcmeManager>,
) -> sync::Arc<dyn Manager> {
let manager = sync::Arc::new(ManagerImpl {
origin_store,
domain_config_store,
domain_checker,
acme_manager,
origin_store: Box::from(origin_store),
domain_config_store: Box::from(domain_config_store),
domain_checker: domain_checker,
acme_manager: acme_manager.map(|m| Box::new(m) as Box<dyn acme::manager::Manager>),
});
task_stack.push_spawn(|canceller| {

23
src/main.rs
View File

@ -73,33 +73,38 @@ async fn main() {
)
.init();
let origin_store = domani::origin::store::git::new(config.origin_store_git_dir_path)
let origin_store = domani::origin::store::git::FSStore::new(config.origin_store_git_dir_path)
.expect("git origin store initialization failed");
let domain_checker = domani::domain::checker::new(
let domain_checker = domani::domain::checker::DNSChecker::new(
config.domain_checker_target_a,
&config.domain_checker_resolver_addr,
)
.await
.expect("domain checker initialization failed");
let domain_config_store = domani::domain::config::new(&config.domain_config_store_dir_path)
.expect("domain config store initialization failed");
let domain_config_store =
domani::domain::config::FSStore::new(&config.domain_config_store_dir_path)
.expect("domain config store initialization failed");
let domain_acme_manager = if config.https_listen_addr.is_some() {
let domain_acme_store_dir_path = config.domain_acme_store_dir_path.unwrap();
let domain_acme_store = domani::domain::acme::store::new(&domain_acme_store_dir_path)
.expect("domain acme store initialization failed");
let domain_acme_store =
domani::domain::acme::store::FSStore::new(&domain_acme_store_dir_path)
.expect("domain acme store initialization failed");
// if https_listen_addr is set then domain_acme_contact_email is required, see the Cli/clap
// settings.
let domain_acme_contact_email = config.domain_acme_contact_email.unwrap();
Some(
domani::domain::acme::manager::new(domain_acme_store, &domain_acme_contact_email)
.await
.expect("domain acme manager initialization failed"),
domani::domain::acme::manager::ManagerImpl::new(
domain_acme_store,
&domain_acme_contact_email,
)
.await
.expect("domain acme manager initialization failed"),
)
} else {
None

28
src/origin/store/git.rs
View File

@ -59,9 +59,9 @@ enum GetOriginError {
Unexpected(#[from] unexpected::Error),
}
/// git::Store implements the Store trait for any Descr::Git based Origins. If any non-git
/// Descrs are used then this implementation will panic.
struct Store {
/// Implements the Store trait for any Descr::Git based Origins, storing the git repos on disk. If
/// any non-git Descrs are used then this implementation will panic.
pub struct FSStore {
dir_path: PathBuf,
// to prevent against syncing the same origin more than once at a time, but still allowing
@ -71,16 +71,16 @@ struct Store {
origins: sync::RwLock<collections::HashMap<origin::Descr, sync::Arc<Origin>>>,
}
pub fn new(dir_path: PathBuf) -> io::Result<Box<dyn super::Store>> {
fs::create_dir_all(&dir_path)?;
Ok(Box::new(Store {
dir_path,
sync_guard: sync::Mutex::new(collections::HashMap::new()),
origins: sync::RwLock::new(collections::HashMap::new()),
}))
}
impl FSStore {
pub fn new(dir_path: PathBuf) -> io::Result<Self> {
fs::create_dir_all(&dir_path)?;
Ok(Self {
dir_path,
sync_guard: sync::Mutex::new(collections::HashMap::new()),
origins: sync::RwLock::new(collections::HashMap::new()),
})
}
impl Store {
fn repo_path(&self, descr: &origin::Descr) -> PathBuf {
self.dir_path.join(descr.id())
}
@ -208,7 +208,7 @@ impl Store {
}
}
impl super::Store for Store {
impl super::Store for FSStore {
fn sync(&self, descr: origin::Descr, limits: store::Limits) -> Result<(), store::SyncError> {
// attempt to lock this descr for syncing, doing so within a new scope so the mutex
// isn't actually being held for the whole method duration.
@ -344,7 +344,7 @@ mod tests {
let limits = store::Limits {};
let store = super::new(tmp_dir.path().to_path_buf()).expect("store created");
let store = super::FSStore::new(tmp_dir.path().to_path_buf()).expect("store created");
store
.sync(descr.clone(), limits)

14
src/origin/store/mux.rs
View File

@ -2,26 +2,28 @@ use crate::error::unexpected::Mappable;
use crate::origin::{self, store};
use std::sync;
struct Store<F, S>
pub struct Store<F, S>
where
S: store::Store,
S: store::Store + 'static,
F: Fn(&origin::Descr) -> Option<S> + Sync + Send,
{
mapping_fn: F,
stores: Vec<S>,
}
pub fn new<F, S>(mapping_fn: F, stores: Vec<S>) -> Box<dyn store::Store>
impl<F, S> Store<F, S>
where
S: store::Store + 'static,
F: Fn(&origin::Descr) -> Option<S> + Sync + Send + 'static,
F: Fn(&origin::Descr) -> Option<S> + Sync + Send,
{
Box::new(Store { mapping_fn, stores })
pub fn new(mapping_fn: F, stores: Vec<S>) -> Store<F, S> {
Store { mapping_fn, stores }
}
}
impl<F, S> store::Store for Store<F, S>
where
S: store::Store,
S: store::Store + 'static,
F: Fn(&origin::Descr) -> Option<S> + Sync + Send,
{
fn sync(&self, descr: origin::Descr, limits: store::Limits) -> Result<(), store::SyncError> {