io-keyring 0.0.2

Set of I/O-free Rust coroutines and runtimes to manage keyring entries
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

#![cfg(feature = "std")]

use std::{
    env,
    io::{stdin, stdout, Write},
};

use io_keyring::{
    coroutines::{
        delete::{DeleteSecret, DeleteSecretResult},
        read::{ReadSecret, ReadSecretResult},
        write::{WriteSecret, WriteSecretResult},
    },
    entry::KeyringEntry,
    runtimes::std::handle,
};
use secrecy::ExposeSecret;

fn main() {
    env_logger::init();

    let service = match env::var("SERVICE") {
        Ok(service) => service,
        Err(_) => read_line("Keyring service?"),
    };

    let name = match env::var("NAME") {
        Ok(name) => name,
        Err(_) => read_line("Keyring entry name?"),
    };

    let password = match env::var("PASSWORD") {
        Ok(password) => password,
        Err(_) => read_line("Keyring entry password?"),
    };

    let entry = KeyringEntry::new(name).with_service(service);

    let mut arg = None;
    let mut read = ReadSecret::new(entry.clone());

    let secret = loop {
        match read.resume(arg.take()) {
            ReadSecretResult::Ok(secret) => break Ok(secret),
            ReadSecretResult::Io(io) => match handle(io) {
                Ok(io) => arg = Some(io),
                Err(err) => break Err(err),
            },
            ReadSecretResult::Err(err) => panic!("{err}"),
        }
    };

    println!("first read: {secret:?}");

    println!("store new password");

    let mut arg = None;
    let mut write = WriteSecret::new(entry.clone(), password);

    loop {
        match write.resume(arg.take()) {
            WriteSecretResult::Ok(()) => break,
            WriteSecretResult::Io(io) => arg = Some(handle(io).unwrap()),
            WriteSecretResult::Err(err) => panic!("{err}"),
        }
    }

    let mut arg = None;
    let mut read = ReadSecret::new(entry.clone());

    let secret = loop {
        match read.resume(arg.take()) {
            ReadSecretResult::Ok(secret) => break secret,
            ReadSecretResult::Io(io) => arg = Some(handle(io).unwrap()),
            ReadSecretResult::Err(err) => panic!("{err}"),
        }
    };

    println!("second read: {:?}", secret.expose_secret());

    println!("delete entry");

    let mut arg = None;
    let mut delete = DeleteSecret::new(entry.clone());

    while let DeleteSecretResult::Io(io) = delete.resume(arg) {
        arg = Some(handle(io).unwrap());
    }

    let mut arg = None;
    let mut read = ReadSecret::new(entry);

    let secret = loop {
        match read.resume(arg.take()) {
            ReadSecretResult::Ok(secret) => break Ok(secret),
            ReadSecretResult::Io(io) => match handle(io) {
                Ok(io) => arg = Some(io),
                Err(err) => break Err(err),
            },
            ReadSecretResult::Err(err) => panic!("{err}"),
        }
    };

    println!("no third read possible: {secret:?}");
}

fn read_line(prompt: &str) -> String {
    print!("{prompt} ");
    stdout().flush().unwrap();

    let mut line = String::new();
    stdin().read_line(&mut line).unwrap();

    line.trim().to_owned()
}