signet 0.0.1

code signing tool
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

use std::marker::PhantomData;
use std::path::{Path, PathBuf};
use serde::{de::DeserializeOwned, Serialize};
use serde_yaml::{from_slice, to_string};
use crate::{Keychain, Keystore, System};
use super::{Context, Error};

pub struct Store<S> {
    root: PathBuf,
    sys:  PhantomData<S>,
}

impl<S: System> Store<S> {
    pub fn new(root: PathBuf) -> Self {
        let sys = PhantomData;
        Self { root, sys }
    }

    pub fn initialize(&self) -> Result<(), Error> {
        let path = &self.root.join("chains");
        S::mkdir(path).context(path)
    }

    pub fn keystore(&self) -> Result<Keystore, Error> {
        self.load(&keystore())
    }

    pub fn keychain(&self, name: &str) -> Result<Keychain, Error> {
        self.load(&keychain(name))
    }

    pub fn init<T: Persistent>(&self, data: &T) -> Result<(), Error> {
        let path  = &self.root.join(data.filename());
        let bytes = to_string(data).context(path)?;
        S::init(path, bytes.as_bytes()).context(path)
    }

    pub fn sync<T: Persistent>(&self, data: &T) -> Result<(), Error> {
        let path  = &self.root.join(data.filename());
        let bytes = to_string(data).context(path)?;
        S::sync(path, bytes.as_bytes()).context(path)
    }

    fn load<T: DeserializeOwned>(&self, path: &Path) -> Result<T, Error> {
        let path  = &self.root.join(path);
        let input = path.clone().into();
        let bytes = S::read(&input).context(path)?;
        from_slice(&bytes).context(path)
    }
}

pub trait Persistent: DeserializeOwned + Serialize {
    fn filename(&self) -> PathBuf;
}

impl Persistent for Keychain {
    fn filename(&self) -> PathBuf {
        keychain(&self.metadata().identity)
    }
}

impl Persistent for Keystore {
    fn filename(&self) -> PathBuf {
        keystore()
    }
}

fn keystore() -> PathBuf {
    Path::new("signet").with_extension("yml")
}

fn keychain(name: &str) -> PathBuf {
    Path::new("chains").join(name).with_extension("yml")
}