feat(tvix/eval): introduce initial EvalIO trait

This trait is going to be used to abstract filesystem interactions in
Tvix.

For now, it only contains a `read_to_string` method that closely
mirrors `std::fs::read_to_string`.

As a first step, to see how this works in practice, we will thread
through only this function to the various relevant parts.

Two implementations are provided in tvix-eval itself: A dummy
implementation (which just returns ErrorKind::NotImplemented for all
operations), and a std implementation which delegates to `std`
functions.

Change-Id: Ied3e3bf4bd0e874dd84e166190e3873a0f923ddb
Reviewed-on: https://cl.tvl.fyi/c/depot/+/7565
Reviewed-by: grfn <grfn@gws.fyi>
Tested-by: BuildkiteCI
This commit is contained in:
Vincent Ambo 2022-12-12 17:19:27 +03:00 committed by tazjin
parent bf286a54bc
commit 25fc6b7c25
2 changed files with 53 additions and 0 deletions

52
tvix/eval/src/io.rs Normal file
View file

@ -0,0 +1,52 @@
//! 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 std::path::PathBuf;
use crate::errors::ErrorKind;
/// Defines how filesystem interaction occurs inside of tvix-eval.
pub trait EvalIO {
/// Read the file at the specified path to a string.
fn read_to_string(&self, path: PathBuf) -> Result<String, ErrorKind>;
}
/// Implementation of [`EvalIO`] that simply uses the equivalent
/// standard library functions, i.e. does local file-IO.
struct StdIO;
impl EvalIO for StdIO {
fn read_to_string(&self, path: PathBuf) -> Result<String, ErrorKind> {
let path: PathBuf = path.into();
std::fs::read_to_string(&path).map_err(|e| ErrorKind::IO {
path: Some(path),
error: std::rc::Rc::new(e),
})
}
}
/// Dummy implementation of [`EvalIO`], can be used in contexts where
/// IO is not available but code should "pretend" that it is.
struct DummyIO;
impl EvalIO for DummyIO {
fn read_to_string(&self, _: PathBuf) -> Result<String, ErrorKind> {
Err(ErrorKind::NotImplemented(
"I/O methods are not implemented in DummyIO",
))
}
}

View file

@ -16,6 +16,7 @@ mod builtins;
mod chunk;
mod compiler;
mod errors;
mod io;
pub mod observer;
mod opcode;
mod pretty_ast;