Browse Source

Add cron

master
Adrian Heine 3 years ago
parent
commit
7d6329a409
  1. 59
      src/command_runner.rs
  2. 77
      src/symbols/cron.rs
  3. 9
      src/symbols/factory.rs
  4. 1
      src/symbols/mod.rs

59
src/command_runner.rs

@ -1,12 +1,24 @@
use std::error::Error;
use std::ffi::OsStr;
use std::io::Result as IoResult;
use std::io::{Result as IoResult, Write};
use std::process::Command;
use std::process::Output;
use std::process::Stdio;
pub trait CommandRunner {
fn run_with_args<S: AsRef<OsStr> + ?Sized>(&self, program: &str, args: &[&S])
-> IoResult<Output>;
fn run_with_args_and_stdin<S: AsRef<OsStr> + ?Sized>(
&self,
program: &str,
args: &[&S],
stdin: &str,
) -> IoResult<Output>;
fn run_with_args<S: AsRef<OsStr> + ?Sized>(
&self,
program: &str,
args: &[&S],
) -> IoResult<Output> {
self.run_with_args_and_stdin(program, args, "")
}
fn get_output<S: AsRef<OsStr> + ?Sized>(
&self,
program: &str,
@ -47,14 +59,26 @@ pub trait CommandRunner {
pub struct StdCommandRunner;
impl CommandRunner for StdCommandRunner {
fn run_with_args<S: AsRef<OsStr> + ?Sized>(
fn run_with_args_and_stdin<S: AsRef<OsStr> + ?Sized>(
&self,
program: &str,
args: &[&S],
input: &str,
) -> IoResult<Output> {
// FIXME: logger
//println!("{} {:?}", program, args);
let res = Command::new(program).args(args).output();
let mut child = Command::new(program)
.args(args)
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.expect("Failed to spawn child process");
let stdin = child.stdin.as_mut().expect("Failed to open stdin");
stdin
.write_all(input.as_bytes())
.expect("Failed to write to stdin");
let res = child.wait_with_output();
println!("{:?}", res);
res
}
@ -114,10 +138,11 @@ impl<'a, C> CommandRunner for SetuidCommandRunner<'a, C>
where
C: 'a + CommandRunner,
{
fn run_with_args<S: AsRef<OsStr> + ?Sized>(
fn run_with_args_and_stdin<S: AsRef<OsStr> + ?Sized>(
&self,
program: &str,
args: &[&S],
input: &str,
) -> IoResult<Output> {
let uid = get_user_by_name(self.user_name)
.expect("User does not exist")
@ -125,7 +150,20 @@ where
let set_home = TempSetEnv::new("HOME", format!("/home/{}", self.user_name));
let set_dbus = TempSetEnv::new("XDG_RUNTIME_DIR", format!("/run/user/{}", uid));
//println!("{} {:?}", program, args);
let res = Command::new(program).uid(uid).gid(uid).args(args).output();
let mut child = Command::new(program)
.args(args)
.stdin(Stdio::piped())
.uid(uid)
.gid(uid)
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.expect("Failed to spawn child process");
let stdin = child.stdin.as_mut().expect("Failed to open stdin");
stdin
.write_all(input.as_bytes())
.expect("Failed to write to stdin");
let res = child.wait_with_output();
println!("{:?}", res);
res
}
@ -158,16 +196,19 @@ impl<'a, C> CommandRunner for SuCommandRunner<'a, C>
where
C: 'a + CommandRunner,
{
fn run_with_args<S: AsRef<OsStr> + ?Sized>(
fn run_with_args_and_stdin<S: AsRef<OsStr> + ?Sized>(
&self,
program: &str,
args: &[&S],
input: &str,
) -> IoResult<Output> {
let raw_new_args = [self.user_name, "-s", "/usr/bin/env", "--", program];
let mut new_args: Vec<&OsStr> = raw_new_args.iter().map(|s| s.as_ref()).collect();
let old_args: Vec<&OsStr> = args.iter().map(|s| s.as_ref()).collect();
new_args.extend_from_slice(&old_args);
self.command_runner.run_with_args("su", &new_args)
self
.command_runner
.run_with_args_and_stdin("su", &new_args, input)
}
}

77
src/symbols/cron.rs

@ -0,0 +1,77 @@
use std::error::Error;
use std::fmt;
use std::ops::Deref;
use command_runner::CommandRunner;
use resources::Resource;
use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner};
pub struct Cron<'r, C, U, R: 'r + CommandRunner>
where
C: Deref<Target = str>,
U: Deref<Target = str>,
{
user: U,
content: C,
command_runner: &'r R,
}
impl<'r, U, R: 'r + CommandRunner> Cron<'r, String, U, R>
where
U: Deref<Target = str>,
{
pub fn new<C: Deref<Target = str>>(user: U, content: C, command_runner: &'r R) -> Self {
Cron {
user,
content: String::from(&*content) + "\n",
command_runner,
}
}
}
impl<'r, C, U, R: 'r + CommandRunner> Symbol for Cron<'r, C, U, R>
where
C: Deref<Target = str>,
U: Deref<Target = str>,
{
fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
let tab = try!(self
.command_runner
.get_output("crontab", &["-l", "-u", &self.user]));
return Ok(tab == self.content.bytes().collect::<Vec<u8>>());
}
fn execute(&self) -> Result<(), Box<dyn Error>> {
self.command_runner.run_with_args_and_stdin(
"crontab",
&["-u", &self.user, "-"],
&self.content,
)?;
Ok(())
}
fn get_prerequisites(&self) -> Vec<Resource> {
vec![]
}
fn as_action<'a>(&'a self, runner: &'a dyn SymbolRunner) -> Box<dyn Action + 'a> {
Box::new(SymbolAction::new(runner, self))
}
fn into_action<'a>(self: Box<Self>, runner: &'a dyn SymbolRunner) -> Box<dyn Action + 'a>
where
Self: 'a,
{
Box::new(OwnedSymbolAction::new(runner, *self))
}
}
impl<'r, C, U, R: 'r + CommandRunner> fmt::Display for Cron<'r, C, U, R>
where
C: Deref<Target = str>,
U: Deref<Target = str>,
{
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
write!(f, "Cron {}", &*self.user)
}
}

9
src/symbols/factory.rs

@ -5,6 +5,7 @@ use std::path::Path;
use command_runner::{CommandRunner, SetuidCommandRunner};
use storage::{SimpleStorage, Storage};
use symbols::acme::{AcmeCert, AcmeCertChain};
use symbols::cron::Cron;
use symbols::file::File;
use symbols::git::checkout::GitCheckout;
use symbols::hook::Hook;
@ -368,4 +369,12 @@ env[PATH] = /usr/local/bin:/usr/bin:/bin
) -> Box<dyn Action + 'a> {
Box::new(File::new(path, content)).into_action(self.symbol_runner)
}
pub fn get_cron<'a, T: 'a + Deref<Target = str>, U: 'a + Deref<Target = str>>(
&'a self,
user: U,
content: T,
) -> Box<dyn Action + 'a> {
Box::new(Cron::new(user, content, self.command_runner)).into_action(self.symbol_runner)
}
}

1
src/symbols/mod.rs

@ -68,6 +68,7 @@ impl<'a, S: Symbol + 'a> Action for OwnedSymbolAction<'a, S> {
}
pub mod acme;
pub mod cron;
pub mod dir;
pub mod factory;
pub mod file;

Loading…
Cancel
Save