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

Cargo fix

Browse source
This commit is contained in:
Adrian Heine 2019-09-12 22:59:22 +02:00
parent 5505c09db4
commit 9bab810b91
38 changed files with 235 additions and 235 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/bin.rs
View file

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

6
src/command_runner.rs
View file

@ -6,21 +6,21 @@ use std::process::Output;
pub trait CommandRunner {
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>> {
fn get_output<S: AsRef<OsStr> + ?Sized>(&self, program: &str, args: &[&S]) -> Result<Vec<u8>, Box<dyn Error>> {
let output = try!(self.run_with_args(program, args));
if !output.status.success() {
return Err(try!(String::from_utf8(output.stderr)).into());
}
Ok(output.stdout)
}
fn get_stderr<S: AsRef<OsStr> + ?Sized>(&self, program: &str, args: &[&S]) -> Result<Vec<u8>, Box<Error>> {
fn get_stderr<S: AsRef<OsStr> + ?Sized>(&self, program: &str, args: &[&S]) -> Result<Vec<u8>, Box<dyn Error>> {
let output = try!(self.run_with_args(program, args));
if !output.status.success() {
return Err(try!(String::from_utf8(output.stderr)).into());
}
Ok(output.stderr)
}
fn run_successfully<S: AsRef<OsStr> + ?Sized>(&self, program: &str, args: &[&S]) -> Result<(), Box<Error>> {
fn run_successfully<S: AsRef<OsStr> + ?Sized>(&self, program: &str, args: &[&S]) -> Result<(), Box<dyn Error>> {
let output = try!(self.run_with_args(program, args));
if output.status.success() {
Ok(())

16
src/factory.rs
View file

@ -27,7 +27,7 @@ impl Factory {
DefaultSymbolRepository::new(command_runner)
}
pub fn get_symbol_runner<'a, RUNNER: SymbolRunner, REPO: SymbolRepository<'a>>(&self, symbol_runner: &'a RUNNER, repo: &'a REPO) -> Box<'a + SymbolRunner> {
pub fn get_symbol_runner<'a, RUNNER: SymbolRunner, REPO: SymbolRepository<'a>>(&self, symbol_runner: &'a RUNNER, repo: &'a REPO) -> Box<dyn 'a + SymbolRunner> {
let runner1 = ReportingSymbolRunner::new(symbol_runner, StdErrLogger);
let runner2 = NonRepeatingSymbolRunner::new(runner1);
Box::new(RequirementsResolvingSymbolRunner::new(runner2, repo))
@ -60,7 +60,7 @@ impl<'a, C: 'a + CommandRunner> DefaultSymbolRepository<'a, SystemUserAdder<'a,
}
impl<'a, C: CommandRunner> SymbolRepository<'a> for DefaultSymbolRepository<'a, SystemUserAdder<'a, C>, C> {
fn get_symbol(&'a self, resource: &Resource) -> Option<Box<Symbol + 'a>> {
fn get_symbol(&'a self, resource: &Resource) -> Option<Box<dyn Symbol + 'a>> {
match resource.get_type() {
"user" => Some(Box::new(User::new(
resource.get_value().to_string().into(),
@ -74,12 +74,12 @@ impl<'a, C: CommandRunner> SymbolRepository<'a> for DefaultSymbolRepository<'a,
Box::new(List::new(vec![
Box::new(Dir::new(value.to_string())),
Box::new(Owner::new(value.to_string(), matches[1].to_string().into(), self.command_runner))
])) as Box<Symbol>
])) as Box<dyn Symbol>
} else if let Some(matches) = self.home.captures(value) {
Box::new(
User::new(matches[1].to_string().into(), self.command_runner, &self.user_adder)
) as Box<Symbol>
} else { Box::new(Dir::new(value.to_string())) as Box<Symbol> }
) as Box<dyn Symbol>
} else { Box::new(Dir::new(value.to_string())) as Box<dyn Symbol> }
)
},
"file" => {
@ -88,17 +88,17 @@ impl<'a, C: CommandRunner> SymbolRepository<'a> for DefaultSymbolRepository<'a,
Some(Box::new(TlsCsr::new(
matches[1].to_string().into(),
self.command_runner
)) as Box<Symbol>)
)) as Box<dyn Symbol>)
} else if let Some(matches) = self.private_key.captures(value) {
Some(Box::new(TlsKey::new(
matches[1].to_string().into(),
self.command_runner
)) as Box<Symbol>)
)) as Box<dyn Symbol>)
} else if let Some(matches) = self.systemd_linger.captures(value) {
Some(Box::new(SystemdUserSession::new(
matches[1].to_string().into(),
self.command_runner
)) as Box<Symbol>)
)) as Box<dyn Symbol>)
} else { None }
},
_ => None

6
src/loggers.rs
View file

@ -18,17 +18,17 @@ impl Logger for StdErrLogger {
}
pub struct FilteringLogger<'a> {
logger: &'a mut Logger
logger: &'a mut dyn Logger
}
impl<'a> FilteringLogger<'a> {
pub fn new(logger: &'a mut Logger) -> Self {
pub fn new(logger: &'a mut dyn Logger) -> Self {
FilteringLogger { logger }
}
}
impl<'a> Logger for FilteringLogger<'a> {
fn debug(&mut self, str: &str) {
fn debug(&mut self, _str: &str) {
return
}
fn write(&mut self, str: &str) {

12
src/repository.rs
View file

@ -4,27 +4,27 @@ use symbols::Symbol;
use resources::Resource;
pub trait SymbolRepository<'a> {
fn get_symbol(&'a self, resource: &Resource) -> Option<Box<Symbol + 'a>>;
fn get_symbol(&'a self, resource: &Resource) -> Option<Box<dyn Symbol + 'a>>;
}
impl<'a, C> SymbolRepository<'a> for C where C: Fn(&Resource) -> Option<Box<Symbol + 'a>> {
fn get_symbol(&'a self, resource: &Resource) -> Option<Box<Symbol + 'a>> {
impl<'a, C> SymbolRepository<'a> for C where C: Fn(&Resource) -> Option<Box<dyn Symbol + 'a>> {
fn get_symbol(&'a self, resource: &Resource) -> Option<Box<dyn Symbol + 'a>> {
self(resource)
}
}
pub struct DispatchingSymbolRepository<'a> {
repositories: HashMap<&'a str, Box<SymbolRepository<'a> + 'a>>
repositories: HashMap<&'a str, Box<dyn SymbolRepository<'a> + 'a>>
}
impl<'a> DispatchingSymbolRepository<'a> {
pub fn new(repositories: HashMap<&'a str, Box<SymbolRepository<'a> + 'a>>) -> Self {
pub fn new(repositories: HashMap<&'a str, Box<dyn SymbolRepository<'a> + 'a>>) -> Self {
DispatchingSymbolRepository { repositories }
}
}
impl<'a> SymbolRepository<'a> for DispatchingSymbolRepository<'a> {
fn get_symbol(&'a self, resource: &Resource) -> Option<Box<Symbol + 'a>> {
fn get_symbol(&'a self, resource: &Resource) -> Option<Box<dyn Symbol + 'a>> {
self.repositories.get(resource.get_type()).and_then(|repo| repo.get_symbol(resource))
}
}

30
src/schema.rs
View file

@ -8,7 +8,7 @@ use symbols::{Symbol, SymbolRunner};
#[derive(Debug)]
pub enum SymbolRunError {
Symbol(Box<Error>),
Symbol(Box<dyn Error>),
ExecuteDidNotReach(())
}
@ -19,7 +19,7 @@ impl Error for SymbolRunError {
SymbolRunError::ExecuteDidNotReach(_) => "Target not reached after executing symbol"
}
}
fn cause(&self) -> Option<&Error> {
fn cause(&self) -> Option<&dyn Error> {
match self {
SymbolRunError::Symbol(ref e) => Some(&**e),
SymbolRunError::ExecuteDidNotReach(_) => None
@ -47,7 +47,7 @@ impl<L: Logger> InitializingSymbolRunner<L> {
}
impl<L: Logger> SymbolRunner for InitializingSymbolRunner<L> {
fn run_symbol(&self, symbol: &Symbol) -> Result<(), Box<Error>>
fn run_symbol(&self, symbol: &dyn Symbol) -> Result<(), Box<dyn Error>>
{
let mut logger = self.logger.borrow_mut();
let target_reached = try!(symbol.target_reached());
@ -78,7 +78,7 @@ impl<L: Logger> DrySymbolRunner<L> {
}
impl<L: Logger> SymbolRunner for DrySymbolRunner<L> {
fn run_symbol(&self, symbol: &Symbol) -> Result<(), Box<Error>>
fn run_symbol(&self, symbol: &dyn Symbol) -> Result<(), Box<dyn Error>>
{
let mut logger = self.logger.borrow_mut();
let target_reached = try!(symbol.target_reached());
@ -99,7 +99,7 @@ impl<'a, R, L> ReportingSymbolRunner<'a, R, L> where R: SymbolRunner, L: Logger
}
impl<'a, R, L> SymbolRunner for ReportingSymbolRunner<'a, R, L> where R: SymbolRunner, L: Logger {
fn run_symbol(&self, symbol: &Symbol) -> Result<(), Box<Error>>
fn run_symbol(&self, symbol: &dyn Symbol) -> Result<(), Box<dyn Error>>
{
let mut logger = self.1.borrow_mut();
logger.debug(format!("Running symbol {}", symbol).as_str());
@ -131,7 +131,7 @@ impl<R> NonRepeatingSymbolRunner<R> where R: SymbolRunner {
}
impl<R: SymbolRunner> SymbolRunner for NonRepeatingSymbolRunner<R> {
fn run_symbol(&self, symbol: &Symbol) -> Result<(), Box<Error>>
fn run_symbol(&self, symbol: &dyn Symbol) -> Result<(), Box<dyn Error>>
{
if let Some(resources) = symbol.provides() {
let mut done = self.done.borrow_mut();
@ -151,7 +151,7 @@ impl<R: SymbolRunner> SymbolRunner for NonRepeatingSymbolRunner<R> {
}
use std::marker::PhantomData;
pub struct RequirementsResolvingSymbolRunner<'a, 's, R: 'a + SymbolRunner, G: 'a + SymbolRepository<'s>>(R, &'a G, PhantomData<Box<Symbol + 's>>);
pub struct RequirementsResolvingSymbolRunner<'a, 's, R: 'a + SymbolRunner, G: 'a + SymbolRepository<'s>>(R, &'a G, PhantomData<Box<dyn Symbol + 's>>);
impl<'s, 'a: 's, R, G> RequirementsResolvingSymbolRunner<'a, 's, R, G> where R: SymbolRunner, G: SymbolRepository<'s> {
pub fn new(symbol_runner: R, symbol_repo: &'a G) -> Self {
@ -160,7 +160,7 @@ impl<'s, 'a: 's, R, G> RequirementsResolvingSymbolRunner<'a, 's, R, G> where R:
}
impl<'s, 'a: 's, R, G> SymbolRunner for RequirementsResolvingSymbolRunner<'a, 's, R, G> where R: SymbolRunner, G: SymbolRepository<'s> {
fn run_symbol(&self, symbol: &Symbol) -> Result<(), Box<Error>>
fn run_symbol(&self, symbol: &dyn Symbol) -> Result<(), Box<dyn Error>>
{
for resource in symbol.get_prerequisites() {
if let Some(dep) = self.1.get_symbol(&resource) {
@ -202,23 +202,23 @@ mod test {
}
struct DummySymbol<'a> {
_execute: &'a Fn() -> Result<(), Box<Error>>,
_target_reached: &'a Fn() -> Result<bool, Box<Error>>
_execute: &'a dyn Fn() -> Result<(), Box<dyn Error>>,
_target_reached: &'a dyn Fn() -> Result<bool, Box<dyn Error>>
}
impl<'b> Symbol for DummySymbol<'b> {
fn target_reached(&self) -> Result<bool, Box<Error>> {
fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
(self._target_reached)()
}
fn execute(&self) -> Result<(), Box<Error>> {
fn execute(&self) -> Result<(), Box<dyn Error>> {
(self._execute)()
}
fn as_action<'a>(&'a self, runner: &'a SymbolRunner) -> Box<Action + 'a> {
fn as_action<'a>(&'a self, runner: &'a dyn SymbolRunner) -> Box<dyn Action + 'a> {
Box::new(SymbolAction::new(runner, self))
}
fn into_action<'a>(self: Box<Self>, runner: &'a SymbolRunner) -> Box<Action + 'a> where Self: 'a {
fn into_action<'a>(self: Box<Self>, runner: &'a dyn SymbolRunner) -> Box<dyn Action + 'a> where Self: 'a {
Box::new(OwnedSymbolAction::new(runner, *self))
}
}
@ -230,7 +230,7 @@ mod test {
}
impl<'a> DummySymbol<'a> {
fn new(target_reached: &'a Fn() -> Result<bool, Box<Error>>, execute: &'a Fn() -> Result<(), Box<Error>>) -> DummySymbol<'a> {
fn new(target_reached: &'a dyn Fn() -> Result<bool, Box<dyn Error>>, execute: &'a dyn Fn() -> Result<(), Box<dyn Error>>) -> DummySymbol<'a> {
DummySymbol { _target_reached: target_reached, _execute: execute }
}
}

8
src/storage.rs
View file

@ -5,8 +5,8 @@ use std::time::{SystemTime, UNIX_EPOCH};
pub trait Storage {
fn write_filename(&self) -> String;
fn read_filename(&self) -> Result<String, Box<Error>>;
fn recent_date(&self) -> Result<u64, Box<Error>>;
fn read_filename(&self) -> Result<String, Box<dyn Error>>;
fn recent_date(&self) -> Result<u64, Box<dyn Error>>;
}
#[derive(Clone)]
@ -30,11 +30,11 @@ impl Storage for SimpleStorage {
self.get_path(Some(SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs()))
}
fn read_filename(&self) -> Result<String, Box<Error>> {
fn read_filename(&self) -> Result<String, Box<dyn Error>> {
Ok(self.get_path(Some(try!(self.recent_date()))))
}
fn recent_date(&self) -> Result<u64, Box<Error>> {
fn recent_date(&self) -> Result<u64, Box<dyn Error>> {
let dir = self.get_path(None);
try!(read_dir(dir))
.map(|entry| entry.ok().and_then(|e| e.file_name().into_string().ok()).and_then(|filename| u64::from_str(&filename).ok()))

8
src/symbols/acme/account_key.rs
View file

@ -29,7 +29,7 @@ impl<'a, C: CommandRunner> fmt::Display for AcmeAccountKey<'a, C> {
}
impl<'a, C: CommandRunner> Symbol for AcmeAccountKey<'a, C> {
fn target_reached(&self) -> Result<bool, Box<Error>> {
fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
if !self.path.exists() {
return Ok(false);
}
@ -37,7 +37,7 @@ impl<'a, C: CommandRunner> Symbol for AcmeAccountKey<'a, C> {
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<dyn Error>> {
self.command_runner.run_successfully("openssl", &["genrsa".as_ref(), "-out".as_ref(), self.path.as_os_str(), self.get_bytes().to_string().as_ref()])
}
@ -45,11 +45,11 @@ impl<'a, C: CommandRunner> Symbol for AcmeAccountKey<'a, C> {
vec![ Resource::new("dir", self.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 dyn SymbolRunner) -> Box<dyn Action + 'b> {
Box::new(SymbolAction::new(runner, self))
}
fn into_action<'b>(self: Box<Self>, runner: &'b SymbolRunner) -> Box<Action + 'b> where Self: 'b {
fn into_action<'b>(self: Box<Self>, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> where Self: 'b {
Box::new(OwnedSymbolAction::new(runner, *self))
}
}

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

@ -37,7 +37,7 @@ impl<'a, C: CommandRunner> fmt::Display for AcmeCert<'a, C> {
const DAYS_IN_SECONDS: u32 = 24*60*60;
impl<'a, C: CommandRunner> Symbol for AcmeCert<'a, C> {
fn target_reached(&self) -> Result<bool, Box<Error>> {
fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
if !Path::new(&self.get_cert_path()).exists() {
return Ok(false);
}
@ -52,7 +52,7 @@ impl<'a, C: CommandRunner> Symbol for AcmeCert<'a, C> {
}
}
fn execute(&self) -> Result<(), Box<Error>> {
fn execute(&self) -> Result<(), Box<dyn Error>> {
let output = try!(self.command_runner.get_output("acme-tiny", &["--account-key", "/home/acme/account.key", "--csr", &self.get_csr_path(), "--acme-dir", "/home/acme/challenges/"]));
let mut file = try!(FsFile::create(self.get_cert_path()));
try!(file.write_all(&output));
@ -63,11 +63,11 @@ impl<'a, C: CommandRunner> Symbol for AcmeCert<'a, C> {
vec![ Resource::new("file", self.get_csr_path()) ]
}
fn as_action<'b>(&'b self, runner: &'b SymbolRunner) -> Box<Action + 'b> {
fn as_action<'b>(&'b self, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> {
Box::new(SymbolAction::new(runner, self))
}
fn into_action<'b>(self: Box<Self>, runner: &'b SymbolRunner) -> Box<Action + 'b> where Self: 'b {
fn into_action<'b>(self: Box<Self>, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> where Self: 'b {
Box::new(OwnedSymbolAction::new(runner, *self))
}
}

8
src/symbols/acme/chain.rs
View file

@ -37,7 +37,7 @@ impl<'a, C: CommandRunner> fmt::Display for AcmeCertChain<'a, C> {
const DAYS_IN_SECONDS: u32 = 24*60*60;
impl<'a, C: CommandRunner> Symbol for AcmeCertChain<'a, C> {
fn target_reached(&self) -> Result<bool, Box<Error>> {
fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
if !Path::new(&self.get_cert_chain_path()).exists() {
return Ok(false);
}
@ -50,7 +50,7 @@ impl<'a, C: CommandRunner> Symbol for AcmeCertChain<'a, C> {
Ok(self.command_runner.run_successfully("openssl", &["verify", "-untrusted", "/home/acme/lets_encrypt_x3_cross_signed.pem", &self.get_cert_chain_path()]).is_ok())
}
fn execute(&self) -> Result<(), Box<Error>> {
fn execute(&self) -> Result<(), Box<dyn Error>> {
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()));
try!(file.write_all(&output));
@ -61,11 +61,11 @@ impl<'a, C: CommandRunner> Symbol for AcmeCertChain<'a, C> {
vec![ Resource::new("file", self.get_single_cert_path()) ]
}
fn as_action<'b>(&'b self, runner: &'b SymbolRunner) -> Box<Action + 'b> {
fn as_action<'b>(&'b self, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> {
Box::new(SymbolAction::new(runner, self))
}
fn into_action<'b>(self: Box<Self>, runner: &'b SymbolRunner) -> Box<Action + 'b> where Self: 'b {
fn into_action<'b>(self: Box<Self>, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> where Self: 'b {
Box::new(OwnedSymbolAction::new(runner, *self))
}
}

10
src/symbols/acme/user.rs
View file

@ -22,10 +22,10 @@ impl<'a> AcmeUser<'a> {
}
impl<'a> Symbol for AcmeUser<'a> {
fn target_reached(&self) -> Result<bool, Box<Error>> {
fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
Ok(false)
}
fn execute(&self) -> Result<(), Box<Error>> {
fn execute(&self) -> Result<(), Box<dyn Error>> {
Ok(())
}
fn get_prerequisites(&self) -> Vec<Resource> {
@ -34,11 +34,11 @@ impl<'a> Symbol for AcmeUser<'a> {
fn provides(&self) -> Option<Vec<Resource>> {
None
}
fn as_action<'b>(&'b self, runner: &'b SymbolRunner) -> Box<Action + 'b> {
fn as_action<'b>(&'b self, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> {
Box::new(SymbolAction::new(runner, self))
}
fn into_action<'b>(self: Box<Self>, runner: &'b SymbolRunner) -> Box<Action + 'b> where Self: 'b {
fn into_action<'b>(self: Box<Self>, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> where Self: 'b {
Box::new(OwnedSymbolAction::new(runner, *self))
}
}
@ -49,7 +49,7 @@ impl<'a> fmt::Display for AcmeUser<'a> {
}
}
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
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<dyn 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![

10
src/symbols/dir.rs
View file

@ -18,7 +18,7 @@ impl<D> Dir<D> where D: AsRef<str> {
}
impl<D> Symbol for Dir<D> where D: AsRef<str> {
fn target_reached(&self) -> Result<bool, Box<Error>> {
fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
let metadata = fs::metadata(self.path.as_ref());
// Check if dir exists
if let Err(e) = metadata {
@ -35,8 +35,8 @@ impl<D> Symbol for Dir<D> where D: AsRef<str> {
}
}
fn execute(&self) -> Result<(), Box<Error>> {
fs::create_dir(self.path.as_ref()).map_err(|e| Box::new(e) as Box<Error>)
fn execute(&self) -> Result<(), Box<dyn Error>> {
fs::create_dir(self.path.as_ref()).map_err(|e| Box::new(e) as Box<dyn Error>)
}
fn get_prerequisites(&self) -> Vec<Resource> {
@ -51,11 +51,11 @@ impl<D> Symbol for Dir<D> where D: AsRef<str> {
Some(vec![ Resource::new("dir", self.path.as_ref()) ])
}
fn as_action<'a>(&'a self, runner: &'a SymbolRunner) -> Box<Action + 'a> {
fn as_action<'a>(&'a self, runner: &'a dyn SymbolRunner) -> Box<dyn Action + 'a> {
Box::new(SymbolAction::new(runner, self))
}
fn into_action<'a>(self: Box<Self>, runner: &'a SymbolRunner) -> Box<Action + 'a> where Self: 'a {
fn into_action<'a>(self: Box<Self>, runner: &'a dyn SymbolRunner) -> Box<dyn Action + 'a> where Self: 'a {
Box::new(OwnedSymbolAction::new(runner, *self))
}
}

30
src/symbols/factory.rs
View file

@ -47,7 +47,7 @@ impl<'b, C: 'b + CommandRunner, R: 'b + SymbolRunner, P: 'b + Policy> SymbolFact
SymbolFactory { command_runner, acme_command_runner, symbol_runner, policy }
}
pub fn get_nginx_acme_server<'a, 'c: 'a, S: 'a + Symbol>(&'c self, host: &'static str, nginx_server_symbol: S) -> Box<Action + 'a> {
pub fn get_nginx_acme_server<'a, 'c: 'a, S: 'a + Symbol>(&'c self, host: &'static str, nginx_server_symbol: S) -> Box<dyn Action + 'a> {
Box::new(ListAction::new(vec![
Box::new(SelfSignedTlsCert::new(
host.into(),
@ -70,7 +70,7 @@ impl<'b, C: 'b + CommandRunner, R: 'b + SymbolRunner, P: 'b + Policy> SymbolFact
)).into_action(self.symbol_runner)
]))
}
pub fn get_nginx_acme_challenge_config<'a>(&'a self) -> Box<Action + 'a> {
pub fn get_nginx_acme_challenge_config<'a>(&'a self) -> Box<dyn Action + 'a> {
Box::new(File::new(
"/etc/nginx/snippets/acme-challenge.conf", "location ^~ /.well-known/acme-challenge/ {
alias /home/acme/challenges/;
@ -83,7 +83,7 @@ impl<'b, C: 'b + CommandRunner, R: 'b + SymbolRunner, P: 'b + Policy> SymbolFact
format!("/run/php/{}.sock", user_name)
}
fn get_php_fpm_pool<'a>(&'a self, user_name: &str) -> Box<Action + 'a> {
fn get_php_fpm_pool<'a>(&'a self, user_name: &str) -> Box<dyn Action + 'a> {
let socket = self.get_php_fpm_pool_socket_path(user_name);
Box::new(Hook::new(
File::new(
@ -105,7 +105,7 @@ env[PATH] = /usr/local/bin:/usr/bin:/bin
)).into_action(self.symbol_runner)
}
pub fn serve_php<'a>(&'a self, host_name: &'static str, root_dir: Cow<'a, str>) -> Box<Action + 'a> {
pub fn serve_php<'a>(&'a self, host_name: &'static str, root_dir: Cow<'a, str>) -> Box<dyn Action + 'a> {
let user_name = self.policy.user_name_for_host(host_name);
let socket = self.get_php_fpm_pool_socket_path(&user_name);
Box::new(ListAction::new(vec![
@ -121,7 +121,7 @@ env[PATH] = /usr/local/bin:/usr/bin:/bin
]))
}
pub fn serve_wordpress<'a>(&'a self, host_name: &'static str, root_dir: Cow<'a, str>) -> Box<Action + 'a> {
pub fn serve_wordpress<'a>(&'a self, host_name: &'static str, root_dir: Cow<'a, str>) -> Box<dyn Action + 'a> {
let user_name = self.policy.user_name_for_host(host_name);
let socket = self.get_php_fpm_pool_socket_path(&user_name);
Box::new(ListAction::new(vec![
@ -139,7 +139,7 @@ env[PATH] = /usr/local/bin:/usr/bin:/bin
]))
}
pub fn serve_dokuwiki<'a>(&'a self, host_name: &'static str, root_dir: &'static str) -> Box<Action + 'a> {
pub fn serve_dokuwiki<'a>(&'a self, host_name: &'static str, root_dir: &'static str) -> Box<dyn Action + 'a> {
let user_name = self.policy.user_name_for_host(host_name);
let socket = self.get_php_fpm_pool_socket_path(&user_name);
Box::new(ListAction::new(vec![
@ -174,7 +174,7 @@ env[PATH] = /usr/local/bin:/usr/bin:/bin
]))
}
pub fn serve_nextcloud<'a>(&'a self, host_name: &'static str, root_dir: Cow<'a, str>) -> Box<Action + 'a> {
pub fn serve_nextcloud<'a>(&'a self, host_name: &'static str, root_dir: Cow<'a, str>) -> Box<dyn Action + 'a> {
let user_name = self.policy.user_name_for_host(host_name);
let socket = self.get_php_fpm_pool_socket_path(&user_name);
Box::new(ListAction::new(vec![
@ -236,15 +236,15 @@ env[PATH] = /usr/local/bin:/usr/bin:/bin
]))
}
pub fn serve_redir<'a>(&'a self, host_name: &'static str, target: &'static str) -> Box<Action + 'a> {
pub fn serve_redir<'a>(&'a self, host_name: &'static str, target: &'static str) -> Box<dyn Action + 'a> {
self.get_nginx_acme_server(host_name, NginxServer::new_redir(host_name, target, self.command_runner))
}
pub fn serve_static<'a>(&'a self, host_name: &'static str, dir: &'a str) -> Box<Action + 'a> {
pub fn serve_static<'a>(&'a self, host_name: &'static str, dir: &'a str) -> Box<dyn Action + 'a> {
self.get_nginx_acme_server(host_name, NginxServer::new_static(host_name, dir, self.command_runner))
}
pub fn get_stored_directory<'a, T: Into<String>>(&'a self, storage_name: &'static str, target: T) -> (Box<Action + 'a>, Box<Action + 'a>) {
pub fn get_stored_directory<'a, T: Into<String>>(&'a self, storage_name: &'static str, target: T) -> (Box<dyn Action + 'a>, Box<dyn Action + 'a>) {
let data = SimpleStorage::new("/root/data".to_string(), storage_name.to_string());
let string_target = target.into();
(
@ -253,7 +253,7 @@ env[PATH] = /usr/local/bin:/usr/bin:/bin
)
}
pub fn get_mariadb_database<'a>(&'a self, name: &'static str) -> Box<Action + 'a> {
pub fn get_mariadb_database<'a>(&'a self, name: &'static str) -> Box<dyn Action + 'a> {
let db_dump = SimpleStorage::new("/root/data".to_string(), format!("{}.sql", name));
Box::new(ListAction::new(vec![
Box::new(MariaDBDatabase::new(name.into(), db_dump.read_filename().unwrap().into(), self.command_runner)).into_action(self.symbol_runner),
@ -261,19 +261,19 @@ env[PATH] = /usr/local/bin:/usr/bin:/bin
]))
}
pub fn get_mariadb_user<'a>(&'a self, user_name: &'static str) -> Box<Action + 'a> {
pub fn get_mariadb_user<'a>(&'a self, user_name: &'static str) -> Box<dyn Action + 'a> {
Box::new(MariaDBUser::new(user_name.into(), self.command_runner)).into_action(self.symbol_runner)
}
pub fn get_git_checkout<'a, T: 'a + AsRef<str>>(&'a self, target: T, source: &'a str, branch: &'a str) -> Box<Action + 'a> {
pub fn get_git_checkout<'a, T: 'a + AsRef<str>>(&'a self, target: T, source: &'a str, branch: &'a str) -> Box<dyn Action + 'a> {
Box::new(GitCheckout::new(target, source, branch, self.command_runner)).into_action(self.symbol_runner)
}
pub fn get_owner<'a, F: 'a + AsRef<str>>(&'a self, file: F, user: &'a str) -> Box<Action + 'a> {
pub fn get_owner<'a, F: 'a + AsRef<str>>(&'a self, file: F, user: &'a str) -> Box<dyn Action + 'a> {
Box::new(Owner::new(file, user.into(), self.command_runner)).into_action(self.symbol_runner)
}
pub fn get_file<'a, F: 'a + Deref<Target=str>, Q: 'a + AsRef<Path>>(&'a self, path: Q, content: F) -> Box<Action + 'a> {
pub fn get_file<'a, F: 'a + Deref<Target=str>, Q: 'a + AsRef<Path>>(&'a self, path: Q, content: F) -> Box<dyn Action + 'a> {
Box::new(File::new(path, content)).into_action(self.symbol_runner)
}
}

8
src/symbols/file.rs
View file

@ -21,7 +21,7 @@ impl<C, D> File<C, D> where C: Deref<Target=str>, D: AsRef<Path> {
}
impl<C, D> Symbol for File<C, D> where C: Deref<Target=str>, D: AsRef<Path> {
fn target_reached(&self) -> Result<bool, Box<Error>> {
fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
let file = FsFile::open(self.path.as_ref());
// Check if file exists
if let Err(e) = file {
@ -44,7 +44,7 @@ impl<C, D> Symbol for File<C, D> where C: Deref<Target=str>, D: AsRef<Path> {
}
}
fn execute(&self) -> Result<(), Box<Error>> {
fn execute(&self) -> Result<(), Box<dyn Error>> {
let mut file = try!(FsFile::create(self.path.as_ref()));
try!(file.write_all(self.content.as_bytes()));
Ok(())
@ -54,11 +54,11 @@ impl<C, D> Symbol for File<C, D> where C: Deref<Target=str>, D: AsRef<Path> {
vec![ Resource::new("dir", Path::new(self.path.as_ref()).parent().unwrap().to_string_lossy() ) ]
}
fn as_action<'a>(&'a self, runner: &'a SymbolRunner) -> Box<Action + 'a> {
fn as_action<'a>(&'a self, runner: &'a dyn SymbolRunner) -> Box<dyn Action + 'a> {
Box::new(SymbolAction::new(runner, self))
}
fn into_action<'a>(self: Box<Self>, runner: &'a SymbolRunner) -> Box<Action + 'a> where Self: 'a {
fn into_action<'a>(self: Box<Self>, runner: &'a dyn SymbolRunner) -> Box<dyn Action + 'a> where Self: 'a {
Box::new(OwnedSymbolAction::new(runner, *self))
}
}

10
src/symbols/git/checkout.rs
View file

@ -29,7 +29,7 @@ impl<'a, C: CommandRunner, T: AsRef<str>> fmt::Display for GitCheckout<'a, C, T>
use std::fs::metadata;
impl<'a, C: CommandRunner, T: AsRef<str>> GitCheckout<'a, C, T> {
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<dyn Error>> {
let mut new_args = vec!["-C", self.target.as_ref()];
new_args.extend_from_slice(args);
self.command_runner.get_output("git", &new_args)
@ -37,7 +37,7 @@ impl<'a, C: CommandRunner, T: AsRef<str>> GitCheckout<'a, C, T> {
}
impl<'a, C: CommandRunner, T: AsRef<str>> Symbol for GitCheckout<'a, C, T> {
fn target_reached(&self) -> Result<bool, Box<Error>> {
fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
if let Err(e) = metadata(self.target.as_ref()) {
return if e.kind() == io::ErrorKind::NotFound {
Ok(false)
@ -52,7 +52,7 @@ impl<'a, C: CommandRunner, T: AsRef<str>> Symbol for GitCheckout<'a, C, T> {
Ok(fetch_head == head)
}
fn execute(&self) -> Result<(), Box<Error>> {
fn execute(&self) -> Result<(), Box<dyn Error>> {
if !Path::new(self.target.as_ref()).exists() {
return self.command_runner.run_successfully("git", &["clone", "--depth", "1", "-b", self.branch, self.source, self.target.as_ref()]);
}
@ -69,11 +69,11 @@ impl<'a, C: CommandRunner, T: AsRef<str>> Symbol for GitCheckout<'a, C, T> {
Some(vec![ Resource::new("dir", self.target.as_ref().to_string()) ])
}
fn as_action<'b>(&'b self, runner: &'b SymbolRunner) -> Box<Action + 'b> {
fn as_action<'b>(&'b self, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> {
Box::new(SymbolAction::new(runner, self))
}
fn into_action<'b>(self: Box<Self>, runner: &'b SymbolRunner) -> Box<Action + 'b> where Self: 'b {
fn into_action<'b>(self: Box<Self>, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> where Self: 'b {
Box::new(OwnedSymbolAction::new(runner, *self))
}
}

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

@ -23,7 +23,7 @@ impl<'a, C: CommandRunner> fmt::Display for GitSubmodules<'a, C> {
}
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<dyn Error>> {
let mut new_args = vec!["-C", self.target];
new_args.extend_from_slice(args);
self.command_runner.get_output("git", &new_args)
@ -31,7 +31,7 @@ impl<'a, C: CommandRunner> GitSubmodules<'a, C> {
}
impl<'a, C: CommandRunner> Symbol for GitSubmodules<'a, C> {
fn target_reached(&self) -> Result<bool, Box<Error>> {
fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
if !Path::new(self.target).exists() {
return Ok(false);
}
@ -39,16 +39,16 @@ impl<'a, C: CommandRunner> Symbol for GitSubmodules<'a, C> {
Ok(output.lines().all(|line| line.is_empty() || line.starts_with(' ')))
}
fn execute(&self) -> Result<(), Box<Error>> {
fn execute(&self) -> Result<(), Box<dyn Error>> {
try!(self._run_in_target_repo(&["submodule", "update", "--init"]));
Ok(())
}
fn as_action<'b>(&'b self, runner: &'b SymbolRunner) -> Box<Action + 'b> {
fn as_action<'b>(&'b self, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> {
Box::new(SymbolAction::new(runner, self))
}
fn into_action<'b>(self: Box<Self>, runner: &'b SymbolRunner) -> Box<Action + 'b> where Self: 'b {
fn into_action<'b>(self: Box<Self>, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> where Self: 'b {
Box::new(OwnedSymbolAction::new(runner, *self))
}
}

24
src/symbols/hook.rs
View file

@ -17,11 +17,11 @@ impl<A, B> Hook<A, B> where A: Symbol, B: Symbol {
}
impl<A, B> Symbol for Hook<A, B> where A: Symbol, B: Symbol {
fn target_reached(&self) -> Result<bool, Box<Error>> {
fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
self.a.target_reached().and_then(|reached| if reached { self.b.target_reached() } else { Ok(reached) })
}
fn execute(&self) -> Result<(), Box<Error>> {
fn execute(&self) -> Result<(), Box<dyn Error>> {
try!(self.a.execute());
self.b.execute()
}
@ -44,11 +44,11 @@ impl<A, B> Symbol for Hook<A, B> where A: Symbol, B: Symbol {
if r.is_empty() { None } else { Some(r) }
}
fn as_action<'a>(&'a self, runner: &'a SymbolRunner) -> Box<Action + 'a> {
fn as_action<'a>(&'a self, runner: &'a dyn SymbolRunner) -> Box<dyn Action + 'a> {
Box::new(SymbolAction::new(runner, self))
}
fn into_action<'a>(self: Box<Self>, runner: &'a SymbolRunner) -> Box<Action + 'a> where Self: 'a {
fn into_action<'a>(self: Box<Self>, runner: &'a dyn SymbolRunner) -> Box<dyn Action + 'a> where Self: 'a {
Box::new(OwnedSymbolAction::new(runner, *self))
}
}
@ -69,13 +69,13 @@ mod test {
struct ErrSymbol(String);
impl Symbol for ErrSymbol {
fn target_reached(&self) -> Result<bool, Box<Error>> { Err(self.0.clone().into()) }
fn execute(&self) -> Result<(), Box<Error>> { Err(self.0.clone().into()) }
fn as_action<'a>(&'a self, runner: &'a SymbolRunner) -> Box<Action + 'a> {
fn target_reached(&self) -> Result<bool, Box<dyn Error>> { Err(self.0.clone().into()) }
fn execute(&self) -> Result<(), Box<dyn Error>> { Err(self.0.clone().into()) }
fn as_action<'a>(&'a self, runner: &'a dyn SymbolRunner) -> Box<dyn Action + 'a> {
Box::new(SymbolAction::new(runner, self))
}
fn into_action<'a>(self: Box<Self>, runner: &'a SymbolRunner) -> Box<Action + 'a> where Self: 'a {
fn into_action<'a>(self: Box<Self>, runner: &'a dyn SymbolRunner) -> Box<dyn Action + 'a> where Self: 'a {
Box::new(OwnedSymbolAction::new(runner, *self))
}
}
@ -83,13 +83,13 @@ mod test {
struct OkSymbol(bool);
impl Symbol for OkSymbol {
fn target_reached(&self) -> Result<bool, Box<Error>> { Ok(self.0) }
fn execute(&self) -> Result<(), Box<Error>> { Ok(()) }
fn as_action<'a>(&'a self, runner: &'a SymbolRunner) -> Box<Action + 'a> {
fn target_reached(&self) -> Result<bool, Box<dyn Error>> { Ok(self.0) }
fn execute(&self) -> Result<(), Box<dyn Error>> { Ok(()) }
fn as_action<'a>(&'a self, runner: &'a dyn SymbolRunner) -> Box<dyn Action + 'a> {
Box::new(SymbolAction::new(runner, self))
}
fn into_action<'a>(self: Box<Self>, runner: &'a SymbolRunner) -> Box<Action + 'a> where Self: 'a {
fn into_action<'a>(self: Box<Self>, runner: &'a dyn SymbolRunner) -> Box<dyn Action + 'a> where Self: 'a {
Box::new(OwnedSymbolAction::new(runner, *self))
}
}

26
src/symbols/list.rs
View file

@ -5,17 +5,17 @@ use resources::Resource;
use symbols::{Action, Symbol, SymbolRunner};
pub struct List<'a> {
symbols: Vec<Box<Symbol + 'a>>
symbols: Vec<Box<dyn Symbol + 'a>>
}
impl<'a> List<'a> {
pub fn new(symbols: Vec<Box<Symbol + 'a>>) -> Self {
pub fn new(symbols: Vec<Box<dyn Symbol + 'a>>) -> Self {
List { symbols }
}
}
impl<'a> Symbol for List<'a> {
fn target_reached(&self) -> Result<bool, Box<Error>> {
fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
for symbol in &self.symbols {
if !try!(symbol.target_reached()) {
return Ok(false);
@ -24,7 +24,7 @@ impl<'a> Symbol for List<'a> {
Ok(true)
}
fn execute(&self) -> Result<(), Box<Error>> {
fn execute(&self) -> Result<(), Box<dyn Error>> {
for symbol in &self.symbols {
try!(symbol.execute());
}
@ -51,28 +51,28 @@ impl<'a> Symbol for List<'a> {
if r.is_empty() { None } else { Some(r) }
}
fn as_action<'b>(&'b self, runner: &'b SymbolRunner) -> Box<Action + 'b> {
fn as_action<'b>(&'b self, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> {
Box::new(SymbolListAction::new(runner, &self.symbols))
}
fn into_action<'b>(self: Box<Self>, runner: &'b SymbolRunner) -> Box<Action + 'b> where Self: 'b {
fn into_action<'b>(self: Box<Self>, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> where Self: 'b {
Box::new(ListAction::new(self.symbols.into_iter().map(|s| s.into_action(runner)).collect()))
}
}
struct SymbolListAction<'a> {
runner: &'a SymbolRunner,
symbols: &'a [Box<Symbol + 'a>]
runner: &'a dyn SymbolRunner,
symbols: &'a [Box<dyn Symbol + 'a>]
}
impl<'a> SymbolListAction<'a> {
fn new(runner: &'a SymbolRunner, symbols: &'a [Box<Symbol + 'a>]) -> Self {
fn new(runner: &'a dyn SymbolRunner, symbols: &'a [Box<dyn Symbol + 'a>]) -> Self {
Self { runner, symbols }
}
}
impl<'a> Action for SymbolListAction<'a> {
fn run(&self) -> Result<(), Box<Error>> {
fn run(&self) -> Result<(), Box<dyn Error>> {
for symbol in self.symbols {
try!(symbol.as_action(self.runner).run());
}
@ -81,17 +81,17 @@ impl<'a> Action for SymbolListAction<'a> {
}
pub struct ListAction<'a> {
actions: Vec<Box<Action + 'a>>
actions: Vec<Box<dyn Action + 'a>>
}
impl<'a> ListAction<'a> {
pub fn new(actions: Vec<Box<Action + 'a>>) -> Self {
pub fn new(actions: Vec<Box<dyn Action + 'a>>) -> Self {
Self { actions }
}
}
impl<'a> Action for ListAction<'a> {
fn run(&self) -> Result<(), Box<Error>> {
fn run(&self) -> Result<(), Box<dyn Error>> {
for action in &self.actions {
try!(action.run());
}

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

@ -16,7 +16,7 @@ impl<'a, C: CommandRunner> MariaDBDatabase<'a, C> {
MariaDBDatabase { db_name, seed_file, command_runner }
}
fn run_sql(&self, sql: &str) -> Result<String, Box<Error>> {
fn run_sql(&self, sql: &str) -> Result<String, Box<dyn Error>> {
let b = try!(self.command_runner.get_output("mariadb", &["--skip-column-names", "-B", "-e", sql]));
Ok(try!(String::from_utf8(b)))
}
@ -29,20 +29,20 @@ impl<'a, C: CommandRunner> fmt::Display for MariaDBDatabase<'a, C> {
}
impl<'a, C: CommandRunner> Symbol for MariaDBDatabase<'a, C> {
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)
fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
Ok(try!(self.run_sql(&format!("SHOW DATABASES LIKE '{}'", self.db_name))).trim_end() == self.db_name)
}
fn execute(&self) -> Result<(), Box<Error>> {
fn execute(&self) -> Result<(), Box<dyn Error>> {
try!(self.run_sql(&format!("CREATE DATABASE {}", self.db_name)));
self.command_runner.run_successfully("sh", &["-c", &format!("mariadb '{}' < {}", self.db_name, self.seed_file)])
}
fn as_action<'b>(&'b self, runner: &'b SymbolRunner) -> Box<Action + 'b> {
fn as_action<'b>(&'b self, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> {
Box::new(SymbolAction::new(runner, self))
}
fn into_action<'b>(self: Box<Self>, runner: &'b SymbolRunner) -> Box<Action + 'b> where Self: 'b {
fn into_action<'b>(self: Box<Self>, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> where Self: 'b {
Box::new(OwnedSymbolAction::new(runner, *self))
}
}

14
src/symbols/mariadb/database_dump.rs
View file

@ -17,7 +17,7 @@ impl<'a, N: AsRef<str>, C: CommandRunner, S: Storage> DatabaseDump<'a, N, C, S>
DatabaseDump { db_name, storage, command_runner }
}
fn run_sql(&self, sql: &str) -> Result<String, Box<Error>> {
fn run_sql(&self, sql: &str) -> Result<String, Box<dyn Error>> {
let b = try!(self.command_runner.get_output("mariadb", &["--skip-column-names", "-B", "-e", sql]));
Ok(try!(String::from_utf8(b)))
}
@ -30,22 +30,22 @@ impl<'a, N: AsRef<str>, C: CommandRunner, S: Storage> fmt::Display for DatabaseD
}
impl<'a, N: AsRef<str>, C: CommandRunner, S: Storage> Symbol for DatabaseDump<'a, N, C, S> {
fn target_reached(&self) -> Result<bool, Box<Error>> {
fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
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.as_ref())));
if modified_date.trim_right() == "NULL" { return Ok(false); }
Ok(try!(u64::from_str(modified_date.trim_right())) <= dump_date)
if modified_date.trim_end() == "NULL" { return Ok(false); }
Ok(try!(u64::from_str(modified_date.trim_end())) <= dump_date)
}
fn execute(&self) -> Result<(), Box<Error>> {
fn execute(&self) -> Result<(), Box<dyn Error>> {
self.command_runner.run_successfully("sh", &["-c", &format!("mysqldump '{}' > {}", self.db_name.as_ref(), self.storage.write_filename())])
}
fn as_action<'b>(&'b self, runner: &'b SymbolRunner) -> Box<Action + 'b> {
fn as_action<'b>(&'b self, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> {
Box::new(SymbolAction::new(runner, self))
}
fn into_action<'b>(self: Box<Self>, runner: &'b SymbolRunner) -> Box<Action + 'b> where Self: 'b {
fn into_action<'b>(self: Box<Self>, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> where Self: 'b {
Box::new(OwnedSymbolAction::new(runner, *self))
}
}

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

@ -16,7 +16,7 @@ impl<'a, C: CommandRunner> MariaDBUser<'a, C> {
MariaDBUser { user_name, command_runner }
}
fn run_sql(&self, sql: &str) -> Result<String, Box<Error>> {
fn run_sql(&self, sql: &str) -> Result<String, Box<dyn Error>> {
let b = try!(self.command_runner.get_output("mariadb", &["--skip-column-names", "-B", "-e", sql]));
Ok(try!(String::from_utf8(b)))
}
@ -29,11 +29,11 @@ impl<'a, C: CommandRunner> fmt::Display for MariaDBUser<'a, C> {
}
impl<'a, C: CommandRunner> Symbol for MariaDBUser<'a, C> {
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)
fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
Ok(try!(self.run_sql(&format!("SELECT User FROM mysql.user WHERE User = '{}' AND plugin = 'unix_socket'", self.user_name))).trim_end() == self.user_name)
}
fn execute(&self) -> Result<(), Box<Error>> {
fn execute(&self) -> Result<(), Box<dyn Error>> {
try!(self.run_sql(&format!("GRANT ALL ON {0}.* TO {0} IDENTIFIED VIA unix_socket", self.user_name)));
Ok(())
}
@ -42,11 +42,11 @@ impl<'a, C: CommandRunner> Symbol for MariaDBUser<'a, C> {
vec![ Resource::new("user", self.user_name.to_string()) ]
}
fn as_action<'b>(&'b self, runner: &'b SymbolRunner) -> Box<Action + 'b> {
fn as_action<'b>(&'b self, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> {
Box::new(SymbolAction::new(runner, self))
}
fn into_action<'b>(self: Box<Self>, runner: &'b SymbolRunner) -> Box<Action + 'b> where Self: 'b {
fn into_action<'b>(self: Box<Self>, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> where Self: 'b {
Box::new(OwnedSymbolAction::new(runner, *self))
}
}

26
src/symbols/mod.rs
View file

@ -3,64 +3,64 @@ use std::fmt::Display;
use resources::Resource;
pub trait Action {
fn run(&self) -> Result<(), Box<Error>>;
fn run(&self) -> Result<(), Box<dyn Error>>;
}
pub trait SymbolRunner {
fn run_symbol(&self, symbol: &Symbol) -> Result<(), Box<Error>>;
fn run_symbol(&self, symbol: &dyn Symbol) -> Result<(), Box<dyn Error>>;
}
impl<R: SymbolRunner + ?Sized> SymbolRunner for Box<R> {
fn run_symbol(&self, symbol: &Symbol) -> Result<(), Box<Error>> {
fn run_symbol(&self, symbol: &dyn Symbol) -> Result<(), Box<dyn Error>> {
(**self).run_symbol(symbol)
}
}
// Symbol
pub trait Symbol: Display {
fn target_reached(&self) -> Result<bool, Box<Error>>;
fn execute(&self) -> Result<(), Box<Error>>;
fn target_reached(&self) -> Result<bool, Box<dyn Error>>;
fn execute(&self) -> Result<(), Box<dyn Error>>;
fn get_prerequisites(&self) -> Vec<Resource> {
vec![]
}
fn provides(&self) -> Option<Vec<Resource>> {
None
}
fn as_action<'a>(&'a self, runner: &'a SymbolRunner) -> Box<Action + 'a>;
fn into_action<'a>(self: Box<Self>, runner: &'a SymbolRunner) -> Box<Action + 'a> where Self: 'a;
fn as_action<'a>(&'a self, runner: &'a dyn SymbolRunner) -> Box<dyn Action + 'a>;
fn into_action<'a>(self: Box<Self>, runner: &'a dyn SymbolRunner) -> Box<dyn Action + 'a> where Self: 'a;
}
// SymbolAction
pub struct SymbolAction<'a, S: Symbol + 'a> {
runner: &'a SymbolRunner,
runner: &'a dyn SymbolRunner,
symbol: &'a S
}
impl<'a, S: Symbol> SymbolAction<'a, S> {
pub fn new(runner: &'a SymbolRunner, symbol: &'a S) -> Self {
pub fn new(runner: &'a dyn SymbolRunner, symbol: &'a S) -> Self {
Self { runner, symbol }
}
}
impl<'a, S: Symbol> Action for SymbolAction<'a, S> {
fn run(&self) -> Result<(), Box<Error>> {
fn run(&self) -> Result<(), Box<dyn Error>> {
self.runner.run_symbol(self.symbol)
}
}
pub struct OwnedSymbolAction<'a, S: Symbol + 'a> {
runner: &'a SymbolRunner,
runner: &'a dyn SymbolRunner,
symbol: S
}
impl<'a, S: Symbol + 'a> OwnedSymbolAction<'a, S> {
pub fn new(runner: &'a SymbolRunner, symbol: S) -> Self {
pub fn new(runner: &'a dyn SymbolRunner, symbol: S) -> Self {
Self { runner, symbol }
}
}
impl<'a, S: Symbol + 'a> Action for OwnedSymbolAction<'a, S> {
fn run(&self) -> Result<(), Box<Error>> {
fn run(&self) -> Result<(), Box<dyn Error>> {
self.runner.run_symbol(&self.symbol)
}
}

10
src/symbols/nginx/server.rs
View file

@ -27,7 +27,7 @@ impl<E: Error> Error for NginxServerError<E> {
NginxServerError::GenericError => "Generic error"
}
}
fn cause(&self) -> Option<&Error> {
fn cause(&self) -> Option<&dyn Error> {
match self {
NginxServerError::ExecError(ref e) => Some(e),
_ => None
@ -157,7 +157,7 @@ location @proxy {{
}
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<dyn Error>> {
if !try!(self.file.target_reached()) {
return Ok(false);
}
@ -165,7 +165,7 @@ impl<'a, C: CommandRunner, T> Symbol for NginxServer<'a, C, T> where T: Deref<Ta
Ok(true)
}
fn execute(&self) -> Result<(), Box<Error>> {
fn execute(&self) -> Result<(), Box<dyn Error>> {
try!(self.file.execute());
self.command_runner.run_successfully("systemctl", &["reload-or-restart", "nginx"])
}
@ -174,11 +174,11 @@ impl<'a, C: CommandRunner, T> Symbol for NginxServer<'a, C, T> where T: Deref<Ta
self.file.get_prerequisites()
}
fn as_action<'b>(&'b self, runner: &'b SymbolRunner) -> Box<Action + 'b> {
fn as_action<'b>(&'b self, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> {
Box::new(SymbolAction::new(runner, self))
}
fn into_action<'b>(self: Box<Self>, runner: &'b SymbolRunner) -> Box<Action + 'b> where Self: 'b {
fn into_action<'b>(self: Box<Self>, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> where Self: 'b {
Box::new(OwnedSymbolAction::new(runner, *self))
}
}

8
src/symbols/noop.rs
View file

@ -6,17 +6,17 @@ use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner};
pub struct NoopSymbol;
impl Symbol for NoopSymbol {
fn target_reached(&self) -> Result<bool, Box<Error>> {
fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
Ok(true)
}
fn execute(&self) -> Result<(), Box<Error>> {
fn execute(&self) -> Result<(), Box<dyn Error>> {
Ok(())
}
fn as_action<'a>(&'a self, runner: &'a SymbolRunner) -> Box<Action + 'a> {
fn as_action<'a>(&'a self, runner: &'a dyn SymbolRunner) -> Box<dyn Action + 'a> {
Box::new(SymbolAction::new(runner, self))
}
fn into_action<'a>(self: Box<Self>, runner: &'a SymbolRunner) -> Box<Action + 'a> where Self: 'a {
fn into_action<'a>(self: Box<Self>, runner: &'a dyn SymbolRunner) -> Box<dyn Action + 'a> where Self: 'a {
Box::new(OwnedSymbolAction::new(runner, *self))
}
}

8
src/symbols/npm.rs
View file

@ -23,7 +23,7 @@ impl<'a, C: CommandRunner> fmt::Display for NpmInstall<'a, C> {
}
impl<'a, C: CommandRunner> Symbol for NpmInstall<'a, C> {
fn target_reached(&self) -> Result<bool, Box<Error>> {
fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
if !Path::new(self.target).exists() {
return Ok(false);
}
@ -31,15 +31,15 @@ impl<'a, C: CommandRunner> Symbol for NpmInstall<'a, C> {
Ok(result.status.success() && !String::from_utf8(result.stdout).unwrap().contains("(empty)"))
}
fn execute(&self) -> Result<(), Box<Error>> {
fn execute(&self) -> Result<(), Box<dyn Error>> {
self.command_runner.run_successfully("sh", &["-c", &format!("cd '{}' && npm install --production --unsafe-perm", self.target)])
}
fn as_action<'b>(&'b self, runner: &'b SymbolRunner) -> Box<Action + 'b> {
fn as_action<'b>(&'b self, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> {
Box::new(SymbolAction::new(runner, self))
}
fn into_action<'b>(self: Box<Self>, runner: &'b SymbolRunner) -> Box<Action + 'b> where Self: 'b {
fn into_action<'b>(self: Box<Self>, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> where Self: 'b {
Box::new(OwnedSymbolAction::new(runner, *self))
}
}

8
src/symbols/owner.rs
View file

@ -24,7 +24,7 @@ impl<'a, C: CommandRunner, D> Owner<'a, C, D> where D: AsRef<str> {
}
impl<'a, C: CommandRunner, D> Symbol for Owner<'a, C, D> where D: AsRef<str> {
fn target_reached(&self) -> Result<bool, Box<Error>> {
fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
if !Path::new(self.path.as_ref()).exists() {
return Ok(false);
}
@ -33,7 +33,7 @@ impl<'a, C: CommandRunner, D> Symbol for Owner<'a, C, D> where D: AsRef<str> {
Ok(actual_uid == target_uid)
}
fn execute(&self) -> Result<(), Box<Error>> {
fn execute(&self) -> Result<(), Box<dyn Error>> {
self.command_runner.run_successfully("chown", &["-R", self.user_name.borrow(), self.path.as_ref()])
}
@ -41,11 +41,11 @@ impl<'a, C: CommandRunner, D> Symbol for Owner<'a, C, D> where D: AsRef<str> {
vec![ Resource::new("user", self.user_name.to_string()) ]
}
fn as_action<'b>(&'b self, runner: &'b SymbolRunner) -> Box<Action + 'b> {
fn as_action<'b>(&'b self, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> {
Box::new(SymbolAction::new(runner, self))
}
fn into_action<'b>(self: Box<Self>, runner: &'b SymbolRunner) -> Box<Action + 'b> where Self: 'b {
fn into_action<'b>(self: Box<Self>, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> where Self: 'b {
Box::new(OwnedSymbolAction::new(runner, *self))
}
}

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

@ -16,7 +16,7 @@ impl<'a, C: CommandRunner> PostgreSQLDatabase<'a, C> {
PostgreSQLDatabase { name, seed_file, command_runner }
}
fn run_sql(&self, sql: &str) -> Result<String, Box<Error>> {
fn run_sql(&self, sql: &str) -> Result<String, Box<dyn Error>> {
let b = try!(self.command_runner.get_output("su", &["-", "postgres", "-c", &format!("psql -t -c \"{}\"", sql)]));
Ok(try!(String::from_utf8(b)))
}
@ -29,21 +29,21 @@ impl<'a, C: CommandRunner> fmt::Display for PostgreSQLDatabase<'a, C> {
}
impl<'a, C: CommandRunner> Symbol for PostgreSQLDatabase<'a, C> {
fn target_reached(&self) -> Result<bool, Box<Error>> {
fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
Ok(try!(self.run_sql(&format!("SELECT datname FROM pg_database WHERE datname LIKE '{}'", self.name))).trim() == self.name)
}
fn execute(&self) -> Result<(), Box<Error>> {
fn execute(&self) -> Result<(), Box<dyn Error>> {
self.command_runner.run_successfully("su", &["-", "postgres", "-c", &format!("createuser {}", self.name)])?;
self.command_runner.run_successfully("su", &["-", "postgres", "-c", &format!("createdb -E UTF8 -T template0 -O {} {0}", self.name)])?;
self.command_runner.run_successfully("su", &["-", "postgres", "-c", &format!("psql '{}' < {}", self.name, self.seed_file)])
}
fn as_action<'b>(&'b self, runner: &'b SymbolRunner) -> Box<Action + 'b> {
fn as_action<'b>(&'b self, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> {
Box::new(SymbolAction::new(runner, self))
}
fn into_action<'b>(self: Box<Self>, runner: &'b SymbolRunner) -> Box<Action + 'b> where Self: 'b {
fn into_action<'b>(self: Box<Self>, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> where Self: 'b {
Box::new(OwnedSymbolAction::new(runner, *self))
}
}

14
src/symbols/postgresql/database_dump.rs
View file

@ -17,7 +17,7 @@ impl<'a, N: AsRef<str>, C: CommandRunner, S: Storage> DatabaseDump<'a, N, C, S>
DatabaseDump { db_name, storage, command_runner }
}
fn run_sql(&self, sql: &str) -> Result<String, Box<Error>> {
fn run_sql(&self, sql: &str) -> Result<String, Box<dyn Error>> {
let b = try!(self.command_runner.get_output("mariadb", &["--skip-column-names", "-B", "-e", sql]));
Ok(try!(String::from_utf8(b)))
}
@ -30,22 +30,22 @@ impl<'a, N: AsRef<str>, C: CommandRunner, S: Storage> fmt::Display for DatabaseD
}
impl<'a, N: AsRef<str>, C: CommandRunner, S: Storage> Symbol for DatabaseDump<'a, N, C, S> {
fn target_reached(&self) -> Result<bool, Box<Error>> {
fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
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.as_ref())));
if modified_date.trim_right() == "NULL" { return Ok(false); }
Ok(try!(u64::from_str(modified_date.trim_right())) <= dump_date)
if modified_date.trim_end() == "NULL" { return Ok(false); }
Ok(try!(u64::from_str(modified_date.trim_end())) <= dump_date)
}
fn execute(&self) -> Result<(), Box<Error>> {
fn execute(&self) -> Result<(), Box<dyn Error>> {
self.command_runner.run_successfully("sh", &["-c", &format!("mysqldump '{}' > {}", self.db_name.as_ref(), self.storage.write_filename())])
}
fn as_action<'b>(&'b self, runner: &'b SymbolRunner) -> Box<Action + 'b> {
fn as_action<'b>(&'b self, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> {
Box::new(SymbolAction::new(runner, self))
}
fn into_action<'b>(self: Box<Self>, runner: &'b SymbolRunner) -> Box<Action + 'b> where Self: 'b {
fn into_action<'b>(self: Box<Self>, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> where Self: 'b {
Box::new(OwnedSymbolAction::new(runner, *self))
}
}

10
src/symbols/stored_directory.rs
View file

@ -34,7 +34,7 @@ impl<'a, S, C: CommandRunner> fmt::Display for StoredDirectory<'a, S, C> where S
}
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<dyn Error>> {
let metadata = fs::metadata(self.path.as_ref());
// Check if dir exists
if let Err(e) = metadata {
@ -50,7 +50,7 @@ impl<'a, S, C: CommandRunner> Symbol for StoredDirectory<'a, S, C> where S: Stor
let dump_date = try!(self.storage.recent_date());
let output = try!(self.command_runner.get_output("sh", &["-c", &format!("find {} -printf '%T@\\n' | sort -r | head -n1 | grep '^[0-9]\\+' -o", self.path)]));
let modified_date = try!(u64::from_str(try!(String::from_utf8(output)).trim_right()));
let modified_date = try!(u64::from_str(try!(String::from_utf8(output)).trim_end()));
if if self.dir == StorageDirection::Save { modified_date > dump_date } else { dump_date > modified_date } {
let output = try!(self.command_runner.run_with_args("diff", &["-rq", &try!(self.storage.read_filename()), self.path.borrow()]));
match output.status.code() {
@ -61,7 +61,7 @@ impl<'a, S, C: CommandRunner> Symbol for StoredDirectory<'a, S, C> where S: Stor
} else { Ok(true) }
}
fn execute(&self) -> Result<(), Box<Error>> {
fn execute(&self) -> Result<(), Box<dyn Error>> {
if self.dir == StorageDirection::Load {
try!(self.command_runner.run_successfully("rm", &["-rf", self.path.borrow()]));
self.command_runner.run_successfully("cp", &["-a", &try!(self.storage.read_filename()), self.path.borrow()])
@ -87,11 +87,11 @@ impl<'a, S, C: CommandRunner> Symbol for StoredDirectory<'a, S, C> where S: Stor
}
}
fn as_action<'b>(&'b self, runner: &'b SymbolRunner) -> Box<Action + 'b> {
fn as_action<'b>(&'b self, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> {
Box::new(SymbolAction::new(runner, self))
}
fn into_action<'b>(self: Box<Self>, runner: &'b SymbolRunner) -> Box<Action + 'b> where Self: 'b {
fn into_action<'b>(self: Box<Self>, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> where Self: 'b {
Box::new(OwnedSymbolAction::new(runner, *self))
}
}

22
src/symbols/systemd/node_js_user_service.rs
View file

@ -33,7 +33,7 @@ impl<E: Error> Error for NodeJsSystemdUserServiceError<E> {
NodeJsSystemdUserServiceError::ActivationFailed(_) => "Activation of service failed"
}
}
fn cause(&self) -> Option<&Error> {
fn cause(&self) -> Option<&dyn Error> {
match self {
NodeJsSystemdUserServiceError::ExecError(ref e) => Some(e),
_ => None
@ -60,7 +60,7 @@ pub struct NodeJsSystemdUserService<'a, C, R> where C: Deref<Target=str>, R: Com
impl<'a, R> NodeJsSystemdUserService<'a, String, SetuidCommandRunner<'a, R>> where R: CommandRunner {
pub fn new(home: &'a str, user_name: &'a str, service_name: &'a str, path: &'a str, command_runner: &'a R) -> Self {
let file_path = format!("{}/.config/systemd/user/{}.service", home.trim_right(), service_name);
let file_path = format!("{}/.config/systemd/user/{}.service", home.trim_end(), service_name);
let port = format!("/var/tmp/{}-{}.socket", user_name, service_name);
let content = format!("[Service]
@ -91,18 +91,18 @@ WantedBy=default.target
impl<'a, C, R> NodeJsSystemdUserService<'a, C, R> where C: Deref<Target=str>, R: CommandRunner {
fn systemctl_wait_for_dbus(&self, args: &[&str]) -> Result<String, Box<Error>> {
fn systemctl_wait_for_dbus(&self, args: &[&str]) -> Result<String, Box<dyn Error>> {
let mut tries = 5;
loop {
let result = try!(self.command_runner.run_with_args("systemctl", args));
if !result.status.success() {
let raw_stderr = try!(String::from_utf8(result.stderr));
let stderr = raw_stderr.trim_right();
let stderr = raw_stderr.trim_end();
if stderr != "Failed to connect to bus: No such file or directory" {
return Err(stderr.into());
}
} else {
return Ok(try!(String::from_utf8(result.stdout)).trim_right().to_string());
return Ok(try!(String::from_utf8(result.stdout)).trim_end().to_string());
}
tries -= 1;
if tries == 0 {
@ -112,7 +112,7 @@ impl<'a, C, R> NodeJsSystemdUserService<'a, C, R> where C: Deref<Target=str>, R:
}
}
fn check_if_service(&self) -> Result<bool, Box<Error>> {
fn check_if_service(&self) -> Result<bool, Box<dyn Error>> {
loop {
let active_state = try!(self.systemctl_wait_for_dbus(&["--user", "show", "--property", "ActiveState", self.service_name]));
match active_state.as_ref() {
@ -126,14 +126,14 @@ impl<'a, C, R> NodeJsSystemdUserService<'a, C, R> where C: Deref<Target=str>, R:
}
impl<'a, C, R> Symbol for NodeJsSystemdUserService<'a, C, R> where C: Deref<Target=str>, R: CommandRunner {
fn target_reached(&self) -> Result<bool, Box<Error>> {
fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
if !(try!(self.file.target_reached())) {
return Ok(false);
}
self.check_if_service()
}
fn execute(&self) -> Result<(), Box<Error>> {
fn execute(&self) -> Result<(), Box<dyn Error>> {
try!(self.file.execute());
try!(self.systemctl_wait_for_dbus(&["--user", "enable", self.service_name]));
try!(self.systemctl_wait_for_dbus(&["--user", "restart", self.service_name]));
@ -143,7 +143,7 @@ impl<'a, C, R> Symbol for NodeJsSystemdUserService<'a, C, R> where C: Deref<Targ
}
let file_name = format!("/var/tmp/{}-{}.socket", self.user_name, self.service_name);
fs::metadata(&file_name).map(|_| ()).map_err(|e| Box::new(e) as Box<Error>)
fs::metadata(&file_name).map(|_| ()).map_err(|e| Box::new(e) as Box<dyn Error>)
}
fn get_prerequisites(&self) -> Vec<Resource> {
@ -152,11 +152,11 @@ impl<'a, C, R> Symbol for NodeJsSystemdUserService<'a, C, R> where C: Deref<Targ
r
}
fn as_action<'b>(&'b self, runner: &'b SymbolRunner) -> Box<Action + 'b> {
fn as_action<'b>(&'b self, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> {
Box::new(SymbolAction::new(runner, self))
}
fn into_action<'b>(self: Box<Self>, runner: &'b SymbolRunner) -> Box<Action + 'b> where Self: 'b {
fn into_action<'b>(self: Box<Self>, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> where Self: 'b {
Box::new(OwnedSymbolAction::new(runner, *self))
}
}

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

@ -16,19 +16,19 @@ impl<'a, C: CommandRunner> ReloadService<'a, C> {
}
impl<'a, C: CommandRunner> Symbol for ReloadService<'a, C> {
fn target_reached(&self) -> Result<bool, Box<Error>> {
fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
Ok(true)
}
fn execute(&self) -> Result<(), Box<Error>> {
fn execute(&self) -> Result<(), Box<dyn Error>> {
self.command_runner.run_successfully("systemctl", &["reload-or-restart", self.service])
}
fn as_action<'b>(&'b self, runner: &'b SymbolRunner) -> Box<Action + 'b> {
fn as_action<'b>(&'b self, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> {
Box::new(SymbolAction::new(runner, self))
}
fn into_action<'b>(self: Box<Self>, runner: &'b SymbolRunner) -> Box<Action + 'b> where Self: 'b {
fn into_action<'b>(self: Box<Self>, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> where Self: 'b {
Box::new(OwnedSymbolAction::new(runner, *self))
}
}

10
src/symbols/systemd/user_session.rs
View file

@ -19,7 +19,7 @@ impl<E: Error> Error for SystemdUserSessionError<E> {
SystemdUserSessionError::GenericError => "Generic error"
}
}
fn cause(&self) -> Option<&Error> {
fn cause(&self) -> Option<&dyn Error> {
match self {
SystemdUserSessionError::ExecError(ref e) => Some(e),
_ => None
@ -45,22 +45,22 @@ impl<'a, C: CommandRunner> SystemdUserSession<'a, C> {
}
impl<'a, C: CommandRunner> Symbol for SystemdUserSession<'a, C> {
fn target_reached(&self) -> Result<bool, Box<Error>> {
fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
let mut path = PathBuf::from("/var/lib/systemd/linger");
path.push(self.user_name.borrow() as &str);
Ok(path.exists())
// Could also do `loginctl show-user ${self.user_name} | grep -F 'Linger=yes`
}
fn execute(&self) -> Result<(), Box<Error>> {
fn execute(&self) -> Result<(), Box<dyn Error>> {
self.command_runner.run_successfully("loginctl", &["enable-linger", self.user_name.borrow()])
}
fn as_action<'b>(&'b self, runner: &'b SymbolRunner) -> Box<Action + 'b> {
fn as_action<'b>(&'b self, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> {
Box::new(SymbolAction::new(runner, self))
}
fn into_action<'b>(self: Box<Self>, runner: &'b SymbolRunner) -> Box<Action + 'b> where Self: 'b {
fn into_action<'b>(self: Box<Self>, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> where Self: 'b {
Box::new(OwnedSymbolAction::new(runner, *self))
}
}

8
src/symbols/tls/csr.rs
View file

@ -33,7 +33,7 @@ impl<'a, C: CommandRunner> fmt::Display for TlsCsr<'a, C> {
}
impl<'a, C: CommandRunner> Symbol for TlsCsr<'a, C> {
fn target_reached(&self) -> Result<bool, Box<Error>> {
fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
if !Path::new(&self.get_csr_path()).exists() {
return Ok(false);
}
@ -42,7 +42,7 @@ impl<'a, C: CommandRunner> Symbol for TlsCsr<'a, C> {
Ok(output == b"verify OK\n")
}
fn execute(&self) -> Result<(), Box<Error>> {
fn execute(&self) -> Result<(), Box<dyn Error>> {
try!(self.command_runner.run_successfully("openssl", &["req", "-new", "-sha256", "-key", &self.get_key_path(), "-out", &self.get_csr_path(), "-subj", &format!("/CN={}", self.domain)]));
Ok(())
}
@ -51,11 +51,11 @@ impl<'a, C: CommandRunner> Symbol for TlsCsr<'a, C> {
vec![Resource::new("file", self.get_key_path())]
}
fn as_action<'b>(&'b self, runner: &'b SymbolRunner) -> Box<Action + 'b> {
fn as_action<'b>(&'b self, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> {
Box::new(SymbolAction::new(runner, self))
}
fn into_action<'b>(self: Box<Self>, runner: &'b SymbolRunner) -> Box<Action + 'b> where Self: 'b {
fn into_action<'b>(self: Box<Self>, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> where Self: 'b {
Box::new(OwnedSymbolAction::new(runner, *self))
}
}

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

@ -32,7 +32,7 @@ impl<'a, C: CommandRunner> fmt::Display for TlsKey<'a, C> {
}
impl<'a, C: CommandRunner> Symbol for TlsKey<'a, C> {
fn target_reached(&self) -> Result<bool, Box<Error>> {
fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
if !Path::new(&self.get_path()).exists() {
return Ok(false);
}
@ -41,15 +41,15 @@ impl<'a, C: CommandRunner> Symbol for TlsKey<'a, C> {
Ok(output.starts_with(&format!("Private-Key: ({} bit)\n", self.get_bytes()).as_bytes()))
}
fn execute(&self) -> Result<(), Box<Error>> {
fn execute(&self) -> Result<(), Box<dyn Error>> {
self.command_runner.run_successfully("openssl", &["genrsa", "-out", &self.get_path(), &self.get_bytes().to_string()])
}
fn as_action<'b>(&'b self, runner: &'b SymbolRunner) -> Box<Action + 'b> {
fn as_action<'b>(&'b self, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> {
Box::new(SymbolAction::new(runner, self))
}
fn into_action<'b>(self: Box<Self>, runner: &'b SymbolRunner) -> Box<Action + 'b> where Self: 'b {
fn into_action<'b>(self: Box<Self>, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> where Self: 'b {
Box::new(OwnedSymbolAction::new(runner, *self))
}
}

8
src/symbols/tls/self_signed_cert.rs
View file

@ -35,7 +35,7 @@ impl<'a, C: CommandRunner> fmt::Display for SelfSignedTlsCert<'a, C> {
const DAYS_IN_SECONDS: u32 = 24*60*60;
impl<'a, C: CommandRunner> Symbol for SelfSignedTlsCert<'a, C> {
fn target_reached(&self) -> Result<bool, Box<Error>> {
fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
if !Path::new(&self.get_cert_path()).exists() {
return Ok(false);
}
@ -53,7 +53,7 @@ println!("{}", output.status.code().unwrap());
}
fn execute(&self) -> Result<(), Box<Error>> {
fn execute(&self) -> Result<(), Box<dyn Error>> {
self.command_runner.run_successfully("openssl", &["req", "-x509", "-sha256", "-days", "90", "-key", &self.get_key_path(), "-out", &self.get_cert_path(), "-subj", &format!("/CN={}", self.domain)])
}
@ -61,11 +61,11 @@ println!("{}", output.status.code().unwrap());
vec![Resource::new("file", self.get_key_path())]
}
fn as_action<'b>(&'b self, runner: &'b SymbolRunner) -> Box<Action + 'b> {
fn as_action<'b>(&'b self, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> {
Box::new(SymbolAction::new(runner, self))
}
fn into_action<'b>(self: Box<Self>, runner: &'b SymbolRunner) -> Box<Action + 'b> where Self: 'b {
fn into_action<'b>(self: Box<Self>, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> where Self: 'b {
Box::new(OwnedSymbolAction::new(runner, *self))
}
}

18
src/symbols/user.rs
View file

@ -10,7 +10,7 @@ use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner};
pub enum UserAdderError {
AlreadyExists,
UnknownError,
ImplError(Box<Error>)
ImplError(Box<dyn Error>)
}
impl Error for UserAdderError {
@ -21,7 +21,7 @@ impl Error for UserAdderError {
UserAdderError::ImplError(_) => "User adding error"
}
}
fn cause(&self) -> Option<&Error> {
fn cause(&self) -> Option<&dyn Error> {
match self {
UserAdderError::ImplError(ref e) => Some(e.as_ref()),
_ => None
@ -53,7 +53,7 @@ impl Error for UserError {
UserError::GenericError => "Could not find out if user exists"
}
}
fn cause(&self) -> Option<&Error> {
fn cause(&self) -> Option<&dyn Error> {
match self {
_ => None
}
@ -88,7 +88,7 @@ impl<'a, C: CommandRunner, A: 'a + UserAdder> fmt::Display for User<'a, C, A> {
}
impl<'a, C: CommandRunner, A: 'a + UserAdder> Symbol for User<'a, C, A> {
fn target_reached(&self) -> Result<bool, Box<Error>> {
fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
let output = try!(self.command_runner.run_with_args("getent", &["passwd", &*self.user_name]));
match output.status.code() {
Some(2) => Ok(false),
@ -97,19 +97,19 @@ impl<'a, C: CommandRunner, A: 'a + UserAdder> Symbol for User<'a, C, A> {
}
}
fn execute(&self) -> Result<(), Box<Error>> {
self.user_adder.add_user(&*self.user_name).map_err(|e| Box::new(e) as Box<Error>)
fn execute(&self) -> Result<(), Box<dyn Error>> {
self.user_adder.add_user(&*self.user_name).map_err(|e| Box::new(e) as Box<dyn Error>)
}
fn provides(&self) -> Option<Vec<Resource>> {
Some(vec![Resource::new("user", self.user_name.to_string())])
}
fn as_action<'b>(&'b self, runner: &'b SymbolRunner) -> Box<Action + 'b> {
fn as_action<'b>(&'b self, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> {
Box::new(SymbolAction::new(runner, self))
}
fn into_action<'b>(self: Box<Self>, runner: &'b SymbolRunner) -> Box<Action + 'b> where Self: 'b {
fn into_action<'b>(self: Box<Self>, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> where Self: 'b {
Box::new(OwnedSymbolAction::new(runner, *self))
}
}
@ -183,7 +183,7 @@ mod test {
struct DummyUserAdder;
impl UserAdder for DummyUserAdder {
fn add_user(&self, user_name: &str) -> Result<(), UserAdderError> {
fn add_user(&self, _user_name: &str) -> Result<(), UserAdderError> {
Ok(())
}
}

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

@ -28,7 +28,7 @@ impl<'a, C, R> WordpressPlugin<'a, C, R> where C: Deref<Target=str>, R: CommandR
}
impl<'a, C, R> Symbol for WordpressPlugin<'a, C, R> where C: Deref<Target=str>, R: CommandRunner {
fn target_reached(&self) -> Result<bool, Box<Error>> {
fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
if !self.get_path().exists() {
return Ok(false);
}
@ -45,7 +45,7 @@ impl<'a, C, R> Symbol for WordpressPlugin<'a, C, R> where C: Deref<Target=str>,
};
},
Ok(file) => {
let mut reader = BufReader::new(file);
let reader = BufReader::new(file);
let regex = Regex::new("(?m)^(Plugin URI|Version): (.+)$")?;
for content in reader.lines() {
for matches in regex.captures_iter(&(content?)) {
@ -62,7 +62,7 @@ impl<'a, C, R> Symbol for WordpressPlugin<'a, C, R> where C: Deref<Target=str>,
Ok(try!(String::from_utf8(upstream)).contains(r###""plugins":[]"###))
}
fn execute(&self) -> Result<(), Box<Error>> {
fn execute(&self) -> Result<(), Box<dyn Error>> {
let source = format!("https://downloads.wordpress.org/plugin/{}.zip", &*self.name);
let zip = format!("/tmp/{}.zip", &*self.name);
try!(self.command_runner.run_successfully("curl", &[source.as_ref() as &str, "-o", zip.as_ref()]));
@ -77,11 +77,11 @@ impl<'a, C, R> Symbol for WordpressPlugin<'a, C, R> where C: Deref<Target=str>,
}
}
fn as_action<'b>(&'b self, runner: &'b SymbolRunner) -> Box<Action + 'b> {
fn as_action<'b>(&'b self, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> {
Box::new(SymbolAction::new(runner, self))
}
fn into_action<'b>(self: Box<Self>, runner: &'b SymbolRunner) -> Box<Action + 'b> where Self: 'b {
fn into_action<'b>(self: Box<Self>, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> where Self: 'b {
Box::new(OwnedSymbolAction::new(runner, *self))
}
}

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

@ -31,7 +31,7 @@ impl<'a, C, R> WordpressTranslation<'a, C, String, R> where C: AsRef<str>, R: Co
impl<'a, C, D, R> WordpressTranslation<'a, C, D, R> where C: AsRef<str>, D: AsRef<str>, R: CommandRunner {
fn get_pairs(&self) -> Vec<(String, String)> {
let version_x = self.version.trim_right_matches(|c: char| c.is_digit(10)).to_owned() + "x";
let version_x = self.version.trim_end_matches(|c: char| c.is_digit(10)).to_owned() + "x";
let locale: &str = self.locale.as_ref();
let path_locale = if locale == "de_DE" { "de".to_owned() } else { locale.to_lowercase().replace('_', "-") };
let mut res = vec![];
@ -48,7 +48,7 @@ impl<'a, C, D, R> WordpressTranslation<'a, C, D, R> where C: AsRef<str>, D: AsRe
}
impl<'a, C, D, R> Symbol for WordpressTranslation<'a, C, D, R> where C: AsRef<str>, D: AsRef<str>, R: CommandRunner {
fn target_reached(&self) -> Result<bool, Box<Error>> {
fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
let mut newest = String::new();
let match_date = Regex::new("(?m)^\"PO-Revision-Date: (.+)\\+0000\\\\n\"$").unwrap();
for (_, target) in self.get_pairs() {
@ -61,8 +61,8 @@ impl<'a, C, D, R> Symbol for WordpressTranslation<'a, C, D, R> where C: AsRef<st
Err(Box::new(e))
};
},
Ok(mut file) => if target.ends_with(".po") {
let mut reader = BufReader::new(file);
Ok(file) => if target.ends_with(".po") {
let reader = BufReader::new(file);
for content in reader.lines() {
if let Some(match_result) = match_date.captures(&try!(content)) {
newest = max(newest, match_result[1].to_string());
@ -76,7 +76,7 @@ impl<'a, C, D, R> Symbol for WordpressTranslation<'a, C, D, R> where C: AsRef<st
Ok(try!(String::from_utf8(upstream)).contains(&format!(r###"language":"{}","version":"{}","updated":"{}"###, self.locale.as_ref(), self.version, newest)))
}
fn execute(&self) -> Result<(), Box<Error>> {
fn execute(&self) -> Result<(), Box<dyn Error>> {
for (source, target) in self.get_pairs() {
try!(self.command_runner.run_successfully("curl", &["--compressed", "-o", &target, &source]));
}
@ -87,11 +87,11 @@ impl<'a, C, D, R> Symbol for WordpressTranslation<'a, C, D, R> where C: AsRef<st
vec![ Resource::new("dir", self.path.as_ref()) ]
}
fn as_action<'b>(&'b self, runner: &'b SymbolRunner) -> Box<Action + 'b> {
fn as_action<'b>(&'b self, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> {
Box::new(SymbolAction::new(runner, self))
}
fn into_action<'b>(self: Box<Self>, runner: &'b SymbolRunner) -> Box<Action + 'b> where Self: 'b {
fn into_action<'b>(self: Box<Self>, runner: &'b dyn SymbolRunner) -> Box<dyn Action + 'b> where Self: 'b {
Box::new(OwnedSymbolAction::new(runner, *self))
}
}