Struct ImageImporter 

pub struct ImageImporter {

    repo: Repo,
    pub(crate) proxy: ImageProxy,
    imgref: OstreeImageReference,
    target_imgref: Option<OstreeImageReference>,
    no_imgref: bool,
    disable_gc: bool,
    sepolicy_commit: Option<String>,
    require_bootable: bool,
    offline: bool,
    ostree_v2024_3: bool,
    diffid_to_digest: HashMap<String, String>,
    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

sepolicy_commit: Option<String>

Optional commit to use as SELinux policy source for non-ostree container layers.

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.

diffid_to_digest: HashMap<String, String>

Mapping from diff_id to blob digest for layer deduplication

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 fn set_sepolicy_commit(&mut self, commit: String)

Set the commit to use as SELinux policy source when importing non-ostree container layers. Has no effect on ostree-native containers (which have their own base commit).

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 build_diffid_to_digest_map(repo: &Repo) -> Result<HashMap<String, String>>

Build a mapping from diff_id to blob_digest by enumerating all stored images. This allows us to reuse layers with the same content even if they have different blob digests.

fn find_digest_by_diffid( &self, manifest: &ImageManifest, config: &ImageConfiguration, layer: &Descriptor, ) -> Option<&String>

fn resolve_commit_by_diffid( &self, manifest: &ImageManifest, config: &ImageConfiguration, layer: &Descriptor, ) -> Result<Option<String>>

Try to resolve a layer commit by looking up its diff_id in already-imported images.

fn query_layer( &self, manifest: &ImageManifest, config: &ImageConfiguration, layer: &Descriptor, ) -> Result<ManifestLayerState>

Query a layer by digest, falling back to diff_id lookup if the direct ref is not found.

fn ensure_ref_for_layer( repo: &Repo, ostree_ref: &str, commit: &str, ) -> Result<()>

Ensure a ref exists for a layer, creating it if needed.

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: &[LayerRef], 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.

fn relabel_layers( repo: &Repo, layer_commits: &[LayerRef], modifier: &RepoCommitModifier, checkout_mode: RepoCheckoutMode, cancellable: Option<&Cancellable>, ) -> Result<u32>

Relabel layer commits with the given commit modifier (which carries an SELinux policy). Each layer is checked out, recommitted with the policy applied, and its ref is updated to point at the new commit. Returns the number of layers that were actually relabeled (i.e. whose commit changed).

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.