docker/buildx
1
0
Fork 0
mirror of https://gitea.com/Lydanne/buildx.git synced 2025-07-09 21:17:09 +08:00
Code Issues Packages Projects Releases 1 Wiki Activity

vendor: update buildkit to 2f99651

Browse Source 
Signed-off-by: CrazyMax <crazy-max@users.noreply.github.com>
This commit is contained in:
CrazyMax
2022-02-09 21:53:27 +01:00
parent 60a025b227
commit 307c94e5c7
360 changed files with 13218 additions and 6961 deletions
Download Patch File Download Diff File Expand all files Collapse all files

319
vendor/github.com/moby/buildkit/api/services/control/control.pb.go generated vendored
View File

@ -770,6 +770,7 @@ type Vertex struct {
Started *time.Time `protobuf:"bytes,5,opt,name=started,proto3,stdtime" json:"started,omitempty"`
Completed *time.Time `protobuf:"bytes,6,opt,name=completed,proto3,stdtime" json:"completed,omitempty"`
Error string `protobuf:"bytes,7,opt,name=error,proto3" json:"error,omitempty"`
ProgressGroup *pb.ProgressGroup `protobuf:"bytes,8,opt,name=progressGroup,proto3" json:"progressGroup,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -843,6 +844,13 @@ func (m *Vertex) GetError() string {
return ""
}
func (m *Vertex) GetProgressGroup() *pb.ProgressGroup {
if m != nil {
return m.ProgressGroup
}
return nil
}
type VertexStatus struct {
ID string `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"`
Vertex github_com_opencontainers_go_digest.Digest `protobuf:"bytes,2,opt,name=vertex,proto3,customtype=github.com/opencontainers/go-digest.Digest" json:"vertex"`
@ -1261,103 +1269,104 @@ func init() {
func init() { proto.RegisterFile("control.proto", fileDescriptor_0c5120591600887d) }
var fileDescriptor_0c5120591600887d = []byte{
// 1521 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0x4b, 0x6f, 0xdb, 0xc6,
0x16, 0x0e, 0x25, 0xeb, 0x75, 0x2c, 0x1b, 0xce, 0x24, 0x37, 0x20, 0x78, 0x71, 0x6d, 0x87, 0xc9,
0x05, 0x84, 0x20, 0xa1, 0x1c, 0xb5, 0x29, 0x52, 0xf7, 0x81, 0x44, 0x56, 0x8a, 0x38, 0x88, 0xd1,
0x74, 0x94, 0x34, 0x40, 0x16, 0x05, 0x28, 0x69, 0x24, 0x13, 0xa6, 0x38, 0xec, 0xcc, 0xd0, 0x89,
0xfa, 0x03, 0xba, 0xee, 0xae, 0x3f, 0xa0, 0x8b, 0xae, 0xba, 0xee, 0x2f, 0x28, 0x90, 0x65, 0xd7,
0x59, 0xb8, 0x45, 0xf6, 0x2d, 0xba, 0xec, 0xb2, 0x98, 0x07, 0x65, 0xca, 0x92, 0xfc, 0x4a, 0x57,
0x9a, 0x33, 0x3c, 0xdf, 0xa7, 0xf3, 0x9c, 0x99, 0x03, 0x4b, 0x5d, 0x1a, 0x09, 0x46, 0x43, 0x2f,
0x66, 0x54, 0x50, 0xb4, 0x32, 0xa4, 0x9d, 0x91, 0xd7, 0x49, 0x82, 0xb0, 0xb7, 0x17, 0x08, 0x6f,
0xff, 0xb6, 0x73, 0x6b, 0x10, 0x88, 0xdd, 0xa4, 0xe3, 0x75, 0xe9, 0xb0, 0x3e, 0xa0, 0x03, 0x5a,
0x57, 0x8a, 0x9d, 0xa4, 0xaf, 0x24, 0x25, 0xa8, 0x95, 0x26, 0x70, 0xd6, 0x06, 0x94, 0x0e, 0x42,
0x72, 0xa8, 0x25, 0x82, 0x21, 0xe1, 0xc2, 0x1f, 0xc6, 0x46, 0xe1, 0x66, 0x86, 0x4f, 0xfe, 0x59,
0x3d, 0xfd, 0xb3, 0x3a, 0xa7, 0xe1, 0x3e, 0x61, 0xf5, 0xb8, 0x53, 0xa7, 0x31, 0x37, 0xda, 0xf5,
0xb9, 0xda, 0x7e, 0x1c, 0xd4, 0xc5, 0x28, 0x26, 0xbc, 0xfe, 0x92, 0xb2, 0x3d, 0xc2, 0x34, 0xc0,
0xfd, 0xd6, 0x82, 0xea, 0x13, 0x96, 0x44, 0x04, 0x93, 0xaf, 0x13, 0xc2, 0x05, 0xba, 0x02, 0xc5,
0x7e, 0x10, 0x0a, 0xc2, 0x6c, 0x6b, 0x3d, 0x5f, 0xab, 0x60, 0x23, 0xa1, 0x15, 0xc8, 0xfb, 0x61,
0x68, 0xe7, 0xd6, 0xad, 0x5a, 0x19, 0xcb, 0x25, 0xaa, 0x41, 0x75, 0x8f, 0x90, 0xb8, 0x95, 0x30,
0x5f, 0x04, 0x34, 0xb2, 0xf3, 0xeb, 0x56, 0x2d, 0xdf, 0x5c, 0x78, 0x7d, 0xb0, 0x66, 0xe1, 0x89,
0x2f, 0xc8, 0x85, 0x8a, 0x94, 0x9b, 0x23, 0x41, 0xb8, 0xbd, 0x90, 0x51, 0x3b, 0xdc, 0x76, 0x6f,
0xc0, 0x4a, 0x2b, 0xe0, 0x7b, 0xcf, 0xb8, 0x3f, 0x38, 0xc9, 0x16, 0xf7, 0x11, 0x5c, 0xcc, 0xe8,
0xf2, 0x98, 0x46, 0x9c, 0xa0, 0x3b, 0x50, 0x64, 0xa4, 0x4b, 0x59, 0x4f, 0x29, 0x2f, 0x36, 0xfe,
0xe7, 0x1d, 0xcd, 0x8d, 0x67, 0x00, 0x52, 0x09, 0x1b, 0x65, 0xf7, 0xfb, 0x3c, 0x2c, 0x66, 0xf6,
0xd1, 0x32, 0xe4, 0xb6, 0x5b, 0xb6, 0xb5, 0x6e, 0xd5, 0x2a, 0x38, 0xb7, 0xdd, 0x42, 0x36, 0x94,
0x76, 0x12, 0xe1, 0x77, 0x42, 0x62, 0x7c, 0x4f, 0x45, 0x74, 0x19, 0x0a, 0xdb, 0xd1, 0x33, 0x4e,
0x94, 0xe3, 0x65, 0xac, 0x05, 0x84, 0x60, 0xa1, 0x1d, 0x7c, 0x43, 0xb4, 0x9b, 0x58, 0xad, 0x91,
0x03, 0xc5, 0x27, 0x3e, 0x23, 0x91, 0xb0, 0x0b, 0x92, 0xb7, 0x99, 0xb3, 0x2d, 0x6c, 0x76, 0x50,
0x13, 0x2a, 0x5b, 0x8c, 0xf8, 0x82, 0xf4, 0xee, 0x0b, 0xbb, 0xb8, 0x6e, 0xd5, 0x16, 0x1b, 0x8e,
0xa7, 0x8b, 0xc2, 0x4b, 0x8b, 0xc2, 0x7b, 0x9a, 0x16, 0x45, 0xb3, 0xfc, 0xfa, 0x60, 0xed, 0xc2,
0x77, 0xbf, 0xc9, 0xd8, 0x8d, 0x61, 0xe8, 0x1e, 0xc0, 0x63, 0x9f, 0x8b, 0x67, 0x5c, 0x91, 0x94,
0x4e, 0x24, 0x59, 0x50, 0x04, 0x19, 0x0c, 0x5a, 0x05, 0x50, 0x41, 0xd8, 0xa2, 0x49, 0x24, 0xec,
0xb2, 0xb2, 0x3d, 0xb3, 0x83, 0xd6, 0x61, 0xb1, 0x45, 0x78, 0x97, 0x05, 0xb1, 0x4a, 0x75, 0x45,
0x85, 0x27, 0xbb, 0x25, 0x19, 0x74, 0x04, 0x9f, 0x8e, 0x62, 0x62, 0x83, 0x52, 0xc8, 0xec, 0xc8,
0x5c, 0xb6, 0x77, 0x7d, 0x46, 0x7a, 0xf6, 0xa2, 0x0a, 0x97, 0x91, 0x64, 0x7c, 0x75, 0x24, 0xb8,
0x5d, 0x55, 0x49, 0x4e, 0x45, 0xf7, 0x87, 0x22, 0x54, 0xdb, 0xb2, 0xc6, 0xd3, 0x72, 0x58, 0x81,
0x3c, 0x26, 0x7d, 0x93, 0x1b, 0xb9, 0x44, 0x1e, 0x40, 0x8b, 0xf4, 0x83, 0x28, 0x50, 0x56, 0xe5,
0x94, 0xe3, 0xcb, 0x5e, 0xdc, 0xf1, 0x0e, 0x77, 0x71, 0x46, 0x03, 0x39, 0x50, 0x7e, 0xf0, 0x2a,
0xa6, 0x4c, 0x96, 0x54, 0x5e, 0xd1, 0x8c, 0x65, 0xf4, 0x1c, 0x96, 0xd2, 0xf5, 0x7d, 0x21, 0x98,
0x2c, 0x54, 0x59, 0x46, 0xb7, 0xa7, 0xcb, 0x28, 0x6b, 0x94, 0x37, 0x81, 0x79, 0x10, 0x09, 0x36,
0xc2, 0x93, 0x3c, 0xd2, 0xc3, 0x36, 0xe1, 0x5c, 0x5a, 0xa8, 0xd2, 0x8f, 0x53, 0x51, 0x9a, 0xf3,
0x19, 0xa3, 0x91, 0x20, 0x51, 0x4f, 0xa5, 0xbe, 0x82, 0xc7, 0xb2, 0x34, 0x27, 0x5d, 0x6b, 0x73,
0x4a, 0xa7, 0x32, 0x67, 0x02, 0x63, 0xcc, 0x99, 0xd8, 0x43, 0x9b, 0x50, 0xd8, 0xf2, 0xbb, 0xbb,
0x44, 0x65, 0x79, 0xb1, 0xb1, 0x3a, 0x4d, 0xa8, 0x3e, 0x7f, 0xae, 0xd2, 0xca, 0x55, 0xa3, 0x5e,
0xc0, 0x1a, 0x82, 0xbe, 0x82, 0xea, 0x83, 0x48, 0x04, 0x22, 0x24, 0x43, 0x95, 0xb1, 0x8a, 0xcc,
0x58, 0x73, 0xf3, 0xcd, 0xc1, 0xda, 0x07, 0x73, 0x0f, 0x9e, 0x44, 0x04, 0x61, 0x9d, 0x64, 0x50,
0x5e, 0x86, 0x02, 0x4f, 0xf0, 0xa1, 0x17, 0xb0, 0x9c, 0x1a, 0xbb, 0x1d, 0xc5, 0x89, 0xe0, 0x36,
0x28, 0xaf, 0x1b, 0xa7, 0xf4, 0x5a, 0x83, 0xb4, 0xdb, 0x47, 0x98, 0x9c, 0x7b, 0x80, 0xa6, 0x73,
0x25, 0x6b, 0x6a, 0x8f, 0x8c, 0xd2, 0x9a, 0xda, 0x23, 0x23, 0xd9, 0xd6, 0xfb, 0x7e, 0x98, 0xe8,
0x76, 0xaf, 0x60, 0x2d, 0x6c, 0xe6, 0xee, 0x5a, 0x92, 0x61, 0x3a, 0xbc, 0x67, 0x62, 0xf8, 0x02,
0x2e, 0xcd, 0x30, 0x75, 0x06, 0xc5, 0xf5, 0x2c, 0xc5, 0x74, 0x4d, 0x1f, 0x52, 0xba, 0x3f, 0xe5,
0xa1, 0x9a, 0x4d, 0x18, 0xda, 0x80, 0x4b, 0xda, 0x4f, 0x4c, 0xfa, 0x2d, 0x12, 0x33, 0xd2, 0x95,
0xa7, 0x84, 0x21, 0x9f, 0xf5, 0x09, 0x35, 0xe0, 0xf2, 0xf6, 0xd0, 0x6c, 0xf3, 0x0c, 0x24, 0xa7,
0xfa, 0x71, 0xe6, 0x37, 0x44, 0xe1, 0x3f, 0x9a, 0x4a, 0x45, 0x22, 0x03, 0xca, 0xab, 0x84, 0x7d,
0x78, 0x7c, 0x55, 0x79, 0x33, 0xb1, 0x3a, 0x6f, 0xb3, 0x79, 0xd1, 0x27, 0x50, 0xd2, 0x1f, 0xd2,
0xc6, 0xbc, 0x76, 0xfc, 0x5f, 0x68, 0xb2, 0x14, 0x23, 0xe1, 0xda, 0x0f, 0x6e, 0x17, 0xce, 0x00,
0x37, 0x18, 0xe7, 0x21, 0x38, 0xf3, 0x4d, 0x3e, 0x4b, 0x09, 0xb8, 0x3f, 0x5a, 0x70, 0x71, 0xea,
0x8f, 0xe4, 0xad, 0xa1, 0xce, 0x4d, 0x4d, 0xa1, 0xd6, 0xa8, 0x05, 0x05, 0xdd, 0xf9, 0x39, 0x65,
0xb0, 0x77, 0x0a, 0x83, 0xbd, 0x4c, 0xdb, 0x6b, 0xb0, 0x73, 0x17, 0xe0, 0x7c, 0xc5, 0xea, 0xfe,
0x6c, 0xc1, 0x92, 0xe9, 0x32, 0x73, 0xc5, 0xfa, 0xb0, 0x92, 0xb6, 0x50, 0xba, 0x67, 0x2e, 0xdb,
0x3b, 0x73, 0x1b, 0x54, 0xab, 0x79, 0x47, 0x71, 0xda, 0xc6, 0x29, 0x3a, 0x67, 0x2b, 0xad, 0xab,
0x23, 0xaa, 0x67, 0xb2, 0xfc, 0x2a, 0x2c, 0xb5, 0x85, 0x2f, 0x12, 0x3e, 0xf7, 0xe6, 0x70, 0xff,
0xb2, 0x60, 0x39, 0xd5, 0x31, 0xde, 0xbd, 0x0f, 0xe5, 0x7d, 0xc2, 0x04, 0x79, 0x45, 0xb8, 0xf1,
0xca, 0x9e, 0xf6, 0xea, 0x4b, 0xa5, 0x81, 0xc7, 0x9a, 0x68, 0x13, 0xca, 0x5c, 0xf1, 0x90, 0x34,
0x51, 0xab, 0xf3, 0x50, 0xe6, 0xff, 0xc6, 0xfa, 0xa8, 0x0e, 0x0b, 0x21, 0x1d, 0x70, 0xd3, 0x33,
0xff, 0x9d, 0x87, 0x7b, 0x4c, 0x07, 0x58, 0x29, 0xa2, 0x8f, 0xa0, 0xfc, 0xd2, 0x67, 0x51, 0x10,
0x0d, 0xd2, 0x2e, 0x58, 0x9b, 0x07, 0x7a, 0xae, 0xf5, 0xf0, 0x18, 0xe0, 0x1e, 0xe4, 0xa0, 0xa8,
0xbf, 0xa1, 0x47, 0x50, 0xec, 0x05, 0x03, 0xc2, 0x85, 0x0e, 0x49, 0xb3, 0x21, 0x0f, 0xf9, 0x37,
0x07, 0x6b, 0x37, 0x32, 0xa7, 0x38, 0x8d, 0x49, 0x24, 0x1f, 0xbb, 0x7e, 0x10, 0x11, 0xc6, 0xeb,
0x03, 0x7a, 0x4b, 0x43, 0xbc, 0x96, 0xfa, 0xc1, 0x86, 0x41, 0x72, 0x05, 0xfa, 0xac, 0x56, 0xe7,
0xc5, 0xf9, 0xb8, 0x34, 0x83, 0x6c, 0x83, 0xc8, 0x1f, 0x12, 0x73, 0x37, 0xab, 0xb5, 0x7c, 0x38,
0x74, 0x65, 0x9d, 0xf7, 0xd4, 0x93, 0xaa, 0x8c, 0x8d, 0x84, 0x36, 0xa1, 0xc4, 0x85, 0xcf, 0xe4,
0x99, 0x53, 0x38, 0xe5, 0x8b, 0x27, 0x05, 0xa0, 0x4f, 0xa1, 0xd2, 0xa5, 0xc3, 0x38, 0x24, 0x12,
0x5d, 0x3c, 0x25, 0xfa, 0x10, 0x22, 0x4b, 0x8f, 0x30, 0x46, 0x99, 0x7a, 0x6b, 0x55, 0xb0, 0x16,
0xdc, 0x3f, 0x73, 0x50, 0xcd, 0x66, 0x7a, 0xea, 0x2d, 0xf9, 0x08, 0x8a, 0xba, 0x6e, 0x74, 0xc9,
0x9e, 0x2f, 0x54, 0x9a, 0x61, 0x66, 0xa8, 0x6c, 0x28, 0x75, 0x13, 0xa6, 0x1e, 0x9a, 0xfa, 0xf9,
0x99, 0x8a, 0xd2, 0x60, 0x41, 0x85, 0x1f, 0xaa, 0x50, 0xe5, 0xb1, 0x16, 0xe4, 0xdb, 0x73, 0x3c,
0x6e, 0x9c, 0xed, 0xed, 0x39, 0x86, 0x65, 0xd3, 0x50, 0x7a, 0xa7, 0x34, 0x94, 0xcf, 0x9c, 0x06,
0xf7, 0x17, 0x0b, 0x2a, 0xe3, 0x16, 0xc9, 0x44, 0xd7, 0x7a, 0xe7, 0xe8, 0x4e, 0x44, 0x26, 0x77,
0xbe, 0xc8, 0x5c, 0x81, 0x22, 0x17, 0x8c, 0xf8, 0x43, 0x3d, 0x19, 0x61, 0x23, 0xc9, 0xc3, 0x68,
0xc8, 0x07, 0x2a, 0x43, 0x55, 0x2c, 0x97, 0xee, 0xdf, 0x16, 0x2c, 0x4d, 0x74, 0xed, 0xbf, 0xea,
0xcb, 0x65, 0x28, 0x84, 0x64, 0x9f, 0xe8, 0xd9, 0x2d, 0x8f, 0xb5, 0x20, 0x77, 0xf9, 0x2e, 0x65,
0x42, 0x19, 0x57, 0xc5, 0x5a, 0x90, 0x36, 0xf7, 0x88, 0xf0, 0x83, 0x50, 0x1d, 0x2f, 0x55, 0x6c,
0x24, 0x69, 0x73, 0xc2, 0x42, 0xf3, 0x7e, 0x95, 0x4b, 0xe4, 0xc2, 0x42, 0x10, 0xf5, 0xa9, 0x29,
0x1b, 0xf5, 0x40, 0x69, 0xd3, 0x84, 0x75, 0xc9, 0x76, 0xd4, 0xa7, 0x58, 0x7d, 0x43, 0x57, 0xa1,
0xc8, 0xfc, 0x68, 0x40, 0xd2, 0xc7, 0x6b, 0x45, 0x6a, 0x61, 0xb9, 0x83, 0xcd, 0x07, 0xd7, 0x85,
0xaa, 0x9a, 0xff, 0x76, 0x08, 0x97, 0xd3, 0x86, 0x2c, 0xeb, 0x9e, 0x2f, 0x7c, 0xe5, 0x76, 0x15,
0xab, 0xb5, 0x7b, 0x13, 0xd0, 0xe3, 0x80, 0x8b, 0xe7, 0x6a, 0x6e, 0xe5, 0x27, 0x0d, 0x87, 0x6d,
0xb8, 0x34, 0xa1, 0x6d, 0x4e, 0xf7, 0x8f, 0x8f, 0x8c, 0x87, 0xd7, 0xa7, 0x0f, 0x4e, 0x35, 0x1e,
0x7b, 0x1a, 0x38, 0x39, 0x25, 0x36, 0xfe, 0xc8, 0x43, 0x69, 0x4b, 0x4f, 0xfe, 0xe8, 0x29, 0x54,
0xc6, 0xd3, 0x27, 0x72, 0xa7, 0x69, 0x8e, 0x8e, 0xb1, 0xce, 0xb5, 0x63, 0x75, 0x8c, 0x7d, 0x0f,
0xa1, 0xa0, 0xe6, 0x70, 0x34, 0xe3, 0xfa, 0xc8, 0x0e, 0xe8, 0xce, 0xf1, 0x73, 0xed, 0x86, 0x25,
0x99, 0xd4, 0xdd, 0x3b, 0x8b, 0x29, 0xfb, 0x6a, 0x76, 0xd6, 0x4e, 0xb8, 0xb4, 0xd1, 0x0e, 0x14,
0xcd, 0x49, 0x36, 0x4b, 0x35, 0x7b, 0xc3, 0x3a, 0xeb, 0xf3, 0x15, 0x34, 0xd9, 0x86, 0x85, 0x76,
0xc6, 0x83, 0xd0, 0x2c, 0xd3, 0xb2, 0x65, 0xe0, 0x9c, 0xf0, 0xbd, 0x66, 0x6d, 0x58, 0xe8, 0x05,
0x2c, 0x66, 0x12, 0x8d, 0x66, 0x24, 0x74, 0xba, 0x6a, 0x9c, 0xff, 0x9f, 0xa0, 0xa5, 0x8d, 0x6d,
0x56, 0x5f, 0xbf, 0x5d, 0xb5, 0x7e, 0x7d, 0xbb, 0x6a, 0xfd, 0xfe, 0x76, 0xd5, 0xea, 0x14, 0x55,
0xcb, 0xbf, 0xf7, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x8f, 0x2a, 0x40, 0x92, 0xfd, 0x11, 0x00,
0x00,
// 1543 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0xcd, 0x6f, 0x1b, 0x45,
0x14, 0xef, 0xda, 0xf1, 0xd7, 0x8b, 0x13, 0xa5, 0xd3, 0x52, 0xad, 0x16, 0x91, 0xa4, 0xdb, 0x22,
0x45, 0x55, 0xbb, 0x4e, 0x03, 0x85, 0x12, 0x3e, 0xd4, 0x3a, 0x2e, 0x34, 0x55, 0x23, 0xca, 0xa4,
0xa5, 0x52, 0x0f, 0x48, 0x6b, 0x7b, 0xbc, 0x59, 0x65, 0xbd, 0xb3, 0xcc, 0xcc, 0xa6, 0x35, 0x7f,
0x00, 0x67, 0x6e, 0xfc, 0x01, 0x1c, 0x38, 0x71, 0xe6, 0x2f, 0x40, 0xea, 0x91, 0x73, 0x0f, 0x01,
0xf5, 0x0e, 0xe2, 0xc8, 0x11, 0xcd, 0xc7, 0x3a, 0xeb, 0xd8, 0xce, 0x57, 0x39, 0x79, 0xde, 0xcc,
0x7b, 0xbf, 0x7d, 0x9f, 0x33, 0xef, 0x19, 0xe6, 0x3a, 0x34, 0x16, 0x8c, 0x46, 0x5e, 0xc2, 0xa8,
0xa0, 0x68, 0xa1, 0x4f, 0xdb, 0x03, 0xaf, 0x9d, 0x86, 0x51, 0x77, 0x37, 0x14, 0xde, 0xde, 0x4d,
0xe7, 0x46, 0x10, 0x8a, 0x9d, 0xb4, 0xed, 0x75, 0x68, 0xbf, 0x11, 0xd0, 0x80, 0x36, 0x14, 0x63,
0x3b, 0xed, 0x29, 0x4a, 0x11, 0x6a, 0xa5, 0x01, 0x9c, 0xa5, 0x80, 0xd2, 0x20, 0x22, 0x07, 0x5c,
0x22, 0xec, 0x13, 0x2e, 0xfc, 0x7e, 0x62, 0x18, 0xae, 0xe7, 0xf0, 0xe4, 0xc7, 0x1a, 0xd9, 0xc7,
0x1a, 0x9c, 0x46, 0x7b, 0x84, 0x35, 0x92, 0x76, 0x83, 0x26, 0xdc, 0x70, 0x37, 0xa6, 0x72, 0xfb,
0x49, 0xd8, 0x10, 0x83, 0x84, 0xf0, 0xc6, 0x73, 0xca, 0x76, 0x09, 0xd3, 0x02, 0xee, 0xf7, 0x16,
0xd4, 0x1f, 0xb1, 0x34, 0x26, 0x98, 0x7c, 0x9b, 0x12, 0x2e, 0xd0, 0x25, 0x28, 0xf7, 0xc2, 0x48,
0x10, 0x66, 0x5b, 0xcb, 0xc5, 0x95, 0x1a, 0x36, 0x14, 0x5a, 0x80, 0xa2, 0x1f, 0x45, 0x76, 0x61,
0xd9, 0x5a, 0xa9, 0x62, 0xb9, 0x44, 0x2b, 0x50, 0xdf, 0x25, 0x24, 0x69, 0xa5, 0xcc, 0x17, 0x21,
0x8d, 0xed, 0xe2, 0xb2, 0xb5, 0x52, 0x6c, 0xce, 0xbc, 0xdc, 0x5f, 0xb2, 0xf0, 0xc8, 0x09, 0x72,
0xa1, 0x26, 0xe9, 0xe6, 0x40, 0x10, 0x6e, 0xcf, 0xe4, 0xd8, 0x0e, 0xb6, 0xdd, 0x6b, 0xb0, 0xd0,
0x0a, 0xf9, 0xee, 0x13, 0xee, 0x07, 0xc7, 0xe9, 0xe2, 0x3e, 0x80, 0xf3, 0x39, 0x5e, 0x9e, 0xd0,
0x98, 0x13, 0x74, 0x0b, 0xca, 0x8c, 0x74, 0x28, 0xeb, 0x2a, 0xe6, 0xd9, 0xb5, 0x77, 0xbc, 0xc3,
0xb1, 0xf1, 0x8c, 0x80, 0x64, 0xc2, 0x86, 0xd9, 0xfd, 0xb1, 0x08, 0xb3, 0xb9, 0x7d, 0x34, 0x0f,
0x85, 0xcd, 0x96, 0x6d, 0x2d, 0x5b, 0x2b, 0x35, 0x5c, 0xd8, 0x6c, 0x21, 0x1b, 0x2a, 0x5b, 0xa9,
0xf0, 0xdb, 0x11, 0x31, 0xb6, 0x67, 0x24, 0xba, 0x08, 0xa5, 0xcd, 0xf8, 0x09, 0x27, 0xca, 0xf0,
0x2a, 0xd6, 0x04, 0x42, 0x30, 0xb3, 0x1d, 0x7e, 0x47, 0xb4, 0x99, 0x58, 0xad, 0x91, 0x03, 0xe5,
0x47, 0x3e, 0x23, 0xb1, 0xb0, 0x4b, 0x12, 0xb7, 0x59, 0xb0, 0x2d, 0x6c, 0x76, 0x50, 0x13, 0x6a,
0x1b, 0x8c, 0xf8, 0x82, 0x74, 0xef, 0x0a, 0xbb, 0xbc, 0x6c, 0xad, 0xcc, 0xae, 0x39, 0x9e, 0x4e,
0x0a, 0x2f, 0x4b, 0x0a, 0xef, 0x71, 0x96, 0x14, 0xcd, 0xea, 0xcb, 0xfd, 0xa5, 0x73, 0x3f, 0xfc,
0x21, 0x7d, 0x37, 0x14, 0x43, 0x77, 0x00, 0x1e, 0xfa, 0x5c, 0x3c, 0xe1, 0x0a, 0xa4, 0x72, 0x2c,
0xc8, 0x8c, 0x02, 0xc8, 0xc9, 0xa0, 0x45, 0x00, 0xe5, 0x84, 0x0d, 0x9a, 0xc6, 0xc2, 0xae, 0x2a,
0xdd, 0x73, 0x3b, 0x68, 0x19, 0x66, 0x5b, 0x84, 0x77, 0x58, 0x98, 0xa8, 0x50, 0xd7, 0x94, 0x7b,
0xf2, 0x5b, 0x12, 0x41, 0x7b, 0xf0, 0xf1, 0x20, 0x21, 0x36, 0x28, 0x86, 0xdc, 0x8e, 0x8c, 0xe5,
0xf6, 0x8e, 0xcf, 0x48, 0xd7, 0x9e, 0x55, 0xee, 0x32, 0x94, 0xf4, 0xaf, 0xf6, 0x04, 0xb7, 0xeb,
0x2a, 0xc8, 0x19, 0xe9, 0xfe, 0x54, 0x86, 0xfa, 0xb6, 0xcc, 0xf1, 0x2c, 0x1d, 0x16, 0xa0, 0x88,
0x49, 0xcf, 0xc4, 0x46, 0x2e, 0x91, 0x07, 0xd0, 0x22, 0xbd, 0x30, 0x0e, 0x95, 0x56, 0x05, 0x65,
0xf8, 0xbc, 0x97, 0xb4, 0xbd, 0x83, 0x5d, 0x9c, 0xe3, 0x40, 0x0e, 0x54, 0xef, 0xbd, 0x48, 0x28,
0x93, 0x29, 0x55, 0x54, 0x30, 0x43, 0x1a, 0x3d, 0x85, 0xb9, 0x6c, 0x7d, 0x57, 0x08, 0x26, 0x13,
0x55, 0xa6, 0xd1, 0xcd, 0xf1, 0x34, 0xca, 0x2b, 0xe5, 0x8d, 0xc8, 0xdc, 0x8b, 0x05, 0x1b, 0xe0,
0x51, 0x1c, 0x69, 0xe1, 0x36, 0xe1, 0x5c, 0x6a, 0xa8, 0xc2, 0x8f, 0x33, 0x52, 0xaa, 0xf3, 0x39,
0xa3, 0xb1, 0x20, 0x71, 0x57, 0x85, 0xbe, 0x86, 0x87, 0xb4, 0x54, 0x27, 0x5b, 0x6b, 0x75, 0x2a,
0x27, 0x52, 0x67, 0x44, 0xc6, 0xa8, 0x33, 0xb2, 0x87, 0xd6, 0xa1, 0xb4, 0xe1, 0x77, 0x76, 0x88,
0x8a, 0xf2, 0xec, 0xda, 0xe2, 0x38, 0xa0, 0x3a, 0xfe, 0x52, 0x85, 0x95, 0xab, 0x42, 0x3d, 0x87,
0xb5, 0x08, 0xfa, 0x06, 0xea, 0xf7, 0x62, 0x11, 0x8a, 0x88, 0xf4, 0x55, 0xc4, 0x6a, 0x32, 0x62,
0xcd, 0xf5, 0x57, 0xfb, 0x4b, 0x1f, 0x4c, 0xbd, 0x78, 0x52, 0x11, 0x46, 0x0d, 0x92, 0x93, 0xf2,
0x72, 0x10, 0x78, 0x04, 0x0f, 0x3d, 0x83, 0xf9, 0x4c, 0xd9, 0xcd, 0x38, 0x49, 0x05, 0xb7, 0x41,
0x59, 0xbd, 0x76, 0x42, 0xab, 0xb5, 0x90, 0x36, 0xfb, 0x10, 0x92, 0x73, 0x07, 0xd0, 0x78, 0xac,
0x64, 0x4e, 0xed, 0x92, 0x41, 0x96, 0x53, 0xbb, 0x64, 0x20, 0xcb, 0x7a, 0xcf, 0x8f, 0x52, 0x5d,
0xee, 0x35, 0xac, 0x89, 0xf5, 0xc2, 0x6d, 0x4b, 0x22, 0x8c, 0xbb, 0xf7, 0x54, 0x08, 0x5f, 0xc1,
0x85, 0x09, 0xaa, 0x4e, 0x80, 0xb8, 0x9a, 0x87, 0x18, 0xcf, 0xe9, 0x03, 0x48, 0xf7, 0x97, 0x22,
0xd4, 0xf3, 0x01, 0x43, 0xab, 0x70, 0x41, 0xdb, 0x89, 0x49, 0xaf, 0x45, 0x12, 0x46, 0x3a, 0xf2,
0x96, 0x30, 0xe0, 0x93, 0x8e, 0xd0, 0x1a, 0x5c, 0xdc, 0xec, 0x9b, 0x6d, 0x9e, 0x13, 0x29, 0xa8,
0x7a, 0x9c, 0x78, 0x86, 0x28, 0xbc, 0xa5, 0xa1, 0x94, 0x27, 0x72, 0x42, 0x45, 0x15, 0xb0, 0x8f,
0x8e, 0xce, 0x2a, 0x6f, 0xa2, 0xac, 0x8e, 0xdb, 0x64, 0x5c, 0xf4, 0x29, 0x54, 0xf4, 0x41, 0x56,
0x98, 0x57, 0x8e, 0xfe, 0x84, 0x06, 0xcb, 0x64, 0xa4, 0xb8, 0xb6, 0x83, 0xdb, 0xa5, 0x53, 0x88,
0x1b, 0x19, 0xe7, 0x3e, 0x38, 0xd3, 0x55, 0x3e, 0x4d, 0x0a, 0xb8, 0x3f, 0x5b, 0x70, 0x7e, 0xec,
0x43, 0xf2, 0xd5, 0x50, 0xf7, 0xa6, 0x86, 0x50, 0x6b, 0xd4, 0x82, 0x92, 0xae, 0xfc, 0x82, 0x52,
0xd8, 0x3b, 0x81, 0xc2, 0x5e, 0xae, 0xec, 0xb5, 0xb0, 0x73, 0x1b, 0xe0, 0x6c, 0xc9, 0xea, 0xfe,
0x6a, 0xc1, 0x9c, 0xa9, 0x32, 0xf3, 0xc4, 0xfa, 0xb0, 0x90, 0x95, 0x50, 0xb6, 0x67, 0x1e, 0xdb,
0x5b, 0x53, 0x0b, 0x54, 0xb3, 0x79, 0x87, 0xe5, 0xb4, 0x8e, 0x63, 0x70, 0xce, 0x46, 0x96, 0x57,
0x87, 0x58, 0x4f, 0xa5, 0xf9, 0x65, 0x98, 0xdb, 0x16, 0xbe, 0x48, 0xf9, 0xd4, 0x97, 0xc3, 0xfd,
0xc7, 0x82, 0xf9, 0x8c, 0xc7, 0x58, 0xf7, 0x3e, 0x54, 0xf7, 0x08, 0x13, 0xe4, 0x05, 0xe1, 0xc6,
0x2a, 0x7b, 0xdc, 0xaa, 0xaf, 0x15, 0x07, 0x1e, 0x72, 0xa2, 0x75, 0xa8, 0x72, 0x85, 0x43, 0xb2,
0x40, 0x2d, 0x4e, 0x93, 0x32, 0xdf, 0x1b, 0xf2, 0xa3, 0x06, 0xcc, 0x44, 0x34, 0xe0, 0xa6, 0x66,
0xde, 0x9e, 0x26, 0xf7, 0x90, 0x06, 0x58, 0x31, 0xa2, 0x8f, 0xa1, 0xfa, 0xdc, 0x67, 0x71, 0x18,
0x07, 0x59, 0x15, 0x2c, 0x4d, 0x13, 0x7a, 0xaa, 0xf9, 0xf0, 0x50, 0x40, 0x76, 0x3a, 0x65, 0x7d,
0x86, 0x1e, 0x40, 0xb9, 0x1b, 0x06, 0x84, 0x0b, 0xed, 0x92, 0xe6, 0x9a, 0xbc, 0xe4, 0x5f, 0xed,
0x2f, 0x5d, 0xcb, 0xdd, 0xe2, 0x34, 0x21, 0xb1, 0x6c, 0x76, 0xfd, 0x30, 0x26, 0x8c, 0x37, 0x02,
0x7a, 0x43, 0x8b, 0x78, 0x2d, 0xf5, 0x83, 0x0d, 0x82, 0xc4, 0x0a, 0xf5, 0x5d, 0xad, 0xee, 0x8b,
0xb3, 0x61, 0x69, 0x04, 0x59, 0x06, 0xb1, 0xdf, 0x27, 0xe6, 0x6d, 0x56, 0x6b, 0xd9, 0x38, 0x74,
0x64, 0x9e, 0x77, 0x55, 0x4b, 0x55, 0xc5, 0x86, 0x42, 0xeb, 0x50, 0xe1, 0xc2, 0x67, 0xf2, 0xce,
0x29, 0x9d, 0xb0, 0xe3, 0xc9, 0x04, 0xd0, 0x67, 0x50, 0xeb, 0xd0, 0x7e, 0x12, 0x11, 0x29, 0x5d,
0x3e, 0xa1, 0xf4, 0x81, 0x88, 0x4c, 0x3d, 0xc2, 0x18, 0x65, 0xaa, 0xd7, 0xaa, 0x61, 0x4d, 0xa0,
0x0f, 0x61, 0x2e, 0x61, 0x34, 0x60, 0x84, 0xf3, 0x2f, 0x18, 0x4d, 0x13, 0xf3, 0xc2, 0x9e, 0x97,
0x97, 0xf7, 0xa3, 0xfc, 0x01, 0x1e, 0xe5, 0x73, 0xff, 0x2e, 0x40, 0x3d, 0x9f, 0x22, 0x63, 0x4d,
0xe8, 0x03, 0x28, 0xeb, 0x84, 0xd3, 0xb9, 0x7e, 0x36, 0x1f, 0x6b, 0x84, 0x89, 0x3e, 0xb6, 0xa1,
0xd2, 0x49, 0x99, 0xea, 0x50, 0x75, 0xdf, 0x9a, 0x91, 0xd2, 0x52, 0x41, 0x85, 0x1f, 0x29, 0x1f,
0x17, 0xb1, 0x26, 0x64, 0xd3, 0x3a, 0x9c, 0x53, 0x4e, 0xd7, 0xb4, 0x0e, 0xc5, 0xf2, 0xf1, 0xab,
0xbc, 0x51, 0xfc, 0xaa, 0xa7, 0x8e, 0x9f, 0xfb, 0x9b, 0x05, 0xb5, 0x61, 0x6d, 0xe5, 0xbc, 0x6b,
0xbd, 0xb1, 0x77, 0x47, 0x3c, 0x53, 0x38, 0x9b, 0x67, 0x2e, 0x41, 0x99, 0x0b, 0x46, 0xfc, 0xbe,
0x1e, 0xa9, 0xb0, 0xa1, 0xe4, 0x2d, 0xd6, 0xe7, 0x81, 0x8a, 0x50, 0x1d, 0xcb, 0xa5, 0xfb, 0xaf,
0x05, 0x73, 0x23, 0xe5, 0xfe, 0xbf, 0xda, 0x72, 0x11, 0x4a, 0x11, 0xd9, 0x23, 0x7a, 0xe8, 0x2b,
0x62, 0x4d, 0xc8, 0x5d, 0xbe, 0x43, 0x99, 0x50, 0xca, 0xd5, 0xb1, 0x26, 0xa4, 0xce, 0x5d, 0x22,
0xfc, 0x30, 0x52, 0xf7, 0x52, 0x1d, 0x1b, 0x4a, 0xea, 0x9c, 0xb2, 0xc8, 0x34, 0xbe, 0x72, 0x89,
0x5c, 0x98, 0x09, 0xe3, 0x1e, 0x35, 0x69, 0xa3, 0x3a, 0x9b, 0x6d, 0x9a, 0xb2, 0x0e, 0xd9, 0x8c,
0x7b, 0x14, 0xab, 0x33, 0x74, 0x19, 0xca, 0xcc, 0x8f, 0x03, 0x92, 0x75, 0xbd, 0x35, 0xc9, 0x85,
0xe5, 0x0e, 0x36, 0x07, 0xae, 0x0b, 0x75, 0x35, 0x38, 0x6e, 0x11, 0x2e, 0xc7, 0x14, 0x99, 0xd6,
0x5d, 0x5f, 0xf8, 0xca, 0xec, 0x3a, 0x56, 0x6b, 0xf7, 0x3a, 0xa0, 0x87, 0x21, 0x17, 0x4f, 0xd5,
0xc0, 0xcb, 0x8f, 0x9b, 0x2a, 0xb7, 0xe1, 0xc2, 0x08, 0xb7, 0x79, 0x16, 0x3e, 0x39, 0x34, 0x57,
0x5e, 0x1d, 0xbf, 0x71, 0xd5, 0x5c, 0xed, 0x69, 0xc1, 0xd1, 0xf1, 0x72, 0xed, 0xaf, 0x22, 0x54,
0x36, 0xf4, 0x5f, 0x06, 0xe8, 0x31, 0xd4, 0x86, 0x63, 0x2b, 0x72, 0xc7, 0x61, 0x0e, 0xcf, 0xbf,
0xce, 0x95, 0x23, 0x79, 0x8c, 0x7e, 0xf7, 0xa1, 0xa4, 0x06, 0x78, 0x34, 0xe1, 0xdd, 0xc9, 0x4f,
0xf6, 0xce, 0xd1, 0x03, 0xf1, 0xaa, 0x25, 0x91, 0xd4, 0xa3, 0x3d, 0x09, 0x29, 0xdf, 0x6e, 0x3b,
0x4b, 0xc7, 0xbc, 0xf6, 0x68, 0x0b, 0xca, 0xe6, 0x26, 0x9b, 0xc4, 0x9a, 0x7f, 0x9a, 0x9d, 0xe5,
0xe9, 0x0c, 0x1a, 0x6c, 0xd5, 0x42, 0x5b, 0xc3, 0x09, 0x6a, 0x92, 0x6a, 0xf9, 0x34, 0x70, 0x8e,
0x39, 0x5f, 0xb1, 0x56, 0x2d, 0xf4, 0x0c, 0x66, 0x73, 0x81, 0x46, 0x13, 0x02, 0x3a, 0x9e, 0x35,
0xce, 0xbb, 0xc7, 0x70, 0x69, 0x65, 0x9b, 0xf5, 0x97, 0xaf, 0x17, 0xad, 0xdf, 0x5f, 0x2f, 0x5a,
0x7f, 0xbe, 0x5e, 0xb4, 0xda, 0x65, 0x55, 0xf2, 0xef, 0xfd, 0x17, 0x00, 0x00, 0xff, 0xff, 0x54,
0x8e, 0x72, 0x11, 0x36, 0x12, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -2442,6 +2451,18 @@ func (m *Vertex) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i -= len(m.XXX_unrecognized)
copy(dAtA[i:], m.XXX_unrecognized)
}
if m.ProgressGroup != nil {
{
size, err := m.ProgressGroup.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintControl(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x42
}
if len(m.Error) > 0 {
i -= len(m.Error)
copy(dAtA[i:], m.Error)
@ -2450,23 +2471,23 @@ func (m *Vertex) MarshalToSizedBuffer(dAtA []byte) (int, error) {
dAtA[i] = 0x3a
}
if m.Completed != nil {
n6, err6 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Completed, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.Completed):])
if err6 != nil {
return 0, err6
}
i -= n6
i = encodeVarintControl(dAtA, i, uint64(n6))
i--
dAtA[i] = 0x32
}
if m.Started != nil {
n7, err7 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Started, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.Started):])
n7, err7 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Completed, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.Completed):])
if err7 != nil {
return 0, err7
}
i -= n7
i = encodeVarintControl(dAtA, i, uint64(n7))
i--
dAtA[i] = 0x32
}
if m.Started != nil {
n8, err8 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Started, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.Started):])
if err8 != nil {
return 0, err8
}
i -= n8
i = encodeVarintControl(dAtA, i, uint64(n8))
i--
dAtA[i] = 0x2a
}
if m.Cached {
@ -2530,31 +2551,31 @@ func (m *VertexStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
copy(dAtA[i:], m.XXX_unrecognized)
}
if m.Completed != nil {
n8, err8 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Completed, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.Completed):])
if err8 != nil {
return 0, err8
}
i -= n8
i = encodeVarintControl(dAtA, i, uint64(n8))
i--
dAtA[i] = 0x42
}
if m.Started != nil {
n9, err9 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Started, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.Started):])
n9, err9 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Completed, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.Completed):])
if err9 != nil {
return 0, err9
}
i -= n9
i = encodeVarintControl(dAtA, i, uint64(n9))
i--
dAtA[i] = 0x42
}
if m.Started != nil {
n10, err10 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Started, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.Started):])
if err10 != nil {
return 0, err10
}
i -= n10
i = encodeVarintControl(dAtA, i, uint64(n10))
i--
dAtA[i] = 0x3a
}
n10, err10 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp):])
if err10 != nil {
return 0, err10
n11, err11 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp):])
if err11 != nil {
return 0, err11
}
i -= n10
i = encodeVarintControl(dAtA, i, uint64(n10))
i -= n11
i = encodeVarintControl(dAtA, i, uint64(n11))
i--
dAtA[i] = 0x32
if m.Total != 0 {
@ -2627,12 +2648,12 @@ func (m *VertexLog) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i--
dAtA[i] = 0x18
}
n11, err11 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp):])
if err11 != nil {
return 0, err11
n12, err12 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp):])
if err12 != nil {
return 0, err12
}
i -= n11
i = encodeVarintControl(dAtA, i, uint64(n11))
i -= n12
i = encodeVarintControl(dAtA, i, uint64(n12))
i--
dAtA[i] = 0x12
if len(m.Vertex) > 0 {
@ -3215,6 +3236,10 @@ func (m *Vertex) Size() (n int) {
if l > 0 {
n += 1 + l + sovControl(uint64(l))
}
if m.ProgressGroup != nil {
l = m.ProgressGroup.Size()
n += 1 + l + sovControl(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
@ -5954,6 +5979,42 @@ func (m *Vertex) Unmarshal(dAtA []byte) error {
}
m.Error = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 8:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ProgressGroup", 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 < 0 {
return ErrInvalidLengthControl
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.ProgressGroup == nil {
m.ProgressGroup = &pb.ProgressGroup{}
}
if err := m.ProgressGroup.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipControl(dAtA[iNdEx:])

1
vendor/github.com/moby/buildkit/api/services/control/control.proto generated vendored
View File

@ -115,6 +115,7 @@ message Vertex {
google.protobuf.Timestamp started = 5 [(gogoproto.stdtime) = true ];
google.protobuf.Timestamp completed = 6 [(gogoproto.stdtime) = true ];
string error = 7; // typed errors?
pb.ProgressGroup progressGroup = 8;
}
message VertexStatus {

2
vendor/github.com/moby/buildkit/api/services/control/generate.go generated vendored
View File

@ -1,3 +1,3 @@
package moby_buildkit_v1 //nolint:golint
package moby_buildkit_v1 //nolint:revive
//go:generate protoc -I=. -I=../../../vendor/ -I=../../../../../../ --gogo_out=plugins=grpc:. control.proto

2
vendor/github.com/moby/buildkit/api/types/generate.go generated vendored
View File

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

3
vendor/github.com/moby/buildkit/client/client.go generated vendored
View File

@ -26,6 +26,7 @@ import (
"go.opentelemetry.io/otel/trace"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials"
"google.golang.org/grpc/credentials/insecure"
)
type Client struct {
@ -102,7 +103,7 @@ func New(ctx context.Context, address string, opts ...ClientOpt) (*Client, error
gopts = append(gopts, grpc.WithContextDialer(dialFn))
}
if needWithInsecure {
gopts = append(gopts, grpc.WithInsecure())
gopts = append(gopts, grpc.WithTransportCredentials(insecure.NewCredentials()))
}
if address == "" {
address = appdefaults.Address

15
vendor/github.com/moby/buildkit/client/graph.go generated vendored
View File

@ -8,13 +8,14 @@ import (
)
type Vertex struct {
Digest digest.Digest
Inputs []digest.Digest
Name string
Started *time.Time
Completed *time.Time
Cached bool
Error string
Digest digest.Digest
Inputs []digest.Digest
Name string
Started *time.Time
Completed *time.Time
Cached bool
Error string
ProgressGroup *pb.ProgressGroup
}
type VertexStatus struct {

1
vendor/github.com/moby/buildkit/client/llb/definition.go generated vendored
View File

@ -160,7 +160,6 @@ func (d *DefinitionOp) Marshal(ctx context.Context, c *Constraints) (digest.Dige
meta := d.metas[d.dgst]
return d.dgst, d.defs[d.dgst], &meta, d.sources[d.dgst], nil
}
func (d *DefinitionOp) Output() Output {

108
vendor/github.com/moby/buildkit/client/llb/diff.go generated vendored Normal file
View File

@ -0,0 +1,108 @@
package llb
import (
"context"
"github.com/moby/buildkit/solver/pb"
digest "github.com/opencontainers/go-digest"
)
type DiffOp struct {
MarshalCache
lower Output
upper Output
output Output
constraints Constraints
}
func NewDiff(lower, upper State, c Constraints) *DiffOp {
addCap(&c, pb.CapDiffOp)
op := &DiffOp{
lower: lower.Output(),
upper: upper.Output(),
constraints: c,
}
op.output = &output{vertex: op}
return op
}
func (m *DiffOp) Validate(ctx context.Context, constraints *Constraints) error {
return nil
}
func (m *DiffOp) Marshal(ctx context.Context, constraints *Constraints) (digest.Digest, []byte, *pb.OpMetadata, []*SourceLocation, error) {
if m.Cached(constraints) {
return m.Load()
}
if err := m.Validate(ctx, constraints); err != nil {
return "", nil, nil, nil, err
}
proto, md := MarshalConstraints(constraints, &m.constraints)
proto.Platform = nil // diff op is not platform specific
op := &pb.DiffOp{}
op.Lower = &pb.LowerDiffInput{Input: pb.InputIndex(len(proto.Inputs))}
if m.lower == nil {
op.Lower.Input = pb.Empty
} else {
pbLowerInput, err := m.lower.ToInput(ctx, constraints)
if err != nil {
return "", nil, nil, nil, err
}
proto.Inputs = append(proto.Inputs, pbLowerInput)
}
op.Upper = &pb.UpperDiffInput{Input: pb.InputIndex(len(proto.Inputs))}
if m.upper == nil {
op.Upper.Input = pb.Empty
} else {
pbUpperInput, err := m.upper.ToInput(ctx, constraints)
if err != nil {
return "", nil, nil, nil, err
}
proto.Inputs = append(proto.Inputs, pbUpperInput)
}
proto.Op = &pb.Op_Diff{Diff: op}
dt, err := proto.Marshal()
if err != nil {
return "", nil, nil, nil, err
}
m.Store(dt, md, m.constraints.SourceLocations, constraints)
return m.Load()
}
func (m *DiffOp) Output() Output {
return m.output
}
func (m *DiffOp) Inputs() (out []Output) {
if m.lower != nil {
out = append(out, m.lower)
}
if m.upper != nil {
out = append(out, m.upper)
}
return out
}
func Diff(lower, upper State, opts ...ConstraintsOpt) State {
if lower.Output() == nil {
if upper.Output() == nil {
// diff of scratch and scratch is scratch
return Scratch()
}
// diff of scratch and upper is just upper
return upper
}
var c Constraints
for _, o := range opts {
o.SetConstraintsOption(&c)
}
return NewState(NewDiff(lower, upper, c).Output())
}

40
vendor/github.com/moby/buildkit/client/llb/exec.go generated vendored
View File

@ -284,6 +284,12 @@ func (e *ExecOp) Marshal(ctx context.Context, c *Constraints) (digest.Digest, []
if len(e.secrets) > 0 {
addCap(&e.constraints, pb.CapExecMountSecret)
for _, s := range e.secrets {
if s.IsEnv {
addCap(&e.constraints, pb.CapExecSecretEnv)
break
}
}
}
if len(e.ssh) > 0 {
@ -369,18 +375,26 @@ func (e *ExecOp) Marshal(ctx context.Context, c *Constraints) (digest.Digest, []
}
for _, s := range e.secrets {
pm := &pb.Mount{
Dest: s.Target,
MountType: pb.MountType_SECRET,
SecretOpt: &pb.SecretOpt{
if s.IsEnv {
peo.Secretenv = append(peo.Secretenv, &pb.SecretEnv{
ID: s.ID,
Uid: uint32(s.UID),
Gid: uint32(s.GID),
Name: s.Target,
Optional: s.Optional,
Mode: uint32(s.Mode),
},
})
} else {
pm := &pb.Mount{
Dest: s.Target,
MountType: pb.MountType_SECRET,
SecretOpt: &pb.SecretOpt{
ID: s.ID,
Uid: uint32(s.UID),
Gid: uint32(s.GID),
Optional: s.Optional,
Mode: uint32(s.Mode),
},
}
peo.Mounts = append(peo.Mounts, pm)
}
peo.Mounts = append(peo.Mounts, pm)
}
for _, s := range e.ssh {
@ -661,6 +675,7 @@ type SecretInfo struct {
UID int
GID int
Optional bool
IsEnv bool
}
var SecretOptional = secretOptionFunc(func(si *SecretInfo) {
@ -673,6 +688,13 @@ func SecretID(id string) SecretOption {
})
}
// SecretAsEnv defines if the secret should be added as an environment variable
func SecretAsEnv(v bool) SecretOption {
return secretOptionFunc(func(si *SecretInfo) {
si.IsEnv = v
})
}
func SecretFileOpt(uid, gid, mode int) SecretOption {
return secretOptionFunc(func(si *SecretInfo) {
si.UID = uid

12
vendor/github.com/moby/buildkit/client/llb/fileop.go generated vendored
View File

@ -683,12 +683,18 @@ func (f *FileOp) Marshal(ctx context.Context, c *Constraints) (digest.Digest, []
f.constraints.Platform = p
}
state := newMarshalState(ctx)
for _, st := range state.actions {
if adder, isCapAdder := st.action.(capAdder); isCapAdder {
adder.addCaps(f)
}
}
pop, md := MarshalConstraints(c, &f.constraints)
pop.Op = &pb.Op_File{
File: pfo,
}
state := newMarshalState(ctx)
_, err := state.add(f.action, c)
if err != nil {
return "", nil, nil, nil, err
@ -696,10 +702,6 @@ func (f *FileOp) Marshal(ctx context.Context, c *Constraints) (digest.Digest, []
pop.Inputs = state.inputs
for i, st := range state.actions {
if adder, isCapAdder := st.action.(capAdder); isCapAdder {
adder.addCaps(f)
}
output := pb.OutputIndex(-1)
if i+1 == len(state.actions) {
output = 0

10
vendor/github.com/moby/buildkit/client/llb/state.go generated vendored
View File

@ -505,6 +505,10 @@ func mergeMetadata(m1, m2 pb.OpMetadata) pb.OpMetadata {
m1.Caps[k] = true
}
if m2.ProgressGroup != nil {
m1.ProgressGroup = m2.ProgressGroup
}
return m1
}
@ -594,6 +598,12 @@ func LocalUniqueID(v string) ConstraintsOpt {
})
}
func ProgressGroup(id, name string) ConstraintsOpt {
return constraintsOptFunc(func(c *Constraints) {
c.Metadata.ProgressGroup = &pb.ProgressGroup{Id: id, Name: name}
})
}
var (
LinuxAmd64 = Platform(ocispecs.Platform{OS: "linux", Architecture: "amd64"})
LinuxArmhf = Platform(ocispecs.Platform{OS: "linux", Architecture: "arm", Variant: "v7"})

16
vendor/github.com/moby/buildkit/client/solve.go generated vendored
View File

@ -263,13 +263,14 @@ func (c *Client) solve(ctx context.Context, def *llb.Definition, runGateway runG
s := SolveStatus{}
for _, v := range resp.Vertexes {
s.Vertexes = append(s.Vertexes, &Vertex{
Digest: v.Digest,
Inputs: v.Inputs,
Name: v.Name,
Started: v.Started,
Completed: v.Completed,
Error: v.Error,
Cached: v.Cached,
Digest: v.Digest,
Inputs: v.Inputs,
Name: v.Name,
Started: v.Started,
Completed: v.Completed,
Error: v.Error,
Cached: v.Cached,
ProgressGroup: v.ProgressGroup,
})
}
for _, v := range resp.Statuses {
@ -459,7 +460,6 @@ func parseCacheOptions(ctx context.Context, opt SolveOpt) (*cacheOptions, error)
}
}
contentStores["local:"+csDir] = cs
}
if im.Type == "registry" {
legacyImportRef := attrs["ref"]

3
vendor/github.com/moby/buildkit/frontend/gateway/client/client.go generated vendored
View File

@ -3,6 +3,7 @@ package client
import (
"context"
"io"
"syscall"
"github.com/moby/buildkit/client/llb"
"github.com/moby/buildkit/solver/pb"
@ -76,7 +77,7 @@ type WinSize struct {
type ContainerProcess interface {
Wait() error
Resize(ctx context.Context, size WinSize) error
// TODO Signal(ctx context.Context, sig os.Signal)
Signal(ctx context.Context, sig syscall.Signal) error
}
type Reference interface {

33
vendor/github.com/moby/buildkit/frontend/gateway/grpcclient/client.go generated vendored
View File

@ -9,10 +9,9 @@ import (
"os"
"strings"
"sync"
"syscall"
"time"
"github.com/moby/buildkit/util/bklog"
"github.com/gogo/googleapis/google/rpc"
gogotypes "github.com/gogo/protobuf/types"
"github.com/golang/protobuf/ptypes/any"
@ -22,7 +21,9 @@ import (
"github.com/moby/buildkit/identity"
opspb "github.com/moby/buildkit/solver/pb"
"github.com/moby/buildkit/util/apicaps"
"github.com/moby/buildkit/util/bklog"
"github.com/moby/buildkit/util/grpcerrors"
"github.com/moby/sys/signal"
digest "github.com/opencontainers/go-digest"
"github.com/pkg/errors"
fstypes "github.com/tonistiigi/fsutil/types"
@ -30,6 +31,7 @@ import (
spb "google.golang.org/genproto/googleapis/rpc/status"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/credentials/insecure"
"google.golang.org/grpc/status"
)
@ -642,6 +644,8 @@ func debugMessage(msg *pb.ExecMessage) string {
return fmt.Sprintf("File Message %s, fd=%d, %d bytes", msg.ProcessID, m.File.Fd, len(m.File.Data))
case *pb.ExecMessage_Resize:
return fmt.Sprintf("Resize Message %s", msg.ProcessID)
case *pb.ExecMessage_Signal:
return fmt.Sprintf("Signal Message %s: %s", msg.ProcessID, m.Signal.Name)
case *pb.ExecMessage_Started:
return fmt.Sprintf("Started Message %s", msg.ProcessID)
case *pb.ExecMessage_Exit:
@ -963,6 +967,29 @@ func (ctrProc *containerProcess) Resize(_ context.Context, size client.WinSize)
})
}
var sigToName = map[syscall.Signal]string{}
func init() {
for name, value := range signal.SignalMap {
sigToName[value] = name
}
}
func (ctrProc *containerProcess) Signal(_ context.Context, sig syscall.Signal) error {
name := sigToName[sig]
if name == "" {
return errors.Errorf("unknown signal %v", sig)
}
return ctrProc.execMsgs.Send(&pb.ExecMessage{
ProcessID: ctrProc.id,
Input: &pb.ExecMessage_Signal{
Signal: &pb.SignalMessage{
Name: name,
},
},
})
}
type reference struct {
c *grpcClient
id string
@ -1042,7 +1069,7 @@ func grpcClientConn(ctx context.Context) (context.Context, *grpc.ClientConn, err
return stdioConn(), nil
})
cc, err := grpc.DialContext(ctx, "localhost", dialOpt, grpc.WithInsecure(), grpc.WithUnaryInterceptor(grpcerrors.UnaryClientInterceptor), grpc.WithStreamInterceptor(grpcerrors.StreamClientInterceptor))
cc, err := grpc.DialContext(ctx, "localhost", dialOpt, grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithUnaryInterceptor(grpcerrors.UnaryClientInterceptor), grpc.WithStreamInterceptor(grpcerrors.StreamClientInterceptor))
if err != nil {
return nil, nil, errors.Wrap(err, "failed to create grpc client")
}

14
vendor/github.com/moby/buildkit/frontend/gateway/pb/caps.go generated vendored
View File

@ -1,4 +1,4 @@
package moby_buildkit_v1_frontend //nolint:golint
package moby_buildkit_v1_frontend //nolint:revive
import "github.com/moby/buildkit/util/apicaps"
@ -44,6 +44,10 @@ const (
// /etc/hosts for containers created via gateway exec.
CapGatewayExecExtraHosts apicaps.CapID = "gateway.exec.extrahosts"
// CapGatewayExecExtraHosts is the capability to send signals to a process
// created via gateway exec.
CapGatewayExecSignals apicaps.CapID = "gateway.exec.signals"
// CapFrontendCaps can be used to check that frontends define support for certain capabilities
CapFrontendCaps apicaps.CapID = "frontend.caps"
@ -57,7 +61,6 @@ const (
)
func init() {
Caps.Init(apicaps.Cap{
ID: CapSolveBase,
Enabled: true,
@ -170,6 +173,13 @@ func init() {
Status: apicaps.CapStatusExperimental,
})
Caps.Init(apicaps.Cap{
ID: CapGatewayExecSignals,
Name: "gateway exec signals",
Enabled: true,
Status: apicaps.CapStatusExperimental,
})
Caps.Init(apicaps.Cap{
ID: CapFrontendCaps,
Name: "frontend capabilities",

2
vendor/github.com/moby/buildkit/frontend/gateway/pb/exit.go generated vendored
View File

@ -1,4 +1,4 @@
package moby_buildkit_v1_frontend //nolint:golint
package moby_buildkit_v1_frontend //nolint:revive
import (
"fmt"

542
vendor/github.com/moby/buildkit/frontend/gateway/pb/gateway.pb.go generated vendored
View File

@ -1679,6 +1679,7 @@ type ExecMessage struct {
// *ExecMessage_Started
// *ExecMessage_Exit
// *ExecMessage_Done
// *ExecMessage_Signal
Input isExecMessage_Input `protobuf_oneof:"Input"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
@ -1742,6 +1743,9 @@ type ExecMessage_Exit struct {
type ExecMessage_Done struct {
Done *DoneMessage `protobuf:"bytes,7,opt,name=Done,proto3,oneof" json:"Done,omitempty"`
}
type ExecMessage_Signal struct {
Signal *SignalMessage `protobuf:"bytes,8,opt,name=Signal,proto3,oneof" json:"Signal,omitempty"`
}
func (*ExecMessage_Init) isExecMessage_Input() {}
func (*ExecMessage_File) isExecMessage_Input() {}
@ -1749,6 +1753,7 @@ func (*ExecMessage_Resize) isExecMessage_Input() {}
func (*ExecMessage_Started) isExecMessage_Input() {}
func (*ExecMessage_Exit) isExecMessage_Input() {}
func (*ExecMessage_Done) isExecMessage_Input() {}
func (*ExecMessage_Signal) isExecMessage_Input() {}
func (m *ExecMessage) GetInput() isExecMessage_Input {
if m != nil {
@ -1806,6 +1811,13 @@ func (m *ExecMessage) GetDone() *DoneMessage {
return nil
}
func (m *ExecMessage) GetSignal() *SignalMessage {
if x, ok := m.GetInput().(*ExecMessage_Signal); ok {
return x.Signal
}
return nil
}
// XXX_OneofWrappers is for the internal use of the proto package.
func (*ExecMessage) XXX_OneofWrappers() []interface{} {
return []interface{}{
@ -1815,6 +1827,7 @@ func (*ExecMessage) XXX_OneofWrappers() []interface{} {
(*ExecMessage_Started)(nil),
(*ExecMessage_Exit)(nil),
(*ExecMessage_Done)(nil),
(*ExecMessage_Signal)(nil),
}
}
@ -2148,6 +2161,55 @@ func (m *ResizeMessage) GetCols() uint32 {
return 0
}
type SignalMessage struct {
// we only send name (ie HUP, INT) because the int values
// are platform dependent.
Name string `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SignalMessage) Reset() { *m = SignalMessage{} }
func (m *SignalMessage) String() string { return proto.CompactTextString(m) }
func (*SignalMessage) ProtoMessage() {}
func (*SignalMessage) Descriptor() ([]byte, []int) {
return fileDescriptor_f1a937782ebbded5, []int{35}
}
func (m *SignalMessage) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *SignalMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_SignalMessage.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *SignalMessage) XXX_Merge(src proto.Message) {
xxx_messageInfo_SignalMessage.Merge(m, src)
}
func (m *SignalMessage) XXX_Size() int {
return m.Size()
}
func (m *SignalMessage) XXX_DiscardUnknown() {
xxx_messageInfo_SignalMessage.DiscardUnknown(m)
}
var xxx_messageInfo_SignalMessage proto.InternalMessageInfo
func (m *SignalMessage) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func init() {
proto.RegisterType((*Result)(nil), "moby.buildkit.v1.frontend.Result")
proto.RegisterMapType((map[string][]byte)(nil), "moby.buildkit.v1.frontend.Result.MetadataEntry")
@ -2191,140 +2253,143 @@ func init() {
proto.RegisterType((*DoneMessage)(nil), "moby.buildkit.v1.frontend.DoneMessage")
proto.RegisterType((*FdMessage)(nil), "moby.buildkit.v1.frontend.FdMessage")
proto.RegisterType((*ResizeMessage)(nil), "moby.buildkit.v1.frontend.ResizeMessage")
proto.RegisterType((*SignalMessage)(nil), "moby.buildkit.v1.frontend.SignalMessage")
}
func init() { proto.RegisterFile("gateway.proto", fileDescriptor_f1a937782ebbded5) }
var fileDescriptor_f1a937782ebbded5 = []byte{
// 2048 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x58, 0xcd, 0x6f, 0x1b, 0xc7,
0x15, 0xf7, 0x8a, 0x94, 0x48, 0x3e, 0x7e, 0x58, 0x19, 0xa7, 0xe9, 0x7a, 0x11, 0x38, 0xca, 0x22,
0x55, 0x69, 0x47, 0x59, 0xa6, 0x72, 0x02, 0xb9, 0x72, 0x90, 0xd4, 0xfa, 0x82, 0x94, 0x48, 0xb2,
0x3a, 0x4a, 0x61, 0x20, 0x48, 0x81, 0xae, 0xb8, 0x43, 0x7a, 0xe1, 0xd5, 0xce, 0x76, 0x76, 0x68,
0x59, 0xc9, 0xa5, 0xbd, 0xf5, 0x58, 0xa0, 0x40, 0xaf, 0x05, 0xfa, 0x17, 0xf4, 0xd2, 0x6b, 0xcf,
0x39, 0xf6, 0x58, 0xf4, 0x10, 0x14, 0xfe, 0x1b, 0x8a, 0x9e, 0x8b, 0x37, 0x33, 0x4b, 0x2e, 0x29,
0x6a, 0x29, 0x22, 0x27, 0xee, 0xbc, 0x79, 0xbf, 0x37, 0xef, 0x6b, 0xde, 0x7b, 0x43, 0x68, 0xf6,
0x7d, 0xc9, 0x2e, 0xfc, 0x4b, 0x2f, 0x11, 0x5c, 0x72, 0x72, 0xf7, 0x9c, 0x9f, 0x5d, 0x7a, 0x67,
0x83, 0x30, 0x0a, 0x5e, 0x84, 0xd2, 0x7b, 0xf9, 0x33, 0xaf, 0x27, 0x78, 0x2c, 0x59, 0x1c, 0x38,
0x1f, 0xf4, 0x43, 0xf9, 0x7c, 0x70, 0xe6, 0x75, 0xf9, 0x79, 0xa7, 0xcf, 0xfb, 0xbc, 0xa3, 0x10,
0x67, 0x83, 0x9e, 0x5a, 0xa9, 0x85, 0xfa, 0xd2, 0x92, 0x9c, 0xf5, 0x49, 0xf6, 0x3e, 0xe7, 0xfd,
0x88, 0xf9, 0x49, 0x98, 0x9a, 0xcf, 0x8e, 0x48, 0xba, 0x9d, 0x54, 0xfa, 0x72, 0x90, 0x1a, 0xcc,
0x5a, 0x0e, 0x83, 0x8a, 0x74, 0x32, 0x45, 0x3a, 0x29, 0x8f, 0x5e, 0x32, 0xd1, 0x49, 0xce, 0x3a,
0x3c, 0xc9, 0xb8, 0x3b, 0xd7, 0x72, 0xfb, 0x49, 0xd8, 0x91, 0x97, 0x09, 0x4b, 0x3b, 0x17, 0x5c,
0xbc, 0x60, 0xc2, 0x00, 0x1e, 0x5e, 0x0b, 0x18, 0xc8, 0x30, 0x42, 0x54, 0xd7, 0x4f, 0x52, 0x3c,
0x04, 0x7f, 0x0d, 0x28, 0x6f, 0xb6, 0xe4, 0x71, 0x98, 0xca, 0x30, 0xec, 0x87, 0x9d, 0x5e, 0xaa,
0x30, 0xfa, 0x14, 0x34, 0x42, 0xb3, 0xbb, 0x7f, 0x28, 0xc1, 0x12, 0x65, 0xe9, 0x20, 0x92, 0x64,
0x15, 0x9a, 0x82, 0xf5, 0x76, 0x58, 0x22, 0x58, 0xd7, 0x97, 0x2c, 0xb0, 0xad, 0x15, 0xab, 0x5d,
0xdb, 0xbf, 0x45, 0xc7, 0xc9, 0xe4, 0x57, 0xd0, 0x12, 0xac, 0x97, 0xe6, 0x18, 0x17, 0x56, 0xac,
0x76, 0x7d, 0xfd, 0x7d, 0xef, 0xda, 0x60, 0x78, 0x94, 0xf5, 0x8e, 0xfc, 0x64, 0x04, 0xd9, 0xbf,
0x45, 0x27, 0x84, 0x90, 0x75, 0x28, 0x09, 0xd6, 0xb3, 0x4b, 0x4a, 0xd6, 0xbd, 0x62, 0x59, 0xfb,
0xb7, 0x28, 0x32, 0x93, 0x0d, 0x28, 0xa3, 0x14, 0xbb, 0xac, 0x40, 0xef, 0xce, 0x54, 0x60, 0xff,
0x16, 0x55, 0x00, 0xf2, 0x05, 0x54, 0xcf, 0x99, 0xf4, 0x03, 0x5f, 0xfa, 0x36, 0xac, 0x94, 0xda,
0xf5, 0xf5, 0x4e, 0x21, 0x18, 0x1d, 0xe4, 0x1d, 0x19, 0xc4, 0x6e, 0x2c, 0xc5, 0x25, 0x1d, 0x0a,
0x70, 0x1e, 0x43, 0x73, 0x6c, 0x8b, 0x2c, 0x43, 0xe9, 0x05, 0xbb, 0xd4, 0xfe, 0xa3, 0xf8, 0x49,
0xde, 0x84, 0xc5, 0x97, 0x7e, 0x34, 0x60, 0xca, 0x55, 0x0d, 0xaa, 0x17, 0x9b, 0x0b, 0x8f, 0xac,
0xad, 0x2a, 0x2c, 0x09, 0x25, 0xde, 0xfd, 0xb3, 0x05, 0xcb, 0x93, 0x7e, 0x22, 0x07, 0xc6, 0x42,
0x4b, 0x29, 0xf9, 0xf1, 0x1c, 0x2e, 0x46, 0x42, 0xaa, 0x55, 0x55, 0x22, 0x9c, 0x0d, 0xa8, 0x0d,
0x49, 0xb3, 0x54, 0xac, 0xe5, 0x54, 0x74, 0x37, 0xa0, 0x44, 0x59, 0x8f, 0xb4, 0x60, 0x21, 0x34,
0x49, 0x41, 0x17, 0xc2, 0x80, 0xac, 0x40, 0x29, 0x60, 0x3d, 0x13, 0xfc, 0x96, 0x97, 0x9c, 0x79,
0x3b, 0xac, 0x17, 0xc6, 0xa1, 0x0c, 0x79, 0x4c, 0x71, 0xcb, 0xfd, 0xab, 0x85, 0xc9, 0x85, 0x6a,
0x91, 0xcf, 0xc6, 0xec, 0x98, 0x9d, 0x2a, 0x57, 0xb4, 0x7f, 0x56, 0xac, 0xfd, 0x47, 0x79, 0xed,
0x67, 0xe6, 0x4f, 0xde, 0x3a, 0x09, 0x4d, 0xca, 0xe4, 0x40, 0xc4, 0x94, 0xfd, 0x76, 0xc0, 0x52,
0x49, 0x7e, 0x9e, 0x45, 0x44, 0xc9, 0x9f, 0x95, 0x56, 0xc8, 0x48, 0x0d, 0x80, 0xb4, 0x61, 0x91,
0x09, 0xc1, 0x85, 0xd1, 0x82, 0x78, 0xba, 0x72, 0x78, 0x22, 0xe9, 0x7a, 0xa7, 0xaa, 0x72, 0x50,
0xcd, 0xe0, 0x2e, 0x43, 0x2b, 0x3b, 0x35, 0x4d, 0x78, 0x9c, 0x32, 0xf7, 0x36, 0x34, 0x0f, 0xe2,
0x64, 0x20, 0x53, 0xa3, 0x87, 0xfb, 0x0f, 0x0b, 0x5a, 0x19, 0x45, 0xf3, 0x90, 0xaf, 0xa1, 0x3e,
0xf2, 0x71, 0xe6, 0xcc, 0xcd, 0x02, 0xfd, 0xc6, 0xf1, 0xb9, 0x00, 0x19, 0xdf, 0xe6, 0xc5, 0x39,
0xc7, 0xb0, 0x3c, 0xc9, 0x30, 0xc5, 0xd3, 0xef, 0x8d, 0x7b, 0x7a, 0x32, 0xf0, 0x39, 0xcf, 0xfe,
0xc9, 0x82, 0xbb, 0x94, 0xa9, 0x52, 0x78, 0x70, 0xee, 0xf7, 0xd9, 0x36, 0x8f, 0x7b, 0x61, 0x3f,
0x73, 0xf3, 0xb2, 0xca, 0xaa, 0x4c, 0x32, 0x26, 0x58, 0x1b, 0xaa, 0x27, 0x91, 0x2f, 0x7b, 0x5c,
0x9c, 0x1b, 0xe1, 0x0d, 0x14, 0x9e, 0xd1, 0xe8, 0x70, 0x97, 0xac, 0x40, 0xdd, 0x08, 0x3e, 0xe2,
0x01, 0x53, 0x35, 0xa3, 0x46, 0xf3, 0x24, 0x62, 0x43, 0xe5, 0x90, 0xf7, 0x8f, 0xfd, 0x73, 0xa6,
0x8a, 0x43, 0x8d, 0x66, 0x4b, 0xf7, 0x77, 0x16, 0x38, 0xd3, 0xb4, 0x32, 0x2e, 0xfe, 0x1c, 0x96,
0x76, 0xc2, 0x3e, 0x4b, 0x75, 0xf4, 0x6b, 0x5b, 0xeb, 0xdf, 0x7d, 0xff, 0xce, 0xad, 0x7f, 0x7f,
0xff, 0xce, 0x83, 0x5c, 0x5d, 0xe5, 0x09, 0x8b, 0xbb, 0x3c, 0x96, 0x7e, 0x18, 0x33, 0x81, 0xed,
0xe1, 0x83, 0x40, 0x41, 0x3c, 0x8d, 0xa4, 0x46, 0x02, 0x79, 0x0b, 0x96, 0xb4, 0x74, 0x73, 0xed,
0xcd, 0xca, 0xfd, 0xef, 0x22, 0x34, 0x4e, 0x51, 0x81, 0xcc, 0x17, 0x1e, 0xc0, 0xc8, 0x85, 0x26,
0xed, 0x26, 0x1d, 0x9b, 0xe3, 0x20, 0x0e, 0x54, 0xf7, 0x4c, 0x88, 0xcd, 0x75, 0x1d, 0xae, 0xc9,
0x57, 0x50, 0xcf, 0xbe, 0x9f, 0x26, 0xd2, 0x2e, 0xa9, 0x1c, 0x79, 0x54, 0x90, 0x23, 0x79, 0x4d,
0xbc, 0x1c, 0xd4, 0x64, 0x48, 0x8e, 0x42, 0x3e, 0x81, 0xbb, 0x07, 0xe7, 0x09, 0x17, 0x72, 0xdb,
0xef, 0x3e, 0x67, 0x74, 0xbc, 0x0b, 0x94, 0x57, 0x4a, 0xed, 0x1a, 0xbd, 0x9e, 0x81, 0xac, 0xc1,
0x1b, 0x7e, 0x14, 0xf1, 0x0b, 0x73, 0x69, 0x54, 0xfa, 0xdb, 0x8b, 0x2b, 0x56, 0xbb, 0x4a, 0xaf,
0x6e, 0x90, 0x0f, 0xe1, 0x4e, 0x8e, 0xf8, 0x44, 0x08, 0xff, 0x12, 0xf3, 0x65, 0x49, 0xf1, 0x4f,
0xdb, 0xc2, 0x0a, 0xb6, 0x17, 0xc6, 0x7e, 0x64, 0x83, 0xe2, 0xd1, 0x0b, 0xe2, 0x42, 0x63, 0xf7,
0x15, 0xaa, 0xc4, 0xc4, 0x13, 0x29, 0x85, 0x5d, 0x57, 0xa1, 0x18, 0xa3, 0x91, 0x13, 0x68, 0x28,
0x85, 0xb5, 0xee, 0xa9, 0xdd, 0x50, 0x4e, 0x5b, 0x2b, 0x70, 0x9a, 0x62, 0x7f, 0x9a, 0xe4, 0xae,
0xd2, 0x98, 0x04, 0xd2, 0x85, 0x56, 0xe6, 0x38, 0x7d, 0x07, 0xed, 0xa6, 0x92, 0xf9, 0x78, 0xde,
0x40, 0x68, 0xb4, 0x3e, 0x62, 0x42, 0x24, 0xa6, 0xc1, 0x2e, 0x5e, 0x37, 0x5f, 0x32, 0xbb, 0xa5,
0x6c, 0x1e, 0xae, 0x9d, 0x4f, 0x61, 0x79, 0x32, 0x96, 0xf3, 0x14, 0x7d, 0xe7, 0x97, 0x70, 0x67,
0x8a, 0x0a, 0x3f, 0xa8, 0x1e, 0xfc, 0xcd, 0x82, 0x37, 0xae, 0xf8, 0x8d, 0x10, 0x28, 0x7f, 0x79,
0x99, 0x30, 0x23, 0x52, 0x7d, 0x93, 0x23, 0x58, 0xc4, 0xb8, 0xa4, 0xf6, 0x82, 0x72, 0xda, 0xc6,
0x3c, 0x81, 0xf0, 0x14, 0x52, 0x3b, 0x4c, 0x4b, 0x71, 0x1e, 0x01, 0x8c, 0x88, 0x73, 0xb5, 0xbe,
0xaf, 0xa1, 0x69, 0xa2, 0x62, 0xca, 0xc3, 0xb2, 0x9e, 0x52, 0x0c, 0x18, 0x67, 0x90, 0x51, 0xbb,
0x28, 0xcd, 0xd9, 0x2e, 0xdc, 0x6f, 0xe1, 0x36, 0x65, 0x7e, 0xb0, 0x17, 0x46, 0xec, 0xfa, 0xaa,
0x88, 0x77, 0x3d, 0x8c, 0xd8, 0x89, 0x2f, 0x9f, 0x0f, 0xef, 0xba, 0x59, 0x93, 0x4d, 0x58, 0xa4,
0x7e, 0xdc, 0x67, 0xe6, 0xe8, 0xf7, 0x0a, 0x8e, 0x56, 0x87, 0x20, 0x2f, 0xd5, 0x10, 0xf7, 0x31,
0xd4, 0x86, 0x34, 0xac, 0x54, 0x4f, 0x7b, 0xbd, 0x94, 0xe9, 0xaa, 0x57, 0xa2, 0x66, 0x85, 0xf4,
0x43, 0x16, 0xf7, 0xcd, 0xd1, 0x25, 0x6a, 0x56, 0xee, 0x2a, 0x8e, 0x2a, 0x99, 0xe6, 0xc6, 0x35,
0x04, 0xca, 0x3b, 0x38, 0x4f, 0x59, 0xea, 0x82, 0xa9, 0x6f, 0x37, 0xc0, 0x36, 0xe7, 0x07, 0x3b,
0xa1, 0xb8, 0xde, 0x40, 0x1b, 0x2a, 0x3b, 0xa1, 0xc8, 0xd9, 0x97, 0x2d, 0xc9, 0x2a, 0x36, 0xc0,
0x6e, 0x34, 0x08, 0xd0, 0x5a, 0xc9, 0x44, 0x6c, 0x2a, 0xfd, 0x04, 0xd5, 0xfd, 0x4c, 0xfb, 0x51,
0x9d, 0x62, 0x94, 0x59, 0x83, 0x0a, 0x8b, 0xa5, 0x08, 0x59, 0xd6, 0x25, 0x89, 0xa7, 0x47, 0x60,
0x4f, 0x8d, 0xc0, 0xaa, 0x1b, 0xd3, 0x8c, 0xc5, 0xdd, 0x80, 0xdb, 0x48, 0x28, 0x0e, 0x04, 0x81,
0x72, 0x4e, 0x49, 0xf5, 0xed, 0x6e, 0xc2, 0xf2, 0x08, 0x68, 0x8e, 0x5e, 0x85, 0x32, 0x0e, 0xd8,
0xa6, 0x8c, 0x4f, 0x3b, 0x57, 0xed, 0xbb, 0x4d, 0xa8, 0x9f, 0x84, 0x71, 0xd6, 0x0f, 0xdd, 0xd7,
0x16, 0x34, 0x4e, 0x78, 0x3c, 0xea, 0x44, 0x27, 0x70, 0x3b, 0xbb, 0x81, 0x4f, 0x4e, 0x0e, 0xb6,
0xfd, 0x24, 0x33, 0x65, 0xe5, 0x6a, 0x98, 0xcd, 0x5b, 0xc0, 0xd3, 0x8c, 0x5b, 0x65, 0x6c, 0x5a,
0x74, 0x12, 0x4e, 0x7e, 0x01, 0x95, 0xc3, 0xc3, 0x2d, 0x25, 0x69, 0x61, 0x2e, 0x49, 0x19, 0x8c,
0x7c, 0x0a, 0x95, 0x67, 0xea, 0x89, 0x92, 0x9a, 0xc6, 0x32, 0x25, 0xe5, 0xb4, 0xa1, 0x9a, 0x8d,
0xb2, 0x2e, 0x17, 0x01, 0xcd, 0x40, 0xee, 0xff, 0x2c, 0xa8, 0x3f, 0xf3, 0x47, 0xb3, 0xd6, 0xe7,
0xb0, 0x14, 0xfc, 0xe0, 0x6e, 0xab, 0x97, 0x78, 0x8b, 0x23, 0xf6, 0x92, 0x45, 0x26, 0x55, 0xf5,
0x02, 0xa9, 0xe9, 0x73, 0x2e, 0xf4, 0xed, 0x6c, 0x50, 0xbd, 0xc0, 0xbc, 0x0e, 0x98, 0xf4, 0xc3,
0x48, 0x75, 0xad, 0x06, 0x35, 0x2b, 0x8c, 0xfa, 0x40, 0x44, 0xaa, 0x29, 0xd5, 0x28, 0x7e, 0x12,
0x17, 0xca, 0x61, 0xdc, 0xe3, 0xaa, 0xef, 0x98, 0xea, 0x76, 0xca, 0x07, 0xa2, 0xcb, 0x0e, 0xe2,
0x1e, 0xa7, 0x6a, 0x8f, 0xbc, 0x0b, 0x4b, 0x02, 0xaf, 0x51, 0x6a, 0x57, 0x94, 0x53, 0x6a, 0xc8,
0xa5, 0x2f, 0x9b, 0xd9, 0x70, 0x5b, 0xd0, 0xd0, 0x76, 0x9b, 0x69, 0xef, 0x8f, 0x0b, 0x70, 0xe7,
0x98, 0x5d, 0x6c, 0x67, 0x76, 0x65, 0x0e, 0x59, 0x81, 0xfa, 0x90, 0x76, 0xb0, 0x63, 0xd2, 0x2f,
0x4f, 0xc2, 0xc3, 0x8e, 0xf8, 0x20, 0x96, 0x59, 0x0c, 0xd5, 0x61, 0x8a, 0x42, 0xcd, 0x06, 0xf9,
0x09, 0x54, 0x8e, 0x99, 0xc4, 0xb7, 0xa4, 0xb2, 0xba, 0xb5, 0x5e, 0x47, 0x9e, 0x63, 0x26, 0x71,
0x34, 0xa2, 0xd9, 0x1e, 0xce, 0x5b, 0x49, 0x36, 0x6f, 0x95, 0xa7, 0xcd, 0x5b, 0xd9, 0x2e, 0xd9,
0x80, 0x7a, 0x97, 0xc7, 0xa9, 0x14, 0x7e, 0x88, 0x07, 0x2f, 0x2a, 0xe6, 0x1f, 0x21, 0xb3, 0x0e,
0xec, 0xf6, 0x68, 0x93, 0xe6, 0x39, 0xc9, 0x03, 0x00, 0xf6, 0x4a, 0x0a, 0x7f, 0x9f, 0xa7, 0x32,
0xb5, 0x97, 0x94, 0xc2, 0x80, 0x38, 0x24, 0x1c, 0x9c, 0xd0, 0xdc, 0xae, 0xfb, 0x16, 0xbc, 0x39,
0xee, 0x11, 0xe3, 0xaa, 0xc7, 0xf0, 0x63, 0xca, 0x22, 0xe6, 0xa7, 0x6c, 0x7e, 0x6f, 0xb9, 0x0e,
0xd8, 0x57, 0xc1, 0x46, 0xf0, 0xdf, 0x4b, 0x50, 0xdf, 0x7d, 0xc5, 0xba, 0x47, 0x2c, 0x4d, 0xfd,
0x3e, 0x23, 0x6f, 0x43, 0xed, 0x44, 0xf0, 0x2e, 0x4b, 0xd3, 0xa1, 0xac, 0x11, 0x81, 0x7c, 0x02,
0xe5, 0x83, 0x38, 0x94, 0xa6, 0xcd, 0xad, 0x16, 0x0e, 0xdd, 0xa1, 0x34, 0x32, 0xf1, 0xc1, 0x89,
0x4b, 0xb2, 0x09, 0x65, 0x2c, 0x12, 0x37, 0x29, 0xd4, 0x41, 0x0e, 0x8b, 0x18, 0xb2, 0xa5, 0x9e,
0xe8, 0xe1, 0x37, 0xcc, 0x44, 0xa9, 0x5d, 0xdc, 0x61, 0xc2, 0x6f, 0xd8, 0x48, 0x82, 0x41, 0x92,
0x5d, 0xa8, 0x9c, 0x4a, 0x5f, 0xe0, 0x9c, 0xa6, 0xa3, 0x77, 0xbf, 0x68, 0x10, 0xd1, 0x9c, 0x23,
0x29, 0x19, 0x16, 0x9d, 0xb0, 0xfb, 0x2a, 0x94, 0xe6, 0x36, 0x14, 0x39, 0x01, 0xd9, 0x72, 0x86,
0xe0, 0x12, 0xd1, 0x3b, 0x3c, 0x66, 0x76, 0x65, 0x26, 0x1a, 0xd9, 0x72, 0x68, 0x5c, 0x6e, 0x55,
0x60, 0x51, 0x4d, 0x22, 0xee, 0x5f, 0x2c, 0xa8, 0xe7, 0x7c, 0x7c, 0x83, 0x3b, 0xf3, 0x36, 0x94,
0xf1, 0x85, 0x6e, 0x62, 0x57, 0x55, 0x37, 0x86, 0x49, 0x9f, 0x2a, 0x2a, 0x5e, 0xfa, 0xbd, 0x40,
0x17, 0xb4, 0x26, 0xc5, 0x4f, 0xa4, 0x7c, 0x29, 0x2f, 0x95, 0xbb, 0xab, 0x14, 0x3f, 0xc9, 0x1a,
0x54, 0x4f, 0x59, 0x77, 0x20, 0x42, 0x79, 0xa9, 0x1c, 0xd8, 0x5a, 0x5f, 0x56, 0xa5, 0xc0, 0xd0,
0xd4, 0xc5, 0x1a, 0x72, 0xb8, 0x5f, 0x60, 0x62, 0x8d, 0x14, 0x24, 0x50, 0xde, 0xc6, 0x77, 0x0a,
0x6a, 0xd6, 0xa4, 0xea, 0x1b, 0x9f, 0x8a, 0xbb, 0xb3, 0x9e, 0x8a, 0xbb, 0xd9, 0x53, 0x71, 0x3c,
0x20, 0xd8, 0x39, 0x72, 0x0e, 0x72, 0x9f, 0x40, 0x6d, 0x98, 0x34, 0xf8, 0x4a, 0xdf, 0x0b, 0xcc,
0x49, 0x0b, 0x7b, 0x01, 0x9a, 0xb2, 0xfb, 0x74, 0x4f, 0x9d, 0x52, 0xa5, 0xf8, 0x39, 0xec, 0xd3,
0xa5, 0x5c, 0x9f, 0xde, 0xc0, 0x47, 0x70, 0x2e, 0x73, 0x90, 0x89, 0xf2, 0x8b, 0x34, 0x53, 0x19,
0xbf, 0xb5, 0x19, 0x51, 0xaa, 0x64, 0x29, 0x33, 0xa2, 0x74, 0xfd, 0x5f, 0x35, 0xa8, 0x1d, 0x1e,
0x6e, 0x6d, 0x89, 0x30, 0xe8, 0x33, 0xf2, 0x7b, 0x0b, 0xc8, 0xd5, 0xb7, 0x15, 0xf9, 0xa8, 0x38,
0x61, 0xa7, 0x3f, 0x10, 0x9d, 0x8f, 0xe7, 0x44, 0x99, 0xb6, 0xf9, 0x15, 0x2c, 0xaa, 0x91, 0x8d,
0xfc, 0xf4, 0x86, 0xa3, 0xb6, 0xd3, 0x9e, 0xcd, 0x68, 0x64, 0x77, 0xa1, 0x9a, 0x8d, 0x3d, 0xe4,
0x41, 0xa1, 0x7a, 0x63, 0x53, 0x9d, 0xf3, 0xfe, 0x8d, 0x78, 0xcd, 0x21, 0xbf, 0x81, 0x8a, 0x99,
0x66, 0xc8, 0xfd, 0x19, 0xb8, 0xd1, 0x5c, 0xe5, 0x3c, 0xb8, 0x09, 0xeb, 0xc8, 0x8c, 0x6c, 0x6a,
0x29, 0x34, 0x63, 0x62, 0x26, 0x2a, 0x34, 0xe3, 0xca, 0x18, 0xf4, 0x0c, 0xca, 0x38, 0xde, 0x90,
0xa2, 0x6b, 0x9e, 0x9b, 0x7f, 0x9c, 0xa2, 0x70, 0x8d, 0xcd, 0x45, 0xbf, 0xc6, 0x72, 0xa8, 0x9e,
0x88, 0xc5, 0x85, 0x30, 0xf7, 0x9f, 0x8e, 0x73, 0xff, 0x06, 0x9c, 0x23, 0xf1, 0xe6, 0x79, 0xd5,
0xbe, 0xc1, 0x1f, 0x2b, 0xb3, 0xc5, 0x4f, 0xfc, 0x85, 0xc3, 0xa1, 0x91, 0xef, 0x72, 0xc4, 0x2b,
0x80, 0x4e, 0x19, 0x10, 0x9c, 0xce, 0x8d, 0xf9, 0xcd, 0x81, 0xdf, 0xe2, 0xa8, 0x3e, 0xde, 0x01,
0xc9, 0x7a, 0xa1, 0x3b, 0xa6, 0xf6, 0x5a, 0xe7, 0xe1, 0x5c, 0x18, 0x73, 0xb8, 0xaf, 0x3b, 0xac,
0xe9, 0xa2, 0xa4, 0xb8, 0x61, 0x0c, 0x3b, 0xb1, 0x73, 0x43, 0xbe, 0xb6, 0xf5, 0xa1, 0x85, 0x79,
0x86, 0x93, 0x55, 0xa1, 0xec, 0xdc, 0xc8, 0x59, 0x98, 0x67, 0xf9, 0x11, 0x6d, 0xab, 0xf1, 0xdd,
0xeb, 0x7b, 0xd6, 0x3f, 0x5f, 0xdf, 0xb3, 0xfe, 0xf3, 0xfa, 0x9e, 0x75, 0xb6, 0xa4, 0xfe, 0x2f,
0x7f, 0xf8, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x8b, 0x9a, 0x89, 0x6b, 0x81, 0x18, 0x00, 0x00,
// 2078 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x58, 0x4f, 0x6f, 0x1b, 0xc7,
0x15, 0xd7, 0x8a, 0x94, 0x48, 0x3e, 0xfe, 0xb1, 0x32, 0x4e, 0x53, 0x7a, 0x11, 0x38, 0xca, 0x36,
0x55, 0x69, 0x47, 0x59, 0xa6, 0x72, 0x02, 0xb9, 0x72, 0x90, 0xd4, 0xfa, 0x07, 0x29, 0x91, 0x64,
0x75, 0x94, 0xc2, 0x40, 0x90, 0x02, 0x5d, 0x71, 0x87, 0xf4, 0xc2, 0xab, 0x9d, 0xed, 0xec, 0xd0,
0xb2, 0x92, 0x4b, 0x7b, 0xeb, 0xb1, 0x40, 0x81, 0x5e, 0x0b, 0xf4, 0x13, 0xf4, 0x13, 0xf4, 0x9c,
0x63, 0x8f, 0x45, 0x0f, 0x41, 0xe1, 0xcf, 0x50, 0x14, 0xe8, 0x2d, 0x78, 0x33, 0xb3, 0xe4, 0x92,
0xa2, 0x96, 0x24, 0x7c, 0xe2, 0xcc, 0xdb, 0xf7, 0x7b, 0xf3, 0xfe, 0xcd, 0x7b, 0x6f, 0x08, 0xf5,
0x9e, 0x27, 0xd9, 0xa5, 0x77, 0xe5, 0xc6, 0x82, 0x4b, 0x4e, 0xee, 0x5c, 0xf0, 0xf3, 0x2b, 0xf7,
0xbc, 0x1f, 0x84, 0xfe, 0xf3, 0x40, 0xba, 0x2f, 0x7e, 0xee, 0x76, 0x05, 0x8f, 0x24, 0x8b, 0x7c,
0xfb, 0x83, 0x5e, 0x20, 0x9f, 0xf5, 0xcf, 0xdd, 0x0e, 0xbf, 0x68, 0xf7, 0x78, 0x8f, 0xb7, 0x15,
0xe2, 0xbc, 0xdf, 0x55, 0x3b, 0xb5, 0x51, 0x2b, 0x2d, 0xc9, 0xde, 0x18, 0x67, 0xef, 0x71, 0xde,
0x0b, 0x99, 0x17, 0x07, 0x89, 0x59, 0xb6, 0x45, 0xdc, 0x69, 0x27, 0xd2, 0x93, 0xfd, 0xc4, 0x60,
0xd6, 0x33, 0x18, 0x54, 0xa4, 0x9d, 0x2a, 0xd2, 0x4e, 0x78, 0xf8, 0x82, 0x89, 0x76, 0x7c, 0xde,
0xe6, 0x71, 0xca, 0xdd, 0xbe, 0x91, 0xdb, 0x8b, 0x83, 0xb6, 0xbc, 0x8a, 0x59, 0xd2, 0xbe, 0xe4,
0xe2, 0x39, 0x13, 0x06, 0xf0, 0xe0, 0x46, 0x40, 0x5f, 0x06, 0x21, 0xa2, 0x3a, 0x5e, 0x9c, 0xe0,
0x21, 0xf8, 0x6b, 0x40, 0x59, 0xb3, 0x25, 0x8f, 0x82, 0x44, 0x06, 0x41, 0x2f, 0x68, 0x77, 0x13,
0x85, 0xd1, 0xa7, 0xa0, 0x11, 0x9a, 0xdd, 0xf9, 0x63, 0x01, 0x96, 0x29, 0x4b, 0xfa, 0xa1, 0x24,
0x6b, 0x50, 0x17, 0xac, 0xbb, 0xcb, 0x62, 0xc1, 0x3a, 0x9e, 0x64, 0x7e, 0xd3, 0x5a, 0xb5, 0x5a,
0x95, 0x83, 0x05, 0x3a, 0x4a, 0x26, 0xbf, 0x86, 0x86, 0x60, 0xdd, 0x24, 0xc3, 0xb8, 0xb8, 0x6a,
0xb5, 0xaa, 0x1b, 0xef, 0xbb, 0x37, 0x06, 0xc3, 0xa5, 0xac, 0x7b, 0xec, 0xc5, 0x43, 0xc8, 0xc1,
0x02, 0x1d, 0x13, 0x42, 0x36, 0xa0, 0x20, 0x58, 0xb7, 0x59, 0x50, 0xb2, 0xee, 0xe6, 0xcb, 0x3a,
0x58, 0xa0, 0xc8, 0x4c, 0x36, 0xa1, 0x88, 0x52, 0x9a, 0x45, 0x05, 0x7a, 0x77, 0xaa, 0x02, 0x07,
0x0b, 0x54, 0x01, 0xc8, 0x17, 0x50, 0xbe, 0x60, 0xd2, 0xf3, 0x3d, 0xe9, 0x35, 0x61, 0xb5, 0xd0,
0xaa, 0x6e, 0xb4, 0x73, 0xc1, 0xe8, 0x20, 0xf7, 0xd8, 0x20, 0xf6, 0x22, 0x29, 0xae, 0xe8, 0x40,
0x80, 0xfd, 0x08, 0xea, 0x23, 0x9f, 0xc8, 0x0a, 0x14, 0x9e, 0xb3, 0x2b, 0xed, 0x3f, 0x8a, 0x4b,
0xf2, 0x26, 0x2c, 0xbd, 0xf0, 0xc2, 0x3e, 0x53, 0xae, 0xaa, 0x51, 0xbd, 0xd9, 0x5a, 0x7c, 0x68,
0x6d, 0x97, 0x61, 0x59, 0x28, 0xf1, 0xce, 0x5f, 0x2c, 0x58, 0x19, 0xf7, 0x13, 0x39, 0x34, 0x16,
0x5a, 0x4a, 0xc9, 0x8f, 0xe7, 0x70, 0x31, 0x12, 0x12, 0xad, 0xaa, 0x12, 0x61, 0x6f, 0x42, 0x65,
0x40, 0x9a, 0xa6, 0x62, 0x25, 0xa3, 0xa2, 0xb3, 0x09, 0x05, 0xca, 0xba, 0xa4, 0x01, 0x8b, 0x81,
0x49, 0x0a, 0xba, 0x18, 0xf8, 0x64, 0x15, 0x0a, 0x3e, 0xeb, 0x9a, 0xe0, 0x37, 0xdc, 0xf8, 0xdc,
0xdd, 0x65, 0xdd, 0x20, 0x0a, 0x64, 0xc0, 0x23, 0x8a, 0x9f, 0x9c, 0xbf, 0x59, 0x98, 0x5c, 0xa8,
0x16, 0xf9, 0x6c, 0xc4, 0x8e, 0xe9, 0xa9, 0x72, 0x4d, 0xfb, 0xa7, 0xf9, 0xda, 0x7f, 0x94, 0xd5,
0x7e, 0x6a, 0xfe, 0x64, 0xad, 0x93, 0x50, 0xa7, 0x4c, 0xf6, 0x45, 0x44, 0xd9, 0xef, 0xfa, 0x2c,
0x91, 0xe4, 0x17, 0x69, 0x44, 0x94, 0xfc, 0x69, 0x69, 0x85, 0x8c, 0xd4, 0x00, 0x48, 0x0b, 0x96,
0x98, 0x10, 0x5c, 0x18, 0x2d, 0x88, 0xab, 0x2b, 0x87, 0x2b, 0xe2, 0x8e, 0x7b, 0xa6, 0x2a, 0x07,
0xd5, 0x0c, 0xce, 0x0a, 0x34, 0xd2, 0x53, 0x93, 0x98, 0x47, 0x09, 0x73, 0x6e, 0x41, 0xfd, 0x30,
0x8a, 0xfb, 0x32, 0x31, 0x7a, 0x38, 0xff, 0xb0, 0xa0, 0x91, 0x52, 0x34, 0x0f, 0xf9, 0x1a, 0xaa,
0x43, 0x1f, 0xa7, 0xce, 0xdc, 0xca, 0xd1, 0x6f, 0x14, 0x9f, 0x09, 0x90, 0xf1, 0x6d, 0x56, 0x9c,
0x7d, 0x02, 0x2b, 0xe3, 0x0c, 0x13, 0x3c, 0xfd, 0xde, 0xa8, 0xa7, 0xc7, 0x03, 0x9f, 0xf1, 0xec,
0x9f, 0x2d, 0xb8, 0x43, 0x99, 0x2a, 0x85, 0x87, 0x17, 0x5e, 0x8f, 0xed, 0xf0, 0xa8, 0x1b, 0xf4,
0x52, 0x37, 0xaf, 0xa8, 0xac, 0x4a, 0x25, 0x63, 0x82, 0xb5, 0xa0, 0x7c, 0x1a, 0x7a, 0xb2, 0xcb,
0xc5, 0x85, 0x11, 0x5e, 0x43, 0xe1, 0x29, 0x8d, 0x0e, 0xbe, 0x92, 0x55, 0xa8, 0x1a, 0xc1, 0xc7,
0xdc, 0x67, 0xaa, 0x66, 0x54, 0x68, 0x96, 0x44, 0x9a, 0x50, 0x3a, 0xe2, 0xbd, 0x13, 0xef, 0x82,
0xa9, 0xe2, 0x50, 0xa1, 0xe9, 0xd6, 0xf9, 0xbd, 0x05, 0xf6, 0x24, 0xad, 0x8c, 0x8b, 0x3f, 0x87,
0xe5, 0xdd, 0xa0, 0xc7, 0x12, 0x1d, 0xfd, 0xca, 0xf6, 0xc6, 0x77, 0xdf, 0xbf, 0xb3, 0xf0, 0xef,
0xef, 0xdf, 0xb9, 0x9f, 0xa9, 0xab, 0x3c, 0x66, 0x51, 0x87, 0x47, 0xd2, 0x0b, 0x22, 0x26, 0xb0,
0x3d, 0x7c, 0xe0, 0x2b, 0x88, 0xab, 0x91, 0xd4, 0x48, 0x20, 0x6f, 0xc1, 0xb2, 0x96, 0x6e, 0xae,
0xbd, 0xd9, 0x39, 0xff, 0x5d, 0x82, 0xda, 0x19, 0x2a, 0x90, 0xfa, 0xc2, 0x05, 0x18, 0xba, 0xd0,
0xa4, 0xdd, 0xb8, 0x63, 0x33, 0x1c, 0xc4, 0x86, 0xf2, 0xbe, 0x09, 0xb1, 0xb9, 0xae, 0x83, 0x3d,
0xf9, 0x0a, 0xaa, 0xe9, 0xfa, 0x49, 0x2c, 0x9b, 0x05, 0x95, 0x23, 0x0f, 0x73, 0x72, 0x24, 0xab,
0x89, 0x9b, 0x81, 0x9a, 0x0c, 0xc9, 0x50, 0xc8, 0x27, 0x70, 0xe7, 0xf0, 0x22, 0xe6, 0x42, 0xee,
0x78, 0x9d, 0x67, 0x8c, 0x8e, 0x76, 0x81, 0xe2, 0x6a, 0xa1, 0x55, 0xa1, 0x37, 0x33, 0x90, 0x75,
0x78, 0xc3, 0x0b, 0x43, 0x7e, 0x69, 0x2e, 0x8d, 0x4a, 0xff, 0xe6, 0xd2, 0xaa, 0xd5, 0x2a, 0xd3,
0xeb, 0x1f, 0xc8, 0x87, 0x70, 0x3b, 0x43, 0x7c, 0x2c, 0x84, 0x77, 0x85, 0xf9, 0xb2, 0xac, 0xf8,
0x27, 0x7d, 0xc2, 0x0a, 0xb6, 0x1f, 0x44, 0x5e, 0xd8, 0x04, 0xc5, 0xa3, 0x37, 0xc4, 0x81, 0xda,
0xde, 0x4b, 0x54, 0x89, 0x89, 0xc7, 0x52, 0x8a, 0x66, 0x55, 0x85, 0x62, 0x84, 0x46, 0x4e, 0xa1,
0xa6, 0x14, 0xd6, 0xba, 0x27, 0xcd, 0x9a, 0x72, 0xda, 0x7a, 0x8e, 0xd3, 0x14, 0xfb, 0x93, 0x38,
0x73, 0x95, 0x46, 0x24, 0x90, 0x0e, 0x34, 0x52, 0xc7, 0xe9, 0x3b, 0xd8, 0xac, 0x2b, 0x99, 0x8f,
0xe6, 0x0d, 0x84, 0x46, 0xeb, 0x23, 0xc6, 0x44, 0x62, 0x1a, 0xec, 0xe1, 0x75, 0xf3, 0x24, 0x6b,
0x36, 0x94, 0xcd, 0x83, 0xbd, 0xfd, 0x29, 0xac, 0x8c, 0xc7, 0x72, 0x9e, 0xa2, 0x6f, 0xff, 0x0a,
0x6e, 0x4f, 0x50, 0xe1, 0xb5, 0xea, 0xc1, 0xdf, 0x2d, 0x78, 0xe3, 0x9a, 0xdf, 0x08, 0x81, 0xe2,
0x97, 0x57, 0x31, 0x33, 0x22, 0xd5, 0x9a, 0x1c, 0xc3, 0x12, 0xc6, 0x25, 0x69, 0x2e, 0x2a, 0xa7,
0x6d, 0xce, 0x13, 0x08, 0x57, 0x21, 0xb5, 0xc3, 0xb4, 0x14, 0xfb, 0x21, 0xc0, 0x90, 0x38, 0x57,
0xeb, 0xfb, 0x1a, 0xea, 0x26, 0x2a, 0xa6, 0x3c, 0xac, 0xe8, 0x29, 0xc5, 0x80, 0x71, 0x06, 0x19,
0xb6, 0x8b, 0xc2, 0x9c, 0xed, 0xc2, 0xf9, 0x16, 0x6e, 0x51, 0xe6, 0xf9, 0xfb, 0x41, 0xc8, 0x6e,
0xae, 0x8a, 0x78, 0xd7, 0x83, 0x90, 0x9d, 0x7a, 0xf2, 0xd9, 0xe0, 0xae, 0x9b, 0x3d, 0xd9, 0x82,
0x25, 0xea, 0x45, 0x3d, 0x66, 0x8e, 0x7e, 0x2f, 0xe7, 0x68, 0x75, 0x08, 0xf2, 0x52, 0x0d, 0x71,
0x1e, 0x41, 0x65, 0x40, 0xc3, 0x4a, 0xf5, 0xa4, 0xdb, 0x4d, 0x98, 0xae, 0x7a, 0x05, 0x6a, 0x76,
0x48, 0x3f, 0x62, 0x51, 0xcf, 0x1c, 0x5d, 0xa0, 0x66, 0xe7, 0xac, 0xe1, 0xa8, 0x92, 0x6a, 0x6e,
0x5c, 0x43, 0xa0, 0xb8, 0x8b, 0xf3, 0x94, 0xa5, 0x2e, 0x98, 0x5a, 0x3b, 0x3e, 0xb6, 0x39, 0xcf,
0xdf, 0x0d, 0xc4, 0xcd, 0x06, 0x36, 0xa1, 0xb4, 0x1b, 0x88, 0x8c, 0x7d, 0xe9, 0x96, 0xac, 0x61,
0x03, 0xec, 0x84, 0x7d, 0x1f, 0xad, 0x95, 0x4c, 0x44, 0xa6, 0xd2, 0x8f, 0x51, 0x9d, 0xcf, 0xb4,
0x1f, 0xd5, 0x29, 0x46, 0x99, 0x75, 0x28, 0xb1, 0x48, 0x8a, 0x80, 0xa5, 0x5d, 0x92, 0xb8, 0x7a,
0x04, 0x76, 0xd5, 0x08, 0xac, 0xba, 0x31, 0x4d, 0x59, 0x9c, 0x4d, 0xb8, 0x85, 0x84, 0xfc, 0x40,
0x10, 0x28, 0x66, 0x94, 0x54, 0x6b, 0x67, 0x0b, 0x56, 0x86, 0x40, 0x73, 0xf4, 0x1a, 0x14, 0x71,
0xc0, 0x36, 0x65, 0x7c, 0xd2, 0xb9, 0xea, 0xbb, 0x53, 0x87, 0xea, 0x69, 0x10, 0xa5, 0xfd, 0xd0,
0x79, 0x65, 0x41, 0xed, 0x94, 0x47, 0xc3, 0x4e, 0x74, 0x0a, 0xb7, 0xd2, 0x1b, 0xf8, 0xf8, 0xf4,
0x70, 0xc7, 0x8b, 0x53, 0x53, 0x56, 0xaf, 0x87, 0xd9, 0xbc, 0x05, 0x5c, 0xcd, 0xb8, 0x5d, 0xc4,
0xa6, 0x45, 0xc7, 0xe1, 0xe4, 0x97, 0x50, 0x3a, 0x3a, 0xda, 0x56, 0x92, 0x16, 0xe7, 0x92, 0x94,
0xc2, 0xc8, 0xa7, 0x50, 0x7a, 0xaa, 0x9e, 0x28, 0x89, 0x69, 0x2c, 0x13, 0x52, 0x4e, 0x1b, 0xaa,
0xd9, 0x28, 0xeb, 0x70, 0xe1, 0xd3, 0x14, 0xe4, 0xfc, 0xcf, 0x82, 0xea, 0x53, 0x6f, 0x38, 0x6b,
0x7d, 0x0e, 0xcb, 0xfe, 0x6b, 0x77, 0x5b, 0xbd, 0xc5, 0x5b, 0x1c, 0xb2, 0x17, 0x2c, 0x34, 0xa9,
0xaa, 0x37, 0x48, 0x4d, 0x9e, 0x71, 0xa1, 0x6f, 0x67, 0x8d, 0xea, 0x0d, 0xe6, 0xb5, 0xcf, 0xa4,
0x17, 0x84, 0xaa, 0x6b, 0xd5, 0xa8, 0xd9, 0x61, 0xd4, 0xfb, 0x22, 0x54, 0x4d, 0xa9, 0x42, 0x71,
0x49, 0x1c, 0x28, 0x06, 0x51, 0x97, 0xab, 0xbe, 0x63, 0xaa, 0xdb, 0x19, 0xef, 0x8b, 0x0e, 0x3b,
0x8c, 0xba, 0x9c, 0xaa, 0x6f, 0xe4, 0x5d, 0x58, 0x16, 0x78, 0x8d, 0x92, 0x66, 0x49, 0x39, 0xa5,
0x82, 0x5c, 0xfa, 0xb2, 0x99, 0x0f, 0x4e, 0x03, 0x6a, 0xda, 0x6e, 0x33, 0xed, 0xfd, 0x69, 0x11,
0x6e, 0x9f, 0xb0, 0xcb, 0x9d, 0xd4, 0xae, 0xd4, 0x21, 0xab, 0x50, 0x1d, 0xd0, 0x0e, 0x77, 0x4d,
0xfa, 0x65, 0x49, 0x78, 0xd8, 0x31, 0xef, 0x47, 0x32, 0x8d, 0xa1, 0x3a, 0x4c, 0x51, 0xa8, 0xf9,
0x40, 0x7e, 0x0a, 0xa5, 0x13, 0x26, 0xf1, 0x2d, 0xa9, 0xac, 0x6e, 0x6c, 0x54, 0x91, 0xe7, 0x84,
0x49, 0x1c, 0x8d, 0x68, 0xfa, 0x0d, 0xe7, 0xad, 0x38, 0x9d, 0xb7, 0x8a, 0x93, 0xe6, 0xad, 0xf4,
0x2b, 0xd9, 0x84, 0x6a, 0x87, 0x47, 0x89, 0x14, 0x5e, 0x80, 0x07, 0x2f, 0x29, 0xe6, 0x1f, 0x21,
0xb3, 0x0e, 0xec, 0xce, 0xf0, 0x23, 0xcd, 0x72, 0x92, 0xfb, 0x00, 0xec, 0xa5, 0x14, 0xde, 0x01,
0x4f, 0x64, 0xd2, 0x5c, 0x56, 0x0a, 0x03, 0xe2, 0x90, 0x70, 0x78, 0x4a, 0x33, 0x5f, 0x9d, 0xb7,
0xe0, 0xcd, 0x51, 0x8f, 0x18, 0x57, 0x3d, 0x82, 0x1f, 0x53, 0x16, 0x32, 0x2f, 0x61, 0xf3, 0x7b,
0xcb, 0xb1, 0xa1, 0x79, 0x1d, 0x6c, 0x04, 0xff, 0xbf, 0x00, 0xd5, 0xbd, 0x97, 0xac, 0x73, 0xcc,
0x92, 0xc4, 0xeb, 0x31, 0xf2, 0x36, 0x54, 0x4e, 0x05, 0xef, 0xb0, 0x24, 0x19, 0xc8, 0x1a, 0x12,
0xc8, 0x27, 0x50, 0x3c, 0x8c, 0x02, 0x69, 0xda, 0xdc, 0x5a, 0xee, 0xd0, 0x1d, 0x48, 0x23, 0x13,
0x1f, 0x9c, 0xb8, 0x25, 0x5b, 0x50, 0xc4, 0x22, 0x31, 0x4b, 0xa1, 0xf6, 0x33, 0x58, 0xc4, 0x90,
0x6d, 0xf5, 0x44, 0x0f, 0xbe, 0x61, 0x26, 0x4a, 0xad, 0xfc, 0x0e, 0x13, 0x7c, 0xc3, 0x86, 0x12,
0x0c, 0x92, 0xec, 0x41, 0xe9, 0x4c, 0x7a, 0x02, 0xe7, 0x34, 0x1d, 0xbd, 0x7b, 0x79, 0x83, 0x88,
0xe6, 0x1c, 0x4a, 0x49, 0xb1, 0xe8, 0x84, 0xbd, 0x97, 0x81, 0x34, 0xb7, 0x21, 0xcf, 0x09, 0xc8,
0x96, 0x31, 0x04, 0xb7, 0x88, 0xde, 0xe5, 0x11, 0x6b, 0x96, 0xa6, 0xa2, 0x91, 0x2d, 0x83, 0xc6,
0x2d, 0xba, 0xe1, 0x2c, 0xe8, 0xe1, 0x7c, 0x57, 0x9e, 0xea, 0x06, 0xcd, 0x98, 0x71, 0x83, 0x26,
0x6c, 0x97, 0x60, 0x49, 0x4d, 0x33, 0xce, 0x5f, 0x2d, 0xa8, 0x66, 0xe2, 0x34, 0xc3, 0xbd, 0x7b,
0x1b, 0x8a, 0xf8, 0xca, 0x37, 0xf1, 0x2f, 0xab, 0x5b, 0xc7, 0xa4, 0x47, 0x15, 0x15, 0x0b, 0xc7,
0xbe, 0xaf, 0x8b, 0x62, 0x9d, 0xe2, 0x12, 0x29, 0x5f, 0xca, 0x2b, 0x15, 0xb2, 0x32, 0xc5, 0x25,
0x59, 0x87, 0xf2, 0x19, 0xeb, 0xf4, 0x45, 0x20, 0xaf, 0x54, 0x10, 0x1a, 0x1b, 0x2b, 0xaa, 0x9c,
0x18, 0x9a, 0xba, 0x9c, 0x03, 0x0e, 0xe7, 0x0b, 0x4c, 0xce, 0xa1, 0x82, 0x04, 0x8a, 0x3b, 0xf8,
0xd6, 0x41, 0xcd, 0xea, 0x54, 0xad, 0xf1, 0xb9, 0xb9, 0x37, 0xed, 0xb9, 0xb9, 0x97, 0x3e, 0x37,
0x47, 0x83, 0x8a, 0xdd, 0x27, 0xe3, 0x64, 0xe7, 0x31, 0x54, 0x06, 0x89, 0x87, 0x2f, 0xfd, 0x7d,
0xdf, 0x9c, 0xb4, 0xb8, 0xef, 0xa3, 0x29, 0x7b, 0x4f, 0xf6, 0xd5, 0x29, 0x65, 0x8a, 0xcb, 0x41,
0xaf, 0x2f, 0x64, 0x7a, 0xfd, 0x26, 0x3e, 0xa4, 0x33, 0xd9, 0x87, 0x4c, 0x94, 0x5f, 0x26, 0xa9,
0xca, 0xb8, 0xd6, 0x66, 0x84, 0x89, 0x92, 0xa5, 0xcc, 0x08, 0x13, 0xe7, 0x27, 0x50, 0x1f, 0x89,
0x17, 0x32, 0xa9, 0x97, 0x9b, 0x19, 0x09, 0x71, 0xbd, 0xf1, 0xaf, 0x0a, 0x54, 0x8e, 0x8e, 0xb6,
0xb7, 0x45, 0xe0, 0xf7, 0x18, 0xf9, 0x83, 0x05, 0xe4, 0xfa, 0x23, 0x8e, 0x7c, 0x94, 0x7f, 0x33,
0x26, 0xbf, 0x44, 0xed, 0x8f, 0xe7, 0x44, 0x99, 0xfe, 0xfc, 0x15, 0x2c, 0xa9, 0xd9, 0x90, 0xfc,
0x6c, 0xc6, 0x99, 0xde, 0x6e, 0x4d, 0x67, 0x34, 0xb2, 0x3b, 0x50, 0x4e, 0xe7, 0x2b, 0x72, 0x3f,
0x57, 0xbd, 0x91, 0xf1, 0xd1, 0x7e, 0x7f, 0x26, 0x5e, 0x73, 0xc8, 0x6f, 0xa1, 0x64, 0xc6, 0x26,
0x72, 0x6f, 0x0a, 0x6e, 0x38, 0xc0, 0xd9, 0xf7, 0x67, 0x61, 0x1d, 0x9a, 0x91, 0x8e, 0x47, 0xb9,
0x66, 0x8c, 0x0d, 0x5f, 0xb9, 0x66, 0x5c, 0x9b, 0xb7, 0x9e, 0x42, 0x11, 0xe7, 0x28, 0x92, 0x57,
0x4f, 0x32, 0x83, 0x96, 0x9d, 0x17, 0xae, 0x91, 0x01, 0xec, 0x37, 0x58, 0x77, 0xd5, 0x5b, 0x34,
0xbf, 0xe2, 0x66, 0xfe, 0x3c, 0xb2, 0xef, 0xcd, 0xc0, 0x39, 0x14, 0x6f, 0xde, 0x71, 0xad, 0x19,
0xfe, 0xc1, 0x99, 0x2e, 0x7e, 0xec, 0xbf, 0x22, 0x0e, 0xb5, 0x6c, 0x3b, 0x25, 0x6e, 0x0e, 0x74,
0xc2, 0x24, 0x62, 0xb7, 0x67, 0xe6, 0x37, 0x07, 0x7e, 0x8b, 0x6f, 0x82, 0xd1, 0x56, 0x4b, 0x36,
0x72, 0xdd, 0x31, 0xb1, 0xa9, 0xdb, 0x0f, 0xe6, 0xc2, 0x98, 0xc3, 0x3d, 0xdd, 0xca, 0x4d, 0xbb,
0x26, 0xf9, 0x9d, 0x69, 0xd0, 0xf2, 0xed, 0x19, 0xf9, 0x5a, 0xd6, 0x87, 0x16, 0xe6, 0x19, 0x8e,
0x70, 0xb9, 0xb2, 0x33, 0xb3, 0x6d, 0x6e, 0x9e, 0x65, 0x67, 0xc1, 0xed, 0xda, 0x77, 0xaf, 0xee,
0x5a, 0xff, 0x7c, 0x75, 0xd7, 0xfa, 0xcf, 0xab, 0xbb, 0xd6, 0xf9, 0xb2, 0xfa, 0x63, 0xfe, 0xc1,
0x0f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x92, 0x5d, 0x25, 0xb8, 0xea, 0x18, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -4500,6 +4565,27 @@ func (m *ExecMessage_Done) MarshalToSizedBuffer(dAtA []byte) (int, error) {
}
return len(dAtA) - i, nil
}
func (m *ExecMessage_Signal) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *ExecMessage_Signal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
if m.Signal != nil {
{
size, err := m.Signal.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintGateway(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x42
}
return len(dAtA) - i, nil
}
func (m *InitMessage) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@ -4540,20 +4626,20 @@ func (m *InitMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
dAtA[i] = 0x20
}
if len(m.Fds) > 0 {
dAtA25 := make([]byte, len(m.Fds)*10)
var j24 int
dAtA26 := make([]byte, len(m.Fds)*10)
var j25 int
for _, num := range m.Fds {
for num >= 1<<7 {
dAtA25[j24] = uint8(uint64(num)&0x7f | 0x80)
dAtA26[j25] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
j24++
j25++
}
dAtA25[j24] = uint8(num)
j24++
dAtA26[j25] = uint8(num)
j25++
}
i -= j24
copy(dAtA[i:], dAtA25[:j24])
i = encodeVarintGateway(dAtA, i, uint64(j24))
i -= j25
copy(dAtA[i:], dAtA26[:j25])
i = encodeVarintGateway(dAtA, i, uint64(j25))
i--
dAtA[i] = 0x1a
}
@ -4763,6 +4849,40 @@ func (m *ResizeMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *SignalMessage) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *SignalMessage) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *SignalMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.XXX_unrecognized != nil {
i -= len(m.XXX_unrecognized)
copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.Name) > 0 {
i -= len(m.Name)
copy(dAtA[i:], m.Name)
i = encodeVarintGateway(dAtA, i, uint64(len(m.Name)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func encodeVarintGateway(dAtA []byte, offset int, v uint64) int {
offset -= sovGateway(v)
base := offset
@ -5545,6 +5665,18 @@ func (m *ExecMessage_Done) Size() (n int) {
}
return n
}
func (m *ExecMessage_Signal) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.Signal != nil {
l = m.Signal.Size()
n += 1 + l + sovGateway(uint64(l))
}
return n
}
func (m *InitMessage) Size() (n int) {
if m == nil {
return 0
@ -5661,6 +5793,22 @@ func (m *ResizeMessage) Size() (n int) {
return n
}
func (m *SignalMessage) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.Name)
if l > 0 {
n += 1 + l + sovGateway(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func sovGateway(x uint64) (n int) {
return (math_bits.Len64(x|1) + 6) / 7
}
@ -10031,6 +10179,41 @@ func (m *ExecMessage) Unmarshal(dAtA []byte) error {
}
m.Input = &ExecMessage_Done{v}
iNdEx = postIndex
case 8:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Signal", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGateway
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthGateway
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthGateway
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
v := &SignalMessage{}
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
m.Input = &ExecMessage_Signal{v}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipGateway(dAtA[iNdEx:])
@ -10708,6 +10891,89 @@ func (m *ResizeMessage) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *SignalMessage) 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 ErrIntOverflowGateway
}
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: SignalMessage: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: SignalMessage: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGateway
}
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 ErrInvalidLengthGateway
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthGateway
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Name = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipGateway(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthGateway
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func skipGateway(dAtA []byte) (n int, err error) {
l := len(dAtA)
iNdEx := 0

8
vendor/github.com/moby/buildkit/frontend/gateway/pb/gateway.proto generated vendored
View File

@ -223,6 +223,8 @@ message ExecMessage {
// DoneMessage from server to client will be the last message for any
// process. Note that FdMessage might be sent after ExitMessage.
DoneMessage Done = 7;
// SignalMessage is used from client to server to send signal events
SignalMessage Signal = 8;
}
}
@ -253,3 +255,9 @@ message ResizeMessage{
uint32 Rows = 1;
uint32 Cols = 2;
}
message SignalMessage {
// we only send name (ie HUP, INT) because the int values
// are platform dependent.
string Name = 1;
}

2
vendor/github.com/moby/buildkit/frontend/gateway/pb/generate.go generated vendored
View File

@ -1,3 +1,3 @@
package moby_buildkit_v1_frontend //nolint:golint
package moby_buildkit_v1_frontend //nolint:revive
//go:generate protoc -I=. -I=../../../vendor/ -I=../../../../../../ --gogo_out=plugins=grpc:. gateway.proto

14
vendor/github.com/moby/buildkit/session/auth/authprovider/authprovider.go generated vendored
View File

@ -86,27 +86,25 @@ func (ap *authProvider) FetchToken(ctx context.Context, req *auth.FetchTokenRequ
progresswriter.Wrap(name, ap.logger, done)
}
ap.mu.Unlock()
// try GET first because Docker Hub does not support POST
// switch once support has landed
resp, err := authutil.FetchToken(ctx, http.DefaultClient, nil, to)
// credential information is provided, use oauth POST endpoint
resp, err := authutil.FetchTokenWithOAuth(ctx, http.DefaultClient, nil, "buildkit-client", to)
if err != nil {
var errStatus remoteserrors.ErrUnexpectedStatus
if errors.As(err, &errStatus) {
// retry with POST request
// Registries without support for POST may return 404 for POST /v2/token.
// As of September 2017, GCR is known to return 404.
// As of February 2018, JFrog Artifactory is known to return 401.
if (errStatus.StatusCode == 405 && to.Username != "") || errStatus.StatusCode == 404 || errStatus.StatusCode == 401 {
resp, err := authutil.FetchTokenWithOAuth(ctx, http.DefaultClient, nil, "buildkit-client", to)
resp, err := authutil.FetchToken(ctx, http.DefaultClient, nil, to)
if err != nil {
return nil, err
}
return toTokenResponse(resp.AccessToken, resp.IssuedAt, resp.ExpiresIn), nil
return toTokenResponse(resp.Token, resp.IssuedAt, resp.ExpiresIn), nil
}
}
return nil, err
}
return toTokenResponse(resp.Token, resp.IssuedAt, resp.ExpiresIn), nil
return toTokenResponse(resp.AccessToken, resp.IssuedAt, resp.ExpiresIn), nil
}
// do request anonymously
resp, err := authutil.FetchToken(ctx, http.DefaultClient, nil, to)

16
vendor/github.com/moby/buildkit/session/filesync/filesync.go generated vendored
View File

@ -70,7 +70,7 @@ func (sp *fsSyncProvider) handle(method string, stream grpc.ServerStream) (retEr
}
}
if pr == nil {
return errors.New("failed to negotiate protocol")
return InvalidSessionError{errors.New("failed to negotiate protocol")}
}
opts, _ := metadata.FromIncomingContext(stream.Context()) // if no metadata continue with empty object
@ -83,7 +83,7 @@ func (sp *fsSyncProvider) handle(method string, stream grpc.ServerStream) (retEr
dir, ok := sp.dirs[dirName]
if !ok {
return status.Errorf(codes.NotFound, "no access allowed to dir %q", dirName)
return InvalidSessionError{status.Errorf(codes.NotFound, "no access allowed to dir %q", dirName)}
}
excludes := opts[keyExcludePatterns]
@ -317,3 +317,15 @@ func CopyFileWriter(ctx context.Context, md map[string]string, c session.Caller)
return newStreamWriter(cc), nil
}
type InvalidSessionError struct {
err error
}
func (e InvalidSessionError) Error() string {
return e.err.Error()
}
func (e InvalidSessionError) Unwrap() error {
return e.err
}

3
vendor/github.com/moby/buildkit/session/grpc.go generated vendored
View File

@ -14,6 +14,7 @@ import (
"go.opentelemetry.io/otel/trace"
"golang.org/x/net/http2"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials/insecure"
"google.golang.org/grpc/health/grpc_health_v1"
)
@ -40,7 +41,7 @@ func grpcClientConn(ctx context.Context, conn net.Conn) (context.Context, *grpc.
dialOpts := []grpc.DialOption{
dialer,
grpc.WithInsecure(),
grpc.WithTransportCredentials(insecure.NewCredentials()),
}
if span := trace.SpanFromContext(ctx); span.SpanContext().IsValid() {

4
vendor/github.com/moby/buildkit/session/grpchijack/dial.go generated vendored
View File

@ -16,11 +16,8 @@ import (
func Dialer(api controlapi.ControlClient) session.Dialer {
return func(ctx context.Context, proto string, meta map[string][]string) (net.Conn, error) {
meta = lowerHeaders(meta)
md := metadata.MD(meta)
ctx = metadata.NewOutgoingContext(ctx, md)
stream, err := api.Session(ctx)
@ -126,7 +123,6 @@ func (c *conn) Close() (err error) {
c.lastBuf = append(c.lastBuf, c.buf...)
}
c.readMu.Unlock()
})
return nil
}

2
vendor/github.com/moby/buildkit/solver/errdefs/solve.go generated vendored
View File

@ -14,7 +14,7 @@ func init() {
typeurl.Register((*Solve)(nil), "github.com/moby/buildkit", "errdefs.Solve+json")
}
//nolint:golint
//nolint:revive
type IsSolve_Subject isSolve_Subject
// SolveError will be returned when an error is encountered during a solve that

14
vendor/github.com/moby/buildkit/solver/pb/caps.go generated vendored
View File

@ -53,6 +53,7 @@ const (
CapExecMountSecret apicaps.CapID = "exec.mount.secret"
CapExecMountSSH apicaps.CapID = "exec.mount.ssh"
CapExecCgroupsMounted apicaps.CapID = "exec.cgroup"
CapExecSecretEnv apicaps.CapID = "exec.secretenv"
CapFileBase apicaps.CapID = "file.base"
CapFileRmWildcard apicaps.CapID = "file.rm.wildcard"
@ -69,10 +70,10 @@ const (
CapRemoteCacheGHA apicaps.CapID = "cache.gha"
CapMergeOp apicaps.CapID = "mergeop"
CapDiffOp apicaps.CapID = "diffop"
)
func init() {
Caps.Init(apicaps.Cap{
ID: CapSourceImage,
Enabled: true,
@ -313,6 +314,12 @@ func init() {
Status: apicaps.CapStatusExperimental,
})
Caps.Init(apicaps.Cap{
ID: CapExecSecretEnv,
Enabled: true,
Status: apicaps.CapStatusExperimental,
})
Caps.Init(apicaps.Cap{
ID: CapFileBase,
Enabled: true,
@ -381,4 +388,9 @@ func init() {
Enabled: true,
Status: apicaps.CapStatusExperimental,
})
Caps.Init(apicaps.Cap{
ID: CapDiffOp,
Enabled: true,
Status: apicaps.CapStatusExperimental,
})
}

1583
vendor/github.com/moby/buildkit/solver/pb/ops.pb.go generated vendored
View File

File diff suppressed because it is too large Load Diff

29
vendor/github.com/moby/buildkit/solver/pb/ops.proto generated vendored
View File

@ -18,6 +18,7 @@ message Op {
FileOp file = 4;
BuildOp build = 5;
MergeOp merge = 6;
DiffOp diff = 7;
}
Platform platform = 10;
WorkerConstraints constraints = 11;
@ -46,6 +47,7 @@ message ExecOp {
repeated Mount mounts = 2;
NetMode network = 3;
SecurityMode security = 4;
repeated SecretEnv secretenv = 5;
}
// Meta is a set of arguments for ExecOp.
@ -85,6 +87,13 @@ enum SecurityMode {
INSECURE = 1; // privileged mode
}
// SecretEnv is an environment variable that is backed by a secret.
message SecretEnv {
string ID = 1;
string name = 2;
bool optional = 3;
}
// Mount specifies how to mount an input Op as a filesystem.
message Mount {
int64 input = 1 [(gogoproto.customtype) = "InputIndex", (gogoproto.nullable) = false];
@ -198,6 +207,8 @@ message OpMetadata {
ExportCache export_cache = 4;
map<string, bool> caps = 5 [(gogoproto.castkey) = "github.com/moby/buildkit/util/apicaps.CapID", (gogoproto.nullable) = false];
ProgressGroup progress_group = 6;
}
// Source is a source mapping description for a file
@ -240,6 +251,11 @@ message ExportCache {
bool Value = 1;
}
message ProgressGroup {
string id = 1;
string name = 2;
}
message ProxyEnv {
string http_proxy = 1;
string https_proxy = 2;
@ -372,3 +388,16 @@ message MergeInput {
message MergeOp {
repeated MergeInput inputs = 1;
}
message LowerDiffInput {
int64 input = 1 [(gogoproto.customtype) = "InputIndex", (gogoproto.nullable) = false];
}
message UpperDiffInput {
int64 input = 1 [(gogoproto.customtype) = "InputIndex", (gogoproto.nullable) = false];
}
message DiffOp {
LowerDiffInput lower = 1;
UpperDiffInput upper = 2;
}

2
vendor/github.com/moby/buildkit/util/apicaps/pb/generate.go generated vendored
View File

@ -1,3 +1,3 @@
package moby_buildkit_v1_apicaps //nolint:golint
package moby_buildkit_v1_apicaps //nolint:revive
//go:generate protoc -I=. -I=../../../vendor/ -I=../../../../../../ --gogo_out=plugins=grpc:. caps.proto

8
vendor/github.com/moby/buildkit/util/grpcerrors/grpcerrors.go generated vendored
View File

@ -169,7 +169,7 @@ func FromGRPC(err error) error {
}
}
err = &grpcStatusErr{st: status.FromProto(n)}
err = &grpcStatusError{st: status.FromProto(n)}
for _, s := range stacks {
if s != nil {
@ -188,18 +188,18 @@ func FromGRPC(err error) error {
return stack.Enable(err)
}
type grpcStatusErr struct {
type grpcStatusError struct {
st *status.Status
}
func (e *grpcStatusErr) Error() string {
func (e *grpcStatusError) Error() string {
if e.st.Code() == codes.OK || e.st.Code() == codes.Unknown {
return e.st.Message()
}
return e.st.Code().String() + ": " + e.st.Message()
}
func (e *grpcStatusErr) GRPCStatus() *status.Status {
func (e *grpcStatusError) GRPCStatus() *status.Status {
return e.st
}

317
vendor/github.com/moby/buildkit/util/progress/progressui/display.go generated vendored
View File

@ -103,28 +103,31 @@ type displayInfo struct {
}
type job struct {
startTime *time.Time
completedTime *time.Time
name string
status string
hasError bool
isCanceled bool
vertex *vertex
showTerm bool
intervals []interval
isCompleted bool
name string
status string
hasError bool
isCanceled bool
vertex *vertex
showTerm bool
}
type trace struct {
w io.Writer
startTime *time.Time
localTimeDiff time.Duration
vertexes []*vertex
byDigest map[digest.Digest]*vertex
nextIndex int
updates map[digest.Digest]struct{}
modeConsole bool
groups map[string]*vertexGroup // group id -> group
}
type vertex struct {
*client.Vertex
statuses []*status
byID map[string]*status
indent string
@ -149,6 +152,11 @@ type vertex struct {
term *vt100.VT100
termBytes int
termCount int
// Interval start time in unix nano -> interval. Using a map ensures
// that updates for the same interval overwrite their previous updates.
intervals map[int64]interval
mostRecentStart *time.Time
}
func (v *vertex) update(c int) {
@ -159,6 +167,160 @@ func (v *vertex) update(c int) {
v.count += c
}
func (v *vertex) isStarted() bool {
return len(v.intervals) > 0
}
func (v *vertex) isCompleted() bool {
for _, ival := range v.intervals {
if ival.stop == nil {
return false
}
}
return true
}
type vertexGroup struct {
*vertex
subVtxs map[digest.Digest]client.Vertex
}
func (vg *vertexGroup) refresh() (changed, newlyStarted bool) {
newVtx := *vg.Vertex
newVtx.Cached = true
alreadyStarted := vg.isStarted()
for _, subVtx := range vg.subVtxs {
if subVtx.Started != nil {
newInterval := interval{
start: subVtx.Started,
stop: subVtx.Completed,
}
prevInterval := vg.intervals[subVtx.Started.UnixNano()]
if !newInterval.isEqual(prevInterval) {
changed = true
}
if !alreadyStarted {
newlyStarted = true
}
vg.intervals[subVtx.Started.UnixNano()] = newInterval
if vg.mostRecentStart == nil || subVtx.Started.After(*vg.mostRecentStart) {
vg.mostRecentStart = subVtx.Started
}
}
// Group is considered cached iff all subvtxs are cached
newVtx.Cached = newVtx.Cached && subVtx.Cached
// Group error is set to the first error found in subvtxs, if any
if newVtx.Error == "" {
newVtx.Error = subVtx.Error
}
}
if vg.Cached != newVtx.Cached {
changed = true
}
if vg.Error != newVtx.Error {
changed = true
}
vg.Vertex = &newVtx
return changed, newlyStarted
}
type interval struct {
start *time.Time
stop *time.Time
}
func (ival interval) duration() time.Duration {
if ival.start == nil {
return 0
}
if ival.stop == nil {
return time.Since(*ival.start)
}
return ival.stop.Sub(*ival.start)
}
func (ival interval) isEqual(other interval) (isEqual bool) {
return equalTimes(ival.start, other.start) && equalTimes(ival.stop, other.stop)
}
func equalTimes(t1, t2 *time.Time) bool {
if t2 == nil {
return t1 == nil
}
if t1 == nil {
return false
}
return t1.Equal(*t2)
}
// mergeIntervals takes a slice of (start, stop) pairs and returns a slice where
// any intervals that overlap in time are combined into a single interval. If an
// interval's stop time is nil, it is treated as positive infinity and consumes
// any intervals after it. Intervals with nil start times are ignored and not
// returned.
func mergeIntervals(intervals []interval) []interval {
// remove any intervals that have not started
var filtered []interval
for _, interval := range intervals {
if interval.start != nil {
filtered = append(filtered, interval)
}
}
intervals = filtered
if len(intervals) == 0 {
return nil
}
// sort intervals by start time
sort.Slice(intervals, func(i, j int) bool {
return intervals[i].start.Before(*intervals[j].start)
})
var merged []interval
cur := intervals[0]
for i := 1; i < len(intervals); i++ {
next := intervals[i]
if cur.stop == nil {
// if cur doesn't stop, all intervals after it will be merged into it
merged = append(merged, cur)
return merged
}
if cur.stop.Before(*next.start) {
// if cur stops before next starts, no intervals after cur will be
// merged into it; cur stands on its own
merged = append(merged, cur)
cur = next
continue
}
if next.stop == nil {
// cur and next partially overlap, but next also never stops, so all
// subsequent intervals will be merged with both cur and next
merged = append(merged, interval{
start: cur.start,
stop: nil,
})
return merged
}
if cur.stop.After(*next.stop) || cur.stop.Equal(*next.stop) {
// cur fully subsumes next
continue
}
// cur partially overlaps with next, merge them together into cur
cur = interval{
start: cur.start,
stop: next.stop,
}
}
// append anything we are left with
merged = append(merged, cur)
return merged
}
type status struct {
*client.VertexStatus
}
@ -169,6 +331,7 @@ func newTrace(w io.Writer, modeConsole bool) *trace {
updates: make(map[digest.Digest]struct{}),
w: w,
modeConsole: modeConsole,
groups: make(map[string]*vertexGroup),
}
}
@ -222,7 +385,39 @@ func (t *trace) triggerVertexEvent(v *client.Vertex) {
}
func (t *trace) update(s *client.SolveStatus, termWidth int) {
groups := make(map[string]struct{})
for _, v := range s.Vertexes {
if t.startTime == nil {
t.startTime = v.Started
}
if v.ProgressGroup != nil {
group, ok := t.groups[v.ProgressGroup.Id]
if !ok {
t.nextIndex++
group = &vertexGroup{
vertex: &vertex{
Vertex: &client.Vertex{
Digest: digest.Digest(v.ProgressGroup.Id),
Name: v.ProgressGroup.Name,
},
byID: make(map[string]*status),
statusUpdates: make(map[string]struct{}),
index: t.nextIndex,
intervals: make(map[int64]interval),
},
subVtxs: make(map[digest.Digest]client.Vertex),
}
if t.modeConsole {
group.term = vt100.NewVT100(termHeight, termWidth-termPad)
}
t.groups[v.ProgressGroup.Id] = group
t.byDigest[group.Digest] = group.vertex
}
groups[v.ProgressGroup.Id] = struct{}{}
group.subVtxs[v.Digest] = *v
t.byDigest[v.Digest] = group.vertex
continue
}
prev, ok := t.byDigest[v.Digest]
if !ok {
t.nextIndex++
@ -230,24 +425,49 @@ func (t *trace) update(s *client.SolveStatus, termWidth int) {
byID: make(map[string]*status),
statusUpdates: make(map[string]struct{}),
index: t.nextIndex,
intervals: make(map[int64]interval),
}
if t.modeConsole {
t.byDigest[v.Digest].term = vt100.NewVT100(termHeight, termWidth-termPad)
}
}
t.triggerVertexEvent(v)
if v.Started != nil && (prev == nil || prev.Started == nil) {
if v.Started != nil && (prev == nil || !prev.isStarted()) {
if t.localTimeDiff == 0 {
t.localTimeDiff = time.Since(*v.Started)
}
t.vertexes = append(t.vertexes, t.byDigest[v.Digest])
}
// allow a duplicate initial vertex that shouldn't reset state
if !(prev != nil && prev.Started != nil && v.Started == nil) {
if !(prev != nil && prev.isStarted() && v.Started == nil) {
t.byDigest[v.Digest].Vertex = v
}
if v.Started != nil {
t.byDigest[v.Digest].intervals[v.Started.UnixNano()] = interval{
start: v.Started,
stop: v.Completed,
}
if t.byDigest[v.Digest].mostRecentStart == nil || v.Started.After(*t.byDigest[v.Digest].mostRecentStart) {
t.byDigest[v.Digest].mostRecentStart = v.Started
}
}
t.byDigest[v.Digest].jobCached = false
}
for groupID := range groups {
group := t.groups[groupID]
changed, newlyStarted := group.refresh()
if changed {
group.update(1)
t.updates[group.Digest] = struct{}{}
}
if newlyStarted {
if t.localTimeDiff == 0 {
t.localTimeDiff = time.Since(*group.mostRecentStart)
}
t.vertexes = append(t.vertexes, group.vertex)
}
group.jobCached = false
}
for _, s := range s.Statuses {
v, ok := t.byDigest[s.Vertex]
if !ok {
@ -293,8 +513,8 @@ func (t *trace) update(s *client.SolveStatus, termWidth int) {
v.logs[len(v.logs)-1] = append(v.logs[len(v.logs)-1], dt...)
} else {
ts := time.Duration(0)
if v.Started != nil {
ts = l.Timestamp.Sub(*v.Started)
if v.isStarted() {
ts = l.Timestamp.Sub(*v.mostRecentStart)
}
prec := 1
sec := ts.Seconds()
@ -339,12 +559,17 @@ func (t *trace) printErrorLogs(f io.Writer) {
func (t *trace) displayInfo() (d displayInfo) {
d.startTime = time.Now()
if t.localTimeDiff != 0 {
d.startTime = (*t.vertexes[0].Started).Add(t.localTimeDiff)
if t.startTime != nil {
d.startTime = t.startTime.Add(t.localTimeDiff)
}
d.countTotal = len(t.byDigest)
for _, v := range t.byDigest {
if v.Completed != nil {
if v.ProgressGroup != nil {
// don't count vtxs in a group, they are merged into a single vtx
d.countTotal--
continue
}
if v.isCompleted() {
d.countCompleted++
}
}
@ -356,11 +581,20 @@ func (t *trace) displayInfo() (d displayInfo) {
}
var jobs []*job
j := &job{
startTime: addTime(v.Started, t.localTimeDiff),
completedTime: addTime(v.Completed, t.localTimeDiff),
name: strings.Replace(v.Name, "\t", " ", -1),
vertex: v,
name: strings.Replace(v.Name, "\t", " ", -1),
vertex: v,
isCompleted: true,
}
for _, ival := range v.intervals {
j.intervals = append(j.intervals, interval{
start: addTime(ival.start, t.localTimeDiff),
stop: addTime(ival.stop, t.localTimeDiff),
})
if ival.stop == nil {
j.isCompleted = false
}
}
j.intervals = mergeIntervals(j.intervals)
if v.Error != "" {
if strings.HasSuffix(v.Error, context.Canceled.Error()) {
j.isCanceled = true
@ -377,9 +611,12 @@ func (t *trace) displayInfo() (d displayInfo) {
jobs = append(jobs, j)
for _, s := range v.statuses {
j := &job{
startTime: addTime(s.Started, t.localTimeDiff),
completedTime: addTime(s.Completed, t.localTimeDiff),
name: v.indent + "=> " + s.ID,
intervals: []interval{{
start: addTime(s.Started, t.localTimeDiff),
stop: addTime(s.Completed, t.localTimeDiff),
}},
isCompleted: s.Completed != nil,
name: v.indent + "=> " + s.ID,
}
if s.Total != 0 {
j.status = fmt.Sprintf("%.2f / %.2f", units.Bytes(s.Current), units.Bytes(s.Total))
@ -390,11 +627,18 @@ func (t *trace) displayInfo() (d displayInfo) {
}
for _, w := range v.warnings {
msg := "WARN: " + string(w.Short)
mostRecentStart := v.mostRecentStart
var mostRecentStop *time.Time
if mostRecentStart != nil {
mostRecentStop = v.intervals[mostRecentStart.UnixNano()].stop
}
j := &job{
startTime: addTime(v.Started, t.localTimeDiff),
completedTime: addTime(v.Completed, t.localTimeDiff),
name: msg,
isCanceled: true,
intervals: []interval{{
start: addTime(mostRecentStart, t.localTimeDiff),
stop: addTime(mostRecentStop, t.localTimeDiff),
}},
name: msg,
isCanceled: true,
}
jobs = append(jobs, j)
}
@ -456,10 +700,10 @@ func setupTerminals(jobs []*job, height int, all bool) []*job {
var candidates []*job
numInUse := 0
for _, j := range jobs {
if j.vertex != nil && j.vertex.termBytes > 0 && j.completedTime == nil {
if j.vertex != nil && j.vertex.termBytes > 0 && !j.isCompleted {
candidates = append(candidates, j)
}
if j.completedTime == nil {
if j.isCompleted {
numInUse++
}
}
@ -512,14 +756,13 @@ func (disp *display) print(d displayInfo, width, height int, all bool) {
fmt.Fprintln(disp.c, out)
lineCount := 0
for _, j := range d.jobs {
endTime := time.Now()
if j.completedTime != nil {
endTime = *j.completedTime
}
if j.startTime == nil {
if len(j.intervals) == 0 {
continue
}
dt := endTime.Sub(*j.startTime).Seconds()
var dt float64
for _, ival := range j.intervals {
dt += ival.duration().Seconds()
}
if dt < 0.05 {
dt = 0
}
@ -549,7 +792,7 @@ func (disp *display) print(d displayInfo, width, height int, all bool) {
}
out = align(out, timer, width)
if j.completedTime != nil {
if j.isCompleted {
color := colorRun
if j.isCanceled {
color = colorCancel
@ -609,7 +852,7 @@ func wrapHeight(j []*job, limit int) []*job {
// wrap things around if incomplete jobs were cut
var invisible []*job
for _, j := range j[:len(j)-limit] {
if j.completedTime == nil {
if !j.isCompleted {
invisible = append(invisible, j)
}
}
@ -617,7 +860,7 @@ func wrapHeight(j []*job, limit int) []*job {
if l := len(invisible); l > 0 {
rewrapped := make([]*job, 0, len(wrapped))
for _, j := range wrapped {
if j.completedTime == nil || l <= 0 {
if !j.isCompleted || l <= 0 {
rewrapped = append(rewrapped, j)
}
l--

2
vendor/github.com/moby/buildkit/util/progress/progressui/printer.go generated vendored
View File

@ -65,7 +65,6 @@ func (p *textMux) printVtx(t *trace, dgst digest.Digest) {
} else {
fmt.Fprintf(p.w, "#%d %s\n", v.index, v.Name)
}
}
if len(v.events) != 0 {
@ -180,7 +179,6 @@ func (p *textMux) printVtx(t *trace, dgst digest.Digest) {
}
fmt.Fprintf(p.w, "#%d DONE%s\n", v.index, tm)
}
}
delete(t.updates, dgst)

2
vendor/github.com/moby/buildkit/util/tracing/detect/detect.go generated vendored
View File

@ -12,7 +12,7 @@ import (
"github.com/pkg/errors"
"go.opentelemetry.io/otel/sdk/resource"
sdktrace "go.opentelemetry.io/otel/sdk/trace"
semconv "go.opentelemetry.io/otel/semconv/v1.4.0"
semconv "go.opentelemetry.io/otel/semconv/v1.7.0"
"go.opentelemetry.io/otel/trace"
)

14
vendor/github.com/moby/buildkit/util/tracing/env/traceenv.go generated vendored
View File

@ -18,9 +18,19 @@ func init() {
}
func initContext(ctx context.Context) context.Context {
// open-telemetry/opentelemetry-specification#740
parent := os.Getenv("TRACEPARENT")
state := os.Getenv("TRACESTATE")
if parent != "" {
tc := propagation.TraceContext{}
return tc.Extract(ctx, &textMap{parent: parent, state: state})
}
// deprecated: removed in v0.11.0
// previously defined in https://github.com/open-telemetry/opentelemetry-swift/blob/4ea467ed4b881d7329bf2254ca7ed7f2d9d6e1eb/Sources/OpenTelemetrySdk/Trace/Propagation/EnvironmentContextPropagator.swift#L14-L15
parent := os.Getenv("OTEL_TRACE_PARENT")
state := os.Getenv("OTEL_TRACE_STATE")
parent = os.Getenv("OTEL_TRACE_PARENT")
state = os.Getenv("OTEL_TRACE_STATE")
if parent == "" {
return ctx

4
vendor/github.com/moby/buildkit/util/tracing/tracing.go generated vendored
View File

@ -12,7 +12,7 @@ import (
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/codes"
"go.opentelemetry.io/otel/propagation"
semconv "go.opentelemetry.io/otel/semconv/v1.4.0"
semconv "go.opentelemetry.io/otel/semconv/v1.7.0"
"go.opentelemetry.io/otel/trace"
)
@ -57,7 +57,7 @@ func ContextWithSpanFromContext(ctx, ctx2 context.Context) context.Context {
return ctx
}
var DefaultTransport http.RoundTripper = NewTransport(http.DefaultTransport)
var DefaultTransport = NewTransport(http.DefaultTransport)
var DefaultClient = &http.Client{
Transport: DefaultTransport,