a94a496b62
+ add versioning (only as counter) + get_secret from sled = refactor serde conversion to JSON
92 lines
2.8 KiB
Rust
92 lines
2.8 KiB
Rust
pub fn add(left: usize, right: usize) -> usize {
|
|
left + right
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn it_works() {
|
|
let result = add(2, 2);
|
|
assert_eq!(result, 4);
|
|
}
|
|
#[test]
|
|
fn test_update_secret() {
|
|
let db: sled::Db = sled::open("sled_db").unwrap();
|
|
update_secret(&db, "foo", TempSecret{version: -99, content: "cool".to_string()});
|
|
}
|
|
#[test]
|
|
fn test_get_secret() {
|
|
let db: sled::Db = sled::open("sled_db").unwrap();
|
|
get_secret(&db, "foo");
|
|
}
|
|
}
|
|
|
|
use sled::Db;
|
|
use base::{deserialize_secret_struct, serialize_secret_json, TempSecret};
|
|
|
|
/// [TODO] Currently no proper versioning
|
|
/// inserts a secret. If there was already a secret in the given path, the version is incremented
|
|
fn update_secret(db: &Db, path: &str, mut secret: TempSecret) {
|
|
match get_secret(db, path) {
|
|
Some(old_secret) => {
|
|
// case secret found. TODO save it somewhere for versioning
|
|
secret.version = old_secret.version + 1;
|
|
#[cfg(test)]
|
|
print!("something was found. new version {} \n", secret.version)
|
|
}
|
|
None => {
|
|
// case new secret
|
|
secret.version = 1;
|
|
}
|
|
}
|
|
// if let secret_json = serialize_secret_json(&secret) {
|
|
// let _res = db.insert(path, secret_json); // maybe this can be handled cleaner
|
|
match serialize_secret_json(&secret) {
|
|
Ok(secret_json) => {
|
|
#[cfg(test)]
|
|
println!("String: {:?}", secret_json.clone());
|
|
let as_ivec = sled::IVec::from(secret_json.into_bytes()); // maybe outsource this in a fn later
|
|
#[cfg(test)]
|
|
println!("ivec: {:?}", as_ivec);
|
|
match db.insert(path, as_ivec) {
|
|
Ok(_) => println!("Secret inserted"),
|
|
Err(e) => eprintln!("Failed to insert secret: {}", e),
|
|
}
|
|
}
|
|
Err(e) => eprintln!("Failed to serialize secret: {}", e),
|
|
}
|
|
}
|
|
|
|
// read and return a secret from the DB
|
|
//if there is no secret, return None
|
|
fn get_secret(db: &Db, path: &str) -> Option<TempSecret>{
|
|
let raw_secret;
|
|
match db.get(path) {
|
|
Ok(Some(ivec)) => {
|
|
raw_secret = ivec;
|
|
}
|
|
Err(e) => {
|
|
eprintln!("Error on retrieving secret: {}", e);
|
|
return None;
|
|
}
|
|
Ok(None) => {
|
|
return None;
|
|
}
|
|
}
|
|
// outsource this in a fn later. TODO maybe deal with unwrap
|
|
let as_str = String::from_utf8(raw_secret.to_vec()).unwrap();
|
|
match deserialize_secret_struct(&as_str) {
|
|
Ok(secret) => {
|
|
#[cfg(test)]
|
|
println!("got some secret: {:?}", secret);
|
|
return Some(secret);
|
|
}
|
|
Err(e) => {
|
|
eprintln!("error on secret deserialization: {}", e);
|
|
return None;
|
|
}
|
|
|
|
}
|
|
}
|