JohnHammond
/
buildkit
mirror of https://github.com/JohnHammond/buildkit.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

llbsolver: update for new cache variables 

Signed-off-by: Tonis Tiigi <tonistiigi@gmail.com>
docker-18.09
Tonis Tiigi 2018-05-07 14:20:25 -07:00
parent f617d38aaa
commit 335b1c3660
5 changed files with 276 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
client/llb/state.go
View File

@ -269,6 +269,31 @@ func WithDescription(m map[string]string) MetadataOpt {
})
}
// WithExportCache forces results for this vertex to be exported with the cache
func WithExportCache() MetadataOpt {
return metadataOptFunc(func(md *OpMetadata) {
md.ExportCache = &pb.ExportCache{Value: true}
})
}
// WithoutExportCache sets results for this vertex to be not exported with
// the cache
func WithoutExportCache() MetadataOpt {
return metadataOptFunc(func(md *OpMetadata) {
// ExportCache with value false means to disable exporting
md.ExportCache = &pb.ExportCache{Value: false}
})
}
// WithoutDefaultExportCache resets the cache export for the vertex to use
// the default defined by the build configuration.
func WithoutDefaultExportCache() MetadataOpt {
return metadataOptFunc(func(md *OpMetadata) {
// nil means no vertex based config has been set
md.ExportCache = nil
})
}
type opMetaWrapper struct {
OpMetadata
}

4
solver-next/llbsolver/solver.go
View File

@ -112,7 +112,9 @@ func (s *Solver) Solve(ctx context.Context, id string, req frontend.SolveRequest
if exp := exp.CacheExporter; exp != nil {
if err := j.Call(ctx, "exporting cache", func(ctx context.Context) error {
prepareDone := oneOffProgress(ctx, "preparing build cache for export")
if _, err := res.CacheKey().ExportTo(ctx, exp, workerRefConverter); err != nil {
if _, err := res.CacheKey().Exporter.ExportTo(ctx, exp, solver.CacheExportOpt{
Convert: workerRefConverter,
}); err != nil {
return prepareDone(err)
}
prepareDone(nil)

3
solver-next/llbsolver/vertex.go
View File

@ -62,6 +62,9 @@ func newVertex(dgst digest.Digest, op *pb.Op, opMeta *pb.OpMetadata, load func(d
if opMeta != nil {
opt.IgnoreCache = opMeta.IgnoreCache
opt.Description = opMeta.Description
if opMeta.ExportCache != nil {
opt.ExportCache = &opMeta.ExportCache.Value
}
}
for _, fn := range opts {
fn(&opt)

298
solver/pb/ops.pb.go
View File

@ -22,6 +22,7 @@
BuildOp
BuildInput
OpMetadata
ExportCache
WorkerConstraint
Definition
*/
@ -480,6 +481,7 @@ type OpMetadata struct {
// Description can be used for keeping any text fields that builder doesn't parse
Description map[string]string `protobuf:"bytes,2,rep,name=description" json:"description,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
WorkerConstraint *WorkerConstraint `protobuf:"bytes,3,opt,name=worker_constraint,json=workerConstraint" json:"worker_constraint,omitempty"`
ExportCache *ExportCache `protobuf:"bytes,4,opt,name=export_cache,json=exportCache" json:"export_cache,omitempty"`
}
func (m *OpMetadata) Reset() { *m = OpMetadata{} }
@ -508,6 +510,29 @@ func (m *OpMetadata) GetWorkerConstraint() *WorkerConstraint {
return nil
}
func (m *OpMetadata) GetExportCache() *ExportCache {
if m != nil {
return m.ExportCache
}
return nil
}
type ExportCache struct {
Value bool `protobuf:"varint,1,opt,name=Value,proto3" json:"Value,omitempty"`
}
func (m *ExportCache) Reset() { *m = ExportCache{} }
func (m *ExportCache) String() string { return proto.CompactTextString(m) }
func (*ExportCache) ProtoMessage() {}
func (*ExportCache) Descriptor() ([]byte, []int) { return fileDescriptorOps, []int{11} }
func (m *ExportCache) GetValue() bool {
if m != nil {
return m.Value
}
return false
}
// WorkerConstraint is experimental and likely to be changed.
type WorkerConstraint struct {
Filter []string `protobuf:"bytes,1,rep,name=filter" json:"filter,omitempty"`
@ -516,7 +541,7 @@ type WorkerConstraint struct {
func (m *WorkerConstraint) Reset() { *m = WorkerConstraint{} }
func (m *WorkerConstraint) String() string { return proto.CompactTextString(m) }
func (*WorkerConstraint) ProtoMessage() {}
func (*WorkerConstraint) Descriptor() ([]byte, []int) { return fileDescriptorOps, []int{11} }
func (*WorkerConstraint) Descriptor() ([]byte, []int) { return fileDescriptorOps, []int{12} }
func (m *WorkerConstraint) GetFilter() []string {
if m != nil {
@ -537,7 +562,7 @@ type Definition struct {
func (m *Definition) Reset() { *m = Definition{} }
func (m *Definition) String() string { return proto.CompactTextString(m) }
func (*Definition) ProtoMessage() {}
func (*Definition) Descriptor() ([]byte, []int) { return fileDescriptorOps, []int{12} }
func (*Definition) Descriptor() ([]byte, []int) { return fileDescriptorOps, []int{13} }
func (m *Definition) GetDef() [][]byte {
if m != nil {
@ -565,6 +590,7 @@ func init() {
proto.RegisterType((*BuildOp)(nil), "pb.BuildOp")
proto.RegisterType((*BuildInput)(nil), "pb.BuildInput")
proto.RegisterType((*OpMetadata)(nil), "pb.OpMetadata")
proto.RegisterType((*ExportCache)(nil), "pb.ExportCache")
proto.RegisterType((*WorkerConstraint)(nil), "pb.WorkerConstraint")
proto.RegisterType((*Definition)(nil), "pb.Definition")
}
@ -1099,6 +1125,44 @@ func (m *OpMetadata) MarshalTo(dAtA []byte) (int, error) {
}
i += n9
}
if m.ExportCache != nil {
dAtA[i] = 0x22
i++
i = encodeVarintOps(dAtA, i, uint64(m.ExportCache.Size()))
n10, err := m.ExportCache.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n10
}
return i, nil
}
func (m *ExportCache) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *ExportCache) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Value {
dAtA[i] = 0x8
i++
if m.Value {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i++
}
return i, nil
}
@ -1177,11 +1241,11 @@ func (m *Definition) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x12
i++
i = encodeVarintOps(dAtA, i, uint64((&v).Size()))
n10, err := (&v).MarshalTo(dAtA[i:])
n11, err := (&v).MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n10
i += n11
}
}
return i, nil
@ -1433,6 +1497,19 @@ func (m *OpMetadata) Size() (n int) {
l = m.WorkerConstraint.Size()
n += 1 + l + sovOps(uint64(l))
}
if m.ExportCache != nil {
l = m.ExportCache.Size()
n += 1 + l + sovOps(uint64(l))
}
return n
}
func (m *ExportCache) Size() (n int) {
var l int
_ = l
if m.Value {
n += 2
}
return n
}
@ -3252,6 +3329,109 @@ func (m *OpMetadata) Unmarshal(dAtA []byte) error {
return err
}
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ExportCache", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowOps
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthOps
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.ExportCache == nil {
m.ExportCache = &ExportCache{}
}
if err := m.ExportCache.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipOps(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthOps
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *ExportCache) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowOps
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: ExportCache: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: ExportCache: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowOps
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
m.Value = bool(v != 0)
default:
iNdEx = preIndex
skippy, err := skipOps(dAtA[iNdEx:])
@ -3662,58 +3842,60 @@ var (
func init() { proto.RegisterFile("ops.proto", fileDescriptorOps) }
var fileDescriptorOps = []byte{
// 842 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0xc1, 0x8e, 0x1b, 0x45,
0x10, 0xdd, 0x19, 0xdb, 0x13, 0x4f, 0xcd, 0x82, 0x4c, 0x13, 0x05, 0xcb, 0x8a, 0xbc, 0x66, 0x40,
0x68, 0x09, 0xd9, 0x59, 0x69, 0x91, 0x50, 0xc4, 0x21, 0xd2, 0x7a, 0x37, 0x12, 0x0b, 0x8a, 0x56,
0x6a, 0x0e, 0x1c, 0xa3, 0xf1, 0x4c, 0xdb, 0x69, 0xc5, 0x9e, 0x1e, 0xf5, 0xf4, 0x64, 0xd7, 0x17,
0x0e, 0x7c, 0x01, 0x12, 0x7f, 0xc1, 0x3f, 0xc0, 0x39, 0x47, 0xae, 0x70, 0x08, 0x68, 0xf9, 0x06,
0xee, 0xa8, 0xaa, 0xdb, 0x9e, 0xc9, 0x12, 0xa4, 0xac, 0xe0, 0xe4, 0xee, 0xaa, 0xd7, 0xaf, 0xaa,
0x5e, 0x55, 0x8d, 0x21, 0x54, 0x65, 0x95, 0x94, 0x5a, 0x19, 0xc5, 0xfc, 0x72, 0x36, 0x3a, 0x58,
0x48, 0xf3, 0xb4, 0x9e, 0x25, 0x99, 0x5a, 0x1d, 0x2e, 0xd4, 0x42, 0x1d, 0x92, 0x6b, 0x56, 0xcf,
0xe9, 0x46, 0x17, 0x3a, 0xd9, 0x27, 0xf1, 0xcf, 0x1e, 0xf8, 0xe7, 0x25, 0x7b, 0x1f, 0x02, 0x59,
0x94, 0xb5, 0xa9, 0x86, 0xde, 0xa4, 0xb3, 0x1f, 0x1d, 0x85, 0x49, 0x39, 0x4b, 0xce, 0xd0, 0xc2,
0x9d, 0x83, 0x4d, 0xa0, 0x2b, 0x2e, 0x45, 0x36, 0xf4, 0x27, 0xde, 0x7e, 0x74, 0x04, 0x08, 0x78,
0x74, 0x29, 0xb2, 0xf3, 0xf2, 0x8b, 0x1d, 0x4e, 0x1e, 0xf6, 0x11, 0x04, 0x95, 0xaa, 0x75, 0x26,
0x86, 0x1d, 0xc2, 0xec, 0x22, 0xe6, 0x6b, 0xb2, 0x10, 0xca, 0x79, 0x91, 0x29, 0x53, 0xe5, 0x7a,
0xd8, 0x6d, 0x98, 0x4e, 0x54, 0xb9, 0xb6, 0x4c, 0xe8, 0x61, 0x1f, 0x40, 0x6f, 0x56, 0xcb, 0x65,
0x3e, 0xec, 0x11, 0x24, 0x42, 0xc8, 0x14, 0x0d, 0x84, 0xb1, 0xbe, 0x69, 0x17, 0x7c, 0x55, 0xc6,
0xdf, 0x42, 0x8f, 0xf2, 0x64, 0x5f, 0x42, 0x90, 0xcb, 0x85, 0xa8, 0xcc, 0xd0, 0x9b, 0x78, 0xfb,
0xe1, 0xf4, 0xe8, 0xc5, 0xcb, 0xbd, 0x9d, 0xdf, 0x5e, 0xee, 0xdd, 0x6b, 0x09, 0xa2, 0x4a, 0x51,
0x64, 0xaa, 0x30, 0xa9, 0x2c, 0x84, 0xae, 0x0e, 0x17, 0xea, 0xc0, 0x3e, 0x49, 0x4e, 0xe9, 0x87,
0x3b, 0x06, 0xf6, 0x31, 0xf4, 0x64, 0x91, 0x8b, 0x4b, 0x2a, 0xb6, 0x33, 0x7d, 0xd7, 0x51, 0x45,
0xe7, 0xb5, 0x29, 0x6b, 0x73, 0x86, 0x2e, 0x6e, 0x11, 0xf1, 0x19, 0x04, 0x56, 0x06, 0x76, 0x17,
0xba, 0x2b, 0x61, 0x52, 0x0a, 0x1f, 0x1d, 0xf5, 0x31, 0xe7, 0xc7, 0xc2, 0xa4, 0x9c, 0xac, 0xa8,
0xf0, 0x4a, 0xd5, 0x85, 0xa9, 0x86, 0x7e, 0xa3, 0xf0, 0x63, 0xb4, 0x70, 0xe7, 0x88, 0x39, 0x74,
0xf1, 0x01, 0x63, 0xd0, 0x4d, 0xf5, 0xc2, 0xb6, 0x22, 0xe4, 0x74, 0x66, 0x03, 0xe8, 0x88, 0xe2,
0x39, 0xbd, 0x0d, 0x39, 0x1e, 0xd1, 0x92, 0x5d, 0xe4, 0x24, 0x75, 0xc8, 0xf1, 0x88, 0xef, 0xea,
0x4a, 0x68, 0xd2, 0x35, 0xe4, 0x74, 0x8e, 0x7f, 0xf4, 0xa0, 0x47, 0x51, 0xd8, 0x3e, 0xd6, 0x54,
0xd6, 0x56, 0x9e, 0xce, 0x94, 0xb9, 0x9a, 0x80, 0xd4, 0xdb, 0x96, 0x84, 0x4a, 0x8e, 0xa0, 0x5f,
0x89, 0xa5, 0xc8, 0x8c, 0xd2, 0x24, 0x40, 0xc8, 0xb7, 0x77, 0x8c, 0x91, 0xa3, 0xc6, 0x36, 0x2c,
0x9d, 0xd9, 0x27, 0x10, 0x28, 0x12, 0x86, 0x22, 0xff, 0x8b, 0x5c, 0x0e, 0x82, 0xe4, 0x5a, 0xa4,
0xb9, 0x2a, 0x96, 0x6b, 0xea, 0x6e, 0x9f, 0x6f, 0xef, 0xf1, 0x43, 0x08, 0xec, 0x20, 0xb0, 0x09,
0x74, 0x2a, 0x9d, 0xb9, 0x61, 0x7c, 0x7b, 0x33, 0x21, 0x76, 0x96, 0x38, 0xba, 0xb6, 0x89, 0xf8,
0x4d, 0x22, 0x31, 0x07, 0x68, 0x60, 0xff, 0x4f, 0xc1, 0xf1, 0x0f, 0x1e, 0xf4, 0x37, 0x33, 0xcc,
0xc6, 0x00, 0x32, 0x17, 0x85, 0x91, 0x73, 0x29, 0xb4, 0x9d, 0x33, 0xde, 0xb2, 0xb0, 0x03, 0xe8,
0xa5, 0xc6, 0xe8, 0x4d, 0x8f, 0xdf, 0x6b, 0x2f, 0x40, 0x72, 0x8c, 0x9e, 0x47, 0x85, 0xd1, 0x6b,
0x6e, 0x51, 0xa3, 0x07, 0x00, 0x8d, 0x11, 0x1b, 0xfa, 0x4c, 0xac, 0x1d, 0x2b, 0x1e, 0xd9, 0x6d,
0xe8, 0x3d, 0x4f, 0x97, 0xb5, 0x70, 0x49, 0xd9, 0xcb, 0xe7, 0xfe, 0x03, 0x2f, 0xfe, 0xc9, 0x87,
0x5b, 0x6e, 0x21, 0xd8, 0x7d, 0xb8, 0x45, 0x0b, 0xe1, 0x32, 0x7a, 0x7d, 0xa5, 0x1b, 0x08, 0x3b,
0xdc, 0x6e, 0x7a, 0x2b, 0x47, 0x47, 0x65, 0x37, 0xde, 0xe5, 0xd8, 0xec, 0x7d, 0x27, 0x17, 0x73,
0xb7, 0xd2, 0xd4, 0x8a, 0x53, 0x31, 0x97, 0x85, 0x34, 0x52, 0x15, 0x1c, 0x5d, 0xec, 0xfe, 0xa6,
0xea, 0x2e, 0x31, 0xde, 0x69, 0x33, 0xfe, 0xb3, 0xe8, 0x33, 0x88, 0x5a, 0x61, 0x5e, 0x53, 0xf5,
0x87, 0xed, 0xaa, 0x5d, 0x48, 0xa2, 0xb3, 0xdf, 0xa3, 0x46, 0x85, 0xff, 0xa0, 0xdf, 0x67, 0x00,
0x0d, 0xe5, 0x9b, 0x4f, 0x4a, 0xfc, 0x97, 0x07, 0x70, 0x5e, 0xe2, 0x96, 0xe6, 0x29, 0x2d, 0xf5,
0xae, 0x5c, 0x14, 0x4a, 0x8b, 0x27, 0x59, 0x9a, 0x3d, 0x15, 0xf4, 0xbe, 0xcf, 0x23, 0x6b, 0x3b,
0x41, 0x13, 0x3b, 0x86, 0x28, 0x17, 0x55, 0xa6, 0x65, 0x89, 0x82, 0x39, 0xd1, 0xf7, 0xb0, 0xa6,
0x86, 0x27, 0x39, 0x6d, 0x10, 0x56, 0xab, 0xf6, 0x1b, 0x76, 0x0c, 0xef, 0x5c, 0x28, 0xfd, 0x4c,
0xe8, 0x27, 0x99, 0x2a, 0x2a, 0xa3, 0x53, 0x59, 0x18, 0xd7, 0x8f, 0xdb, 0x48, 0xf4, 0x0d, 0x39,
0x4f, 0xb6, 0x3e, 0x3e, 0xb8, 0xb8, 0x66, 0x19, 0x3d, 0x84, 0xc1, 0xf5, 0x18, 0x37, 0xd2, 0xeb,
0x1e, 0x0c, 0xae, 0x47, 0x61, 0x77, 0x20, 0x98, 0xcb, 0xa5, 0xa1, 0xb1, 0xc3, 0xaf, 0x92, 0xbb,
0xc5, 0xbf, 0x7a, 0x00, 0xcd, 0x88, 0x60, 0x18, 0x9c, 0x1f, 0xc4, 0xec, 0xda, 0x79, 0x59, 0x42,
0x7f, 0xe5, 0x2a, 0x77, 0x7a, 0xdc, 0x7d, 0x75, 0xac, 0x92, 0x8d, 0x30, 0x94, 0xa8, 0xfd, 0x92,
0x7f, 0xf7, 0xfb, 0x8d, 0xbe, 0xe4, 0xdb, 0x08, 0xa3, 0xaf, 0xe0, 0xad, 0x57, 0xe8, 0xde, 0x70,
0xe2, 0x9a, 0xee, 0xb4, 0x74, 0x98, 0x0e, 0x5e, 0x5c, 0x8d, 0xbd, 0x5f, 0xae, 0xc6, 0xde, 0x1f,
0x57, 0x63, 0xef, 0xfb, 0x3f, 0xc7, 0x3b, 0xb3, 0x80, 0xfe, 0x47, 0x3f, 0xfd, 0x3b, 0x00, 0x00,
0xff, 0xff, 0x99, 0xd2, 0xfe, 0xe4, 0x87, 0x07, 0x00, 0x00,
// 877 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0xcd, 0x8e, 0x1b, 0x45,
0x10, 0xde, 0x19, 0xff, 0xc4, 0xae, 0x59, 0xc0, 0x34, 0x51, 0xb0, 0xac, 0xc8, 0x6b, 0x26, 0x08,
0x2d, 0x21, 0xeb, 0x95, 0x8c, 0x84, 0x22, 0x0e, 0x91, 0xd6, 0xbb, 0x91, 0x58, 0x50, 0xb4, 0x52,
0x23, 0xc1, 0x31, 0x1a, 0xcf, 0xb4, 0x9d, 0x56, 0xbc, 0xd3, 0xad, 0x9e, 0x9e, 0xac, 0x7d, 0xe1,
0xc0, 0x13, 0x20, 0xf1, 0x14, 0xf0, 0x0e, 0x70, 0xce, 0x91, 0x2b, 0x1c, 0x02, 0x5a, 0x5e, 0x04,
0x55, 0x75, 0xdb, 0x33, 0x59, 0x82, 0x94, 0x15, 0x39, 0xb9, 0xab, 0xea, 0xeb, 0xaf, 0xaa, 0xbe,
0xae, 0x1a, 0x43, 0x57, 0xe9, 0x62, 0xac, 0x8d, 0xb2, 0x8a, 0x85, 0x7a, 0x36, 0x38, 0x58, 0x48,
0xfb, 0xa4, 0x9c, 0x8d, 0x53, 0x75, 0x7e, 0xb8, 0x50, 0x0b, 0x75, 0x48, 0xa1, 0x59, 0x39, 0x27,
0x8b, 0x0c, 0x3a, 0xb9, 0x2b, 0xf1, 0xaf, 0x01, 0x84, 0x67, 0x9a, 0x7d, 0x00, 0x6d, 0x99, 0xeb,
0xd2, 0x16, 0xfd, 0x60, 0xd4, 0xd8, 0x8f, 0x26, 0xdd, 0xb1, 0x9e, 0x8d, 0x4f, 0xd1, 0xc3, 0x7d,
0x80, 0x8d, 0xa0, 0x29, 0x56, 0x22, 0xed, 0x87, 0xa3, 0x60, 0x3f, 0x9a, 0x00, 0x02, 0x1e, 0xae,
0x44, 0x7a, 0xa6, 0xbf, 0xd8, 0xe1, 0x14, 0x61, 0x1f, 0x41, 0xbb, 0x50, 0xa5, 0x49, 0x45, 0xbf,
0x41, 0x98, 0x5d, 0xc4, 0x7c, 0x4d, 0x1e, 0x42, 0xf9, 0x28, 0x32, 0xa5, 0x4a, 0xaf, 0xfb, 0xcd,
0x8a, 0xe9, 0x58, 0xe9, 0xb5, 0x63, 0xc2, 0x08, 0xbb, 0x03, 0xad, 0x59, 0x29, 0x97, 0x59, 0xbf,
0x45, 0x90, 0x08, 0x21, 0x53, 0x74, 0x10, 0xc6, 0xc5, 0xa6, 0x4d, 0x08, 0x95, 0x8e, 0xbf, 0x83,
0x16, 0xd5, 0xc9, 0xbe, 0x84, 0x76, 0x26, 0x17, 0xa2, 0xb0, 0xfd, 0x60, 0x14, 0xec, 0x77, 0xa7,
0x93, 0xe7, 0x2f, 0xf6, 0x76, 0xfe, 0x78, 0xb1, 0x77, 0xb7, 0x26, 0x88, 0xd2, 0x22, 0x4f, 0x55,
0x6e, 0x13, 0x99, 0x0b, 0x53, 0x1c, 0x2e, 0xd4, 0x81, 0xbb, 0x32, 0x3e, 0xa1, 0x1f, 0xee, 0x19,
0xd8, 0xc7, 0xd0, 0x92, 0x79, 0x26, 0x56, 0xd4, 0x6c, 0x63, 0xfa, 0x9e, 0xa7, 0x8a, 0xce, 0x4a,
0xab, 0x4b, 0x7b, 0x8a, 0x21, 0xee, 0x10, 0xf1, 0x29, 0xb4, 0x9d, 0x0c, 0xec, 0x36, 0x34, 0xcf,
0x85, 0x4d, 0x28, 0x7d, 0x34, 0xe9, 0x60, 0xcd, 0x8f, 0x84, 0x4d, 0x38, 0x79, 0x51, 0xe1, 0x73,
0x55, 0xe6, 0xb6, 0xe8, 0x87, 0x95, 0xc2, 0x8f, 0xd0, 0xc3, 0x7d, 0x20, 0xe6, 0xd0, 0xc4, 0x0b,
0x8c, 0x41, 0x33, 0x31, 0x0b, 0xf7, 0x14, 0x5d, 0x4e, 0x67, 0xd6, 0x83, 0x86, 0xc8, 0x9f, 0xd1,
0xdd, 0x2e, 0xc7, 0x23, 0x7a, 0xd2, 0x8b, 0x8c, 0xa4, 0xee, 0x72, 0x3c, 0xe2, 0xbd, 0xb2, 0x10,
0x86, 0x74, 0xed, 0x72, 0x3a, 0xc7, 0x3f, 0x07, 0xd0, 0xa2, 0x2c, 0x6c, 0x1f, 0x7b, 0xd2, 0xa5,
0x93, 0xa7, 0x31, 0x65, 0xbe, 0x27, 0x20, 0xf5, 0xb6, 0x2d, 0xa1, 0x92, 0x03, 0xe8, 0x14, 0x62,
0x29, 0x52, 0xab, 0x0c, 0x09, 0xd0, 0xe5, 0x5b, 0x1b, 0x73, 0x64, 0xa8, 0xb1, 0x4b, 0x4b, 0x67,
0xf6, 0x09, 0xb4, 0x15, 0x09, 0x43, 0x99, 0xff, 0x43, 0x2e, 0x0f, 0x41, 0x72, 0x23, 0x92, 0x4c,
0xe5, 0xcb, 0x35, 0xbd, 0x6e, 0x87, 0x6f, 0xed, 0xf8, 0x01, 0xb4, 0xdd, 0x20, 0xb0, 0x11, 0x34,
0x0a, 0x93, 0xfa, 0x61, 0x7c, 0x7b, 0x33, 0x21, 0x6e, 0x96, 0x38, 0x86, 0xb6, 0x85, 0x84, 0x55,
0x21, 0x31, 0x07, 0xa8, 0x60, 0x6f, 0xa6, 0xe1, 0xf8, 0xc7, 0x00, 0x3a, 0x9b, 0x19, 0x66, 0x43,
0x00, 0x99, 0x89, 0xdc, 0xca, 0xb9, 0x14, 0xc6, 0xcd, 0x19, 0xaf, 0x79, 0xd8, 0x01, 0xb4, 0x12,
0x6b, 0xcd, 0xe6, 0x8d, 0xdf, 0xaf, 0x2f, 0xc0, 0xf8, 0x08, 0x23, 0x0f, 0x73, 0x6b, 0xd6, 0xdc,
0xa1, 0x06, 0xf7, 0x01, 0x2a, 0x27, 0x3e, 0xe8, 0x53, 0xb1, 0xf6, 0xac, 0x78, 0x64, 0x37, 0xa1,
0xf5, 0x2c, 0x59, 0x96, 0xc2, 0x17, 0xe5, 0x8c, 0xcf, 0xc3, 0xfb, 0x41, 0xfc, 0x4b, 0x08, 0x37,
0xfc, 0x42, 0xb0, 0x7b, 0x70, 0x83, 0x16, 0xc2, 0x57, 0xf4, 0xea, 0x4e, 0x37, 0x10, 0x76, 0xb8,
0xdd, 0xf4, 0x5a, 0x8d, 0x9e, 0xca, 0x6d, 0xbc, 0xaf, 0xb1, 0xda, 0xfb, 0x46, 0x26, 0xe6, 0x7e,
0xa5, 0xe9, 0x29, 0x4e, 0xc4, 0x5c, 0xe6, 0xd2, 0x4a, 0x95, 0x73, 0x0c, 0xb1, 0x7b, 0x9b, 0xae,
0x9b, 0xc4, 0x78, 0xab, 0xce, 0xf8, 0xef, 0xa6, 0x4f, 0x21, 0xaa, 0xa5, 0x79, 0x45, 0xd7, 0x1f,
0xd6, 0xbb, 0xf6, 0x29, 0x89, 0xce, 0x7d, 0x8f, 0x2a, 0x15, 0xfe, 0x87, 0x7e, 0x9f, 0x01, 0x54,
0x94, 0xaf, 0x3f, 0x29, 0xf1, 0x4f, 0x21, 0xc0, 0x99, 0xc6, 0x2d, 0xcd, 0x12, 0x5a, 0xea, 0x5d,
0xb9, 0xc8, 0x95, 0x11, 0x8f, 0xd3, 0x24, 0x7d, 0x22, 0xe8, 0x7e, 0x87, 0x47, 0xce, 0x77, 0x8c,
0x2e, 0x76, 0x04, 0x51, 0x26, 0x8a, 0xd4, 0x48, 0x8d, 0x82, 0x79, 0xd1, 0xf7, 0xb0, 0xa7, 0x8a,
0x67, 0x7c, 0x52, 0x21, 0x9c, 0x56, 0xf5, 0x3b, 0xec, 0x08, 0xde, 0xbd, 0x50, 0xe6, 0xa9, 0x30,
0x8f, 0x53, 0x95, 0x17, 0xd6, 0x24, 0x32, 0xb7, 0xfe, 0x3d, 0x6e, 0x22, 0xd1, 0xb7, 0x14, 0x3c,
0xde, 0xc6, 0x78, 0xef, 0xe2, 0x8a, 0x87, 0x4d, 0x60, 0x57, 0xac, 0xb4, 0x32, 0xd6, 0x17, 0xea,
0x3e, 0xbd, 0xef, 0xb8, 0x8f, 0x38, 0xfa, 0xa9, 0x58, 0x1e, 0x89, 0xca, 0x18, 0x3c, 0x80, 0xde,
0xd5, 0xba, 0xae, 0xa5, 0xf1, 0x1d, 0x88, 0x6a, 0xdc, 0x08, 0xfc, 0x86, 0x80, 0x4e, 0x24, 0x67,
0xc4, 0x77, 0xa1, 0x77, 0xb5, 0x7c, 0x76, 0x0b, 0xda, 0x73, 0xb9, 0xb4, 0x34, 0xcf, 0xf8, 0xb9,
0xf3, 0x56, 0xfc, 0x7b, 0x00, 0x50, 0xcd, 0x1e, 0xd6, 0x82, 0x83, 0x89, 0x98, 0x5d, 0x37, 0x88,
0x4b, 0xe8, 0x9c, 0x7b, 0x49, 0xbd, 0xd0, 0xb7, 0x5f, 0x9e, 0xd7, 0xf1, 0x46, 0x71, 0xea, 0xc6,
0xfd, 0x45, 0x7c, 0xff, 0xe7, 0xb5, 0xfe, 0x22, 0xb6, 0x19, 0x06, 0x5f, 0xc1, 0x5b, 0x2f, 0xd1,
0xbd, 0xe6, 0x28, 0x57, 0xcf, 0x5e, 0x13, 0x6b, 0xda, 0x7b, 0x7e, 0x39, 0x0c, 0x7e, 0xbb, 0x1c,
0x06, 0x7f, 0x5d, 0x0e, 0x83, 0x1f, 0xfe, 0x1e, 0xee, 0xcc, 0xda, 0xf4, 0x07, 0xfd, 0xe9, 0x3f,
0x01, 0x00, 0x00, 0xff, 0xff, 0xc0, 0x1c, 0x9d, 0x57, 0xe0, 0x07, 0x00, 0x00,
}

5
solver/pb/ops.proto
View File

@ -93,8 +93,13 @@ message OpMetadata {
// Description can be used for keeping any text fields that builder doesn't parse
map<string, string> description = 2;
WorkerConstraint worker_constraint = 3;
ExportCache export_cache = 4;
}
message ExportCache {
bool Value = 1;
};
// WorkerConstraint is experimental and likely to be changed.
message WorkerConstraint {
repeated string filter = 1; // containerd-style filter