Method ImagePull

src/cmd/linuxkit/cache/write.go:42–143

ImagePull takes an image name and ensures that the image manifest or index to which it refers exists in local cache and, if not, pulls it from the registry and writes it locally. It should be efficient and only write missing blobs, based on their content hash. If the ref and all of the content for t

(ref *reference.Spec, platforms []imagespec.Platform, alwaysPull bool)

// Note that ImagePull does try ValidateImage first, so if the image is already in the cache, it will not
// do any network activity at all.
func (p *Provider) ImagePull(ref *reference.Spec, platforms []imagespec.Platform, alwaysPull bool) error {
	imageName := util.ReferenceExpand(ref.String())
	canonicalRef, err := reference.Parse(imageName)
	if err != nil {
		return fmt.Errorf("invalid image name %s: %v", imageName, err)
	}
	ref = &canonicalRef
	image := ref.String()
	pullImageName := image
	platformMessage := platformMessageGenerator(platforms)
	remoteOptions := []remote.Option{remote.WithAuthFromKeychain(authn.DefaultKeychain)}
	log.Debugf("ImagePull to cache %s trusted reference %s", image, pullImageName)

	// unless alwaysPull is set to true, check locally first
	if alwaysPull {
		log.Debugf("Instructed always to pull, so pulling image %s %s", image, platformMessage)
	} else {
		imgSrc, err := p.ValidateImage(ref, platforms)
		switch {
		case err == nil && imgSrc != nil:
			log.Debugf("Image %s %s found in local cache, not pulling", image, platformMessage)
			return nil
		case err != nil && errors.Is(err, &noReferenceError{}):
			log.Debugf("Image %s %s not found in local cache, pulling", image, platformMessage)
		default:
			log.Debugf("Image %s %s incomplete or invalid in local cache, error %v, pulling", image, platformMessage, err)
		}
	}
	remoteRef, err := name.ParseReference(pullImageName)
	if err != nil {
		return fmt.Errorf("invalid image name %s: %v", pullImageName, err)
	}

	desc, err := registry.GetRemote().Get(remoteRef, remoteOptions...)
	if err != nil {
		return fmt.Errorf("error getting manifest for image %s: %v", pullImageName, err)
	}

	// get our lock
	if err := p.Lock(); err != nil {
		return fmt.Errorf("unable to lock cache for removing descriptors: %v", err)
	}
	defer p.Unlock()

	// first attempt as an index
	ii, err := desc.ImageIndex()
	if err == nil {
		log.Debugf("ImageWrite retrieved %s is index, saving, first checking if it contains target %s", pullImageName, platformMessage)
		im, err := ii.IndexManifest()
		if err != nil {
			return fmt.Errorf("unable to get IndexManifest: %v", err)
		}
		// only useful if it contains our architecture
		var foundPlatforms []*v1.Platform
		for _, m := range im.Manifests {
			if m.MediaType.IsImage() && m.Platform != nil {
				foundPlatforms = append(foundPlatforms, m.Platform)
			}