Struct RegistryIndex 

pub struct RegistryIndex<'gctx> {
    source_id: SourceId,
    path: Filesystem,
    summaries_cache: RefCell<HashMap<InternedString, Rc<Summaries>>>,
    summaries_inflight: RefCell<HashMap<InternedString, Vec<Sender<Rc<Summaries>>>>>,
    gctx: &'gctx GlobalContext,
    cache_manager: CacheManager<'gctx>,
}

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: RefCell<HashMap<InternedString, Rc<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.

summaries_inflight: RefCell<HashMap<InternedString, Vec<Sender<Rc<Summaries>>>>>

Requests that are currently running.

gctx: &'gctx GlobalContext

GlobalContext reference for convenience.

cache_manager: CacheManager<'gctx>

Manager of on-disk caches.

Implementations

impl<'gctx> RegistryIndex<'gctx>

pub fn new( source_id: SourceId, path: &Filesystem, gctx: &'gctx GlobalContext, ) -> RegistryIndex<'gctx>

Creates an empty registry index at path.

pub async fn hash( &self, pkg: PackageId, load: &dyn RegistryData, ) -> CargoResult<String>

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.

async fn summaries<'a, 'b>( &'a self, name: InternedString, req: &'b OptVersionReq, load: &dyn RegistryData, ) -> CargoResult<impl Iterator<Item = 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.

async fn load_summaries( &self, name: InternedString, load: &dyn RegistryData, ) -> CargoResult<Rc<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.

async fn load_summaries_uncached( &self, name: InternedString, load: &dyn RegistryData, ) -> CargoResult<Rc<Summaries>>

pub fn clear_summaries_cache(&self)

Clears the in-memory summaries cache.

pub async fn query_inner( &self, name: InternedString, req: &OptVersionReq, load: &dyn RegistryData, f: &mut dyn FnMut(IndexSummary), ) -> CargoResult<()>

async fn query_inner_with_online( &self, name: InternedString, req: &OptVersionReq, load: &dyn RegistryData, f: &mut dyn FnMut(IndexSummary), online: bool, ) -> 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 async fn is_yanked( &self, pkg: PackageId, load: &dyn RegistryData, ) -> 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: 200 bytes