bpm_core 0.1.0

Cross-platform software helping to verify, prove and secure package compilation, building, fetching, and deployment. Core package.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

use std::{
    process::{Command, Stdio},
    sync::Arc,
};

use log::debug;
use tokio::sync::Mutex;

use crate::package_managers::{
    pacman::pacman_package_manager::PacmanPackageManager, traits::package_manager::PackageManager,
};

/**
 * Package managers service
 */
pub struct PackageManagersService {
    available_package_managers: Arc<Mutex<Vec<Arc<Box<dyn PackageManager>>>>>,
    selected_package_manager: Arc<Mutex<Option<usize>>>,
}

impl PackageManagersService {
    /**
     * Create service
     */
    pub fn new() -> Self {
        Self {
            available_package_managers: Arc::new(Mutex::new(Vec::new())),
            selected_package_manager: Arc::new(Mutex::new(Some(0))),
        }
    }
    /**
     * Probe and init package managers
     */
    pub async fn init_package_managers(&self) {
        debug!("Probing installed package managers...");

        let supported_package_managers = vec!["pacman"];

        for package_manager_cmd in supported_package_managers {
            // Check if package manager installed
            let command_spawn = Command::new(package_manager_cmd)
                .stdout(Stdio::null())
                .stderr(Stdio::null())
                .spawn();
            match command_spawn {
                Ok(_) => (),
                Err(_) => {
                    debug!(
                    "Package manager {package_manager_cmd} was not found on system, skipping..."
                );

                    continue;
                }
            }

            // If so, build struct then cast to PackageManager trait
            let package_manager: Arc<Box<dyn PackageManager>> = match package_manager_cmd {
                "pacman" => Arc::new(Box::new(PacmanPackageManager {})),
                _ => panic!(
                    "Package manager {} exists, but does not match any known struct",
                    package_manager_cmd
                ),
            };

            self.available_package_managers
                .lock()
                .await
                .push(package_manager);
        }

        debug!(
            "Done probing installed package managers ! ( found {} package managers )",
            self.available_package_managers.lock().await.len()
        );
    }

    /**
     * Return selected package manager
     */
    pub async fn get_selected_package_manager(&self) -> Arc<Box<dyn PackageManager>> {
        let package_managers = self.available_package_managers.lock().await;

        let selected_id = self
            .selected_package_manager
            .lock()
            .await
            .expect("Package manager selected id must be set in order to get package manager");

        let package_manager = package_managers
            .get(selected_id)
            .expect("Could not find package manager");

        Arc::clone(package_manager)
    }
}