Cargo format

src/symbols/systemd/node_js_user_service.rs

@@ -1,22 +1,22 @@
 use std::error::Error;
 use std::fmt;
-use std::io;
 use std::fs;
+use std::io;
+use std::ops::Deref;
 use std::process::Output;
 use std::thread::sleep;
 use std::time::Duration;
-use std::ops::Deref;
 
 use command_runner::{CommandRunner, SetuidCommandRunner};
 use resources::Resource;
-use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner};
 use symbols::file::File as FileSymbol;
+use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner};
 
 #[derive(Debug)]
 pub enum NodeJsSystemdUserServiceError<E: Error> {
   ActivationFailed(io::Result<Output>),
   ExecError(E),
-  GenericError
+  GenericError,
 }
 
 impl From<io::Error> for NodeJsSystemdUserServiceError<io::Error> {
@@ -30,13 +30,13 @@ impl<E: Error> Error for NodeJsSystemdUserServiceError<E> {
     match self {
       NodeJsSystemdUserServiceError::ExecError(ref e) => e.description(),
       NodeJsSystemdUserServiceError::GenericError => "Generic error",
-      NodeJsSystemdUserServiceError::ActivationFailed(_) => "Activation of service failed"
+      NodeJsSystemdUserServiceError::ActivationFailed(_) => "Activation of service failed",
     }
   }
   fn cause(&self) -> Option<&dyn Error> {
     match self {
       NodeJsSystemdUserServiceError::ExecError(ref e) => Some(e),
-      _ => None
+      _ => None,
     }
   }
 }
@@ -51,19 +51,37 @@ impl<E: Error> fmt::Display for NodeJsSystemdUserServiceError<E> {
   }
 }
 
-pub struct NodeJsSystemdUserService<'a, C, R> where C: Deref<Target=str>, R: CommandRunner {
+pub struct NodeJsSystemdUserService<'a, C, R>
+where
+  C: Deref<Target = str>,
+  R: CommandRunner,
+{
   service_name: &'a str,
   user_name: &'a str,
   command_runner: R,
-  file: FileSymbol<C, String>
+  file: FileSymbol<C, String>,
 }
 
-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_end(), service_name);
+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_end(),
+      service_name
+    );
 
     let port = format!("/var/tmp/{}-{}.socket", user_name, service_name);
-    let content = format!("[Service]
+    let content = format!(
+      "[Service]
 Environment=NODE_ENV=production
 Environment=PORT={1}
 ExecStartPre=/bin/rm -f {1}
@@ -78,19 +96,24 @@ Restart=always
 
 [Install]
 WantedBy=default.target
-", path, port);
+",
+      path, port
+    );
 
     NodeJsSystemdUserService {
       service_name,
       user_name,
       command_runner: SetuidCommandRunner::new(user_name, command_runner),
-      file: FileSymbol::new(file_path, content)
+      file: FileSymbol::new(file_path, content),
     }
   }
 }
 
-impl<'a, C, R> NodeJsSystemdUserService<'a, C, R> where C: Deref<Target=str>, R: CommandRunner {
-
+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<dyn Error>> {
     let mut tries = 5;
     loop {
@@ -102,7 +125,11 @@ impl<'a, C, R> NodeJsSystemdUserService<'a, C, R> where C: Deref<Target=str>, R:
           return Err(stderr.into());
         }
       } else {
-        return Ok(try!(String::from_utf8(result.stdout)).trim_end().to_string());
+        return Ok(
+          try!(String::from_utf8(result.stdout))
+            .trim_end()
+            .to_string(),
+        );
       }
       tries -= 1;
       if tries == 0 {
@@ -114,18 +141,36 @@ impl<'a, C, R> NodeJsSystemdUserService<'a, C, R> where C: Deref<Target=str>, R:
 
   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]));
+      let active_state = try!(self.systemctl_wait_for_dbus(&[
+        "--user",
+        "show",
+        "--property",
+        "ActiveState",
+        self.service_name
+      ]));
       match active_state.as_ref() {
         "ActiveState=activating" => sleep(Duration::from_millis(500)),
         "ActiveState=active" => return Ok(true),
-        "ActiveState=failed" => return Err(Box::new(NodeJsSystemdUserServiceError::ActivationFailed(self.command_runner.run_with_args("journalctl", &["--user", &format!("--user-unit={}", self.service_name)])) as NodeJsSystemdUserServiceError<io::Error>)),
-        _ => return Ok(false)
+        "ActiveState=failed" => {
+          return Err(Box::new(NodeJsSystemdUserServiceError::ActivationFailed(
+            self.command_runner.run_with_args(
+              "journalctl",
+              &["--user", &format!("--user-unit={}", self.service_name)],
+            ),
+          )
+            as NodeJsSystemdUserServiceError<io::Error>))
+        }
+        _ => return Ok(false),
       }
     }
   }
 }
 
-impl<'a, C, R> Symbol for NodeJsSystemdUserService<'a, C, R> where C: Deref<Target=str>, R: CommandRunner {
+impl<'a, C, R> Symbol for NodeJsSystemdUserService<'a, C, R>
+where
+  C: Deref<Target = str>,
+  R: CommandRunner,
+{
   fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
     if !(try!(self.file.target_reached())) {
       return Ok(false);
@@ -139,15 +184,22 @@ impl<'a, C, R> Symbol for NodeJsSystemdUserService<'a, C, R> where C: Deref<Targ
     try!(self.systemctl_wait_for_dbus(&["--user", "restart", self.service_name]));
 
     if !(try!(self.check_if_service())) {
-      return Err(Box::new(NodeJsSystemdUserServiceError::GenericError as NodeJsSystemdUserServiceError<io::Error>));
+      return Err(Box::new(
+        NodeJsSystemdUserServiceError::GenericError as NodeJsSystemdUserServiceError<io::Error>,
+      ));
     }
 
     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<dyn Error>)
+    fs::metadata(&file_name)
+      .map(|_| ())
+      .map_err(|e| Box::new(e) as Box<dyn Error>)
   }
 
   fn get_prerequisites(&self) -> Vec<Resource> {
-    let mut r = vec![ Resource::new("file", format!("/var/lib/systemd/linger/{}", self.user_name)) ];
+    let mut r = vec![Resource::new(
+      "file",
+      format!("/var/lib/systemd/linger/{}", self.user_name),
+    )];
     r.extend(self.file.get_prerequisites().into_iter());
     r
   }
@@ -156,13 +208,24 @@ impl<'a, C, R> Symbol for NodeJsSystemdUserService<'a, C, R> where C: Deref<Targ
     Box::new(SymbolAction::new(runner, self))
   }
 
-  fn into_action<'b>(self: Box<Self>, runner: &'b dyn SymbolRunner) -> Box<dyn 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))
   }
 }
 
-impl<'a, C, R> fmt::Display for NodeJsSystemdUserService<'a, C, R> where C: Deref<Target=str>, R: CommandRunner {
-  fn fmt(&self, f: &mut fmt::Formatter) -> Result<(),fmt::Error>{
-    write!(f, "Systemd Node.js user service unit for {}", self.service_name)
+impl<'a, C, R> fmt::Display for NodeJsSystemdUserService<'a, C, R>
+where
+  C: Deref<Target = str>,
+  R: CommandRunner,
+{
+  fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+    write!(
+      f,
+      "Systemd Node.js user service unit for {}",
+      self.service_name
+    )
   }
 }

src/symbols/systemd/reload.rs

@@ -6,12 +6,15 @@ use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner};
 
 pub struct ReloadService<'a, C: 'a + CommandRunner> {
   service: &'a str,
-  command_runner: &'a C
+  command_runner: &'a C,
 }
 
 impl<'a, C: CommandRunner> ReloadService<'a, C> {
   pub fn new(service: &'a str, command_runner: &'a C) -> Self {
-    ReloadService { service, command_runner }
+    ReloadService {
+      service,
+      command_runner,
+    }
   }
 }
 
@@ -21,20 +24,25 @@ impl<'a, C: CommandRunner> Symbol for ReloadService<'a, C> {
   }
 
   fn execute(&self) -> Result<(), Box<dyn Error>> {
-    self.command_runner.run_successfully("systemctl", &["reload-or-restart", self.service])
+    self
+      .command_runner
+      .run_successfully("systemctl", &["reload-or-restart", self.service])
   }
 
   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 dyn SymbolRunner) -> Box<dyn 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))
   }
 }
 
 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)
   }
 }

src/symbols/systemd/user_session.rs

@@ -1,4 +1,4 @@
-use std::borrow::{ Borrow, Cow };
+use std::borrow::{Borrow, Cow};
 use std::error::Error;
 use std::fmt;
 use std::path::PathBuf;
@@ -9,20 +9,20 @@ use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner};
 #[derive(Debug)]
 pub enum SystemdUserSessionError<E: Error> {
   ExecError(E),
-  GenericError
+  GenericError,
 }
 
 impl<E: Error> Error for SystemdUserSessionError<E> {
   fn description(&self) -> &str {
     match self {
       SystemdUserSessionError::ExecError(ref e) => e.description(),
-      SystemdUserSessionError::GenericError => "Generic error"
+      SystemdUserSessionError::GenericError => "Generic error",
     }
   }
   fn cause(&self) -> Option<&dyn Error> {
     match self {
       SystemdUserSessionError::ExecError(ref e) => Some(e),
-      _ => None
+      _ => None,
     }
   }
 }
@@ -35,12 +35,15 @@ impl<E: Error> fmt::Display for SystemdUserSessionError<E> {
 
 pub struct SystemdUserSession<'a, C: 'a + CommandRunner> {
   user_name: Cow<'a, str>,
-  command_runner: &'a C
+  command_runner: &'a C,
 }
 
 impl<'a, C: CommandRunner> SystemdUserSession<'a, C> {
   pub fn new(user_name: Cow<'a, str>, command_runner: &'a C) -> Self {
-    SystemdUserSession { user_name, command_runner }
+    SystemdUserSession {
+      user_name,
+      command_runner,
+    }
   }
 }
 
@@ -53,20 +56,25 @@ impl<'a, C: CommandRunner> Symbol for SystemdUserSession<'a, C> {
   }
 
   fn execute(&self) -> Result<(), Box<dyn Error>> {
-    self.command_runner.run_successfully("loginctl", &["enable-linger", self.user_name.borrow()])
+    self
+      .command_runner
+      .run_successfully("loginctl", &["enable-linger", self.user_name.borrow()])
   }
 
   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 dyn SymbolRunner) -> Box<dyn 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))
   }
 }
 
 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)
   }
 }