liboxen 0.9.9-alpha

Oxen is a fast, unstructured data version control, to help version datasets, written in Rust.
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
122
123
124
125
126
127

//! Reader to find entries within a commit directory
//!

use crate::constants::{FILES_DIR, HISTORY_DIR};
use crate::core::db;
use crate::core::db::path_db;
use crate::error::OxenError;
use crate::model::{CommitEntry, LocalRepository};
use crate::util;

use rocksdb::{DBWithThreadMode, IteratorMode, MultiThreaded};
use std::collections::HashSet;
use std::path::{Path, PathBuf};
use std::str;

/// # CommitDirEntryReader
/// We keep a list of all the committed files in a subdirectory directory for fast lookup
pub struct CommitDirEntryReader {
    db: DBWithThreadMode<MultiThreaded>,
    dir: PathBuf,
}

impl CommitDirEntryReader {
    /// .oxen/history/commit_id/files/path/to/dir
    pub fn db_dir(base_path: &Path, commit_id: &str, dir: &Path) -> PathBuf {
        if dir == Path::new("") {
            return util::fs::oxen_hidden_dir(base_path)
                .join(HISTORY_DIR)
                .join(commit_id)
                .join(FILES_DIR);
        }

        util::fs::oxen_hidden_dir(base_path)
            .join(HISTORY_DIR)
            .join(commit_id)
            .join(FILES_DIR)
            .join(dir)
    }

    pub fn db_exists(base_path: &Path, commit_id: &str, dir: &Path) -> bool {
        // Must check the CURRENT file since the .oxen/history/COMMIT_ID/files/ path
        // may have already been created by a deeper object
        let db_path = CommitDirEntryReader::db_dir(base_path, commit_id, dir);
        db_path.join("CURRENT").exists()
    }

    /// # Create new commit dir
    /// Contains all the committed files within that dir, for faster filtering per dir
    pub fn new(
        repository: &LocalRepository,
        commit_id: &str,
        dir: &Path,
    ) -> Result<CommitDirEntryReader, OxenError> {
        CommitDirEntryReader::new_from_path(&repository.path, commit_id, dir)
    }

    pub fn new_from_path(
        base_path: &Path,
        commit_id: &str,
        dir: &Path,
    ) -> Result<CommitDirEntryReader, OxenError> {
        let db_path = CommitDirEntryReader::db_dir(base_path, commit_id, dir);
        log::debug!(
            "CommitDirEntryReader::new() dir {:?} db_path {:?}",
            dir,
            db_path
        );

        let opts = db::opts::default();
        if !CommitDirEntryReader::db_exists(base_path, commit_id, dir) {
            if let Err(err) = std::fs::create_dir_all(&db_path) {
                log::error!("CommitDirEntryReader could not create dir {db_path:?}\nErr: {err:?}");
            }
            // open it then lose scope to close it
            let _db: DBWithThreadMode<MultiThreaded> =
                DBWithThreadMode::open(&opts, dunce::simplified(&db_path))?;
        }

        Ok(CommitDirEntryReader {
            db: DBWithThreadMode::open_for_read_only(&opts, &db_path, true)?,
            dir: dir.to_owned(),
        })
    }

    pub fn num_entries(&self) -> usize {
        self.db.iterator(IteratorMode::Start).count()
    }

    pub fn has_file<P: AsRef<Path>>(&self, path: P) -> bool {
        let path = path.as_ref();
        path_db::has_entry(&self.db, path)
    }

    pub fn get_entry<P: AsRef<Path>>(&self, path: P) -> Result<Option<CommitEntry>, OxenError> {
        let path = path.as_ref();
        path_db::get_entry(&self.db, path)
    }

    pub fn list_files(&self) -> Result<Vec<PathBuf>, OxenError> {
        path_db::list_paths(&self.db, &self.dir)
    }

    pub fn list_entries(&self) -> Result<Vec<CommitEntry>, OxenError> {
        path_db::list_entries(&self.db)
    }

    pub fn list_entries_set(&self) -> Result<HashSet<CommitEntry>, OxenError> {
        path_db::list_entries_set(&self.db)
    }

    pub fn list_entry_page(
        &self,
        page: usize,
        page_size: usize,
    ) -> Result<Vec<CommitEntry>, OxenError> {
        path_db::list_entry_page(&self.db, page, page_size)
    }

    pub fn list_entry_page_with_offset(
        &self,
        page: usize,
        page_size: usize,
        offset: usize,
    ) -> Result<Vec<CommitEntry>, OxenError> {
        path_db::list_entry_page_with_offset(&self.db, page, page_size, offset)
    }
}