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.
210 lines
5.5 KiB
210 lines
5.5 KiB
use std::borrow::Cow;
|
|
use std::error::Error;
|
|
use std::fmt;
|
|
use std::io::Error as IoError;
|
|
|
|
use command_runner::CommandRunner;
|
|
use resources::Resource;
|
|
use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner};
|
|
|
|
#[derive(Debug, PartialEq)]
|
|
pub enum UserAdderError<E: Error> {
|
|
AlreadyExists,
|
|
UnknownError,
|
|
ImplError(E)
|
|
}
|
|
|
|
impl<E: Error> Error for UserAdderError<E> {
|
|
fn description(&self) -> &str {
|
|
match self {
|
|
&UserAdderError::AlreadyExists => "User already exists",
|
|
&UserAdderError::UnknownError => "Unknown error",
|
|
&UserAdderError::ImplError(_) => "User adding error"
|
|
}
|
|
}
|
|
fn cause(&self) -> Option<&Error> {
|
|
match self {
|
|
&UserAdderError::ImplError(ref e) => Some(e),
|
|
_ => None
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<E: Error> fmt::Display for UserAdderError<E> {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
match self.cause() {
|
|
Some(e) => write!(f, "{} (cause: {})", self.description(), e),
|
|
None => write!(f, "{}", self.description())
|
|
}
|
|
}
|
|
}
|
|
|
|
pub trait UserAdder {
|
|
type SubE: Error;
|
|
fn add_user(&self, user_name: &str) -> Result<(), UserAdderError<Self::SubE>>;
|
|
}
|
|
|
|
#[derive(Debug, PartialEq)]
|
|
pub enum UserError {
|
|
GenericError
|
|
}
|
|
|
|
impl Error for UserError {
|
|
fn description(&self) -> &str {
|
|
match self {
|
|
&UserError::GenericError => "Could not find out if user exists"
|
|
}
|
|
}
|
|
fn cause(&self) -> Option<&Error> {
|
|
match self {
|
|
_ => None
|
|
}
|
|
}
|
|
}
|
|
|
|
impl fmt::Display for UserError {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
match self.cause() {
|
|
Some(e) => write!(f, "{} (cause: {})", self.description(), e),
|
|
None => write!(f, "{}", self.description())
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct User<'a, C: 'a + CommandRunner, E, A> where E: Error + Sized, A: 'a + UserAdder<SubE=E> {
|
|
user_name: Cow<'a, str>,
|
|
command_runner: &'a C,
|
|
user_adder: &'a A
|
|
}
|
|
|
|
impl<'a, C: CommandRunner, E: Error + Sized, A: 'a + UserAdder<SubE=E>> User<'a, C, E, A> {
|
|
pub fn new(user_name: Cow<'a, str>, command_runner: &'a C, user_adder: &'a A) -> Self {
|
|
User {
|
|
user_name: user_name,
|
|
command_runner: command_runner,
|
|
user_adder: user_adder
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'a, C: CommandRunner, E: Error, A: UserAdder<SubE=E>> fmt::Display for User<'a, C, E, A> {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
write!(f, "User {}", self.user_name)
|
|
}
|
|
}
|
|
|
|
impl<'a, C: CommandRunner, E: 'static + Error, A: UserAdder<SubE=E>> Symbol for User<'a, C, E, A> {
|
|
fn target_reached(&self) -> Result<bool, Box<Error>> {
|
|
let output = try!(self.command_runner.run_with_args("getent", &["passwd", &*self.user_name]));
|
|
match output.status.code() {
|
|
Some(2) => Ok(false),
|
|
Some(0) => Ok(true),
|
|
_ => Err(Box::new(UserError::GenericError))
|
|
}
|
|
}
|
|
|
|
fn execute(&self) -> Result<(), Box<Error>> {
|
|
self.user_adder.add_user(&*self.user_name).map_err(|e| Box::new(e) as Box<Error>)
|
|
}
|
|
|
|
fn provides(&self) -> Option<Vec<Resource>> {
|
|
Some(vec![Resource::new("user", self.user_name.to_string())])
|
|
}
|
|
|
|
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))
|
|
}
|
|
}
|
|
|
|
pub struct SystemUserAdder<'a, C: 'a + CommandRunner> {
|
|
command_runner: &'a C
|
|
}
|
|
|
|
impl<'a, C: CommandRunner> SystemUserAdder<'a, C> {
|
|
pub fn new(command_runner: &'a C) -> Self {
|
|
SystemUserAdder { command_runner: command_runner }
|
|
}
|
|
}
|
|
|
|
impl<'a, C: CommandRunner> UserAdder for SystemUserAdder<'a, C> {
|
|
type SubE = IoError;
|
|
fn add_user(&self, user_name: &str) -> Result<(), UserAdderError<IoError>> {
|
|
let output = self.command_runner.run_with_args(
|
|
"adduser",
|
|
&[
|
|
// "-m", // Necessary for Fedora, not accepted in Debian
|
|
"--system",
|
|
user_name
|
|
]);
|
|
match output {
|
|
Ok(output) => match output.status.code() {
|
|
Some(0) => Ok(()),
|
|
Some(1) =>
|
|
{
|
|
println!("{:?}", output);
|
|
Err(UserAdderError::AlreadyExists)},
|
|
Some(_) =>
|
|
{
|
|
println!("{:?}", output);
|
|
Err(UserAdderError::UnknownError)
|
|
},
|
|
None => {
|
|
println!("{:?}", output);
|
|
Err(UserAdderError::UnknownError)
|
|
},
|
|
},
|
|
Err(e) => Err(UserAdderError::ImplError(e))
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use std::error::Error;
|
|
use std::fmt;
|
|
|
|
use command_runner::StdCommandRunner;
|
|
use symbols::{Action, OwnedSymbolAction, Symbol, SymbolAction, SymbolRunner};
|
|
use symbols::user::User;
|
|
use symbols::user::UserAdder;
|
|
use symbols::user::UserAdderError;
|
|
|
|
#[derive(Debug, PartialEq)]
|
|
struct DummyError;
|
|
impl Error for DummyError {
|
|
fn description(&self) -> &str {
|
|
"DummyError"
|
|
}
|
|
}
|
|
|
|
impl fmt::Display for DummyError {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
write!(f, "DummyError")
|
|
}
|
|
}
|
|
|
|
struct DummyUserAdder;
|
|
|
|
impl UserAdder for DummyUserAdder {
|
|
type SubE = DummyError;
|
|
fn add_user(&self, user_name: &str) -> Result<(), UserAdderError<Self::SubE>> {
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_target_reached_nonexisting() {
|
|
let symbol = User { user_name: "nonexisting".into(), command_runner: &StdCommandRunner, user_adder: &DummyUserAdder };
|
|
assert_eq!(symbol.target_reached().unwrap(), false);
|
|
}
|
|
|
|
#[test]
|
|
fn test_target_reached_root() {
|
|
let symbol = User { user_name: "root".into(), command_runner: &StdCommandRunner, user_adder: &DummyUserAdder };
|
|
assert_eq!(symbol.target_reached().unwrap(), true);
|
|
}
|
|
}
|