Struct debian_packaging::repository::filesystem::FilesystemReleaseClient

pub struct FilesystemReleaseClient { /* private fields */ }

Trait Implementations

impl DataResolver for FilesystemReleaseClient

fn get_path<'life0, 'life1, 'async_trait>(
    &'life0 self,
    path: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn AsyncRead + Send>>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Get the content of a relative path as an async reader.

fn get_path_with_digest_verification<'life0, 'life1, 'async_trait>(
    &'life0 self,
    path: &'life1 str,
    expected_size: u64,
    expected_digest: ContentDigest
) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn AsyncRead + Send>>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Obtain a reader that performs content integrity checking.

fn get_path_decoded<'life0, 'life1, 'async_trait>(
    &'life0 self,
    path: &'life1 str,
    compression: Compression
) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn AsyncRead + Send>>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Get the content of a relative path with decompression transparently applied.

fn get_path_decoded_with_digest_verification<'life0, 'life1, 'async_trait>(
    &'life0 self,
    path: &'life1 str,
    compression: Compression,
    expected_size: u64,
    expected_digest: ContentDigest
) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn AsyncRead + Send>>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Like Self::get_path_decoded() but also perform content integrity verification.

impl ReleaseReader for FilesystemReleaseClient

fn url(&self) -> Result<Url>

Obtain the base URL to which this instance is bound.

fn root_relative_path(&self) -> &str

Obtain the path relative to the repository root this instance is bound to.

fn release_file(&self) -> &ReleaseFile<'static>

Obtain the parsed [In]Release file from which this reader is derived.

fn preferred_compression(&self) -> Compression

Obtain the preferred compression format to retrieve index files in.

fn set_preferred_compression(&mut self, compression: Compression)

Set the preferred compression format for retrieved index files.

fn retrieve_checksum(&self) -> Result<ChecksumType>

Obtain the checksum flavor of content to retrieve.

fn classified_indices_entries(
    &self
) -> Result<Vec<ClassifiedReleaseFileEntry<'_>>>

Obtain ClassifiedReleaseFileEntry within the parsed Release file.

fn packages_indices_entries(&self) -> Result<Vec<PackagesFileEntry<'_>>>

Obtain parsed Packages file entries within this Release file.

fn packages_indices_entries_preferred_compression(
    &self
) -> Result<Vec<PackagesFileEntry<'_>>>

Like Self::packages_indices_entries() except it deduplicates entries.

fn contents_indices_entries(&self) -> Result<Vec<ContentsFileEntry<'_>>>

Resolve indices for Contents files.

fn sources_indices_entries(&self) -> Result<Vec<SourcesFileEntry<'_>>>

Resolve indices for Sources file.

fn sources_indices_entries_preferred_compression(
    &self
) -> Result<Vec<SourcesFileEntry<'_>>>

Like Self::sources_indices_entries except it deduplicates entries.

fn packages_entry(
    &self,
    component: &str,
    architecture: &str,
    is_installer: bool
) -> Result<PackagesFileEntry<'_>>

Resolve a reference to a Packages file to fetch given search criteria.

fn resolve_packages_from_entry<'entry, 'slf: 'entry, 'async_trait>(
    &'slf self,
    entry: &'entry PackagesFileEntry<'slf>
) -> Pin<Box<dyn Future<Output = Result<BinaryPackageList<'static>>> + Send + 'async_trait>> where
    'entry: 'async_trait,
    'slf: 'async_trait,
    Self: 'async_trait, 

Fetch and parse a Packages file described by a PackagesFileEntry.

fn resolve_packages<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    component: &'life1 str,
    arch: &'life2 str,
    is_installer: bool
) -> Pin<Box<dyn Future<Output = Result<BinaryPackageList<'static>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

Resolve packages given parameters to resolve a Packages file.

fn resolve_package_fetches<'life0, 'async_trait>(
    &'life0 self,
    packages_file_filter: Box<dyn Fn(PackagesFileEntry<'_>) -> bool + Send>,
    binary_package_filter: Box<dyn Fn(BinaryPackageControlFile<'_>) -> bool + Send>,
    threads: usize
) -> Pin<Box<dyn Future<Output = Result<Vec<BinaryPackageFetch<'_>>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Retrieve fetch instructions for binary packages.

fn sources_entry(&self, component: &str) -> Result<SourcesFileEntry<'_>>

Resolve the SourcesFileEntry for a given component.

fn resolve_sources_from_entry<'entry, 'slf: 'entry, 'async_trait>(
    &'slf self,
    entry: &'entry SourcesFileEntry<'slf>
) -> Pin<Box<dyn Future<Output = Result<DebianSourcePackageList<'static>>> + Send + 'async_trait>> where
    'entry: 'async_trait,
    'slf: 'async_trait,
    Self: 'async_trait, 

Fetch a Sources file and parse source package entries inside.

fn resolve_sources<'life0, 'life1, 'async_trait>(
    &'life0 self,
    component: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<DebianSourcePackageList<'static>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Fetch a Sources file for the given component and parse source package entries inside.

fn resolve_source_fetches<'life0, 'async_trait>(
    &'life0 self,
    sources_file_filter: Box<dyn Fn(SourcesFileEntry<'_>) -> bool + Send>,
    source_package_filter: Box<dyn Fn(DebianSourceControlFile<'_>) -> bool + Send>,
    threads: usize
) -> Pin<Box<dyn Future<Output = Result<Vec<SourcePackageFetch<'_>>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Resolves SourcePackageFetch for describing files to fetch for source packages.

fn contents_entry(
    &self,
    component: &str,
    architecture: &str,
    is_installer: bool
) -> Result<ContentsFileEntry<'_>>

Resolve a reference to a Contents file to fetch given search criteria.

fn resolve_contents<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    component: &'life1 str,
    architecture: &'life2 str,
    is_installer: bool
) -> Pin<Box<dyn Future<Output = Result<ContentsFile>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait,