sqlarfs 0.1.1

A file archive format and virtual filesystem backed by a SQLite database
Documentation 
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

#![allow(dead_code)]

mod matchers;

use std::io;
use std::path::Path;
use std::sync::mpsc;
use std::thread;
use std::time::{Duration, SystemTime, UNIX_EPOCH};

use rand::prelude::*;
use sqlarfs::Connection;

#[allow(unused_imports)]
pub use matchers::*;

pub const WRITE_DATA_SIZE: usize = 64;

pub fn connection() -> sqlarfs::Result<Connection> {
    Connection::open_in_memory()
}

// This is for rounding a file mtime down to the nearest whole second, because that's what this
// implementation of SQLite archives does.
pub fn truncate_mtime(time: SystemTime) -> SystemTime {
    let unix_time_secs = time.duration_since(UNIX_EPOCH).unwrap().as_secs();
    UNIX_EPOCH + Duration::from_secs(unix_time_secs)
}

pub fn random_bytes(len: usize) -> Vec<u8> {
    let mut buf = Vec::with_capacity(len);
    let mut rng = SmallRng::from_entropy();
    rng.fill_bytes(&mut buf);
    buf
}

// A buffer of bytes that can be compressed to a smaller size.
pub fn compressible_bytes() -> Vec<u8> {
    vec![0u8; 64]
}

// A buffer of bytes that cannot be compressed to a smaller size.
pub fn incompressible_bytes() -> Vec<u8> {
    // Make it deterministic to ensure tests don't flake, just in case zlib *can* manage to
    // compress these random non-repeating bytes.
    let mut rng = SmallRng::seed_from_u64(0);

    // No repeating bytes.
    let pool = (0..255).collect::<Vec<u8>>();

    pool.choose_multiple(&mut rng, 64).copied().collect()
}

// Run the given function in a separate thread with a timeout. This is for tests where the failure
// case could result in them hanging.
pub fn with_timeout<F>(timeout: Duration, f: F) -> sqlarfs::Result<()>
where
    F: FnOnce() -> sqlarfs::Result<()> + Send + 'static,
{
    let (tx, rx) = mpsc::channel();

    let handle = thread::spawn(move || {
        let result = f();
        tx.send(()).unwrap();
        result
    });

    rx.recv_timeout(timeout)
        .unwrap_or_else(|_| panic!("test timed out after {} seconds", timeout.as_secs()));

    handle.join().unwrap()
}

// TODO: Use `eyre::Result` instead of `sqlarfs::Result` for all tests, making this unnecessary.
pub fn into_sqlarfs_error<E>(_: E) -> sqlarfs::Error
where
    E: std::error::Error + Send + Sync + 'static,
{
    sqlarfs::Error::Io {
        kind: io::ErrorKind::Other,
        code: None,
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SqlarTableRow {
    pub name: String,
    pub mode: Option<u32>,
    pub mtime: Option<u64>,
    pub sz: Option<i64>,
    pub data: Option<Vec<u8>>,
}

pub fn dump_table(db: &Path) -> sqlarfs::Result<Vec<SqlarTableRow>> {
    rusqlite::Connection::open_with_flags(
        db,
        rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY | rusqlite::OpenFlags::SQLITE_OPEN_NO_MUTEX,
    )
    .map_err(sqlarfs::Error::from)?
    .prepare("SELECT name, mode, mtime, sz, data FROM sqlar;")?
    .query_map([], |row| {
        let name = row.get(0)?;
        let mode = row.get(1)?;
        let mtime = row.get(2)?;
        let sz = row.get(3)?;

        Ok(SqlarTableRow {
            name,
            mode,
            mtime,
            sz,
            data: if sz == Some(-1) {
                row.get::<_, String>(4)?.as_bytes().to_vec().into()
            } else {
                row.get(4)?
            },
        })
    })?
    .collect::<Result<Vec<_>, _>>()
    .map_err(sqlarfs::Error::from)
}