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
|
use clap::Subcommand;
use eyre::{Result, WrapErr};
use tracing_subscriber::filter::EnvFilter;
use crate::atuin_client::settings::Settings;
mod config;
mod daemon;
mod default_config;
mod history;
mod info;
mod stats;
// mod store;
mod sync;
mod wrapped;
#[derive(Subcommand, Debug)]
#[command(infer_subcommands = true)]
pub(crate) enum Cmd {
/// Manipulate shell history
#[command(subcommand)]
History(history::Cmd),
/// Interact with the daemon
#[command(subcommand)]
Daemon(daemon::Cmd),
#[command(subcommand)]
/// Request a sync or view sync status
Sync(sync::Cmd),
/// Information about dotfiles locations and ENV vars
#[command()]
Info,
/// Calculate statistics for your history
Stats(stats::Cmd),
#[command()]
/// Display a recap of your last year's history
Wrapped { year: Option<i32> },
/// Print the default atuin configuration (config.toml)
#[command()]
DefaultConfig,
#[command(subcommand)]
/// Manage your configuration
Config(config::Cmd),
}
impl Cmd {
pub(crate) fn run(self) -> Result<()> {
let mut runtime = tokio::runtime::Builder::new_current_thread();
let runtime = runtime.enable_all().build().unwrap();
let res = {
let settings = Settings::new().wrap_err("could not load client settings")?;
runtime.block_on(self.run_inner(settings))
};
runtime.shutdown_timeout(std::time::Duration::from_millis(50));
res
}
async fn run_inner(self, settings: Settings) -> Result<()> {
// ATUIN_LOG env var overrides config file level settings
let env_log_set = std::env::var("ATUIN_LOG").is_ok();
// Base filter from env var (or empty if not set)
let base_filter =
EnvFilter::from_env("ATUIN_LOG").add_directive("sqlx_sqlite::regexp=off".parse()?);
if env_log_set
&& let Err(e) = tracing_subscriber::fmt()
.with_file(true)
.with_line_number(true)
.with_level(true)
.without_time()
.with_env_filter(base_filter)
.try_init()
{
eprintln!("failed to initialize logging: {e}");
}
tracing::trace!(command = ?self, "client command");
// Skip initializing any databases for history
// This is a pretty hot path, as it runs before and after every single command the user
// runs
match self {
Self::History(history) => return history.run(&settings).await,
Self::Config(config) => return config.run(&settings).await,
_ => {}
}
match self {
Self::Daemon(cmd) => cmd.run(&settings).await,
Self::Sync(sync) => sync.run(settings).await,
Self::Stats(stats) => stats.run(&settings).await,
Self::Wrapped { year } => wrapped::run(year, &settings).await,
// Self::Store(store) => store.run(&settings, &db, sqlite_store).await,
Self::Info => info::run(&settings).await,
Self::DefaultConfig => {
default_config::run();
Ok(())
}
Self::History(_) | Self::Config(_) => {
unreachable!()
}
}
}
}
|
