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

gateway: expose worker information 

Signed-off-by: Tonis Tiigi <tonistiigi@gmail.com>
docker-18.09
Tonis Tiigi 2018-06-29 18:35:39 -07:00
parent 90d164ced5
commit 946a12eb42
14 changed files with 773 additions and 522 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

498
api/services/control/control.pb.go
View File

@ -23,7 +23,6 @@
BytesMessage BytesMessage
ListWorkersRequest ListWorkersRequest
ListWorkersResponse ListWorkersResponse
WorkerRecord
*/ */
package moby_buildkit_v1 package moby_buildkit_v1
@ -33,6 +32,7 @@ import math "math"
import _ "github.com/gogo/protobuf/gogoproto" import _ "github.com/gogo/protobuf/gogoproto"
import _ "github.com/golang/protobuf/ptypes/timestamp" import _ "github.com/golang/protobuf/ptypes/timestamp"
import pb "github.com/moby/buildkit/solver/pb" import pb "github.com/moby/buildkit/solver/pb"
import moby_buildkit_v1_types "github.com/moby/buildkit/api/types"
import time "time" import time "time"
import github_com_opencontainers_go_digest "github.com/opencontainers/go-digest" import github_com_opencontainers_go_digest "github.com/opencontainers/go-digest"
@ -526,7 +526,7 @@ func (m *ListWorkersRequest) GetFilter() []string {
} }
type ListWorkersResponse struct { type ListWorkersResponse struct {
Record []*WorkerRecord `protobuf:"bytes,1,rep,name=record" json:"record,omitempty"` Record []*moby_buildkit_v1_types.WorkerRecord `protobuf:"bytes,1,rep,name=record" json:"record,omitempty"`
} }
func (m *ListWorkersResponse) Reset() { *m = ListWorkersResponse{} } func (m *ListWorkersResponse) Reset() { *m = ListWorkersResponse{} }
@ -534,45 +534,13 @@ func (m *ListWorkersResponse) String() string { return proto.CompactT
func (*ListWorkersResponse) ProtoMessage() {} func (*ListWorkersResponse) ProtoMessage() {}
func (*ListWorkersResponse) Descriptor() ([]byte, []int) { return fileDescriptorControl, []int{14} } func (*ListWorkersResponse) Descriptor() ([]byte, []int) { return fileDescriptorControl, []int{14} }
func (m *ListWorkersResponse) GetRecord() []*WorkerRecord { func (m *ListWorkersResponse) GetRecord() []*moby_buildkit_v1_types.WorkerRecord {
if m != nil { if m != nil {
return m.Record return m.Record
} }
return nil return nil
} }
type WorkerRecord struct {
ID string `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"`
Labels map[string]string `protobuf:"bytes,2,rep,name=Labels" json:"Labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
Platforms []pb.Platform `protobuf:"bytes,3,rep,name=platforms" json:"platforms"`
}
func (m *WorkerRecord) Reset() { *m = WorkerRecord{} }
func (m *WorkerRecord) String() string { return proto.CompactTextString(m) }
func (*WorkerRecord) ProtoMessage() {}
func (*WorkerRecord) Descriptor() ([]byte, []int) { return fileDescriptorControl, []int{15} }
func (m *WorkerRecord) GetID() string {
if m != nil {
return m.ID
}
return ""
}
func (m *WorkerRecord) GetLabels() map[string]string {
if m != nil {
return m.Labels
}
return nil
}
func (m *WorkerRecord) GetPlatforms() []pb.Platform {
if m != nil {
return m.Platforms
}
return nil
}
func init() { func init() {
proto.RegisterType((*PruneRequest)(nil), "moby.buildkit.v1.PruneRequest") proto.RegisterType((*PruneRequest)(nil), "moby.buildkit.v1.PruneRequest")
proto.RegisterType((*DiskUsageRequest)(nil), "moby.buildkit.v1.DiskUsageRequest") proto.RegisterType((*DiskUsageRequest)(nil), "moby.buildkit.v1.DiskUsageRequest")
@ -589,7 +557,6 @@ func init() {
proto.RegisterType((*BytesMessage)(nil), "moby.buildkit.v1.BytesMessage") proto.RegisterType((*BytesMessage)(nil), "moby.buildkit.v1.BytesMessage")
proto.RegisterType((*ListWorkersRequest)(nil), "moby.buildkit.v1.ListWorkersRequest") proto.RegisterType((*ListWorkersRequest)(nil), "moby.buildkit.v1.ListWorkersRequest")
proto.RegisterType((*ListWorkersResponse)(nil), "moby.buildkit.v1.ListWorkersResponse") proto.RegisterType((*ListWorkersResponse)(nil), "moby.buildkit.v1.ListWorkersResponse")
proto.RegisterType((*WorkerRecord)(nil), "moby.buildkit.v1.WorkerRecord")
} }
// Reference imports to suppress errors if they are not otherwise used. // Reference imports to suppress errors if they are not otherwise used.
@ -1620,59 +1587,6 @@ func (m *ListWorkersResponse) MarshalTo(dAtA []byte) (int, error) {
return i, nil return i, nil
} }
func (m *WorkerRecord) 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 *WorkerRecord) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if len(m.ID) > 0 {
dAtA[i] = 0xa
i++
i = encodeVarintControl(dAtA, i, uint64(len(m.ID)))
i += copy(dAtA[i:], m.ID)
}
if len(m.Labels) > 0 {
for k, _ := range m.Labels {
dAtA[i] = 0x12
i++
v := m.Labels[k]
mapSize := 1 + len(k) + sovControl(uint64(len(k))) + 1 + len(v) + sovControl(uint64(len(v)))
i = encodeVarintControl(dAtA, i, uint64(mapSize))
dAtA[i] = 0xa
i++
i = encodeVarintControl(dAtA, i, uint64(len(k)))
i += copy(dAtA[i:], k)
dAtA[i] = 0x12
i++
i = encodeVarintControl(dAtA, i, uint64(len(v)))
i += copy(dAtA[i:], v)
}
}
if len(m.Platforms) > 0 {
for _, msg := range m.Platforms {
dAtA[i] = 0x1a
i++
i = encodeVarintControl(dAtA, i, uint64(msg.Size()))
n, err := msg.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n
}
}
return i, nil
}
func encodeVarintControl(dAtA []byte, offset int, v uint64) int { func encodeVarintControl(dAtA []byte, offset int, v uint64) int {
for v >= 1<<7 { for v >= 1<<7 {
dAtA[offset] = uint8(v&0x7f | 0x80) dAtA[offset] = uint8(v&0x7f | 0x80)
@ -1984,30 +1898,6 @@ func (m *ListWorkersResponse) Size() (n int) {
return n return n
} }
func (m *WorkerRecord) Size() (n int) {
var l int
_ = l
l = len(m.ID)
if l > 0 {
n += 1 + l + sovControl(uint64(l))
}
if len(m.Labels) > 0 {
for k, v := range m.Labels {
_ = k
_ = v
mapEntrySize := 1 + len(k) + sovControl(uint64(len(k))) + 1 + len(v) + sovControl(uint64(len(v)))
n += mapEntrySize + 1 + sovControl(uint64(mapEntrySize))
}
}
if len(m.Platforms) > 0 {
for _, e := range m.Platforms {
l = e.Size()
n += 1 + l + sovControl(uint64(l))
}
}
return n
}
func sovControl(x uint64) (n int) { func sovControl(x uint64) (n int) {
for { for {
n++ n++
@ -4487,7 +4377,7 @@ func (m *ListWorkersResponse) Unmarshal(dAtA []byte) error {
if postIndex > l { if postIndex > l {
return io.ErrUnexpectedEOF return io.ErrUnexpectedEOF
} }
m.Record = append(m.Record, &WorkerRecord{}) m.Record = append(m.Record, &moby_buildkit_v1_types.WorkerRecord{})
if err := m.Record[len(m.Record)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { if err := m.Record[len(m.Record)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err return err
} }
@ -4513,234 +4403,6 @@ func (m *ListWorkersResponse) Unmarshal(dAtA []byte) error {
} }
return nil return nil
} }
func (m *WorkerRecord) 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 ErrIntOverflowControl
}
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: WorkerRecord: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: WorkerRecord: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowControl
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthControl
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.ID = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowControl
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthControl
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Labels == nil {
m.Labels = make(map[string]string)
}
var mapkey string
var mapvalue string
for iNdEx < postIndex {
entryPreIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowControl
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
if fieldNum == 1 {
var stringLenmapkey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowControl
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLenmapkey |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLenmapkey := int(stringLenmapkey)
if intStringLenmapkey < 0 {
return ErrInvalidLengthControl
}
postStringIndexmapkey := iNdEx + intStringLenmapkey
if postStringIndexmapkey > l {
return io.ErrUnexpectedEOF
}
mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
iNdEx = postStringIndexmapkey
} else if fieldNum == 2 {
var stringLenmapvalue uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowControl
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLenmapvalue |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLenmapvalue := int(stringLenmapvalue)
if intStringLenmapvalue < 0 {
return ErrInvalidLengthControl
}
postStringIndexmapvalue := iNdEx + intStringLenmapvalue
if postStringIndexmapvalue > l {
return io.ErrUnexpectedEOF
}
mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
iNdEx = postStringIndexmapvalue
} else {
iNdEx = entryPreIndex
skippy, err := skipControl(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthControl
}
if (iNdEx + skippy) > postIndex {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
m.Labels[mapkey] = mapvalue
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Platforms", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowControl
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthControl
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Platforms = append(m.Platforms, pb.Platform{})
if err := m.Platforms[len(m.Platforms)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipControl(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthControl
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func skipControl(dAtA []byte) (n int, err error) { func skipControl(dAtA []byte) (n int, err error) {
l := len(dAtA) l := len(dAtA)
iNdEx := 0 iNdEx := 0
@ -4849,81 +4511,79 @@ var (
func init() { proto.RegisterFile("control.proto", fileDescriptorControl) } func init() { proto.RegisterFile("control.proto", fileDescriptorControl) }
var fileDescriptorControl = []byte{ var fileDescriptorControl = []byte{
// 1214 bytes of a gzipped FileDescriptorProto // 1176 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x57, 0x4f, 0x6f, 0x1b, 0x55, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0x4d, 0x6f, 0x23, 0x45,
0x10, 0x67, 0x6d, 0xc7, 0xf6, 0x8e, 0x9d, 0x28, 0x3c, 0xa0, 0x5a, 0x2d, 0x90, 0x98, 0x05, 0x24, 0x13, 0x7e, 0xc7, 0x76, 0xfc, 0x51, 0x76, 0xa2, 0xbc, 0x0d, 0xac, 0x46, 0x03, 0x24, 0x66, 0x00,
0xab, 0x6a, 0xd7, 0x69, 0xa0, 0x08, 0x72, 0xa8, 0x5a, 0xc7, 0x45, 0x24, 0x4a, 0x44, 0xd8, 0x34, 0xc9, 0x5a, 0xed, 0xce, 0x64, 0x03, 0x2b, 0xa1, 0x08, 0xad, 0x76, 0x1d, 0x2f, 0x22, 0x51, 0x22,
0x54, 0xe2, 0xb6, 0xb6, 0x5f, 0xdc, 0x55, 0xd6, 0xfb, 0x96, 0xf7, 0x9e, 0xa3, 0x86, 0x4f, 0xc1, 0x96, 0xce, 0x86, 0x95, 0xb8, 0x8d, 0xed, 0x8e, 0x77, 0x14, 0x7b, 0x7a, 0xe8, 0xee, 0x09, 0x6b,
0x81, 0x6f, 0xc2, 0x81, 0x33, 0x07, 0xa4, 0xde, 0xe0, 0xcc, 0x21, 0x45, 0xb9, 0xc3, 0x67, 0x40, 0x7e, 0x05, 0x07, 0xfe, 0x09, 0x07, 0xce, 0x1c, 0x90, 0xf6, 0xc8, 0x99, 0x43, 0x16, 0xe5, 0x0e,
0xef, 0xcf, 0xda, 0xcf, 0x5e, 0xe7, 0x8f, 0xd3, 0x93, 0xdf, 0xcc, 0xfe, 0xe6, 0xb7, 0xf3, 0x66, 0xbf, 0x01, 0xf5, 0xc7, 0xd8, 0xed, 0xd8, 0xf9, 0xdc, 0x53, 0xba, 0x2a, 0x4f, 0x3d, 0x53, 0x5d,
0x66, 0x67, 0xc6, 0xb0, 0xdc, 0x23, 0x09, 0xa7, 0x24, 0xf6, 0x53, 0x4a, 0x38, 0x41, 0xab, 0x43, 0x4f, 0xb9, 0xab, 0x60, 0xb9, 0x47, 0x13, 0xc1, 0xe8, 0x30, 0x48, 0x19, 0x15, 0x14, 0xad, 0x8e,
0xd2, 0x3d, 0xf3, 0xbb, 0xa3, 0x28, 0xee, 0x9f, 0x44, 0xdc, 0x3f, 0x7d, 0xe0, 0xde, 0x1f, 0x44, 0x68, 0x77, 0x1c, 0x74, 0xb3, 0x78, 0xd8, 0x3f, 0x8e, 0x45, 0x70, 0xf2, 0xc0, 0xbb, 0x3f, 0x88,
0xfc, 0xc5, 0xa8, 0xeb, 0xf7, 0xc8, 0xb0, 0x35, 0x20, 0x03, 0xd2, 0x92, 0xc0, 0xee, 0xe8, 0x58, 0xc5, 0xcb, 0xac, 0x1b, 0xf4, 0xe8, 0x28, 0x1c, 0xd0, 0x01, 0x0d, 0x15, 0xb0, 0x9b, 0x1d, 0x29,
0x4a, 0x52, 0x90, 0x27, 0x45, 0xe0, 0xae, 0x0f, 0x08, 0x19, 0xc4, 0x78, 0x82, 0xe2, 0xd1, 0x10, 0x4b, 0x19, 0xea, 0xa4, 0x09, 0xbc, 0xf5, 0x01, 0xa5, 0x83, 0x21, 0x99, 0xa2, 0x44, 0x3c, 0x22,
0x33, 0x1e, 0x0e, 0x53, 0x0d, 0xb8, 0x67, 0xf0, 0x89, 0x97, 0xb5, 0xb2, 0x97, 0xb5, 0x18, 0x89, 0x5c, 0x44, 0xa3, 0xd4, 0x00, 0xee, 0x59, 0x7c, 0xf2, 0x63, 0x61, 0xfe, 0xb1, 0x90, 0xd3, 0xe1,
0x4f, 0x31, 0x6d, 0xa5, 0xdd, 0x16, 0x49, 0x99, 0x42, 0x7b, 0x2b, 0x50, 0x3f, 0xa0, 0xa3, 0x04, 0x09, 0x61, 0x61, 0xda, 0x0d, 0x69, 0xca, 0x0d, 0x3a, 0xbc, 0x10, 0x1d, 0xa5, 0x71, 0x28, 0xc6,
0x07, 0xf8, 0xc7, 0x11, 0x66, 0xdc, 0xbb, 0x0b, 0xab, 0x9d, 0x88, 0x9d, 0x1c, 0xb1, 0x70, 0x90, 0x29, 0xe1, 0xe1, 0x8f, 0x94, 0x1d, 0x13, 0xa6, 0x03, 0xfc, 0x15, 0x68, 0x3c, 0x63, 0x59, 0x42,
0xe9, 0xd0, 0x1d, 0x28, 0x1f, 0x47, 0x31, 0xc7, 0xd4, 0xb1, 0x1a, 0x56, 0xd3, 0x0e, 0xb4, 0xe4, 0x30, 0xf9, 0x21, 0x23, 0x5c, 0xf8, 0x77, 0x61, 0xb5, 0x13, 0xf3, 0xe3, 0x43, 0x1e, 0x0d, 0x72,
0xed, 0xc2, 0xdb, 0x06, 0x96, 0xa5, 0x24, 0x61, 0x18, 0x3d, 0x84, 0x32, 0xc5, 0x3d, 0x42, 0xfb, 0x1f, 0xba, 0x03, 0xe5, 0xa3, 0x78, 0x28, 0x08, 0x73, 0x9d, 0xa6, 0xd3, 0xaa, 0x61, 0x63, 0xf9,
0x8e, 0xd5, 0x28, 0x36, 0x6b, 0x9b, 0x1f, 0xfa, 0xb3, 0x37, 0xf6, 0xb5, 0x81, 0x00, 0x05, 0x1a, 0xbb, 0xf0, 0x7f, 0x0b, 0xcb, 0x53, 0x9a, 0x70, 0x82, 0x1e, 0x42, 0x99, 0x91, 0x1e, 0x65, 0x7d,
0xec, 0xfd, 0x5e, 0x80, 0x9a, 0xa1, 0x47, 0x2b, 0x50, 0xd8, 0xe9, 0xe8, 0xf7, 0x15, 0x76, 0x3a, 0xd7, 0x69, 0x16, 0x5b, 0xf5, 0xcd, 0x0f, 0x83, 0xf3, 0x25, 0x0a, 0x4c, 0x80, 0x04, 0x61, 0x03,
0xc8, 0x81, 0xca, 0xfe, 0x88, 0x87, 0xdd, 0x18, 0x3b, 0x85, 0x86, 0xd5, 0xac, 0x06, 0x99, 0x88, 0xf6, 0x7f, 0x2f, 0x40, 0xdd, 0xf2, 0xa3, 0x15, 0x28, 0xec, 0x74, 0xcc, 0xf7, 0x0a, 0x3b, 0x1d,
0xde, 0x85, 0xa5, 0x9d, 0xe4, 0x88, 0x61, 0xa7, 0x28, 0xf5, 0x4a, 0x40, 0x08, 0x4a, 0x87, 0xd1, 0xe4, 0x42, 0x65, 0x3f, 0x13, 0x51, 0x77, 0x48, 0xdc, 0x42, 0xd3, 0x69, 0x55, 0x71, 0x6e, 0xa2,
0x4f, 0xd8, 0x29, 0x35, 0xac, 0x66, 0x31, 0x90, 0x67, 0x71, 0x8f, 0x83, 0x90, 0xe2, 0x84, 0x3b, 0x77, 0x61, 0x69, 0x27, 0x39, 0xe4, 0xc4, 0x2d, 0x2a, 0xbf, 0x36, 0x10, 0x82, 0xd2, 0x41, 0xfc,
0x4b, 0xea, 0x1e, 0x4a, 0x42, 0x6d, 0xb0, 0xb7, 0x29, 0x0e, 0x39, 0xee, 0x3f, 0xe1, 0x4e, 0xb9, 0x13, 0x71, 0x4b, 0x4d, 0xa7, 0x55, 0xc4, 0xea, 0x2c, 0xef, 0xf1, 0x2c, 0x62, 0x24, 0x11, 0xee,
0x61, 0x35, 0x6b, 0x9b, 0xae, 0xaf, 0xc2, 0xec, 0x67, 0x61, 0xf6, 0x9f, 0x65, 0x61, 0x6e, 0x57, 0x92, 0xbe, 0x87, 0xb6, 0x50, 0x1b, 0x6a, 0xdb, 0x8c, 0x44, 0x82, 0xf4, 0x9f, 0x08, 0xb7, 0xdc,
0x5f, 0x9d, 0xaf, 0xbf, 0xf5, 0xf3, 0xeb, 0x75, 0x2b, 0x98, 0x98, 0xa1, 0xc7, 0x00, 0x7b, 0x21, 0x74, 0x5a, 0xf5, 0x4d, 0x2f, 0xd0, 0xba, 0x04, 0xb9, 0x2e, 0xc1, 0xf3, 0x5c, 0x97, 0x76, 0xf5,
0xe3, 0x47, 0x4c, 0x92, 0x54, 0xae, 0x25, 0x29, 0x49, 0x02, 0xc3, 0x06, 0xad, 0x01, 0xc8, 0x00, 0xf5, 0xe9, 0xfa, 0xff, 0x7e, 0x7e, 0xb3, 0xee, 0xe0, 0x69, 0x18, 0x7a, 0x0c, 0xb0, 0x17, 0x71,
0x6c, 0x93, 0x51, 0xc2, 0x9d, 0xaa, 0xf4, 0xdb, 0xd0, 0xa0, 0x06, 0xd4, 0x3a, 0x98, 0xf5, 0x68, 0x71, 0xc8, 0x15, 0x49, 0xe5, 0x4a, 0x92, 0x92, 0x22, 0xb0, 0x62, 0xd0, 0x1a, 0x80, 0x2a, 0xc0,
0x94, 0xf2, 0x88, 0x24, 0x8e, 0x2d, 0xaf, 0x60, 0xaa, 0xbc, 0x5f, 0x4a, 0x50, 0x3f, 0x14, 0x39, 0x36, 0xcd, 0x12, 0xe1, 0x56, 0x55, 0xde, 0x96, 0x07, 0x35, 0xa1, 0xde, 0x21, 0xbc, 0xc7, 0xe2,
0xce, 0x12, 0xb7, 0x0a, 0xc5, 0x00, 0x1f, 0xeb, 0x28, 0x8a, 0x23, 0xf2, 0x01, 0x3a, 0xf8, 0x38, 0x54, 0xc4, 0x34, 0x71, 0x6b, 0xea, 0x0a, 0xb6, 0xcb, 0xff, 0xa5, 0x04, 0x8d, 0x03, 0xd9, 0x14,
0x4a, 0x22, 0xc9, 0x51, 0x90, 0x6e, 0xae, 0xf8, 0x69, 0xd7, 0x9f, 0x68, 0x03, 0x03, 0x81, 0x5c, 0xb9, 0x70, 0xab, 0x50, 0xc4, 0xe4, 0xc8, 0x54, 0x51, 0x1e, 0x51, 0x00, 0xd0, 0x21, 0x47, 0x71,
0xa8, 0x3e, 0x7d, 0x99, 0x12, 0x2a, 0x92, 0x5f, 0x94, 0x34, 0x63, 0x19, 0x3d, 0x87, 0xe5, 0xec, 0x12, 0x2b, 0x8e, 0x82, 0x4a, 0x73, 0x25, 0x48, 0xbb, 0xc1, 0xd4, 0x8b, 0x2d, 0x04, 0xf2, 0xa0,
0xfc, 0x84, 0x73, 0xca, 0x9c, 0x92, 0x4c, 0xf8, 0x83, 0x7c, 0xc2, 0x4d, 0xa7, 0xfc, 0x29, 0x9b, 0xfa, 0xf4, 0x55, 0x4a, 0x99, 0x14, 0xbf, 0xa8, 0x68, 0x26, 0x36, 0x7a, 0x01, 0xcb, 0xf9, 0xf9,
0xa7, 0x09, 0xa7, 0x67, 0xc1, 0x34, 0x8f, 0xc8, 0xf5, 0x21, 0x66, 0x4c, 0x78, 0xa8, 0x12, 0x95, 0x89, 0x10, 0x8c, 0xbb, 0x25, 0x25, 0xf8, 0x83, 0x79, 0xc1, 0xed, 0xa4, 0x82, 0x99, 0x98, 0xa7,
0x89, 0xc2, 0x9d, 0xaf, 0x29, 0x49, 0x38, 0x4e, 0xfa, 0x32, 0x51, 0x76, 0x30, 0x96, 0x85, 0x3b, 0x89, 0x60, 0x63, 0x3c, 0xcb, 0x23, 0xb5, 0x3e, 0x20, 0x9c, 0xcb, 0x0c, 0xb5, 0x50, 0xb9, 0x29,
0xd9, 0x59, 0xb9, 0x53, 0xb9, 0x91, 0x3b, 0x53, 0x36, 0xda, 0x9d, 0x29, 0x1d, 0xda, 0x82, 0xa5, 0xd3, 0xf9, 0x8a, 0xd1, 0x44, 0x90, 0xa4, 0xaf, 0x84, 0xaa, 0xe1, 0x89, 0x2d, 0xd3, 0xc9, 0xcf,
0xed, 0xb0, 0xf7, 0x02, 0xcb, 0x9c, 0xd4, 0x36, 0xd7, 0xf2, 0x84, 0xf2, 0xf1, 0xb7, 0x32, 0x09, 0x3a, 0x9d, 0xca, 0xb5, 0xd2, 0x99, 0x89, 0x31, 0xe9, 0xcc, 0xf8, 0xd0, 0x16, 0x2c, 0x6d, 0x47,
0xac, 0x5d, 0x12, 0xe5, 0x11, 0x28, 0x13, 0xf7, 0x31, 0xa0, 0xfc, 0x7d, 0x45, 0x5e, 0x4e, 0xf0, 0xbd, 0x97, 0x44, 0x69, 0x52, 0xdf, 0x5c, 0x9b, 0x27, 0x54, 0xff, 0xfe, 0x46, 0x89, 0xc0, 0xdb,
0x59, 0x96, 0x97, 0x13, 0x7c, 0x26, 0x8a, 0xf8, 0x34, 0x8c, 0x47, 0xaa, 0xb8, 0xed, 0x40, 0x09, 0x25, 0xd9, 0x1e, 0x58, 0x87, 0x78, 0x8f, 0x01, 0xcd, 0xdf, 0x57, 0xea, 0x72, 0x4c, 0xc6, 0xb9,
0x5b, 0x85, 0x2f, 0x2d, 0xc1, 0x90, 0x77, 0x71, 0x11, 0x06, 0xef, 0xb5, 0x05, 0x75, 0xd3, 0x43, 0x2e, 0xc7, 0x64, 0x2c, 0x9b, 0xf8, 0x24, 0x1a, 0x66, 0xba, 0xb9, 0x6b, 0x58, 0x1b, 0x5b, 0x85,
0xf4, 0x01, 0xd8, 0xca, 0xa9, 0x49, 0x71, 0x4c, 0x14, 0xa2, 0x0e, 0x77, 0x86, 0x5a, 0x60, 0x4e, 0x2f, 0x1c, 0xc9, 0x30, 0x9f, 0xe2, 0x4d, 0x18, 0xfc, 0x37, 0x0e, 0x34, 0xec, 0x0c, 0xd1, 0x07,
0xa1, 0x51, 0x6c, 0xda, 0x81, 0xa1, 0x41, 0xdf, 0x41, 0x4d, 0x81, 0x55, 0x94, 0x8b, 0x32, 0xca, 0x50, 0xd3, 0x49, 0x4d, 0x9b, 0x63, 0xea, 0x90, 0x7d, 0xb8, 0x33, 0x32, 0x06, 0x77, 0x0b, 0xcd,
0xad, 0xab, 0x83, 0xe2, 0x1b, 0x16, 0x2a, 0xc6, 0x26, 0x87, 0xfb, 0x08, 0x56, 0x67, 0x01, 0x0b, 0x62, 0xab, 0x86, 0x2d, 0x0f, 0xfa, 0x16, 0xea, 0x1a, 0xac, 0xab, 0x5c, 0x54, 0x55, 0x0e, 0x2f,
0xdd, 0xf0, 0x37, 0x0b, 0x96, 0x75, 0x52, 0x75, 0x17, 0x0a, 0x33, 0x46, 0x4c, 0x33, 0x9d, 0xee, 0x2f, 0x4a, 0x60, 0x45, 0xe8, 0x1a, 0xdb, 0x1c, 0xde, 0x23, 0x58, 0x3d, 0x0f, 0xb8, 0xd1, 0x0d,
0x47, 0x0f, 0x2f, 0xad, 0x07, 0x05, 0xf3, 0x67, 0xed, 0x94, 0xbf, 0x39, 0x3a, 0x77, 0x1b, 0xde, 0x7f, 0x73, 0x60, 0xd9, 0x88, 0x6a, 0x5e, 0xa1, 0x28, 0x67, 0x24, 0x2c, 0xf7, 0x99, 0xf7, 0xe8,
0x9b, 0x0b, 0x5d, 0xc8, 0xf3, 0x8f, 0x60, 0xf9, 0x90, 0x87, 0x7c, 0xc4, 0x2e, 0xfd, 0x64, 0xbd, 0xe1, 0x85, 0xfd, 0xa0, 0x61, 0xc1, 0xf9, 0x38, 0x9d, 0xef, 0x1c, 0x9d, 0xb7, 0x0d, 0xef, 0x2d,
0x5f, 0x2d, 0x58, 0xc9, 0x30, 0xfa, 0x76, 0x9f, 0x43, 0xf5, 0x14, 0x53, 0x8e, 0x5f, 0x62, 0xa6, 0x84, 0xde, 0x28, 0xf3, 0x8f, 0x60, 0xf9, 0x40, 0x44, 0x22, 0xe3, 0x17, 0xfe, 0x64, 0xfd, 0x5f,
0x6f, 0xe5, 0xe4, 0x6f, 0xf5, 0xbd, 0x44, 0x04, 0x63, 0x24, 0xda, 0x82, 0x2a, 0x93, 0x3c, 0x58, 0x1d, 0x58, 0xc9, 0x31, 0xe6, 0x76, 0x9f, 0x43, 0xf5, 0x84, 0x30, 0x41, 0x5e, 0x11, 0x6e, 0x6e,
0xa5, 0x75, 0x6e, 0x29, 0x2b, 0x2b, 0xfd, 0xbe, 0x31, 0x1e, 0xb5, 0xa0, 0x14, 0x93, 0x41, 0x96, 0xe5, 0xce, 0xdf, 0xea, 0x3b, 0x85, 0xc0, 0x13, 0x24, 0xda, 0x82, 0x2a, 0x57, 0x3c, 0x44, 0xcb,
0xed, 0xf7, 0x2f, 0xb3, 0xdb, 0x23, 0x83, 0x40, 0x02, 0xbd, 0xf3, 0x02, 0x94, 0x95, 0x0e, 0xed, 0xba, 0xb0, 0x95, 0x75, 0x94, 0xf9, 0xde, 0x04, 0x8f, 0x42, 0x28, 0x0d, 0xe9, 0x20, 0x57, 0xfb,
0x42, 0xb9, 0x1f, 0x0d, 0x30, 0xe3, 0xea, 0x56, 0xed, 0x4d, 0xf1, 0x81, 0xfc, 0x7d, 0xbe, 0x7e, 0xfd, 0x8b, 0xe2, 0xf6, 0xe8, 0x00, 0x2b, 0xa0, 0x7f, 0x5a, 0x80, 0xb2, 0xf6, 0xa1, 0x5d, 0x28,
0xd7, 0x18, 0x54, 0x24, 0xc5, 0x89, 0x18, 0x94, 0x61, 0x94, 0x60, 0xca, 0x5a, 0x03, 0x72, 0x5f, 0xf7, 0xe3, 0x01, 0xe1, 0x42, 0xdf, 0xaa, 0xbd, 0x29, 0x7f, 0x20, 0x7f, 0x9d, 0xae, 0xdf, 0xb5,
0x99, 0xf8, 0x1d, 0xf9, 0x13, 0x68, 0x06, 0xc1, 0x15, 0x25, 0xe9, 0x88, 0xeb, 0xc2, 0xbc, 0x1d, 0x66, 0x15, 0x4d, 0x49, 0x22, 0x27, 0x6b, 0x14, 0x27, 0x84, 0xf1, 0x70, 0x40, 0xef, 0xeb, 0x90,
0x97, 0x62, 0x10, 0x23, 0x22, 0x09, 0x87, 0x58, 0xf7, 0x35, 0x79, 0x16, 0x23, 0xa2, 0x27, 0xea, 0xa0, 0xa3, 0xfe, 0x60, 0xc3, 0x20, 0xb9, 0xe2, 0x24, 0xcd, 0x84, 0x69, 0xcc, 0xdb, 0x71, 0x69,
0xb6, 0x2f, 0x07, 0x47, 0x35, 0xd0, 0x12, 0xda, 0x82, 0x0a, 0xe3, 0x21, 0xe5, 0xb8, 0x2f, 0x5b, 0x06, 0x39, 0x22, 0x92, 0x68, 0x44, 0xcc, 0xbb, 0xa6, 0xce, 0x72, 0x44, 0xf4, 0x64, 0xdf, 0xf6,
0xd2, 0x4d, 0x7a, 0x7b, 0x66, 0x80, 0x1e, 0x81, 0xdd, 0x23, 0xc3, 0x34, 0xc6, 0xc2, 0xba, 0x7c, 0xd5, 0xe0, 0xa8, 0x62, 0x63, 0xa1, 0x2d, 0xa8, 0x70, 0x11, 0x31, 0x41, 0xfa, 0xea, 0x49, 0xba,
0x43, 0xeb, 0x89, 0x89, 0xa8, 0x1e, 0x4c, 0x29, 0xa1, 0x72, 0xaa, 0xd8, 0x81, 0x12, 0xbc, 0xff, 0xce, 0xdb, 0x9e, 0x07, 0xa0, 0x47, 0x50, 0xeb, 0xd1, 0x51, 0x3a, 0x24, 0x32, 0xba, 0x7c, 0xcd,
0x0a, 0x50, 0x37, 0x93, 0x95, 0x9b, 0x98, 0xbb, 0x50, 0x56, 0xa9, 0x57, 0x55, 0x77, 0xbb, 0x50, 0xe8, 0x69, 0x88, 0xec, 0x1e, 0xc2, 0x18, 0x65, 0x6a, 0xaa, 0xd4, 0xb0, 0x36, 0xfc, 0x7f, 0x0b,
0x29, 0x86, 0xb9, 0xa1, 0x72, 0xa0, 0xd2, 0x1b, 0x51, 0x39, 0x4e, 0xd5, 0x90, 0xcd, 0x44, 0xe1, 0xd0, 0xb0, 0xc5, 0x9a, 0x9b, 0x98, 0xbb, 0x50, 0xd6, 0xd2, 0xeb, 0xae, 0xbb, 0x5d, 0xa9, 0x34,
0x30, 0x27, 0x3c, 0x8c, 0x65, 0xa8, 0x8a, 0x81, 0x12, 0xc4, 0x94, 0x1d, 0xaf, 0x2a, 0x8b, 0x4d, 0xc3, 0xc2, 0x52, 0xb9, 0x50, 0xe9, 0x65, 0x4c, 0x8d, 0x53, 0x3d, 0x64, 0x73, 0x53, 0x26, 0x2c,
0xd9, 0xb1, 0x99, 0x99, 0x86, 0xca, 0x1b, 0xa5, 0xa1, 0xba, 0x70, 0x1a, 0xbc, 0x3f, 0x2c, 0xb0, 0xa8, 0x88, 0x86, 0xaa, 0x54, 0x45, 0xac, 0x0d, 0x39, 0x65, 0x27, 0xbb, 0xcd, 0xcd, 0xa6, 0xec,
0xc7, 0x55, 0x6e, 0x44, 0xd7, 0x7a, 0xe3, 0xe8, 0x4e, 0x45, 0xa6, 0x70, 0xbb, 0xc8, 0xdc, 0x81, 0x24, 0xcc, 0x96, 0xa1, 0xf2, 0x56, 0x32, 0x54, 0x6f, 0x2c, 0x83, 0xff, 0x87, 0x03, 0xb5, 0x49,
0x32, 0xe3, 0x14, 0x87, 0x43, 0x99, 0xa3, 0x62, 0xa0, 0x25, 0xd1, 0x4f, 0x86, 0x6c, 0x20, 0x33, 0x97, 0x5b, 0xd5, 0x75, 0xde, 0xba, 0xba, 0x33, 0x95, 0x29, 0xdc, 0xae, 0x32, 0x77, 0xa0, 0xcc,
0x54, 0x0f, 0xc4, 0xd1, 0xf3, 0xa0, 0xde, 0x3e, 0xe3, 0x98, 0xed, 0x63, 0x26, 0x96, 0x0b, 0x91, 0x05, 0x23, 0xd1, 0x48, 0x69, 0x54, 0xc4, 0xc6, 0x92, 0xef, 0xc9, 0x88, 0x0f, 0x94, 0x42, 0x0d,
0xdb, 0x7e, 0xc8, 0x43, 0x79, 0x8f, 0x7a, 0x20, 0xcf, 0xde, 0x3d, 0x40, 0x7b, 0x11, 0xe3, 0xcf, 0x2c, 0x8f, 0xbe, 0x0f, 0x8d, 0xf6, 0x58, 0x10, 0xbe, 0x4f, 0xb8, 0x5c, 0x2e, 0xa4, 0xb6, 0xfd,
0x09, 0x3d, 0xc1, 0x94, 0xcd, 0xdb, 0x03, 0x8b, 0xc6, 0x1e, 0xb8, 0x0f, 0xef, 0x4c, 0xa1, 0x75, 0x48, 0x44, 0xea, 0x1e, 0x0d, 0xac, 0xce, 0xfe, 0x3d, 0x40, 0x7b, 0x31, 0x17, 0x2f, 0xd4, 0xa6,
0x97, 0xfa, 0x62, 0x66, 0x13, 0x9c, 0xd3, 0x6d, 0x94, 0xc9, 0xcc, 0x2a, 0xf8, 0xa7, 0x05, 0x75, 0xc8, 0x17, 0xed, 0x81, 0x45, 0x6b, 0x0f, 0x3c, 0x80, 0x77, 0x66, 0xd0, 0xe6, 0x95, 0xfa, 0xf2,
0xf3, 0x41, 0xae, 0xb2, 0xdb, 0x50, 0xde, 0x0b, 0xbb, 0x38, 0xce, 0xda, 0xd8, 0xdd, 0xab, 0x89, 0xdc, 0x26, 0xf8, 0xc9, 0xfc, 0xab, 0xa1, 0x16, 0xd2, 0x40, 0x07, 0xce, 0x2e, 0x84, 0x9b, 0xff,
0x7d, 0x05, 0x56, 0x7d, 0x5c, 0x5b, 0xa2, 0x0d, 0xb0, 0xd3, 0x38, 0xe4, 0xc7, 0x84, 0x0e, 0xb3, 0x14, 0xa1, 0xb2, 0xad, 0x77, 0x6d, 0xf4, 0x1c, 0x6a, 0x93, 0x45, 0x13, 0xf9, 0xf3, 0x34, 0xe7,
0xae, 0x56, 0x17, 0x7b, 0xd0, 0x81, 0x56, 0xea, 0x31, 0x3e, 0x01, 0xb9, 0x5f, 0x41, 0xcd, 0x20, 0x37, 0x56, 0xef, 0xe3, 0x4b, 0x31, 0x26, 0xbf, 0xaf, 0x61, 0x49, 0xad, 0xbe, 0x68, 0xc1, 0x33,
0x5a, 0xa4, 0xcb, 0x6f, 0xfe, 0x5b, 0x84, 0xca, 0xb6, 0xfa, 0x1b, 0x80, 0x9e, 0x81, 0x3d, 0x5e, 0x68, 0xef, 0xc4, 0xde, 0xe5, 0x2b, 0xec, 0x86, 0x23, 0x99, 0xd4, 0x0c, 0x59, 0xc4, 0x64, 0x2f,
0x9a, 0x91, 0x97, 0xf7, 0x7c, 0x76, 0xfb, 0x76, 0x3f, 0xbe, 0x12, 0xa3, 0x63, 0xfd, 0x0d, 0x2c, 0x1b, 0xde, 0xfa, 0x15, 0xc3, 0x07, 0xed, 0x43, 0xd9, 0xfc, 0x9c, 0x17, 0x41, 0xed, 0x49, 0xe1,
0xc9, 0x35, 0x1e, 0xcd, 0x09, 0xb2, 0xb9, 0xdf, 0xbb, 0x57, 0xaf, 0xe3, 0x1b, 0x96, 0x60, 0x92, 0x35, 0x2f, 0x06, 0x68, 0xb2, 0x0d, 0x07, 0xed, 0x4f, 0x36, 0xa9, 0x45, 0xa9, 0xd9, 0x6d, 0xe0,
0xf3, 0x70, 0x1e, 0x93, 0xb9, 0x38, 0xb9, 0xeb, 0xd7, 0x0c, 0x52, 0xb4, 0x0f, 0x65, 0xdd, 0x9a, 0x5d, 0xf1, 0xff, 0x96, 0xb3, 0xe1, 0xa0, 0xef, 0xa1, 0x6e, 0x09, 0x8d, 0x16, 0x08, 0x3a, 0xdf,
0xe6, 0x41, 0xcd, 0xa9, 0xe7, 0x36, 0x2e, 0x07, 0x28, 0xb2, 0x0d, 0x0b, 0xed, 0x8f, 0xb7, 0xc2, 0x35, 0xde, 0xa7, 0x57, 0xa0, 0x74, 0xb2, 0xed, 0xc6, 0xeb, 0xb3, 0x35, 0xe7, 0xcf, 0xb3, 0x35,
0x79, 0xae, 0x99, 0x25, 0xed, 0x5e, 0xf3, 0xbc, 0x69, 0x6d, 0x58, 0xe8, 0x07, 0xa8, 0x19, 0x45, 0xe7, 0xef, 0xb3, 0x35, 0xa7, 0x5b, 0x56, 0x7d, 0xff, 0xd9, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff,
0x8b, 0x3e, 0xc9, 0x9b, 0xe4, 0xbf, 0x00, 0xf7, 0xd3, 0x6b, 0x50, 0xca, 0xd9, 0x76, 0xfd, 0xd5, 0xe1, 0xef, 0xcc, 0xf5, 0x6f, 0x0d, 0x00, 0x00,
0xc5, 0x9a, 0xf5, 0xd7, 0xc5, 0x9a, 0xf5, 0xcf, 0xc5, 0x9a, 0xd5, 0x2d, 0xcb, 0x6f, 0xf8, 0xb3,
0xff, 0x03, 0x00, 0x00, 0xff, 0xff, 0x86, 0xd4, 0x0f, 0xa1, 0x0a, 0x0e, 0x00, 0x00,
} }

9
api/services/control/control.proto
View File

@ -8,6 +8,7 @@ package moby.buildkit.v1;
import "github.com/gogo/protobuf/gogoproto/gogo.proto"; import "github.com/gogo/protobuf/gogoproto/gogo.proto";
import "google/protobuf/timestamp.proto"; import "google/protobuf/timestamp.proto";
import "github.com/moby/buildkit/solver/pb/ops.proto"; import "github.com/moby/buildkit/solver/pb/ops.proto";
import "github.com/moby/buildkit/api/types/worker.proto";
option (gogoproto.sizer_all) = true; option (gogoproto.sizer_all) = true;
option (gogoproto.marshaler_all) = true; option (gogoproto.marshaler_all) = true;
@ -116,11 +117,5 @@ message ListWorkersRequest {
} }
message ListWorkersResponse { message ListWorkersResponse {
repeated WorkerRecord record = 1; repeated moby.buildkit.v1.types.WorkerRecord record = 1;
}
message WorkerRecord {
string ID = 1;
map<string, string> Labels = 2;
repeated pb.Platform platforms = 3 [(gogoproto.nullable) = false];
} }

3
api/types/generate.go Normal file
View File

@ -0,0 +1,3 @@
package moby_buildkit_v1_types
//go:generate protoc -I=. -I=../../vendor/ -I=../../../../../ --gogo_out=plugins=grpc:. worker.proto

523
api/types/worker.pb.go Normal file
View File

@ -0,0 +1,523 @@
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: worker.proto
/*
Package moby_buildkit_v1_types is a generated protocol buffer package.
It is generated from these files:
worker.proto
It has these top-level messages:
WorkerRecord
*/
package moby_buildkit_v1_types
import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"
import pb "github.com/moby/buildkit/solver/pb"
import io "io"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
type WorkerRecord struct {
ID string `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"`
Labels map[string]string `protobuf:"bytes,2,rep,name=Labels" json:"Labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
Platforms []pb.Platform `protobuf:"bytes,3,rep,name=platforms" json:"platforms"`
}
func (m *WorkerRecord) Reset() { *m = WorkerRecord{} }
func (m *WorkerRecord) String() string { return proto.CompactTextString(m) }
func (*WorkerRecord) ProtoMessage() {}
func (*WorkerRecord) Descriptor() ([]byte, []int) { return fileDescriptorWorker, []int{0} }
func (m *WorkerRecord) GetID() string {
if m != nil {
return m.ID
}
return ""
}
func (m *WorkerRecord) GetLabels() map[string]string {
if m != nil {
return m.Labels
}
return nil
}
func (m *WorkerRecord) GetPlatforms() []pb.Platform {
if m != nil {
return m.Platforms
}
return nil
}
func init() {
proto.RegisterType((*WorkerRecord)(nil), "moby.buildkit.v1.types.WorkerRecord")
}
func (m *WorkerRecord) 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 *WorkerRecord) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if len(m.ID) > 0 {
dAtA[i] = 0xa
i++
i = encodeVarintWorker(dAtA, i, uint64(len(m.ID)))
i += copy(dAtA[i:], m.ID)
}
if len(m.Labels) > 0 {
for k, _ := range m.Labels {
dAtA[i] = 0x12
i++
v := m.Labels[k]
mapSize := 1 + len(k) + sovWorker(uint64(len(k))) + 1 + len(v) + sovWorker(uint64(len(v)))
i = encodeVarintWorker(dAtA, i, uint64(mapSize))
dAtA[i] = 0xa
i++
i = encodeVarintWorker(dAtA, i, uint64(len(k)))
i += copy(dAtA[i:], k)
dAtA[i] = 0x12
i++
i = encodeVarintWorker(dAtA, i, uint64(len(v)))
i += copy(dAtA[i:], v)
}
}
if len(m.Platforms) > 0 {
for _, msg := range m.Platforms {
dAtA[i] = 0x1a
i++
i = encodeVarintWorker(dAtA, i, uint64(msg.Size()))
n, err := msg.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n
}
}
return i, nil
}
func encodeVarintWorker(dAtA []byte, offset int, v uint64) int {
for v >= 1<<7 {
dAtA[offset] = uint8(v&0x7f | 0x80)
v >>= 7
offset++
}
dAtA[offset] = uint8(v)
return offset + 1
}
func (m *WorkerRecord) Size() (n int) {
var l int
_ = l
l = len(m.ID)
if l > 0 {
n += 1 + l + sovWorker(uint64(l))
}
if len(m.Labels) > 0 {
for k, v := range m.Labels {
_ = k
_ = v
mapEntrySize := 1 + len(k) + sovWorker(uint64(len(k))) + 1 + len(v) + sovWorker(uint64(len(v)))
n += mapEntrySize + 1 + sovWorker(uint64(mapEntrySize))
}
}
if len(m.Platforms) > 0 {
for _, e := range m.Platforms {
l = e.Size()
n += 1 + l + sovWorker(uint64(l))
}
}
return n
}
func sovWorker(x uint64) (n int) {
for {
n++
x >>= 7
if x == 0 {
break
}
}
return n
}
func sozWorker(x uint64) (n int) {
return sovWorker(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *WorkerRecord) 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 ErrIntOverflowWorker
}
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: WorkerRecord: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: WorkerRecord: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowWorker
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthWorker
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.ID = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowWorker
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthWorker
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Labels == nil {
m.Labels = make(map[string]string)
}
var mapkey string
var mapvalue string
for iNdEx < postIndex {
entryPreIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowWorker
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
if fieldNum == 1 {
var stringLenmapkey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowWorker
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLenmapkey |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLenmapkey := int(stringLenmapkey)
if intStringLenmapkey < 0 {
return ErrInvalidLengthWorker
}
postStringIndexmapkey := iNdEx + intStringLenmapkey
if postStringIndexmapkey > l {
return io.ErrUnexpectedEOF
}
mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
iNdEx = postStringIndexmapkey
} else if fieldNum == 2 {
var stringLenmapvalue uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowWorker
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLenmapvalue |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLenmapvalue := int(stringLenmapvalue)
if intStringLenmapvalue < 0 {
return ErrInvalidLengthWorker
}
postStringIndexmapvalue := iNdEx + intStringLenmapvalue
if postStringIndexmapvalue > l {
return io.ErrUnexpectedEOF
}
mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
iNdEx = postStringIndexmapvalue
} else {
iNdEx = entryPreIndex
skippy, err := skipWorker(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthWorker
}
if (iNdEx + skippy) > postIndex {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
m.Labels[mapkey] = mapvalue
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Platforms", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowWorker
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthWorker
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Platforms = append(m.Platforms, pb.Platform{})
if err := m.Platforms[len(m.Platforms)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipWorker(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthWorker
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func skipWorker(dAtA []byte) (n int, err error) {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowWorker
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
wireType := int(wire & 0x7)
switch wireType {
case 0:
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowWorker
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
iNdEx++
if dAtA[iNdEx-1] < 0x80 {
break
}
}
return iNdEx, nil
case 1:
iNdEx += 8
return iNdEx, nil
case 2:
var length int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowWorker
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
length |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
iNdEx += length
if length < 0 {
return 0, ErrInvalidLengthWorker
}
return iNdEx, nil
case 3:
for {
var innerWire uint64
var start int = iNdEx
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowWorker
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
innerWire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
innerWireType := int(innerWire & 0x7)
if innerWireType == 4 {
break
}
next, err := skipWorker(dAtA[start:])
if err != nil {
return 0, err
}
iNdEx = start + next
}
return iNdEx, nil
case 4:
return iNdEx, nil
case 5:
iNdEx += 4
return iNdEx, nil
default:
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
}
}
panic("unreachable")
}
var (
ErrInvalidLengthWorker = fmt.Errorf("proto: negative length found during unmarshaling")
ErrIntOverflowWorker = fmt.Errorf("proto: integer overflow")
)
func init() { proto.RegisterFile("worker.proto", fileDescriptorWorker) }
var fileDescriptorWorker = []byte{
// 273 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x8f, 0x41, 0x4b, 0xf3, 0x40,
0x10, 0x86, 0xbf, 0x4d, 0x3e, 0x0b, 0xdd, 0x06, 0x91, 0x45, 0x24, 0xe4, 0x10, 0x8b, 0xa7, 0x1e,
0x74, 0xb6, 0xea, 0x45, 0x3d, 0x96, 0x0a, 0x16, 0x3c, 0x48, 0x2e, 0x9e, 0xb3, 0xed, 0x36, 0x86,
0x24, 0xce, 0xb2, 0xd9, 0x44, 0xf2, 0x0f, 0x7b, 0xf4, 0xe2, 0x55, 0x24, 0xbf, 0x44, 0xba, 0x89,
0x98, 0x83, 0xb7, 0x79, 0x87, 0x67, 0x1e, 0xde, 0xa1, 0xde, 0x1b, 0xea, 0x4c, 0x6a, 0x50, 0x1a,
0x0d, 0xb2, 0x93, 0x02, 0x45, 0x03, 0xa2, 0x4a, 0xf3, 0x4d, 0x96, 0x1a, 0xa8, 0x2f, 0xc1, 0x34,
0x4a, 0x96, 0xc1, 0x45, 0x92, 0x9a, 0x97, 0x4a, 0xc0, 0x1a, 0x0b, 0x9e, 0x60, 0x82, 0xdc, 0xe2,
0xa2, 0xda, 0xda, 0x64, 0x83, 0x9d, 0x3a, 0x4d, 0x70, 0x3e, 0xc0, 0xf7, 0x46, 0xfe, 0x63, 0xe4,
0x25, 0xe6, 0xb5, 0xd4, 0x5c, 0x09, 0x8e, 0xaa, 0xec, 0xe8, 0xb3, 0x0f, 0x42, 0xbd, 0x67, 0xdb,
0x22, 0x92, 0x6b, 0xd4, 0x1b, 0x76, 0x48, 0x9d, 0xd5, 0xd2, 0x27, 0x53, 0x32, 0x1b, 0x47, 0xce,
0x6a, 0xc9, 0x1e, 0xe8, 0xe8, 0x31, 0x16, 0x32, 0x2f, 0x7d, 0x67, 0xea, 0xce, 0x26, 0x57, 0x73,
0xf8, 0xbb, 0x26, 0x0c, 0x2d, 0xd0, 0x9d, 0xdc, 0xbf, 0x1a, 0xdd, 0x44, 0xfd, 0x3d, 0x9b, 0xd3,
0xb1, 0xca, 0x63, 0xb3, 0x45, 0x5d, 0x94, 0xbe, 0x6b, 0x65, 0x1e, 0x28, 0x01, 0x4f, 0xfd, 0x72,
0xf1, 0x7f, 0xf7, 0x79, 0xfa, 0x2f, 0xfa, 0x85, 0x82, 0x5b, 0x3a, 0x19, 0x88, 0xd8, 0x11, 0x75,
0x33, 0xd9, 0xf4, 0xdd, 0xf6, 0x23, 0x3b, 0xa6, 0x07, 0x75, 0x9c, 0x57, 0xd2, 0x77, 0xec, 0xae,
0x0b, 0x77, 0xce, 0x0d, 0x59, 0x78, 0xbb, 0x36, 0x24, 0xef, 0x6d, 0x48, 0xbe, 0xda, 0x90, 0x88,
0x91, 0x7d, 0xf6, 0xfa, 0x3b, 0x00, 0x00, 0xff, 0xff, 0xa9, 0x5c, 0x8f, 0x26, 0x71, 0x01, 0x00,
0x00,
}

16
api/types/worker.proto Normal file
View File

@ -0,0 +1,16 @@
syntax = "proto3";
package moby.buildkit.v1.types;
import "github.com/gogo/protobuf/gogoproto/gogo.proto";
import "github.com/moby/buildkit/solver/pb/ops.proto";
option (gogoproto.sizer_all) = true;
option (gogoproto.marshaler_all) = true;
option (gogoproto.unmarshaler_all) = true;
message WorkerRecord {
string ID = 1;
map<string, string> Labels = 2;
repeated pb.Platform platforms = 3 [(gogoproto.nullable) = false];
}

16
client/workers.go
View File

@ -33,7 +33,7 @@ func (c *Client) ListWorkers(ctx context.Context, opts ...ListWorkersOption) ([]
wi = append(wi, &WorkerInfo{ wi = append(wi, &WorkerInfo{
ID: w.ID, ID: w.ID,
Labels: w.Labels, Labels: w.Labels,
Platforms: toClientPlatforms(w.Platforms), Platforms: pb.ToSpecPlatforms(w.Platforms),
}) })
} }
@ -51,17 +51,3 @@ func WithWorkerFilter(f []string) ListWorkersOption {
wi.Filter = f wi.Filter = f
} }
} }
func toClientPlatforms(p []pb.Platform) []specs.Platform {
out := make([]specs.Platform, 0, len(p))
for _, pp := range p {
out = append(out, specs.Platform{
OS: pp.OS,
Architecture: pp.Architecture,
Variant: pp.Variant,
OSVersion: pp.OSVersion,
OSFeatures: pp.OSFeatures,
})
}
return out
}

2
cmd/buildkitd/main.go
View File

@ -379,7 +379,7 @@ func newController(c *cli.Context, root string) (*control.Controller, error) {
} }
frontends := map[string]frontend.Frontend{} frontends := map[string]frontend.Frontend{}
frontends["dockerfile.v0"] = dockerfile.NewDockerfileFrontend() frontends["dockerfile.v0"] = dockerfile.NewDockerfileFrontend()
frontends["gateway.v0"] = gateway.NewGatewayFrontend() frontends["gateway.v0"] = gateway.NewGatewayFrontend(wc)
cacheStorage, err := boltdbcachestorage.NewStore(filepath.Join(root, "cache.db")) cacheStorage, err := boltdbcachestorage.NewStore(filepath.Join(root, "cache.db"))
if err != nil { if err != nil {

20
control/control.go
View File

@ -5,6 +5,7 @@ import (
"github.com/docker/distribution/reference" "github.com/docker/distribution/reference"
controlapi "github.com/moby/buildkit/api/services/control" controlapi "github.com/moby/buildkit/api/services/control"
apitypes "github.com/moby/buildkit/api/types"
"github.com/moby/buildkit/cache/remotecache" "github.com/moby/buildkit/cache/remotecache"
"github.com/moby/buildkit/client" "github.com/moby/buildkit/client"
"github.com/moby/buildkit/exporter" "github.com/moby/buildkit/exporter"
@ -15,7 +16,6 @@ import (
"github.com/moby/buildkit/solver/llbsolver" "github.com/moby/buildkit/solver/llbsolver"
"github.com/moby/buildkit/solver/pb" "github.com/moby/buildkit/solver/pb"
"github.com/moby/buildkit/worker" "github.com/moby/buildkit/worker"
specs "github.com/opencontainers/image-spec/specs-go/v1"
"github.com/pkg/errors" "github.com/pkg/errors"
"github.com/sirupsen/logrus" "github.com/sirupsen/logrus"
"golang.org/x/sync/errgroup" "golang.org/x/sync/errgroup"
@ -275,10 +275,10 @@ func (c *Controller) ListWorkers(ctx context.Context, r *controlapi.ListWorkersR
return nil, err return nil, err
} }
for _, w := range workers { for _, w := range workers {
resp.Record = append(resp.Record, &controlapi.WorkerRecord{ resp.Record = append(resp.Record, &apitypes.WorkerRecord{
ID: w.ID(), ID: w.ID(),
Labels: w.Labels(), Labels: w.Labels(),
Platforms: toPBPlatforms(w.Platforms()), Platforms: pb.PlatformsFromSpec(w.Platforms()),
}) })
} }
return resp, nil return resp, nil
@ -302,17 +302,3 @@ func parseCacheExporterOpt(opt map[string]string) solver.CacheExportMode {
} }
return solver.CacheExportModeMin return solver.CacheExportModeMin
} }
func toPBPlatforms(p []specs.Platform) []pb.Platform {
out := make([]pb.Platform, 0, len(p))
for _, pp := range p {
out = append(out, pb.Platform{
OS: pp.OS,
Architecture: pp.Architecture,
Variant: pp.Variant,
OSVersion: pp.OSVersion,
OSFeatures: pp.OSFeatures,
})
}
return out
}

5
frontend/frontend.go
View File

@ -5,6 +5,7 @@ import (
"io" "io"
"github.com/moby/buildkit/cache" "github.com/moby/buildkit/cache"
"github.com/moby/buildkit/client"
"github.com/moby/buildkit/executor" "github.com/moby/buildkit/executor"
"github.com/moby/buildkit/solver" "github.com/moby/buildkit/solver"
"github.com/moby/buildkit/solver/pb" "github.com/moby/buildkit/solver/pb"
@ -28,3 +29,7 @@ type SolveRequest struct {
FrontendOpt map[string]string FrontendOpt map[string]string
ImportCacheRefs []string // TODO: map[string]string for supporting non-registry ref? ImportCacheRefs []string // TODO: map[string]string for supporting non-registry ref?
} }
type WorkerInfos interface {
WorkerInfos() []client.WorkerInfo
}

29
frontend/gateway/gateway.go
View File

@ -12,6 +12,7 @@ import (
"time" "time"
"github.com/docker/distribution/reference" "github.com/docker/distribution/reference"
apitypes "github.com/moby/buildkit/api/types"
"github.com/moby/buildkit/cache" "github.com/moby/buildkit/cache"
"github.com/moby/buildkit/client/llb" "github.com/moby/buildkit/client/llb"
"github.com/moby/buildkit/executor" "github.com/moby/buildkit/executor"
@ -20,6 +21,7 @@ import (
"github.com/moby/buildkit/identity" "github.com/moby/buildkit/identity"
"github.com/moby/buildkit/session" "github.com/moby/buildkit/session"
"github.com/moby/buildkit/solver" "github.com/moby/buildkit/solver"
opspb "github.com/moby/buildkit/solver/pb"
"github.com/moby/buildkit/util/tracing" "github.com/moby/buildkit/util/tracing"
"github.com/moby/buildkit/worker" "github.com/moby/buildkit/worker"
specs "github.com/opencontainers/image-spec/specs-go/v1" specs "github.com/opencontainers/image-spec/specs-go/v1"
@ -37,11 +39,14 @@ const (
exporterImageConfig = "containerimage.config" exporterImageConfig = "containerimage.config"
) )
func NewGatewayFrontend() frontend.Frontend { func NewGatewayFrontend(w frontend.WorkerInfos) frontend.Frontend {
return &gatewayFrontend{} return &gatewayFrontend{
workers: w,
}
} }
type gatewayFrontend struct { type gatewayFrontend struct {
workers frontend.WorkerInfos
} }
func filterPrefix(opts map[string]string, pfx string) map[string]string { func filterPrefix(opts map[string]string, pfx string) map[string]string {
@ -132,7 +137,7 @@ func (gf *gatewayFrontend) Solve(ctx context.Context, llbBridge frontend.Fronten
rootFS = workerRef.ImmutableRef rootFS = workerRef.ImmutableRef
} }
lbf, err := newLLBBridgeForwarder(ctx, llbBridge) lbf, err := newLLBBridgeForwarder(ctx, llbBridge, gf.workers)
defer lbf.conn.Close() defer lbf.conn.Close()
if err != nil { if err != nil {
return nil, nil, err return nil, nil, err
@ -180,12 +185,13 @@ func (gf *gatewayFrontend) Solve(ctx context.Context, llbBridge frontend.Fronten
return lbf.lastRef, lbf.exporterAttr, nil return lbf.lastRef, lbf.exporterAttr, nil
} }
func newLLBBridgeForwarder(ctx context.Context, llbBridge frontend.FrontendLLBBridge) (*llbBridgeForwarder, error) { func newLLBBridgeForwarder(ctx context.Context, llbBridge frontend.FrontendLLBBridge, workers frontend.WorkerInfos) (*llbBridgeForwarder, error) {
lbf := &llbBridgeForwarder{ lbf := &llbBridgeForwarder{
callCtx: ctx, callCtx: ctx,
llbBridge: llbBridge, llbBridge: llbBridge,
refs: map[string]solver.Result{}, refs: map[string]solver.Result{},
pipe: newPipe(), pipe: newPipe(),
workers: workers,
} }
server := grpc.NewServer() server := grpc.NewServer()
@ -257,6 +263,7 @@ type llbBridgeForwarder struct {
refs map[string]solver.Result refs map[string]solver.Result
lastRef solver.CachedResult lastRef solver.CachedResult
exporterAttr map[string][]byte exporterAttr map[string][]byte
workers frontend.WorkerInfos
*pipe *pipe
} }
@ -353,9 +360,21 @@ func (lbf *llbBridgeForwarder) ReadFile(ctx context.Context, req *pb.ReadFileReq
} }
func (lbf *llbBridgeForwarder) Ping(context.Context, *pb.PingRequest) (*pb.PongResponse, error) { func (lbf *llbBridgeForwarder) Ping(context.Context, *pb.PingRequest) (*pb.PongResponse, error) {
workers := lbf.workers.WorkerInfos()
pbWorkers := make([]*apitypes.WorkerRecord, 0, len(workers))
for _, w := range workers {
pbWorkers = append(pbWorkers, &apitypes.WorkerRecord{
ID: w.ID,
Labels: w.Labels,
Platforms: opspb.PlatformsFromSpec(w.Platforms),
})
}
return &pb.PongResponse{ return &pb.PongResponse{
FrontendAPICaps: pb.Caps.All(), FrontendAPICaps: pb.Caps.All(),
// FIXME: do not merge before llb & worker info Workers: pbWorkers,
// TODO: add LLB info
}, nil }, nil
} }

106
frontend/gateway/pb/gateway.pb.go
View File

@ -25,7 +25,7 @@ import fmt "fmt"
import math "math" import math "math"
import _ "github.com/gogo/protobuf/gogoproto" import _ "github.com/gogo/protobuf/gogoproto"
import pb "github.com/moby/buildkit/solver/pb" import pb "github.com/moby/buildkit/solver/pb"
import moby_buildkit_v1 "github.com/moby/buildkit/api/services/control" import moby_buildkit_v1_types "github.com/moby/buildkit/api/types"
import moby_buildkit_v1_apicaps "github.com/moby/buildkit/util/apicaps/pb" import moby_buildkit_v1_apicaps "github.com/moby/buildkit/util/apicaps/pb"
import github_com_opencontainers_go_digest "github.com/opencontainers/go-digest" import github_com_opencontainers_go_digest "github.com/opencontainers/go-digest"
@ -253,7 +253,7 @@ func (*PingRequest) Descriptor() ([]byte, []int) { return fileDescriptorGateway,
type PongResponse struct { type PongResponse struct {
FrontendAPICaps []moby_buildkit_v1_apicaps.APICap `protobuf:"bytes,1,rep,name=FrontendAPICaps" json:"FrontendAPICaps"` FrontendAPICaps []moby_buildkit_v1_apicaps.APICap `protobuf:"bytes,1,rep,name=FrontendAPICaps" json:"FrontendAPICaps"`
LLBCaps []moby_buildkit_v1_apicaps.APICap `protobuf:"bytes,2,rep,name=LLBCaps" json:"LLBCaps"` LLBCaps []moby_buildkit_v1_apicaps.APICap `protobuf:"bytes,2,rep,name=LLBCaps" json:"LLBCaps"`
Workers []*moby_buildkit_v1.WorkerRecord `protobuf:"bytes,3,rep,name=Workers" json:"Workers,omitempty"` Workers []*moby_buildkit_v1_types.WorkerRecord `protobuf:"bytes,3,rep,name=Workers" json:"Workers,omitempty"`
} }
func (m *PongResponse) Reset() { *m = PongResponse{} } func (m *PongResponse) Reset() { *m = PongResponse{} }
@ -275,7 +275,7 @@ func (m *PongResponse) GetLLBCaps() []moby_buildkit_v1_apicaps.APICap {
return nil return nil
} }
func (m *PongResponse) GetWorkers() []*moby_buildkit_v1.WorkerRecord { func (m *PongResponse) GetWorkers() []*moby_buildkit_v1_types.WorkerRecord {
if m != nil { if m != nil {
return m.Workers return m.Workers
} }
@ -2099,7 +2099,7 @@ func (m *PongResponse) Unmarshal(dAtA []byte) error {
if postIndex > l { if postIndex > l {
return io.ErrUnexpectedEOF return io.ErrUnexpectedEOF
} }
m.Workers = append(m.Workers, &moby_buildkit_v1.WorkerRecord{}) m.Workers = append(m.Workers, &moby_buildkit_v1_types.WorkerRecord{})
if err := m.Workers[len(m.Workers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { if err := m.Workers[len(m.Workers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err return err
} }
@ -2233,53 +2233,53 @@ var (
func init() { proto.RegisterFile("gateway.proto", fileDescriptorGateway) } func init() { proto.RegisterFile("gateway.proto", fileDescriptorGateway) }
var fileDescriptorGateway = []byte{ var fileDescriptorGateway = []byte{
// 756 bytes of a gzipped FileDescriptorProto // 754 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x55, 0x4d, 0x6b, 0xeb, 0x46, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x55, 0x4f, 0x4f, 0xeb, 0x46,
0x14, 0xad, 0x2c, 0x27, 0xcf, 0xbe, 0x76, 0x9a, 0x30, 0x94, 0xa2, 0xa7, 0x85, 0x9f, 0x11, 0xe5, 0x10, 0xaf, 0xe3, 0xc0, 0x4b, 0x26, 0xa1, 0xa0, 0x55, 0x55, 0xf9, 0xf9, 0xc0, 0x8b, 0xac, 0xea,
0x55, 0xa4, 0x8d, 0x44, 0x9d, 0x16, 0x42, 0x02, 0xa5, 0x71, 0x3e, 0x20, 0xc5, 0x10, 0x33, 0x5d, 0xd5, 0x7a, 0x2d, 0xb6, 0x1a, 0x5a, 0x09, 0x51, 0x09, 0x95, 0xf0, 0x47, 0xa2, 0x8a, 0x44, 0xb4,
0x04, 0xb2, 0x1b, 0xdb, 0x23, 0x65, 0xb0, 0xac, 0x51, 0xa5, 0xb1, 0x5b, 0xd3, 0x4d, 0xfb, 0x73, 0x3d, 0x20, 0x71, 0xdb, 0x24, 0x6b, 0xb3, 0x8a, 0xe3, 0x75, 0xed, 0x0d, 0x34, 0xea, 0xa5, 0xfd,
0xfa, 0x4f, 0xb2, 0xec, 0x3a, 0x94, 0x50, 0xf2, 0x4b, 0xca, 0x8c, 0x46, 0x8e, 0x62, 0xd7, 0x6e, 0x38, 0xfd, 0x26, 0x1c, 0x7b, 0xe6, 0x80, 0xaa, 0x7c, 0x92, 0x6a, 0xd7, 0xeb, 0x60, 0x12, 0x92,
0xb2, 0xd2, 0xdc, 0xeb, 0x73, 0xce, 0xdc, 0xab, 0x7b, 0xae, 0x0c, 0x3b, 0x21, 0x11, 0xf4, 0x17, 0x07, 0xa7, 0xec, 0x4c, 0xe6, 0xf7, 0x9b, 0x99, 0x9d, 0xdf, 0xac, 0x61, 0x2b, 0x24, 0x82, 0xde,
0x32, 0xf7, 0x92, 0x94, 0x0b, 0x8e, 0xde, 0x4f, 0xf8, 0x60, 0xee, 0x0d, 0xa6, 0x2c, 0x1a, 0x8d, 0x91, 0xa9, 0x97, 0xa4, 0x5c, 0x70, 0xf4, 0x7e, 0xcc, 0xfb, 0x53, 0xaf, 0x3f, 0x61, 0xd1, 0x70,
0x99, 0xf0, 0x66, 0xdf, 0x78, 0x41, 0xca, 0x63, 0x41, 0xe3, 0x91, 0x7d, 0x10, 0x32, 0x71, 0x37, 0xc4, 0x84, 0x77, 0xfb, 0x83, 0x17, 0xa4, 0x3c, 0x16, 0x34, 0x1e, 0xda, 0x7b, 0x21, 0x13, 0x37,
0x1d, 0x78, 0x43, 0x3e, 0xf1, 0x43, 0x1e, 0x72, 0x5f, 0x31, 0x06, 0xd3, 0x40, 0x45, 0x2a, 0x50, 0x93, 0xbe, 0x37, 0xe0, 0x63, 0x3f, 0xe4, 0x21, 0xf7, 0x15, 0xa2, 0x3f, 0x09, 0x94, 0xa5, 0x0c,
0xa7, 0x5c, 0xc9, 0xfe, 0xba, 0x04, 0x97, 0xa2, 0x7e, 0x21, 0xea, 0x67, 0x3c, 0x9a, 0xd1, 0xd4, 0x75, 0xca, 0x99, 0xec, 0xef, 0x4b, 0xe1, 0x92, 0xd4, 0x2f, 0x48, 0xfd, 0x8c, 0x47, 0xb7, 0x34,
0x4f, 0x06, 0x3e, 0x4f, 0x32, 0x8d, 0x3e, 0x59, 0x8b, 0x26, 0x09, 0xf3, 0x33, 0x9a, 0xce, 0xd8, 0xf5, 0x93, 0xbe, 0xcf, 0x93, 0x4c, 0x47, 0xfb, 0x2b, 0xa3, 0x49, 0xc2, 0x7c, 0x31, 0x4d, 0x68,
0x90, 0x66, 0xfe, 0x90, 0xc7, 0x22, 0xe5, 0x51, 0xf1, 0xd4, 0xe4, 0xc3, 0xb5, 0xe4, 0xa9, 0x60, 0xe6, 0xdf, 0xf1, 0x74, 0x44, 0x53, 0x0d, 0xd8, 0x5f, 0x09, 0x98, 0x08, 0x16, 0x49, 0xd4, 0x80,
0x91, 0x54, 0x18, 0x92, 0x24, 0x93, 0x17, 0xca, 0x67, 0x4e, 0x72, 0x6e, 0xe0, 0x3d, 0xa6, 0xaa, 0x24, 0x99, 0x4c, 0x22, 0x7f, 0x73, 0x90, 0x73, 0x05, 0xef, 0x31, 0x55, 0xe9, 0x2f, 0xc6, 0x24,
0x94, 0xab, 0x09, 0x09, 0xe9, 0x19, 0x8f, 0x03, 0x16, 0x62, 0xfa, 0xf3, 0x94, 0x66, 0x02, 0xed, 0xa4, 0x27, 0x3c, 0x0e, 0x58, 0x88, 0xe9, 0xef, 0x13, 0x9a, 0x09, 0xb4, 0x03, 0x26, 0xa6, 0x81,
0x81, 0x89, 0x69, 0x60, 0x19, 0x6d, 0xc3, 0xad, 0x63, 0x79, 0x44, 0x2e, 0xd4, 0xfa, 0x11, 0x11, 0x65, 0xb4, 0x0c, 0xb7, 0x8e, 0xe5, 0x11, 0xb9, 0x50, 0xeb, 0x45, 0x44, 0x04, 0x3c, 0x1d, 0x5b,
0x01, 0x4f, 0x27, 0x56, 0xa5, 0x6d, 0xb8, 0x8d, 0x4e, 0xd3, 0x4b, 0x06, 0x5e, 0x91, 0xc3, 0x8b, 0x95, 0x96, 0xe1, 0x36, 0xda, 0x4d, 0x2f, 0xe9, 0x7b, 0x85, 0x0f, 0xcf, 0xff, 0x75, 0xfe, 0x32,
0x5f, 0x9d, 0xdf, 0x0d, 0xb0, 0xff, 0x4b, 0x39, 0x4b, 0x78, 0x9c, 0x51, 0xf4, 0x23, 0x6c, 0x9f, 0xc0, 0x7e, 0x89, 0x39, 0x4b, 0x78, 0x9c, 0x51, 0xf4, 0x2b, 0x6c, 0x9e, 0xb2, 0x90, 0x66, 0x22,
0xb3, 0x90, 0x66, 0x22, 0x57, 0xef, 0x76, 0xee, 0x1f, 0x3f, 0x7c, 0xf2, 0xf0, 0xf8, 0x61, 0xbf, 0x67, 0xef, 0xb4, 0xef, 0x1f, 0x3f, 0x7c, 0xf1, 0xf0, 0xf8, 0xe1, 0x53, 0xa9, 0x09, 0x9e, 0xd0,
0xd4, 0x04, 0x4f, 0x68, 0x2c, 0x5b, 0x24, 0x2c, 0xa6, 0x69, 0xe6, 0x87, 0xfc, 0x60, 0xa4, 0x28, 0x78, 0xc0, 0x63, 0x41, 0x58, 0x4c, 0xd3, 0xcc, 0x0f, 0xf9, 0xde, 0x50, 0x41, 0xbc, 0x1c, 0x89,
0x5e, 0xce, 0xc4, 0x5a, 0x01, 0x7d, 0x0e, 0xdb, 0xb9, 0xba, 0x2a, 0xa9, 0x89, 0x75, 0xe4, 0x3c, 0x35, 0x03, 0xfa, 0x1a, 0x36, 0x73, 0x76, 0x55, 0x52, 0x13, 0x6b, 0xcb, 0x79, 0xa8, 0x40, 0xf3,
0x54, 0xa0, 0xf9, 0x93, 0x2c, 0xa0, 0xe8, 0xc7, 0x03, 0x38, 0xa7, 0x01, 0x8b, 0x99, 0x60, 0x3c, 0x37, 0x59, 0x40, 0xd1, 0x8f, 0x07, 0x70, 0x4a, 0x03, 0x16, 0x33, 0xc1, 0x78, 0xac, 0x12, 0x37,
0x56, 0x17, 0x37, 0x3a, 0x9f, 0xca, 0xfa, 0x9f, 0xb3, 0xb8, 0x84, 0x40, 0x36, 0xd4, 0x2e, 0xf5, 0xda, 0x5f, 0xca, 0xfa, 0x9f, 0xbc, 0xb8, 0x14, 0x81, 0x6c, 0xa8, 0x9d, 0xeb, 0x59, 0x2b, 0xea,
0xdc, 0x95, 0x74, 0x1d, 0x2f, 0x62, 0x74, 0x0b, 0x8d, 0xe2, 0x7c, 0x9d, 0x08, 0xcb, 0x6c, 0x9b, 0x3a, 0x9e, 0xdb, 0xe8, 0x1a, 0x1a, 0xc5, 0xf9, 0x32, 0x11, 0x96, 0xd9, 0x32, 0xdd, 0x46, 0xfb,
0x6e, 0xa3, 0x73, 0xe4, 0xad, 0x35, 0x8e, 0x57, 0xae, 0xc4, 0x2b, 0x51, 0x2f, 0x62, 0x91, 0xce, 0xc0, 0x5b, 0x29, 0x16, 0xaf, 0x5c, 0x89, 0x57, 0x82, 0x9e, 0xc5, 0x22, 0x9d, 0xe2, 0x32, 0x19,
0x71, 0x59, 0x0c, 0xb9, 0xb0, 0x7b, 0x35, 0x49, 0x78, 0x2a, 0xce, 0xc8, 0xf0, 0x8e, 0x62, 0x1a, 0x72, 0x61, 0xfb, 0x62, 0x9c, 0xf0, 0x54, 0x9c, 0x90, 0xc1, 0x0d, 0xc5, 0x34, 0xc8, 0xac, 0x6a,
0x64, 0x56, 0xb5, 0x6d, 0xba, 0x75, 0xbc, 0x9c, 0x46, 0x9f, 0xc1, 0xd6, 0x25, 0x8b, 0x49, 0x64, 0xcb, 0x74, 0xeb, 0x78, 0xd1, 0x8d, 0xbe, 0x82, 0x8d, 0x73, 0x16, 0x93, 0xc8, 0x82, 0x96, 0xe1,
0x41, 0xdb, 0x70, 0x6b, 0x38, 0x0f, 0x90, 0x03, 0xcd, 0x8b, 0x5f, 0x25, 0x90, 0xa6, 0xa7, 0x42, 0xd6, 0x70, 0x6e, 0x20, 0x07, 0x9a, 0x67, 0x7f, 0xc8, 0x40, 0x9a, 0x1e, 0x0b, 0x91, 0x5a, 0x0d,
0xa4, 0x56, 0x43, 0xbd, 0x96, 0x17, 0x39, 0xfb, 0x7b, 0xd8, 0x5b, 0x2e, 0x42, 0xce, 0x7b, 0x4c, 0x75, 0x2d, 0xcf, 0x7c, 0xf6, 0x11, 0xec, 0x2c, 0x16, 0x21, 0xe7, 0x3d, 0xa2, 0xd3, 0x62, 0xde,
0xe7, 0xc5, 0xbc, 0xc7, 0x74, 0x2e, 0xf5, 0x67, 0x24, 0x9a, 0x52, 0xdd, 0x7e, 0x1e, 0x1c, 0x57, 0x23, 0x3a, 0x95, 0xfc, 0xb7, 0x24, 0x9a, 0x50, 0xdd, 0x7e, 0x6e, 0x1c, 0x56, 0x0e, 0x0c, 0xe7,
0x8e, 0x0c, 0xe7, 0x02, 0x76, 0x74, 0x47, 0x7a, 0xa2, 0xab, 0x66, 0x59, 0x2e, 0xa3, 0xb2, 0x5a, 0x0c, 0xb6, 0x74, 0x47, 0x7a, 0xa2, 0xcb, 0x62, 0x59, 0x2c, 0xa3, 0xb2, 0x5c, 0x86, 0xf3, 0x27,
0x86, 0xf3, 0x1b, 0xec, 0x62, 0x4a, 0x46, 0x97, 0x2c, 0xa2, 0xeb, 0x5d, 0x27, 0xe7, 0xc0, 0x22, 0x6c, 0x63, 0x4a, 0x86, 0xe7, 0x2c, 0xa2, 0xab, 0x55, 0x27, 0xe7, 0xc0, 0x22, 0xda, 0x23, 0xe2,
0xda, 0x27, 0xe2, 0x6e, 0x31, 0x07, 0x1d, 0xa3, 0x63, 0xd8, 0xc2, 0x24, 0x0e, 0xa9, 0x65, 0xaa, 0x66, 0x3e, 0x07, 0x6d, 0xa3, 0x43, 0xd8, 0xc0, 0x24, 0x0e, 0xa9, 0x65, 0xaa, 0x71, 0x7e, 0xb3,
0x71, 0x7e, 0xb1, 0x61, 0x02, 0xea, 0x12, 0x89, 0xc5, 0x39, 0xc5, 0x39, 0x81, 0xfa, 0x22, 0x27, 0x66, 0x02, 0x2a, 0x89, 0x8c, 0xc5, 0x39, 0xc4, 0xf9, 0x19, 0xea, 0x73, 0x9f, 0x54, 0xd1, 0x65,
0x5d, 0x74, 0x1d, 0x04, 0x19, 0xcd, 0x1d, 0x69, 0x62, 0x1d, 0xc9, 0x7c, 0x8f, 0xc6, 0xa1, 0xbe, 0x10, 0x64, 0x34, 0x57, 0xa4, 0x89, 0xb5, 0x25, 0xfd, 0x5d, 0x1a, 0x87, 0x3a, 0xb5, 0x89, 0xb5,
0xda, 0xc4, 0x3a, 0x72, 0x3e, 0xc2, 0xde, 0x73, 0xe5, 0xfa, 0x1d, 0x20, 0xa8, 0x9e, 0x13, 0x41, 0xe5, 0x7c, 0x84, 0x9d, 0xa7, 0xca, 0xf5, 0x1d, 0x20, 0xa8, 0x9e, 0x12, 0x41, 0x14, 0x43, 0x13,
0x94, 0x42, 0x13, 0xab, 0xb3, 0xb3, 0x03, 0x8d, 0x3e, 0x8b, 0x8b, 0x9d, 0x72, 0xfe, 0x36, 0xa0, 0xab, 0xb3, 0xb3, 0x05, 0x8d, 0x1e, 0x8b, 0x8b, 0x9d, 0x72, 0x66, 0x06, 0x34, 0x7b, 0x3c, 0x7e,
0xd9, 0xe7, 0xf1, 0xf3, 0x26, 0xf4, 0x61, 0xb7, 0x18, 0xc4, 0x69, 0xff, 0xea, 0x8c, 0x24, 0x99, 0xda, 0x84, 0x1e, 0x6c, 0x17, 0x83, 0x38, 0xee, 0x5d, 0x9c, 0x90, 0x24, 0xb3, 0x0c, 0x25, 0xa6,
0x65, 0x28, 0x33, 0xb5, 0x57, 0x5b, 0xd1, 0x3b, 0xec, 0xe5, 0xc0, 0x6e, 0x55, 0x2e, 0x0d, 0x5e, 0xd6, 0x72, 0x2b, 0x7a, 0x87, 0xbd, 0x3c, 0xb0, 0x53, 0x95, 0x4b, 0x83, 0x17, 0xe1, 0xe8, 0x17,
0xa6, 0xa3, 0x1f, 0xe0, 0x5d, 0xaf, 0xd7, 0x55, 0x4a, 0x95, 0x37, 0x29, 0x15, 0x34, 0x74, 0x04, 0x78, 0xd7, 0xed, 0x76, 0x14, 0x53, 0xe5, 0x4d, 0x4c, 0x05, 0x0c, 0x1d, 0xc1, 0xbb, 0x2b, 0xf5,
0xef, 0x6e, 0x78, 0x3a, 0xa6, 0x69, 0xa6, 0x8d, 0xdd, 0x5a, 0x55, 0xc8, 0x01, 0x98, 0x0e, 0x79, 0xb4, 0x64, 0x5a, 0xd8, 0x2f, 0x5c, 0xab, 0x7a, 0x81, 0xbc, 0x3c, 0x0c, 0xd3, 0x01, 0x4f, 0x87,
0x3a, 0xc2, 0x05, 0xbc, 0xf3, 0xa7, 0x09, 0xf5, 0x5e, 0xaf, 0xdb, 0x4d, 0xd9, 0x28, 0xa4, 0xe8, 0xb8, 0x00, 0xb5, 0xff, 0x31, 0xa1, 0xde, 0xed, 0x76, 0x3a, 0x29, 0x1b, 0x86, 0x14, 0xfd, 0x6d,
0x0f, 0x03, 0xd0, 0xea, 0x47, 0x00, 0x7d, 0xbb, 0x61, 0x48, 0x6b, 0xbf, 0x46, 0xf6, 0x77, 0x6f, 0x00, 0x5a, 0x7e, 0x0a, 0xd0, 0x8f, 0x6b, 0x46, 0xb5, 0xf2, 0x4d, 0xb2, 0x7f, 0x7a, 0x23, 0x4a,
0x64, 0xe9, 0xf7, 0x7b, 0x0b, 0x5b, 0xca, 0xa8, 0xe8, 0xcb, 0x57, 0x2e, 0xa7, 0xed, 0xfe, 0x3f, 0xdf, 0xf2, 0x35, 0x6c, 0x28, 0xb9, 0xa2, 0x6f, 0x5f, 0xb9, 0xa2, 0xb6, 0xfb, 0xf9, 0x40, 0xcd,
0x50, 0x6b, 0x0f, 0xa1, 0x56, 0x78, 0x00, 0xed, 0x6f, 0x2c, 0xef, 0x85, 0xc5, 0xed, 0xaf, 0x5e, 0x3d, 0x80, 0x5a, 0xa1, 0x04, 0xf4, 0x69, 0x6d, 0x79, 0xcf, 0x84, 0x6e, 0x7f, 0xf7, 0xaa, 0x58,
0x85, 0xd5, 0x97, 0xdc, 0x40, 0x55, 0x1a, 0x08, 0x7d, 0xdc, 0x40, 0x2a, 0x39, 0xcc, 0xde, 0xd4, 0x9d, 0xe4, 0x0a, 0xaa, 0x52, 0x46, 0xe8, 0xe3, 0x1a, 0x50, 0x49, 0x67, 0xf6, 0xba, 0x3e, 0xcb,
0x67, 0xd9, 0x79, 0xdd, 0xe6, 0xfd, 0x53, 0xcb, 0xf8, 0xeb, 0xa9, 0x65, 0xfc, 0xf3, 0xd4, 0x32, 0xfa, 0xeb, 0x34, 0xef, 0x67, 0xbb, 0xc6, 0xbf, 0xb3, 0x5d, 0xe3, 0xbf, 0xd9, 0xae, 0xd1, 0xdf,
0x06, 0xdb, 0xea, 0x0f, 0xe1, 0xf0, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x91, 0x1e, 0x29, 0x71, 0x54, 0x9f, 0x85, 0xfd, 0xff, 0x03, 0x00, 0x00, 0xff, 0xff, 0x8a, 0x0f, 0xb2, 0xc3, 0x05, 0x07,
0x0b, 0x07, 0x00, 0x00, 0x00, 0x00,
} }

4
frontend/gateway/pb/gateway.proto
View File

@ -4,7 +4,7 @@ package moby.buildkit.v1.frontend;
import "github.com/gogo/protobuf/gogoproto/gogo.proto"; import "github.com/gogo/protobuf/gogoproto/gogo.proto";
import "github.com/moby/buildkit/solver/pb/ops.proto"; import "github.com/moby/buildkit/solver/pb/ops.proto";
import "github.com/moby/buildkit/api/services/control/control.proto"; import "github.com/moby/buildkit/api/types/worker.proto";
import "github.com/moby/buildkit/util/apicaps/pb/caps.proto"; import "github.com/moby/buildkit/util/apicaps/pb/caps.proto";
option (gogoproto.sizer_all) = true; option (gogoproto.sizer_all) = true;
@ -67,5 +67,5 @@ message PingRequest{
message PongResponse{ message PongResponse{
repeated moby.buildkit.v1.apicaps.APICap FrontendAPICaps = 1 [(gogoproto.nullable) = false]; repeated moby.buildkit.v1.apicaps.APICap FrontendAPICaps = 1 [(gogoproto.nullable) = false];
repeated moby.buildkit.v1.apicaps.APICap LLBCaps = 2 [(gogoproto.nullable) = false]; repeated moby.buildkit.v1.apicaps.APICap LLBCaps = 2 [(gogoproto.nullable) = false];
repeated moby.buildkit.v1.WorkerRecord Workers = 3; repeated moby.buildkit.v1.types.WorkerRecord Workers = 3;
} }

41
solver/pb/platform.go Normal file
View File

@ -0,0 +1,41 @@
package pb
import (
specs "github.com/opencontainers/image-spec/specs-go/v1"
)
func (p *Platform) Spec() specs.Platform {
return specs.Platform{
OS: p.OS,
Architecture: p.Architecture,
Variant: p.Variant,
OSVersion: p.OSVersion,
OSFeatures: p.OSFeatures,
}
}
func PlatformFromSpec(p specs.Platform) Platform {
return Platform{
OS: p.OS,
Architecture: p.Architecture,
Variant: p.Variant,
OSVersion: p.OSVersion,
OSFeatures: p.OSFeatures,
}
}
func ToSpecPlatforms(p []Platform) []specs.Platform {
out := make([]specs.Platform, 0, len(p))
for _, pp := range p {
out = append(out, pp.Spec())
}
return out
}
func PlatformsFromSpec(p []specs.Platform) []Platform {
out := make([]Platform, 0, len(p))
for _, pp := range p {
out = append(out, PlatformFromSpec(pp))
}
return out
}

17
worker/workercontroller.go
View File

@ -4,6 +4,7 @@ import (
"sync" "sync"
"github.com/containerd/containerd/filters" "github.com/containerd/containerd/filters"
"github.com/moby/buildkit/client"
"github.com/pkg/errors" "github.com/pkg/errors"
) )
@ -58,3 +59,19 @@ func (c *Controller) Get(id string) (Worker, error) {
} }
// TODO: add Get(Constraint) (*Worker, error) // TODO: add Get(Constraint) (*Worker, error)
func (c *Controller) WorkerInfos() []client.WorkerInfo {
workers, err := c.List()
if err != nil {
return nil
}
out := make([]client.WorkerInfo, 0, len(workers))
for _, w := range workers {
out = append(out, client.WorkerInfo{
ID: w.ID(),
Labels: w.Labels(),
Platforms: w.Platforms(),
})
}
return out
}