maurice/snix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

refactor(tvix/eval/io): use io::Error instead of tvix_eval errors

Browse source 
We didn't return anything useful other than ErrorKind::IO anyways.

We can use io::ErrorKind::Unsupported for DummyIO.

Fixes b/271.

Change-Id: Icb231e9b38168e8b6fa473bfa405d160357b317f
Reviewed-on: https://cl.tvl.fyi/c/depot/+/8602
Autosubmit: flokli <flokli@flokli.de>
Tested-by: BuildkiteCI
Reviewed-by: tazjin <tazjin@tvl.su>
This commit is contained in:
Florian Klink 2023-05-21 11:00:49 +03:00 • committed by clbot
parent 03958a5446
commit b7ab6c0856
4 changed files with 70 additions and 63 deletions
Download patch file Download diff file Expand all files Collapse all files

72
tvix/eval/src/io.rs
View file

@ -15,12 +15,11 @@
//! 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;
use std::{
io,
path::{Path, PathBuf},
};
/// Types of files as represented by `builtins.readDir` in Nix.
#[derive(Debug)]
@ -34,14 +33,14 @@ pub enum FileType {
/// Defines how filesystem interaction occurs inside of tvix-eval.
pub trait EvalIO {
/// Verify whether the file at the specified path exists.
fn path_exists(&mut self, path: PathBuf) -> Result<bool, ErrorKind>;
fn path_exists(&mut self, path: PathBuf) -> Result<bool, io::Error>;
/// Read the file at the specified path to a string.
fn read_to_string(&mut self, path: PathBuf) -> Result<String, ErrorKind>;
fn read_to_string(&mut self, path: PathBuf) -> Result<String, io::Error>;
/// Read the directory at the specified path and return the names
/// of its entries associated with their [`FileType`].
fn read_dir(&mut self, path: PathBuf) -> Result<Vec<(SmolStr, FileType)>, ErrorKind>;
fn read_dir(&mut self, path: PathBuf) -> Result<Vec<(SmolStr, FileType)>, io::Error>;
/// Import the given path. What this means depends on the
/// implementation, for example for a `std::io`-based
@ -50,7 +49,7 @@ pub trait EvalIO {
///
/// This is primarily used in the context of things like coercing
/// a local path to a string, or builtins like `path`.
fn import_path(&mut self, path: &Path) -> Result<PathBuf, ErrorKind>;
fn import_path(&mut self, path: &Path) -> Result<PathBuf, io::Error>;
/// Returns the root of the store directory, if such a thing
/// exists in the evaluation context.
@ -66,37 +65,20 @@ pub struct StdIO;
#[cfg(feature = "impure")]
impl EvalIO for StdIO {
fn path_exists(&mut self, path: PathBuf) -> Result<bool, ErrorKind> {
path.try_exists().map_err(|e| ErrorKind::IO {
path: Some(path),
error: Rc::new(e),
})
fn path_exists(&mut self, path: PathBuf) -> Result<bool, io::Error> {
path.try_exists()
}
fn read_to_string(&mut 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_to_string(&mut self, path: PathBuf) -> Result<String, io::Error> {
std::fs::read_to_string(&path)
}
fn read_dir(&mut self, path: PathBuf) -> Result<Vec<(SmolStr, FileType)>, ErrorKind> {
fn read_dir(&mut self, path: PathBuf) -> Result<Vec<(SmolStr, FileType)>, io::Error> {
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();
for entry in path.read_dir()? {
let entry = entry?;
let file_type = entry.metadata()?.file_type();
let val = if file_type.is_dir() {
FileType::Directory
@ -116,7 +98,7 @@ impl EvalIO for StdIO {
// this is a no-op for `std::io`, as the user can already refer to
// the path directly
fn import_path(&mut self, path: &Path) -> Result<PathBuf, ErrorKind> {
fn import_path(&mut self, path: &Path) -> Result<PathBuf, io::Error> {
Ok(path.to_path_buf())
}
}
@ -126,26 +108,30 @@ impl EvalIO for StdIO {
pub struct DummyIO;
impl EvalIO for DummyIO {
fn path_exists(&mut self, _: PathBuf) -> Result<bool, ErrorKind> {
Err(ErrorKind::NotImplemented(
fn path_exists(&mut self, _: PathBuf) -> Result<bool, io::Error> {
Err(io::Error::new(
io::ErrorKind::Unsupported,
"I/O methods are not implemented in DummyIO",
))
}
fn read_to_string(&mut self, _: PathBuf) -> Result<String, ErrorKind> {
Err(ErrorKind::NotImplemented(
fn read_to_string(&mut self, _: PathBuf) -> Result<String, io::Error> {
Err(io::Error::new(
io::ErrorKind::Unsupported,
"I/O methods are not implemented in DummyIO",
))
}
fn read_dir(&mut self, _: PathBuf) -> Result<Vec<(SmolStr, FileType)>, ErrorKind> {
Err(ErrorKind::NotImplemented(
fn read_dir(&mut self, _: PathBuf) -> Result<Vec<(SmolStr, FileType)>, io::Error> {
Err(io::Error::new(
io::ErrorKind::Unsupported,
"I/O methods are not implemented in DummyIO",
))
}
fn import_path(&mut self, _: &Path) -> Result<PathBuf, ErrorKind> {
Err(ErrorKind::NotImplemented(
fn import_path(&mut self, _: &Path) -> Result<PathBuf, io::Error> {
Err(io::Error::new(
io::ErrorKind::Unsupported,
"I/O methods are not implemented in DummyIO",
))
}

35
tvix/eval/src/vm/generators.rs
View file

@ -406,15 +406,27 @@ impl<'o> VM<'o> {
}
VMRequest::PathImport(path) => {
let imported =
self.io_handle.import_path(&path).with_span(&span, self)?;
let imported = self
.io_handle
.import_path(&path)
.map_err(|e| ErrorKind::IO {
path: Some(path),
error: e.into(),
})
.with_span(&span, self)?;
message = VMResponse::Path(imported);
}
VMRequest::ReadToString(path) => {
let content =
self.io_handle.read_to_string(path).with_span(&span, self)?;
let content = self
.io_handle
.read_to_string(path.clone())
.map_err(|e| ErrorKind::IO {
path: Some(path),
error: e.into(),
})
.with_span(&span, self)?;
message = VMResponse::Value(Value::String(content.into()))
}
@ -422,7 +434,11 @@ impl<'o> VM<'o> {
VMRequest::PathExists(path) => {
let exists = self
.io_handle
.path_exists(path)
.path_exists(path.clone())
.map_err(|e| ErrorKind::IO {
path: Some(path),
error: e.into(),
})
.map(Value::Bool)
.with_span(&span, self)?;
@ -430,7 +446,14 @@ impl<'o> VM<'o> {
}
VMRequest::ReadDir(path) => {
let dir = self.io_handle.read_dir(path).with_span(&span, self)?;
let dir = self
.io_handle
.read_dir(path.clone())
.map_err(|e| ErrorKind::IO {
path: Some(path),
error: e.into(),
})
.with_span(&span, self)?;
message = VMResponse::Directory(dir);
}