Struct tvix_glue::tvix_store_io::TvixStoreIO

pub struct TvixStoreIO {
    pub(crate) blob_service: Arc<dyn BlobService>,
    pub(crate) directory_service: Arc<dyn DirectoryService>,
    pub(crate) path_info_service: Arc<dyn PathInfoService>,
    pub(crate) nar_calculation_service: Arc<dyn NarCalculationService>,
    std_io: StdIO,
    build_service: Arc<dyn BuildService>,
    pub(crate) tokio_handle: Handle,
    pub(crate) fetcher: Fetcher<Arc<dyn BlobService>, Arc<dyn DirectoryService>, Arc<dyn PathInfoService>, Arc<dyn NarCalculationService>>,
    pub known_paths: RefCell<KnownPaths>,
}

Implements EvalIO, asking given PathInfoService, DirectoryService and BlobService.

In case the given path does not exist in these stores, we ask StdIO. This is to both cover cases of syntactically valid store paths, that exist on the filesystem (still managed by Nix), as well as being able to read files outside store paths.

This structure is also directly used by the derivation builtins and tightly coupled to it.

In the future, we may revisit that coupling and figure out how to generalize this interface and hide this implementation detail of the glue itself so that glue can be used with more than one implementation of “Tvix Store IO” which does not necessarily bring the concept of blob service, directory service or path info service.

Fields

blob_service: Arc<dyn BlobService>

directory_service: Arc<dyn DirectoryService>

path_info_service: Arc<dyn PathInfoService>

nar_calculation_service: Arc<dyn NarCalculationService>

std_io: StdIO

build_service: Arc<dyn BuildService>

tokio_handle: Handle

fetcher: Fetcher<Arc<dyn BlobService>, Arc<dyn DirectoryService>, Arc<dyn PathInfoService>, Arc<dyn NarCalculationService>>

known_paths: RefCell<KnownPaths>

Implementations

impl TvixStoreIO

pub fn new( blob_service: Arc<dyn BlobService>, directory_service: Arc<dyn DirectoryService>, path_info_service: Arc<dyn PathInfoService>, nar_calculation_service: Arc<dyn NarCalculationService>, build_service: Arc<dyn BuildService>, tokio_handle: Handle ) -> Self

async fn store_path_to_node( &self, store_path: &StorePath<String>, sub_path: &Path ) -> Result<Option<Node>>

for a given StorePath and additional Path inside the store path, look up the PathInfo, and if it exists, and then use directoryservice::descend_to to return the Node specified by sub_path.

In case there is no PathInfo yet, this means we need to build it (which currently is stubbed out still).

pub(crate) async fn node_to_path_info<'a>( &self, name: &'a str, path: &Path, ca: &CAHash, root_node: Node ) -> Result<(PathInfo, NixHash, StorePathRef<'a>)>

pub(crate) async fn register_node_in_path_info_service<'a>( &self, name: &'a str, path: &Path, ca: &CAHash, root_node: Node ) -> Result<StorePathRef<'a>>

pub async fn store_path_exists<'a>( &'a self, store_path: StorePathRef<'a> ) -> Result<bool>

Trait Implementations

impl EvalIO for TvixStoreIO

fn path_exists(&self, path: &Path) -> Result<bool>

Verify whether the file at the specified path exists.

fn open(&self, path: &Path) -> Result<Box<dyn Read>>

Open the file at the specified path to a io::Read.

fn file_type(&self, path: &Path) -> Result<FileType>

Return the FileType of the given path, or an error if it doesn’t exist.

fn read_dir(&self, path: &Path) -> Result<Vec<(Bytes, FileType)>>

Read the directory at the specified path and return the names of its entries associated with their FileType.

fn import_path(&self, path: &Path) -> Result<PathBuf>

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.

fn store_dir(&self) -> Option<String>

Returns the root of the store directory, if such a thing exists in the evaluation context.