konarr 0.5.1

Konarr
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

//! # Task - Catalogue
use geekorm::{ConnectionManager, prelude::*};

use super::TaskTrait;
use crate::{
    models::{Component, ComponentType, SnapshotMetadataKey},
    utils::catalogue::Catalogue,
};

/// Catalogue the components task
#[derive(Default)]
pub struct CatalogueTask {
    force: bool,
    snapshot: Option<i32>,
}

#[async_trait::async_trait]
impl TaskTrait for CatalogueTask {
    async fn run(&self, database: &ConnectionManager) -> Result<(), crate::KonarrError> {
        log::info!("Starting Catalogue Task");
        let catalogue = Catalogue::new();

        let mut counter = 0;
        let mut comps = Component::all(&database.acquire().await).await?;
        log::debug!("Checking component types for `{}` Components", comps.len());

        for mut comp in comps.iter_mut() {
            if !self.force {
                match comp.component_type {
                    ComponentType::Unknown
                    | ComponentType::Library
                    | ComponentType::Application => {
                        if catalogue.catalogue(&mut comp)? {
                            log::info!("Updating component_type: {}", comp.component_type);
                            comp.update(&database.acquire().await).await?;
                            counter += 1;
                        }
                    }
                    _ => {}
                }
            } else if self.force && catalogue.catalogue(&mut comp)? {
                log::info!("Updating component_type: {}", comp.component_type);
                comp.update(&database.acquire().await).await?;
                counter += 1;
            }
        }
        if counter != 0 {
            log::info!("Updated `{}` component out of `{}`", counter, comps.len());
        }

        if let Some(snapshot) = self.snapshot {
            process_snapshot(database, snapshot).await?;
        }

        log::info!("Catalogue Task Completed");
        Ok(())
    }
}

impl CatalogueTask {
    /// Set the Catalogue Task to force
    pub fn force() -> Self {
        Self {
            force: true,
            snapshot: None,
        }
    }
    /// Set the Catalogue Task to a specific snapshot
    pub fn snapshot(id: impl Into<i32>) -> Self {
        Self {
            force: false,
            snapshot: Some(id.into()),
        }
    }
}

/// Once the catalogue has been run, process the snapshot metadata.
/// This function will process a specific snapshot and catalogue its components
/// and update the snapshot metadata accordingly.
async fn process_snapshot(
    database: &ConnectionManager,
    snapshot_id: i32,
) -> Result<(), crate::KonarrError> {
    log::info!("Processing catalogue Snapshot ID: {}", snapshot_id);
    let mut snapshot =
        crate::models::Snapshot::fetch_by_primary_key(&database.acquire().await, snapshot_id)
            .await?;
    let dependencies = snapshot
        .fetch_all_dependencies(&database.acquire().await)
        .await?;

    for dependency in dependencies {
        let comp = dependency.component();
        match comp.component_type {
            ComponentType::OperatingSystem => {
                // Capture OS Name and Version
                snapshot
                    .set_metadata(
                        &database.acquire().await,
                        SnapshotMetadataKey::Os,
                        &dependency.name(),
                    )
                    .await?;

                if let Some(version) = dependency.version() {
                    snapshot
                        .set_metadata(
                            &database.acquire().await,
                            SnapshotMetadataKey::OsVersion,
                            &version,
                        )
                        .await?;
                }
            }
            _ => {}
        }
    }
    Ok(())
}