Struct ImageImporter 

pub struct ImageImporter {
    repo: Repo,
    pub(crate) proxy: ImageProxy,
    imgref: OstreeImageReference,
    target_imgref: Option<OstreeImageReference>,
    no_imgref: bool,
    disable_gc: bool,
    require_bootable: bool,
    offline: bool,
    ostree_v2024_3: bool,
    layer_progress: Option<Sender<ImportProgress>>,
    layer_byte_progress: Option<Sender<Option<LayerProgress>>>,
}

Context for importing a container image.

Fields

repo: Repo

proxy: ImageProxy

imgref: OstreeImageReference

target_imgref: Option<OstreeImageReference>

no_imgref: bool

disable_gc: bool

require_bootable: bool

If true, require the image has the bootable flag

offline: bool

Do not attempt to contact the network

ostree_v2024_3: bool

If true, we have ostree v2024.3 or newer.

layer_progress: Option<Sender<ImportProgress>>

layer_byte_progress: Option<Sender<Option<LayerProgress>>>

Implementations

impl ImageImporter

const CACHED_KEY_MANIFEST_DIGEST: &'static str = "ostree-ext.cached.manifest-digest"

The metadata key used in ostree commit metadata to serialize

const CACHED_KEY_MANIFEST: &'static str = "ostree-ext.cached.manifest"

const CACHED_KEY_CONFIG: &'static str = "ostree-ext.cached.config"

pub async fn new( repo: &Repo, imgref: &OstreeImageReference, config: ImageProxyConfig, ) -> Result<Self>

Create a new importer.

pub fn set_target(&mut self, target: &OstreeImageReference)

Write cached data as if the image came from this source.

pub fn set_no_imgref(&mut self)

Do not write the final image ref, but do write refs for shared layers. This is useful in scenarios where you want to “pre-pull” an image, but in such a way that it does not need to be manually removed later.

pub fn set_offline(&mut self)

Do not attempt to contact the network

pub fn require_bootable(&mut self)

Require that the image has the bootable metadata field

pub fn set_ostree_version(&mut self, year: u32, v: u32)

Override the ostree version being targeted

pub fn disable_gc(&mut self)

Do not prune image layers.

pub async fn prepare(&mut self) -> Result<PrepareResult>

Determine if there is a new manifest, and if so return its digest. This will also serialize the new manifest and configuration into metadata associated with the image, so that invocations of [query_cached] can re-fetch it without accessing the network.

pub fn request_progress(&mut self) -> Receiver<ImportProgress>

Create a channel receiver that will get notifications for layer fetches.

pub fn request_layer_progress(&mut self) -> Receiver<Option<LayerProgress>>

Create a channel receiver that will get notifications for byte-level progress of layer fetches.

pub(crate) async fn cache_pending( &self, commit: &str, manifest_digest: &Digest, manifest: &ImageManifest, config: &ImageConfiguration, ) -> Result<()>

Serialize the metadata about a pending fetch as detached metadata on the commit object, so it can be retrieved later offline

fn create_prepared_import( &mut self, manifest_digest: Digest, manifest: ImageManifest, config: ImageConfiguration, previous_state: Option<Box<LayeredImageState>>, previous_imageid: Option<String>, proxy_img: OpenedImage, ) -> Result<Box<PreparedImport>>

Given existing metadata (manifest, config, previous image statE) generate a PreparedImport structure which e.g. includes a diff of the layers.

pub(crate) async fn prepare_internal( &mut self, verify_layers: bool, ) -> Result<PrepareResult>

Determine if there is a new manifest, and if so return its digest.

pub(crate) async fn unencapsulate_base( &self, import: &mut PreparedImport, require_ostree: bool, write_refs: bool, ) -> Result<()>

Extract the base ostree commit.

pub async fn unencapsulate(self) -> Result<Import>

Retrieve an inner ostree commit.

This does not write cached references for each blob, and errors out if the image has any non-ostree layers.

fn write_merge_commit_impl( repo: &Repo, base_commit: Option<&str>, layer_commits: &[String], have_derived_layers: bool, metadata: Variant, timestamp: u64, ostree_ref: &str, no_imgref: bool, disable_gc: bool, cancellable: Option<&Cancellable>, ) -> Result<Box<LayeredImageState>>

Generate a single ostree commit that combines all layers, and also includes container image metadata such as the manifest and config.

pub async fn import( self, import: Box<PreparedImport>, ) -> Result<Box<LayeredImageState>>

Import a layered container image.

If enabled, this will also prune unused container image layers.

Trait Implementations

impl Debug for ImageImporter

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.