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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
|
//! Interface for injecting I/O-related functionality into tvix-eval.
//!
//! The Nix language contains several builtins (e.g. `builtins.readDir`), as
//! well as language feature (e.g. string-"coercion" of paths) that interact
//! with the filesystem.
//!
//! The language evaluator implemented by this crate does not depend on any
//! particular filesystem interaction model. Instead, this module provides a
//! trait that can be implemented by tvix-eval callers to provide the
//! functionality they desire.
//!
//! In theory this can be used to implement "mocked" filesystem interactions, or
//! interaction with remote filesystems, etc.
//!
//! In the context of Nix builds, callers also use this interface to determine
//! how store paths are opened and so on.
use crate::errors::ErrorKind;
use smol_str::SmolStr;
use std::path::{Path, PathBuf};
#[cfg(feature = "impure")]
use std::rc::Rc;
/// Types of files as represented by `builtins.readDir` in Nix.
#[derive(Debug)]
pub enum FileType {
Directory,
Regular,
Symlink,
Unknown,
}
/// Defines how filesystem interaction occurs inside of tvix-eval.
pub trait EvalIO {
/// Verify whether the file at the specified path exists.
fn path_exists(&self, path: PathBuf) -> Result<bool, ErrorKind>;
/// Read the file at the specified path to a string.
fn read_to_string(&self, path: PathBuf) -> Result<String, ErrorKind>;
/// Read the directory at the specified path and return the names
/// of its entries associated with their [`FileType`].
fn read_dir(&self, path: PathBuf) -> Result<Vec<(SmolStr, FileType)>, ErrorKind>;
/// Import the given path. What this means depends on the
/// implementation, for example for a `std::io`-based
/// implementation this might be a no-op, while for a Tvix store
/// this might be a copy of the given files to the store.
///
/// This is primarily used in the context of things like coercing
/// a local path to a string, or builtins like `path`.
fn import_path(&self, path: &Path) -> Result<PathBuf, ErrorKind>;
/// Returns the root of the store directory, if such a thing
/// exists in the evaluation context.
fn store_dir(&self) -> Option<String> {
None
}
}
/// Implementation of [`EvalIO`] that simply uses the equivalent
/// standard library functions, i.e. does local file-IO.
#[cfg(feature = "impure")]
pub struct StdIO;
#[cfg(feature = "impure")]
impl EvalIO for StdIO {
fn path_exists(&self, path: PathBuf) -> Result<bool, ErrorKind> {
path.try_exists().map_err(|e| ErrorKind::IO {
path: Some(path),
error: Rc::new(e),
})
}
fn read_to_string(&self, path: PathBuf) -> Result<String, ErrorKind> {
std::fs::read_to_string(&path).map_err(|e| ErrorKind::IO {
path: Some(path),
error: Rc::new(e),
})
}
fn read_dir(&self, path: PathBuf) -> Result<Vec<(SmolStr, FileType)>, ErrorKind> {
let mut result = vec![];
let mk_err = |err| ErrorKind::IO {
path: Some(path.clone()),
error: Rc::new(err),
};
for entry in path.read_dir().map_err(mk_err)? {
let entry = entry.map_err(mk_err)?;
let file_type = entry
.metadata()
.map_err(|err| ErrorKind::IO {
path: Some(entry.path()),
error: Rc::new(err),
})?
.file_type();
let val = if file_type.is_dir() {
FileType::Directory
} else if file_type.is_file() {
FileType::Regular
} else if file_type.is_symlink() {
FileType::Symlink
} else {
FileType::Unknown
};
result.push((SmolStr::new(entry.file_name().to_string_lossy()), val));
}
Ok(result)
}
// this is a no-op for `std::io`, as the user can already refer to
// the path directly
fn import_path(&self, path: &Path) -> Result<PathBuf, ErrorKind> {
Ok(path.to_path_buf())
}
}
/// Dummy implementation of [`EvalIO`], can be used in contexts where
/// IO is not available but code should "pretend" that it is.
pub struct DummyIO;
impl EvalIO for DummyIO {
fn path_exists(&self, _: PathBuf) -> Result<bool, ErrorKind> {
Err(ErrorKind::NotImplemented(
"I/O methods are not implemented in DummyIO",
))
}
fn read_to_string(&self, _: PathBuf) -> Result<String, ErrorKind> {
Err(ErrorKind::NotImplemented(
"I/O methods are not implemented in DummyIO",
))
}
fn read_dir(&self, _: PathBuf) -> Result<Vec<(SmolStr, FileType)>, ErrorKind> {
Err(ErrorKind::NotImplemented(
"I/O methods are not implemented in DummyIO",
))
}
fn import_path(&self, _: &Path) -> Result<PathBuf, ErrorKind> {
Err(ErrorKind::NotImplemented(
"I/O methods are not implemented in DummyIO",
))
}
}
|
