rustible/src/modules/package/mod.rs

use serde::Serialize;

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

use std::boxed::Box;

pub mod list;
pub use list::{PackageList, IntoPackageList};

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

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

pub type PackageStatus = ();

#[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 Module<PackageArgs, (), PackageError> for PackageModule<Box<dyn SpecificPackageManager>> {
    fn serialize_args(&self) -> serde_json::Value {
        serde_json::to_value(&self.args).unwrap()
    }
    
    fn module_name(&self) -> &'static str {
        "package"
    }

    fn run(self) -> Result<(), PackageError> {
        let packages = self.args.name;

        match &self.args.state {
            PackageState::Present => {
                self.manager.install(packages)
            }, PackageState::Absent => {
                self.manager.remove(packages)
            }, PackageState::Latest => {
                unimplemented!()
            }
        }
    }
}

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

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

        PackageModule {
            args,
            manager,
        }
    }
}


impl PackageModule<NoManager> {
    pub fn new() -> PackageArgsBuilder<builder::NoPackage, builder::NoState, builder::NoManager> {
        PackageArgsBuilder::new()
    }
}
    
#[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>;
}