schematics/src/symbols/systemd/node_js_user_service.rs

use std::error::Error;
use std::fmt;
use std::io;
use std::fs;
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;

#[derive(Debug)]
pub enum NodeJsSystemdUserServiceError<E: Error> {
  ActivationFailed(io::Result<Output>),
  ExecError(E),
  GenericError
}

impl From<io::Error> for NodeJsSystemdUserServiceError<io::Error> {
  fn from(err: io::Error) -> NodeJsSystemdUserServiceError<io::Error> {
    NodeJsSystemdUserServiceError::ExecError(err)
  }
}

impl<E: Error> Error for NodeJsSystemdUserServiceError<E> {
  fn description(&self) -> &str {
    match self {
      &NodeJsSystemdUserServiceError::ExecError(ref e) => e.description(),
      &NodeJsSystemdUserServiceError::GenericError => "Generic error",
      &NodeJsSystemdUserServiceError::ActivationFailed(_) => "Activation of service failed"
    }
  }
  fn cause(&self) -> Option<&Error> {
    match self {
      &NodeJsSystemdUserServiceError::ExecError(ref e) => Some(e),
      _ => None
    }
  }
}

impl<E: Error> fmt::Display for NodeJsSystemdUserServiceError<E> {
  fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
    try!(write!(f, "{}", self.description()));
    if let &NodeJsSystemdUserServiceError::ActivationFailed(Ok(ref log)) = self {
      try!(write!(f, ": {:?}", log));
    };
    Ok(())
  }
}

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>
}

impl<'a, R> NodeJsSystemdUserService<'a, String, SetuidCommandRunner<'a, R>> where R: CommandRunner {
  pub fn new(home: &'a str, user_name: &'a str, name: &'a str, path: &'a str, command_runner: &'a R) -> Self {
    let file_path = format!("{}/.config/systemd/user/{}.service", home.trim_right(), name);

    let port = format!("/var/tmp/{}-{}.socket", user_name, name);
    let content = format!("[Service]
Environment=NODE_ENV=production
Environment=PORT={1}
ExecStartPre=/bin/rm -f {1}
ExecStart=/usr/bin/nodejs {0}
ExecStartPost=/bin/sh -c 'sleep 1 && chmod 666 {1}'

# FIXME: This only works if the nodejs path is a directory
WorkingDirectory={0}
Restart=always
#RuntimeDirectory=service
#RuntimeDirectoryMode=766

[Install]
WantedBy=default.target
", path, port);

    NodeJsSystemdUserService {
      service_name: name,
      user_name: user_name,
      command_runner: SetuidCommandRunner::new(user_name, command_runner),
      file: FileSymbol::new(file_path, content)
    }
  }
}

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>> {
    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();
        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());
      }
      tries -= 1;
      if tries == 0 {
        return Err("Gave up waiting for dbus to appear".to_string().into());
      }
      sleep(Duration::from_millis(500));
    }
  }

  fn check_if_service(&self) -> Result<bool, Box<Error>> {
    loop {
      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)
      }
    }
  }
}

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>> {
    if !(try!(self.file.target_reached())) {
      return Ok(false);
    }
    self.check_if_service()
  }

  fn execute(&self) -> Result<(), Box<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]));

    if !(try!(self.check_if_service())) {
      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<Error>)
  }

  fn get_prerequisites(&self) -> Vec<Resource> {
    let mut r = vec![ Resource::new("file", format!("/var/lib/systemd/linger/{}", self.user_name)) ];
    r.extend(self.file.get_prerequisites().into_iter());
    r
  }

  fn as_action<'b>(&'b self, runner: &'b SymbolRunner) -> Box<Action + 'b> {
    Box::new(SymbolAction::new(runner, self))
  }

  fn into_action<'b>(self: Box<Self>, runner: &'b SymbolRunner) -> Box<Action + 'b> where Self: 'b {
    Box::new(OwnedSymbolAction::new(runner, *self))
  }
}

impl<'a, 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)
  }
}