2021-02-13 13:21:49 -07:00
|
|
|
use std::env;
|
|
|
|
|
2021-04-13 12:14:07 -06:00
|
|
|
use chrono::Utc;
|
|
|
|
|
2023-04-11 09:26:16 -06:00
|
|
|
use atuin_common::utils::uuid_v7;
|
2020-10-04 17:59:28 -06:00
|
|
|
|
2023-06-15 04:29:40 -06:00
|
|
|
mod builder;
|
|
|
|
|
|
|
|
/// Client-side history entry.
|
|
|
|
///
|
|
|
|
/// Client stores data unencrypted, and only encrypts it before sending to the server.
|
|
|
|
///
|
|
|
|
/// To create a new history entry, use one of the builders:
|
|
|
|
/// - [`History::import()`] to import an entry from the shell history file
|
|
|
|
/// - [`History::capture()`] to capture an entry via hook
|
|
|
|
/// - [`History::from_db()`] to create an instance from the database entry
|
|
|
|
//
|
|
|
|
// ## Implementation Notes
|
|
|
|
//
|
|
|
|
// New fields must should be added to `encryption::{encode, decode}` in a backwards
|
|
|
|
// compatible way. (eg sensible defaults and updating the nfields parameter)
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, sqlx::FromRow)]
|
2020-10-04 17:59:28 -06:00
|
|
|
pub struct History {
|
2023-06-15 04:29:40 -06:00
|
|
|
/// A client-generated ID, used to identify the entry when syncing.
|
|
|
|
///
|
|
|
|
/// Stored as `client_id` in the database.
|
2021-02-13 10:02:52 -07:00
|
|
|
pub id: String,
|
2023-06-15 04:29:40 -06:00
|
|
|
/// When the command was run.
|
2021-04-13 12:14:07 -06:00
|
|
|
pub timestamp: chrono::DateTime<Utc>,
|
2023-06-15 04:29:40 -06:00
|
|
|
/// How long the command took to run.
|
2021-02-13 10:02:52 -07:00
|
|
|
pub duration: i64,
|
2023-06-15 04:29:40 -06:00
|
|
|
/// The exit code of the command.
|
2021-02-13 10:02:52 -07:00
|
|
|
pub exit: i64,
|
2023-06-15 04:29:40 -06:00
|
|
|
/// The command that was run.
|
2020-10-04 17:59:28 -06:00
|
|
|
pub command: String,
|
2023-06-15 04:29:40 -06:00
|
|
|
/// The current working directory when the command was run.
|
2020-10-04 17:59:28 -06:00
|
|
|
pub cwd: String,
|
2023-06-15 04:29:40 -06:00
|
|
|
/// The session ID, associated with a terminal session.
|
2021-02-13 13:21:49 -07:00
|
|
|
pub session: String,
|
2023-06-15 04:29:40 -06:00
|
|
|
/// The hostname of the machine the command was run on.
|
2021-02-13 13:21:49 -07:00
|
|
|
pub hostname: String,
|
2023-06-15 04:29:40 -06:00
|
|
|
/// Timestamp, which is set when the entry is deleted, allowing a soft delete.
|
2023-03-20 03:26:54 -06:00
|
|
|
pub deleted_at: Option<chrono::DateTime<Utc>>,
|
2020-10-04 17:59:28 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
impl History {
|
2023-03-20 03:26:54 -06:00
|
|
|
#[allow(clippy::too_many_arguments)]
|
2023-06-15 04:29:40 -06:00
|
|
|
fn new(
|
2021-04-13 12:14:07 -06:00
|
|
|
timestamp: chrono::DateTime<Utc>,
|
2021-02-13 13:21:49 -07:00
|
|
|
command: String,
|
|
|
|
cwd: String,
|
|
|
|
exit: i64,
|
|
|
|
duration: i64,
|
|
|
|
session: Option<String>,
|
|
|
|
hostname: Option<String>,
|
2023-03-20 03:26:54 -06:00
|
|
|
deleted_at: Option<chrono::DateTime<Utc>>,
|
2021-02-14 08:15:26 -07:00
|
|
|
) -> Self {
|
2021-02-14 11:00:41 -07:00
|
|
|
let session = session
|
|
|
|
.or_else(|| env::var("ATUIN_SESSION").ok())
|
2023-04-11 09:26:16 -06:00
|
|
|
.unwrap_or_else(|| uuid_v7().as_simple().to_string());
|
2023-06-12 10:58:46 -06:00
|
|
|
let hostname = hostname.unwrap_or_else(|| {
|
|
|
|
format!(
|
|
|
|
"{}:{}",
|
|
|
|
env::var("ATUIN_HOST_NAME").unwrap_or_else(|_| whoami::hostname()),
|
|
|
|
env::var("ATUIN_HOST_USER").unwrap_or_else(|_| whoami::username())
|
|
|
|
)
|
|
|
|
});
|
2021-02-13 13:21:49 -07:00
|
|
|
|
2021-02-14 08:15:26 -07:00
|
|
|
Self {
|
2023-04-11 09:26:16 -06:00
|
|
|
id: uuid_v7().as_simple().to_string(),
|
2021-02-13 12:37:00 -07:00
|
|
|
timestamp,
|
2020-10-05 10:20:48 -06:00
|
|
|
command,
|
|
|
|
cwd,
|
2021-02-13 10:02:52 -07:00
|
|
|
exit,
|
|
|
|
duration,
|
2021-02-13 13:21:49 -07:00
|
|
|
session,
|
|
|
|
hostname,
|
2023-03-20 03:26:54 -06:00
|
|
|
deleted_at,
|
2020-10-04 17:59:28 -06:00
|
|
|
}
|
|
|
|
}
|
2022-04-25 00:13:30 -06:00
|
|
|
|
2023-06-15 04:29:40 -06:00
|
|
|
/// Builder for a history entry that is imported from shell history.
|
|
|
|
///
|
|
|
|
/// The only two required fields are `timestamp` and `command`.
|
|
|
|
///
|
|
|
|
/// ## Examples
|
|
|
|
/// ```
|
|
|
|
/// use atuin_client::history::History;
|
|
|
|
///
|
|
|
|
/// let history: History = History::import()
|
|
|
|
/// .timestamp(chrono::Utc::now())
|
|
|
|
/// .command("ls -la")
|
|
|
|
/// .build()
|
|
|
|
/// .into();
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// If shell history contains more information, it can be added to the builder:
|
|
|
|
/// ```
|
|
|
|
/// use atuin_client::history::History;
|
|
|
|
///
|
|
|
|
/// let history: History = History::import()
|
|
|
|
/// .timestamp(chrono::Utc::now())
|
|
|
|
/// .command("ls -la")
|
|
|
|
/// .cwd("/home/user")
|
|
|
|
/// .exit(0)
|
|
|
|
/// .duration(100)
|
|
|
|
/// .build()
|
|
|
|
/// .into();
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// Unknown command or command without timestamp cannot be imported, which
|
|
|
|
/// is forced at compile time:
|
|
|
|
///
|
|
|
|
/// ```compile_fail
|
|
|
|
/// use atuin_client::history::History;
|
|
|
|
///
|
|
|
|
/// // this will not compile because timestamp is missing
|
|
|
|
/// let history: History = History::import()
|
|
|
|
/// .command("ls -la")
|
|
|
|
/// .build()
|
|
|
|
/// .into();
|
|
|
|
/// ```
|
|
|
|
pub fn import() -> builder::HistoryImportedBuilder {
|
|
|
|
builder::HistoryImported::builder()
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Builder for a history entry that is captured via hook.
|
|
|
|
///
|
|
|
|
/// This builder is used only at the `start` step of the hook,
|
|
|
|
/// so it doesn't have any fields which are known only after
|
|
|
|
/// the command is finished, such as `exit` or `duration`.
|
|
|
|
///
|
|
|
|
/// ## Examples
|
|
|
|
/// ```rust
|
|
|
|
/// use atuin_client::history::History;
|
|
|
|
///
|
|
|
|
/// let history: History = History::capture()
|
|
|
|
/// .timestamp(chrono::Utc::now())
|
|
|
|
/// .command("ls -la")
|
|
|
|
/// .cwd("/home/user")
|
|
|
|
/// .build()
|
|
|
|
/// .into();
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// Command without any required info cannot be captured, which is forced at compile time:
|
|
|
|
///
|
|
|
|
/// ```compile_fail
|
|
|
|
/// use atuin_client::history::History;
|
|
|
|
///
|
|
|
|
/// // this will not compile because `cwd` is missing
|
|
|
|
/// let history: History = History::capture()
|
|
|
|
/// .timestamp(chrono::Utc::now())
|
|
|
|
/// .command("ls -la")
|
|
|
|
/// .build()
|
|
|
|
/// .into();
|
|
|
|
/// ```
|
|
|
|
pub fn capture() -> builder::HistoryCapturedBuilder {
|
|
|
|
builder::HistoryCaptured::builder()
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Builder for a history entry that is imported from the database.
|
|
|
|
///
|
|
|
|
/// All fields are required, as they are all present in the database.
|
|
|
|
///
|
|
|
|
/// ```compile_fail
|
|
|
|
/// use atuin_client::history::History;
|
|
|
|
///
|
|
|
|
/// // this will not compile because `id` field is missing
|
|
|
|
/// let history: History = History::from_db()
|
|
|
|
/// .timestamp(chrono::Utc::now())
|
|
|
|
/// .command("ls -la".to_string())
|
|
|
|
/// .cwd("/home/user".to_string())
|
|
|
|
/// .exit(0)
|
|
|
|
/// .duration(100)
|
|
|
|
/// .session("somesession".to_string())
|
|
|
|
/// .hostname("localhost".to_string())
|
|
|
|
/// .deleted_at(None)
|
|
|
|
/// .build()
|
|
|
|
/// .into();
|
|
|
|
/// ```
|
|
|
|
pub fn from_db() -> builder::HistoryFromDbBuilder {
|
|
|
|
builder::HistoryFromDb::builder()
|
|
|
|
}
|
|
|
|
|
2022-04-25 00:13:30 -06:00
|
|
|
pub fn success(&self) -> bool {
|
|
|
|
self.exit == 0 || self.duration == -1
|
|
|
|
}
|
2020-10-04 17:59:28 -06:00
|
|
|
}
|