artisan_keystore 2.1.1

A keystore server designed for AH
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
126
127
128

//! Message types exchanged between the client and the keystore server.

use colored::*;
use serde::{Deserialize, Serialize}; // Add this crate to your Cargo.toml

#[derive(Serialize, Deserialize, Debug, Clone)]
/// Request to add a new key to the store.
pub struct AddKeyCommand {
    pub id: String,
    pub value: Vec<u8>,
    pub ttl: Option<u64>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
/// Request to fetch a key by id.
pub struct GetKeyCommand {
    pub id: String,
    pub version: Option<u32>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
/// Request to rotate a key when it is near expiration.
pub struct MigrateKeyCommand {
    pub id: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
/// Request to generate a key of a given length.
pub struct GenerateKeyCommand {
    pub length: Option<usize>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
/// Generic success/failure response from the server.
pub struct CommandResponse {
    pub success: bool,
    pub message: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
/// Wrapper around all possible commands exchanged with the server.
pub enum AppMessage {
    AddKey(AddKeyCommand),
    GetKey(GetKeyCommand),
    MigrateKey(MigrateKeyCommand),
    GenerateKey(GenerateKeyCommand),
    Response(CommandResponse),
}

// Implement Display for AddKeyCommand
impl std::fmt::Display for AddKeyCommand {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "{}: {}\n{}: {}\n{}: {}",
            "ID".green().bold(),
            self.id,
            "Value".blue(),
            hex::encode(self.value.clone()),
            "TTL".yellow(),
            self.ttl.unwrap_or(0)
        )
    }
}

// Implement Display for GetKeyCommand
impl std::fmt::Display for GetKeyCommand {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "{}: {}\n{}: {}",
            "ID".green().bold(),
            self.id,
            "Version".blue(),
            self.version.unwrap_or(0)
        )
    }
}

// Implement Display for MigrateKeyCommand
impl std::fmt::Display for MigrateKeyCommand {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}: {}", "ID".green().bold(), self.id)
    }
}

// Implement Display for GenerateKeyCommand
impl std::fmt::Display for GenerateKeyCommand {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}: {}", "Length".yellow(), self.length.unwrap_or(32))
    }
}

// Implement Display for CommandResponse
impl std::fmt::Display for CommandResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let status = if self.success {
            "Success".green().bold()
        } else {
            "Failure".red().bold()
        };
        write!(
            f,
            "{}: {}\n{}: {}",
            "Status".blue(),
            status,
            "Message".yellow(),
            self.message
        )
    }
}

// Implement Display for AppMessage
impl std::fmt::Display for AppMessage {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            AppMessage::AddKey(cmd) => write!(f, "{}\n{}", "Add Key Command".bold().magenta(), cmd),
            AppMessage::GetKey(cmd) => write!(f, "{}\n{}", "Get Key Command".bold().magenta(), cmd),
            AppMessage::MigrateKey(cmd) => {
                write!(f, "{}\n{}", "Migrate Key Command".bold().magenta(), cmd)
            }
            AppMessage::GenerateKey(cmd) => {
                write!(f, "{}\n{}", "Generate Key Command".bold().magenta(), cmd)
            }
            AppMessage::Response(res) => write!(f, "{}\n{}", "Command Response".bold().cyan(), res),
        }
    }
}