rustible/src/modules/package/list.rs

use serde::Serialize;

use crate::facts::{Facts, os::OsFamily};
use crate::utils::cmd::CmdOutput;

use std::boxed::Box;

pub mod pacman;
use pacman::ArchlinuxPackageManager;
pub mod apt;
use apt::DebianPackageManager;

pub mod builder;
use builder::{NoPackage, PackageArgsBuilder};

#[derive(Clone, Debug, Serialize)]
pub struct PackageArgs {
    name: PackageList,
    state: PackageState,
}

#[derive(Clone, Debug, Serialize)]
pub enum PackageState {
    Present,
    Absent,
    Latest,
}

#[derive(Debug)]
pub struct PackageModule<Manager> {
    manager: Manager,
    args: PackageArgs,
}

impl<Manager> Module<PackageArgs, (), PackageError> for PackageModule<Manager> {
    fn clone_args(&self) -> PackageArgs {
        self.args.clone()
    }
    
    fn module_name() -> &'static str {
        "package"
    }   
}

impl Module<PackageArgs, (), PackageError> for PackageModule<Box<dyn SpecificPackageManager>> {
    fn run(&self) -> Result<(), PackageError> {
        Ok(())
    }
}


impl Module<PackageArgs, (), PackageError> for PackageModule<NoManager> {
    fn with_facts(self, facts: &Facts) -> PackageModule<Box<dyn SpecificPackageManager>> {
        let Self { args, .. } = self; 

        let manager = match facts.os.family() {
                OsFamily::Debian => Box::new(DebianPackageManager),
                OsFamily::Archlinux => Box::new(ArchlinuxPackageManager),
        };

        PackageModule {
            args,
            manager,
        }
    }
}


impl PackageModule {
    pub fn new() -> PackageArgsBuilder {
        PackageArgsBuilder::new()
    }
    
    pub fn from_args_with_facts(args: PackageArgs, facts: &Facts) -> PackageModule {
        let manager = match facts.os.family() {
                OsFamily::Debian => PackageModule(Box::new(DebianPackageManager)),
                OsFamily::Archlinux => PackageModule(Box::new(ArchlinuxPackageManager)),
        };
        PackageModule {
            manager,
            args,
        }
    }

    pub fn from_args_with(args: PackageArgs, manager: SpecificPackageManager) -> PackageManager {
        PackageModule {
            manager: Box::new(manager),
            args,
        }
    }
}

#[derive(Clone, Debug, Serialize)]
pub enum PackageError {
    IoError(String),
    CmdFail(CmdOutput),
}

impl From<std::io::Error> for PackageError {
    fn from(e: std::io::Error) -> PackageError {
        PackageError::IoError(e.to_string())
    }
}

pub trait SpecificPackageManager: std::fmt::Debug {
    fn name(&self) -> &'static str;
    fn update(&self) -> Result<(), PackageError>;
    fn install(&self, list: PackageList) -> Result<(), PackageError>;
    fn remove(&self, list: PackageList) -> Result<(), PackageError>;
}