Method Pull

engine/server/resolver/resolver.go:241–377

(ctx context.Context, ref string, opts PullOpts)

}

func (r *Resolver) Pull(ctx context.Context, ref string, opts PullOpts) (_ *PulledImage, rerr error) {
	span, ctx := tracing.StartSpan(ctx, "pulling "+ref, telemetry.Encapsulated())
	defer func() {
		tracing.FinishWithError(span, rerr)
	}()

	platformMatcher := platforms.Only(platforms.Normalize(opts.Platform))
	if opts.ResolveMode == ResolveModeDefault {
		if parsed, err := reference.ParseNormalizedNamed(ref); err == nil {
			if canonical, ok := parsed.(reference.Canonical); ok {
				rootDesc, found, err := r.localCanonicalRootDescriptor(ctx, canonical.Digest())
				if err != nil {
					return nil, err
				}
				if found {
					closure, found, release, err := r.tryLocalCanonicalClosure(ctx, canonical.String(), rootDesc, platformMatcher, opts.LayerLimit)
					if err != nil {
						return nil, err
					}
					if found {
						return &PulledImage{
							Ref:          canonical.String(),
							ManifestDesc: closure.ManifestDesc,
							ConfigDesc:   closure.ConfigDesc,
							Layers:       closure.Layers,
							Nonlayers:    closure.Nonlayers,
							release:      release,
						}, nil
					}
				}
			}
		}
	}

	resolvedRef, rootDesc, resolver, err := r.resolveRemoteRootDescriptor(ctx, ref, opts.Network)
	if err != nil {
		return nil, err
	}
	fetcher, err := resolver.Fetcher(ctx, resolvedRef)
	if err != nil {
		return nil, err
	}
	var manifestDesc ocispecs.Descriptor
	var manifest ocispecs.Manifest
	if opts.ResolveMode == ResolveModeDefault {
		metadata, err := r.ensureImageConfigMetadata(ctx, resolvedRef, rootDesc, fetcher, platformMatcher, true)
		if err != nil {
			return nil, err
		}
		manifestDesc = metadata.manifestDesc
		manifest = metadata.manifest
	} else {
		provider := contentutil.FromFetcher(fetcher)
		var err error
		manifestDesc, manifest, err = resolveManifestDescriptor(ctx, provider, rootDesc, platformMatcher, true)
		if err != nil {
			return nil, err
		}