adrian/schematics
1
0
Fork 0
Code Issues Pull requests Releases Activity

Compare commits

base: adrian:d091265d2769cdcc3c3ec615a29285c47ca28b50
Branches Tags
adrian:master
..
compare: adrian:ac1c06dd319edd94bb7bcbafd1da309fa587be0f
Branches Tags
adrian:master

No commits in common. "d091265d2769cdcc3c3ec615a29285c47ca28b50" and "ac1c06dd319edd94bb7bcbafd1da309fa587be0f" have entirely different histories.
d091265d27 ... ac1c06dd31

30 changed files with 305 additions and 414 deletions
Download patch file Download diff file Expand all files Collapse all files

1
Cargo.toml
View file

@ -15,7 +15,6 @@ once_cell = "1.4"
slog = { version = "2", features = ["max_level_trace", "release_max_level_trace"] }
slog-term = "2.5"
slog-async = "2.7"
nonzero_ext = "0.3.0"
[dev-dependencies]
tempfile = "3"

50
src/artifacts/mod.rs
View file

@ -1,24 +1,13 @@
use std::path::{self, PathBuf};
use std::rc::Rc;
use std::path::{Path as ActualPath, PathBuf};
#[derive(Clone, Debug)]
pub struct Path(Rc<path::Path>);
pub struct Path(PathBuf);
impl Path {
pub(crate) fn clone_rc(&self) -> Rc<path::Path> {
Rc::clone(&self.0)
}
pub fn join(&self, path: impl AsRef<path::Path>) -> Self {
Self::from(self.0.join(path))
}
}
// FIXME: This is a specialization since with Path: AsRef<path::Path>
// FIXME: This is a specialization since with Path: Into<PathBuf>
// it would overwrite impl<T> From <T> for T
//impl<T: AsRef<path::Path>> From<T> for Path {
//impl<T: Into<PathBuf>> From<T> for Path {
// fn from(v: T) -> Self {
// Self(v.as_ref().into())
// Path(v.into())
// }
//}
@ -26,8 +15,7 @@ macro_rules! path_from {
( $t:ty ) => {
impl From<$t> for Path {
fn from(v: $t) -> Self {
let path: &path::Path = v.as_ref();
Self(path.into())
Self(v.into())
}
}
};
@ -37,35 +25,23 @@ path_from!(String);
path_from!(&str);
path_from!(PathBuf);
impl From<Rc<path::Path>> for Path {
fn from(v: Rc<path::Path>) -> Self {
Self(v)
}
}
impl AsRef<path::Path> for Path {
fn as_ref(&self) -> &path::Path {
&self.0
}
}
impl From<Path> for Rc<path::Path> {
impl From<Path> for PathBuf {
fn from(v: Path) -> Self {
v.0
}
}
impl From<&Path> for Rc<path::Path> {
fn from(v: &Path) -> Self {
v.0.clone()
impl AsRef<ActualPath> for Path {
fn as_ref(&self) -> &ActualPath {
&self.0
}
}
#[derive(Clone, Debug)]
pub struct UserName(pub Rc<str>);
pub struct UserName(pub String);
#[derive(Clone, Debug)]
pub struct ServiceName(pub Rc<str>);
pub struct ServiceName(pub String);
#[derive(Clone, Debug)]
pub struct DatabaseName(pub Rc<str>);
pub struct DatabaseName(pub String);

2
src/bin.rs
View file

@ -2,7 +2,7 @@ use std::env;
use std::process::exit;
pub fn schematics_main(run: &dyn Fn(bool) -> Result<(), ()>) {
let args: Box<[String]> = env::args().collect();
let args: Vec<String> = env::args().collect();
let dry_run = match args.len() {
1 => false,
2 => {

3
src/build.rs
View file

@ -15,8 +15,7 @@ pub fn create_static_output(
.to_str()
.ok_or("Filename is not valid unicode")?
.to_uppercase();
let file = read_file(source_path)?;
let content = std::str::from_utf8(&file)?;
let content = String::from_utf8(read_file(source_path)?)?;
let fence = content.chars().filter(|&c| c == '#').collect::<String>() + "#";
writeln!(

166
src/builder.rs
View file

@ -41,8 +41,7 @@ use crate::templates::systemd::{
};
use crate::to_artifact::ToArtifact;
use std::fmt::Display;
use std::path::Path;
use std::rc::Rc;
use std::path::{Path, PathBuf};
pub trait ImplementationBuilder<R> {
type Prerequisites: ToArtifact;
@ -65,13 +64,13 @@ impl<D> ImplementationBuilder<Key<D>> for DefaultBuilder {
type Prerequisites = ();
fn prerequisites(_resource: &Key<D>) -> Self::Prerequisites {}
type Implementation = KeySymbol<StdCommandRunner, Rc<Path>>;
type Implementation = KeySymbol<StdCommandRunner, PathBuf>;
fn create(
_resource: &Key<D>,
target: &<Key<D> as Resource>::Artifact,
(): <Self::Prerequisites as ToArtifact>::Artifact,
) -> Self::Implementation {
KeySymbol::new(StdCommandRunner, target.clone_rc())
KeySymbol::new(StdCommandRunner, target.clone().into())
}
}
@ -81,7 +80,7 @@ impl<D: Clone> ImplementationBuilder<Csr<D>> for DefaultBuilder {
Key(resource.0.clone())
}
type Implementation = CsrSymbol<StdCommandRunner, D, Rc<Path>, Rc<Path>>;
type Implementation = CsrSymbol<StdCommandRunner, D, PathBuf, PathBuf>;
fn create(
resource: &Csr<D>,
target: &<Csr<D> as Resource>::Artifact,
@ -90,8 +89,8 @@ impl<D: Clone> ImplementationBuilder<Csr<D>> for DefaultBuilder {
CsrSymbol::new(
StdCommandRunner,
resource.0.clone(),
key.clone_rc(),
target.clone_rc(),
key.into(),
target.clone().into(),
)
}
}
@ -117,7 +116,7 @@ impl<D: Clone> ImplementationBuilder<Cert<D>> for DefaultBuilder {
}
type Implementation =
CertSymbol<SetuidCommandRunner<Rc<str>>, SetuidCommandRunner<Rc<str>>, D, Rc<Path>>;
CertSymbol<SetuidCommandRunner<String>, SetuidCommandRunner<String>, D, PathBuf>;
fn create(
resource: &Cert<D>,
target: &<Cert<D> as Resource>::Artifact,
@ -126,11 +125,11 @@ impl<D: Clone> ImplementationBuilder<Cert<D>> for DefaultBuilder {
CertSymbol::new(
resource.0.clone(),
SetuidCommandRunner::new(user_name.0),
root_cert.clone_rc(),
account_key.clone_rc(),
challenges_dir.clone_rc(),
csr.clone_rc(),
target.clone_rc(),
root_cert.into(),
account_key.into(),
challenges_dir.into(),
csr.into(),
target.clone().into(),
)
}
}
@ -141,13 +140,13 @@ impl<D: Clone> ImplementationBuilder<CertChain<D>> for DefaultBuilder {
(Cert(resource.0.clone()), AcmeRootCert)
}
type Implementation = ConcatSymbol<[Rc<Path>; 2], Rc<Path>, Rc<Path>>;
type Implementation = ConcatSymbol<[PathBuf; 2], PathBuf, PathBuf>;
fn create(
_resource: &CertChain<D>,
target: &<CertChain<D> as Resource>::Artifact,
(cert, root_cert): <Self::Prerequisites as ToArtifact>::Artifact,
) -> Self::Implementation {
ConcatSymbol::new([cert.clone_rc(), root_cert.clone_rc()], target.clone_rc())
ConcatSymbol::new([cert.into(), root_cert.into()], target.clone().into())
}
}
@ -157,13 +156,13 @@ impl<D: Clone> ImplementationBuilder<KeyAndCertBundle<D>> for DefaultBuilder {
(CertChain(resource.0.clone()), Key(resource.0.clone()))
}
type Implementation = ConcatSymbol<[Rc<Path>; 2], Rc<Path>, Rc<Path>>;
type Implementation = ConcatSymbol<[PathBuf; 2], PathBuf, PathBuf>;
fn create(
_resource: &KeyAndCertBundle<D>,
target: &<KeyAndCertBundle<D> as Resource>::Artifact,
(cert_chain, key): <Self::Prerequisites as ToArtifact>::Artifact,
) -> Self::Implementation {
ConcatSymbol::new([key.clone_rc(), cert_chain.clone_rc()], target.clone_rc())
ConcatSymbol::new([key.into(), cert_chain.into()], target.clone().into())
}
}
@ -171,7 +170,7 @@ impl<P: AsRef<Path> + Clone> ImplementationBuilder<File<P>> for DefaultBuilder {
type Prerequisites = ();
fn prerequisites(_resource: &File<P>) -> Self::Prerequisites {}
type Implementation = FileSymbol<P, Rc<str>>;
type Implementation = FileSymbol<P, String>;
fn create(
resource: &File<P>,
_target: &<File<P> as Resource>::Artifact,
@ -202,7 +201,7 @@ impl ImplementationBuilder<DefaultServer> for DefaultBuilder {
}
type Implementation = (
FileSymbol<Rc<Path>, Box<str>>,
FileSymbol<PathBuf, String>,
ReloadServiceSymbol<StdCommandRunner, StdCommandRunner, &'static str>,
);
fn create(
@ -212,8 +211,8 @@ impl ImplementationBuilder<DefaultServer> for DefaultBuilder {
) -> Self::Implementation {
(
FileSymbol::new(
target.clone_rc(),
nginx::default_server(challenges_snippet_path).into(),
target.clone().into(),
nginx::default_server(challenges_snippet_path),
),
ReloadServiceSymbol::new(StdCommandRunner, "nginx"),
)
@ -231,7 +230,7 @@ impl<D: AsRef<str> + Clone + Display> ImplementationBuilder<ServeCustom<D>> for
}
type Implementation = (
FileSymbol<Rc<Path>, Box<str>>,
FileSymbol<PathBuf, String>,
ReloadServiceSymbol<StdCommandRunner, StdCommandRunner, &'static str>,
);
fn create(
@ -241,8 +240,8 @@ impl<D: AsRef<str> + Clone + Display> ImplementationBuilder<ServeCustom<D>> for
) -> Self::Implementation {
(
FileSymbol::new(
target.clone_rc(),
nginx::server_config(&resource.0, cert, key, &resource.1, challenges_snippet_path).into(),
target.clone().into(),
nginx::server_config(&resource.0, cert, key, &resource.1, challenges_snippet_path),
),
ReloadServiceSymbol::new(StdCommandRunner, "nginx"),
)
@ -268,7 +267,7 @@ impl<D: Clone + Display, P: AsRef<Path>, C: Clone + Into<PhpFpmPoolConfig>>
}
type Implementation = (
FileSymbol<Rc<Path>, Box<str>>,
FileSymbol<PathBuf, String>,
ReloadServiceSymbol<StdCommandRunner, StdCommandRunner, &'static str>,
);
fn create(
@ -278,15 +277,14 @@ impl<D: Clone + Display, P: AsRef<Path>, C: Clone + Into<PhpFpmPoolConfig>>
) -> Self::Implementation {
(
FileSymbol::new(
target.clone_rc(),
target.clone().into(),
nginx::server_config(
&resource.0,
cert,
key,
nginx::php_snippet(resource.2, pool.0, &resource.1) + &resource.3,
challenges_snippet_path,
)
.into(),
),
),
ReloadServiceSymbol::new(StdCommandRunner, "nginx"),
)
@ -318,7 +316,7 @@ impl<D: Clone + Display, P: Clone + AsRef<Path>> ImplementationBuilder<ServeServ
}
type Implementation = (
FileSymbol<Rc<Path>, Box<str>>,
FileSymbol<PathBuf, String>,
ReloadServiceSymbol<StdCommandRunner, StdCommandRunner, &'static str>,
);
fn create(
@ -328,15 +326,14 @@ impl<D: Clone + Display, P: Clone + AsRef<Path>> ImplementationBuilder<ServeServ
) -> Self::Implementation {
(
FileSymbol::new(
target.clone_rc(),
target.clone().into(),
nginx::server_config(
&resource.0,
cert,
key,
nginx::proxy_snippet(&socket.0, &resource.3),
challenges_snippet_path,
)
.into(),
),
),
ReloadServiceSymbol::new(StdCommandRunner, "nginx"),
)
@ -354,7 +351,7 @@ impl<D: AsRef<str> + Clone + Display> ImplementationBuilder<ServeRedir<D>> for D
}
type Implementation = (
FileSymbol<Rc<Path>, Box<str>>,
FileSymbol<PathBuf, String>,
ReloadServiceSymbol<StdCommandRunner, StdCommandRunner, &'static str>,
);
fn create(
@ -364,15 +361,14 @@ impl<D: AsRef<str> + Clone + Display> ImplementationBuilder<ServeRedir<D>> for D
) -> Self::Implementation {
(
FileSymbol::new(
target.clone_rc(),
target.clone().into(),
nginx::server_config(
&resource.0,
cert,
key,
nginx::redir_snippet(resource.1.as_ref()),
challenges_snippet_path,
)
.into(),
),
),
ReloadServiceSymbol::new(StdCommandRunner, "nginx"),
)
@ -392,7 +388,7 @@ impl<D: AsRef<str> + Clone + Display, P: AsRef<Path>> ImplementationBuilder<Serv
}
type Implementation = (
FileSymbol<Rc<Path>, Box<str>>,
FileSymbol<PathBuf, String>,
ReloadServiceSymbol<StdCommandRunner, StdCommandRunner, &'static str>,
);
fn create(
@ -402,15 +398,14 @@ impl<D: AsRef<str> + Clone + Display, P: AsRef<Path>> ImplementationBuilder<Serv
) -> Self::Implementation {
(
FileSymbol::new(
target.clone_rc(),
target.clone().into(),
nginx::server_config(
&resource.0,
cert,
key,
nginx::static_snippet(resource.1.as_ref()),
challenges_snippet_path,
)
.into(),
),
),
ReloadServiceSymbol::new(StdCommandRunner, "nginx"),
)
@ -422,8 +417,8 @@ impl<D: Clone> ImplementationBuilder<PhpFpmPool<D>> for DefaultBuilder {
fn prerequisites(_resource: &PhpFpmPool<D>) -> Self::Prerequisites {}
type Implementation = (
FileSymbol<Rc<Path>, Box<str>>,
ReloadServiceSymbol<StdCommandRunner, StdCommandRunner, Rc<str>>,
FileSymbol<PathBuf, String>,
ReloadServiceSymbol<StdCommandRunner, StdCommandRunner, String>,
);
fn create(
resource: &PhpFpmPool<D>,
@ -432,8 +427,8 @@ impl<D: Clone> ImplementationBuilder<PhpFpmPool<D>> for DefaultBuilder {
) -> Self::Implementation {
(
FileSymbol::new(
conf_path.clone_rc(),
php_fpm_pool_config(&user_name.0, socket_path, &resource.1).into(),
conf_path.clone().into(),
php_fpm_pool_config(&user_name.0, socket_path, &resource.1),
),
ReloadServiceSymbol::new(StdCommandRunner, service_name.0.clone()),
)
@ -446,10 +441,10 @@ impl<D, P: AsRef<Path>> ImplementationBuilder<SystemdSocketService<D, P>> for De
type Implementation = (
// First three could be parallel
FileSymbol<Rc<Path>, Box<str>>,
SystemdUserSessionSymbol<'static, Rc<str>, StdCommandRunner>,
OwnerSymbol<StdCommandRunner, StdCommandRunner, Box<Path>, Rc<str>>,
UserServiceSymbol<'static, Rc<Path>, Rc<str>>,
FileSymbol<PathBuf, String>,
SystemdUserSessionSymbol<'static, String, StdCommandRunner>,
OwnerSymbol<StdCommandRunner, StdCommandRunner, PathBuf, String>,
UserServiceSymbol<'static, PathBuf, String>,
);
fn create(
resource: &SystemdSocketService<D, P>,
@ -458,7 +453,7 @@ impl<D, P: AsRef<Path>> ImplementationBuilder<SystemdSocketService<D, P>> for De
) -> Self::Implementation {
(
FileSymbol::new(
conf_path.clone_rc(),
conf_path.clone().into(),
if resource.4 {
systemd_nodejs_service(&resource.2, socket_path, &resource.3)
} else {
@ -468,16 +463,15 @@ impl<D, P: AsRef<Path>> ImplementationBuilder<SystemdSocketService<D, P>> for De
&resource.3,
"",
)
}
.into(),
},
),
SystemdUserSessionSymbol::new(user_name.0.clone(), &StdCommandRunner),
OwnerSymbol::new(
conf_path.as_ref().parent().unwrap().into(),
conf_path.as_ref().parent().unwrap().to_path_buf(),
user_name.0.clone(),
StdCommandRunner,
),
UserServiceSymbol::new(socket_path.clone_rc(), user_name.0.clone(), resource.1),
UserServiceSymbol::new(socket_path.clone().into(), user_name.0.clone(), resource.1),
)
}
}
@ -522,7 +516,7 @@ impl<P: Clone + AsRef<Path>> ImplementationBuilder<StoredDirectory<P>> for Defau
) -> Self::Implementation {
SavedDirectorySymbol::new(
resource.1.clone(),
SimpleStorage::new(target.clone_rc()),
SimpleStorage::new(target.clone().into()),
StorageDirection::Store,
StdCommandRunner,
)
@ -541,7 +535,7 @@ impl<P: Clone + AsRef<Path>> ImplementationBuilder<LoadedDirectory<P>> for Defau
) -> Self::Implementation {
SavedDirectorySymbol::new(
resource.1.clone(),
SimpleStorage::new(target.clone_rc()),
SimpleStorage::new(target.clone().into()),
StorageDirection::Load,
StdCommandRunner,
)
@ -552,7 +546,7 @@ impl<D: Clone> ImplementationBuilder<UserForDomain<D>> for DefaultBuilder {
type Prerequisites = ();
fn prerequisites(_resource: &UserForDomain<D>) -> Self::Prerequisites {}
type Implementation = UserSymbol<Rc<str>, StdCommandRunner>;
type Implementation = UserSymbol<String, StdCommandRunner>;
fn create(
_resource: &UserForDomain<D>,
(user_name, _home_path): &<UserForDomain<D> as Resource>::Artifact,
@ -566,7 +560,7 @@ impl ImplementationBuilder<User> for DefaultBuilder {
type Prerequisites = ();
fn prerequisites(_resource: &User) -> Self::Prerequisites {}
type Implementation = UserSymbol<Rc<str>, StdCommandRunner>;
type Implementation = UserSymbol<String, StdCommandRunner>;
fn create(
resource: &User,
(): &<User as Resource>::Artifact,
@ -580,7 +574,7 @@ impl<P: AsRef<Path> + Clone> ImplementationBuilder<Owner<P>> for DefaultBuilder
type Prerequisites = ();
fn prerequisites(_resource: &Owner<P>) -> Self::Prerequisites {}
type Implementation = OwnerSymbol<StdCommandRunner, StdCommandRunner, P, Rc<str>>;
type Implementation = OwnerSymbol<StdCommandRunner, StdCommandRunner, P, String>;
fn create(
resource: &Owner<P>,
(): &<Owner<P> as Resource>::Artifact,
@ -594,7 +588,7 @@ impl ImplementationBuilder<AcmeUser> for DefaultBuilder {
type Prerequisites = ();
fn prerequisites(_resource: &AcmeUser) -> Self::Prerequisites {}
type Implementation = UserSymbol<Rc<str>, StdCommandRunner>;
type Implementation = UserSymbol<String, StdCommandRunner>;
fn create(
_resource: &AcmeUser,
user_name: &<AcmeUser as Resource>::Artifact,
@ -611,8 +605,8 @@ impl ImplementationBuilder<AcmeChallengesDir> for DefaultBuilder {
}
type Implementation = (
DirSymbol<Rc<Path>>,
OwnerSymbol<StdCommandRunner, StdCommandRunner, Rc<Path>, Rc<str>>,
DirSymbol<PathBuf>,
OwnerSymbol<StdCommandRunner, StdCommandRunner, PathBuf, String>,
);
fn create(
_resource: &AcmeChallengesDir,
@ -620,8 +614,8 @@ impl ImplementationBuilder<AcmeChallengesDir> for DefaultBuilder {
user_name: <Self::Prerequisites as ToArtifact>::Artifact,
) -> Self::Implementation {
(
DirSymbol::new(target.clone_rc()),
OwnerSymbol::new(target.clone_rc(), user_name.0, StdCommandRunner),
DirSymbol::new(target.clone().into()),
OwnerSymbol::new(target.clone().into(), user_name.0, StdCommandRunner),
)
}
}
@ -632,15 +626,15 @@ impl ImplementationBuilder<AcmeChallengesNginxSnippet> for DefaultBuilder {
AcmeChallengesDir
}
type Implementation = FileSymbol<Rc<Path>, Box<str>>;
type Implementation = FileSymbol<PathBuf, String>;
fn create(
_resource: &AcmeChallengesNginxSnippet,
target: &<AcmeChallengesNginxSnippet as Resource>::Artifact,
challenges_dir: <Self::Prerequisites as ToArtifact>::Artifact,
) -> Self::Implementation {
FileSymbol::new(
target.clone_rc(),
nginx::acme_challenges_snippet(challenges_dir).into(),
target.clone().into(),
nginx::acme_challenges_snippet(challenges_dir),
)
}
}
@ -652,8 +646,8 @@ impl ImplementationBuilder<AcmeAccountKey> for DefaultBuilder {
}
type Implementation = (
KeySymbol<StdCommandRunner, Rc<Path>>,
OwnerSymbol<StdCommandRunner, StdCommandRunner, Rc<Path>, Rc<str>>,
KeySymbol<StdCommandRunner, PathBuf>,
OwnerSymbol<StdCommandRunner, StdCommandRunner, PathBuf, String>,
);
fn create(
_resource: &AcmeAccountKey,
@ -661,8 +655,8 @@ impl ImplementationBuilder<AcmeAccountKey> for DefaultBuilder {
user_name: <Self::Prerequisites as ToArtifact>::Artifact,
) -> Self::Implementation {
(
KeySymbol::new(StdCommandRunner, target.clone_rc()),
OwnerSymbol::new(target.clone_rc(), user_name.0, StdCommandRunner),
KeySymbol::new(StdCommandRunner, target.clone().into()),
OwnerSymbol::new(target.clone().into(), user_name.0, StdCommandRunner),
)
}
}
@ -671,13 +665,13 @@ impl ImplementationBuilder<AcmeRootCert> for DefaultBuilder {
type Prerequisites = ();
fn prerequisites(_resource: &AcmeRootCert) -> Self::Prerequisites {}
type Implementation = FileSymbol<Rc<Path>, &'static str>;
type Implementation = FileSymbol<PathBuf, &'static str>;
fn create(
_resource: &AcmeRootCert,
target: &<AcmeRootCert as Resource>::Artifact,
(): <Self::Prerequisites as ToArtifact>::Artifact,
) -> Self::Implementation {
FileSymbol::new(target.clone_rc(), LETS_ENCRYPT_R3)
FileSymbol::new(target.clone().into(), LETS_ENCRYPT_R3)
}
}
@ -685,7 +679,7 @@ impl<D> ImplementationBuilder<MariaDbUser<D>> for DefaultBuilder {
type Prerequisites = ();
fn prerequisites(_resource: &MariaDbUser<D>) -> Self::Prerequisites {}
type Implementation = MariaDbUserSymbol<'static, Rc<str>, StdCommandRunner>;
type Implementation = MariaDbUserSymbol<'static, String, StdCommandRunner>;
fn create(
_resource: &MariaDbUser<D>,
user_name: &<MariaDbUser<D> as Resource>::Artifact,
@ -702,15 +696,15 @@ impl<D: Clone> ImplementationBuilder<MariaDbDatabase<D>> for DefaultBuilder {
}
type Implementation = (
MariaDbDatabaseSymbol<'static, Rc<str>, SimpleStorage, StdCommandRunner>,
MariaDbDumpSymbol<'static, Rc<str>, StdCommandRunner, SimpleStorage>,
MariaDbDatabaseSymbol<'static, String, SimpleStorage, StdCommandRunner>,
MariaDbDumpSymbol<'static, String, StdCommandRunner, SimpleStorage>,
);
fn create(
_resource: &MariaDbDatabase<D>,
(db_name, _, data_path): &<MariaDbDatabase<D> as Resource>::Artifact,
_: <Self::Prerequisites as ToArtifact>::Artifact,
) -> Self::Implementation {
let db_dump = SimpleStorage::new(data_path.clone_rc());
let db_dump = SimpleStorage::new(data_path.clone().into());
(
MariaDbDatabaseSymbol::new(db_name.0.clone(), db_dump.clone(), &StdCommandRunner),
MariaDbDumpSymbol::new(db_name.0.clone(), db_dump, &StdCommandRunner),
@ -722,13 +716,13 @@ impl<D: Clone> ImplementationBuilder<PostgresqlDatabase<D>> for DefaultBuilder {
type Prerequisites = ();
fn prerequisites(_: &PostgresqlDatabase<D>) -> Self::Prerequisites {}
type Implementation = (PostgreSQLDatabaseSymbol<'static, Rc<str>, Rc<str>, StdCommandRunner>,);
type Implementation = (PostgreSQLDatabaseSymbol<'static, String, String, StdCommandRunner>,);
fn create(
_resource: &PostgresqlDatabase<D>,
(db_name, data_path): &<PostgresqlDatabase<D> as Resource>::Artifact,
_: <Self::Prerequisites as ToArtifact>::Artifact,
) -> Self::Implementation {
let db_dump = SimpleStorage::new(data_path.clone_rc());
let db_dump = SimpleStorage::new(data_path.clone().into());
(PostgreSQLDatabaseSymbol::new(
db_name.0.clone(),
db_dump.read_filename().unwrap().to_str().unwrap().into(),
@ -738,9 +732,9 @@ impl<D: Clone> ImplementationBuilder<PostgresqlDatabase<D>> for DefaultBuilder {
}
impl<P: Clone + AsRef<Path>> ImplementationBuilder<WordpressPlugin<P>> for DefaultBuilder {
type Prerequisites = Dir<Rc<Path>>;
type Prerequisites = Dir<PathBuf>;
fn prerequisites(resource: &WordpressPlugin<P>) -> Self::Prerequisites {
Dir::new(resource.0.as_ref().join("wp-content/plugins"))
Dir(resource.0.as_ref().join("wp-content/plugins"))
}
type Implementation = WordpressPluginSymbol<'static, P, &'static str, StdCommandRunner>;
@ -753,21 +747,21 @@ impl<P: Clone + AsRef<Path>> ImplementationBuilder<WordpressPlugin<P>> for Defau
}
}
impl<P: AsRef<Path>> ImplementationBuilder<WordpressTranslation<P>> for DefaultBuilder {
type Prerequisites = Dir<Rc<Path>>;
impl<P: Clone + AsRef<Path>> ImplementationBuilder<WordpressTranslation<P>> for DefaultBuilder {
type Prerequisites = Dir<PathBuf>;
fn prerequisites(resource: &WordpressTranslation<P>) -> Self::Prerequisites {
Dir::new(resource.0.as_ref().join("wp-content/languages"))
Dir(resource.0.as_ref().join("wp-content/languages"))
}
type Implementation =
WordpressTranslationSymbol<'static, &'static str, Box<Path>, StdCommandRunner>;
WordpressTranslationSymbol<'static, &'static str, PathBuf, StdCommandRunner>;
fn create(
resource: &WordpressTranslation<P>,
(): &<WordpressTranslation<P> as Resource>::Artifact,
_: <Self::Prerequisites as ToArtifact>::Artifact,
) -> Self::Implementation {
WordpressTranslationSymbol::new(
(*resource.0.as_ref().join("wp-content/languages")).into(),
resource.0.as_ref().join("wp-content/languages"),
resource.1,
resource.2,
&StdCommandRunner,
@ -781,7 +775,7 @@ impl<D: Clone> ImplementationBuilder<Cron<D>> for DefaultBuilder {
UserForDomain(resource.0.clone())
}
type Implementation = CronSymbol<'static, Box<str>, Rc<str>, StdCommandRunner>;
type Implementation = CronSymbol<'static, String, String, StdCommandRunner>;
fn create(
resource: &Cron<D>,
(): &<Cron<D> as Resource>::Artifact,

4
src/command_runner.rs
View file

@ -19,7 +19,7 @@ fn check_success(output: Output) -> Result<Output, Box<dyn Error>> {
if output.status.success() {
Ok(output)
} else {
Err(std::str::from_utf8(&output.stderr)?.into())
Err(String::from_utf8(output.stderr)?.into())
}
}
@ -93,7 +93,7 @@ struct TempSetEnv<'a> {
}
impl<'a> TempSetEnv<'a> {
fn new(name: &'a str, new_value: impl AsRef<OsStr>) -> TempSetEnv<'a> {
fn new(name: &'a str, new_value: String) -> TempSetEnv<'a> {
let old_value = env::var(name);
env::set_var(name, new_value);
TempSetEnv {

63
src/locator.rs
View file

@ -12,8 +12,7 @@ use crate::resources::{
use crate::to_artifact::ToArtifact;
use std::fmt::Display;
use std::marker::PhantomData;
use std::path::Path;
use std::rc::Rc;
use std::path::{Path, PathBuf};
pub trait Policy {
#[must_use]
@ -22,13 +21,13 @@ pub trait Policy {
}
#[must_use]
fn user_home(user_name: &str) -> Rc<Path> {
Path::new("/home").join(user_name).into()
fn user_home(user_name: &str) -> PathBuf {
Path::new("/home").join(user_name)
}
#[must_use]
fn user_name_for_domain(domain_name: &'_ str) -> Rc<str> {
domain_name.split('.').rev().fold(String::new(), |result, part| if result.is_empty() { result } else { result + "_" } + part).into()
fn user_name_for_domain(domain_name: &'_ str) -> String {
domain_name.split('.').rev().fold(String::new(), |result, part| if result.is_empty() { result } else { result + "_" } + part)
}
#[must_use]
@ -37,8 +36,8 @@ pub trait Policy {
}
#[must_use]
fn path_for_data(name: impl Display) -> Rc<Path> {
Path::new("/root/data").join(format!("_{name}")).into()
fn path_for_data(name: impl Display) -> PathBuf {
Path::new("/root/data").join(format!("_{name}"))
}
}
@ -60,37 +59,37 @@ pub struct DefaultLocator<P = DefaultPolicy> {
}
impl<P, D: AsRef<str>> ResourceLocator<Key<D>> for DefaultLocator<P> {
type Prerequisites = Dir<Rc<Path>>;
type Prerequisites = Dir<PathBuf>;
fn locate(resource: &Key<D>) -> (<Key<D> as Resource>::Artifact, Self::Prerequisites) {
(
PathArtifact::from(format!("/etc/ssl/private/{}.key", resource.0.as_ref())),
Dir::new("/etc/ssl/private"),
Dir("/etc/ssl/private".into()),
)
}
}
impl<P, D: AsRef<str>> ResourceLocator<Csr<D>> for DefaultLocator<P> {
type Prerequisites = Dir<Rc<Path>>;
type Prerequisites = Dir<PathBuf>;
fn locate(resource: &Csr<D>) -> (<Csr<D> as Resource>::Artifact, Self::Prerequisites) {
(
PathArtifact::from(format!("/etc/ssl/local_certs/{}.csr", resource.0.as_ref())),
Dir::new("/etc/ssl/local_certs"),
Dir("/etc/ssl/local_certs".into()),
)
}
}
impl<P, D: AsRef<str>> ResourceLocator<Cert<D>> for DefaultLocator<P> {
type Prerequisites = Dir<Rc<Path>>;
type Prerequisites = Dir<PathBuf>;
fn locate(resource: &Cert<D>) -> (<Cert<D> as Resource>::Artifact, Self::Prerequisites) {
(
PathArtifact::from(format!("/etc/ssl/local_certs/{}.crt", resource.0.as_ref())),
Dir::new("/etc/ssl/local_certs"),
Dir("/etc/ssl/local_certs".into()),
)
}
}
impl<P, D: AsRef<str>> ResourceLocator<CertChain<D>> for DefaultLocator<P> {
type Prerequisites = Dir<Rc<Path>>;
type Prerequisites = Dir<PathBuf>;
fn locate(
resource: &CertChain<D>,
) -> (<CertChain<D> as Resource>::Artifact, Self::Prerequisites) {
@ -99,13 +98,13 @@ impl<P, D: AsRef<str>> ResourceLocator<CertChain<D>> for DefaultLocator<P> {
"/etc/ssl/local_certs/{}.chained.crt",
resource.0.as_ref()
)),
Dir::new("/etc/ssl/local_certs"),
Dir("/etc/ssl/local_certs".into()),
)
}
}
impl<P, D: AsRef<str>> ResourceLocator<KeyAndCertBundle<D>> for DefaultLocator<P> {
type Prerequisites = Dir<Rc<Path>>;
type Prerequisites = Dir<PathBuf>;
fn locate(
resource: &KeyAndCertBundle<D>,
) -> (
@ -117,34 +116,34 @@ impl<P, D: AsRef<str>> ResourceLocator<KeyAndCertBundle<D>> for DefaultLocator<P
"/etc/ssl/private/{}.with_key.crt",
resource.0.as_ref()
)),
Dir::new("/etc/ssl/private"),
Dir("/etc/ssl/private".into()),
)
}
}
impl<POLICY, P: AsRef<Path>> ResourceLocator<File<P>> for DefaultLocator<POLICY> {
type Prerequisites = Dir<Rc<Path>>;
type Prerequisites = Dir<PathBuf>;
fn locate(resource: &File<P>) -> (<File<P> as Resource>::Artifact, Self::Prerequisites) {
((), Dir::new(resource.0.as_ref().parent().unwrap()))
((), Dir(resource.0.as_ref().parent().unwrap().into()))
}
}
impl<'a, POLICY, P: AsRef<Path>> ResourceLocator<GitCheckout<'a, P>> for DefaultLocator<POLICY> {
type Prerequisites = Dir<Rc<Path>>;
type Prerequisites = Dir<PathBuf>;
fn locate(
resource: &GitCheckout<'a, P>,
) -> (
<GitCheckout<'a, P> as Resource>::Artifact,
Self::Prerequisites,
) {
((), Dir::new(resource.0.as_ref().parent().unwrap()))
((), Dir(resource.0.as_ref().parent().unwrap().into()))
}
}
impl<POLICY, P: Clone + AsRef<Path>> ResourceLocator<Dir<P>> for DefaultLocator<POLICY> {
type Prerequisites = Option<Dir<Rc<Path>>>;
type Prerequisites = Option<Dir<PathBuf>>;
fn locate(resource: &Dir<P>) -> (<Dir<P> as Resource>::Artifact, Self::Prerequisites) {
((), resource.0.as_ref().parent().map(Dir::new))
((), resource.0.as_ref().parent().map(|p| Dir(p.into())))
}
}
@ -174,7 +173,7 @@ impl<POLICY: Policy, P: AsRef<Path>> ResourceLocator<StoredDirectory<P>>
impl<POLICY: Policy, P: AsRef<Path>> ResourceLocator<LoadedDirectory<P>>
for DefaultLocator<POLICY>
{
type Prerequisites = Dir<Rc<Path>>;
type Prerequisites = Dir<PathBuf>;
fn locate(
resource: &LoadedDirectory<P>,
) -> (
@ -183,13 +182,13 @@ impl<POLICY: Policy, P: AsRef<Path>> ResourceLocator<LoadedDirectory<P>>
) {
(
PathArtifact::from(POLICY::path_for_data(resource.0)),
Dir::new(resource.1.as_ref().parent().unwrap()),
Dir(resource.1.as_ref().parent().unwrap().into()),
)
}
}
impl<P: Policy> ResourceLocator<AcmeAccountKey> for DefaultLocator<P> {
type Prerequisites = Dir<Rc<Path>>;
type Prerequisites = Dir<PathBuf>;
fn locate(
_resource: &AcmeAccountKey,
) -> (<AcmeAccountKey as Resource>::Artifact, Self::Prerequisites) {
@ -208,7 +207,7 @@ impl<P: Policy> ResourceLocator<AcmeUser> for DefaultLocator<P> {
}
impl<P: Policy> ResourceLocator<AcmeChallengesDir> for DefaultLocator<P> {
type Prerequisites = Dir<Rc<Path>>;
type Prerequisites = Dir<PathBuf>;
fn locate(
_resource: &AcmeChallengesDir,
) -> (
@ -237,7 +236,7 @@ impl<P: Policy> ResourceLocator<AcmeChallengesNginxSnippet> for DefaultLocator<P
}
impl<P: Policy> ResourceLocator<AcmeRootCert> for DefaultLocator<P> {
type Prerequisites = Dir<Rc<Path>>;
type Prerequisites = Dir<PathBuf>;
fn locate(
_resource: &AcmeRootCert,
) -> (<AcmeRootCert as Resource>::Artifact, Self::Prerequisites) {
@ -371,7 +370,7 @@ impl<D: Clone + AsRef<str>, P: Policy> ResourceLocator<PhpFpmPool<D>> for Defaul
php_version, user.0
)),
user,
ServiceNameArtifact(format!("php{php_version}-fpm").into()),
ServiceNameArtifact(format!("php{php_version}-fpm")),
),
(),
)
@ -381,7 +380,7 @@ impl<D: Clone + AsRef<str>, P: Policy> ResourceLocator<PhpFpmPool<D>> for Defaul
impl<D: Clone + AsRef<str>, P, POLICY: Policy> ResourceLocator<SystemdSocketService<D, P>>
for DefaultLocator<POLICY>
{
type Prerequisites = Dir<Rc<Path>>;
type Prerequisites = Dir<PathBuf>;
fn locate(
resource: &SystemdSocketService<D, P>,
) -> (
@ -397,7 +396,7 @@ impl<D: Clone + AsRef<str>, P, POLICY: Policy> ResourceLocator<SystemdSocketServ
PathArtifact::from(service_dir_path.join(format!("{}.service", resource.1))),
user_name,
),
Dir::new(service_dir_path),
Dir(service_dir_path),
)
}
}

122
src/resources/mod.rs
View file

@ -4,7 +4,7 @@ use crate::artifacts::{
};
use crate::templates::php::FpmPoolConfig;
use std::hash::Hash;
use std::path::Path;
use std::path::PathBuf;
pub trait Resource {
type Artifact;
@ -41,41 +41,23 @@ impl<D> Resource for KeyAndCertBundle<D> {
}
#[derive(Debug, Hash, PartialEq, Eq)]
pub struct File<P>(pub P, pub Rc<str>);
pub struct File<P>(pub P, pub String);
impl<P> Resource for File<P> {
type Artifact = ();
}
impl File<Rc<Path>> {
pub fn new(p: impl Into<Rc<Path>>, content: impl AsRef<str>) -> Self {
Self(p.into(), content.as_ref().into())
}
}
#[derive(Debug, Hash, PartialEq, Eq)]
pub struct GitCheckout<'a, P>(pub P, pub &'a str, pub &'a str);
impl<'a, P> Resource for GitCheckout<'a, P> {
type Artifact = ();
}
impl<'a> GitCheckout<'a, Rc<Path>> {
pub fn new(target: impl Into<Rc<Path>>, src: &'a str, head: &'a str) -> Self {
Self(target.into(), src, head)
}
}
#[derive(Debug, Hash, PartialEq, Eq)]
pub struct Dir<P>(pub P);
impl<P> Resource for Dir<P> {
type Artifact = ();
}
impl Dir<Rc<Path>> {
pub fn new(p: impl AsRef<Path>) -> Self {
Self(p.as_ref().into())
}
}
#[derive(Debug, Hash, PartialEq, Eq)]
pub struct UserForDomain<D>(pub D);
impl<D> Resource for UserForDomain<D> {
@ -124,11 +106,10 @@ impl<P> Resource for LoadedDirectory<P> {
type Artifact = PathArtifact;
}
pub fn get_saved_directory(
pub fn get_saved_directory<P: Clone>(
storage_name: &'static str,
target: impl Into<Rc<Path>>,
) -> (StoredDirectory<Rc<Path>>, LoadedDirectory<Rc<Path>>) {
let target = target.into();
target: P,
) -> (StoredDirectory<P>, LoadedDirectory<P>) {
(
StoredDirectory(storage_name, target.clone()),
LoadedDirectory(storage_name, target),
@ -136,7 +117,7 @@ pub fn get_saved_directory(
}
#[derive(Debug, Hash, PartialEq, Eq)]
pub struct User(pub Rc<str>);
pub struct User(pub String);
impl Resource for User {
type Artifact = ();
}
@ -153,32 +134,20 @@ impl<P> Resource for NpmInstall<P> {
type Artifact = ();
}
impl NpmInstall<Rc<Path>> {
pub fn new(path: impl Into<Rc<Path>>) -> Self {
Self(path.into())
}
}
#[derive(Debug, Hash, PartialEq, Eq)]
pub struct Owner<P>(pub Rc<str>, pub P);
pub struct Owner<P>(pub String, pub P);
impl<P> Resource for Owner<P> {
type Artifact = ();
}
impl Owner<Rc<Path>> {
pub fn new(user: &UserNameArtifact, p: impl Into<Rc<Path>>) -> Self {
Self(user.0.clone(), p.into())
}
}
#[derive(Debug, Hash, PartialEq, Eq)]
pub struct ServeCustom<D>(pub D, pub Rc<str>);
pub struct ServeCustom<D>(pub D, pub String);
impl<D> Resource for ServeCustom<D> {
type Artifact = PathArtifact;
}
#[derive(Debug, Hash, PartialEq, Eq)]
pub struct ServePhp<D, P, C>(pub D, pub P, pub &'static str, pub Rc<str>, pub C);
pub struct ServePhp<D, P, C>(pub D, pub P, pub &'static str, pub String, pub C);
impl<D, P, C> Resource for ServePhp<D, P, C> {
type Artifact = PathArtifact;
}
@ -189,25 +158,6 @@ pub struct ServeService<D, P>(pub D, pub &'static str, pub P, pub P, pub P, pub
impl<D, P> Resource for ServeService<D, P> {
type Artifact = PathArtifact;
}
impl<D> ServeService<D, Rc<Path>> {
pub fn new(
domain: D,
service_name: &'static str,
exec: impl Into<Rc<Path>>,
static_path: impl Into<Rc<Path>>,
working_directory: impl Into<Rc<Path>>,
is_nodejs: bool,
) -> Self {
Self(
domain,
service_name,
exec.into(),
static_path.into(),
working_directory.into(),
is_nodejs,
)
}
}
#[derive(Debug, Hash, PartialEq, Eq)]
pub struct ServeRedir<D>(pub D, pub D);
@ -221,12 +171,6 @@ impl<D, P> Resource for ServeStatic<D, P> {
type Artifact = PathArtifact;
}
impl<D> ServeStatic<D, Rc<Path>> {
pub fn new(domain: D, path: impl Into<Rc<Path>>) -> Self {
Self(domain, path.into())
}
}
#[derive(Debug, Hash, PartialEq, Eq)]
pub struct DefaultServer;
impl Resource for DefaultServer {
@ -269,26 +213,14 @@ impl<P> Resource for WordpressPlugin<P> {
type Artifact = ();
}
impl WordpressPlugin<Rc<Path>> {
pub fn new(path: impl Into<Rc<Path>>, name: &'static str) -> Self {
Self(path.into(), name)
}
}
#[derive(Debug, Hash, PartialEq, Eq)]
pub struct WordpressTranslation<P>(pub P, pub &'static str, pub &'static str);
impl<P> Resource for WordpressTranslation<P> {
type Artifact = ();
}
impl WordpressTranslation<Rc<Path>> {
pub fn new(path: impl Into<Rc<Path>>, version: &'static str, lang: &'static str) -> Self {
Self(path.into(), version, lang)
}
}
#[derive(Debug, Hash, PartialEq, Eq)]
pub struct Cron<D>(pub D, pub Rc<str>);
pub struct Cron<D>(pub D, pub String);
impl<D> Resource for Cron<D> {
type Artifact = ();
}
@ -355,38 +287,38 @@ default_resources!(
Cron: Cron<D>,
Csr: Csr<D>,
DefaultServer: DefaultServer,
Dir: Dir<Rc<Path>>,
File: File<Rc<Path>>,
GitCheckout: GitCheckout<'a, Rc<Path>>,
Dir: Dir<PathBuf>,
File: File<PathBuf>,
GitCheckout: GitCheckout<'a, PathBuf>,
Key: Key<D>,
KeyAndCertBundle: KeyAndCertBundle<D>,
LoadedDirectory: LoadedDirectory<Rc<Path>>,
LoadedDirectory: LoadedDirectory<PathBuf>,
MariaDbDatabase: MariaDbDatabase<D>,
MariaDbUser: MariaDbUser<D>,
PostgresqlDatabase: PostgresqlDatabase<D>,
SystemdSocketService: SystemdSocketService<D, Rc<Path>>,
NpmInstall: NpmInstall<Rc<Path>>,
Owner: Owner<Rc<Path>>,
SystemdSocketService: SystemdSocketService<D, PathBuf>,
NpmInstall: NpmInstall<PathBuf>,
Owner: Owner<PathBuf>,
PhpFpmPool: PhpFpmPool<D>,
ServeCustom: ServeCustom<D>,
ServeService: ServeService<D, Rc<Path>>,
ServePhp: ServePhp<D, Rc<Path>, FpmPoolConfig>,
ServeService: ServeService<D, PathBuf>,
ServePhp: ServePhp<D, PathBuf, FpmPoolConfig>,
ServeRedir: ServeRedir<D>,
ServeStatic: ServeStatic<D, Rc<Path>>,
StoredDirectory: StoredDirectory<Rc<Path>>,
ServeStatic: ServeStatic<D, PathBuf>,
StoredDirectory: StoredDirectory<PathBuf>,
User: User,
UserForDomain: UserForDomain<D>,
WordpressPlugin: WordpressPlugin<Rc<Path>>,
WordpressTranslation: WordpressTranslation<Rc<Path>>,
WordpressPlugin: WordpressPlugin<PathBuf>,
WordpressTranslation: WordpressTranslation<PathBuf>,
);
pub fn serve_php<D, C: Into<FpmPoolConfig>>(
pub fn serve_php<D, P: Into<PathBuf>, C: Into<FpmPoolConfig>>(
domain: D,
path: impl Into<Rc<Path>>,
path: P,
root_filename: &'static str,
nginx_config: impl Into<Rc<str>>,
nginx_config: impl Into<String>,
pool_config: C,
) -> ServePhp<D, Rc<Path>, FpmPoolConfig> {
) -> ServePhp<D, PathBuf, FpmPoolConfig> {
ServePhp(
domain,
path.into(),

29
src/setup/mod.rs
View file

@ -169,7 +169,7 @@ impl<
#[cfg(test)]
mod test {
use super::symbol_runner::TestSymbolRunner;
use super::SymbolRunner;
use crate::async_utils::run;
use crate::loggers::{Entry, StoringLogger};
use crate::resources::{FromArtifact, FromResource, Resource};
@ -178,11 +178,33 @@ mod test {
use crate::{ImplementationBuilder, ResourceLocator, Setup};
use async_trait::async_trait;
use regex::Regex;
use slog::{info, Logger};
use std::cell::RefCell;
use std::error::Error;
use std::fmt::Debug;
use std::rc::{Rc, Weak};
struct TestSymbolRunner {
count: Rc<RefCell<usize>>,
}
#[async_trait(?Send)]
impl SymbolRunner for TestSymbolRunner {
async fn run_symbol<S: Symbol + Debug>(
&self,
symbol: &S,
logger: &Logger,
force: bool,
) -> Result<bool, Box<dyn Error>> {
info!(logger, "run");
let run = force || !symbol.target_reached().await?;
if run {
*self.count.borrow_mut() += 1;
}
Ok(run)
}
}
#[derive(Debug, PartialEq, Eq, Hash)]
struct TestResource<T>(&'static str, T);
impl<T> Resource for TestResource<T> {
@ -286,7 +308,10 @@ mod test {
>,
StoringLogger,
) {
let (count, runner) = TestSymbolRunner::new();
let count = Rc::new(RefCell::new(0));
let runner = TestSymbolRunner {
count: Rc::clone(&count),
};
let logger = StoringLogger::new();
(count, Setup::new_with(runner, logger.clone()), logger)
}

32
src/setup/runnable.rs
View file

@ -53,10 +53,10 @@ for_each_tuple!(runnable_for_tuple);
#[cfg(test)]
mod test {
use super::super::symbol_runner::TestSymbolRunner;
use super::Runnable;
use crate::async_utils::run;
use crate::symbols::Symbol;
use crate::SymbolRunner;
use async_trait::async_trait;
use slog::{o, Discard, Logger};
use std::cell::RefCell;
@ -103,11 +103,39 @@ mod test {
}
}
struct TestSymbolRunner {
count: Rc<RefCell<usize>>,
}
fn get_runner() -> (Rc<RefCell<usize>>, TestSymbolRunner) {
let count = Rc::new(RefCell::new(0));
let runner = TestSymbolRunner {
count: Rc::clone(&count),
};
(count, runner)
}
#[async_trait(?Send)]
impl SymbolRunner for TestSymbolRunner {
async fn run_symbol<S: Symbol + Debug>(
&self,
symbol: &S,
_logger: &Logger,
force: bool,
) -> Result<bool, Box<dyn Error>> {
let run = force || !symbol.target_reached().await?;
if run {
*self.count.borrow_mut() += 1;
}
Ok(run)
}
}
fn run_symbol(
runnable: impl Runnable,
force: bool,
) -> (Rc<RefCell<usize>>, Result<bool, Box<dyn Error>>) {
let (count, runner) = TestSymbolRunner::new();
let (count, runner) = get_runner();
let res = run(runnable.run(&runner, &Logger::root(Discard, o!()), force));
(count, res)
}

38
src/setup/symbol_runner.rs
View file

@ -2,13 +2,9 @@ use crate::async_utils::sleep;
use crate::symbols::Symbol;
use async_trait::async_trait;
use slog::{debug, info, o, trace, Logger};
#[cfg(test)]
use std::cell::RefCell;
use std::error::Error;
use std::fmt;
use std::fmt::Debug;
#[cfg(test)]
use std::rc::Rc;
use std::time::Duration;
#[async_trait(?Send)]
@ -202,40 +198,6 @@ where
}
}
#[cfg(test)]
pub struct TestSymbolRunner {
count: Rc<RefCell<usize>>,
}
#[cfg(test)]
impl TestSymbolRunner {
pub fn new() -> (Rc<RefCell<usize>>, Self) {
let count = Rc::new(RefCell::new(0));
let runner = TestSymbolRunner {
count: Rc::clone(&count),
};
(count, runner)
}
}
#[cfg(test)]
#[async_trait(?Send)]
impl SymbolRunner for TestSymbolRunner {
async fn run_symbol<S: Symbol + Debug>(
&self,
symbol: &S,
logger: &Logger,
force: bool,
) -> Result<bool, Box<dyn Error>> {
info!(logger, "run");
let run = force || !symbol.target_reached().await?;
if run {
*self.count.borrow_mut() += 1;
}
Ok(run)
}
}
#[cfg(test)]
mod test {
use super::{DrySymbolRunner, InitializingSymbolRunner, ReportingSymbolRunner, SymbolRunner};

31
src/storage.rs
View file

@ -1,46 +1,49 @@
use std::error::Error;
use std::fs::read_dir;
use std::path::Path;
use std::rc::Rc;
use std::path::PathBuf;
use std::str::FromStr;
use std::time::{SystemTime, UNIX_EPOCH};
pub trait Storage {
fn write_filename(&self) -> Box<Path>;
fn read_filename(&self) -> Result<Box<Path>, Box<dyn Error>>;
fn write_filename(&self) -> PathBuf;
fn read_filename(&self) -> Result<PathBuf, Box<dyn Error>>;
fn recent_date(&self) -> Result<u64, Box<dyn Error>>;
}
#[derive(Debug, Clone)]
pub struct SimpleStorage(Rc<Path>);
pub struct SimpleStorage(PathBuf);
impl SimpleStorage {
#[must_use]
pub const fn new(base: Rc<Path>) -> Self {
pub const fn new(base: PathBuf) -> Self {
Self(base)
}
fn get_path(&self, date: u64) -> Box<Path> {
self.0.join(date.to_string()).into()
fn get_path(&self, date: Option<u64>) -> PathBuf {
match date {
Some(d) => self.0.join(d.to_string()),
None => self.0.clone(),
}
}
}
impl Storage for SimpleStorage {
fn write_filename(&self) -> Box<Path> {
self.get_path(
fn write_filename(&self) -> PathBuf {
self.get_path(Some(
SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_secs(),
)
))
}
fn read_filename(&self) -> Result<Box<Path>, Box<dyn Error>> {
Ok(self.get_path(self.recent_date()?))
fn read_filename(&self) -> Result<PathBuf, Box<dyn Error>> {
Ok(self.get_path(Some(self.recent_date()?)))
}
fn recent_date(&self) -> Result<u64, Box<dyn Error>> {
read_dir(&self.0)?
let dir = self.get_path(None);
read_dir(dir)?
.map(|entry| {
entry
.ok()

2
src/symbols/acme/cert.rs
View file

@ -102,7 +102,7 @@ impl<_C: CommandRunner, C: Borrow<_C>, D: AsRef<str>, P: AsRef<Path>> Symbol for
{
Ok(false)
} else {
Err(std::str::from_utf8(&output.stderr)?.into())
Err(String::from_utf8(output.stderr)?.into())
}
}

4
src/symbols/cron.rs
View file

@ -10,11 +10,11 @@ pub struct Cron<'r, C, U, R> {
command_runner: &'r R,
}
impl<'r, U, R> Cron<'r, Box<str>, U, R> {
impl<'r, U, R> Cron<'r, String, U, R> {
pub fn new<C: AsRef<str>>(user: U, content: C, command_runner: &'r R) -> Self {
Self {
user,
content: (String::from(content.as_ref()) + "\n").into(),
content: String::from(content.as_ref()) + "\n",
command_runner,
}
}

15
src/symbols/git/submodules.rs
View file

@ -42,14 +42,15 @@ impl<P: AsRef<Path>, C: CommandRunner> Symbol for GitSubmodules<'_, P, C> {
if !self.target.as_ref().exists() {
return Ok(false);
}
let output = String::from_utf8(
self
._run_in_target_repo(args!["submodule", "status"])
.await?,
)?;
Ok(
std::str::from_utf8(
&self
._run_in_target_repo(args!["submodule", "status"])
.await?,
)?
.lines()
.all(|line| line.is_empty() || line.starts_with(' ')),
output
.lines()
.all(|line| line.is_empty() || line.starts_with(' ')),
)
}

4
src/symbols/mariadb/database.rs
View file

@ -11,7 +11,7 @@ pub struct Database<'a, D, S, C> {
command_runner: &'a C,
}
impl<'a, D, S, C> Database<'a, D, S, C> {
impl<'a, D, S, C: CommandRunner> Database<'a, D, S, C> {
pub const fn new(db_name: D, seed_file: S, command_runner: &'a C) -> Self {
Self {
db_name,
@ -19,9 +19,7 @@ impl<'a, D, S, C> Database<'a, D, S, C> {
command_runner,
}
}
}
impl<'a, D, S, C: CommandRunner> Database<'a, D, S, C> {
async fn run_sql(&self, sql: &str) -> Result<String, Box<dyn Error>> {
let b = self
.command_runner

4
src/symbols/mariadb/dump.rs
View file

@ -12,7 +12,7 @@ pub struct Dump<'a, N, C, S> {
command_runner: &'a C,
}
impl<'a, N, C, S> Dump<'a, N, C, S> {
impl<'a, N, C: CommandRunner, S> Dump<'a, N, C, S> {
pub const fn new(db_name: N, storage: S, command_runner: &'a C) -> Self {
Self {
db_name,
@ -20,9 +20,7 @@ impl<'a, N, C, S> Dump<'a, N, C, S> {
command_runner,
}
}
}
impl<'a, N, C: CommandRunner, S> Dump<'a, N, C, S> {
async fn run_sql(&self, sql: &str) -> Result<String, Box<dyn Error>> {
let b = self
.command_runner

4
src/symbols/mariadb/user.rs
View file

@ -9,16 +9,14 @@ pub struct User<'a, U, C> {
command_runner: &'a C,
}
impl<'a, U: AsRef<str>, C> User<'a, U, C> {
impl<'a, U: AsRef<str>, C: CommandRunner> User<'a, U, C> {
pub const fn new(user_name: U, command_runner: &'a C) -> Self {
Self {
user_name,
command_runner,
}
}
}
impl<'a, U: AsRef<str>, C: CommandRunner> User<'a, U, C> {
async fn run_sql(&self, sql: &str) -> Result<String, Box<dyn Error>> {
let b = self
.command_runner

6
src/symbols/npm.rs
View file

@ -6,12 +6,12 @@ use std::fmt;
use std::path::Path;
#[derive(Debug)]
pub struct Install<'a, T: AsRef<Path>, C> {
pub struct Install<'a, T: AsRef<Path>, C: CommandRunner> {
target: T,
command_runner: &'a C,
}
impl<'a, T: AsRef<Path>, C> Install<'a, T, C> {
impl<'a, T: AsRef<Path>, C: CommandRunner> Install<'a, T, C> {
pub const fn new(target: T, command_runner: &'a C) -> Self {
Self {
target,
@ -51,7 +51,7 @@ impl<T: AsRef<Path>, C: CommandRunner> Symbol for Install<'_, T, C> {
.await?;
Ok(
result.status.success()
&& !std::str::from_utf8(&result.stdout)
&& !String::from_utf8(result.stdout)
.unwrap()
.contains("(empty)"),
)

8
src/symbols/postgresql/database.rs
View file

@ -5,23 +5,21 @@ use std::error::Error;
use std::fmt;
#[derive(Debug)]
pub struct PostgreSQLDatabase<'a, N, S, C> {
pub struct PostgreSQLDatabase<'a, N: AsRef<str>, S: AsRef<str>, C: CommandRunner> {
name: N,
seed_file: S,
command_runner: &'a C,
}
impl<'a, N, S, C> PostgreSQLDatabase<'a, N, S, C> {
impl<'a, N: AsRef<str>, S: AsRef<str>, C: CommandRunner> PostgreSQLDatabase<'a, N, S, C> {
pub const fn new(name: N, seed_file: S, command_runner: &'a C) -> Self {
Self {
PostgreSQLDatabase {
name,
seed_file,
command_runner,
}
}
}
impl<'a, N: AsRef<str>, S: AsRef<str>, C: CommandRunner> PostgreSQLDatabase<'a, N, S, C> {
async fn run_sql(&self, sql: &str) -> Result<String, Box<dyn Error>> {
let b = self
.command_runner

22
src/symbols/saved_directory.rs
View file

@ -73,7 +73,7 @@ impl<_C: CommandRunner, C: Borrow<_C>, P: AsRef<Path>, S: Storage> Symbol
],
)
.await?;
let modified_date = u64::from_str(std::str::from_utf8(&output)?.trim_end())?;
let modified_date = u64::from_str(String::from_utf8(output)?.trim_end())?;
if if self.dir == StorageDirection::Store {
modified_date > dump_date
} else {
@ -84,17 +84,13 @@ impl<_C: CommandRunner, C: Borrow<_C>, P: AsRef<Path>, S: Storage> Symbol
.borrow()
.run_with_args(
"diff",
args![
"-rq",
self.storage.read_filename()?.as_os_str(),
self.path.as_ref()
],
args!["-rq", self.storage.read_filename()?, self.path.as_ref()],
)
.await?;
match output.status.code() {
Some(0) => Ok(true),
Some(1) => Ok(false),
_ => Err(std::str::from_utf8(&output.stderr)?.into()),
_ => Err(String::from_utf8(output.stderr)?.into()),
}
} else {
Ok(true)
@ -113,11 +109,7 @@ impl<_C: CommandRunner, C: Borrow<_C>, P: AsRef<Path>, S: Storage> Symbol
.borrow()
.run_successfully(
"cp",
args![
"-a",
self.storage.read_filename()?.as_os_str(),
self.path.as_ref()
],
args!["-a", self.storage.read_filename()?, self.path.as_ref()],
)
.await
} else {
@ -126,11 +118,7 @@ impl<_C: CommandRunner, C: Borrow<_C>, P: AsRef<Path>, S: Storage> Symbol
.borrow()
.run_successfully(
"cp",
args![
"-a",
self.path.as_ref(),
self.storage.write_filename().as_os_str()
],
args!["-a", self.path.as_ref(), self.storage.write_filename()],
)
.await
}

8
src/symbols/systemd/user_service.rs
View file

@ -30,9 +30,9 @@ impl<S: AsRef<Path>, U: AsRef<str>> UserService<'_, S, U> {
loop {
let result = self.command_runner.run_with_args("systemctl", args).await?;
if result.status.success() {
return Ok(std::str::from_utf8(&result.stdout)?.trim_end().to_string());
return Ok(String::from_utf8(result.stdout)?.trim_end().to_string());
}
let raw_stderr = std::str::from_utf8(&result.stderr)?;
let raw_stderr = String::from_utf8(result.stderr)?;
let stderr = raw_stderr.trim_end();
if stderr != "Failed to connect to bus: No such file or directory" {
return Err(stderr.into());
@ -61,8 +61,8 @@ impl<S: AsRef<Path>, U: AsRef<str>> UserService<'_, S, U> {
"ActiveState=active" => return Ok(true),
"ActiveState=failed" => {
return Err(
std::str::from_utf8(
&self
String::from_utf8(
self
.command_runner
.get_output(
"journalctl",

6
src/symbols/tls/key.rs
View file

@ -1,16 +1,14 @@
use crate::command_runner::CommandRunner;
use crate::symbols::Symbol;
use async_trait::async_trait;
use nonzero_ext::nonzero;
use std::error::Error;
use std::num::NonZeroU32;
use std::path::Path;
#[derive(Debug)]
pub struct Key<C, P> {
file_path: P,
command_runner: C,
bits: NonZeroU32,
bits: u32,
}
impl<C, P> Key<C, P> {
@ -18,7 +16,7 @@ impl<C, P> Key<C, P> {
Self {
file_path,
command_runner,
bits: nonzero!(4096u32), // FIXME: Policy
bits: 4096,
}
}
}

26
src/symbols/wordpress/plugin.rs
View file

@ -6,7 +6,7 @@ use std::error::Error;
use std::fs::File as FsFile;
use std::io;
use std::io::{BufRead, BufReader};
use std::path::Path;
use std::path::{Path, PathBuf};
#[derive(Debug)]
pub struct Plugin<'a, P, N, R> {
@ -15,7 +15,7 @@ pub struct Plugin<'a, P, N, R> {
command_runner: &'a R,
}
impl<'a, P: AsRef<Path>, N: AsRef<str>, R> Plugin<'a, P, N, R> {
impl<'a, P: AsRef<Path>, N: AsRef<str>, R: CommandRunner> Plugin<'a, P, N, R> {
pub const fn new(base: P, name: N, command_runner: &'a R) -> Self {
Self {
base,
@ -24,13 +24,12 @@ impl<'a, P: AsRef<Path>, N: AsRef<str>, R> Plugin<'a, P, N, R> {
}
}
fn get_path(&self) -> Box<Path> {
fn get_path(&self) -> PathBuf {
self
.base
.as_ref()
.join("wp-content/plugins")
.join(self.name.as_ref())
.into()
}
}
@ -42,8 +41,8 @@ impl<P: AsRef<Path>, N: AsRef<str>, R: CommandRunner> Symbol for Plugin<'_, P, N
return Ok(false);
}
let path = base_path.join(self.name.as_ref().to_owned() + ".php");
let mut version: Option<Box<str>> = None;
let mut plugin_uri: Option<Box<str>> = None;
let mut version = String::new();
let mut plugin_uri = String::new();
match FsFile::open(path) {
Err(e) => {
// Check if file exists
@ -57,12 +56,11 @@ impl<P: AsRef<Path>, N: AsRef<str>, R: CommandRunner> Symbol for Plugin<'_, P, N
let reader = BufReader::new(file);
let regex = Regex::new("(?m)^(Plugin URI|Version): (.+)$")?;
for content in reader.lines() {
let content = content?;
for matches in regex.captures_iter(&content) {
for matches in regex.captures_iter(&(content?)) {
if &matches[1] == "Plugin URI" {
plugin_uri = Some(matches[2].into());
plugin_uri = matches[2].to_string();
} else {
version = Some(matches[2].into());
version = matches[2].to_string();
}
}
}
@ -77,14 +75,14 @@ impl<P: AsRef<Path>, N: AsRef<str>, R: CommandRunner> Symbol for Plugin<'_, P, N
format!(
r###"plugins={{"plugins":{{"{0}/{0}.php":{{"Version":"{1}", "PluginURI":"{2}"}}}}}}"###,
self.name.as_ref(),
version.as_deref().unwrap_or_default(),
plugin_uri.as_deref().unwrap_or_default()
version,
plugin_uri
),
"https://api.wordpress.org/plugins/update-check/1.1/",
],
)
.await?;
Ok(std::str::from_utf8(&upstream)?.contains(r###""plugins":[]"###))
Ok(String::from_utf8(upstream)?.contains(r###""plugins":[]"###))
}
async fn execute(&self) -> Result<(), Box<dyn Error>> {
@ -99,7 +97,7 @@ impl<P: AsRef<Path>, N: AsRef<str>, R: CommandRunner> Symbol for Plugin<'_, P, N
.await?;
self
.command_runner
.run_successfully("rm", args!["-rf", self.get_path().as_os_str()])
.run_successfully("rm", args!["-rf", self.get_path()])
.await?;
self
.command_runner

32
src/symbols/wordpress/translation.rs
View file

@ -8,6 +8,7 @@ use std::fs::File as FsFile;
use std::io;
use std::io::{BufRead, BufReader};
use std::path::Path;
use std::path::PathBuf;
#[derive(Debug)]
pub struct Translation<'a, C, D, R> {
@ -17,7 +18,7 @@ pub struct Translation<'a, C, D, R> {
command_runner: &'a R,
}
impl<'a, D, C: AsRef<str>, R> Translation<'a, C, D, R> {
impl<'a, D, C: AsRef<str>, R: CommandRunner> Translation<'a, C, D, R> {
pub const fn new(path: D, version: &'a str, locale: C, command_runner: &'a R) -> Self {
Self {
path,
@ -29,7 +30,7 @@ impl<'a, D, C: AsRef<str>, R> Translation<'a, C, D, R> {
}
impl<C: AsRef<str>, D: AsRef<Path>, R: CommandRunner> Translation<'_, C, D, R> {
fn get_pairs(&self) -> impl Iterator<Item = (Box<str>, Box<Path>)> + '_ {
fn get_pairs(&self) -> Vec<(String, PathBuf)> {
let version_x = self
.version
.trim_end_matches(|c: char| c.is_ascii_digit())
@ -41,19 +42,21 @@ impl<C: AsRef<str>, D: AsRef<Path>, R: CommandRunner> Translation<'_, C, D, R> {
} else {
locale.to_lowercase().replace('_', "-")
};
[
let mut res = vec![];
for &(in_slug, out_slug) in &[
("", ""),
("cc/", "continents-cities-"),
("admin/", "admin-"),
("admin/network/", "admin-network-"),
].into_iter().flat_map(move |(in_slug, out_slug)|{
["po", "mo"].map(|format|
(
format!("https://translate.wordpress.org/projects/wp/{version_x}/{in_slug}{path_locale}/default/export-translations?format={format}").into(),
self.path.as_ref().join(format!("{}{}.{}", out_slug, self.locale.as_ref(), format)).into()
))
] {
for format in &["po", "mo"] {
res.push((
format!("https://translate.wordpress.org/projects/wp/{version_x}/{in_slug}{path_locale}/default/export-translations?format={format}"),
[self.path.as_ref(), format!("{}{}.{}", out_slug, self.locale.as_ref(), format).as_ref()].iter().collect()
));
}
)
}
res
}
}
@ -77,7 +80,7 @@ impl<C: AsRef<str>, D: AsRef<Path>, R: CommandRunner> Symbol for Translation<'_,
let reader = BufReader::new(file);
for content in reader.lines() {
if let Some(match_result) = match_date.captures(&content?) {
newest = max(newest, match_result[1].into());
newest = max(newest, match_result[1].to_string());
break;
}
}
@ -96,7 +99,7 @@ impl<C: AsRef<str>, D: AsRef<Path>, R: CommandRunner> Symbol for Translation<'_,
)],
)
.await?;
Ok(std::str::from_utf8(&upstream)?.contains(&format!(
Ok(String::from_utf8(upstream)?.contains(&format!(
r###"language":"{}","version":"{}","updated":"{}"###,
self.locale.as_ref(),
self.version,
@ -108,10 +111,7 @@ impl<C: AsRef<str>, D: AsRef<Path>, R: CommandRunner> Symbol for Translation<'_,
for (source, target) in self.get_pairs() {
self
.command_runner
.run_successfully(
"curl",
args!["--compressed", "-o", target.as_os_str(), source.as_ref(),],
)
.run_successfully("curl", args!["--compressed", "-o", target, source,])
.await?;
}
Ok(())

5
src/templates/nginx/server.rs
View file

@ -1,5 +1,4 @@
use std::fmt::Display;
use std::num::NonZeroUsize;
use std::path::Path;
#[must_use]
@ -102,11 +101,11 @@ impl<T: AsRef<Path>> SocketSpec for T {
}
#[derive(Debug)]
pub struct LocalTcpSocket(NonZeroUsize);
pub struct LocalTcpSocket(usize);
impl LocalTcpSocket {
#[must_use]
pub const fn new(x: NonZeroUsize) -> Self {
pub const fn new(x: usize) -> Self {
Self(x)
}
}

9
src/templates/php.rs
View file

@ -1,11 +1,10 @@
use std::fmt::{Display, Error, Formatter};
use std::num::NonZeroUsize;
use std::path::Path;
#[derive(Clone, Debug, PartialEq, Hash, Eq)]
pub struct FpmPoolConfig {
max_children: NonZeroUsize,
custom: Option<Box<str>>,
max_children: usize,
custom: Option<String>,
}
impl Display for FpmPoolConfig {
@ -20,14 +19,14 @@ impl Display for FpmPoolConfig {
impl From<usize> for FpmPoolConfig {
fn from(max_children: usize) -> Self {
Self {
max_children: NonZeroUsize::try_from(max_children).unwrap(),
max_children,
custom: None,
}
}
}
impl FpmPoolConfig {
pub fn new(max_children: NonZeroUsize, custom: impl Into<Box<str>>) -> Self {
pub fn new(max_children: usize, custom: impl Into<String>) -> Self {
Self {
max_children,
custom: Some(custom.into()),

6
tests/file.rs
View file

@ -3,7 +3,7 @@ use schematics::symbols::file::File as FileSymbol;
use schematics::symbols::Symbol;
use std::fs::File;
use std::io::Write;
use std::path::Path;
use std::path::{Path, PathBuf};
use tempfile::{tempdir, TempDir};
fn get_dir(content: Option<&str>) -> TempDir {
@ -19,8 +19,8 @@ fn get_dir(content: Option<&str>) -> TempDir {
tmp_dir
}
fn get_symbol(path: &Path) -> FileSymbol<Box<Path>, &str> {
FileSymbol::new(path.join("filename").into(), "target content")
fn get_symbol(path: &Path) -> FileSymbol<PathBuf, &str> {
FileSymbol::new(path.join("filename"), "target content")
}
// Normal cases

7
tests/setup.rs
View file

@ -9,7 +9,6 @@ use schematics::SymbolRunner;
use slog::{info, Logger as SlogLogger};
use std::error::Error;
use std::fmt::Debug;
use std::path::Path;
use std::time::Duration;
#[derive(Clone, Debug)]
@ -61,7 +60,7 @@ fn test(
#[test]
fn can_create_an_acme_user() {
let mut result = test(1, |setup| {
assert_eq!(&*(run(setup.add(AcmeUser)).unwrap().0).0, "acme");
assert_eq!((run(setup.add(AcmeUser)).unwrap().0).0, "acme");
});
let entry = result
.pop()
@ -134,8 +133,8 @@ fn can_create_an_acme_cert() {
#[test]
fn can_create_a_git_checkout() {
let mut result = test(1, |setup| {
run(setup.add(GitCheckout::new(
"/tmp/somepath".as_ref() as &Path,
run(setup.add(GitCheckout(
"/tmp/somepath".into(),
"/tmp/some_src_repo",
"master",
)))

10
tests/storage.rs
View file

@ -16,7 +16,7 @@ fn get_dir<'a, I: IntoIterator<Item = &'a &'a str>>(content: I) -> TempDir {
}
fn get_storage(path: &Path) -> SimpleStorage {
SimpleStorage::new(path.join("_filename").into())
SimpleStorage::new(path.join("_filename"))
}
// Normal cases
@ -33,7 +33,7 @@ fn single_file() {
);
assert_eq!(
dir.path().join("_filename").join("12345"),
Path::new(&*storage.read_filename().unwrap())
Path::new(&storage.read_filename().unwrap())
);
assert_eq!(storage.recent_date().unwrap(), 12345);
}
@ -50,7 +50,7 @@ fn two_files() {
);
assert_eq!(
dir.path().join("_filename").join("23456"),
Path::new(&*storage.read_filename().unwrap())
Path::new(&storage.read_filename().unwrap())
);
assert_eq!(storage.recent_date().unwrap(), 23456);
}
@ -67,7 +67,7 @@ fn another_two_files() {
);
assert_eq!(
dir.path().join("_filename").join("23456"),
Path::new(&*storage.read_filename().unwrap())
Path::new(&storage.read_filename().unwrap())
);
assert_eq!(storage.recent_date().unwrap(), 23456);
}
@ -84,7 +84,7 @@ fn three_files() {
);
assert_eq!(
dir.path().join("_filename").join("23456"),
Path::new(&*storage.read_filename().unwrap())
Path::new(&storage.read_filename().unwrap())
);
assert_eq!(storage.recent_date().unwrap(), 23456);
}