urma-cli 0.2.2

Command-line program for URMA identities, wallets, Wire, archives and Git
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

use crate::{config, git_progress, provider_warnings::ProviderWarnings};
use std::{
    os::unix::fs::DirBuilderExt,
    path::PathBuf,
    sync::Mutex,
    time::{SystemTime, UNIX_EPOCH},
};
use tracing_subscriber::{
    Layer,
    filter::{LevelFilter, Targets},
    fmt::MakeWriter,
    layer::SubscriberExt,
    util::SubscriberInitExt,
};
use urma_runtime::error::Error;

pub(crate) fn install(
    verbosity: u8,
    writer: impl for<'a> MakeWriter<'a> + Clone + Send + Sync + 'static,
) -> Result<Destination, Error> {
    let level = config::load()?.log_level.filter();
    match config::log_output()? {
        config::LogOutput::Console => install_stderr(writer, level),
        config::LogOutput::File => install_file(verbosity, writer, level),
    }
}

pub(crate) enum Destination {
    File(PathBuf),
    Console,
}

fn install_stderr(
    writer: impl for<'a> MakeWriter<'a> + Clone + Send + Sync + 'static,
    level: LevelFilter,
) -> Result<Destination, Error> {
    let warnings = ProviderWarnings::new(writer.clone(), config::provider_warning_window());
    tracing_subscriber::registry()
        .with(
            tracing_subscriber::fmt::layer()
                .with_ansi(false)
                .with_writer(writer)
                .with_filter(
                    Targets::new()
                        .with_target("urma", level)
                        .with_target("urma_timer", LevelFilter::OFF)
                        .with_target("urma_ui", LevelFilter::OFF),
                )
                .with_filter(warnings),
        )
        .try_init()
        .map_err(|cause| Error::Io(std::io::Error::other(cause)))?;
    Ok(Destination::Console)
}

fn install_file(
    verbosity: u8,
    writer: impl for<'a> MakeWriter<'a> + Send + Sync + 'static,
    level: LevelFilter,
) -> Result<Destination, Error> {
    let directory = config::log_directory()?;
    std::fs::DirBuilder::new()
        .recursive(true)
        .mode(0o700)
        .create(&directory)?;
    let timestamp = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .map_err(|cause| Error::Io(std::io::Error::other(cause)))?;
    let (file, path) = tempfile::Builder::new()
        .prefix(&format!("urma-{}-", timestamp.as_secs()))
        .suffix(".log")
        .tempfile_in(directory)?
        .keep()
        .map_err(|cause| Error::Io(cause.error))?;
    let console_level = match verbosity {
        0 => LevelFilter::WARN,
        1 => LevelFilter::INFO,
        2 => LevelFilter::DEBUG,
        _ => LevelFilter::TRACE,
    };
    tracing_subscriber::registry()
        .with(
            git_progress::ProgressLayer::new(file.try_clone()?, level >= LevelFilter::INFO)
                .with_filter(Targets::new().with_target("urma_ui", LevelFilter::INFO)),
        )
        .with(
            tracing_subscriber::fmt::layer()
                .with_target(false)
                .with_level(false)
                .with_ansi(false)
                .with_writer(writer)
                .with_filter(
                    Targets::new()
                        .with_target("urma_progress", console_level)
                        .with_target("urma_stage", LevelFilter::INFO),
                ),
        )
        .with(
            tracing_subscriber::fmt::layer()
                .with_ansi(false)
                .with_writer(Mutex::new(file))
                .with_filter(
                    Targets::new()
                        .with_target("urma", level)
                        .with_target("urma_timer", LevelFilter::OFF)
                        .with_target("urma_ui", LevelFilter::OFF),
                ),
        )
        .try_init()
        .map_err(|cause| Error::Io(std::io::Error::other(cause)))?;
    Ok(Destination::File(path))
}