Browse Source

Switch CommandRunner to OsStr

master
Adrian Heine 7 years ago
parent
commit
3b45b0f77c
  1. 25
      src/command_runner.rs
  2. 26
      src/symbols/acme/account_key.rs
  3. 12
      src/symbols/acme/cert.rs
  4. 14
      src/symbols/acme/chain.rs
  5. 2
      src/symbols/acme/mod.rs
  6. 66
      src/symbols/acme/user.rs
  7. 14
      src/symbols/git/checkout.rs
  8. 14
      src/symbols/git/submodules.rs
  9. 12
      src/symbols/mariadb/database.rs
  10. 12
      src/symbols/mariadb/database_dump.rs
  11. 12
      src/symbols/mariadb/user.rs
  12. 34
      src/symbols/nginx/server.rs
  13. 12
      src/symbols/npm.rs
  14. 12
      src/symbols/owner.rs
  15. 12
      src/symbols/stored_directory.rs
  16. 12
      src/symbols/systemd/reload.rs
  17. 12
      src/symbols/systemd/user_session.rs
  18. 12
      src/symbols/tls/csr.rs
  19. 12
      src/symbols/tls/key.rs
  20. 12
      src/symbols/tls/self_signed_cert.rs
  21. 22
      src/symbols/user.rs
  22. 5
      src/symbols/wordpress/plugin.rs

25
src/command_runner.rs

@ -1,25 +1,26 @@
use std::error::Error; use std::error::Error;
use std::ffi::OsStr;
use std::io::Result as IoResult; use std::io::Result as IoResult;
use std::process::Command; use std::process::Command;
use std::process::Output; use std::process::Output;
pub trait CommandRunner { pub trait CommandRunner {
fn run_with_args(&self, program: &str, args: &[&str]) -> IoResult<Output>;
fn get_output(&self, program: &str, args: &[&str]) -> Result<Vec<u8>, Box<Error>> {
fn run_with_args<S: AsRef<OsStr> + ?Sized>(&self, program: &str, args: &[&S]) -> IoResult<Output>;
fn get_output<S: AsRef<OsStr> + ?Sized>(&self, program: &str, args: &[&S]) -> Result<Vec<u8>, Box<Error>> {
let output = try!(self.run_with_args(program, args)); let output = try!(self.run_with_args(program, args));
if !output.status.success() { if !output.status.success() {
return Err(try!(String::from_utf8(output.stderr)).into()); return Err(try!(String::from_utf8(output.stderr)).into());
} }
Ok(output.stdout) Ok(output.stdout)
} }
fn get_stderr(&self, program: &str, args: &[&str]) -> Result<Vec<u8>, Box<Error>> {
fn get_stderr<S: AsRef<OsStr> + ?Sized>(&self, program: &str, args: &[&S]) -> Result<Vec<u8>, Box<Error>> {
let output = try!(self.run_with_args(program, args)); let output = try!(self.run_with_args(program, args));
if !output.status.success() { if !output.status.success() {
return Err(try!(String::from_utf8(output.stderr)).into()); return Err(try!(String::from_utf8(output.stderr)).into());
} }
Ok(output.stderr) Ok(output.stderr)
} }
fn run_successfully(&self, program: &str, args: &[&str]) -> Result<(), Box<Error>> {
fn run_successfully<S: AsRef<OsStr> + ?Sized>(&self, program: &str, args: &[&S]) -> Result<(), Box<Error>> {
let output = try!(self.run_with_args(program, args)); let output = try!(self.run_with_args(program, args));
if output.status.success() { if output.status.success() {
Ok(()) Ok(())
@ -33,9 +34,9 @@ pub trait CommandRunner {
pub struct StdCommandRunner; pub struct StdCommandRunner;
impl CommandRunner for StdCommandRunner { impl CommandRunner for StdCommandRunner {
fn run_with_args(&self, program: &str, args: &[&str]) -> IoResult<Output> {
fn run_with_args<S: AsRef<OsStr> + ?Sized>(&self, program: &str, args: &[&S]) -> IoResult<Output> {
// FIXME: logger // FIXME: logger
println!("{} {:?}", program, args);
//println!("{} {:?}", program, args);
let res = Command::new(program).args(args).output(); let res = Command::new(program).args(args).output();
println!("{:?}", res); println!("{:?}", res);
res res
@ -81,11 +82,11 @@ impl<'a> Drop for TempSetEnv<'a> {
} }
impl<'a, C> CommandRunner for SetuidCommandRunner<'a, C> where C: 'a + CommandRunner { impl<'a, C> CommandRunner for SetuidCommandRunner<'a, C> where C: 'a + CommandRunner {
fn run_with_args(&self, program: &str, args: &[&str]) -> IoResult<Output> {
fn run_with_args<S: AsRef<OsStr> + ?Sized>(&self, program: &str, args: &[&S]) -> IoResult<Output> {
let uid = get_user_by_name(self.user_name).expect("User does not exist").uid(); let uid = get_user_by_name(self.user_name).expect("User does not exist").uid();
let set_home = TempSetEnv::new("HOME", format!("/home/{}", self.user_name)); let set_home = TempSetEnv::new("HOME", format!("/home/{}", self.user_name));
let set_dbus = TempSetEnv::new("XDG_RUNTIME_DIR", format!("/run/user/{}", uid)); let set_dbus = TempSetEnv::new("XDG_RUNTIME_DIR", format!("/run/user/{}", uid));
println!("{} {:?}", program, args);
//println!("{} {:?}", program, args);
let res = Command::new(program).uid(uid).gid(uid).args(args).output(); let res = Command::new(program).uid(uid).gid(uid).args(args).output();
println!("{:?}", res); println!("{:?}", res);
res res
@ -110,9 +111,11 @@ impl<'a, C> SuCommandRunner<'a, C> where C: 'a + CommandRunner {
// Su doesn't set XDG_RUNTIME_DIR // Su doesn't set XDG_RUNTIME_DIR
// https://github.com/systemd/systemd/blob/master/src/login/pam_systemd.c#L439 // https://github.com/systemd/systemd/blob/master/src/login/pam_systemd.c#L439
impl<'a, C> CommandRunner for SuCommandRunner<'a, C> where C: 'a + CommandRunner { impl<'a, C> CommandRunner for SuCommandRunner<'a, C> where C: 'a + CommandRunner {
fn run_with_args(&self, program: &str, args: &[&str]) -> IoResult<Output> {
let mut new_args = vec![self.user_name, "-s", "/usr/bin/env", "--", program];
new_args.extend_from_slice(args);
fn run_with_args<S: AsRef<OsStr> + ?Sized>(&self, program: &str, args: &[&S]) -> IoResult<Output> {
let raw_new_args = [self.user_name, "-s", "/usr/bin/env", "--", program];
let mut new_args: Vec<&OsStr> = raw_new_args.iter().map(|s| s.as_ref()).collect();
let old_args: Vec<&OsStr> = args.iter().map(|s| s.as_ref()).collect();
new_args.extend_from_slice(&old_args);
self.command_runner.run_with_args("su", &new_args) self.command_runner.run_with_args("su", &new_args)
} }
} }

26
src/symbols/acme/account_key.rs

@ -7,20 +7,20 @@ use command_runner::CommandRunner;
use resources::Resource; use resources::Resource;
use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner}; use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner};
pub struct AcmeAccountKey<'a> {
path: Cow<'a, str>,
command_runner: &'a CommandRunner
pub struct AcmeAccountKey<'a, C: 'a + CommandRunner> {
path: Cow<'a, Path>,
command_runner: &'a C
} }
impl<'a> AcmeAccountKey<'a> {
pub fn new(path: Cow<'a, str>, command_runner: &'a CommandRunner) -> AcmeAccountKey<'a> {
impl<'a, C: CommandRunner> AcmeAccountKey<'a, C> {
pub fn new(path: Cow<'a, Path>, command_runner: &'a C) -> Self {
AcmeAccountKey { AcmeAccountKey {
path: path, path: path,
command_runner: command_runner command_runner: command_runner
} }
} }
fn get_path(&self) -> &str {
fn get_path(&self) -> &Path {
self.path.borrow() self.path.borrow()
} }
@ -29,27 +29,27 @@ impl<'a> AcmeAccountKey<'a> {
} }
} }
impl<'a> fmt::Display for AcmeAccountKey<'a> {
impl<'a, C: CommandRunner> fmt::Display for AcmeAccountKey<'a, C> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "AcmeAccountKey {}", self.path)
write!(f, "AcmeAccountKey {}", self.get_path().display())
} }
} }
impl<'a> Symbol for AcmeAccountKey<'a> {
impl<'a, C: CommandRunner> Symbol for AcmeAccountKey<'a, C> {
fn target_reached(&self) -> Result<bool, Box<Error>> { fn target_reached(&self) -> Result<bool, Box<Error>> {
if !Path::new(self.get_path()).exists() {
if !self.get_path().exists() {
return Ok(false); return Ok(false);
} }
let stdout = try!(self.command_runner.get_output("openssl", &["rsa", "-in", self.get_path(), "-noout", "-check", "-text"]));
let stdout = try!(self.command_runner.get_output("openssl", &["rsa".as_ref(), "-in".as_ref(), self.get_path().as_os_str(), "-noout".as_ref(), "-check".as_ref(), "-text".as_ref()]));
Ok(stdout.starts_with(&format!("Private-Key: ({} bit)\n", self.get_bytes()).as_bytes())) Ok(stdout.starts_with(&format!("Private-Key: ({} bit)\n", self.get_bytes()).as_bytes()))
} }
fn execute(&self) -> Result<(), Box<Error>> { fn execute(&self) -> Result<(), Box<Error>> {
self.command_runner.run_successfully("openssl", &["genrsa", "-out", self.get_path(), &self.get_bytes().to_string()])
self.command_runner.run_successfully("openssl", &["genrsa".as_ref(), "-out".as_ref(), self.get_path().as_os_str(), self.get_bytes().to_string().as_ref()])
} }
fn get_prerequisites(&self) -> Vec<Resource> { fn get_prerequisites(&self) -> Vec<Resource> {
vec![ Resource::new("dir", Path::new(self.get_path()).parent().unwrap().to_string_lossy() ) ]
vec![ Resource::new("dir", self.get_path().parent().unwrap().to_string_lossy() ) ]
} }
fn as_action<'b>(&'b self, runner: &'b SymbolRunner) -> Box<Action + 'b> { fn as_action<'b>(&'b self, runner: &'b SymbolRunner) -> Box<Action + 'b> {

12
src/symbols/acme/cert.rs

@ -9,13 +9,13 @@ use command_runner::CommandRunner;
use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner}; use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner};
use resources::Resource; use resources::Resource;
pub struct AcmeCert<'a> {
pub struct AcmeCert<'a, C: 'a + CommandRunner> {
domain: Cow<'a, str>, domain: Cow<'a, str>,
command_runner: &'a CommandRunner
command_runner: &'a C
} }
impl<'a> AcmeCert<'a> {
pub fn new(domain: Cow<'a, str>, command_runner: &'a CommandRunner) -> AcmeCert<'a> {
impl<'a, C: CommandRunner> AcmeCert<'a, C> {
pub fn new(domain: Cow<'a, str>, command_runner: &'a C) -> Self {
AcmeCert { AcmeCert {
domain: domain, domain: domain,
command_runner: command_runner command_runner: command_runner
@ -31,7 +31,7 @@ impl<'a> AcmeCert<'a> {
} }
} }
impl<'a> fmt::Display for AcmeCert<'a> {
impl<'a, C: CommandRunner> fmt::Display for AcmeCert<'a, C> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "AcmeCert {}", self.domain) write!(f, "AcmeCert {}", self.domain)
} }
@ -39,7 +39,7 @@ impl<'a> fmt::Display for AcmeCert<'a> {
const DAYS_IN_SECONDS: u32 = 24*60*60; const DAYS_IN_SECONDS: u32 = 24*60*60;
impl<'a> Symbol for AcmeCert<'a> {
impl<'a, C: CommandRunner> Symbol for AcmeCert<'a, C> {
fn target_reached(&self) -> Result<bool, Box<Error>> { fn target_reached(&self) -> Result<bool, Box<Error>> {
if !Path::new(&self.get_cert_path()).exists() { if !Path::new(&self.get_cert_path()).exists() {
return Ok(false); return Ok(false);

14
src/symbols/acme/chain.rs

@ -9,13 +9,13 @@ use command_runner::CommandRunner;
use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner}; use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner};
use resources::Resource; use resources::Resource;
pub struct AcmeCertChain<'a> {
pub struct AcmeCertChain<'a, C: 'a + CommandRunner> {
domain: Cow<'a, str>, domain: Cow<'a, str>,
command_runner: &'a CommandRunner
command_runner: &'a C
} }
impl<'a> AcmeCertChain<'a> {
pub fn new(domain: Cow<'a, str>, command_runner: &'a CommandRunner) -> AcmeCertChain<'a> {
impl<'a, C: CommandRunner> AcmeCertChain<'a, C> {
pub fn new(domain: Cow<'a, str>, command_runner: &'a C) -> Self {
AcmeCertChain { AcmeCertChain {
domain: domain, domain: domain,
command_runner: command_runner command_runner: command_runner
@ -31,7 +31,7 @@ impl<'a> AcmeCertChain<'a> {
} }
} }
impl<'a> fmt::Display for AcmeCertChain<'a> {
impl<'a, C: CommandRunner> fmt::Display for AcmeCertChain<'a, C> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "AcmeCertChain {}", self.domain) write!(f, "AcmeCertChain {}", self.domain)
} }
@ -39,7 +39,7 @@ impl<'a> fmt::Display for AcmeCertChain<'a> {
const DAYS_IN_SECONDS: u32 = 24*60*60; const DAYS_IN_SECONDS: u32 = 24*60*60;
impl<'a> Symbol for AcmeCertChain<'a> {
impl<'a, C: CommandRunner> Symbol for AcmeCertChain<'a, C> {
fn target_reached(&self) -> Result<bool, Box<Error>> { fn target_reached(&self) -> Result<bool, Box<Error>> {
if !Path::new(&self.get_cert_chain_path()).exists() { if !Path::new(&self.get_cert_chain_path()).exists() {
return Ok(false); return Ok(false);
@ -54,7 +54,7 @@ impl<'a> Symbol for AcmeCertChain<'a> {
} }
fn execute(&self) -> Result<(), Box<Error>> { fn execute(&self) -> Result<(), Box<Error>> {
let output = try!(self.command_runner.get_output("cat", &[&self.get_single_cert_path(), "/home/acme/lets_encrypt_x3_cross_signed.pem"]));
let output = try!(self.command_runner.get_output("cat", &[self.get_single_cert_path().as_ref(), "/home/acme/lets_encrypt_x3_cross_signed.pem"]));
let mut file = try!(FsFile::create(self.get_cert_chain_path())); let mut file = try!(FsFile::create(self.get_cert_chain_path()));
try!(file.write_all(&output)); try!(file.write_all(&output));
Ok(()) Ok(())

2
src/symbols/acme/mod.rs

@ -1,7 +1,9 @@
mod account_key; mod account_key;
mod cert; mod cert;
mod chain; mod chain;
mod user;
pub use self::account_key::AcmeAccountKey; pub use self::account_key::AcmeAccountKey;
pub use self::cert::AcmeCert; pub use self::cert::AcmeCert;
pub use self::chain::AcmeCertChain; pub use self::chain::AcmeCertChain;
pub use self::user::new as newAcmeUser;

66
src/symbols/acme/user.rs

@ -0,0 +1,66 @@
use std::borrow::{Borrow, Cow};
use std::error::Error;
use std::fmt;
use std::ops::Deref;
use std::path::PathBuf;
use resources::Resource;
use command_runner::CommandRunner;
use symbols::{Action, OwnedSymbolAction, SymbolAction, SymbolRunner, Symbol};
use symbols::acme::AcmeAccountKey;
use symbols::dir::Dir;
use symbols::file::File;
use symbols::hook::Hook;
use symbols::list::List;
use symbols::owner::Owner;
pub struct AcmeUser<'a>(Cow<'a, str>);
impl<'a> AcmeUser<'a> {
pub fn new<S: Into<Cow<'a, str>>>(user_name: S) -> Self {
AcmeUser(user_name.into())
}
}
impl<'a> Symbol for AcmeUser<'a> {
fn target_reached(&self) -> Result<bool, Box<Error>> {
Ok(false)
}
fn execute(&self) -> Result<(), Box<Error>> {
Ok(())
}
fn get_prerequisites(&self) -> Vec<Resource> {
vec![]
}
fn provides(&self) -> Option<Vec<Resource>> {
None
}
fn as_action<'b>(&'b self, runner: &'b SymbolRunner) -> Box<Action + 'b> {
Box::new(SymbolAction::new(runner, self))
}
fn into_action<'b>(self: Box<Self>, runner: &'b SymbolRunner) -> Box<Action + 'b> where Self: 'b {
Box::new(OwnedSymbolAction::new(runner, *self))
}
}
impl<'a> fmt::Display for AcmeUser<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "AcmeUser {}", self.0)
}
}
pub fn new<'a, S: Into<Cow<'a, str>>, C: CommandRunner, P: 'a + Deref<Target=str>>(command_runner: &'a C, cert: P, user_name: S) -> Box<Symbol + 'a> { // impl trait
let user_name_cow = user_name.into();
let account_key_file: PathBuf = ["home", user_name_cow.borrow(), "account.key"].iter().collect();
Box::new(List::new(vec![
Box::new(AcmeAccountKey::new(account_key_file.clone().into(), command_runner)),
Box::new(Owner::new(account_key_file.to_string_lossy().into_owned(), user_name_cow.clone(), command_runner)),
Box::new(Dir::new("/home/acme/challenges")),
Box::new(Owner::new("/home/acme/challenges", user_name_cow.clone(), command_runner)),
Box::new(Dir::new("/etc/ssl/local_certs")),
Box::new(Owner::new("/etc/ssl/local_certs", user_name_cow, command_runner)),
Box::new(File::new("/home/acme/lets_encrypt_x3_cross_signed.pem", cert))
]))
}

14
src/symbols/git/checkout.rs

@ -7,15 +7,15 @@ use command_runner::CommandRunner;
use resources::Resource; use resources::Resource;
use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner}; use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner};
pub struct GitCheckout<'a> {
pub struct GitCheckout<'a, C: 'a + CommandRunner> {
target: &'a str, target: &'a str,
source: &'a str, source: &'a str,
branch: &'a str, branch: &'a str,
command_runner: &'a CommandRunner
command_runner: &'a C
} }
impl<'a> GitCheckout<'a> {
pub fn new(target: &'a str, source: &'a str, branch: &'a str, command_runner: &'a CommandRunner) -> GitCheckout<'a> {
impl<'a, C: CommandRunner> GitCheckout<'a, C> {
pub fn new(target: &'a str, source: &'a str, branch: &'a str, command_runner: &'a C) -> Self {
GitCheckout { GitCheckout {
target: target, target: target,
source: source, source: source,
@ -25,7 +25,7 @@ impl<'a> GitCheckout<'a> {
} }
} }
impl<'a> fmt::Display for GitCheckout<'a> {
impl<'a, C: CommandRunner> fmt::Display for GitCheckout<'a, C> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "Checkout {} (branch {}) into {}", self.source, self.branch, self.target) write!(f, "Checkout {} (branch {}) into {}", self.source, self.branch, self.target)
} }
@ -33,7 +33,7 @@ impl<'a> fmt::Display for GitCheckout<'a> {
use std::fs::metadata; use std::fs::metadata;
impl<'a> GitCheckout<'a> {
impl<'a, C: CommandRunner> GitCheckout<'a, C> {
fn _run_in_target_repo(&self, args: &[&str]) -> Result<Vec<u8>, Box<Error>> { fn _run_in_target_repo(&self, args: &[&str]) -> Result<Vec<u8>, Box<Error>> {
let mut new_args = vec!["-C", self.target]; let mut new_args = vec!["-C", self.target];
new_args.extend_from_slice(args); new_args.extend_from_slice(args);
@ -41,7 +41,7 @@ impl<'a> GitCheckout<'a> {
} }
} }
impl<'a> Symbol for GitCheckout<'a> {
impl<'a, C: CommandRunner> Symbol for GitCheckout<'a, C> {
fn target_reached(&self) -> Result<bool, Box<Error>> { fn target_reached(&self) -> Result<bool, Box<Error>> {
if let Err(e) = metadata(self.target) { if let Err(e) = metadata(self.target) {
return if e.kind() == io::ErrorKind::NotFound { return if e.kind() == io::ErrorKind::NotFound {

14
src/symbols/git/submodules.rs

@ -5,13 +5,13 @@ use std::path::Path;
use command_runner::CommandRunner; use command_runner::CommandRunner;
use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner}; use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner};
pub struct GitSubmodules<'a> {
pub struct GitSubmodules<'a, C: 'a + CommandRunner> {
target: &'a str, target: &'a str,
command_runner: &'a CommandRunner
command_runner: &'a C
} }
impl<'a> GitSubmodules<'a> {
pub fn new(target: &'a str, command_runner: &'a CommandRunner) -> GitSubmodules<'a> {
impl<'a, C: CommandRunner> GitSubmodules<'a, C> {
pub fn new(target: &'a str, command_runner: &'a C) -> Self {
GitSubmodules { GitSubmodules {
target: target, target: target,
command_runner: command_runner command_runner: command_runner
@ -19,13 +19,13 @@ impl<'a> GitSubmodules<'a> {
} }
} }
impl<'a> fmt::Display for GitSubmodules<'a> {
impl<'a, C: CommandRunner> fmt::Display for GitSubmodules<'a, C> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "Submodules for {}", self.target) write!(f, "Submodules for {}", self.target)
} }
} }
impl<'a> GitSubmodules<'a> {
impl<'a, C: CommandRunner> GitSubmodules<'a, C> {
fn _run_in_target_repo(&self, args: &[&str]) -> Result<Vec<u8>, Box<Error>> { fn _run_in_target_repo(&self, args: &[&str]) -> Result<Vec<u8>, Box<Error>> {
let mut new_args = vec!["-C", self.target]; let mut new_args = vec!["-C", self.target];
new_args.extend_from_slice(args); new_args.extend_from_slice(args);
@ -33,7 +33,7 @@ impl<'a> GitSubmodules<'a> {
} }
} }
impl<'a> Symbol for GitSubmodules<'a> {
impl<'a, C: CommandRunner> Symbol for GitSubmodules<'a, C> {
fn target_reached(&self) -> Result<bool, Box<Error>> { fn target_reached(&self) -> Result<bool, Box<Error>> {
if !Path::new(self.target).exists() { if !Path::new(self.target).exists() {
return Ok(false); return Ok(false);

12
src/symbols/mariadb/database.rs

@ -5,14 +5,14 @@ use std::fmt;
use command_runner::CommandRunner; use command_runner::CommandRunner;
use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner}; use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner};
pub struct MariaDBDatabase<'a> {
pub struct MariaDBDatabase<'a, C: 'a + CommandRunner> {
db_name: Cow<'a, str>, db_name: Cow<'a, str>,
seed_file: Cow<'a, str>, seed_file: Cow<'a, str>,
command_runner: &'a CommandRunner
command_runner: &'a C
} }
impl<'a> MariaDBDatabase<'a> {
pub fn new(db_name: Cow<'a, str>, seed_file: Cow<'a, str>, command_runner: &'a CommandRunner) -> MariaDBDatabase<'a> {
impl<'a, C: CommandRunner> MariaDBDatabase<'a, C> {
pub fn new(db_name: Cow<'a, str>, seed_file: Cow<'a, str>, command_runner: &'a C) -> Self {
MariaDBDatabase { MariaDBDatabase {
db_name: db_name, db_name: db_name,
seed_file: seed_file, seed_file: seed_file,
@ -26,13 +26,13 @@ impl<'a> MariaDBDatabase<'a> {
} }
} }
impl<'a> fmt::Display for MariaDBDatabase<'a> {
impl<'a, C: CommandRunner> fmt::Display for MariaDBDatabase<'a, C> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "MariaDB Database {}", self.db_name) write!(f, "MariaDB Database {}", self.db_name)
} }
} }
impl<'a> Symbol for MariaDBDatabase<'a> {
impl<'a, C: CommandRunner> Symbol for MariaDBDatabase<'a, C> {
fn target_reached(&self) -> Result<bool, Box<Error>> { fn target_reached(&self) -> Result<bool, Box<Error>> {
Ok(try!(self.run_sql(&format!("SHOW DATABASES LIKE '{}'", self.db_name))).trim_right() == self.db_name) Ok(try!(self.run_sql(&format!("SHOW DATABASES LIKE '{}'", self.db_name))).trim_right() == self.db_name)
} }

12
src/symbols/mariadb/database_dump.rs

@ -7,14 +7,14 @@ use command_runner::CommandRunner;
use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner}; use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner};
use storage::Storage; use storage::Storage;
pub struct DatabaseDump<'a, S> where S: Storage {
pub struct DatabaseDump<'a, C, S> where C: 'a + CommandRunner, S: Storage {
db_name: Cow<'a, str>, db_name: Cow<'a, str>,
storage: S, storage: S,
command_runner: &'a CommandRunner
command_runner: &'a C
} }
impl<'a, S> DatabaseDump<'a, S> where S: Storage {
pub fn new(db_name: Cow<'a, str>, storage: S, command_runner: &'a CommandRunner) -> Self {
impl<'a, C: CommandRunner, S> DatabaseDump<'a, C, S> where S: Storage {
pub fn new(db_name: Cow<'a, str>, storage: S, command_runner: &'a C) -> Self {
DatabaseDump { DatabaseDump {
db_name: db_name, db_name: db_name,
storage: storage, storage: storage,
@ -28,13 +28,13 @@ impl<'a, S> DatabaseDump<'a, S> where S: Storage {
} }
} }
impl<'a, S> fmt::Display for DatabaseDump<'a, S> where S: Storage {
impl<'a, C: CommandRunner, S> fmt::Display for DatabaseDump<'a, C, S> where S: Storage {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "Dump MariaDB Database {}", self.db_name) write!(f, "Dump MariaDB Database {}", self.db_name)
} }
} }
impl<'a, S> Symbol for DatabaseDump<'a, S> where S: Storage {
impl<'a, C: CommandRunner, S> Symbol for DatabaseDump<'a, C, S> where S: Storage {
fn target_reached(&self) -> Result<bool, Box<Error>> { fn target_reached(&self) -> Result<bool, Box<Error>> {
let dump_date = try!(self.storage.recent_date()); let dump_date = try!(self.storage.recent_date());
let modified_date = try!(self.run_sql(&format!("select UNIX_TIMESTAMP(MAX(UPDATE_TIME)) from information_schema.tables WHERE table_schema = '{}'", self.db_name))); let modified_date = try!(self.run_sql(&format!("select UNIX_TIMESTAMP(MAX(UPDATE_TIME)) from information_schema.tables WHERE table_schema = '{}'", self.db_name)));

12
src/symbols/mariadb/user.rs

@ -6,13 +6,13 @@ use command_runner::CommandRunner;
use resources::Resource; use resources::Resource;
use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner}; use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner};
pub struct MariaDBUser<'a> {
pub struct MariaDBUser<'a, C: 'a + CommandRunner> {
user_name: Cow<'a, str>, user_name: Cow<'a, str>,
command_runner: &'a CommandRunner
command_runner: &'a C
} }
impl<'a> MariaDBUser<'a> {
pub fn new(user_name: Cow<'a, str>, command_runner: &'a CommandRunner) -> MariaDBUser<'a> {
impl<'a, C: CommandRunner> MariaDBUser<'a, C> {
pub fn new(user_name: Cow<'a, str>, command_runner: &'a C) -> Self {
MariaDBUser { MariaDBUser {
user_name: user_name, user_name: user_name,
command_runner: command_runner command_runner: command_runner
@ -25,13 +25,13 @@ impl<'a> MariaDBUser<'a> {
} }
} }
impl<'a> fmt::Display for MariaDBUser<'a> {
impl<'a, C: CommandRunner> fmt::Display for MariaDBUser<'a, C> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "MariaDB User {}", self.user_name) write!(f, "MariaDB User {}", self.user_name)
} }
} }
impl<'a> Symbol for MariaDBUser<'a> {
impl<'a, C: CommandRunner> Symbol for MariaDBUser<'a, C> {
fn target_reached(&self) -> Result<bool, Box<Error>> { fn target_reached(&self) -> Result<bool, Box<Error>> {
Ok(try!(self.run_sql(&format!("SELECT User FROM mysql.user WHERE User = '{}' AND plugin = 'unix_socket'", self.user_name))).trim_right() == self.user_name) Ok(try!(self.run_sql(&format!("SELECT User FROM mysql.user WHERE User = '{}' AND plugin = 'unix_socket'", self.user_name))).trim_right() == self.user_name)
} }

34
src/symbols/nginx/server.rs

@ -41,15 +41,14 @@ impl<E: Error> fmt::Display for NginxServerError<E> {
} }
} }
pub struct NginxServer<'a, C> where C: Deref<Target=str> {
command_runner: &'a CommandRunner,
file: FileSymbol<C, Cow<'a, str>>,
pub struct NginxServer<'a, C: 'a + CommandRunner, T> where T: Deref<Target=str> {
command_runner: &'a C,
file: FileSymbol<T, Cow<'a, str>>,
} }
use std::borrow::Cow; use std::borrow::Cow;
impl<'a> NginxServer<'a, String> {
pub fn server_config(domain: &str, content: &str) -> String {
pub fn server_config(domain: &str, content: &str) -> String {
format!("server {{ format!("server {{
listen 80; listen 80;
server_name {0}; server_name {0};
@ -73,16 +72,17 @@ server {{
{1} {1}
}} }}
", domain, content) ", domain, content)
}
}
pub fn new_redir(domain: &'a str, target: &'a str, command_runner: &'a CommandRunner) -> Self {
let content = NginxServer::server_config(domain, &format!("location / {{
impl<'a, C: CommandRunner> NginxServer<'a, C, String> {
pub fn new_redir(domain: &'a str, target: &'a str, command_runner: &'a C) -> Self {
let content = server_config(domain, &format!("location / {{
return 301 $scheme://{}$request_uri; return 301 $scheme://{}$request_uri;
}}", target)); }}", target));
NginxServer::new(domain, content, command_runner) NginxServer::new(domain, content, command_runner)
} }
pub fn new_proxy(domain: &'a str, socket_path: &'a str, static_path: &'a str, command_runner: &'a CommandRunner) -> Self {
pub fn new_proxy(domain: &'a str, socket_path: &'a str, static_path: &'a str, command_runner: &'a C) -> Self {
let proxy_content = format!("location / {{ let proxy_content = format!("location / {{
try_files $uri @proxy; try_files $uri @proxy;
}} }}
@ -93,15 +93,15 @@ location @proxy {{
proxy_redirect off; proxy_redirect off;
}}", socket_path); }}", socket_path);
let content = NginxServer::server_config(domain, &format!("
let content = server_config(domain, &format!("
root {}; root {};
{} {}
", static_path, proxy_content)); ", static_path, proxy_content));
NginxServer::new(domain, content, command_runner) NginxServer::new(domain, content, command_runner)
} }
pub fn new_php(domain: &'a str, socket_path: &'a str, static_path: &'a str, command_runner: &'a CommandRunner) -> Self {
let content = NginxServer::server_config(domain, &format!("
pub fn new_php(domain: &'a str, socket_path: &'a str, static_path: &'a str, command_runner: &'a C) -> Self {
let content = server_config(domain, &format!("
root {}; root {};
index index.html index.php; index index.html index.php;
location ~ [^/]\\.php(/|$) {{ location ~ [^/]\\.php(/|$) {{
@ -112,15 +112,15 @@ location @proxy {{
NginxServer::new(domain, content, command_runner) NginxServer::new(domain, content, command_runner)
} }
pub fn new_static(domain: &'a str, static_path: &'a str, command_runner: &'a CommandRunner) -> Self {
let content = NginxServer::server_config(domain, &format!("
pub fn new_static(domain: &'a str, static_path: &'a str, command_runner: &'a C) -> Self {
let content = server_config(domain, &format!("
root {}; root {};
try_files $uri $uri/ $uri.html =404; try_files $uri $uri/ $uri.html =404;
", static_path)); ", static_path));
NginxServer::new(domain, content, command_runner) NginxServer::new(domain, content, command_runner)
} }
pub fn new(domain: &'a str, content: String, command_runner: &'a CommandRunner) -> Self {
pub fn new(domain: &'a str, content: String, command_runner: &'a C) -> Self {
let file_path: Cow<str> = Cow::from(String::from("/etc/nginx/sites-enabled/") + domain); let file_path: Cow<str> = Cow::from(String::from("/etc/nginx/sites-enabled/") + domain);
NginxServer { NginxServer {
command_runner: command_runner, command_runner: command_runner,
@ -129,7 +129,7 @@ location @proxy {{
} }
} }
impl<'a, C> Symbol for NginxServer<'a, C> where C: Deref<Target=str> {
impl<'a, C: CommandRunner, T> Symbol for NginxServer<'a, C, T> where T: Deref<Target=str> {
fn target_reached(&self) -> Result<bool, Box<Error>> { fn target_reached(&self) -> Result<bool, Box<Error>> {
if !try!(self.file.target_reached()) { if !try!(self.file.target_reached()) {
return Ok(false); return Ok(false);
@ -156,7 +156,7 @@ impl<'a, C> Symbol for NginxServer<'a, C> where C: Deref<Target=str> {
} }
} }
impl<'a, C> fmt::Display for NginxServer<'a, C> where C: Deref<Target=str> {
impl<'a, C: CommandRunner, T> fmt::Display for NginxServer<'a, C, T> where T: Deref<Target=str> {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(),fmt::Error>{ fn fmt(&self, f: &mut fmt::Formatter) -> Result<(),fmt::Error>{
write!(f, "Nginx server config") write!(f, "Nginx server config")
} }

12
src/symbols/npm.rs

@ -5,13 +5,13 @@ use std::path::Path;
use command_runner::CommandRunner; use command_runner::CommandRunner;
use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner}; use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner};
pub struct NpmInstall<'a> {
pub struct NpmInstall<'a, C: 'a + CommandRunner> {
target: &'a str, target: &'a str,
command_runner: &'a CommandRunner
command_runner: &'a C
} }
impl<'a> NpmInstall<'a> {
pub fn new(target: &'a str, command_runner: &'a CommandRunner) -> NpmInstall<'a> {
impl<'a, C: CommandRunner> NpmInstall<'a, C> {
pub fn new(target: &'a str, command_runner: &'a C) -> Self {
NpmInstall { NpmInstall {
target: target, target: target,
command_runner: command_runner command_runner: command_runner
@ -19,13 +19,13 @@ impl<'a> NpmInstall<'a> {
} }
} }
impl<'a> fmt::Display for NpmInstall<'a> {
impl<'a, C: CommandRunner> fmt::Display for NpmInstall<'a, C> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "npm install in {}", self.target) write!(f, "npm install in {}", self.target)
} }
} }
impl<'a> Symbol for NpmInstall<'a> {
impl<'a, C: CommandRunner> Symbol for NpmInstall<'a, C> {
fn target_reached(&self) -> Result<bool, Box<Error>> { fn target_reached(&self) -> Result<bool, Box<Error>> {
if !Path::new(self.target).exists() { if !Path::new(self.target).exists() {
return Ok(false); return Ok(false);

12
src/symbols/owner.rs

@ -11,19 +11,19 @@ use command_runner::CommandRunner;
use resources::Resource; use resources::Resource;
use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner}; use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner};
pub struct Owner<'a, D> where D: AsRef<str> + fmt::Display {
pub struct Owner<'a, C: 'a + CommandRunner, D> where D: AsRef<str> + fmt::Display {
path: D, path: D,
user_name: Cow<'a, str>, user_name: Cow<'a, str>,
command_runner: &'a CommandRunner
command_runner: &'a C
} }
impl<'a, D> Owner<'a, D> where D: AsRef<str> + fmt::Display {
pub fn new(path: D, user_name: Cow<'a, str>, command_runner: &'a CommandRunner) -> Self {
impl<'a, C: CommandRunner, D> Owner<'a, C, D> where D: AsRef<str> + fmt::Display {
pub fn new(path: D, user_name: Cow<'a, str>, command_runner: &'a C) -> Self {
Owner { path: path, user_name: user_name, command_runner: command_runner } Owner { path: path, user_name: user_name, command_runner: command_runner }
} }
} }
impl<'a, D> Symbol for Owner<'a, D> where D: AsRef<str> + fmt::Display {
impl<'a, C: CommandRunner, D> Symbol for Owner<'a, C, D> where D: AsRef<str> + fmt::Display {
fn target_reached(&self) -> Result<bool, Box<Error>> { fn target_reached(&self) -> Result<bool, Box<Error>> {
if !Path::new(self.path.as_ref()).exists() { if !Path::new(self.path.as_ref()).exists() {
return Ok(false); return Ok(false);
@ -50,7 +50,7 @@ impl<'a, D> Symbol for Owner<'a, D> where D: AsRef<str> + fmt::Display {
} }
} }
impl<'a, D> fmt::Display for Owner<'a, D> where D: AsRef<str> + fmt::Display {
impl<'a, C: CommandRunner, D> fmt::Display for Owner<'a, C, D> where D: AsRef<str> + fmt::Display {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error>{ fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error>{
write!(f, "Owner {} for {}", self.user_name, self.path) write!(f, "Owner {} for {}", self.user_name, self.path)
} }

12
src/symbols/stored_directory.rs

@ -14,15 +14,15 @@ use storage::Storage;
#[derive(Debug, PartialEq)] #[derive(Debug, PartialEq)]
pub enum StorageDirection { Load, Save } pub enum StorageDirection { Load, Save }
pub struct StoredDirectory<'a, S> where S: Storage {
pub struct StoredDirectory<'a, S, C: 'a + CommandRunner> where S: Storage {
path: Cow<'a, str>, path: Cow<'a, str>,
storage: S, storage: S,
dir: StorageDirection, dir: StorageDirection,
command_runner: &'a CommandRunner
command_runner: &'a C
} }
impl<'a, S> StoredDirectory<'a, S> where S: Storage {
pub fn new(path: Cow<'a, str>, storage: S, dir: StorageDirection, command_runner: &'a CommandRunner) -> Self {
impl<'a, S, C: CommandRunner> StoredDirectory<'a, S, C> where S: Storage {
pub fn new(path: Cow<'a, str>, storage: S, dir: StorageDirection, command_runner: &'a C) -> Self {
StoredDirectory { StoredDirectory {
path: path, path: path,
storage: storage, storage: storage,
@ -32,13 +32,13 @@ impl<'a, S> StoredDirectory<'a, S> where S: Storage {
} }
} }
impl<'a, S> fmt::Display for StoredDirectory<'a, S> where S: Storage {
impl<'a, S, C: CommandRunner> fmt::Display for StoredDirectory<'a, S, C> where S: Storage {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "Stored directory {} ({:?})", self.path, self.dir) write!(f, "Stored directory {} ({:?})", self.path, self.dir)
} }
} }
impl<'a, S> Symbol for StoredDirectory<'a, S> where S: Storage {
impl<'a, S, C: CommandRunner> Symbol for StoredDirectory<'a, S, C> where S: Storage {
fn target_reached(&self) -> Result<bool, Box<Error>> { fn target_reached(&self) -> Result<bool, Box<Error>> {
let metadata = fs::metadata(self.path.as_ref()); let metadata = fs::metadata(self.path.as_ref());
// Check if dir exists // Check if dir exists

12
src/symbols/systemd/reload.rs

@ -4,13 +4,13 @@ use std::fmt;
use command_runner::CommandRunner; use command_runner::CommandRunner;
use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner}; use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner};
pub struct ReloadService<'a> {
pub struct ReloadService<'a, C: 'a + CommandRunner> {
service: &'a str, service: &'a str,
command_runner: &'a CommandRunner
command_runner: &'a C
} }
impl<'a> ReloadService<'a> {
pub fn new(service: &'a str, command_runner: &'a CommandRunner) -> Self {
impl<'a, C: CommandRunner> ReloadService<'a, C> {
pub fn new(service: &'a str, command_runner: &'a C) -> Self {
ReloadService { ReloadService {
service: service, service: service,
command_runner: command_runner command_runner: command_runner
@ -18,7 +18,7 @@ impl<'a> ReloadService<'a> {
} }
} }
impl<'a> Symbol for ReloadService<'a> {
impl<'a, C: CommandRunner> Symbol for ReloadService<'a, C> {
fn target_reached(&self) -> Result<bool, Box<Error>> { fn target_reached(&self) -> Result<bool, Box<Error>> {
Ok(true) Ok(true)
} }
@ -36,7 +36,7 @@ impl<'a> Symbol for ReloadService<'a> {
} }
} }
impl<'a> fmt::Display for ReloadService<'a> {
impl<'a, C: CommandRunner> fmt::Display for ReloadService<'a, C> {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(),fmt::Error>{ fn fmt(&self, f: &mut fmt::Formatter) -> Result<(),fmt::Error>{
write!(f, "Reload service {}", self.service) write!(f, "Reload service {}", self.service)
} }

12
src/symbols/systemd/user_session.rs

@ -33,13 +33,13 @@ impl<E: Error> fmt::Display for SystemdUserSessionError<E> {
} }
} }
pub struct SystemdUserSession<'a> {
pub struct SystemdUserSession<'a, C: 'a + CommandRunner> {
user_name: Cow<'a, str>, user_name: Cow<'a, str>,
command_runner: &'a CommandRunner
command_runner: &'a C
} }
impl<'a> SystemdUserSession<'a> {
pub fn new(user_name: Cow<'a, str>, command_runner: &'a CommandRunner) -> Self {
impl<'a, C: CommandRunner> SystemdUserSession<'a, C> {
pub fn new(user_name: Cow<'a, str>, command_runner: &'a C) -> Self {
SystemdUserSession { SystemdUserSession {
user_name: user_name, user_name: user_name,
command_runner: command_runner command_runner: command_runner
@ -47,7 +47,7 @@ impl<'a> SystemdUserSession<'a> {
} }
} }
impl<'a> Symbol for SystemdUserSession<'a> {
impl<'a, C: CommandRunner> Symbol for SystemdUserSession<'a, C> {
fn target_reached(&self) -> Result<bool, Box<Error>> { fn target_reached(&self) -> Result<bool, Box<Error>> {
let mut path = PathBuf::from("/var/lib/systemd/linger"); let mut path = PathBuf::from("/var/lib/systemd/linger");
path.push(self.user_name.borrow() as &str); path.push(self.user_name.borrow() as &str);
@ -68,7 +68,7 @@ impl<'a> Symbol for SystemdUserSession<'a> {
} }
} }
impl<'a> fmt::Display for SystemdUserSession<'a> {
impl<'a, C: CommandRunner> fmt::Display for SystemdUserSession<'a, C> {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(),fmt::Error>{ fn fmt(&self, f: &mut fmt::Formatter) -> Result<(),fmt::Error>{
write!(f, "Systemd user session for {}", self.user_name) write!(f, "Systemd user session for {}", self.user_name)
} }

12
src/symbols/tls/csr.rs

@ -7,13 +7,13 @@ use command_runner::CommandRunner;
use resources::Resource; use resources::Resource;
use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner}; use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner};
pub struct TlsCsr<'a> {
pub struct TlsCsr<'a, C: 'a + CommandRunner> {
domain: Cow<'a, str>, domain: Cow<'a, str>,
command_runner: &'a CommandRunner
command_runner: &'a C
} }
impl<'a> TlsCsr<'a> {
pub fn new(domain: Cow<'a, str>, command_runner: &'a CommandRunner) -> TlsCsr<'a> {
impl<'a, C: CommandRunner> TlsCsr<'a, C> {
pub fn new(domain: Cow<'a, str>, command_runner: &'a C) -> Self {
TlsCsr { TlsCsr {
domain: domain, domain: domain,
command_runner: command_runner command_runner: command_runner
@ -29,13 +29,13 @@ impl<'a> TlsCsr<'a> {
} }
} }
impl<'a> fmt::Display for TlsCsr<'a> {
impl<'a, C: CommandRunner> fmt::Display for TlsCsr<'a, C> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "TlsCsr {}", self.domain) write!(f, "TlsCsr {}", self.domain)
} }
} }
impl<'a> Symbol for TlsCsr<'a> {
impl<'a, C: CommandRunner> Symbol for TlsCsr<'a, C> {
fn target_reached(&self) -> Result<bool, Box<Error>> { fn target_reached(&self) -> Result<bool, Box<Error>> {
if !Path::new(&self.get_csr_path()).exists() { if !Path::new(&self.get_csr_path()).exists() {
return Ok(false); return Ok(false);

12
src/symbols/tls/key.rs

@ -6,13 +6,13 @@ use std::path::Path;
use command_runner::CommandRunner; use command_runner::CommandRunner;
use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner}; use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner};
pub struct TlsKey<'a> {
pub struct TlsKey<'a, C: 'a + CommandRunner> {
domain: Cow<'a, str>, domain: Cow<'a, str>,
command_runner: &'a CommandRunner
command_runner: &'a C
} }
impl<'a> TlsKey<'a> {
pub fn new(domain: Cow<'a, str>, command_runner: &'a CommandRunner) -> TlsKey<'a> {
impl<'a, C: CommandRunner> TlsKey<'a, C> {
pub fn new(domain: Cow<'a, str>, command_runner: &'a C) -> Self {
TlsKey { TlsKey {
domain: domain, domain: domain,
command_runner: command_runner command_runner: command_runner
@ -28,13 +28,13 @@ impl<'a> TlsKey<'a> {
} }
} }
impl<'a> fmt::Display for TlsKey<'a> {
impl<'a, C: CommandRunner> fmt::Display for TlsKey<'a, C> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "TlsKey {}", self.domain) write!(f, "TlsKey {}", self.domain)
} }
} }
impl<'a> Symbol for TlsKey<'a> {
impl<'a, C: CommandRunner> Symbol for TlsKey<'a, C> {
fn target_reached(&self) -> Result<bool, Box<Error>> { fn target_reached(&self) -> Result<bool, Box<Error>> {
if !Path::new(&self.get_path()).exists() { if !Path::new(&self.get_path()).exists() {
return Ok(false); return Ok(false);

12
src/symbols/tls/self_signed_cert.rs

@ -7,13 +7,13 @@ use command_runner::CommandRunner;
use resources::Resource; use resources::Resource;
use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner}; use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner};
pub struct SelfSignedTlsCert<'a> {
pub struct SelfSignedTlsCert<'a, C: 'a + CommandRunner> {
domain: Cow<'a, str>, domain: Cow<'a, str>,
command_runner: &'a CommandRunner
command_runner: &'a C
} }
impl<'a> SelfSignedTlsCert<'a> {
pub fn new(domain: Cow<'a, str>, command_runner: &'a CommandRunner) -> SelfSignedTlsCert<'a> {
impl<'a, C: CommandRunner> SelfSignedTlsCert<'a, C> {
pub fn new(domain: Cow<'a, str>, command_runner: &'a C) -> Self {
SelfSignedTlsCert { SelfSignedTlsCert {
domain: domain, domain: domain,
command_runner: command_runner command_runner: command_runner
@ -29,7 +29,7 @@ impl<'a> SelfSignedTlsCert<'a> {
} }
} }
impl<'a> fmt::Display for SelfSignedTlsCert<'a> {
impl<'a, C: CommandRunner> fmt::Display for SelfSignedTlsCert<'a, C> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "SelfSignedTlsCert {}", self.domain) write!(f, "SelfSignedTlsCert {}", self.domain)
} }
@ -37,7 +37,7 @@ impl<'a> fmt::Display for SelfSignedTlsCert<'a> {
const DAYS_IN_SECONDS: u32 = 24*60*60; const DAYS_IN_SECONDS: u32 = 24*60*60;
impl<'a> Symbol for SelfSignedTlsCert<'a> {
impl<'a, C: CommandRunner> Symbol for SelfSignedTlsCert<'a, C> {
fn target_reached(&self) -> Result<bool, Box<Error>> { fn target_reached(&self) -> Result<bool, Box<Error>> {
if !Path::new(&self.get_cert_path()).exists() { if !Path::new(&self.get_cert_path()).exists() {
return Ok(false); return Ok(false);

22
src/symbols/user.rs

@ -71,14 +71,14 @@ impl fmt::Display for UserError {
} }
} }
pub struct User<'a, E, A> where E: Error + Sized, A: 'a + UserAdder<SubE=E> {
pub struct User<'a, C: 'a + CommandRunner, E, A> where E: Error + Sized, A: 'a + UserAdder<SubE=E> {
user_name: Cow<'a, str>, user_name: Cow<'a, str>,
command_runner: &'a CommandRunner,
command_runner: &'a C,
user_adder: &'a A user_adder: &'a A
} }
impl<'a, E: Error + Sized, A: 'a + UserAdder<SubE=E>> User<'a, E, A> {
pub fn new(user_name: Cow<'a, str>, command_runner: &'a CommandRunner, user_adder: &'a A) -> User<'a, E, A> {
impl<'a, C: CommandRunner, E: Error + Sized, A: 'a + UserAdder<SubE=E>> User<'a, C, E, A> {
pub fn new(user_name: Cow<'a, str>, command_runner: &'a C, user_adder: &'a A) -> Self {
User { User {
user_name: user_name, user_name: user_name,
command_runner: command_runner, command_runner: command_runner,
@ -87,13 +87,13 @@ impl<'a, E: Error + Sized, A: 'a + UserAdder<SubE=E>> User<'a, E, A> {
} }
} }
impl<'a, E: Error, A: UserAdder<SubE=E>> fmt::Display for User<'a, E, A> {
impl<'a, C: CommandRunner, E: Error, A: UserAdder<SubE=E>> fmt::Display for User<'a, C, E, A> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "User {}", self.user_name) write!(f, "User {}", self.user_name)
} }
} }
impl<'a, E: 'static + Error, A: UserAdder<SubE=E>> Symbol for User<'a, E, A> {
impl<'a, C: CommandRunner, E: 'static + Error, A: UserAdder<SubE=E>> Symbol for User<'a, C, E, A> {
fn target_reached(&self) -> Result<bool, Box<Error>> { fn target_reached(&self) -> Result<bool, Box<Error>> {
let output = try!(self.command_runner.run_with_args("getent", &["passwd", &*self.user_name])); let output = try!(self.command_runner.run_with_args("getent", &["passwd", &*self.user_name]));
match output.status.code() { match output.status.code() {
@ -120,17 +120,17 @@ impl<'a, E: 'static + Error, A: UserAdder<SubE=E>> Symbol for User<'a, E, A> {
} }
} }
pub struct SystemUserAdder<'a> {
command_runner: &'a CommandRunner
pub struct SystemUserAdder<'a, C: 'a + CommandRunner> {
command_runner: &'a C
} }
impl<'a> SystemUserAdder<'a> {
pub fn new(command_runner: &'a CommandRunner) -> SystemUserAdder<'a> {
impl<'a, C: CommandRunner> SystemUserAdder<'a, C> {
pub fn new(command_runner: &'a C) -> Self {
SystemUserAdder { command_runner: command_runner } SystemUserAdder { command_runner: command_runner }
} }
} }
impl<'a> UserAdder for SystemUserAdder<'a> {
impl<'a, C: CommandRunner> UserAdder for SystemUserAdder<'a, C> {
type SubE = IoError; type SubE = IoError;
fn add_user(&self, user_name: &str) -> Result<(), UserAdderError<IoError>> { fn add_user(&self, user_name: &str) -> Result<(), UserAdderError<IoError>> {
let output = self.command_runner.run_with_args( let output = self.command_runner.run_with_args(

5
src/symbols/wordpress/plugin.rs

@ -54,10 +54,11 @@ impl<'a, C, R> Symbol for WordpressPlugin<'a, C, R> where C: Deref<Target=str> +
} }
fn execute(&self) -> Result<(), Box<Error>> { fn execute(&self) -> Result<(), Box<Error>> {
let source = format!("https://downloads.wordpress.org/plugin/{}.zip", self.name);
let zip = format!("/tmp/{}.zip", self.name); let zip = format!("/tmp/{}.zip", self.name);
try!(self.command_runner.run_successfully("curl", &[&format!("https://downloads.wordpress.org/plugin/{}.zip", self.name), "-o", &zip]));
try!(self.command_runner.run_successfully("curl", &[source.as_ref() as &str, "-o", zip.as_ref()]));
try!(self.command_runner.run_successfully("rm", &["-rf", &self.get_path().to_string_lossy()])); try!(self.command_runner.run_successfully("rm", &["-rf", &self.get_path().to_string_lossy()]));
self.command_runner.run_successfully("unzip", &[&zip, "-d", &Path::new(&*self.base).join("wp-content/plugins").to_string_lossy()])
self.command_runner.run_successfully("unzip", &[zip.as_ref(), "-d".as_ref(), Path::new(&*self.base).join("wp-content/plugins").as_os_str()])
} }
fn get_prerequisites(&self) -> Vec<Resource> { fn get_prerequisites(&self) -> Vec<Resource> {

Loading…
Cancel
Save