Struct cargo::sources::registry::index::RegistryIndex

pub struct RegistryIndex<'cfg> {
    source_id: SourceId,
    path: Filesystem,
    summaries_cache: HashMap<InternedString, Summaries>,
    config: &'cfg Config,
}

Manager for handling the on-disk index.

Different kinds of registries store the index differently:

• LocalRegistry` is a simple on-disk tree of files of the raw index.
• RemoteRegistry is stored as a raw git repository.
• HttpRegistry fills the on-disk index cache directly without keeping any raw index.

These means of access are handled via the RegistryData trait abstraction. This transparently handles caching of the index in a more efficient format.

Fields

source_id: SourceId

path: Filesystem

Root directory of the index for the registry.

summaries_cache: HashMap<InternedString, Summaries>

In-memory cache of summary data.

This is keyed off the package name. The Summaries value handles loading the summary data. It keeps an optimized on-disk representation of the JSON files, which is created in an as-needed fashion. If it hasn’t been cached already, it uses RegistryData::load to access to JSON files from the index, and the creates the optimized on-disk summary cache.

config: &'cfg Config

Config reference for convenience.

Implementations

impl<'cfg> RegistryIndex<'cfg>

pub fn new( source_id: SourceId, path: &Filesystem, config: &'cfg Config ) -> RegistryIndex<'cfg>

Creates an empty registry index at path.

pub fn hash( &mut self, pkg: PackageId, load: &mut dyn RegistryData ) -> Poll<CargoResult<&str>>

Returns the hash listed for a specified PackageId. Primarily for checking the integrity of a downloaded package matching the checksum in the index file, aka IndexSummary.

fn summaries<'a, 'b>( &'a mut self, name: InternedString, req: &'b OptVersionReq, load: &mut dyn RegistryData ) -> Poll<CargoResult<impl Iterator<Item = &'a IndexSummary> + 'b>>where 'a: 'b,

Load a list of summaries for name package in this registry which match req.

This function will semantically

1. parse the index file (either raw or cache),
2. match all versions,
3. and then return an iterator over all summaries which matched.

Internally there’s quite a few layer of caching to amortize this cost though since this method is called quite a lot on null builds in Cargo.

fn load_summaries( &mut self, name: InternedString, load: &mut dyn RegistryData ) -> Poll<CargoResult<&mut Summaries>>

Actually parses what summaries we have available.

If Cargo has run previously, this tries in this order:

1. Returns from in-memory cache, aka RegistryIndex::summaries_cache.

2. If missing, hands over to Summaries::parse to parse an index file.

   The actual kind index file being parsed depends on which kind of RegistryData the load argument is given. For example, a Git-based RemoteRegistry will first try a on-disk index cache file, and then try parsing registry raw index from Git repository.

In effect, this is intended to be a quite cheap operation.

pub fn clear_summaries_cache(&mut self)

Clears the in-memory summaries cache.

pub fn query_inner( &mut self, name: InternedString, req: &OptVersionReq, load: &mut dyn RegistryData, yanked_whitelist: &HashSet<PackageId>, f: &mut dyn FnMut(Summary) ) -> Poll<CargoResult<()>>

Attempts to find the packages that match a name and a version req.

This is primarily used by Source::query.

fn query_inner_with_online( &mut self, name: InternedString, req: &OptVersionReq, load: &mut dyn RegistryData, yanked_whitelist: &HashSet<PackageId>, f: &mut dyn FnMut(IndexSummary), online: bool ) -> Poll<CargoResult<()>>

Inner implementation of Self::query_inner. Returns the number of summaries we’ve got.

The online controls whether Cargo can access the network when needed.

pub fn is_yanked( &mut self, pkg: PackageId, load: &mut dyn RegistryData ) -> Poll<CargoResult<bool>>

Looks into the summaries to check if a package has been yanked.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 88 bytes