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

//! # Konarr Project - Agent
use super::KonarrProject;
use crate::{
    KonarrClient, KonarrError,
    client::{ServerInfo, snapshot::KonarrSnapshot},
};
use log::{debug, info};

/// Konarr Project Snapshot Data struct
///
/// This struct is used to store a different data for checking if
/// a snapshot needs to be created
#[derive(Debug, Default)]
pub struct KonarrProjectSnapshotData {
    /// Server Information
    pub info: Option<ServerInfo>,
    /// Container SHA 256
    pub container_sha: Option<String>,
    /// Tool name + version
    pub tool: Option<String>,
}

impl KonarrProject {
    /// Get or create a new snapshot for a project
    ///
    /// This will create a new snapshot ifthe following conditions are met:
    ///
    /// - Container SHA is different from the last snapshot
    /// - Tool + Version is different from the last snapshot
    /// - Last snapshot is older than 24 hours
    pub async fn snapshot(
        &mut self,
        client: &KonarrClient,
        data: &KonarrProjectSnapshotData,
    ) -> Result<KonarrSnapshot, KonarrError> {
        let version = data.info.clone().unwrap_or_default().version()?;

        if let Some(snap) = &self.snapshot {
            // Force a re-scan flag
            if let Some(data) = snap.metadata.get("rescan") {
                if data == "true" {
                    info!("Force rescan flag is set, creating new snapshot");
                    self.create_snapshot(client).await?;
                    return Ok(self.snapshot.clone().unwrap());
                }
            }

            // If the tool+version has changes (updated) we need to create a new snapshot
            if let Some(data_tool) = &data.tool {
                log::debug!("Local tool version: {}", data_tool);
                if let Some(tool) = snap.metadata.get("bom.tool") {
                    if version.major <= 0 && version.minor <= 3 {
                        // +v0.3 = name@version
                        log::debug!("Remote Tool version: {}", tool);
                        if tool != data_tool {
                            info!("Tool version is different, creating new snapshot with new tool");
                            self.create_snapshot(client).await?;
                            return Ok(self.snapshot.clone().unwrap());
                        }
                    } else {
                        // For backwards compatibility
                        log::warn!(
                            "Checking tool name and version does not work for v0.2 or below"
                        );
                    }
                }
            }

            // Time passed
            let now = chrono::Utc::now();
            if now.signed_duration_since(snap.created_at).num_hours() >= 24 {
                info!("24 hours has passed since the last snapshot, creating a new one");
                self.create_snapshot(client).await?;
                return Ok(self.snapshot.clone().unwrap());
            }

            // Check container SHA
            if let Some(container_sha) = &data.container_sha {
                if let Some(sha) = snap.metadata.get("container.sha") {
                    debug!("Container Snapshot SHA: {} == {}", &container_sha, sha);
                    if sha != container_sha {
                        info!("Snapshot SHA for Container is different: {}", self.name);
                        self.create_snapshot(client).await?;
                        return Ok(self.snapshot.clone().unwrap());
                    }
                    log::debug!("Container SHAs are the same, skipping creation");
                } else {
                    debug!("Creating new Snapshot for Container: {}", self.name);
                    self.create_snapshot(client).await?;
                }
            }
        } else {
            info!("Creating initial Snapshot...");
            self.create_snapshot(client).await?;
        }

        Ok(self.snapshot.clone().unwrap())
    }

    /// Create a new snapshot for a project and update the snapshot field
    async fn create_snapshot(&mut self, client: &KonarrClient) -> Result<(), KonarrError> {
        let snap = KonarrSnapshot::create(client, self.id).await?;
        self.snapshot = Some(snap);
        Ok(())
    }
}