You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
178 lines
5.9 KiB
178 lines
5.9 KiB
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 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>> {
|
|
try!(self.command_runner.run_with_args("mkdir", &["-p", Path::new(self.path.as_ref()).parent().unwrap().to_str().unwrap()]));
|
|
// FIXME: Permissions
|
|
// try!(create_dir_all(Path::new(&path).parent().unwrap()));
|
|
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(())
|
|
}
|
|
|
|
/* // FIXME
|
|
fn get_prerequisites(&self) -> Vec<Box<Resource>> {
|
|
self.file.get_prerequisites()
|
|
}
|
|
*/
|
|
}
|
|
|
|
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)
|
|
}
|
|
}
|