corrator 1.4.1

A tool to verify the versions of apps used inside docker containers.
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
120
121
122
123
124
125

use std::path::PathBuf;

use bonsaidb::core::Error;

use crate::end_of_life::Cycle;
use bonsaidb::{
	core::{
		connection::Connection,
		schema::{Collection, SerializedCollection},
	},
	local::{
		config::{Builder, StorageConfiguration},
		Database,
	},
};
use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize, Collection)]
#[collection(
    name = "eol_cycles",
    primary_key = String,
    natural_id = Some(format!("{}::{}", self.product, self.cycle))
)]
struct CachedCycle {
	product: String,
	cycle: String,
	data: Cycle,
}

/// Retrieve an existing cached endoflife.date product cycle
///
/// # Examples
///
/// ```no_run
/// use corrator::end_of_life::cache;
///
/// let db = cache::eol_cache_db().unwrap();
/// cache::get_cycle(&db, "ubuntu", "22.10");
/// ```
pub fn get_cycle(
	db: &Database,
	product: &str,
	cycle: &str,
) -> Result<Option<Cycle>, bonsaidb::core::Error> {
	let key = format!("{product}::{cycle}");
	let entry = CachedCycle::get(&key, db)?;

	match entry {
		Some(x) => Ok(Some(x.contents.data)),
		None => Ok(None),
	}
}

/// Insert a new endoflife.date product cycle
///
/// # Examples
///
/// ```no_run
/// use corrator::end_of_life::{cache, Cycle};
///
/// let db = cache::eol_cache_db().unwrap();
/// let cycle: Cycle = Default::default();
/// cache::insert_cycle(&db, "ubuntu", "22.10", cycle);
/// ```
pub fn insert_cycle(
	db: &Database,
	product: &str,
	cycle: &str,
	data: Cycle,
) -> Result<Cycle, Error> {
	let key = format!("{product}::{cycle}");
	let entry = CachedCycle {
		product: String::from(product),
		cycle: String::from(cycle),
		data,
	};

	if let Ok(None) = get_cycle(db, product, cycle) {
		db.collection::<CachedCycle>().insert(&key, &entry)?;
	}

	Ok(entry.data)
}

/// Clears the cache entirely
///
/// # Examples
/// ```no_run
/// use corrator::end_of_life::cache;
///
/// cache::clear();
/// ```
pub fn clear() -> Result<(), Error> {
	drop(std::fs::remove_dir_all(eol_cache_db_path()));

	Ok(())
}

/// Returns a reusable bonsaidb instance
///
/// This was made a public function to reduce the number of times a DB
/// connection was created, when bonsaidb started producting intermittent
/// connection refusals.
///
/// # Examples
/// ```no_run
/// use corrator::end_of_life::cache;
///
/// let db = cache::eol_cache_db().unwrap();
/// ```
pub fn eol_cache_db() -> Result<Database, Error> {
	let db_path = eol_cache_db_path();

	Ok(
		Database::open::<CachedCycle>(StorageConfiguration::new(db_path))
			.expect("Couldn't connect to DB"),
	)
}

fn eol_cache_db_path() -> PathBuf {
	directories::ProjectDirs::from("rs", "", "corrator")
		.expect("could not find project directory")
		.data_dir()
		.join("corrator.bonsaidb")
}