Bump buildkit to master and fix versions incompatible with go mod 1.13

Bump github.com/gogo/googleapis to v1.3.2
Bump github.com/docker/cli to master

Signed-off-by: Silvin Lubecki <silvin.lubecki@docker.com>

vendor/github.com/moby/buildkit/client/build.go

@@ -103,3 +103,8 @@ func (g *gatewayClientForBuild) Return(ctx context.Context, in *gatewayapi.Retur
 	ctx = buildid.AppendToOutgoingContext(ctx, g.buildID)
 	return g.gateway.Return(ctx, in, opts...)
 }
+
+func (g *gatewayClientForBuild) Inputs(ctx context.Context, in *gatewayapi.InputsRequest, opts ...grpc.CallOption) (*gatewayapi.InputsResponse, error) {
+	ctx = buildid.AppendToOutgoingContext(ctx, g.buildID)
+	return g.gateway.Inputs(ctx, in, opts...)
+}

vendor/github.com/moby/buildkit/client/client_windows.go

@@ -5,7 +5,7 @@ import (
 	"strings"
 	"time"
 
-	"github.com/Microsoft/go-winio"
+	winio "github.com/Microsoft/go-winio"
 	"github.com/pkg/errors"
 )
 

vendor/github.com/moby/buildkit/client/llb/definition.go

@@ -0,0 +1,161 @@
+package llb
+
+import (
+	"github.com/moby/buildkit/solver/pb"
+	digest "github.com/opencontainers/go-digest"
+	specs "github.com/opencontainers/image-spec/specs-go/v1"
+	"github.com/pkg/errors"
+)
+
+// DefinitionOp implements llb.Vertex using a marshalled definition.
+//
+// For example, after marshalling a LLB state and sending over the wire, the
+// LLB state can be reconstructed from the definition.
+type DefinitionOp struct {
+	MarshalCache
+	ops       map[digest.Digest]*pb.Op
+	defs      map[digest.Digest][]byte
+	metas     map[digest.Digest]pb.OpMetadata
+	platforms map[digest.Digest]*specs.Platform
+	dgst      digest.Digest
+	index     pb.OutputIndex
+}
+
+// NewDefinitionOp returns a new operation from a marshalled definition.
+func NewDefinitionOp(def *pb.Definition) (*DefinitionOp, error) {
+	ops := make(map[digest.Digest]*pb.Op)
+	defs := make(map[digest.Digest][]byte)
+
+	var dgst digest.Digest
+	for _, dt := range def.Def {
+		var op pb.Op
+		if err := (&op).Unmarshal(dt); err != nil {
+			return nil, errors.Wrap(err, "failed to parse llb proto op")
+		}
+		dgst = digest.FromBytes(dt)
+		ops[dgst] = &op
+		defs[dgst] = dt
+	}
+
+	var index pb.OutputIndex
+	if dgst != "" {
+		index = ops[dgst].Inputs[0].Index
+		dgst = ops[dgst].Inputs[0].Digest
+	}
+
+	return &DefinitionOp{
+		ops:       ops,
+		defs:      defs,
+		metas:     def.Metadata,
+		platforms: make(map[digest.Digest]*specs.Platform),
+		dgst:      dgst,
+		index:     index,
+	}, nil
+}
+
+func (d *DefinitionOp) ToInput(c *Constraints) (*pb.Input, error) {
+	return d.Output().ToInput(c)
+}
+
+func (d *DefinitionOp) Vertex() Vertex {
+	return d
+}
+
+func (d *DefinitionOp) Validate() error {
+	// Scratch state has no digest, ops or metas.
+	if d.dgst == "" {
+		return nil
+	}
+
+	if len(d.ops) == 0 || len(d.defs) == 0 || len(d.metas) == 0 {
+		return errors.Errorf("invalid definition op with no ops %d %d", len(d.ops), len(d.metas))
+	}
+
+	_, ok := d.ops[d.dgst]
+	if !ok {
+		return errors.Errorf("invalid definition op with unknown op %q", d.dgst)
+	}
+
+	_, ok = d.defs[d.dgst]
+	if !ok {
+		return errors.Errorf("invalid definition op with unknown def %q", d.dgst)
+	}
+
+	_, ok = d.metas[d.dgst]
+	if !ok {
+		return errors.Errorf("invalid definition op with unknown metas %q", d.dgst)
+	}
+
+	// It is possible for d.index >= len(d.ops[d.dgst]) when depending on scratch
+	// images.
+	if d.index < 0 {
+		return errors.Errorf("invalid definition op with invalid index")
+	}
+
+	return nil
+}
+
+func (d *DefinitionOp) Marshal(c *Constraints) (digest.Digest, []byte, *pb.OpMetadata, error) {
+	if d.dgst == "" {
+		return "", nil, nil, errors.Errorf("cannot marshal empty definition op")
+	}
+
+	if err := d.Validate(); err != nil {
+		return "", nil, nil, err
+	}
+
+	meta := d.metas[d.dgst]
+	return d.dgst, d.defs[d.dgst], &meta, nil
+
+}
+
+func (d *DefinitionOp) Output() Output {
+	if d.dgst == "" {
+		return nil
+	}
+
+	return &output{vertex: d, platform: d.platform(), getIndex: func() (pb.OutputIndex, error) {
+		return d.index, nil
+	}}
+}
+
+func (d *DefinitionOp) Inputs() []Output {
+	if d.dgst == "" {
+		return nil
+	}
+
+	var inputs []Output
+
+	op := d.ops[d.dgst]
+	for _, input := range op.Inputs {
+		vtx := &DefinitionOp{
+			ops:       d.ops,
+			defs:      d.defs,
+			metas:     d.metas,
+			platforms: d.platforms,
+			dgst:      input.Digest,
+			index:     input.Index,
+		}
+		inputs = append(inputs, &output{vertex: vtx, platform: d.platform(), getIndex: func() (pb.OutputIndex, error) {
+			return pb.OutputIndex(vtx.index), nil
+		}})
+	}
+
+	return inputs
+}
+
+func (d *DefinitionOp) platform() *specs.Platform {
+	platform, ok := d.platforms[d.dgst]
+	if ok {
+		return platform
+	}
+
+	op := d.ops[d.dgst]
+	if op.Platform != nil {
+		spec := op.Platform.Spec()
+		platform = &spec
+	}
+
+	d.platforms[d.dgst] = platform
+	return platform
+}

vendor/github.com/moby/buildkit/client/llb/resolver.go

@@ -3,8 +3,8 @@ package llb
 import (
 	"context"
 
-	gw "github.com/moby/buildkit/frontend/gateway/client"
 	digest "github.com/opencontainers/go-digest"
+	specs "github.com/opencontainers/image-spec/specs-go/v1"
 )
 
 // WithMetaResolver adds a metadata resolver to an image
@@ -16,5 +16,11 @@ func WithMetaResolver(mr ImageMetaResolver) ImageOption {
 
 // ImageMetaResolver can resolve image config metadata from a reference
 type ImageMetaResolver interface {
-	ResolveImageConfig(ctx context.Context, ref string, opt gw.ResolveImageConfigOpt) (digest.Digest, []byte, error)
+	ResolveImageConfig(ctx context.Context, ref string, opt ResolveImageConfigOpt) (digest.Digest, []byte, error)
+}
+
+type ResolveImageConfigOpt struct {
+	Platform    *specs.Platform
+	ResolveMode string
+	LogName     string
 }

vendor/github.com/moby/buildkit/client/llb/source.go

@@ -9,7 +9,6 @@ import (
 	"strings"
 
 	"github.com/docker/distribution/reference"
-	gw "github.com/moby/buildkit/frontend/gateway/client"
 	"github.com/moby/buildkit/solver/pb"
 	"github.com/moby/buildkit/util/apicaps"
 	digest "github.com/opencontainers/go-digest"
@@ -119,7 +118,7 @@ func Image(ref string, opts ...ImageOption) State {
 		src.err = err
 	}
 	if info.metaResolver != nil {
-		_, dt, err := info.metaResolver.ResolveImageConfig(context.TODO(), ref, gw.ResolveImageConfigOpt{
+		_, dt, err := info.metaResolver.ResolveImageConfig(context.TODO(), ref, ResolveImageConfigOpt{
 			Platform:    info.Constraints.Platform,
 			ResolveMode: info.resolveMode.String(),
 		})

vendor/github.com/moby/buildkit/client/solve.go

@@ -35,6 +35,7 @@ type SolveOpt struct {
 	SharedKey             string
 	Frontend              string
 	FrontendAttrs         map[string]string
+	FrontendInputs        map[string]llb.State
 	CacheExports          []CacheOptionsEntry
 	CacheImports          []CacheOptionsEntry
 	Session               []session.Attachable
@@ -188,16 +189,27 @@ func (c *Client) solve(ctx context.Context, def *llb.Definition, runGateway runG
 		if def != nil {
 			pbd = def.ToPB()
 		}
+
+		frontendInputs := make(map[string]*pb.Definition)
+		for key, st := range opt.FrontendInputs {
+			def, err := st.Marshal()
+			if err != nil {
+				return err
+			}
+			frontendInputs[key] = def.ToPB()
+		}
+
 		resp, err := c.controlClient().Solve(ctx, &controlapi.SolveRequest{
-			Ref:           ref,
-			Definition:    pbd,
-			Exporter:      ex.Type,
-			ExporterAttrs: ex.Attrs,
-			Session:       s.ID(),
-			Frontend:      opt.Frontend,
-			FrontendAttrs: opt.FrontendAttrs,
-			Cache:         cacheOpt.options,
-			Entitlements:  opt.AllowedEntitlements,
+			Ref:            ref,
+			Definition:     pbd,
+			Exporter:       ex.Type,
+			ExporterAttrs:  ex.Attrs,
+			Session:        s.ID(),
+			Frontend:       opt.Frontend,
+			FrontendAttrs:  opt.FrontendAttrs,
+			FrontendInputs: frontendInputs,
+			Cache:          cacheOpt.options,
+			Entitlements:   opt.AllowedEntitlements,
 		})
 		if err != nil {
 			return errors.Wrap(err, "failed to solve")
@@ -412,15 +424,15 @@ func parseCacheOptions(opt SolveOpt) (*cacheOptions, error) {
 			}
 			cs, err := contentlocal.NewStore(csDir)
 			if err != nil {
-				return nil, err
+				logrus.Warning("local cache import at " + csDir + " not found due to err: " + err.Error())
+				continue
 			}
-			contentStores["local:"+csDir] = cs
-
 			// if digest is not specified, load from "latest" tag
 			if attrs["digest"] == "" {
 				idx, err := ociindex.ReadIndexJSONFileLocked(filepath.Join(csDir, "index.json"))
 				if err != nil {
-					return nil, err
+					logrus.Warning("local cache import at " + csDir + " not found due to err: " + err.Error())
+					continue
 				}
 				for _, m := range idx.Manifests {
 					if m.Annotations[ocispec.AnnotationRefName] == "latest" {
@@ -432,6 +444,8 @@ func parseCacheOptions(opt SolveOpt) (*cacheOptions, error) {
 					return nil, errors.New("local cache importer requires either explicit digest or \"latest\" tag on index.json")
 				}
 			}
+			contentStores["local:"+csDir] = cs
+
 		}
 		if im.Type == "registry" {
 			legacyImportRef := attrs["ref"]