ate-auth 1.9.0

Represents a standardized data model and API for authenticating an ATE chain-of-trust
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

#![allow(unused_imports)]
use ate::prelude::*;
use ate::utils::LoadProgress;
use error_chain::bail;
use std::io::stdout;
use std::io::Write;
use std::sync::Arc;
use tracing::{debug, error, info, instrument, span, trace, warn, Level};
use url::Url;

use crate::cmd::*;
use crate::error::*;
use crate::helper::*;
use crate::opt::*;
use crate::prelude::*;
use crate::request::*;

pub async fn main_opts_db(
    opts_db: OptsDatabase,
    token: Option<String>,
    token_path: Option<String>,
    auth: url::Url,
    hint_group: &str,
) -> Result<(), AteError> {
    let db_name = match &opts_db.action {
        DatabaseAction::Truncate(action) => action.name.clone(),
        DatabaseAction::Details(action) => action.name.clone(),
    };

    let group_name = match db_name.split("/").map(|a| a.to_string()).next() {
        Some(a) => a,
        None => {
            eprintln!("The database name is invalid");
            std::process::exit(1);
        }
    };

    // Build the conf and registry
    let conf = ConfAte::default();
    let session = main_session_group(
        token.clone(),
        token_path.clone(),
        group_name.clone(),
        true,
        None,
        Some(auth.clone()),
        hint_group,
    )
    .await?;
    let registry = ate::mesh::Registry::new(&conf).await.temporal(true);

    // Create a progress bar loader
    let progress_local = LoadProgress::new(std::io::stderr());
    let progress_remote = LoadProgress::new(std::io::stderr());

    // Load the chain
    let remote = crate::prelude::origin_url(&opts_db.remote, "db");
    let guard = registry
        .open_ext(
            &remote,
            &ChainKey::from(db_name.clone()),
            progress_local,
            progress_remote,
        )
        .await?;
    let db = guard.as_arc();
    
    match opts_db.action {
        DatabaseAction::Details(_action) => {
            let guard = db.metrics().lock().unwrap();
            println!("Database Chain Details");
            println!("======================");
            println!("Remote: {}", remote);
            println!("Group Name: {}", group_name);
            println!("DB Name: {}", db_name);
            println!("Size: {}", guard.chain_size);
        }
        DatabaseAction::Truncate(_action) => {
            print!("Deleting all events...");
            let dio = db.dio_full(&session).await;
            let mut ids = dio.dio.all_keys().await;
            while ids.is_empty() == false {
                print!(".");
                for _ in 0..100 {
                    let id = match ids.pop() {
                        Some(a) => a,
                        None => break,
                    };
                    let _ = dio.delete(&id).await;
                }
                dio.commit().await?;
            }
            println!("Done");
        }
    }
    Ok(())
}