athaller/hstdb - Change B5GTKRQI4WCU4NUJLJJ22GRPS7DJ72PXE3FRPI3LL7UU2QDAY26QC

Fix newlines being saved as a valid command (#26)

When a command was received that only contained newlines it was saved as a valid command.

This pullrequests changes that and strips ending newlines (\n and \r\n) from the command. When that results in an empty string the command will not be saved like any other empty command.

Also added some intigration tests for the client/server.

Fixes #21.

Created by Alexander Thaller on October 5, 2021

B5GTKRQI4WCU4NUJLJJ22GRPS7DJ72PXE3FRPI3LL7UU2QDAY26QC

Dependencies

In channels

main

Change contents

Insertion in Cargo.lock at line 35 [4.61]

[3.430]

[3.622]

name = "ansi_term"
version = "0.12.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d52a9bb7ec0cf484c551830a7ce27bd20d67eac647e1befb56b0be4ee39a55d2"
dependencies = [
 "winapi",
]
[[package]]

Replacement in Cargo.lock at line 131 [4.61]
B:BD[3.1517] → [3.1517:1531]
```
 "ansi_term",
```
[3.1517]
[3.1531]
```
 "ansi_term 0.11.0",
```

Insertion in Cargo.lock at line 229 [4.61]

[5.1156]

[6.1683]

]
[[package]]
name = "ctor"
version = "0.1.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ccc0a48a9b826acdf4028595adc9db92caea352f7af011a3034acd172a52a0aa"
dependencies = [
 "quote",
 "syn",

Insertion in Cargo.lock at line 252 [4.61]

[3.2081]

name = "diff"
version = "0.1.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0e25ea47919b1560c4e3b7fe0aaab9becf5b84a10325ddf7db0f0ba5e1026499"
[[package]]

Insertion in Cargo.lock at line 428 [4.61]
[7.505]
[7.505]
```
 "pretty_assertions",
```
Insertion in Cargo.lock at line 435 [4.61]
[3.2796]
[8.1518]
```
 "tempfile",
```

Insertion in Cargo.lock at line 619 [4.61]

[2.2176]

[9.2338]


[[package]]
name = "output_vt100"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "53cdc5b785b7a58c5aad8216b3dfa114df64b0b06ae6e1501cef91df2fbdf8f9"
dependencies = [
 "winapi",
]

Insertion in Cargo.lock at line 679 [4.61]

[10.3779]

[3.2797]


[[package]]
name = "ppv-lite86"
version = "0.2.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ac74c624d6b2d21f425f752262f42188365d7b8ff1aff74c82e45136510a4857"
[[package]]
name = "pretty_assertions"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ec0cfe1b2403f172ba0f234e500906ee0a3e493fb81092dac23ebefe129301cc"
dependencies = [
 "ansi_term 0.12.1",
 "ctor",
 "diff",
 "output_vt100",
]

Insertion in Cargo.lock at line 757 [4.61]

[8.2870]

[10.3977]

name = "rand"
version = "0.8.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2e7573632e6454cf6b99d7aac4ccca54be06da05aca2ef7423d22d27d4d4bcd8"
dependencies = [
 "libc",
 "rand_chacha",
 "rand_core",
 "rand_hc",
]
[[package]]
name = "rand_chacha"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
dependencies = [
 "ppv-lite86",
 "rand_core",
]
[[package]]
name = "rand_core"
version = "0.6.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
dependencies = [
 "getrandom",
]
[[package]]
name = "rand_hc"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d51e9f596de227fda2ea6c84607f5558e196eeaf43c986b724ba4fb8fdf497e7"
dependencies = [
 "rand_core",
]
[[package]]

Insertion in Cargo.lock at line 839 [4.61]

[11.1314]

name = "remove_dir_all"
version = "0.5.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
dependencies = [
 "winapi",
]
[[package]]

Insertion in Cargo.lock at line 1015 [4.61]

[8.4562]

[7.1666]

name = "tempfile"
version = "3.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dac1c663cfc93810f88aed9b8941d48cabf856a1b111c29a40439018d870eb22"
dependencies = [
 "cfg-if",
 "libc",
 "rand",
 "redox_syscall",
 "remove_dir_all",
 "winapi",
]
[[package]]

Insertion in Cargo.toml at line 41 [4.240]

[8.7133]

[12.18]


[dev-dependencies]
tempfile = "3"
pretty_assertions = "1"

Insertion in src/entry.rs at line 30 [8.7188]

[13.243]

[5.3790]

        let command = start.command.trim_end();
        let command = command
            .strip_suffix("\\r\\n")
            .or_else(|| command.strip_suffix("\\n"))
            .unwrap_or(command)
            .to_string();
        let user = start.user.trim().to_string();
        let hostname = start.hostname.trim().to_string();

Replacement in src/entry.rs at line 42 [8.7188]

B:BD[5.3805] → [5.3805:3841]

            command: start.command,

[5.3805]

[5.3841]

            time_finished: finish.time_stamp,
            time_start: start.time_stamp,
            hostname,
            command,

Replacement in src/entry.rs at line 49 [8.7188]

B:BD[5.3946] → [5.3946:4064]

B:BD[5.4064] → [14.414:452]

            time_finished: finish.time_stamp,
            time_start: start.time_stamp,
            user: start.user,
            hostname: start.hostname,

[5.3946]

[5.4064]

            user,

File addition: lib.rs (----------)

[4.634]

pub mod client;
pub mod config;
pub mod entry;
pub mod message;
pub mod opt;
pub mod run;
pub mod server;
pub mod store;

Replacement in src/run/mod.rs at line 304 [16.1890]

B:BD[6.6011] → [15.0:49]

    server::builder(cache_dir, data_dir, socket)

[6.6011]

[6.6073]

    server::builder(cache_dir, data_dir, socket, true)

Insertion in src/server/builder.rs at line 36 [6.6130]
[6.6863]
[6.6863]
```
    pub(super) handle_ctrlc: bool,
```
Insertion in src/server/builder.rs at line 51 [6.6130]
[6.7443]
[6.7443]
```
        let handle_ctrlc = self.handle_ctrlc;
```
Insertion in src/server/builder.rs at line 61 [6.6130]
[6.7608]
[6.7608]
```
            handle_ctrlc,
```
Insertion in src/server/mod.rs at line 104 [6.7664]
[15.5197]
[15.5197]
```
    pub(super) handle_ctrlc: bool,
```

Replacement in src/server/mod.rs at line 107 [6.7664]

B:BD[15.5200] → [15.5200:5284]

pub fn builder(cache_dir: PathBuf, data_dir: PathBuf, socket: PathBuf) -> Builder {

[15.5200]

[15.5284]

pub fn builder(
    cache_dir: PathBuf,
    data_dir: PathBuf,
    socket: PathBuf,
    handle_ctrlc: bool,
) -> Builder {

Insertion in src/server/mod.rs at line 117 [6.7664]
[15.5351]
[15.5351]
```
        handle_ctrlc,
```

Replacement in src/server/mod.rs at line 138 [6.7664]

B:BD[15.5810] → [15.5810:5882]

        Self::ctrl_c_watcher(self.stopping, self.socket_path.clone())?;

[15.5810]

[15.5882]

        if self.handle_ctrlc {
            Self::ctrl_c_watcher(self.stopping, self.socket_path.clone())?;
        }

File addition: tests (d--x------)
[4.2]

File addition: client_server_intigration.rs (----------)

[0.4042]

use pretty_assertions::assert_eq;
use std::{
    path::PathBuf,
    sync::{
        Arc,
        Barrier,
    },
    thread,
};
use chrono::Utc;
use hstdb::{
    client::{
        self,
        Client,
    },
    entry::Entry,
    message::{
        CommandFinished,
        CommandStart,
        Message,
    },
    server,
    store::{
        self,
        Filter,
    },
};
use uuid::Uuid;
struct TestClient {
    client: Client,
    barrier_stop: Arc<Barrier>,
    cache_dir: PathBuf,
    data_dir: PathBuf,
    keep_datadir: bool,
}
impl Drop for TestClient {
    fn drop(&mut self) {
        self.barrier_stop.wait();
        std::fs::remove_dir_all(&self.cache_dir).unwrap();
        if !self.keep_datadir {
            std::fs::remove_dir_all(&self.data_dir).unwrap();
        }
    }
}
fn create_client_and_server(keep_datadir: bool) -> TestClient {
    let cache_dir = tempfile::tempdir().unwrap().into_path();
    let data_dir = tempfile::tempdir().unwrap().into_path();
    let socket = tempfile::NamedTempFile::new()
        .unwrap()
        .into_temp_path()
        .to_path_buf();
    let barrier_start = Arc::new(Barrier::new(2));
    let barrier_stop = Arc::new(Barrier::new(2));
    {
        let barrier_start = Arc::clone(&barrier_start);
        let barrier_stop = Arc::clone(&barrier_stop);
        let cache_dir = cache_dir.clone();
        let data_dir = data_dir.clone();
        let socket = socket.clone();
        let server = server::builder(cache_dir, data_dir, socket, false)
            .build()
            .unwrap();
        thread::spawn(move || {
            barrier_start.wait();
            server.run().unwrap();
            barrier_stop.wait();
        });
    }
    barrier_start.wait();
    let client = client::new(socket);
    TestClient {
        client,
        barrier_stop,
        cache_dir,
        data_dir,
        keep_datadir,
    }
}
#[test]
fn stop_server() {
    let client = create_client_and_server(false);
    client.client.send(&Message::Stop).unwrap();
}
#[test]
fn write_entry() {
    let client = create_client_and_server(true);
    let session_id = Uuid::new_v4();
    let start_data = CommandStart {
        command: "Test".to_string(),
        pwd: PathBuf::from("/tmp"),
        session_id: session_id.clone(),
        time_stamp: Utc::now(),
        user: "testuser".to_string(),
        hostname: "testhostname".to_string(),
    };
    let finish_data = CommandFinished {
        session_id,
        time_stamp: Utc::now(),
        result: 0,
    };
    client
        .client
        .send(&Message::CommandStart(start_data.clone()))
        .unwrap();
    client
        .client
        .send(&Message::CommandFinished(finish_data.clone()))
        .unwrap();
    client.client.send(&Message::Stop).unwrap();
    let data_dir = client.data_dir.clone();
    drop(client);
    let mut entries = store::new(data_dir.clone())
        .get_entries(&Filter::default())
        .unwrap();
    std::fs::remove_dir_all(data_dir).unwrap();
    dbg!(&entries);
    assert_eq!(entries.len(), 1);
    let got = entries.remove(0);
    let expected = Entry {
        time_finished: finish_data.time_stamp,
        time_start: start_data.time_stamp,
        hostname: start_data.hostname,
        command: start_data.command,
        pwd: start_data.pwd,
        result: finish_data.result,
        session_id: start_data.session_id,
        user: start_data.user,
    };
    assert_eq!(expected, got);
}
#[test]
fn write_entry_whitespace() {
    let client = create_client_and_server(true);
    let session_id = Uuid::new_v4();
    let start_data = CommandStart {
        command: r#"Test\nTest\nTest      "#.to_string(),
        pwd: PathBuf::from("/tmp"),
        session_id: session_id.clone(),
        time_stamp: Utc::now(),
        user: "testuser".to_string(),
        hostname: "testhostname".to_string(),
    };
    let finish_data = CommandFinished {
        session_id,
        time_stamp: Utc::now(),
        result: 0,
    };
    client
        .client
        .send(&Message::CommandStart(start_data.clone()))
        .unwrap();
    client
        .client
        .send(&Message::CommandFinished(finish_data.clone()))
        .unwrap();
    client.client.send(&Message::Stop).unwrap();
    let data_dir = client.data_dir.clone();
    drop(client);
    let mut entries = store::new(data_dir.clone())
        .get_entries(&Filter::default())
        .unwrap();
    std::fs::remove_dir_all(data_dir).unwrap();
    dbg!(&entries);
    assert_eq!(entries.len(), 1);
    let got = entries.remove(0);
    let expected = Entry {
        time_finished: finish_data.time_stamp,
        time_start: start_data.time_stamp,
        hostname: start_data.hostname,
        command: r#"Test\nTest\nTest"#.to_string(),
        pwd: start_data.pwd,
        result: finish_data.result,
        session_id: start_data.session_id,
        user: start_data.user,
    };
    assert_eq!(expected, got);
}
// TODO: Make a test for this probably needs a restructuring of how we
// detect leading spaces in commands
//#[test]
// fn write_command_starting_spaces() {
//    let client = create_client_and_server(true);
//
//    let session_id = Uuid::new_v4();
//
//    let start_data = CommandStart {
//        command: " Test".to_string(),
//        pwd: PathBuf::from("/tmp"),
//        session_id: session_id.clone(),
//        time_stamp: Utc::now(),
//        user: "testuser".to_string(),
//        hostname: "testhostname".to_string(),
//    };
//
//    let finish_data = CommandFinished {
//        session_id,
//        time_stamp: Utc::now(),
//        result: 0,
//    };
//
//    client
//        .client
//        .send(&Message::CommandStart(start_data.clone()))
//        .unwrap();
//
//    client
//        .client
//        .send(&Message::CommandFinished(finish_data.clone()))
//        .unwrap();
//
//    client.client.send(&Message::Stop).unwrap();
//
//    let data_dir = client.data_dir.clone();
//    drop(client);
//
//    let entries = store::new(data_dir.clone())
//        .get_entries(&Filter::default())
//        .unwrap();
//
//    std::fs::remove_dir_all(data_dir).unwrap();
//
//    dbg!(&entries);
//
//    assert_eq!(entries.len(), 0);
//}
#[test]
fn write_empty_command() {
    let client = create_client_and_server(true);
    let session_id = Uuid::new_v4();
    let start_data = CommandStart {
        command: "".to_string(),
        pwd: PathBuf::from("/tmp"),
        session_id: session_id.clone(),
        time_stamp: Utc::now(),
        user: "testuser".to_string(),
        hostname: "testhostname".to_string(),
    };
    let finish_data = CommandFinished {
        session_id,
        time_stamp: Utc::now(),
        result: 0,
    };
    client
        .client
        .send(&Message::CommandStart(start_data.clone()))
        .unwrap();
    client
        .client
        .send(&Message::CommandFinished(finish_data.clone()))
        .unwrap();
    client.client.send(&Message::Stop).unwrap();
    let data_dir = client.data_dir.clone();
    drop(client);
    let entries = store::new(data_dir.clone())
        .get_entries(&Filter::default())
        .unwrap();
    std::fs::remove_dir_all(data_dir).unwrap();
    dbg!(&entries);
    assert_eq!(entries.len(), 0);
}
#[test]
fn write_newline_command() {
    let client = create_client_and_server(true);
    let session_id = Uuid::new_v4();
    let commands = vec![
        "\n".to_string(),
        "\r\n".to_string(),
        "\n\n".to_string(),
        "\n\n\n".to_string(),
        r#"\n"#.to_string(),
        '\n'.to_string(),
        '\r'.to_string(),
    ];
    for command in commands {
        let start_data = CommandStart {
            command,
            pwd: PathBuf::from("/tmp"),
            session_id: session_id.clone(),
            time_stamp: Utc::now(),
            user: "testuser".to_string(),
            hostname: "testhostname".to_string(),
        };
        let finish_data = CommandFinished {
            session_id,
            time_stamp: Utc::now(),
            result: 0,
        };
        client
            .client
            .send(&Message::CommandStart(start_data.clone()))
            .unwrap();
        client
            .client
            .send(&Message::CommandFinished(finish_data.clone()))
            .unwrap();
    }
    client.client.send(&Message::Stop).unwrap();
    let data_dir = client.data_dir.clone();
    drop(client);
    let entries = store::new(data_dir.clone())
        .get_entries(&Filter::default())
        .unwrap();
    std::fs::remove_dir_all(data_dir).unwrap();
    dbg!(&entries);
    assert_eq!(entries.len(), 0);
}