vendor: update buildkit to master@ae9d0f5

Signed-off-by: Justin Chadwell <me@jedevc.com>

vendor/github.com/moby/buildkit/solver/errdefs/errdefs.pb.go

@@ -186,6 +186,7 @@ type Solve struct {
 	MountIDs []string `protobuf:"bytes,2,rep,name=mountIDs,proto3" json:"mountIDs,omitempty"`
 	Op       *pb.Op   `protobuf:"bytes,3,opt,name=op,proto3" json:"op,omitempty"`
 	// Types that are valid to be assigned to Subject:
+	//
 	//	*Solve_File
 	//	*Solve_Cache
 	Subject              isSolve_Subject `protobuf_oneof:"subject"`

vendor/github.com/moby/buildkit/solver/pb/caps.go

@@ -73,13 +73,18 @@ const (
 	CapMetaDescription apicaps.CapID = "meta.description"
 	CapMetaExportCache apicaps.CapID = "meta.exportcache"
 
-	CapRemoteCacheGHA apicaps.CapID = "cache.gha"
-	CapRemoteCacheS3  apicaps.CapID = "cache.s3"
+	CapRemoteCacheGHA    apicaps.CapID = "cache.gha"
+	CapRemoteCacheS3     apicaps.CapID = "cache.s3"
+	CapRemoteCacheAzBlob apicaps.CapID = "cache.azblob"
 
 	CapMergeOp apicaps.CapID = "mergeop"
 	CapDiffOp  apicaps.CapID = "diffop"
 
-	CapAnnotations apicaps.CapID = "exporter.image.annotations"
+	CapAnnotations  apicaps.CapID = "exporter.image.annotations"
+	CapAttestations apicaps.CapID = "exporter.image.attestations"
+
+	// CapSourceDateEpoch is the capability to automatically handle the date epoch
+	CapSourceDateEpoch apicaps.CapID = "exporter.sourcedateepoch"
 )
 
 func init() {
@@ -423,6 +428,12 @@ func init() {
 		Status:  apicaps.CapStatusExperimental,
 	})
 
+	Caps.Init(apicaps.Cap{
+		ID:      CapRemoteCacheAzBlob,
+		Enabled: true,
+		Status:  apicaps.CapStatusExperimental,
+	})
+
 	Caps.Init(apicaps.Cap{
 		ID:      CapMergeOp,
 		Enabled: true,
@@ -440,4 +451,17 @@ func init() {
 		Enabled: true,
 		Status:  apicaps.CapStatusExperimental,
 	})
+
+	Caps.Init(apicaps.Cap{
+		ID:      CapAttestations,
+		Enabled: true,
+		Status:  apicaps.CapStatusExperimental,
+	})
+
+	Caps.Init(apicaps.Cap{
+		ID:      CapSourceDateEpoch,
+		Name:    "source date epoch",
+		Enabled: true,
+		Status:  apicaps.CapStatusExperimental,
+	})
 }

vendor/github.com/moby/buildkit/solver/pb/ops.pb.go

@@ -154,6 +154,7 @@ type Op struct {
 	// inputs is a set of input edges.
 	Inputs []*Input `protobuf:"bytes,1,rep,name=inputs,proto3" json:"inputs,omitempty"`
 	// Types that are valid to be assigned to Op:
+	//
 	//	*Op_Exec
 	//	*Op_Source
 	//	*Op_File
@@ -1948,6 +1949,7 @@ type FileAction struct {
 	SecondaryInput InputIndex  `protobuf:"varint,2,opt,name=secondaryInput,proto3,customtype=InputIndex" json:"secondaryInput"`
 	Output         OutputIndex `protobuf:"varint,3,opt,name=output,proto3,customtype=OutputIndex" json:"output"`
 	// Types that are valid to be assigned to Action:
+	//
 	//	*FileAction_Copy
 	//	*FileAction_Mkfile
 	//	*FileAction_Mkdir
@@ -2465,6 +2467,7 @@ func (m *ChownOpt) GetGroup() *UserOpt {
 
 type UserOpt struct {
 	// Types that are valid to be assigned to User:
+	//
 	//	*UserOpt_ByName
 	//	*UserOpt_ByID
 	User isUserOpt_User `protobuf_oneof:"user"`

vendor/github.com/moby/buildkit/solver/result/attestation.go

@@ -0,0 +1,36 @@
+package result
+
+import (
+	pb "github.com/moby/buildkit/frontend/gateway/pb"
+	digest "github.com/opencontainers/go-digest"
+)
+
+type Attestation struct {
+	Kind pb.AttestationKind
+
+	Ref  string
+	Path string
+
+	InToto      InTotoAttestation
+	ContentFunc func() ([]byte, error)
+}
+
+type InTotoAttestation struct {
+	PredicateType string
+	Subjects      []InTotoSubject
+}
+
+type InTotoSubject struct {
+	Kind pb.InTotoSubjectKind
+
+	Name   string
+	Digest []digest.Digest
+}
+
+func DigestMap(ds ...digest.Digest) map[string]string {
+	m := map[string]string{}
+	for _, d := range ds {
+		m[d.Algorithm().String()] = d.Encoded()
+	}
+	return m
+}

vendor/github.com/moby/buildkit/solver/result/result.go

@@ -0,0 +1,131 @@
+package result
+
+import (
+	"reflect"
+	"strings"
+	"sync"
+
+	"github.com/moby/buildkit/identity"
+	"github.com/pkg/errors"
+)
+
+const (
+	attestationRefPrefix = "attestation:"
+)
+
+type Result[T any] struct {
+	mu           sync.Mutex
+	Ref          T
+	Refs         map[string]T
+	Metadata     map[string][]byte
+	Attestations map[string][]Attestation
+}
+
+func (r *Result[T]) AddMeta(k string, v []byte) {
+	r.mu.Lock()
+	if r.Metadata == nil {
+		r.Metadata = map[string][]byte{}
+	}
+	r.Metadata[k] = v
+	r.mu.Unlock()
+}
+
+func (r *Result[T]) AddRef(k string, ref T) {
+	r.mu.Lock()
+	if r.Refs == nil {
+		r.Refs = map[string]T{}
+	}
+	r.Refs[k] = ref
+	r.mu.Unlock()
+}
+
+func (r *Result[T]) AddAttestation(k string, v Attestation, ref T) {
+	r.mu.Lock()
+	if r.Refs == nil {
+		r.Refs = map[string]T{}
+	}
+	if r.Attestations == nil {
+		r.Attestations = map[string][]Attestation{}
+	}
+	if v.ContentFunc == nil && !strings.HasPrefix(v.Ref, attestationRefPrefix) {
+		v.Ref = "attestation:" + identity.NewID()
+		r.Refs[v.Ref] = ref
+	}
+	r.Attestations[k] = append(r.Attestations[k], v)
+	r.mu.Unlock()
+}
+
+func (r *Result[T]) SetRef(ref T) {
+	r.Ref = ref
+}
+
+func (r *Result[T]) SingleRef() (T, error) {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	if r.Refs != nil && !reflect.ValueOf(r.Ref).IsValid() {
+		var t T
+		return t, errors.Errorf("invalid map result")
+	}
+	return r.Ref, nil
+}
+
+func (r *Result[T]) EachRef(fn func(T) error) (err error) {
+	if reflect.ValueOf(r.Ref).IsValid() {
+		err = fn(r.Ref)
+	}
+	for _, r := range r.Refs {
+		if reflect.ValueOf(r).IsValid() {
+			if err1 := fn(r); err1 != nil && err == nil {
+				err = err1
+			}
+		}
+	}
+	return err
+}
+
+// EachRef iterates over references in both a and b.
+// a and b are assumed to be of the same size and map their references
+// to the same set of keys
+func EachRef[U any, V any](a *Result[U], b *Result[V], fn func(U, V) error) (err error) {
+	if reflect.ValueOf(a.Ref).IsValid() && reflect.ValueOf(b.Ref).IsValid() {
+		err = fn(a.Ref, b.Ref)
+	}
+	for k, r := range a.Refs {
+		if reflect.ValueOf(r).IsValid() && reflect.ValueOf(b.Refs[k]).IsValid() {
+			if err1 := fn(r, b.Refs[k]); err1 != nil && err == nil {
+				err = err1
+			}
+		}
+	}
+	return err
+}
+
+func ConvertResult[U any, V any](r *Result[U], fn func(U) (V, error)) (*Result[V], error) {
+	r2 := &Result[V]{}
+	var err error
+
+	if reflect.ValueOf(r.Ref).IsValid() {
+		r2.Ref, err = fn(r.Ref)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	if r.Refs != nil {
+		r2.Refs = map[string]V{}
+	}
+	for k, r := range r.Refs {
+		if reflect.ValueOf(r).IsValid() {
+			r2.Refs[k], err = fn(r)
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	r2.Attestations = r.Attestations
+	r2.Metadata = r.Metadata
+
+	return r2, nil
+}