Method ResolveImageConfig

engine/server/resolver/resolver.go:155–239

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

}

func (r *Resolver) ResolveImageConfig(
	ctx context.Context,
	ref string,
	opts ResolveImageConfigOpts,
) (_ string, _ digest.Digest, _ []byte, rerr error) {
	span, ctx := tracing.StartSpan(ctx, "resolving "+ref, telemetry.Encapsulated())
	defer func() {
		tracing.FinishWithError(span, rerr)
	}()

	key := ref
	if opts.Platform != nil {
		key += platforms.Format(platforms.Normalize(*opts.Platform))
	}
	key += fmt.Sprintf(":%d", opts.ResolveMode)

	resolve := func(ctx context.Context) (*resolveImageConfigResult, error) {
		if opts.ResolveMode == ResolveModeDefault {
			if resolvedRef, dgst, configBytes, found, err := r.tryLocalCanonicalConfig(ctx, ref, opts); err != nil {
				return nil, err
			} else if found {
				return &resolveImageConfigResult{
					ref:    resolvedRef,
					digest: dgst,
					config: configBytes,
				}, 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
		}

		platformMatcher := imageConfigPlatformMatcher(opts.Platform)
		if opts.ResolveMode == ResolveModeDefault {
			metadata, err := r.ensureImageConfigMetadata(ctx, resolvedRef, rootDesc, fetcher, platformMatcher, false)
			if err != nil {
				return nil, err
			}
			return &resolveImageConfigResult{
				ref:    resolvedRef,
				digest: rootDesc.Digest,
				config: metadata.configBytes,
			}, nil
		}

		provider := contentutil.FromFetcher(fetcher)
		configDesc, err := images.Config(ctx, provider, rootDesc, platformMatcher)
		if err != nil {
			return nil, err
		}
		configBytes, err := content.ReadBlob(ctx, provider, configDesc)
		if err != nil {