Update

src/symbols/dir.rs

@@ -7,17 +7,17 @@ use std::path::Path;
 use resources::Resource;
 use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner};
 
-pub struct Dir<D> where D: AsRef<str> + fmt::Display {
+pub struct Dir<D> where D: AsRef<str> {
   path: D
 }
 
-impl<D> Dir<D> where D: AsRef<str> + fmt::Display {
+impl<D> Dir<D> where D: AsRef<str> {
   pub fn new(path: D) -> Self {
     Dir { path: path }
   }
 }
 
-impl<D> Symbol for Dir<D> where D: AsRef<str> + fmt::Display {
+impl<D> Symbol for Dir<D> where D: AsRef<str> {
   fn target_reached(&self) -> Result<bool, Box<Error>> {
     let metadata = fs::metadata(self.path.as_ref());
     // Check if dir exists
@@ -48,7 +48,7 @@ impl<D> Symbol for Dir<D> where D: AsRef<str> + fmt::Display {
   }
 
   fn provides(&self) -> Option<Vec<Resource>> {
-    Some(vec![ Resource::new("dir", self.path.to_string()) ])
+    Some(vec![ Resource::new("dir", self.path.as_ref()) ])
   }
 
   fn as_action<'a>(&'a self, runner: &'a SymbolRunner) -> Box<Action + 'a> {
@@ -60,8 +60,8 @@ impl<D> Symbol for Dir<D> where D: AsRef<str> + fmt::Display {
   }
 }
 
-impl<D> fmt::Display for Dir<D> where D: AsRef<str> + fmt::Display {
+impl<D> fmt::Display for Dir<D> where D: AsRef<str> {
   fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error>{
-    write!(f, "Dir {}", self.path)
+    write!(f, "Dir {}", self.path.as_ref())
   }
 }

src/symbols/factory.rs

@@ -1,10 +1,17 @@
+use std::ops::Deref;
+use std::path::Path;
+
 use command_runner::{CommandRunner, SetuidCommandRunner};
+use storage::SimpleStorage;
 use symbols::{Action, Symbol, SymbolRunner};
 use symbols::acme::{AcmeCert, AcmeCertChain};
 use symbols::file::File;
+use symbols::git::checkout::GitCheckout;
 use symbols::hook::Hook;
 use symbols::list::ListAction;
 use symbols::nginx::server::NginxServer;
+use symbols::owner::Owner;
+use symbols::stored_directory::{StoredDirectory, StorageDirection};
 use symbols::systemd::reload::ReloadService;
 use symbols::tls::SelfSignedTlsCert;
 
@@ -86,4 +93,25 @@ pm.max_children = 10"
       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>) {
+    let data = SimpleStorage::new("/root/data".to_string(), storage_name.to_string());
+    let string_target = target.into();
+    (
+      Box::new(StoredDirectory::new(string_target.clone().into(), data.clone(), StorageDirection::Save, self.command_runner)).into_action(self.symbol_runner),
+      Box::new(StoredDirectory::new(string_target.into(), data.clone(), StorageDirection::Load, 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> {
+    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> {
+    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>, P: 'a + AsRef<Path>>(&'a self, path: P, content: F) -> Box<Action + 'a> {
+    Box::new(File::new(path, content)).into_action(self.symbol_runner)
+  }
 }

src/symbols/file.rs

@@ -9,12 +9,12 @@ use std::path::Path;
 use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner};
 use resources::Resource;
 
-pub struct File<C, D> where C: Deref<Target=str>, D: AsRef<str> + fmt::Display {
+pub struct File<C, D> where C: Deref<Target=str>, D: AsRef<Path> {
   path: D,
   content: C
 }
 
-impl<C, D> File<C, D> where C: Deref<Target=str>, D: AsRef<str> + fmt::Display {
+impl<C, D> File<C, D> where C: Deref<Target=str>, D: AsRef<Path> {
   pub fn new(path: D, content: C) -> Self {
     File {
       path: path,
@@ -23,7 +23,7 @@ impl<C, D> File<C, D> where C: Deref<Target=str>, D: AsRef<str> + fmt::Display {
   }
 }
 
-impl<C, D> Symbol for File<C, D> where C: Deref<Target=str>, D: AsRef<str> + fmt::Display {
+impl<C, D> Symbol for File<C, D> where C: Deref<Target=str>, D: AsRef<Path> {
   fn target_reached(&self) -> Result<bool, Box<Error>> {
     let file = FsFile::open(self.path.as_ref());
     // Check if file exists
@@ -66,8 +66,8 @@ impl<C, D> Symbol for File<C, D> where C: Deref<Target=str>, D: AsRef<str> + fmt
   }
 }
 
-impl<C, D> fmt::Display for File<C, D> where C: Deref<Target=str>, D: AsRef<str> + fmt::Display {
+impl<C, D> fmt::Display for File<C, D> where C: Deref<Target=str>, D: AsRef<Path> {
   fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error>{
-    write!(f, "File {}", self.path)
+    write!(f, "File {}", self.path.as_ref().display())
   }
 }

src/symbols/git/checkout.rs

@@ -7,15 +7,15 @@ use command_runner::CommandRunner;
 use resources::Resource;
 use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner};
 
-pub struct GitCheckout<'a, C: 'a + CommandRunner> {
-  target: &'a str,
+pub struct GitCheckout<'a, C: 'a + CommandRunner, T: AsRef<str>> {
+  target: T,
   source: &'a str,
   branch: &'a str,
   command_runner: &'a C
 }
 
-impl<'a, C: CommandRunner> GitCheckout<'a, C> {
-  pub fn new(target: &'a str, source: &'a str, branch: &'a str, command_runner: &'a C) -> Self {
+impl<'a, C: CommandRunner, T: AsRef<str>> GitCheckout<'a, C, T> {
+  pub fn new(target: T, source: &'a str, branch: &'a str, command_runner: &'a C) -> Self {
     GitCheckout {
       target: target,
       source: source,
@@ -25,25 +25,25 @@ impl<'a, C: CommandRunner> GitCheckout<'a, C> {
   }
 }
 
-impl<'a, C: CommandRunner> fmt::Display for GitCheckout<'a, C> {
+impl<'a, C: CommandRunner, T: AsRef<str>> fmt::Display for GitCheckout<'a, C, T> {
   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.as_ref())
   }
 }
 
 use std::fs::metadata;
 
-impl<'a, C: CommandRunner> GitCheckout<'a, C> {
+impl<'a, C: CommandRunner, T: AsRef<str>> GitCheckout<'a, C, T> {
   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.as_ref()];
     new_args.extend_from_slice(args);
     self.command_runner.get_output("git", &new_args)
   }
 }
 
-impl<'a, C: CommandRunner> Symbol for GitCheckout<'a, C> {
+impl<'a, C: CommandRunner, T: AsRef<str>> Symbol for GitCheckout<'a, C, T> {
   fn target_reached(&self) -> Result<bool, Box<Error>> {
-    if let Err(e) = metadata(self.target) {
+    if let Err(e) = metadata(self.target.as_ref()) {
       return if e.kind() == io::ErrorKind::NotFound {
         Ok(false)
       } else {
@@ -58,8 +58,8 @@ impl<'a, C: CommandRunner> Symbol for GitCheckout<'a, C> {
   }
 
   fn execute(&self) -> Result<(), Box<Error>> {
-    if !Path::new(self.target).exists() {
-      return self.command_runner.run_successfully("git", &["clone", "--depth", "1", "-b", self.branch, self.source, self.target]);
+    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()]);
     }
     try!(self._run_in_target_repo(&["fetch", self.source, self.branch]));
     try!(self._run_in_target_repo(&["merge", "FETCH_HEAD"]));
@@ -67,11 +67,11 @@ impl<'a, C: CommandRunner> Symbol for GitCheckout<'a, C> {
   }
 
   fn get_prerequisites(&self) -> Vec<Resource> {
-    vec![ Resource::new("dir", Path::new(self.target).parent().unwrap().to_string_lossy()) ]
+    vec![ Resource::new("dir", Path::new(self.target.as_ref()).parent().unwrap().to_string_lossy()) ]
   }
 
   fn provides(&self) -> Option<Vec<Resource>> {
-    Some(vec![ Resource::new("dir", self.target.to_string()) ])
+    Some(vec![ Resource::new("dir", self.target.as_ref().to_string()) ])
   }
 
   fn as_action<'b>(&'b self, runner: &'b SymbolRunner) -> Box<Action + 'b> {

src/symbols/nginx/server.rs

@@ -43,7 +43,7 @@ impl<E: Error> fmt::Display for NginxServerError<E> {
 
 pub struct NginxServer<'a, C: 'a + CommandRunner, T> where T: Deref<Target=str> {
   command_runner: &'a C,
-  file: FileSymbol<T, Cow<'a, str>>,
+  file: FileSymbol<T, String>,
 }
 
 use std::borrow::Cow;
@@ -121,7 +121,7 @@ location @proxy {{
   }
 
   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 = String::from("/etc/nginx/sites-enabled/") + domain;
     NginxServer {
       command_runner: command_runner,
       file: FileSymbol::new(file_path, content)

src/symbols/owner.rs

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

src/symbols/wordpress/plugin.rs

@@ -11,13 +11,13 @@ use command_runner::CommandRunner;
 use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner};
 use resources::Resource;
 
-pub struct WordpressPlugin<'a, C, R> where C: Deref<Target=str> + fmt::Display, R: 'a + CommandRunner {
+pub struct WordpressPlugin<'a, C, R> where C: Deref<Target=str>, R: 'a + CommandRunner {
   base: C,
   name: C,
   command_runner: &'a R
 }
 
-impl<'a, C, R> WordpressPlugin<'a, C, R> where C: Deref<Target=str> + fmt::Display, R: CommandRunner {
+impl<'a, C, R> WordpressPlugin<'a, C, R> where C: Deref<Target=str>, R: CommandRunner {
   pub fn new(base: C, name: C, command_runner: &'a R) -> Self {
     WordpressPlugin {
       base: base,
@@ -31,7 +31,7 @@ impl<'a, C, R> WordpressPlugin<'a, C, R> where C: Deref<Target=str> + fmt::Displ
   }
 }
 
-impl<'a, C, R> Symbol for WordpressPlugin<'a, C, R> where C: Deref<Target=str> + fmt::Display, R: CommandRunner {
+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>> {
     if !self.get_path().exists() {
       return Ok(false);
@@ -62,13 +62,13 @@ impl<'a, C, R> Symbol for WordpressPlugin<'a, C, R> where C: Deref<Target=str> +
         }
       }
     }
-    let upstream = try!(self.command_runner.get_output("curl", &["--form", &format!(r###"plugins={{"plugins":{{"{0}/{0}.php":{{"Version":"{1}", "PluginURI":"{2}"}}}}}}"###, self.name, version, plugin_uri), "https://api.wordpress.org/plugins/update-check/1.1/"]));
+    let upstream = try!(self.command_runner.get_output("curl", &["--form", &format!(r###"plugins={{"plugins":{{"{0}/{0}.php":{{"Version":"{1}", "PluginURI":"{2}"}}}}}}"###, &*self.name, version, plugin_uri), "https://api.wordpress.org/plugins/update-check/1.1/"]));
     Ok(try!(String::from_utf8(upstream)).contains(r###""plugins":[]"###))
   }
 
   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 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()]));
     try!(self.command_runner.run_successfully("rm", &["-rf", &self.get_path().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()])
@@ -90,9 +90,9 @@ impl<'a, C, R> Symbol for WordpressPlugin<'a, C, R> where C: Deref<Target=str> +
   }
 }
 
-impl<'a, C, R> fmt::Display for WordpressPlugin<'a, C, R> where C: Deref<Target=str> + fmt::Display, R: CommandRunner {
+impl<'a, C, R> fmt::Display for WordpressPlugin<'a, C, R> where C: Deref<Target=str>, R: CommandRunner {
   fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error>{
-    write!(f, "WordpressPlugin {}", self.name)
+    write!(f, "WordpressPlugin {}", &*self.name)
   }
 }
 

src/symbols/wordpress/translation.rs

@@ -11,15 +11,15 @@ use command_runner::CommandRunner;
 use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner};
 use resources::Resource;
 
-pub struct WordpressTranslation<'a, C, D, R> where C: AsRef<str> + fmt::Display, D: AsRef<str> + fmt::Display, R: 'a + CommandRunner {
+pub struct WordpressTranslation<'a, C, D, R> where C: AsRef<str>, D: AsRef<str>, R: 'a + CommandRunner {
   path: D,
   version: &'a str,
   locale: C,
   command_runner: &'a R
 }
 
-impl<'a, C, R> WordpressTranslation<'a, C, String, R> where C: AsRef<str> + fmt::Display, R: CommandRunner {
-  pub fn new<D: AsRef<str> + fmt::Display>(path: D, version: &'a str, locale: C, command_runner: &'a R) -> Self {
+impl<'a, C, R> WordpressTranslation<'a, C, String, R> where C: AsRef<str>, R: CommandRunner {
+  pub fn new<D: AsRef<str>>(path: D, version: &'a str, locale: C, command_runner: &'a R) -> Self {
     WordpressTranslation {
       path: Path::new(path.as_ref()).join("wp-content/languages").to_string_lossy().to_string(),
       version: version,
@@ -29,7 +29,7 @@ impl<'a, C, R> WordpressTranslation<'a, C, String, R> where C: AsRef<str> + fmt:
   }
 }
 
-impl<'a, C, D, R> WordpressTranslation<'a, C, D, R> where C: AsRef<str> + fmt::Display, D: AsRef<str> + fmt::Display, R: CommandRunner {
+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 locale: &str = self.locale.as_ref();
@@ -39,7 +39,7 @@ impl<'a, C, D, R> WordpressTranslation<'a, C, D, R> where C: AsRef<str> + fmt::D
       for format in ["po", "mo"].into_iter() {
         res.push((
           format!("https://translate.wordpress.org/projects/wp/{}/{}{}/default/export-translations?format={}", version_x, in_slug, path_locale, format),
-          format!("{}/{}{}.{}", self.path, out_slug, self.locale, format)
+          format!("{}/{}{}.{}", self.path.as_ref(), out_slug, self.locale.as_ref(), format)
         ))
       }
     }
@@ -47,7 +47,7 @@ impl<'a, C, D, R> WordpressTranslation<'a, C, D, R> where C: AsRef<str> + fmt::D
   }
 }
 
-impl<'a, C, D, R> Symbol for WordpressTranslation<'a, C, D, R> where C: AsRef<str> + fmt::Display, D: AsRef<str> + fmt::Display, R: CommandRunner {
+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>> {
     let mut newest = String::new();
     let match_date = Regex::new("(?m)^\"PO-Revision-Date: (.+)\\+0000\\\\n\"$").unwrap();
@@ -72,8 +72,8 @@ impl<'a, C, D, R> Symbol for WordpressTranslation<'a, C, D, R> where C: AsRef<st
         }
       }
     }
-    let upstream = try!(self.command_runner.get_output("curl", &[&format!("https://api.wordpress.org/core/version-check/1.7/?version={}&locale={}", self.version, self.locale)]));
-    Ok(try!(String::from_utf8(upstream)).contains(&format!(r###"language":"{}","version":"{}","updated":"{}"###, self.locale, self.version, newest)))
+    let upstream = try!(self.command_runner.get_output("curl", &[&format!("https://api.wordpress.org/core/version-check/1.7/?version={}&locale={}", self.version, self.locale.as_ref())]));
+    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>> {
@@ -96,9 +96,9 @@ impl<'a, C, D, R> Symbol for WordpressTranslation<'a, C, D, R> where C: AsRef<st
   }
 }
 
-impl<'a, C, D, R> fmt::Display for WordpressTranslation<'a, C, D, R> where C: AsRef<str> + fmt::Display, D: AsRef<str> + fmt::Display, R: CommandRunner {
+impl<'a, C, D, R> fmt::Display for WordpressTranslation<'a, C, D, R> where C: AsRef<str>, D: AsRef<str>, R: CommandRunner {
   fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error>{
-    write!(f, "WordpressTranslation {}", self.path)
+    write!(f, "WordpressTranslation {}", self.path.as_ref())
   }
 }