schematics/src/symbols/systemd/node_js_user_service.rs

use std::error::Error;
use std::os::unix::fs::PermissionsExt;
use std::fmt;
use std::io;
use std::fs;
use std::process::Output;
use std::path::Path;
use std::thread::sleep;
use std::time::Duration;
use std::ops::Deref;

use command_runner::CommandRunner;
use resources::{ FileResource, Resource };
use symbols::Symbol;
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, P, C> where P: AsRef<str> + fmt::Display, C: Deref<Target=str> {
  name: &'a str,
  user_name: &'a str,
  path: P,
  command_runner: &'a CommandRunner,
  file: FileSymbol<C, Cow<'a, str>>
}

use std::borrow::Cow;

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

    let content = format!("[Service]
ExecStartPre=rm /var/tmp/{1}-{2}.socket
# This only works if the path is a directory
WorkingDirectory={0}
ExecStart=/usr/bin/nodejs {0}
Restart=always
Environment=NODE_ENV=production
Environment=PORT=/var/tmp/{1}-{2}.socket
#RuntimeDirectory=service
#RuntimeDirectoryMode=766

[Install]
WantedBy=default.target
", path, user_name, name);
    NodeJsSystemdUserService {
      name: name,
      user_name: user_name,
      path: file_path.clone(),
      command_runner: command_runner,
      file: FileSymbol::new(file_path, content)
    }
  }
}

impl<'a, P, C> NodeJsSystemdUserService<'a, P, C> where P: AsRef<str> + fmt::Display, C: Deref<Target=str> {
  fn check_if_service(&self) -> Result<bool, Box<Error>> {
    loop {
      // Check if service is registered
      let active_state = try!(self.command_runner.run_with_args("systemctl", &["--user", "show", "--property", "ActiveState", self.name]));
      if !active_state.status.success() {
        return Err(String::from_utf8(active_state.stderr).unwrap().trim_right().into());
      }
      // Check if service is running
      match String::from_utf8(active_state.stdout).unwrap().trim_right() {
        "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.name)])) as NodeJsSystemdUserServiceError<io::Error>)),
        _ => return Ok(false)
      }
    }
  }
}

impl<'a, P, C> Symbol for NodeJsSystemdUserService<'a, P, C> where P: AsRef<str> + fmt::Display, C: Deref<Target=str> {
  fn target_reached(&self) -> Result<bool, Box<Error>> {
    match self.file.target_reached() {
      Ok(false) => return Ok(false),
      Ok(true) => {},
      Err(e) => return Err(Box::new(NodeJsSystemdUserServiceError::GenericError as NodeJsSystemdUserServiceError<io::Error>))
    }
/*
    if !(try!(self.file.target_reached())) {
      return Ok(false)
    }
*/
    self.check_if_service()
  }

  fn execute(&self) -> Result<(), Box<Error>> {
    match self.file.execute() {
      Ok(_) => {},
      Err(e) => return Err(e)
    }
    try!(self.command_runner.run_with_args("systemctl", &["--user", "enable", self.name]));
    try!(self.command_runner.run_with_args("systemctl", &["--user", "start", self.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.name);
//    try!(self.command_runner.run_with_args("chmod", &["666", &file_name]));

    let mut tries = 5;
    loop {
      let metadata = fs::metadata(file_name.clone());
      match metadata {
        Ok(metadata) => {
          let mut perms = metadata.permissions();
          perms.set_mode(0o666);
          try!(fs::set_permissions(file_name, perms));
          break;
        },
        Err(e) => {
          if e.kind() == io::ErrorKind::NotFound {
            tries -= 1;
            if tries == 0 { return Err("Gave up waiting for socket to appear".to_string().into()); }
            sleep(Duration::from_millis(500));
          } else {
            return Err(Box::new(e));
          }
        }
      }
    }
    Ok(())
  }

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

impl<'a, P, C> fmt::Display for NodeJsSystemdUserService<'a, P, C> where P: AsRef<str> + fmt::Display, C: Deref<Target=str> {
  fn fmt(&self, f: &mut fmt::Formatter) -> Result<(),fmt::Error>{
    write!(f, "Systemd Node.js user service unit for {}", self.path)
  }
}