Struct SnixStoreIO 

pub struct SnixStoreIO {
    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 “Snix 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 SnixStoreIO

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, hashed_mirrors: Vec<Url>, ) -> Self

async fn store_path_to_path_info<S>( &self, store_path: &StorePath<S>, sub_path: &Path, ) -> Result<Option<PathInfo>>

where S: AsRef<str>,

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

In case there is no PathInfo yet, we check “self.known_paths” (learnt by the evaluator)

• If there’s a fetch, we do that and return the resulting PathInfo.
• If there’s a Derivation, we build it and return the resulting PathInfo. To build it, we need to do a function call to ourselves with all inputs of that Derivation, which will trigger fetches / builds of inputs, recursively.

This should be replaced with a proper scheduler knowing about a partial subgraph at some point, because this design doesn’t allow concurrent builds yet.

Trait Implementations

impl EvalIO for SnixStoreIO

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 Snix 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.

fn get_env(&self, key: &OsStr) -> Option<OsString>

Fetches the environment variable key from the current process.