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 master@cbfd4023383d

Browse Source 
Signed-off-by: Justin Chadwell <me@jedevc.com>
This commit is contained in:
Justin Chadwell
2023-09-07 12:13:54 +01:00
parent e018f8b6fb
commit e2ebab5f26
60 changed files with 1912 additions and 664 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1986,7 +1986,7 @@ func init() {
func init() { proto.RegisterFile("control.proto", fileDescriptor_0c5120591600887d) }
var fileDescriptor_0c5120591600887d = []byte{
// 2261 bytes of a gzipped FileDescriptorProto
// 2260 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x59, 0xcd, 0x6e, 0x1b, 0xc9,
0x11, 0xde, 0x21, 0x25, 0xfe, 0x14, 0x29, 0x59, 0x6a, 0x7b, 0x8d, 0xc9, 0xc4, 0x2b, 0xc9, 0xb3,
0x76, 0x22, 0x38, 0xf6, 0x50, 0xcb, 0xac, 0x63, 0xaf, 0x9c, 0x38, 0x16, 0x45, 0x66, 0x2d, 0xc7,
@ -1995,140 +1995,140 @@ var fileDescriptor_0c5120591600887d = []byte{
0x13, 0x04, 0xf0, 0x31, 0xe7, 0x3d, 0x38, 0x81, 0x1f, 0x20, 0xc8, 0x31, 0xb9, 0x05, 0xfd, 0x33,
0xe4, 0x90, 0x33, 0x94, 0x28, 0xdb, 0x27, 0x76, 0x75, 0xd7, 0x57, 0x53, 0x55, 0x5d, 0x5d, 0x5d,
0xd5, 0x84, 0x85, 0x76, 0x18, 0x70, 0x1a, 0xfa, 0x4e, 0x44, 0x43, 0x1e, 0xa2, 0xa5, 0x5e, 0x78,
0x38, 0x70, 0x0e, 0xfb, 0x9e, 0xdf, 0x39, 0xf6, 0xb8, 0x73, 0xf2, 0x89, 0x75, 0xab, 0xeb, 0xf1,
0x17, 0xfd, 0x43, 0xa7, 0x1d, 0xf6, 0x6a, 0xdd, 0xb0, 0x1b, 0xd6, 0x24, 0xe3, 0x61, 0xff, 0x48,
0x52, 0x92, 0x90, 0x23, 0x25, 0xc0, 0x5a, 0xed, 0x86, 0x61, 0xd7, 0x27, 0x23, 0x2e, 0xee, 0xf5,
0x08, 0xe3, 0x6e, 0x2f, 0xd2, 0x0c, 0x37, 0x13, 0xf2, 0xc4, 0xc7, 0x6a, 0xf1, 0xc7, 0x6a, 0x2c,
0xf4, 0x4f, 0x08, 0xad, 0x45, 0x87, 0xb5, 0x30, 0x62, 0x9a, 0xbb, 0x36, 0x95, 0xdb, 0x8d, 0xbc,
0x1a, 0x1f, 0x44, 0x84, 0xd5, 0xbe, 0x0e, 0xe9, 0x31, 0xa1, 0x1a, 0x50, 0x9f, 0x54, 0x57, 0xe9,
0xe3, 0x46, 0x1e, 0xd3, 0xc3, 0x1a, 0x8d, 0xda, 0x35, 0xc6, 0x5d, 0xde, 0x8f, 0x3f, 0x72, 0xfb,
0x14, 0x95, 0xfa, 0xb4, 0x4d, 0xa2, 0xd0, 0xf7, 0xda, 0x03, 0xa1, 0x98, 0x1a, 0x29, 0x98, 0xfd,
0x5b, 0x03, 0xaa, 0x7b, 0xb4, 0x1f, 0x10, 0x4c, 0x7e, 0xd3, 0x27, 0x8c, 0xa3, 0xcb, 0x50, 0x38,
0xf2, 0x7c, 0x4e, 0xa8, 0x69, 0xac, 0xe5, 0xd7, 0xcb, 0x58, 0x53, 0x68, 0x09, 0xf2, 0xae, 0xef,
0x9b, 0xb9, 0x35, 0x63, 0xbd, 0x84, 0xc5, 0x10, 0xad, 0x43, 0xf5, 0x98, 0x90, 0xa8, 0xd9, 0xa7,
0x2e, 0xf7, 0xc2, 0xc0, 0xcc, 0xaf, 0x19, 0xeb, 0xf9, 0xc6, 0xdc, 0xab, 0xd7, 0xab, 0x06, 0x1e,
0x5b, 0x41, 0x36, 0x94, 0x05, 0xdd, 0x18, 0x70, 0xc2, 0xcc, 0xb9, 0x04, 0xdb, 0x68, 0xda, 0xbe,
0x01, 0x4b, 0x4d, 0x8f, 0x1d, 0x3f, 0x65, 0x6e, 0xf7, 0x2c, 0x5d, 0xec, 0x47, 0xb0, 0x9c, 0xe0,
0x65, 0x51, 0x18, 0x30, 0x82, 0x6e, 0x43, 0x81, 0x92, 0x76, 0x48, 0x3b, 0x92, 0xb9, 0x52, 0xff,
0xc8, 0x99, 0x0c, 0x03, 0x47, 0x03, 0x04, 0x13, 0xd6, 0xcc, 0xf6, 0x9f, 0xf2, 0x50, 0x49, 0xcc,
0xa3, 0x45, 0xc8, 0xed, 0x34, 0x4d, 0x63, 0xcd, 0x58, 0x2f, 0xe3, 0xdc, 0x4e, 0x13, 0x99, 0x50,
0xdc, 0xed, 0x73, 0xf7, 0xd0, 0x27, 0xda, 0xf6, 0x98, 0x44, 0x97, 0x60, 0x7e, 0x27, 0x78, 0xca,
0x88, 0x34, 0xbc, 0x84, 0x15, 0x81, 0x10, 0xcc, 0xed, 0x7b, 0xdf, 0x10, 0x65, 0x26, 0x96, 0x63,
0x64, 0x41, 0x61, 0xcf, 0xa5, 0x24, 0xe0, 0xe6, 0xbc, 0x90, 0xdb, 0xc8, 0x99, 0x06, 0xd6, 0x33,
0xa8, 0x01, 0xe5, 0x6d, 0x4a, 0x5c, 0x4e, 0x3a, 0x5b, 0xdc, 0x2c, 0xac, 0x19, 0xeb, 0x95, 0xba,
0xe5, 0xa8, 0x4d, 0x76, 0xe2, 0xf8, 0x73, 0x0e, 0xe2, 0xf8, 0x6b, 0x94, 0x5e, 0xbd, 0x5e, 0xfd,
0xe0, 0x0f, 0xff, 0x14, 0xbe, 0x1b, 0xc2, 0xd0, 0x03, 0x80, 0xc7, 0x2e, 0xe3, 0x4f, 0x99, 0x14,
0x52, 0x3c, 0x53, 0xc8, 0x9c, 0x14, 0x90, 0xc0, 0xa0, 0x15, 0x00, 0xe9, 0x84, 0xed, 0xb0, 0x1f,
0x70, 0xb3, 0x24, 0x75, 0x4f, 0xcc, 0xa0, 0x35, 0xa8, 0x34, 0x09, 0x6b, 0x53, 0x2f, 0x92, 0x5b,
0x5d, 0x96, 0xee, 0x49, 0x4e, 0x09, 0x09, 0xca, 0x83, 0x07, 0x83, 0x88, 0x98, 0x20, 0x19, 0x12,
0x33, 0x62, 0x2f, 0xf7, 0x5f, 0xb8, 0x94, 0x74, 0xcc, 0x8a, 0x74, 0x97, 0xa6, 0x84, 0x7f, 0x95,
0x27, 0x98, 0x59, 0x95, 0x9b, 0x1c, 0x93, 0xf6, 0xef, 0x8a, 0x50, 0xdd, 0x17, 0xc7, 0x29, 0x0e,
0x87, 0x25, 0xc8, 0x63, 0x72, 0xa4, 0xf7, 0x46, 0x0c, 0x91, 0x03, 0xd0, 0x24, 0x47, 0x5e, 0xe0,
0x49, 0xad, 0x72, 0xd2, 0xf0, 0x45, 0x27, 0x3a, 0x74, 0x46, 0xb3, 0x38, 0xc1, 0x81, 0x2c, 0x28,
0xb5, 0x5e, 0x46, 0x21, 0x15, 0x21, 0x95, 0x97, 0x62, 0x86, 0x34, 0x7a, 0x06, 0x0b, 0xf1, 0x78,
0x8b, 0x73, 0x2a, 0x02, 0x55, 0x84, 0xd1, 0x27, 0xe9, 0x30, 0x4a, 0x2a, 0xe5, 0x8c, 0x61, 0x5a,
0x01, 0xa7, 0x03, 0x3c, 0x2e, 0x47, 0x58, 0xb8, 0x4f, 0x18, 0x13, 0x1a, 0xca, 0xed, 0xc7, 0x31,
0x29, 0xd4, 0xf9, 0x05, 0x0d, 0x03, 0x4e, 0x82, 0x8e, 0xdc, 0xfa, 0x32, 0x1e, 0xd2, 0x42, 0x9d,
0x78, 0xac, 0xd4, 0x29, 0xce, 0xa4, 0xce, 0x18, 0x46, 0xab, 0x33, 0x36, 0x87, 0x36, 0x61, 0x7e,
0xdb, 0x6d, 0xbf, 0x20, 0x72, 0x97, 0x2b, 0xf5, 0x95, 0xb4, 0x40, 0xb9, 0xfc, 0x44, 0x6e, 0x2b,
0x93, 0x07, 0xf5, 0x03, 0xac, 0x20, 0xe8, 0x57, 0x50, 0x6d, 0x05, 0xdc, 0xe3, 0x3e, 0xe9, 0xc9,
0x1d, 0x2b, 0x8b, 0x1d, 0x6b, 0x6c, 0x7e, 0xf7, 0x7a, 0xf5, 0x27, 0x53, 0xd3, 0x4f, 0x9f, 0x7b,
0x7e, 0x8d, 0x24, 0x50, 0x4e, 0x42, 0x04, 0x1e, 0x93, 0x87, 0xbe, 0x82, 0xc5, 0x58, 0xd9, 0x9d,
0x20, 0xea, 0x73, 0x66, 0x82, 0xb4, 0xba, 0x3e, 0xa3, 0xd5, 0x0a, 0xa4, 0xcc, 0x9e, 0x90, 0x24,
0x9c, 0xbd, 0x13, 0x70, 0x42, 0x03, 0xd7, 0xd7, 0x21, 0x38, 0xa4, 0xd1, 0x8e, 0x88, 0x34, 0x91,
0x25, 0xf7, 0x64, 0x6e, 0x34, 0xab, 0xd2, 0x35, 0xd7, 0xd3, 0x5f, 0x4d, 0xe6, 0x52, 0x47, 0x31,
0xe3, 0x31, 0xa8, 0xf5, 0x00, 0x50, 0x3a, 0x24, 0x44, 0xe8, 0x1e, 0x93, 0x41, 0x1c, 0xba, 0xc7,
0x64, 0x20, 0xb2, 0xc7, 0x89, 0xeb, 0xf7, 0x55, 0x56, 0x29, 0x63, 0x45, 0x6c, 0xe6, 0xee, 0x1a,
0x42, 0x42, 0x7a, 0x17, 0xcf, 0x25, 0xe1, 0x0b, 0xb8, 0x98, 0xe1, 0x91, 0x0c, 0x11, 0xd7, 0x92,
0x22, 0xd2, 0x47, 0x67, 0x24, 0xd2, 0xfe, 0x6b, 0x1e, 0xaa, 0xc9, 0xb8, 0x40, 0x1b, 0x70, 0x51,
0xd9, 0x89, 0xc9, 0x51, 0x93, 0x44, 0x94, 0xb4, 0x45, 0x32, 0xd2, 0xc2, 0xb3, 0x96, 0x50, 0x1d,
0x2e, 0xed, 0xf4, 0xf4, 0x34, 0x4b, 0x40, 0x72, 0xf2, 0xd8, 0x67, 0xae, 0xa1, 0x10, 0x3e, 0x54,
0xa2, 0xa4, 0x27, 0x12, 0xa0, 0xbc, 0x8c, 0x8b, 0xcf, 0x4e, 0x0f, 0x5e, 0x27, 0x13, 0xab, 0xc2,
0x23, 0x5b, 0x2e, 0xfa, 0x19, 0x14, 0xd5, 0x42, 0x7c, 0xfe, 0x3f, 0x3e, 0xfd, 0x13, 0x4a, 0x58,
0x8c, 0x11, 0x70, 0x65, 0x07, 0x33, 0xe7, 0xcf, 0x01, 0xd7, 0x18, 0xeb, 0x21, 0x58, 0xd3, 0x55,
0x3e, 0x4f, 0x08, 0xd8, 0x7f, 0x31, 0x60, 0x39, 0xf5, 0x21, 0x71, 0x39, 0xc9, 0xf4, 0xac, 0x44,
0xc8, 0x31, 0x6a, 0xc2, 0xbc, 0x4a, 0x30, 0x39, 0xa9, 0xb0, 0x33, 0x83, 0xc2, 0x4e, 0x22, 0xbb,
0x28, 0xb0, 0x75, 0x17, 0xe0, 0xed, 0x82, 0xd5, 0xfe, 0x9b, 0x01, 0x0b, 0xfa, 0x30, 0xeb, 0x9b,
0xdc, 0x85, 0xa5, 0xf8, 0x08, 0xc5, 0x73, 0xfa, 0x4e, 0xbf, 0x3d, 0x35, 0x0f, 0x28, 0x36, 0x67,
0x12, 0xa7, 0x74, 0x4c, 0x89, 0xb3, 0xb6, 0xe3, 0xb8, 0x9a, 0x60, 0x3d, 0x97, 0xe6, 0x57, 0x61,
0x61, 0x5f, 0x96, 0x60, 0x53, 0x2f, 0x28, 0xfb, 0x3f, 0x06, 0x2c, 0xc6, 0x3c, 0xda, 0xba, 0x4f,
0xa1, 0x74, 0x42, 0x28, 0x27, 0x2f, 0x09, 0xd3, 0x56, 0x99, 0x69, 0xab, 0xbe, 0x94, 0x1c, 0x78,
0xc8, 0x89, 0x36, 0xa1, 0xa4, 0xca, 0x3d, 0x12, 0x6f, 0xd4, 0xca, 0x34, 0x94, 0xfe, 0xde, 0x90,
0x1f, 0xd5, 0x60, 0xce, 0x0f, 0xbb, 0x4c, 0x9f, 0x99, 0xef, 0x4f, 0xc3, 0x3d, 0x0e, 0xbb, 0x58,
0x32, 0xa2, 0x7b, 0x50, 0xfa, 0xda, 0xa5, 0x81, 0x17, 0x74, 0xe3, 0x53, 0xb0, 0x3a, 0x0d, 0xf4,
0x4c, 0xf1, 0xe1, 0x21, 0x40, 0x14, 0x54, 0x05, 0xb5, 0x86, 0x1e, 0x41, 0xa1, 0xe3, 0x75, 0x09,
0xe3, 0xca, 0x25, 0x8d, 0xba, 0xb8, 0x4b, 0xbe, 0x7b, 0xbd, 0x7a, 0x23, 0x71, 0x59, 0x84, 0x11,
0x09, 0x44, 0xf9, 0xee, 0x7a, 0x01, 0xa1, 0xa2, 0xbc, 0xbd, 0xa5, 0x20, 0x4e, 0x53, 0xfe, 0x60,
0x2d, 0x41, 0xc8, 0xf2, 0xd4, 0x95, 0x20, 0xf3, 0xc5, 0xdb, 0xc9, 0x52, 0x12, 0xc4, 0x31, 0x08,
0xdc, 0x1e, 0xd1, 0x25, 0x80, 0x1c, 0x8b, 0xfa, 0xa4, 0x2d, 0xe2, 0xbc, 0x23, 0x2b, 0xb7, 0x12,
0xd6, 0x14, 0xda, 0x84, 0x22, 0xe3, 0x2e, 0x15, 0x39, 0x67, 0x7e, 0xc6, 0xc2, 0x2a, 0x06, 0xa0,
0xfb, 0x50, 0x6e, 0x87, 0xbd, 0xc8, 0x27, 0x02, 0x5d, 0x98, 0x11, 0x3d, 0x82, 0x88, 0xd0, 0x23,
0x94, 0x86, 0x54, 0x96, 0x74, 0x65, 0xac, 0x08, 0x74, 0x07, 0x16, 0x22, 0x1a, 0x76, 0x29, 0x61,
0xec, 0x73, 0x1a, 0xf6, 0x23, 0x7d, 0x91, 0x2f, 0x8b, 0xe4, 0xbd, 0x97, 0x5c, 0xc0, 0xe3, 0x7c,
0xf6, 0xbf, 0x73, 0x50, 0x4d, 0x86, 0x48, 0xaa, 0xd6, 0x7d, 0x04, 0x05, 0x15, 0x70, 0x2a, 0xd6,
0xdf, 0xce, 0xc7, 0x4a, 0x42, 0xa6, 0x8f, 0x4d, 0x28, 0xb6, 0xfb, 0x54, 0x16, 0xc2, 0xaa, 0x3c,
0x8e, 0x49, 0x61, 0x29, 0x0f, 0xb9, 0xeb, 0x4b, 0x1f, 0xe7, 0xb1, 0x22, 0x44, 0x6d, 0x3c, 0xec,
0xbc, 0xce, 0x57, 0x1b, 0x0f, 0x61, 0xc9, 0xfd, 0x2b, 0xbe, 0xd3, 0xfe, 0x95, 0xce, 0xbd, 0x7f,
0xf6, 0xdf, 0x0d, 0x28, 0x0f, 0xcf, 0x56, 0xc2, 0xbb, 0xc6, 0x3b, 0x7b, 0x77, 0xcc, 0x33, 0xb9,
0xb7, 0xf3, 0xcc, 0x65, 0x28, 0x30, 0x4e, 0x89, 0xdb, 0x53, 0x9d, 0x1b, 0xd6, 0x94, 0xc8, 0x62,
0x3d, 0xd6, 0x95, 0x3b, 0x54, 0xc5, 0x62, 0x68, 0xff, 0xd7, 0x80, 0x85, 0xb1, 0xe3, 0xfe, 0x5e,
0x6d, 0xb9, 0x04, 0xf3, 0x3e, 0x39, 0x21, 0xaa, 0xb7, 0xcc, 0x63, 0x45, 0x88, 0x59, 0xf6, 0x22,
0xa4, 0x5c, 0x2a, 0x57, 0xc5, 0x8a, 0x10, 0x3a, 0x77, 0x08, 0x77, 0x3d, 0x5f, 0xe6, 0xa5, 0x2a,
0xd6, 0x94, 0xd0, 0xb9, 0x4f, 0x7d, 0x5d, 0x5f, 0x8b, 0x21, 0xb2, 0x61, 0xce, 0x0b, 0x8e, 0x42,
0x1d, 0x36, 0xb2, 0xb2, 0x51, 0x75, 0xda, 0x4e, 0x70, 0x14, 0x62, 0xb9, 0x86, 0xae, 0x42, 0x81,
0xba, 0x41, 0x97, 0xc4, 0xc5, 0x75, 0x59, 0x70, 0x61, 0x31, 0x83, 0xf5, 0x82, 0x6d, 0x43, 0x55,
0xf6, 0xa7, 0xbb, 0x84, 0x89, 0x6e, 0x48, 0x84, 0x75, 0xc7, 0xe5, 0xae, 0x34, 0xbb, 0x8a, 0xe5,
0xd8, 0xbe, 0x09, 0xe8, 0xb1, 0xc7, 0xf8, 0x33, 0xd9, 0xc2, 0xb3, 0xb3, 0x9a, 0xd7, 0x7d, 0xb8,
0x38, 0xc6, 0xad, 0xaf, 0x85, 0x9f, 0x4e, 0xb4, 0xaf, 0xd7, 0xd2, 0x19, 0x57, 0xbe, 0x14, 0x38,
0x0a, 0x38, 0xd1, 0xc5, 0x2e, 0x40, 0x45, 0xda, 0xa5, 0xbe, 0x6d, 0xbb, 0x50, 0x55, 0xa4, 0x16,
0xfe, 0x05, 0x5c, 0x88, 0x05, 0x7d, 0x49, 0xa8, 0x6c, 0x45, 0x0c, 0xe9, 0x97, 0x1f, 0x4e, 0xfb,
0x4a, 0x63, 0x9c, 0x1d, 0x4f, 0xe2, 0x6d, 0x02, 0x17, 0x25, 0xcf, 0x43, 0x8f, 0xf1, 0x90, 0x0e,
0x62, 0xab, 0x57, 0x00, 0xb6, 0xda, 0xdc, 0x3b, 0x21, 0x4f, 0x02, 0x5f, 0x5d, 0xa3, 0x25, 0x9c,
0x98, 0x89, 0xaf, 0xc8, 0xdc, 0xa8, 0x87, 0xbb, 0x02, 0xe5, 0x96, 0x4b, 0xfd, 0x41, 0xeb, 0xa5,
0xc7, 0x75, 0x2b, 0x3d, 0x9a, 0xb0, 0x7f, 0x6f, 0xc0, 0x72, 0xf2, 0x3b, 0xad, 0x13, 0x91, 0x2e,
0xee, 0xc1, 0x1c, 0x8f, 0xeb, 0x98, 0xc5, 0x2c, 0x23, 0x52, 0x10, 0x51, 0xea, 0x60, 0x09, 0x4a,
0x78, 0x5a, 0x1d, 0x9c, 0x6b, 0xa7, 0xc3, 0x27, 0x3c, 0xfd, 0xbf, 0x12, 0xa0, 0xf4, 0x72, 0x46,
0x6f, 0x9a, 0x6c, 0xee, 0x72, 0x13, 0xcd, 0xdd, 0xf3, 0xc9, 0xe6, 0x4e, 0x5d, 0xcd, 0x77, 0x66,
0xd1, 0x64, 0x86, 0x16, 0xef, 0x2e, 0x94, 0xe3, 0xea, 0x26, 0xbe, 0xc0, 0xad, 0xb4, 0xe8, 0x61,
0x01, 0x34, 0x62, 0x46, 0xeb, 0xf1, 0x8d, 0xa3, 0xee, 0x3a, 0x14, 0xe7, 0x14, 0x1a, 0xb5, 0x1d,
0x5d, 0x57, 0xe8, 0x5b, 0xe8, 0xfe, 0xf9, 0xde, 0x2d, 0xe6, 0x26, 0xdf, 0x2c, 0x1a, 0x50, 0xd9,
0x8e, 0x13, 0xe5, 0x39, 0x1e, 0x2d, 0x92, 0x20, 0xb4, 0xa1, 0x0b, 0x1b, 0x95, 0x9a, 0xaf, 0xa4,
0x4d, 0x8c, 0x1f, 0x28, 0x42, 0xaa, 0x2b, 0x9b, 0xa3, 0x8c, 0xd2, 0xb2, 0x2c, 0x1d, 0xb4, 0x39,
0x93, 0xef, 0x67, 0xac, 0x2f, 0xd1, 0x67, 0x50, 0xc0, 0x84, 0xf5, 0x7d, 0x2e, 0x5f, 0x42, 0x2a,
0xf5, 0xab, 0x53, 0xa4, 0x2b, 0x26, 0x79, 0x56, 0x35, 0x00, 0xfd, 0x12, 0x8a, 0x6a, 0xc4, 0xcc,
0xca, 0xb4, 0x96, 0x3f, 0x43, 0x33, 0x8d, 0xd1, 0x0d, 0x85, 0xa6, 0xc4, 0x71, 0xfc, 0x9c, 0x04,
0x44, 0xbf, 0xd0, 0x89, 0xb6, 0x76, 0x1e, 0x27, 0x66, 0x50, 0x1d, 0xe6, 0x39, 0x75, 0xdb, 0xc4,
0x5c, 0x98, 0xc1, 0x85, 0x8a, 0x55, 0x24, 0xb6, 0xc8, 0x0b, 0x02, 0xd2, 0x31, 0x17, 0x55, 0xa5,
0xa4, 0x28, 0xf4, 0x03, 0x58, 0x0c, 0xfa, 0x3d, 0xd9, 0x2c, 0x74, 0xf6, 0x39, 0x89, 0x98, 0x79,
0x41, 0x7e, 0x6f, 0x62, 0x16, 0x5d, 0x83, 0x85, 0xa0, 0xdf, 0x3b, 0x10, 0x37, 0xbc, 0x62, 0x5b,
0x92, 0x6c, 0xe3, 0x93, 0xe8, 0x26, 0x2c, 0x0b, 0x5c, 0xbc, 0xdb, 0x8a, 0x73, 0x59, 0x72, 0xa6,
0x17, 0xde, 0x43, 0xcf, 0xfc, 0x3e, 0x3a, 0x02, 0xeb, 0x39, 0x54, 0x93, 0xfb, 0x90, 0x81, 0xbd,
0x33, 0xde, 0x71, 0xcf, 0x10, 0x17, 0x89, 0x86, 0xe3, 0x39, 0x7c, 0xef, 0x69, 0xd4, 0x71, 0x39,
0xc9, 0xca, 0xbc, 0xe9, 0x0c, 0x74, 0x19, 0x0a, 0x7b, 0x6a, 0xa3, 0xd4, 0xcb, 0xa5, 0xa6, 0xc4,
0x7c, 0x93, 0x08, 0xe7, 0xe9, 0x74, 0xab, 0x29, 0xfb, 0x0a, 0x58, 0x59, 0xe2, 0x95, 0x33, 0xec,
0x3f, 0xe7, 0x00, 0x46, 0xc1, 0x80, 0x3e, 0x02, 0xe8, 0x91, 0x8e, 0xe7, 0xfe, 0x9a, 0x8f, 0x1a,
0xca, 0xb2, 0x9c, 0x91, 0x5d, 0xe5, 0xa8, 0xf4, 0xcf, 0xbd, 0x73, 0xe9, 0x8f, 0x60, 0x8e, 0x79,
0xdf, 0x10, 0x5d, 0xa6, 0xc8, 0x31, 0x7a, 0x02, 0x15, 0x37, 0x08, 0x42, 0x2e, 0xc3, 0x38, 0x6e,
0xb6, 0x6f, 0x9d, 0x16, 0xbe, 0xce, 0xd6, 0x88, 0x5f, 0x9d, 0x92, 0xa4, 0x04, 0xeb, 0x3e, 0x2c,
0x4d, 0x32, 0x9c, 0xab, 0x19, 0xfc, 0xd6, 0x80, 0x0b, 0x13, 0x5b, 0x87, 0x3e, 0x1d, 0x66, 0x01,
0x63, 0x86, 0xe3, 0x15, 0x27, 0x80, 0x07, 0x50, 0xdd, 0xe2, 0x5c, 0x64, 0x3d, 0x65, 0x9b, 0x6a,
0xf7, 0x4e, 0xc7, 0x8e, 0x21, 0xec, 0x3f, 0x1a, 0xa3, 0x77, 0xce, 0xcc, 0x9e, 0xff, 0xde, 0x78,
0xcf, 0x7f, 0x7d, 0xfa, 0xe5, 0xf0, 0x3e, 0x5b, 0xfd, 0x1b, 0x3f, 0x87, 0x0f, 0x33, 0x2f, 0x66,
0x54, 0x81, 0xe2, 0xfe, 0xc1, 0x16, 0x3e, 0x68, 0x35, 0x97, 0x3e, 0x40, 0x55, 0x28, 0x6d, 0x3f,
0xd9, 0xdd, 0x7b, 0xdc, 0x3a, 0x68, 0x2d, 0x19, 0x62, 0xa9, 0xd9, 0x12, 0xe3, 0xe6, 0x52, 0xae,
0xfe, 0x6d, 0x01, 0x8a, 0xdb, 0xea, 0xbf, 0x1e, 0x74, 0x00, 0xe5, 0xe1, 0x9f, 0x00, 0xc8, 0xce,
0xf0, 0xce, 0xc4, 0xbf, 0x09, 0xd6, 0xc7, 0xa7, 0xf2, 0xe8, 0xc4, 0xfd, 0x10, 0xe6, 0xe5, 0xdf,
0x21, 0x28, 0xa3, 0xbd, 0x4e, 0xfe, 0x4f, 0x62, 0x9d, 0xfe, 0xf7, 0xc2, 0x86, 0x21, 0x24, 0xc9,
0xb7, 0x89, 0x2c, 0x49, 0xc9, 0xc7, 0x4b, 0x6b, 0xf5, 0x8c, 0x47, 0x0d, 0xb4, 0x0b, 0x05, 0xdd,
0xb0, 0x65, 0xb1, 0x26, 0x5f, 0x20, 0xac, 0xb5, 0xe9, 0x0c, 0x4a, 0xd8, 0x86, 0x81, 0x76, 0x87,
0xef, 0xd1, 0x59, 0xaa, 0x25, 0xab, 0x5d, 0xeb, 0x8c, 0xf5, 0x75, 0x63, 0xc3, 0x40, 0x5f, 0x41,
0x25, 0x51, 0xcf, 0xa2, 0x8c, 0x6a, 0x2a, 0x5d, 0x1c, 0x5b, 0xd7, 0xcf, 0xe0, 0xd2, 0x96, 0xb7,
0x60, 0x4e, 0x1e, 0xa4, 0x0c, 0x67, 0x27, 0xca, 0xdd, 0x2c, 0x35, 0xc7, 0xca, 0xdf, 0x43, 0x55,
0xa0, 0x93, 0x20, 0x19, 0x7d, 0xe8, 0xfa, 0x59, 0xf7, 0xea, 0xd4, 0xb0, 0x49, 0x05, 0xf1, 0x86,
0x81, 0x42, 0x40, 0xe9, 0xe4, 0x89, 0x7e, 0x94, 0x11, 0x25, 0xd3, 0x32, 0xb8, 0x75, 0x73, 0x36,
0x66, 0x65, 0x54, 0xa3, 0xfa, 0xea, 0xcd, 0x8a, 0xf1, 0x8f, 0x37, 0x2b, 0xc6, 0xbf, 0xde, 0xac,
0x18, 0x87, 0x05, 0x59, 0x31, 0xfd, 0xf8, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff, 0x7c, 0xb8, 0xc3,
0x68, 0x0b, 0x1d, 0x00, 0x00,
0x38, 0x70, 0x0e, 0xfb, 0x9e, 0xdf, 0x39, 0xf6, 0xb8, 0x73, 0xf2, 0x89, 0x55, 0xef, 0x7a, 0xfc,
0x45, 0xff, 0xd0, 0x69, 0x87, 0xbd, 0x5a, 0x37, 0xec, 0x86, 0xb5, 0x6e, 0x18, 0x76, 0x7d, 0xe2,
0x46, 0x1e, 0xd3, 0xc3, 0x1a, 0x8d, 0xda, 0x35, 0xc6, 0x5d, 0xde, 0x67, 0x4a, 0x8a, 0x75, 0x6b,
0x12, 0x23, 0xa7, 0x0f, 0xfb, 0x47, 0x92, 0x92, 0x84, 0x1c, 0x69, 0xf6, 0x5a, 0x82, 0x5d, 0x7c,
0xbf, 0x16, 0x7f, 0xbf, 0xe6, 0x46, 0x5e, 0x8d, 0x0f, 0x22, 0xc2, 0x6a, 0x5f, 0x87, 0xf4, 0x98,
0x50, 0x0d, 0xb8, 0x39, 0x15, 0xc0, 0x42, 0xff, 0x84, 0xd0, 0x5a, 0x74, 0x58, 0x0b, 0xa3, 0x58,
0x9b, 0xdb, 0xa7, 0x70, 0xf7, 0x69, 0x9b, 0x44, 0xa1, 0xef, 0xb5, 0x07, 0x02, 0xa3, 0x46, 0x1a,
0xb6, 0xaa, 0xad, 0x1b, 0xea, 0xce, 0xbd, 0x1e, 0x61, 0xdc, 0xed, 0x45, 0x8a, 0xc1, 0xfe, 0xad,
0x01, 0xd5, 0x3d, 0xda, 0x0f, 0x08, 0x26, 0xbf, 0xe9, 0x13, 0xc6, 0xd1, 0x65, 0x28, 0x1c, 0x79,
0x3e, 0x27, 0xd4, 0x34, 0xd6, 0xf2, 0xeb, 0x65, 0xac, 0x29, 0xb4, 0x04, 0x79, 0xd7, 0xf7, 0xcd,
0xdc, 0x9a, 0xb1, 0x5e, 0xc2, 0x62, 0x88, 0xd6, 0xa1, 0x7a, 0x4c, 0x48, 0xd4, 0xec, 0x53, 0x97,
0x7b, 0x61, 0x60, 0xe6, 0xd7, 0x8c, 0xf5, 0x7c, 0x63, 0xee, 0xd5, 0xeb, 0x55, 0x03, 0x8f, 0xad,
0x20, 0x1b, 0xca, 0x82, 0x6e, 0x0c, 0x38, 0x61, 0xe6, 0x5c, 0x82, 0x6d, 0x34, 0x6d, 0xdf, 0x80,
0xa5, 0xa6, 0xc7, 0x8e, 0x9f, 0x32, 0xb7, 0x7b, 0x96, 0x2e, 0xf6, 0x23, 0x58, 0x4e, 0xf0, 0xb2,
0x28, 0x0c, 0x18, 0x41, 0xb7, 0xa1, 0x40, 0x49, 0x3b, 0xa4, 0x1d, 0xc9, 0x5c, 0xa9, 0x7f, 0xe4,
0x4c, 0x86, 0x81, 0xa3, 0x01, 0x82, 0x09, 0x6b, 0x66, 0xfb, 0x4f, 0x79, 0xa8, 0x24, 0xe6, 0xd1,
0x22, 0xe4, 0x76, 0x9a, 0xa6, 0xb1, 0x66, 0xac, 0x97, 0x71, 0x6e, 0xa7, 0x89, 0x4c, 0x28, 0xee,
0xf6, 0xb9, 0x7b, 0xe8, 0x13, 0x6d, 0x7b, 0x4c, 0xa2, 0x4b, 0x30, 0xbf, 0x13, 0x3c, 0x65, 0x44,
0x1a, 0x5e, 0xc2, 0x8a, 0x40, 0x08, 0xe6, 0xf6, 0xbd, 0x6f, 0x88, 0x32, 0x13, 0xcb, 0x31, 0xb2,
0xa0, 0xb0, 0xe7, 0x52, 0x12, 0x70, 0x73, 0x5e, 0xc8, 0x6d, 0xe4, 0x4c, 0x03, 0xeb, 0x19, 0xd4,
0x80, 0xf2, 0x36, 0x25, 0x2e, 0x27, 0x9d, 0x2d, 0x6e, 0x16, 0xd6, 0x8c, 0xf5, 0x4a, 0xdd, 0x72,
0xd4, 0xae, 0x39, 0xf1, 0xae, 0x39, 0x07, 0xf1, 0xae, 0x35, 0x4a, 0xaf, 0x5e, 0xaf, 0x7e, 0xf0,
0x87, 0x7f, 0x0a, 0xdf, 0x0d, 0x61, 0xe8, 0x01, 0xc0, 0x63, 0x97, 0xf1, 0xa7, 0x4c, 0x0a, 0x29,
0x9e, 0x29, 0x64, 0x4e, 0x0a, 0x48, 0x60, 0xd0, 0x0a, 0x80, 0x74, 0xc2, 0x76, 0xd8, 0x0f, 0xb8,
0x59, 0x92, 0xba, 0x27, 0x66, 0xd0, 0x1a, 0x54, 0x9a, 0x84, 0xb5, 0xa9, 0x17, 0xc9, 0xad, 0x2e,
0x4b, 0xf7, 0x24, 0xa7, 0x84, 0x04, 0xe5, 0xc1, 0x83, 0x41, 0x44, 0x4c, 0x90, 0x0c, 0x89, 0x19,
0xb1, 0x97, 0xfb, 0x2f, 0x5c, 0x4a, 0x3a, 0x66, 0x45, 0xba, 0x4b, 0x53, 0xc2, 0xbf, 0xca, 0x13,
0xcc, 0xac, 0xca, 0x4d, 0x8e, 0x49, 0xfb, 0x77, 0x45, 0xa8, 0xee, 0x8b, 0xa3, 0x10, 0x87, 0xc3,
0x12, 0xe4, 0x31, 0x39, 0xd2, 0x7b, 0x23, 0x86, 0xc8, 0x01, 0x68, 0x92, 0x23, 0x2f, 0xf0, 0xa4,
0x56, 0x39, 0x69, 0xf8, 0xa2, 0x13, 0x1d, 0x3a, 0xa3, 0x59, 0x9c, 0xe0, 0x40, 0x16, 0x94, 0x5a,
0x2f, 0xa3, 0x90, 0x8a, 0x90, 0xca, 0x4b, 0x31, 0x43, 0x1a, 0x3d, 0x83, 0x85, 0x78, 0xbc, 0xc5,
0x39, 0x15, 0x81, 0x2a, 0xc2, 0xe8, 0x93, 0x74, 0x18, 0x25, 0x95, 0x72, 0xc6, 0x30, 0xad, 0x80,
0xd3, 0x01, 0x1e, 0x97, 0x23, 0x2c, 0xdc, 0x27, 0x8c, 0x09, 0x0d, 0xe5, 0xf6, 0xe3, 0x98, 0x14,
0xea, 0xfc, 0x82, 0x86, 0x01, 0x27, 0x41, 0x47, 0x6e, 0x7d, 0x19, 0x0f, 0x69, 0xa1, 0x4e, 0x3c,
0x56, 0xea, 0x14, 0x67, 0x52, 0x67, 0x0c, 0xa3, 0xd5, 0x19, 0x9b, 0x43, 0x9b, 0x30, 0xbf, 0xed,
0xb6, 0x5f, 0x10, 0xb9, 0xcb, 0x95, 0xfa, 0x4a, 0x5a, 0xa0, 0x5c, 0x7e, 0x22, 0xb7, 0x95, 0xc9,
0x83, 0xfa, 0x01, 0x56, 0x10, 0xf4, 0x2b, 0xa8, 0xb6, 0x02, 0xee, 0x71, 0x9f, 0xf4, 0xe4, 0x8e,
0x95, 0xc5, 0x8e, 0x35, 0x36, 0xbf, 0x7b, 0xbd, 0xfa, 0x93, 0xa9, 0xf9, 0xa9, 0xcf, 0x3d, 0xbf,
0x46, 0x12, 0x28, 0x27, 0x21, 0x02, 0x8f, 0xc9, 0x43, 0x5f, 0xc1, 0x62, 0xac, 0xec, 0x4e, 0x10,
0xf5, 0x39, 0x33, 0x41, 0x5a, 0x5d, 0x9f, 0xd1, 0x6a, 0x05, 0x52, 0x66, 0x4f, 0x48, 0x12, 0xce,
0xde, 0x09, 0x38, 0xa1, 0x81, 0xeb, 0xeb, 0x10, 0x1c, 0xd2, 0x68, 0x47, 0x44, 0x9a, 0x48, 0xa3,
0x7b, 0x32, 0x79, 0x9a, 0x55, 0xe9, 0x9a, 0xeb, 0xe9, 0xaf, 0x26, 0x93, 0xad, 0xa3, 0x98, 0xf1,
0x18, 0xd4, 0x7a, 0x00, 0x28, 0x1d, 0x12, 0x22, 0x74, 0x8f, 0xc9, 0x20, 0x0e, 0xdd, 0x63, 0x32,
0x10, 0xd9, 0xe3, 0xc4, 0xf5, 0xfb, 0x2a, 0xab, 0x94, 0xb1, 0x22, 0x36, 0x73, 0x77, 0x0d, 0x21,
0x21, 0xbd, 0x8b, 0xe7, 0x92, 0xf0, 0x05, 0x5c, 0xcc, 0xf0, 0x48, 0x86, 0x88, 0x6b, 0x49, 0x11,
0xe9, 0xa3, 0x33, 0x12, 0x69, 0xff, 0x35, 0x0f, 0xd5, 0x64, 0x5c, 0xa0, 0x0d, 0xb8, 0xa8, 0xec,
0xc4, 0xe4, 0xa8, 0x49, 0x22, 0x4a, 0xda, 0x22, 0x19, 0x69, 0xe1, 0x59, 0x4b, 0xa8, 0x0e, 0x97,
0x76, 0x7a, 0x7a, 0x9a, 0x25, 0x20, 0x39, 0x79, 0xec, 0x33, 0xd7, 0x50, 0x08, 0x1f, 0x2a, 0x51,
0xd2, 0x13, 0x09, 0x50, 0x5e, 0xc6, 0xc5, 0x67, 0xa7, 0x07, 0xaf, 0x93, 0x89, 0x55, 0xe1, 0x91,
0x2d, 0x17, 0xfd, 0x0c, 0x8a, 0x6a, 0x21, 0x3e, 0xff, 0x1f, 0x9f, 0xfe, 0x09, 0x25, 0x2c, 0xc6,
0x08, 0xb8, 0xb2, 0x83, 0x99, 0xf3, 0xe7, 0x80, 0x6b, 0x8c, 0xf5, 0x10, 0xac, 0xe9, 0x2a, 0x9f,
0x27, 0x04, 0xec, 0xbf, 0x18, 0xb0, 0x9c, 0xfa, 0x90, 0xb8, 0x9c, 0x64, 0x7a, 0x56, 0x22, 0xe4,
0x18, 0x35, 0x61, 0x5e, 0x25, 0x98, 0x9c, 0x54, 0xd8, 0x99, 0x41, 0x61, 0x27, 0x91, 0x5d, 0x14,
0xd8, 0xba, 0x0b, 0xf0, 0x76, 0xc1, 0x6a, 0xff, 0xcd, 0x80, 0x05, 0x7d, 0x98, 0xf5, 0x4d, 0xee,
0xc2, 0x52, 0x7c, 0x84, 0xe2, 0x39, 0x7d, 0xa7, 0xdf, 0x9e, 0x9a, 0x07, 0x14, 0x9b, 0x33, 0x89,
0x53, 0x3a, 0xa6, 0xc4, 0x59, 0xdb, 0x71, 0x5c, 0x4d, 0xb0, 0x9e, 0x4b, 0xf3, 0xab, 0xb0, 0xb0,
0x2f, 0x2b, 0xc6, 0xa9, 0x17, 0x94, 0xfd, 0x1f, 0x03, 0x16, 0x63, 0x1e, 0x6d, 0xdd, 0xa7, 0x50,
0x3a, 0x21, 0x94, 0x93, 0x97, 0x84, 0x69, 0xab, 0xcc, 0xb4, 0x55, 0x5f, 0x4a, 0x0e, 0x3c, 0xe4,
0x44, 0x9b, 0x50, 0x52, 0xd5, 0x29, 0x89, 0x37, 0x6a, 0x65, 0x1a, 0x4a, 0x7f, 0x6f, 0xc8, 0x8f,
0x6a, 0x30, 0xe7, 0x87, 0x5d, 0xa6, 0xcf, 0xcc, 0xf7, 0xa7, 0xe1, 0x1e, 0x87, 0x5d, 0x2c, 0x19,
0xd1, 0x3d, 0x28, 0x7d, 0xed, 0xd2, 0xc0, 0x0b, 0xba, 0xf1, 0x29, 0x58, 0x9d, 0x06, 0x7a, 0xa6,
0xf8, 0xf0, 0x10, 0x20, 0x0a, 0xaa, 0x82, 0x5a, 0x43, 0x8f, 0xa0, 0xd0, 0xf1, 0xba, 0x84, 0x71,
0xe5, 0x92, 0x46, 0x5d, 0xdc, 0x25, 0xdf, 0xbd, 0x5e, 0xbd, 0x91, 0xb8, 0x2c, 0xc2, 0x88, 0x04,
0xa2, 0x7c, 0x77, 0xbd, 0x80, 0x50, 0x51, 0x8d, 0xdf, 0x52, 0x10, 0xa7, 0x29, 0x7f, 0xb0, 0x96,
0x20, 0x64, 0x79, 0xea, 0x4a, 0x90, 0xf9, 0xe2, 0xed, 0x64, 0x29, 0x09, 0xe2, 0x18, 0x04, 0x6e,
0x8f, 0xe8, 0x12, 0x40, 0x8e, 0x45, 0x7d, 0xd2, 0x16, 0x71, 0xde, 0x91, 0x95, 0x5b, 0x09, 0x6b,
0x0a, 0x6d, 0x42, 0x91, 0x71, 0x97, 0x8a, 0x9c, 0x33, 0x3f, 0x63, 0x61, 0x15, 0x03, 0xd0, 0x7d,
0x28, 0xb7, 0xc3, 0x5e, 0xe4, 0x13, 0x81, 0x2e, 0xcc, 0x88, 0x1e, 0x41, 0x44, 0xe8, 0x11, 0x4a,
0x43, 0x2a, 0x4b, 0xba, 0x32, 0x56, 0x04, 0xba, 0x03, 0x0b, 0x11, 0x0d, 0xbb, 0x94, 0x30, 0xf6,
0x39, 0x0d, 0xfb, 0x91, 0xbe, 0xc8, 0x97, 0x45, 0xf2, 0xde, 0x4b, 0x2e, 0xe0, 0x71, 0x3e, 0xfb,
0xdf, 0x39, 0xa8, 0x26, 0x43, 0x24, 0x55, 0xeb, 0x3e, 0x82, 0x82, 0x0a, 0x38, 0x15, 0xeb, 0x6f,
0xe7, 0x63, 0x25, 0x21, 0xd3, 0xc7, 0x26, 0x14, 0xdb, 0x7d, 0x2a, 0x0b, 0x61, 0x55, 0x1e, 0xc7,
0xa4, 0xb0, 0x94, 0x87, 0xdc, 0xf5, 0xa5, 0x8f, 0xf3, 0x58, 0x11, 0xa2, 0x36, 0x1e, 0xf6, 0x2b,
0xe7, 0xab, 0x8d, 0x87, 0xb0, 0xe4, 0xfe, 0x15, 0xdf, 0x69, 0xff, 0x4a, 0xe7, 0xde, 0x3f, 0xfb,
0xef, 0x06, 0x94, 0x87, 0x67, 0x2b, 0xe1, 0x5d, 0xe3, 0x9d, 0xbd, 0x3b, 0xe6, 0x99, 0xdc, 0xdb,
0x79, 0xe6, 0x32, 0x14, 0x18, 0xa7, 0xc4, 0xed, 0xa9, 0xce, 0x0d, 0x6b, 0x4a, 0x64, 0xb1, 0x1e,
0xeb, 0xca, 0x1d, 0xaa, 0x62, 0x31, 0xb4, 0xff, 0x6b, 0xc0, 0xc2, 0xd8, 0x71, 0x7f, 0xaf, 0xb6,
0x5c, 0x82, 0x79, 0x9f, 0x9c, 0x10, 0xd5, 0x5b, 0xe6, 0xb1, 0x22, 0xc4, 0x2c, 0x7b, 0x11, 0x52,
0x2e, 0x95, 0xab, 0x62, 0x45, 0x08, 0x9d, 0x3b, 0x84, 0xbb, 0x9e, 0x2f, 0xf3, 0x52, 0x15, 0x6b,
0x4a, 0xe8, 0xdc, 0xa7, 0xbe, 0xae, 0xaf, 0xc5, 0x10, 0xd9, 0x30, 0xe7, 0x05, 0x47, 0xa1, 0x0e,
0x1b, 0x59, 0xd9, 0xa8, 0x3a, 0x6d, 0x27, 0x38, 0x0a, 0xb1, 0x5c, 0x43, 0x57, 0xa1, 0x40, 0xdd,
0xa0, 0x4b, 0xe2, 0xe2, 0xba, 0x2c, 0xb8, 0xb0, 0x98, 0xc1, 0x7a, 0xc1, 0xb6, 0xa1, 0x2a, 0xfb,
0xd3, 0x5d, 0xc2, 0x44, 0x37, 0x24, 0xc2, 0xba, 0xe3, 0x72, 0x57, 0x9a, 0x5d, 0xc5, 0x72, 0x6c,
0xdf, 0x04, 0xf4, 0xd8, 0x63, 0xfc, 0x99, 0xec, 0xee, 0xd9, 0x59, 0xcd, 0xeb, 0x3e, 0x5c, 0x1c,
0xe3, 0xd6, 0xd7, 0xc2, 0x4f, 0x27, 0xda, 0xd7, 0x6b, 0xe9, 0x8c, 0x2b, 0x1f, 0x11, 0x1c, 0x05,
0x9c, 0xe8, 0x62, 0x17, 0xa0, 0x22, 0xed, 0x52, 0xdf, 0xb6, 0x5d, 0xa8, 0x2a, 0x52, 0x0b, 0xff,
0x02, 0x2e, 0xc4, 0x82, 0xbe, 0x24, 0x54, 0xb6, 0x22, 0x86, 0xf4, 0xcb, 0x0f, 0xa7, 0x7d, 0xa5,
0x31, 0xce, 0x8e, 0x27, 0xf1, 0x36, 0x81, 0x8b, 0x92, 0xe7, 0xa1, 0xc7, 0x78, 0x48, 0x07, 0xb1,
0xd5, 0x2b, 0x00, 0x5b, 0x6d, 0xee, 0x9d, 0x90, 0x27, 0x81, 0xaf, 0xae, 0xd1, 0x12, 0x4e, 0xcc,
0xc4, 0x57, 0x64, 0x6e, 0xd4, 0xc3, 0x5d, 0x81, 0x72, 0xcb, 0xa5, 0xfe, 0xa0, 0xf5, 0xd2, 0xe3,
0xba, 0x95, 0x1e, 0x4d, 0xd8, 0xbf, 0x37, 0x60, 0x39, 0xf9, 0x9d, 0xd6, 0x89, 0x48, 0x17, 0xf7,
0x60, 0x8e, 0xc7, 0x75, 0xcc, 0x62, 0x96, 0x11, 0x29, 0x88, 0x28, 0x75, 0xb0, 0x04, 0x25, 0x3c,
0xad, 0x0e, 0xce, 0xb5, 0xd3, 0xe1, 0x13, 0x9e, 0xfe, 0x5f, 0x09, 0x50, 0x7a, 0x39, 0xa3, 0x37,
0x4d, 0x36, 0x77, 0xb9, 0x89, 0xe6, 0xee, 0xf9, 0x64, 0x73, 0xa7, 0xae, 0xe6, 0x3b, 0xb3, 0x68,
0x32, 0x43, 0x8b, 0x77, 0x17, 0xca, 0x71, 0x75, 0x13, 0x5f, 0xe0, 0x56, 0x5a, 0xf4, 0xb0, 0x00,
0x1a, 0x31, 0xa3, 0xf5, 0xf8, 0xc6, 0x51, 0x77, 0x1d, 0x8a, 0x73, 0x0a, 0x8d, 0xda, 0x8e, 0xae,
0x2b, 0xf4, 0x2d, 0x74, 0xff, 0x7c, 0xef, 0x16, 0x73, 0x93, 0x6f, 0x16, 0x0d, 0xa8, 0x6c, 0xc7,
0x89, 0xf2, 0x1c, 0x8f, 0x16, 0x49, 0x10, 0xda, 0xd0, 0x85, 0x8d, 0x4a, 0xcd, 0x57, 0xd2, 0x26,
0xc6, 0x0f, 0x14, 0x21, 0xd5, 0x95, 0xcd, 0x51, 0x46, 0x69, 0x59, 0x96, 0x0e, 0xda, 0x9c, 0xc9,
0xf7, 0x33, 0xd6, 0x97, 0xe8, 0x33, 0x28, 0x60, 0xc2, 0xfa, 0x3e, 0x97, 0x2f, 0x21, 0x95, 0xfa,
0xd5, 0x29, 0xd2, 0x15, 0x93, 0x3c, 0xab, 0x1a, 0x80, 0x7e, 0x09, 0x45, 0x35, 0x62, 0x66, 0x65,
0x5a, 0xcb, 0x9f, 0xa1, 0x99, 0xc6, 0xe8, 0x86, 0x42, 0x53, 0xe2, 0x38, 0x7e, 0x4e, 0x02, 0xa2,
0x5f, 0xe8, 0x44, 0x5b, 0x3b, 0x8f, 0x13, 0x33, 0xa8, 0x0e, 0xf3, 0x9c, 0xba, 0x6d, 0x62, 0x2e,
0xcc, 0xe0, 0x42, 0xc5, 0x2a, 0x12, 0x5b, 0xe4, 0x05, 0x01, 0xe9, 0x98, 0x8b, 0xaa, 0x52, 0x52,
0x14, 0xfa, 0x01, 0x2c, 0x06, 0xfd, 0x9e, 0x6c, 0x16, 0x3a, 0xfb, 0x9c, 0x44, 0xcc, 0xbc, 0x20,
0xbf, 0x37, 0x31, 0x8b, 0xae, 0xc1, 0x42, 0xd0, 0xef, 0x1d, 0x88, 0x1b, 0x5e, 0xb1, 0x2d, 0x49,
0xb6, 0xf1, 0x49, 0x74, 0x13, 0x96, 0x05, 0x2e, 0xde, 0x6d, 0xc5, 0xb9, 0x2c, 0x39, 0xd3, 0x0b,
0xef, 0xa1, 0x67, 0x7e, 0x1f, 0x1d, 0x81, 0xf5, 0x1c, 0xaa, 0xc9, 0x7d, 0xc8, 0xc0, 0xde, 0x19,
0xef, 0xb8, 0x67, 0x88, 0x8b, 0x44, 0xc3, 0xf1, 0x1c, 0xbe, 0xf7, 0x34, 0xea, 0xb8, 0x9c, 0x64,
0x65, 0xde, 0x74, 0x06, 0xba, 0x0c, 0x85, 0x3d, 0xb5, 0x51, 0xea, 0xe5, 0x52, 0x53, 0x62, 0xbe,
0x49, 0x84, 0xf3, 0x74, 0xba, 0xd5, 0x94, 0x7d, 0x05, 0xac, 0x2c, 0xf1, 0xca, 0x19, 0xf6, 0x9f,
0x73, 0x00, 0xa3, 0x60, 0x40, 0x1f, 0x01, 0xf4, 0x48, 0xc7, 0x73, 0x7f, 0xcd, 0x47, 0x0d, 0x65,
0x59, 0xce, 0xc8, 0xae, 0x72, 0x54, 0xfa, 0xe7, 0xde, 0xb9, 0xf4, 0x47, 0x30, 0xc7, 0xbc, 0x6f,
0x88, 0x2e, 0x53, 0xe4, 0x18, 0x3d, 0x81, 0x8a, 0x1b, 0x04, 0x21, 0x97, 0x61, 0x1c, 0x37, 0xdb,
0xb7, 0x4e, 0x0b, 0x5f, 0x67, 0x6b, 0xc4, 0xaf, 0x4e, 0x49, 0x52, 0x82, 0x75, 0x1f, 0x96, 0x26,
0x19, 0xce, 0xd5, 0x0c, 0x7e, 0x6b, 0xc0, 0x85, 0x89, 0xad, 0x43, 0x9f, 0x0e, 0xb3, 0x80, 0x31,
0xc3, 0xf1, 0x8a, 0x13, 0xc0, 0x03, 0xa8, 0x6e, 0x71, 0x2e, 0xb2, 0x9e, 0xb2, 0x4d, 0xb5, 0x7b,
0xa7, 0x63, 0xc7, 0x10, 0xf6, 0x1f, 0x8d, 0xd1, 0x3b, 0x67, 0x66, 0xcf, 0x7f, 0x6f, 0xbc, 0xe7,
0xbf, 0x3e, 0xfd, 0x72, 0x78, 0x9f, 0xad, 0xfe, 0x8d, 0x9f, 0xc3, 0x87, 0x99, 0x17, 0x33, 0xaa,
0x40, 0x71, 0xff, 0x60, 0x0b, 0x1f, 0xb4, 0x9a, 0x4b, 0x1f, 0xa0, 0x2a, 0x94, 0xb6, 0x9f, 0xec,
0xee, 0x3d, 0x6e, 0x1d, 0xb4, 0x96, 0x0c, 0xb1, 0xd4, 0x6c, 0x89, 0x71, 0x73, 0x29, 0x57, 0xff,
0xb6, 0x00, 0xc5, 0x6d, 0xf5, 0x5f, 0x0f, 0x3a, 0x80, 0xf2, 0xf0, 0x4f, 0x00, 0x64, 0x67, 0x78,
0x67, 0xe2, 0xdf, 0x04, 0xeb, 0xe3, 0x53, 0x79, 0x74, 0xe2, 0x7e, 0x08, 0xf3, 0xf2, 0xef, 0x10,
0x94, 0xd1, 0x5e, 0x27, 0xff, 0x27, 0xb1, 0x4e, 0xff, 0x7b, 0x61, 0xc3, 0x10, 0x92, 0xe4, 0xdb,
0x44, 0x96, 0xa4, 0xe4, 0xe3, 0xa5, 0xb5, 0x7a, 0xc6, 0xa3, 0x06, 0xda, 0x85, 0x82, 0x6e, 0xd8,
0xb2, 0x58, 0x93, 0x2f, 0x10, 0xd6, 0xda, 0x74, 0x06, 0x25, 0x6c, 0xc3, 0x40, 0xbb, 0xc3, 0xf7,
0xe8, 0x2c, 0xd5, 0x92, 0xd5, 0xae, 0x75, 0xc6, 0xfa, 0xba, 0xb1, 0x61, 0xa0, 0xaf, 0xa0, 0x92,
0xa8, 0x67, 0x51, 0x46, 0x35, 0x95, 0x2e, 0x8e, 0xad, 0xeb, 0x67, 0x70, 0x69, 0xcb, 0x5b, 0x30,
0x27, 0x0f, 0x52, 0x86, 0xb3, 0x13, 0xe5, 0x6e, 0x96, 0x9a, 0x63, 0xe5, 0xef, 0xa1, 0x2a, 0xd0,
0x49, 0x90, 0x8c, 0x3e, 0x74, 0xfd, 0xac, 0x7b, 0x75, 0x6a, 0xd8, 0xa4, 0x82, 0x78, 0xc3, 0x40,
0x21, 0xa0, 0x74, 0xf2, 0x44, 0x3f, 0xca, 0x88, 0x92, 0x69, 0x19, 0xdc, 0xba, 0x39, 0x1b, 0xb3,
0x32, 0xaa, 0x51, 0x7d, 0xf5, 0x66, 0xc5, 0xf8, 0xc7, 0x9b, 0x15, 0xe3, 0x5f, 0x6f, 0x56, 0x8c,
0xc3, 0x82, 0xac, 0x98, 0x7e, 0xfc, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xf6, 0x99, 0xcf,
0x0b, 0x1d, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.

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

@ -2,13 +2,13 @@ syntax = "proto3";
package moby.buildkit.v1;
import "github.com/gogo/protobuf/gogoproto/gogo.proto";
import "google/protobuf/timestamp.proto";
import "github.com/moby/buildkit/solver/pb/ops.proto";
import "github.com/moby/buildkit/api/types/worker.proto";
// import "github.com/containerd/containerd/api/types/descriptor.proto";
import "github.com/gogo/googleapis/google/rpc/status.proto";
import "github.com/gogo/protobuf/gogoproto/gogo.proto";
import "github.com/moby/buildkit/api/types/worker.proto";
import "github.com/moby/buildkit/solver/pb/ops.proto";
import "github.com/moby/buildkit/sourcepolicy/pb/policy.proto";
import "google/protobuf/timestamp.proto";
option (gogoproto.sizer_all) = true;
option (gogoproto.marshaler_all) = true;

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

@ -8,6 +8,7 @@ import (
"net/url"
"os"
"strings"
"time"
contentapi "github.com/containerd/containerd/api/services/content/v1"
"github.com/containerd/containerd/defaults"
@ -186,16 +187,29 @@ func (c *Client) Dialer() session.Dialer {
}
func (c *Client) Wait(ctx context.Context) error {
opts := []grpc.CallOption{grpc.WaitForReady(true)}
_, err := c.ControlClient().Info(ctx, &controlapi.InfoRequest{}, opts...)
if err != nil {
if code := grpcerrors.Code(err); code == codes.Unimplemented {
for {
_, err := c.ControlClient().Info(ctx, &controlapi.InfoRequest{})
if err == nil {
return nil
}
switch code := grpcerrors.Code(err); code {
case codes.Unavailable:
case codes.Unimplemented:
// only buildkit v0.11+ supports the info api, but an unimplemented
// response error is still a response so we can ignore it
return nil
default:
return err
}
select {
case <-ctx.Done():
return ctx.Err()
case <-time.After(time.Second):
}
c.conn.ResetConnectBackoff()
}
return err
}
func (c *Client) Close() error {

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

@ -8,49 +8,50 @@ import (
)
type Vertex struct {
Digest digest.Digest
Inputs []digest.Digest
Name string
Started *time.Time
Completed *time.Time
Cached bool
Error string
ProgressGroup *pb.ProgressGroup
Digest digest.Digest `json:"digest,omitempty"`
Inputs []digest.Digest `json:"inputs,omitempty"`
Name string `json:"name,omitempty"`
Started *time.Time `json:"started,omitempty"`
Completed *time.Time `json:"completed,omitempty"`
Cached bool `json:"cached,omitempty"`
Error string `json:"error,omitempty"`
ProgressGroup *pb.ProgressGroup `json:"progressGroup,omitempty"`
}
type VertexStatus struct {
ID string
Vertex digest.Digest
Name string
Total int64
Current int64
Timestamp time.Time
Started *time.Time
Completed *time.Time
ID string `json:"id"`
Vertex digest.Digest `json:"vertex,omitempty"`
Name string `json:"name,omitempty"`
Total int64 `json:"total,omitempty"`
Current int64 `json:"current"`
Timestamp time.Time `json:"timestamp,omitempty"`
Started *time.Time `json:"started,omitempty"`
Completed *time.Time `json:"completed,omitempty"`
}
type VertexLog struct {
Vertex digest.Digest
Stream int
Data []byte
Timestamp time.Time
Vertex digest.Digest `json:"vertex,omitempty"`
Stream int `json:"stream,omitempty"`
Data []byte `json:"data"`
Timestamp time.Time `json:"timestamp"`
}
type VertexWarning struct {
Vertex digest.Digest
Level int
Short []byte
Detail [][]byte
URL string
SourceInfo *pb.SourceInfo
Range []*pb.Range
Vertex digest.Digest `json:"vertex,omitempty"`
Level int `json:"level,omitempty"`
Short []byte `json:"short,omitempty"`
Detail [][]byte `json:"detail,omitempty"`
URL string `json:"url,omitempty"`
SourceInfo *pb.SourceInfo `json:"sourceInfo,omitempty"`
Range []*pb.Range `json:"range,omitempty"`
}
type SolveStatus struct {
Vertexes []*Vertex
Statuses []*VertexStatus
Logs []*VertexLog
Warnings []*VertexWarning
Vertexes []*Vertex `json:"vertexes,omitempty"`
Statuses []*VertexStatus `json:"statuses,omitempty"`
Logs []*VertexLog `json:"logs,omitempty"`
Warnings []*VertexWarning `json:"warnings,omitempty"`
}
type SolveResponse struct {

52
vendor/github.com/moby/buildkit/client/llb/source.go generated vendored
View File

@ -5,10 +5,11 @@ import (
_ "crypto/sha256" // for opencontainers/go-digest
"encoding/json"
"os"
"path"
"strconv"
"strings"
"github.com/docker/distribution/reference"
"github.com/distribution/reference"
"github.com/moby/buildkit/solver/pb"
"github.com/moby/buildkit/util/apicaps"
"github.com/moby/buildkit/util/gitutil"
@ -226,7 +227,7 @@ type ImageInfo struct {
// Git returns a state that represents a git repository.
// Example:
//
// st := llb.Git("https://github.com/moby/buildkit.git#v0.11.6")
// st := llb.Git("https://github.com/moby/buildkit.git", "v0.11.6")
//
// The example fetches the v0.11.6 tag of the buildkit repository.
// You can also use a commit hash or a branch name.
@ -237,29 +238,30 @@ type ImageInfo struct {
//
// By default the git repository is cloned with `--depth=1` to reduce the amount of data downloaded.
// Additionally the ".git" directory is removed after the clone, you can keep ith with the [KeepGitDir] [GitOption].
func Git(remote, ref string, opts ...GitOption) State {
url := strings.Split(remote, "#")[0]
var protocolType int
remote, protocolType = gitutil.ParseProtocol(remote)
var sshHost string
if protocolType == gitutil.SSHProtocol {
parts := strings.SplitN(remote, ":", 2)
if len(parts) == 2 {
sshHost = parts[0]
// keep remote consistent with http(s) version
remote = parts[0] + "/" + parts[1]
}
}
if protocolType == gitutil.UnknownProtocol {
func Git(url, ref string, opts ...GitOption) State {
remote, err := gitutil.ParseURL(url)
if errors.Is(err, gitutil.ErrUnknownProtocol) {
url = "https://" + url
remote, err = gitutil.ParseURL(url)
}
if remote != nil {
remote.Fragment = ""
url = remote.String()
}
id := remote
if ref != "" {
id += "#" + ref
var id string
if err != nil {
// If we can't parse the URL, just use the full URL as the ID. The git
// operation will fail later on.
id = url
} else {
// We construct the ID manually here, so that we can create the same ID
// for different protocols (e.g. https and ssh) that have the same
// host/path/fragment combination.
id = remote.Host + path.Join("/", remote.Path)
if ref != "" {
id += "#" + ref
}
}
gi := &GitInfo{
@ -290,11 +292,11 @@ func Git(remote, ref string, opts ...GitOption) State {
addCap(&gi.Constraints, pb.CapSourceGitHTTPAuth)
}
}
if protocolType == gitutil.SSHProtocol {
if remote != nil && remote.Scheme == gitutil.SSHProtocol {
if gi.KnownSSHHosts != "" {
attrs[pb.AttrKnownSSHHosts] = gi.KnownSSHHosts
} else if sshHost != "" {
keyscan, err := sshutil.SSHKeyScan(sshHost)
} else {
keyscan, err := sshutil.SSHKeyScan(remote.Host)
if err == nil {
// best effort
attrs[pb.AttrKnownSSHHosts] = keyscan

42
vendor/github.com/moby/buildkit/client/llb/sourcemap.go generated vendored
View File

@ -1,6 +1,7 @@
package llb
import (
"bytes"
"context"
"github.com/moby/buildkit/solver/pb"
@ -47,6 +48,33 @@ func (s *SourceMap) Location(r []*pb.Range) ConstraintsOpt {
})
}
func equalSourceMap(sm1, sm2 *SourceMap) (out bool) {
if sm1 == nil || sm2 == nil {
return false
}
if sm1.Filename != sm2.Filename {
return false
}
if sm1.Language != sm2.Language {
return false
}
if len(sm1.Data) != len(sm2.Data) {
return false
}
if !bytes.Equal(sm1.Data, sm2.Data) {
return false
}
if sm1.Definition != nil && sm2.Definition != nil {
if len(sm1.Definition.Def) != len(sm2.Definition.Def) && len(sm1.Definition.Def) != 0 {
return false
}
if !bytes.Equal(sm1.Definition.Def[len(sm1.Definition.Def)-1], sm2.Definition.Def[len(sm2.Definition.Def)-1]) {
return false
}
}
return true
}
type SourceLocation struct {
SourceMap *SourceMap
Ranges []*pb.Range
@ -69,8 +97,18 @@ func (smc *sourceMapCollector) Add(dgst digest.Digest, ls []*SourceLocation) {
for _, l := range ls {
idx, ok := smc.index[l.SourceMap]
if !ok {
idx = len(smc.maps)
smc.maps = append(smc.maps, l.SourceMap)
idx = -1
// slow equality check
for i, m := range smc.maps {
if equalSourceMap(m, l.SourceMap) {
idx = i
break
}
}
if idx == -1 {
idx = len(smc.maps)
smc.maps = append(smc.maps, l.SourceMap)
}
}
smc.index[l.SourceMap] = idx
}

20
vendor/github.com/moby/buildkit/cmd/buildkitd/config/config.go generated vendored
View File

@ -14,9 +14,15 @@ type Config struct {
// Entitlements e.g. security.insecure, network.host
Entitlements []string `toml:"insecure-entitlements"`
// LogFormat is the format of the logs. It can be "json" or "text".
Log LogConfig `toml:"log"`
// GRPC configuration settings
GRPC GRPCConfig `toml:"grpc"`
OTEL OTELConfig `toml:"otel"`
Workers struct {
OCI OCIConfig `toml:"oci"`
Containerd ContainerdConfig `toml:"containerd"`
@ -29,6 +35,10 @@ type Config struct {
History *HistoryConfig `toml:"history"`
}
type LogConfig struct {
Format string `toml:"format"`
}
type GRPCConfig struct {
Address []string `toml:"address"`
DebugAddress string `toml:"debugAddress"`
@ -46,6 +56,10 @@ type TLSConfig struct {
CA string `toml:"ca"`
}
type OTELConfig struct {
SocketPath string `toml:"socketPath"`
}
type GCConfig struct {
GC *bool `toml:"gc"`
GCKeepStorage DiskSpace `toml:"gckeepstorage"`
@ -98,6 +112,7 @@ type ContainerdConfig struct {
Labels map[string]string `toml:"labels"`
Platforms []string `toml:"platforms"`
Namespace string `toml:"namespace"`
Runtime ContainerdRuntime `toml:"runtime"`
GCConfig
NetworkConfig
Snapshotter string `toml:"snapshotter"`
@ -114,6 +129,11 @@ type ContainerdConfig struct {
Rootless bool `toml:"rootless"`
}
type ContainerdRuntime struct {
Name string `toml:"name"`
Options map[string]interface{} `toml:"options"`
}
type GCPolicy struct {
All bool `toml:"all"`
KeepBytes DiskSpace `toml:"keepBytes"`

4
vendor/github.com/moby/buildkit/exporter/containerimage/exptypes/keys.go generated vendored
View File

@ -72,4 +72,8 @@ var (
// Value: int (0-9) for gzip and estargz
// Value: int (0-22) for zstd
OptKeyCompressionLevel ImageExporterOptKey = "compression-level"
// Rewrite timestamps in layers to match SOURCE_DATE_EPOCH
// Value: bool <true|false>
OptKeyRewriteTimestamp ImageExporterOptKey = "rewrite-timestamp"
)

7
vendor/github.com/moby/buildkit/exporter/containerimage/image/docker_image.go generated vendored
View File

@ -35,11 +35,8 @@ type ImageConfig struct {
Healthcheck *HealthConfig `json:",omitempty"` // Healthcheck describes how to check the container is healthy
// NetworkDisabled bool `json:",omitempty"` // Is network disabled
// MacAddress string `json:",omitempty"` // Mac Address of the container
OnBuild []string // ONBUILD metadata that were defined on the image Dockerfile
StopTimeout *int `json:",omitempty"` // Timeout (in seconds) to stop a container
Shell strslice.StrSlice `json:",omitempty"` // Shell for shell-form of RUN, CMD, ENTRYPOINT
OnBuild []string // ONBUILD metadata that were defined on the image Dockerfile
Shell strslice.StrSlice `json:",omitempty"` // Shell for shell-form of RUN, CMD, ENTRYPOINT
}
// Image is the JSON structure which describes some basic information about the image.

73
vendor/github.com/moby/buildkit/frontend/dockerfile/dockerignore/dockerignore.go generated vendored
View File

@ -1,73 +0,0 @@
package dockerignore
import (
"bufio"
"bytes"
"io"
"path/filepath"
"strings"
)
// ReadAll reads an ignore file from a reader and returns the list of file
// patterns to ignore, applying the following rules:
//
// - An UTF8 BOM header (if present) is stripped.
// - Lines starting with "#" are considered comments and are skipped.
//
// For remaining lines:
//
// - Leading and trailing whitespace is removed from each ignore pattern.
// - It uses [filepath.Clean] to get the shortest/cleanest path for
// ignore patterns.
// - Leading forward-slashes ("/") are removed from ignore patterns,
// so "/some/path" and "some/path" are considered equivalent.
func ReadAll(reader io.Reader) ([]string, error) {
if reader == nil {
return nil, nil
}
var excludes []string
currentLine := 0
utf8bom := []byte{0xEF, 0xBB, 0xBF}
scanner := bufio.NewScanner(reader)
for scanner.Scan() {
scannedBytes := scanner.Bytes()
// We trim UTF8 BOM
if currentLine == 0 {
scannedBytes = bytes.TrimPrefix(scannedBytes, utf8bom)
}
pattern := string(scannedBytes)
currentLine++
// Lines starting with # (comments) are ignored before processing
if strings.HasPrefix(pattern, "#") {
continue
}
pattern = strings.TrimSpace(pattern)
if pattern == "" {
continue
}
// normalize absolute paths to paths relative to the context
// (taking care of '!' prefix)
invert := pattern[0] == '!'
if invert {
pattern = strings.TrimSpace(pattern[1:])
}
if len(pattern) > 0 {
pattern = filepath.Clean(pattern)
pattern = filepath.ToSlash(pattern)
if len(pattern) > 1 && pattern[0] == '/' {
pattern = pattern[1:]
}
}
if invert {
pattern = "!" + pattern
}
excludes = append(excludes, pattern)
}
if err := scanner.Err(); err != nil {
return nil, err
}
return excludes, nil
}

15
vendor/github.com/moby/buildkit/frontend/dockerui/config.go generated vendored
View File

@ -10,15 +10,15 @@ import (
"time"
"github.com/containerd/containerd/platforms"
"github.com/docker/distribution/reference"
"github.com/distribution/reference"
controlapi "github.com/moby/buildkit/api/services/control"
"github.com/moby/buildkit/client/llb"
"github.com/moby/buildkit/exporter/containerimage/image"
"github.com/moby/buildkit/frontend/attestations"
"github.com/moby/buildkit/frontend/dockerfile/dockerignore"
"github.com/moby/buildkit/frontend/gateway/client"
"github.com/moby/buildkit/solver/pb"
"github.com/moby/buildkit/util/flightcontrol"
"github.com/moby/patternmatcher/ignorefile"
digest "github.com/opencontainers/go-digest"
ocispecs "github.com/opencontainers/image-spec/specs-go/v1"
"github.com/pkg/errors"
@ -442,7 +442,7 @@ func (bc *Client) MainContext(ctx context.Context, opts ...llb.LocalOption) (*ll
var excludes []string
if len(bc.dockerignore) != 0 {
excludes, err = dockerignore.ReadAll(bytes.NewBuffer(bc.dockerignore))
excludes, err = ignorefile.ReadAll(bytes.NewBuffer(bc.dockerignore))
if err != nil {
return nil, errors.Wrapf(err, "failed parsing %s", bc.dockerignoreName)
}
@ -494,6 +494,15 @@ func (bc *Client) IsNoCache(name string) bool {
return false
}
func DefaultMainContext(opts ...llb.LocalOption) *llb.State {
opts = append([]llb.LocalOption{
llb.SharedKeyHint(DefaultLocalNameContext),
WithInternalName("load build context"),
}, opts...)
st := llb.Local(DefaultLocalNameContext, opts...)
return &st
}
func WithInternalName(name string) llb.ConstraintsOpt {
return llb.WithCustomName("[internal] " + name)
}

6
vendor/github.com/moby/buildkit/frontend/dockerui/namedcontext.go generated vendored
View File

@ -7,13 +7,13 @@ import (
"fmt"
"strings"
"github.com/docker/distribution/reference"
"github.com/distribution/reference"
"github.com/moby/buildkit/client/llb"
"github.com/moby/buildkit/exporter/containerimage/exptypes"
"github.com/moby/buildkit/exporter/containerimage/image"
"github.com/moby/buildkit/frontend/dockerfile/dockerignore"
"github.com/moby/buildkit/frontend/gateway/client"
"github.com/moby/buildkit/util/imageutil"
"github.com/moby/patternmatcher/ignorefile"
"github.com/pkg/errors"
)
@ -206,7 +206,7 @@ func (bc *Client) namedContextRecursive(ctx context.Context, name string, nameWi
}) // error ignored
if len(dt) != 0 {
excludes, err = dockerignore.ReadAll(bytes.NewBuffer(dt))
excludes, err = ignorefile.ReadAll(bytes.NewBuffer(dt))
if err != nil {
return nil, nil, errors.Wrapf(err, "failed parsing %s", DefaultDockerignoreName)
}

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

@ -2659,7 +2659,7 @@ func init() {
func init() { proto.RegisterFile("gateway.proto", fileDescriptor_f1a937782ebbded5) }
var fileDescriptor_f1a937782ebbded5 = []byte{
// 2497 bytes of a gzipped FileDescriptorProto
// 2496 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x59, 0xcf, 0x6f, 0x1b, 0xc7,
0xf5, 0xd7, 0x8a, 0x14, 0x45, 0x3e, 0xfe, 0x10, 0x3d, 0x71, 0xf2, 0xa5, 0x17, 0x81, 0x23, 0xaf,
0x63, 0x45, 0x96, 0x1d, 0xd2, 0x5f, 0xd9, 0x86, 0x5c, 0xbb, 0x75, 0x62, 0xfd, 0x82, 0x14, 0x4b,
@ -2669,154 +2669,153 @@ var fileDescriptor_f1a937782ebbded5 = []byte{
0x37, 0x33, 0x4b, 0x0e, 0x7f, 0x68, 0x45, 0xd6, 0x27, 0xce, 0xbc, 0x79, 0x3f, 0xe6, 0xbd, 0x37,
0xef, 0xcd, 0x67, 0x96, 0x50, 0xee, 0xd8, 0x9c, 0x9d, 0xda, 0x67, 0xf5, 0x30, 0x0a, 0x78, 0x40,
0xae, 0x1c, 0x07, 0x87, 0x67, 0xf5, 0xc3, 0xae, 0xeb, 0x39, 0xaf, 0x5c, 0x5e, 0x3f, 0xf9, 0xff,
0x7a, 0x3b, 0x0a, 0x7c, 0xce, 0x7c, 0xc7, 0xfc, 0xb8, 0xe3, 0xf2, 0xa3, 0xee, 0x61, 0xbd, 0x15,
0x1c, 0x37, 0x3a, 0x41, 0x27, 0x68, 0x08, 0x89, 0xc3, 0x6e, 0x5b, 0xcc, 0xc4, 0x44, 0x8c, 0xa4,
0x26, 0x73, 0x75, 0x98, 0xbd, 0x13, 0x04, 0x1d, 0x8f, 0xd9, 0xa1, 0x1b, 0xab, 0x61, 0x23, 0x0a,
0x5b, 0x8d, 0x98, 0xdb, 0xbc, 0x1b, 0x2b, 0x99, 0xdb, 0x9a, 0x0c, 0x6e, 0xa4, 0x91, 0x6c, 0xa4,
0x11, 0x07, 0xde, 0x09, 0x8b, 0x1a, 0xe1, 0x61, 0x23, 0x08, 0x13, 0xee, 0xc6, 0xb9, 0xdc, 0x76,
0xe8, 0x36, 0xf8, 0x59, 0xc8, 0xe2, 0xc6, 0x69, 0x10, 0xbd, 0x62, 0x91, 0x12, 0xb8, 0x7b, 0xae,
0x40, 0x97, 0xbb, 0x1e, 0x4a, 0xb5, 0xec, 0x30, 0x46, 0x23, 0xf8, 0xab, 0x84, 0x74, 0xb7, 0x79,
0xe0, 0xbb, 0x31, 0x77, 0xdd, 0x8e, 0xdb, 0x68, 0xc7, 0x42, 0x46, 0x5a, 0x41, 0x27, 0x14, 0xfb,
0xfd, 0x14, 0x17, 0xba, 0x51, 0x8b, 0x85, 0x81, 0xe7, 0xb6, 0xce, 0xd0, 0x86, 0x1c, 0x49, 0x31,
0xeb, 0x6f, 0x59, 0xc8, 0x51, 0x16, 0x77, 0x3d, 0x4e, 0x96, 0xa0, 0x1c, 0xb1, 0xf6, 0x26, 0x0b,
0x23, 0xd6, 0xb2, 0x39, 0x73, 0x6a, 0xc6, 0xa2, 0xb1, 0x5c, 0xd8, 0x99, 0xa1, 0x83, 0x64, 0xf2,
0x13, 0xa8, 0x44, 0xac, 0x1d, 0x6b, 0x8c, 0xb3, 0x8b, 0xc6, 0x72, 0x71, 0xf5, 0x56, 0xfd, 0xdc,
0x1c, 0xd6, 0x29, 0x6b, 0xef, 0xdb, 0x61, 0x5f, 0x64, 0x67, 0x86, 0x0e, 0x29, 0x21, 0xab, 0x90,
0x89, 0x58, 0xbb, 0x96, 0x11, 0xba, 0xae, 0xa6, 0xeb, 0xda, 0x99, 0xa1, 0xc8, 0x4c, 0xd6, 0x20,
0x8b, 0x5a, 0x6a, 0x59, 0x21, 0x74, 0xed, 0xc2, 0x0d, 0xec, 0xcc, 0x50, 0x21, 0x40, 0x9e, 0x42,
0xfe, 0x98, 0x71, 0xdb, 0xb1, 0xb9, 0x5d, 0x83, 0xc5, 0xcc, 0x72, 0x71, 0xb5, 0x91, 0x2a, 0x8c,
0x01, 0xaa, 0xef, 0x2b, 0x89, 0x2d, 0x9f, 0x47, 0x67, 0xb4, 0xa7, 0x80, 0xbc, 0x84, 0x92, 0xcd,
0x39, 0xc3, 0x64, 0xb8, 0x81, 0x1f, 0xd7, 0x4a, 0x42, 0xe1, 0xdd, 0x8b, 0x15, 0x3e, 0xd1, 0xa4,
0xa4, 0xd2, 0x01, 0x45, 0xe6, 0x23, 0x28, 0x0f, 0xd8, 0x24, 0x55, 0xc8, 0xbc, 0x62, 0x67, 0x32,
0x31, 0x14, 0x87, 0xe4, 0x32, 0xcc, 0x9d, 0xd8, 0x5e, 0x97, 0x89, 0x1c, 0x94, 0xa8, 0x9c, 0x3c,
0x9c, 0x7d, 0x60, 0x98, 0x47, 0x70, 0x69, 0x44, 0xff, 0x18, 0x05, 0x3f, 0xd2, 0x15, 0x14, 0x57,
0x3f, 0x4a, 0xd9, 0xb5, 0xae, 0x4e, 0xb3, 0xb4, 0x9e, 0x87, 0x5c, 0x24, 0x1c, 0xb2, 0x7e, 0x67,
0x40, 0x75, 0x38, 0xd5, 0x64, 0x57, 0x25, 0xc9, 0x10, 0x61, 0xb9, 0x3f, 0xc5, 0x29, 0x41, 0x82,
0x0a, 0x8c, 0x50, 0x61, 0xae, 0x41, 0xa1, 0x47, 0xba, 0x28, 0x18, 0x05, 0x6d, 0x8b, 0xd6, 0x1a,
0x64, 0x28, 0x6b, 0x93, 0x0a, 0xcc, 0xba, 0xea, 0x5c, 0xd3, 0x59, 0xd7, 0x21, 0x8b, 0x90, 0x71,
0x58, 0x5b, 0xb9, 0x5e, 0xa9, 0x87, 0x87, 0xf5, 0x4d, 0xd6, 0x76, 0x7d, 0x17, 0x5d, 0xa4, 0xb8,
0x64, 0xfd, 0xde, 0xc0, 0xfa, 0xc0, 0x6d, 0x91, 0x4f, 0x06, 0xfc, 0xb8, 0xf8, 0xb4, 0x8f, 0xec,
0xfe, 0x65, 0xfa, 0xee, 0xef, 0x0d, 0x66, 0xe2, 0x82, 0x12, 0xd0, 0xbd, 0xfb, 0x29, 0x94, 0xf4,
0xdc, 0x90, 0x1d, 0x28, 0x6a, 0xe7, 0x48, 0x6d, 0x78, 0x69, 0xb2, 0xcc, 0x52, 0x5d, 0xd4, 0xfa,
0x63, 0x06, 0x8a, 0xda, 0x22, 0x79, 0x0c, 0xd9, 0x57, 0xae, 0x2f, 0x43, 0x58, 0x59, 0x5d, 0x99,
0x4c, 0xe5, 0x53, 0xd7, 0x77, 0xa8, 0x90, 0x23, 0x4d, 0xad, 0xee, 0x66, 0xc5, 0xb6, 0xee, 0x4d,
0xa6, 0xe3, 0xdc, 0xe2, 0xbb, 0x33, 0x45, 0xdb, 0x90, 0x4d, 0x83, 0x40, 0x36, 0xb4, 0xf9, 0x91,
0x68, 0x1a, 0x05, 0x2a, 0xc6, 0xe4, 0x0e, 0xbc, 0xe3, 0xfa, 0x2f, 0x02, 0x1e, 0x34, 0x23, 0xe6,
0xb8, 0x78, 0xf8, 0x5e, 0x9c, 0x85, 0xac, 0x36, 0x27, 0x58, 0xc6, 0x2d, 0x91, 0x26, 0x54, 0x24,
0xf9, 0xa0, 0x7b, 0xf8, 0x0b, 0xd6, 0xe2, 0x71, 0x2d, 0x27, 0xfc, 0x59, 0x4e, 0xd9, 0xc2, 0xae,
0x2e, 0x40, 0x87, 0xe4, 0xdf, 0xaa, 0xda, 0xad, 0xbf, 0x18, 0x50, 0x1e, 0x50, 0x4f, 0x3e, 0x1d,
0x48, 0xd5, 0xed, 0x49, 0xb7, 0xa5, 0x25, 0xeb, 0x33, 0xc8, 0x39, 0x6e, 0x87, 0xc5, 0x5c, 0xa4,
0xaa, 0xb0, 0xbe, 0xfa, 0xdd, 0xf7, 0x1f, 0xcc, 0xfc, 0xf3, 0xfb, 0x0f, 0x56, 0xb4, 0xab, 0x26,
0x08, 0x99, 0xdf, 0x0a, 0x7c, 0x6e, 0xbb, 0x3e, 0x8b, 0xf0, 0x82, 0xfd, 0x58, 0x8a, 0xd4, 0x37,
0xc5, 0x0f, 0x55, 0x1a, 0x30, 0xe8, 0xbe, 0x7d, 0xcc, 0x44, 0x9e, 0x0a, 0x54, 0x8c, 0x2d, 0x0e,
0x65, 0xca, 0x78, 0x37, 0xf2, 0x29, 0xfb, 0x65, 0x17, 0x99, 0x7e, 0x90, 0x34, 0x12, 0xb1, 0xe9,
0x8b, 0x1a, 0x3a, 0x32, 0x52, 0x25, 0x40, 0x96, 0x61, 0x8e, 0x45, 0x51, 0x10, 0xa9, 0xe2, 0x21,
0x75, 0x79, 0xd5, 0xd7, 0xa3, 0xb0, 0x55, 0x3f, 0x10, 0x57, 0x3d, 0x95, 0x0c, 0x56, 0x15, 0x2a,
0x89, 0xd5, 0x38, 0x0c, 0xfc, 0x98, 0x59, 0x0b, 0x18, 0xba, 0xb0, 0xcb, 0x63, 0xb5, 0x0f, 0xeb,
0x5b, 0x03, 0x2a, 0x09, 0x45, 0xf2, 0x90, 0x2f, 0xa0, 0xd8, 0x6f, 0x0d, 0x49, 0x0f, 0x78, 0x98,
0x1a, 0x54, 0x5d, 0x5e, 0xeb, 0x2b, 0xaa, 0x25, 0xe8, 0xea, 0xcc, 0x67, 0x50, 0x1d, 0x66, 0x18,
0x93, 0xfd, 0x0f, 0x07, 0x1b, 0xc4, 0x70, 0xbf, 0xd2, 0x4e, 0xc3, 0xb7, 0xb3, 0x70, 0x85, 0x32,
0x81, 0x5d, 0x76, 0x8f, 0xed, 0x0e, 0xdb, 0x08, 0xfc, 0xb6, 0xdb, 0x49, 0xc2, 0x5c, 0x15, 0xcd,
0x30, 0xd1, 0x8c, 0x7d, 0x71, 0x19, 0xf2, 0x4d, 0xcf, 0xe6, 0xed, 0x20, 0x3a, 0x56, 0xca, 0x4b,
0xa8, 0x3c, 0xa1, 0xd1, 0xde, 0x2a, 0x59, 0x84, 0xa2, 0x52, 0xbc, 0x1f, 0x38, 0x49, 0x3a, 0x75,
0x12, 0xa9, 0xc1, 0xfc, 0x5e, 0xd0, 0x79, 0x86, 0xc9, 0x96, 0x15, 0x96, 0x4c, 0x89, 0x05, 0x25,
0xc5, 0x18, 0xf5, 0xaa, 0x6b, 0x8e, 0x0e, 0xd0, 0xc8, 0xfb, 0x50, 0x38, 0x60, 0x71, 0xec, 0x06,
0xfe, 0xee, 0x66, 0x2d, 0x27, 0xe4, 0xfb, 0x04, 0xd4, 0x7d, 0xc0, 0x83, 0x88, 0xed, 0x6e, 0xd6,
0xe6, 0xa5, 0x6e, 0x35, 0x25, 0xfb, 0x50, 0x39, 0x10, 0x38, 0xa7, 0x89, 0xe8, 0xc6, 0x65, 0x71,
0x2d, 0x2f, 0x52, 0x74, 0x63, 0x34, 0x45, 0x3a, 0x1e, 0xaa, 0x0b, 0xf6, 0x33, 0x3a, 0x24, 0x6c,
0xfd, 0xd6, 0x00, 0x73, 0x5c, 0x00, 0xd5, 0x69, 0xf8, 0x0c, 0x72, 0xf2, 0x7c, 0xcb, 0x20, 0xfe,
0x6f, 0x95, 0x21, 0x7f, 0xc9, 0x7b, 0x90, 0x93, 0xda, 0x55, 0x51, 0xab, 0x59, 0x92, 0xa5, 0x4c,
0x2f, 0x4b, 0xd6, 0xaf, 0x73, 0x50, 0x3a, 0xc0, 0x2d, 0x25, 0x89, 0xac, 0x03, 0xf4, 0xf3, 0xaf,
0x6a, 0x66, 0xf8, 0x54, 0x68, 0x1c, 0xc4, 0x84, 0xfc, 0xb6, 0x3a, 0x9f, 0xea, 0x8a, 0xec, 0xcd,
0xc9, 0xe7, 0x50, 0x4c, 0xc6, 0xcf, 0x43, 0x5e, 0xcb, 0x88, 0xe8, 0x3d, 0x48, 0x39, 0xe0, 0xfa,
0x4e, 0xea, 0x9a, 0xa8, 0x3a, 0xde, 0x1a, 0x85, 0xdc, 0x86, 0x4b, 0xb6, 0xe7, 0x05, 0xa7, 0xaa,
0x66, 0x45, 0xf5, 0x89, 0xec, 0xe7, 0xe9, 0xe8, 0x02, 0xf6, 0x62, 0x8d, 0xf8, 0x24, 0x8a, 0xec,
0x33, 0x0c, 0x44, 0x4e, 0xf0, 0x8f, 0x5b, 0xc2, 0xb6, 0xb8, 0xed, 0xfa, 0xb6, 0x57, 0x03, 0xc1,
0x23, 0x27, 0x78, 0xdc, 0xb6, 0x5e, 0x87, 0x41, 0xc4, 0x59, 0xf4, 0x84, 0xf3, 0xa8, 0x56, 0x14,
0xe1, 0x1d, 0xa0, 0x91, 0x26, 0x94, 0x36, 0xec, 0xd6, 0x11, 0xdb, 0x3d, 0x46, 0x62, 0x02, 0xdd,
0xd2, 0x9a, 0xa5, 0x60, 0x7f, 0x1e, 0xea, 0x98, 0x4d, 0xd7, 0x40, 0x5a, 0x50, 0x49, 0x5c, 0x97,
0x2d, 0xa0, 0x56, 0x16, 0x3a, 0x1f, 0x4d, 0x1b, 0x4a, 0x29, 0x2d, 0x4d, 0x0c, 0xa9, 0xc4, 0x44,
0x6e, 0x61, 0xb5, 0xdb, 0x9c, 0xd5, 0x2a, 0xc2, 0xe7, 0xde, 0x7c, 0x4c, 0x25, 0x2c, 0xbc, 0x45,
0x25, 0x98, 0x8f, 0xa1, 0x3a, 0x9c, 0xdc, 0x69, 0x90, 0x97, 0xf9, 0x63, 0x78, 0x67, 0x8c, 0x47,
0x6f, 0xd5, 0xdd, 0xfe, 0x6c, 0xc0, 0xa5, 0x91, 0x34, 0xe0, 0x0d, 0x23, 0xba, 0x8a, 0x54, 0x29,
0xc6, 0x64, 0x1f, 0xe6, 0x30, 0xcd, 0xb1, 0xc2, 0x1a, 0x6b, 0xd3, 0xe4, 0xb5, 0x2e, 0x24, 0x65,
0xfc, 0xa5, 0x16, 0xf3, 0x01, 0x40, 0x9f, 0x38, 0x15, 0xfe, 0xfc, 0x02, 0xca, 0x2a, 0xc9, 0xaa,
0x83, 0x54, 0x25, 0x6c, 0x51, 0xc2, 0x08, 0x4b, 0xfa, 0x97, 0x5f, 0x66, 0xca, 0xcb, 0xcf, 0xfa,
0x0a, 0x16, 0x28, 0xb3, 0x9d, 0x6d, 0xd7, 0x63, 0xe7, 0xf7, 0x78, 0x2c, 0x7e, 0xd7, 0x63, 0x4d,
0x84, 0x3e, 0x49, 0xf1, 0xab, 0x39, 0x79, 0x08, 0x73, 0xd4, 0xf6, 0x3b, 0x4c, 0x99, 0xfe, 0x30,
0xc5, 0xb4, 0x30, 0x82, 0xbc, 0x54, 0x8a, 0x58, 0x8f, 0xa0, 0xd0, 0xa3, 0x61, 0x33, 0x7b, 0xde,
0x6e, 0xc7, 0x4c, 0x36, 0xc6, 0x0c, 0x55, 0x33, 0xa4, 0xef, 0x31, 0xbf, 0xa3, 0x4c, 0x67, 0xa8,
0x9a, 0x59, 0x4b, 0xf8, 0x5e, 0x48, 0x76, 0xae, 0x42, 0x43, 0x20, 0xbb, 0x89, 0xf8, 0xd0, 0x10,
0xf5, 0x2a, 0xc6, 0x96, 0x83, 0x97, 0xb6, 0xed, 0x6c, 0xba, 0xd1, 0xf9, 0x0e, 0xd6, 0x60, 0x7e,
0xd3, 0x8d, 0x34, 0xff, 0x92, 0x29, 0x59, 0xc2, 0xeb, 0xbc, 0xe5, 0x75, 0x1d, 0xf4, 0x96, 0xb3,
0xc8, 0x57, 0x5d, 0x75, 0x88, 0x6a, 0x7d, 0x22, 0xe3, 0x28, 0xac, 0xa8, 0xcd, 0xdc, 0x86, 0x79,
0xe6, 0xf3, 0x08, 0xcb, 0x48, 0xde, 0xf9, 0xa4, 0x2e, 0x5f, 0xe0, 0x75, 0xf1, 0x02, 0x17, 0xd8,
0x82, 0x26, 0x2c, 0xd6, 0x1a, 0x2c, 0x20, 0x21, 0x3d, 0x11, 0x04, 0xb2, 0xda, 0x26, 0xc5, 0xd8,
0x7a, 0x08, 0xd5, 0xbe, 0xa0, 0x32, 0xbd, 0x04, 0x59, 0x04, 0xbf, 0xaa, 0xaf, 0x8f, 0xb3, 0x2b,
0xd6, 0xad, 0xeb, 0xb0, 0x90, 0x14, 0xff, 0xb9, 0x46, 0x2d, 0x02, 0xd5, 0x3e, 0x93, 0xc2, 0x3d,
0x65, 0x28, 0x36, 0x5d, 0x3f, 0x81, 0x05, 0xd6, 0x1b, 0x03, 0x4a, 0xcd, 0xc0, 0xef, 0xdf, 0x72,
0x4d, 0x58, 0x48, 0x4a, 0xf7, 0x49, 0x73, 0x77, 0xc3, 0x0e, 0x93, 0x18, 0x2c, 0x8e, 0x9e, 0x0f,
0xf5, 0x0d, 0xa3, 0x2e, 0x19, 0xd7, 0xb3, 0x78, 0x21, 0xd2, 0x61, 0x71, 0xf2, 0x29, 0xcc, 0xef,
0xed, 0xad, 0x0b, 0x4d, 0xb3, 0x53, 0x69, 0x4a, 0xc4, 0xc8, 0x63, 0x98, 0x7f, 0x29, 0x3e, 0xad,
0xc4, 0xea, 0x8a, 0x1a, 0x73, 0x56, 0x65, 0x84, 0x24, 0x1b, 0x65, 0xad, 0x20, 0x72, 0x68, 0x22,
0x64, 0xfd, 0xdb, 0x80, 0xe2, 0x4b, 0xbb, 0x0f, 0x39, 0xfb, 0x18, 0xf7, 0x2d, 0x6e, 0x72, 0x85,
0x71, 0x2f, 0xc3, 0x9c, 0xc7, 0x4e, 0x98, 0xa7, 0xce, 0xb8, 0x9c, 0x20, 0x35, 0x3e, 0x0a, 0x22,
0x59, 0xd6, 0x25, 0x2a, 0x27, 0x58, 0x10, 0x0e, 0xe3, 0xb6, 0xeb, 0xd5, 0xb2, 0x8b, 0x19, 0xbc,
0xf5, 0xe5, 0x0c, 0x33, 0xd7, 0x8d, 0x3c, 0xf5, 0xf0, 0xc0, 0x21, 0xb1, 0x20, 0xeb, 0xfa, 0xed,
0x40, 0xdc, 0x7f, 0xaa, 0x2d, 0xca, 0x16, 0xbd, 0xeb, 0xb7, 0x03, 0x2a, 0xd6, 0xc8, 0x35, 0xc8,
0x45, 0x58, 0x7f, 0x71, 0x6d, 0x5e, 0x04, 0xa5, 0x80, 0x5c, 0xb2, 0x4a, 0xd5, 0x82, 0x55, 0x81,
0x92, 0xf4, 0x5b, 0x25, 0xff, 0x4f, 0xb3, 0xf0, 0xce, 0x33, 0x76, 0xba, 0x91, 0xf8, 0x95, 0x04,
0x64, 0x11, 0x8a, 0x3d, 0xda, 0xee, 0xa6, 0x3a, 0x42, 0x3a, 0x09, 0x8d, 0xed, 0x07, 0x5d, 0x9f,
0x27, 0x39, 0x14, 0xc6, 0x04, 0x85, 0xaa, 0x05, 0x72, 0x03, 0xe6, 0x9f, 0x31, 0x7e, 0x1a, 0x44,
0xaf, 0x84, 0xd7, 0x95, 0xd5, 0x22, 0xf2, 0x3c, 0x63, 0x1c, 0x11, 0x22, 0x4d, 0xd6, 0x10, 0x76,
0x86, 0x09, 0xec, 0xcc, 0x8e, 0x83, 0x9d, 0xc9, 0x2a, 0x59, 0x83, 0x62, 0x2b, 0xf0, 0x63, 0x1e,
0xd9, 0x2e, 0x1a, 0x9e, 0x13, 0xcc, 0xef, 0x22, 0xb3, 0x4c, 0xec, 0x46, 0x7f, 0x91, 0xea, 0x9c,
0x64, 0x05, 0x80, 0xbd, 0xe6, 0x91, 0xbd, 0x13, 0xc4, 0xbd, 0x27, 0x1a, 0xa0, 0x1c, 0x12, 0x76,
0x9b, 0x54, 0x5b, 0xc5, 0x0e, 0x79, 0x14, 0xc4, 0x5c, 0xbc, 0x53, 0x24, 0xbc, 0xec, 0xcd, 0xad,
0xf7, 0xe0, 0xf2, 0x60, 0xb4, 0x54, 0x18, 0x1f, 0xc1, 0xff, 0x51, 0xe6, 0x31, 0x3b, 0x66, 0xd3,
0x47, 0xd2, 0x32, 0xa1, 0x36, 0x2a, 0xac, 0x14, 0xff, 0x27, 0x03, 0xc5, 0xad, 0xd7, 0xac, 0xb5,
0xcf, 0xe2, 0xd8, 0xee, 0x08, 0x60, 0xdc, 0x8c, 0x82, 0x16, 0x8b, 0xe3, 0x9e, 0xae, 0x3e, 0x81,
0xfc, 0x10, 0xb2, 0xbb, 0xbe, 0xcb, 0xd5, 0xdd, 0xb9, 0x94, 0xfa, 0x2e, 0x71, 0xb9, 0xd2, 0xb9,
0x33, 0x43, 0x85, 0x14, 0x79, 0x08, 0x59, 0xec, 0x3c, 0x93, 0x74, 0x7f, 0x47, 0x93, 0x45, 0x19,
0xb2, 0x2e, 0xbe, 0x1f, 0xba, 0x5f, 0x32, 0x95, 0xc1, 0xe5, 0xf4, 0x6b, 0xcb, 0xfd, 0x92, 0xf5,
0x35, 0x28, 0x49, 0xb2, 0x85, 0xb0, 0xde, 0x8e, 0x38, 0x73, 0x54, 0x66, 0x6f, 0xa6, 0x81, 0x25,
0xc9, 0xd9, 0xd7, 0x92, 0xc8, 0x62, 0x10, 0xb6, 0x5e, 0xbb, 0x5c, 0x55, 0x4a, 0x5a, 0x10, 0x90,
0x4d, 0x73, 0x04, 0xa7, 0x28, 0xbd, 0x19, 0xf8, 0x32, 0xf3, 0xe9, 0xd2, 0xc8, 0xa6, 0x49, 0xe3,
0x14, 0xc3, 0x70, 0xe0, 0x76, 0x10, 0x83, 0xe6, 0x2f, 0x0c, 0x83, 0x64, 0xd4, 0xc2, 0x20, 0x09,
0xeb, 0xf3, 0x30, 0x27, 0x20, 0x92, 0xf5, 0x77, 0x03, 0x8a, 0x5a, 0x9e, 0x26, 0xa8, 0xc9, 0xf7,
0x21, 0xbb, 0xcf, 0xc4, 0x37, 0x15, 0x34, 0x9e, 0x17, 0x15, 0xc9, 0xb8, 0x4d, 0x05, 0x15, 0x9b,
0xca, 0xb6, 0x23, 0x1b, 0x66, 0x99, 0xe2, 0x10, 0x29, 0x2f, 0xf8, 0x99, 0x48, 0x59, 0x9e, 0xe2,
0x90, 0xdc, 0x86, 0xfc, 0x01, 0x6b, 0x75, 0x23, 0x97, 0x9f, 0x89, 0x24, 0x54, 0x56, 0xab, 0xa2,
0xd5, 0x28, 0x9a, 0x28, 0xdc, 0x1e, 0x07, 0xb9, 0x05, 0x85, 0x98, 0xb5, 0x22, 0xc6, 0x99, 0x7f,
0xa2, 0xaa, 0xaa, 0xac, 0xd8, 0x23, 0xc6, 0xb7, 0xfc, 0x13, 0xda, 0x5f, 0xb7, 0x9e, 0xe2, 0x49,
0xee, 0x7b, 0x43, 0x20, 0xbb, 0x81, 0x6f, 0x47, 0x74, 0xa3, 0x4c, 0xc5, 0x18, 0x9f, 0xef, 0x5b,
0x17, 0x3d, 0xdf, 0xb7, 0x92, 0xe7, 0xfb, 0xe0, 0x09, 0xc0, 0x6b, 0x4c, 0xcb, 0x88, 0xf5, 0x04,
0x0a, 0xbd, 0x53, 0x4a, 0x2a, 0x30, 0xbb, 0xed, 0x28, 0x4b, 0xb3, 0xdb, 0x0e, 0xfa, 0xbd, 0xf5,
0x7c, 0x5b, 0x58, 0xc9, 0x53, 0x1c, 0xf6, 0xd0, 0x46, 0x46, 0x43, 0x1b, 0x6b, 0x50, 0x1e, 0x38,
0xaa, 0xc8, 0x44, 0x83, 0xd3, 0x38, 0xd9, 0x32, 0x8e, 0xa5, 0x1b, 0x5e, 0x2c, 0x74, 0x09, 0x37,
0xbc, 0xd8, 0xba, 0x0e, 0xe5, 0x81, 0xe4, 0x22, 0x93, 0x78, 0x09, 0x2b, 0x50, 0x8a, 0xe3, 0x15,
0x06, 0x0b, 0x43, 0x1f, 0xc7, 0xc8, 0x0d, 0xc8, 0xc9, 0x8f, 0x30, 0xd5, 0x19, 0xf3, 0xca, 0xd7,
0xdf, 0x2c, 0xbe, 0x3b, 0xc4, 0x20, 0x17, 0x91, 0x6d, 0xbd, 0xeb, 0x3b, 0x1e, 0xab, 0x1a, 0x63,
0xd9, 0xe4, 0xa2, 0x99, 0xfd, 0xcd, 0x1f, 0xae, 0xce, 0xac, 0xd8, 0x70, 0x69, 0xe4, 0xc3, 0x0e,
0xb9, 0x0e, 0xd9, 0x03, 0xe6, 0xb5, 0x13, 0x33, 0x23, 0x0c, 0xb8, 0x48, 0xae, 0x41, 0x86, 0xda,
0xa7, 0x55, 0xc3, 0xac, 0x7d, 0xfd, 0xcd, 0xe2, 0xe5, 0xd1, 0xaf, 0x43, 0xf6, 0xa9, 0x34, 0xb1,
0xfa, 0x57, 0x80, 0xc2, 0xde, 0xde, 0xfa, 0x7a, 0xe4, 0x3a, 0x1d, 0x46, 0x7e, 0x65, 0x00, 0x19,
0x7d, 0x33, 0x93, 0x7b, 0xe9, 0x0d, 0x61, 0xfc, 0x37, 0x0a, 0xf3, 0xfe, 0x94, 0x52, 0x0a, 0xb2,
0x7c, 0x0e, 0x73, 0x02, 0x67, 0x93, 0x8f, 0x26, 0x7c, 0x6e, 0x99, 0xcb, 0x17, 0x33, 0x2a, 0xdd,
0x2d, 0xc8, 0x27, 0x58, 0x95, 0xac, 0xa4, 0x6e, 0x6f, 0x00, 0x8a, 0x9b, 0xb7, 0x26, 0xe2, 0x55,
0x46, 0x7e, 0x0e, 0xf3, 0x0a, 0x82, 0x92, 0x9b, 0x17, 0xc8, 0xf5, 0xc1, 0xb0, 0xb9, 0x32, 0x09,
0x6b, 0xdf, 0x8d, 0x04, 0x6a, 0xa6, 0xba, 0x31, 0x04, 0x64, 0x53, 0xdd, 0x18, 0xc1, 0xae, 0xad,
0xfe, 0x03, 0x35, 0xd5, 0xc8, 0x10, 0x70, 0x4d, 0x35, 0x32, 0x8c, 0x5f, 0xc9, 0x4b, 0xc8, 0x22,
0x7e, 0x25, 0x69, 0xbd, 0x5a, 0x03, 0xb8, 0x66, 0xda, 0x99, 0x18, 0x00, 0xbe, 0x3f, 0xc3, 0x3b,
0x4d, 0x7c, 0x8b, 0x48, 0xbf, 0xcd, 0xb4, 0x6f, 0x97, 0xe6, 0xcd, 0x09, 0x38, 0xfb, 0xea, 0xd5,
0x3b, 0x7e, 0x79, 0x82, 0x0f, 0x88, 0x17, 0xab, 0x1f, 0xfa, 0x54, 0x19, 0x40, 0x49, 0x87, 0x2a,
0xa4, 0x9e, 0x22, 0x3a, 0x06, 0x01, 0x9a, 0x8d, 0x89, 0xf9, 0x95, 0xc1, 0xaf, 0xf0, 0x11, 0x37,
0x08, 0x63, 0xc8, 0x6a, 0x6a, 0x38, 0xc6, 0x02, 0x26, 0xf3, 0xee, 0x54, 0x32, 0xca, 0xb8, 0x2d,
0x61, 0x92, 0x82, 0x42, 0x24, 0xfd, 0xd6, 0xef, 0xc1, 0x29, 0x73, 0x42, 0xbe, 0x65, 0xe3, 0x8e,
0x81, 0xe7, 0x0c, 0xa1, 0x73, 0xaa, 0x6e, 0xed, 0x4d, 0x91, 0x7a, 0xce, 0x74, 0x0c, 0xbe, 0x5e,
0xfa, 0xee, 0xcd, 0x55, 0xe3, 0x1f, 0x6f, 0xae, 0x1a, 0xff, 0x7a, 0x73, 0xd5, 0x38, 0xcc, 0x89,
0x7f, 0x64, 0xef, 0xfe, 0x37, 0x00, 0x00, 0xff, 0xff, 0x20, 0x47, 0x7d, 0x27, 0x1a, 0x1f, 0x00,
0x00,
0x7a, 0x3b, 0x0a, 0x7c, 0xce, 0x7c, 0xc7, 0x5c, 0xed, 0xb8, 0xfc, 0xa8, 0x7b, 0x58, 0x6f, 0x05,
0xc7, 0x8d, 0x4e, 0xd0, 0x09, 0x1a, 0x9d, 0x20, 0xe8, 0x78, 0xcc, 0x0e, 0xdd, 0x58, 0x0d, 0x1b,
0x51, 0xd8, 0x6a, 0xc4, 0xdc, 0xe6, 0xdd, 0x58, 0xaa, 0x33, 0x3f, 0x1e, 0x96, 0x11, 0xe4, 0xc3,
0x6e, 0x5b, 0xcc, 0xc4, 0x44, 0x8c, 0x14, 0x7b, 0x43, 0x63, 0xc7, 0x8d, 0x34, 0x92, 0x8d, 0x34,
0xec, 0xd0, 0x6d, 0xf0, 0xb3, 0x90, 0xc5, 0x8d, 0xd3, 0x20, 0x7a, 0xc5, 0x22, 0x25, 0x70, 0xfb,
0x5c, 0x81, 0x38, 0xf0, 0x4e, 0x58, 0xd4, 0x08, 0x0f, 0x1b, 0x41, 0x98, 0xec, 0xe6, 0x7e, 0x0a,
0x77, 0x37, 0x6a, 0xb1, 0x30, 0xf0, 0xdc, 0xd6, 0x19, 0xca, 0xc8, 0x91, 0x12, 0xbb, 0x7b, 0xae,
0x58, 0x97, 0xbb, 0x1e, 0x6e, 0xad, 0x65, 0x87, 0x31, 0x8a, 0xe1, 0xef, 0x18, 0xcf, 0x79, 0xe0,
0xbb, 0x31, 0x77, 0xdd, 0x8e, 0xdb, 0x68, 0xc7, 0x42, 0x46, 0xba, 0x82, 0xa1, 0x92, 0xec, 0xd6,
0xdf, 0xb2, 0x90, 0xa3, 0x2c, 0xee, 0x7a, 0x9c, 0x2c, 0x41, 0x39, 0x62, 0xed, 0x4d, 0x16, 0x46,
0xac, 0x65, 0x73, 0xe6, 0xd4, 0x8c, 0x45, 0x63, 0xb9, 0xb0, 0x33, 0x43, 0x07, 0xc9, 0xe4, 0x27,
0x50, 0x89, 0x58, 0x3b, 0xd6, 0x18, 0x67, 0x17, 0x8d, 0xe5, 0xe2, 0xea, 0xad, 0xfa, 0xb9, 0x39,
0xac, 0x53, 0xd6, 0xde, 0xb7, 0xc3, 0xbe, 0xc8, 0xce, 0x0c, 0x1d, 0x52, 0x42, 0x56, 0x21, 0x13,
0xb1, 0x76, 0x2d, 0x23, 0x74, 0x5d, 0x4d, 0xd7, 0xb5, 0x33, 0x43, 0x91, 0x99, 0xac, 0x41, 0x16,
0xb5, 0xd4, 0xb2, 0x42, 0xe8, 0xda, 0x85, 0x1b, 0xd8, 0x99, 0xa1, 0x42, 0x80, 0x3c, 0x85, 0xfc,
0x31, 0xe3, 0xb6, 0x63, 0x73, 0xbb, 0x06, 0x8b, 0x99, 0xe5, 0xe2, 0x6a, 0x23, 0x55, 0x18, 0x03,
0x54, 0xdf, 0x57, 0x12, 0x5b, 0x3e, 0x8f, 0xce, 0x68, 0x4f, 0x01, 0x79, 0x09, 0x25, 0x9b, 0x73,
0x86, 0x51, 0x75, 0x03, 0x3f, 0xae, 0x95, 0x84, 0xc2, 0xbb, 0x17, 0x2b, 0x7c, 0xa2, 0x49, 0x49,
0xa5, 0x03, 0x8a, 0xcc, 0x47, 0x50, 0x1e, 0xb0, 0x49, 0xaa, 0x90, 0x79, 0xc5, 0xce, 0x64, 0x62,
0x28, 0x0e, 0xc9, 0x65, 0x98, 0x3b, 0xb1, 0xbd, 0x2e, 0x13, 0x39, 0x28, 0x51, 0x39, 0x79, 0x38,
0xfb, 0xc0, 0x30, 0x8f, 0xe0, 0xd2, 0x88, 0xfe, 0x31, 0x0a, 0x7e, 0xa4, 0x2b, 0x28, 0xae, 0x7e,
0x94, 0xb2, 0x6b, 0x5d, 0x9d, 0x66, 0x69, 0x3d, 0x0f, 0xb9, 0x48, 0x38, 0x64, 0xfd, 0xce, 0x80,
0xea, 0x70, 0xaa, 0xc9, 0xae, 0x4a, 0x92, 0x21, 0xc2, 0x72, 0x7f, 0x8a, 0x53, 0x82, 0x04, 0x15,
0x18, 0xa1, 0xc2, 0x5c, 0x83, 0x42, 0x8f, 0x74, 0x51, 0x30, 0x0a, 0xda, 0x16, 0xad, 0x35, 0xc8,
0x50, 0xd6, 0x26, 0x15, 0x98, 0x75, 0xd5, 0xb9, 0xa6, 0xb3, 0xae, 0x43, 0x16, 0x21, 0xe3, 0xb0,
0xb6, 0x72, 0xbd, 0x52, 0x0f, 0x0f, 0xeb, 0x9b, 0xac, 0xed, 0xfa, 0x2e, 0xba, 0x48, 0x71, 0xc9,
0xfa, 0xbd, 0x81, 0xf5, 0x81, 0xdb, 0x22, 0x9f, 0x0c, 0xf8, 0x71, 0xf1, 0x69, 0x1f, 0xd9, 0xfd,
0xcb, 0xf4, 0xdd, 0xdf, 0x1b, 0xcc, 0xc4, 0x05, 0x25, 0xa0, 0x7b, 0xf7, 0x53, 0x28, 0xe9, 0xb9,
0x21, 0x3b, 0x50, 0xd4, 0xce, 0x91, 0xda, 0xf0, 0xd2, 0x64, 0x99, 0xa5, 0xba, 0xa8, 0xf5, 0xc7,
0x0c, 0x14, 0xb5, 0x45, 0xf2, 0x18, 0xb2, 0xaf, 0x5c, 0x5f, 0x86, 0xb0, 0xb2, 0xba, 0x32, 0x99,
0xca, 0xa7, 0xae, 0xef, 0x50, 0x21, 0x47, 0x9a, 0x5a, 0xdd, 0xcd, 0x8a, 0x6d, 0xdd, 0x9b, 0x4c,
0xc7, 0xb9, 0xc5, 0x77, 0x67, 0x8a, 0xb6, 0x21, 0x9b, 0x06, 0x81, 0x6c, 0x68, 0xf3, 0x23, 0xd1,
0x34, 0x0a, 0x54, 0x8c, 0xc9, 0x1d, 0x78, 0xc7, 0xf5, 0x5f, 0x04, 0x3c, 0x68, 0x46, 0xcc, 0x71,
0xf1, 0xf0, 0xbd, 0x38, 0x0b, 0x59, 0x6d, 0x4e, 0xb0, 0x8c, 0x5b, 0x22, 0x4d, 0xa8, 0x48, 0xf2,
0x41, 0xf7, 0xf0, 0x17, 0xac, 0xc5, 0xe3, 0x5a, 0x4e, 0xf8, 0xb3, 0x9c, 0xb2, 0x85, 0x5d, 0x5d,
0x80, 0x0e, 0xc9, 0xbf, 0x55, 0xb5, 0x5b, 0x7f, 0x31, 0xa0, 0x3c, 0xa0, 0x9e, 0x7c, 0x3a, 0x90,
0xaa, 0xdb, 0x93, 0x6e, 0x4b, 0x4b, 0xd6, 0x67, 0x90, 0x73, 0xdc, 0x0e, 0x8b, 0xb9, 0x48, 0x55,
0x61, 0x7d, 0xf5, 0xbb, 0xef, 0x3f, 0x98, 0xf9, 0xe7, 0xf7, 0x1f, 0xac, 0x68, 0x57, 0x4c, 0x10,
0x32, 0xbf, 0x15, 0xf8, 0xdc, 0x76, 0x7d, 0x16, 0xe1, 0x7d, 0xfc, 0xb1, 0x14, 0xa9, 0x6f, 0x8a,
0x1f, 0xaa, 0x34, 0x60, 0xd0, 0x7d, 0xfb, 0x98, 0x89, 0x3c, 0x15, 0xa8, 0x18, 0x5b, 0x1c, 0xca,
0x94, 0xf1, 0x6e, 0xe4, 0x53, 0xf6, 0xcb, 0x2e, 0x32, 0xfd, 0x20, 0x69, 0x24, 0x62, 0xd3, 0x17,
0x35, 0x74, 0x64, 0xa4, 0x4a, 0x80, 0x2c, 0xc3, 0x1c, 0x8b, 0xa2, 0x20, 0x52, 0xc5, 0x43, 0xea,
0x12, 0x19, 0xd4, 0xa3, 0xb0, 0x55, 0x3f, 0x10, 0xc8, 0x80, 0x4a, 0x06, 0xab, 0x0a, 0x95, 0xc4,
0x6a, 0x1c, 0x06, 0x7e, 0xcc, 0xac, 0x05, 0x0c, 0x5d, 0xd8, 0xe5, 0xb1, 0xda, 0x87, 0xf5, 0xad,
0x01, 0x95, 0x84, 0x22, 0x79, 0xc8, 0x17, 0x50, 0xec, 0xb7, 0x86, 0xa4, 0x07, 0x3c, 0x4c, 0x0d,
0xaa, 0x2e, 0xaf, 0xf5, 0x15, 0xd5, 0x12, 0x74, 0x75, 0xe6, 0x33, 0xa8, 0x0e, 0x33, 0x8c, 0xc9,
0xfe, 0x87, 0x83, 0x0d, 0x62, 0xb8, 0x5f, 0x69, 0xa7, 0xe1, 0xdb, 0x59, 0xb8, 0x42, 0x99, 0x80,
0x22, 0xbb, 0xc7, 0x76, 0x87, 0x6d, 0x04, 0x7e, 0xdb, 0xed, 0x24, 0x61, 0xae, 0x8a, 0x66, 0x98,
0x68, 0xc6, 0xbe, 0xb8, 0x0c, 0xf9, 0xa6, 0x67, 0xf3, 0x76, 0x10, 0x1d, 0x2b, 0xe5, 0x25, 0x54,
0x9e, 0xd0, 0x68, 0x6f, 0x95, 0x2c, 0x42, 0x51, 0x29, 0xde, 0x0f, 0x9c, 0x24, 0x9d, 0x3a, 0x89,
0xd4, 0x60, 0x7e, 0x2f, 0xe8, 0x3c, 0xc3, 0x64, 0xcb, 0x0a, 0x4b, 0xa6, 0xc4, 0x82, 0x92, 0x62,
0x8c, 0x7a, 0xd5, 0x35, 0x47, 0x07, 0x68, 0xe4, 0x7d, 0x28, 0x1c, 0xb0, 0x38, 0x76, 0x03, 0x7f,
0x77, 0xb3, 0x96, 0x13, 0xf2, 0x7d, 0x02, 0xea, 0x3e, 0xe0, 0x41, 0xc4, 0x76, 0x37, 0x6b, 0xf3,
0x52, 0xb7, 0x9a, 0x92, 0x7d, 0xa8, 0x1c, 0x08, 0x2c, 0xd5, 0x44, 0x04, 0xe5, 0xb2, 0xb8, 0x96,
0x17, 0x29, 0xba, 0x31, 0x9a, 0x22, 0x1d, 0x73, 0xd5, 0x05, 0xfb, 0x19, 0x1d, 0x12, 0xb6, 0x7e,
0x6b, 0x80, 0x39, 0x2e, 0x80, 0xea, 0x34, 0x7c, 0x06, 0x39, 0x79, 0xbe, 0x65, 0x10, 0xff, 0xb7,
0xca, 0x90, 0xbf, 0xe4, 0x3d, 0xc8, 0x49, 0xed, 0xaa, 0xa8, 0xd5, 0x2c, 0xc9, 0x52, 0xa6, 0x97,
0x25, 0xeb, 0xd7, 0x39, 0x28, 0x1d, 0xe0, 0x96, 0x92, 0x44, 0xd6, 0x01, 0xfa, 0xf9, 0x57, 0x35,
0x33, 0x7c, 0x2a, 0x34, 0x0e, 0x62, 0x42, 0x7e, 0x5b, 0x9d, 0x4f, 0x75, 0x45, 0xf6, 0xe6, 0xe4,
0x73, 0x28, 0x26, 0xe3, 0xe7, 0x21, 0xaf, 0x65, 0x44, 0xf4, 0x1e, 0xa4, 0x1c, 0x70, 0x7d, 0x27,
0x75, 0x4d, 0x54, 0x1d, 0x6f, 0x8d, 0x42, 0x6e, 0xc3, 0x25, 0xdb, 0xf3, 0x82, 0x53, 0x55, 0xb3,
0xa2, 0xfa, 0x44, 0xf6, 0xf3, 0x74, 0x74, 0x01, 0x7b, 0xb1, 0x46, 0x7c, 0x12, 0x45, 0xf6, 0x19,
0x06, 0x22, 0x27, 0xf8, 0xc7, 0x2d, 0x61, 0x5b, 0xdc, 0x76, 0x7d, 0xdb, 0xab, 0x81, 0xe0, 0x91,
0x13, 0x3c, 0x6e, 0x5b, 0xaf, 0xc3, 0x20, 0xe2, 0x2c, 0x7a, 0xc2, 0x79, 0x54, 0x2b, 0x8a, 0xf0,
0x0e, 0xd0, 0x48, 0x13, 0x4a, 0x1b, 0x76, 0xeb, 0x88, 0xed, 0x1e, 0x23, 0x31, 0x81, 0x6e, 0x69,
0xcd, 0x52, 0xb0, 0x3f, 0x0f, 0x75, 0xcc, 0xa6, 0x6b, 0x20, 0x2d, 0xa8, 0x24, 0xae, 0xcb, 0x16,
0x50, 0x2b, 0x0b, 0x9d, 0x8f, 0xa6, 0x0d, 0xa5, 0x94, 0x96, 0x26, 0x86, 0x54, 0x62, 0x22, 0xb7,
0xb0, 0xda, 0x6d, 0xce, 0x6a, 0x15, 0xe1, 0x73, 0x6f, 0x3e, 0xa6, 0x12, 0x16, 0xde, 0xa2, 0x12,
0xcc, 0xc7, 0x50, 0x1d, 0x4e, 0xee, 0x34, 0xc8, 0xcb, 0xfc, 0x31, 0xbc, 0x33, 0xc6, 0xa3, 0xb7,
0xea, 0x6e, 0x7f, 0x36, 0xe0, 0xd2, 0x48, 0x1a, 0xf0, 0x86, 0x11, 0x5d, 0x45, 0xaa, 0x14, 0x63,
0xb2, 0x0f, 0x73, 0x98, 0xe6, 0x58, 0x61, 0x8d, 0xb5, 0x69, 0xf2, 0x5a, 0x17, 0x92, 0x32, 0xfe,
0x52, 0x8b, 0xf9, 0x00, 0xa0, 0x4f, 0x9c, 0x0a, 0x7f, 0x7e, 0x01, 0x65, 0x95, 0x64, 0xd5, 0x41,
0xaa, 0x12, 0xb6, 0x28, 0x61, 0x84, 0x25, 0xfd, 0xcb, 0x2f, 0x33, 0xe5, 0xe5, 0x67, 0x7d, 0x05,
0x0b, 0x94, 0xd9, 0xce, 0xb6, 0xeb, 0xb1, 0xf3, 0x7b, 0x3c, 0x16, 0xbf, 0xeb, 0xb1, 0x26, 0x42,
0x9f, 0xa4, 0xf8, 0xd5, 0x9c, 0x3c, 0x84, 0x39, 0x6a, 0xfb, 0x1d, 0xa6, 0x4c, 0x7f, 0x98, 0x62,
0x5a, 0x18, 0x41, 0x5e, 0x2a, 0x45, 0xac, 0x47, 0x50, 0xe8, 0xd1, 0xb0, 0x99, 0x3d, 0x6f, 0xb7,
0x63, 0x26, 0x1b, 0x63, 0x86, 0xaa, 0x19, 0xd2, 0xf7, 0x98, 0xdf, 0x51, 0xa6, 0x33, 0x54, 0xcd,
0xac, 0x25, 0x7c, 0x2f, 0x24, 0x3b, 0x57, 0xa1, 0x21, 0x90, 0xdd, 0x44, 0x7c, 0x68, 0x88, 0x7a,
0x15, 0x63, 0xcb, 0xc1, 0x4b, 0xdb, 0x76, 0x36, 0xdd, 0xe8, 0x7c, 0x07, 0x6b, 0x30, 0xbf, 0xe9,
0x46, 0x9a, 0x7f, 0xc9, 0x94, 0x2c, 0xe1, 0x75, 0xde, 0xf2, 0xba, 0x0e, 0x7a, 0xcb, 0x59, 0xe4,
0xab, 0xae, 0x3a, 0x44, 0xb5, 0x3e, 0x91, 0x71, 0x14, 0x56, 0xd4, 0x66, 0x6e, 0xc3, 0x3c, 0xf3,
0x79, 0x84, 0x65, 0x24, 0xef, 0x7c, 0x52, 0x97, 0x4f, 0xe9, 0xba, 0x78, 0x4a, 0x0b, 0x6c, 0x41,
0x13, 0x16, 0x6b, 0x0d, 0x16, 0x90, 0x90, 0x9e, 0x08, 0x02, 0x59, 0x6d, 0x93, 0x62, 0x6c, 0x3d,
0x84, 0x6a, 0x5f, 0x50, 0x99, 0x5e, 0x82, 0x2c, 0x82, 0x5f, 0xd5, 0xd7, 0xc7, 0xd9, 0x15, 0xeb,
0xd6, 0x75, 0x58, 0x48, 0x8a, 0xff, 0x5c, 0xa3, 0x16, 0x81, 0x6a, 0x9f, 0x49, 0xe1, 0x9e, 0x32,
0x14, 0x9b, 0xae, 0x9f, 0xc0, 0x02, 0xeb, 0x8d, 0x01, 0xa5, 0x66, 0xe0, 0xf7, 0x6f, 0xb9, 0x26,
0x2c, 0x24, 0xa5, 0xfb, 0xa4, 0xb9, 0xbb, 0x61, 0x87, 0x49, 0x0c, 0x16, 0x47, 0xcf, 0x87, 0xfa,
0x18, 0x51, 0x97, 0x8c, 0xeb, 0x59, 0xbc, 0x10, 0xe9, 0xb0, 0x38, 0xf9, 0x14, 0xe6, 0xf7, 0xf6,
0xd6, 0x85, 0xa6, 0xd9, 0xa9, 0x34, 0x25, 0x62, 0xe4, 0x31, 0xcc, 0xbf, 0x14, 0x1f, 0x62, 0x62,
0x75, 0x45, 0x8d, 0x39, 0xab, 0x32, 0x42, 0x92, 0x8d, 0xb2, 0x56, 0x10, 0x39, 0x34, 0x11, 0xb2,
0xfe, 0x6d, 0x40, 0xf1, 0xa5, 0xdd, 0x87, 0x9c, 0x7d, 0x8c, 0xfb, 0x16, 0x37, 0xb9, 0xc2, 0xb8,
0x97, 0x61, 0xce, 0x63, 0x27, 0xcc, 0x53, 0x67, 0x5c, 0x4e, 0x90, 0x1a, 0x1f, 0x05, 0x91, 0x2c,
0xeb, 0x12, 0x95, 0x13, 0x2c, 0x08, 0x87, 0x71, 0xdb, 0xf5, 0x6a, 0xd9, 0xc5, 0x0c, 0xde, 0xfa,
0x72, 0x86, 0x99, 0xeb, 0x46, 0x9e, 0x7a, 0x78, 0xe0, 0x90, 0x58, 0x90, 0x75, 0xfd, 0x76, 0x20,
0xee, 0x3f, 0xd5, 0x16, 0x65, 0x8b, 0xde, 0xf5, 0xdb, 0x01, 0x15, 0x6b, 0xe4, 0x1a, 0xe4, 0x22,
0xac, 0xbf, 0xb8, 0x36, 0x2f, 0x82, 0x52, 0x40, 0x2e, 0x59, 0xa5, 0x6a, 0xc1, 0xaa, 0x40, 0x49,
0xfa, 0xad, 0x92, 0xff, 0xa7, 0x59, 0x78, 0xe7, 0x19, 0x3b, 0xdd, 0x48, 0xfc, 0x4a, 0x02, 0xb2,
0x08, 0xc5, 0x1e, 0x6d, 0x77, 0x53, 0x1d, 0x21, 0x9d, 0x84, 0xc6, 0xf6, 0x83, 0xae, 0xcf, 0x93,
0x1c, 0x0a, 0x63, 0x82, 0x42, 0xd5, 0x02, 0xb9, 0x01, 0xf3, 0xcf, 0x18, 0x3f, 0x0d, 0xa2, 0x57,
0xc2, 0xeb, 0xca, 0x6a, 0x11, 0x79, 0x9e, 0x31, 0x8e, 0x08, 0x91, 0x26, 0x6b, 0x08, 0x3b, 0xc3,
0x04, 0x76, 0x66, 0xc7, 0xc1, 0xce, 0x64, 0x95, 0xac, 0x41, 0xb1, 0x15, 0xf8, 0x31, 0x8f, 0x6c,
0x17, 0x0d, 0xcf, 0x09, 0xe6, 0x77, 0x91, 0x59, 0x26, 0x76, 0xa3, 0xbf, 0x48, 0x75, 0x4e, 0xb2,
0x02, 0xc0, 0x5e, 0xf3, 0xc8, 0xde, 0x09, 0xe2, 0xde, 0x13, 0x0d, 0x50, 0x0e, 0x09, 0xbb, 0x4d,
0xaa, 0xad, 0x62, 0x87, 0x3c, 0x0a, 0x62, 0x2e, 0xde, 0x29, 0x12, 0x5e, 0xf6, 0xe6, 0xd6, 0x7b,
0x70, 0x79, 0x30, 0x5a, 0x2a, 0x8c, 0x8f, 0xe0, 0xff, 0x28, 0xf3, 0x98, 0x1d, 0xb3, 0xe9, 0x23,
0x69, 0x99, 0x50, 0x1b, 0x15, 0x56, 0x8a, 0xff, 0x93, 0x81, 0xe2, 0xd6, 0x6b, 0xd6, 0xda, 0x67,
0x71, 0x6c, 0x77, 0x04, 0x30, 0x6e, 0x46, 0x41, 0x8b, 0xc5, 0x71, 0x4f, 0x57, 0x9f, 0x40, 0x7e,
0x08, 0xd9, 0x5d, 0xdf, 0xe5, 0xea, 0xee, 0x5c, 0x4a, 0x7d, 0x97, 0xb8, 0x5c, 0xe9, 0xdc, 0x99,
0xa1, 0x42, 0x8a, 0x3c, 0x84, 0x2c, 0x76, 0x9e, 0x49, 0xba, 0xbf, 0xa3, 0xc9, 0xa2, 0x0c, 0x59,
0x17, 0xdf, 0x0f, 0xdd, 0x2f, 0x99, 0xca, 0xe0, 0x72, 0xfa, 0xb5, 0xe5, 0x7e, 0xc9, 0xfa, 0x1a,
0x94, 0x24, 0xd9, 0x42, 0x58, 0x6f, 0x47, 0x9c, 0x39, 0x2a, 0xb3, 0x37, 0xd3, 0xc0, 0x92, 0xe4,
0xec, 0x6b, 0x49, 0x64, 0x31, 0x08, 0x5b, 0xaf, 0x5d, 0xae, 0x2a, 0x25, 0x2d, 0x08, 0xc8, 0xa6,
0x39, 0x82, 0x53, 0x94, 0xde, 0x0c, 0x7c, 0x99, 0xf9, 0x74, 0x69, 0x64, 0xd3, 0xa4, 0x71, 0x8a,
0x61, 0x38, 0x70, 0x3b, 0x88, 0x41, 0xf3, 0x17, 0x86, 0x41, 0x32, 0x6a, 0x61, 0x90, 0x84, 0xf5,
0x79, 0x98, 0x13, 0x10, 0xc9, 0xfa, 0xbb, 0x01, 0x45, 0x2d, 0x4f, 0x13, 0xd4, 0xe4, 0xfb, 0x90,
0xdd, 0x67, 0xe2, 0x9b, 0x0a, 0x1a, 0xcf, 0x8b, 0x8a, 0x64, 0xdc, 0xa6, 0x82, 0x8a, 0x4d, 0x65,
0xdb, 0x91, 0x0d, 0xb3, 0x4c, 0x71, 0x88, 0x94, 0x17, 0xfc, 0x4c, 0xa4, 0x2c, 0x4f, 0x71, 0x48,
0x6e, 0x43, 0xfe, 0x80, 0xb5, 0xba, 0x91, 0xcb, 0xcf, 0x44, 0x12, 0x2a, 0xab, 0x55, 0xd1, 0x6a,
0x14, 0x4d, 0x14, 0x6e, 0x8f, 0x83, 0xdc, 0x82, 0x42, 0xcc, 0x5a, 0x11, 0xe3, 0xcc, 0x3f, 0x51,
0x55, 0x55, 0x56, 0xec, 0x11, 0xe3, 0x5b, 0xfe, 0x09, 0xed, 0xaf, 0x5b, 0x4f, 0xf1, 0x24, 0xf7,
0xbd, 0x21, 0x90, 0xdd, 0xc0, 0xb7, 0x23, 0xba, 0x51, 0xa6, 0x62, 0x8c, 0xcf, 0xf7, 0xad, 0x8b,
0x9e, 0xef, 0x5b, 0xc9, 0xf3, 0x7d, 0xf0, 0x04, 0xe0, 0x35, 0xa6, 0x65, 0xc4, 0x7a, 0x02, 0x85,
0xde, 0x29, 0x25, 0x15, 0x98, 0xdd, 0x76, 0x94, 0xa5, 0xd9, 0x6d, 0x07, 0xfd, 0xde, 0x7a, 0xbe,
0x2d, 0xac, 0xe4, 0x29, 0x0e, 0x7b, 0x68, 0x23, 0xa3, 0xa1, 0x8d, 0x35, 0x28, 0x0f, 0x1c, 0x55,
0x64, 0xa2, 0xc1, 0x69, 0x9c, 0x6c, 0x19, 0xc7, 0xd2, 0x0d, 0x2f, 0x16, 0xba, 0x84, 0x1b, 0x5e,
0x6c, 0x5d, 0x87, 0xf2, 0x40, 0x72, 0x91, 0x49, 0xbc, 0x84, 0x15, 0x28, 0xc5, 0xf1, 0x0a, 0x83,
0x85, 0xa1, 0x8f, 0x63, 0xe4, 0x06, 0xe4, 0xe4, 0x47, 0x98, 0xea, 0x8c, 0x79, 0xe5, 0xeb, 0x6f,
0x16, 0xdf, 0x1d, 0x62, 0x90, 0x8b, 0xc8, 0xb6, 0xde, 0xf5, 0x1d, 0x8f, 0x55, 0x8d, 0xb1, 0x6c,
0x72, 0xd1, 0xcc, 0xfe, 0xe6, 0x0f, 0x57, 0x67, 0x56, 0x6c, 0xb8, 0x34, 0xf2, 0x61, 0x87, 0x5c,
0x87, 0xec, 0x01, 0xf3, 0xda, 0x89, 0x99, 0x11, 0x06, 0x5c, 0x24, 0xd7, 0x20, 0x43, 0xed, 0xd3,
0xaa, 0x61, 0xd6, 0xbe, 0xfe, 0x66, 0xf1, 0xf2, 0xe8, 0xd7, 0x21, 0xfb, 0x54, 0x9a, 0x58, 0xfd,
0x2b, 0x40, 0x61, 0x6f, 0x6f, 0x7d, 0x3d, 0x72, 0x9d, 0x0e, 0x23, 0xbf, 0x32, 0x80, 0x8c, 0xbe,
0x99, 0xc9, 0xbd, 0xf4, 0x86, 0x30, 0xfe, 0x1b, 0x85, 0x79, 0x7f, 0x4a, 0x29, 0x05, 0x59, 0x3e,
0x87, 0x39, 0x81, 0xb3, 0xc9, 0x47, 0x13, 0x3e, 0xb7, 0xcc, 0xe5, 0x8b, 0x19, 0x95, 0xee, 0x16,
0xe4, 0x13, 0xac, 0x4a, 0x56, 0x52, 0xb7, 0x37, 0x00, 0xc5, 0xcd, 0x5b, 0x13, 0xf1, 0x2a, 0x23,
0x3f, 0x87, 0x79, 0x05, 0x41, 0xc9, 0xcd, 0x0b, 0xe4, 0xfa, 0x60, 0xd8, 0x5c, 0x99, 0x84, 0xb5,
0xef, 0x46, 0x02, 0x35, 0x53, 0xdd, 0x18, 0x02, 0xb2, 0xa9, 0x6e, 0x8c, 0x60, 0xd7, 0x56, 0xff,
0x81, 0x9a, 0x6a, 0x64, 0x08, 0xb8, 0xa6, 0x1a, 0x19, 0xc6, 0xaf, 0xe4, 0x25, 0x64, 0x11, 0xbf,
0x92, 0xb4, 0x5e, 0xad, 0x01, 0x5c, 0x33, 0xed, 0x4c, 0x0c, 0x00, 0xdf, 0x9f, 0xe1, 0x9d, 0x26,
0xbe, 0x45, 0xa4, 0xdf, 0x66, 0xda, 0xb7, 0x4b, 0xf3, 0xe6, 0x04, 0x9c, 0x7d, 0xf5, 0xea, 0x1d,
0xbf, 0x3c, 0xc1, 0x07, 0xc4, 0x8b, 0xd5, 0x0f, 0x7d, 0xaa, 0x0c, 0xa0, 0xa4, 0x43, 0x15, 0x52,
0x4f, 0x11, 0x1d, 0x83, 0x00, 0xcd, 0xc6, 0xc4, 0xfc, 0xca, 0xe0, 0x57, 0xf8, 0x88, 0x1b, 0x84,
0x31, 0x64, 0x35, 0x35, 0x1c, 0x63, 0x01, 0x93, 0x79, 0x77, 0x2a, 0x19, 0x65, 0xdc, 0x96, 0x30,
0x49, 0x41, 0x21, 0x92, 0x7e, 0xeb, 0xf7, 0xe0, 0x94, 0x39, 0x21, 0xdf, 0xb2, 0x71, 0xc7, 0xc0,
0x73, 0x86, 0xd0, 0x39, 0x55, 0xb7, 0xf6, 0xa6, 0x48, 0x3d, 0x67, 0x3a, 0x06, 0x5f, 0x2f, 0x7d,
0xf7, 0xe6, 0xaa, 0xf1, 0x8f, 0x37, 0x57, 0x8d, 0x7f, 0xbd, 0xb9, 0x6a, 0x1c, 0xe6, 0xc4, 0x3f,
0xb2, 0x77, 0xff, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x83, 0xe1, 0x34, 0x1a, 0x1a, 0x1f, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.

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

@ -2,15 +2,13 @@ syntax = "proto3";
package moby.buildkit.v1.frontend;
import "github.com/gogo/protobuf/gogoproto/gogo.proto";
import "github.com/gogo/googleapis/google/rpc/status.proto";
import "github.com/moby/buildkit/solver/pb/ops.proto";
import "github.com/gogo/protobuf/gogoproto/gogo.proto";
import "github.com/moby/buildkit/api/types/worker.proto";
import "github.com/moby/buildkit/solver/pb/ops.proto";
import "github.com/moby/buildkit/sourcepolicy/pb/policy.proto";
import "github.com/moby/buildkit/util/apicaps/pb/caps.proto";
import "github.com/tonistiigi/fsutil/types/stat.proto";
import "github.com/moby/buildkit/sourcepolicy/pb/policy.proto";
option (gogoproto.sizer_all) = true;
option (gogoproto.marshaler_all) = true;
@ -70,7 +68,7 @@ message RefMap {
}
message Attestations {
repeated Attestation attestation = 1;
repeated Attestation attestation = 1;
}
message Attestation {
@ -167,7 +165,7 @@ message SolveResponse {
// deprecated
string ref = 1; // can be used by readfile request
// deprecated
/* bytes ExporterAttr = 2;*/
// bytes ExporterAttr = 2;
// these fields are returned when allowMapReturn was set
Result result = 3;

8
vendor/github.com/moby/buildkit/session/auth/auth.proto generated vendored
View File

@ -5,10 +5,10 @@ package moby.filesync.v1;
option go_package = "auth";
service Auth{
rpc Credentials(CredentialsRequest) returns (CredentialsResponse);
rpc FetchToken(FetchTokenRequest) returns (FetchTokenResponse);
rpc GetTokenAuthority(GetTokenAuthorityRequest) returns (GetTokenAuthorityResponse);
rpc VerifyTokenAuthority(VerifyTokenAuthorityRequest) returns (VerifyTokenAuthorityResponse);
rpc Credentials(CredentialsRequest) returns (CredentialsResponse);
rpc FetchToken(FetchTokenRequest) returns (FetchTokenResponse);
rpc GetTokenAuthority(GetTokenAuthorityRequest) returns (GetTokenAuthorityResponse);
rpc VerifyTokenAuthority(VerifyTokenAuthorityRequest) returns (VerifyTokenAuthorityResponse);
}
message CredentialsRequest {

11
vendor/github.com/moby/buildkit/session/auth/authprovider/authconfig.go generated vendored Normal file
View File

@ -0,0 +1,11 @@
package authprovider
type AuthTLSConfig struct {
RootCAs []string
KeyPairs []TLSKeyPair
}
type TLSKeyPair struct {
Key string
Certificate string
}

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

@ -5,9 +5,11 @@ import (
"crypto/ed25519"
"crypto/hmac"
"crypto/sha256"
"crypto/tls"
"crypto/x509"
"fmt"
"net/http"
"os"
"runtime"
"strconv"
"strings"
"sync"
@ -18,6 +20,7 @@ import (
"github.com/docker/cli/cli/config"
"github.com/docker/cli/cli/config/configfile"
"github.com/docker/cli/cli/config/types"
http "github.com/hashicorp/go-cleanhttp"
"github.com/moby/buildkit/session"
"github.com/moby/buildkit/session/auth"
"github.com/moby/buildkit/util/progress/progresswriter"
@ -32,12 +35,13 @@ const defaultExpiration = 60
const dockerHubConfigfileKey = "https://index.docker.io/v1/"
const dockerHubRegistryHost = "registry-1.docker.io"
func NewDockerAuthProvider(cfg *configfile.ConfigFile) session.Attachable {
func NewDockerAuthProvider(cfg *configfile.ConfigFile, tlsConfigs map[string]*AuthTLSConfig) session.Attachable {
return &authProvider{
authConfigCache: map[string]*types.AuthConfig{},
config: cfg,
seeds: &tokenSeeds{dir: config.Dir()},
loggerCache: map[string]struct{}{},
tlsConfigs: tlsConfigs,
}
}
@ -47,6 +51,7 @@ type authProvider struct {
seeds *tokenSeeds
logger progresswriter.Logger
loggerCache map[string]struct{}
tlsConfigs map[string]*AuthTLSConfig
// The need for this mutex is not well understood.
// Without it, the docker cli on OS X hangs when
@ -89,6 +94,13 @@ func (ap *authProvider) FetchToken(ctx context.Context, req *auth.FetchTokenRequ
Secret: creds.Secret,
}
var httpClient = http.DefaultClient()
if tc, err := ap.tlsConfig(req.Host); err == nil && tc != nil {
transport := http.DefaultTransport()
transport.TLSClientConfig = tc
httpClient.Transport = transport
}
if creds.Secret != "" {
done := func(progresswriter.SubLogger) error {
return err
@ -103,7 +115,7 @@ func (ap *authProvider) FetchToken(ctx context.Context, req *auth.FetchTokenRequ
}
ap.mu.Unlock()
// credential information is provided, use oauth POST endpoint
resp, err := authutil.FetchTokenWithOAuth(ctx, http.DefaultClient, nil, "buildkit-client", to)
resp, err := authutil.FetchTokenWithOAuth(ctx, httpClient, nil, "buildkit-client", to)
if err != nil {
var errStatus remoteserrors.ErrUnexpectedStatus
if errors.As(err, &errStatus) {
@ -111,7 +123,7 @@ func (ap *authProvider) FetchToken(ctx context.Context, req *auth.FetchTokenRequ
// 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.FetchToken(ctx, http.DefaultClient, nil, to)
resp, err := authutil.FetchToken(ctx, httpClient, nil, to)
if err != nil {
return nil, err
}
@ -123,13 +135,52 @@ func (ap *authProvider) FetchToken(ctx context.Context, req *auth.FetchTokenRequ
return toTokenResponse(resp.AccessToken, resp.IssuedAt, resp.ExpiresIn), nil
}
// do request anonymously
resp, err := authutil.FetchToken(ctx, http.DefaultClient, nil, to)
resp, err := authutil.FetchToken(ctx, httpClient, nil, to)
if err != nil {
return nil, errors.Wrap(err, "failed to fetch anonymous token")
}
return toTokenResponse(resp.Token, resp.IssuedAt, resp.ExpiresIn), nil
}
func (ap *authProvider) tlsConfig(host string) (*tls.Config, error) {
if ap.tlsConfigs == nil {
return nil, nil
}
c, ok := ap.tlsConfigs[host]
if !ok {
return nil, nil
}
tc := &tls.Config{}
if len(c.RootCAs) > 0 {
systemPool, err := x509.SystemCertPool()
if err != nil {
if runtime.GOOS == "windows" {
systemPool = x509.NewCertPool()
} else {
return nil, errors.Wrapf(err, "unable to get system cert pool")
}
}
tc.RootCAs = systemPool
}
for _, p := range c.RootCAs {
dt, err := os.ReadFile(p)
if err != nil {
return nil, errors.Wrapf(err, "failed to read %s", p)
}
tc.RootCAs.AppendCertsFromPEM(dt)
}
for _, kp := range c.KeyPairs {
cert, err := tls.LoadX509KeyPair(kp.Certificate, kp.Key)
if err != nil {
return nil, errors.Wrapf(err, "failed to load keypair for %s", kp.Certificate)
}
tc.Certificates = append(tc.Certificates, cert)
}
return tc, nil
}
func (ap *authProvider) credentials(host string) (*auth.CredentialsResponse, error) {
ac, err := ap.getAuthConfig(host)
if err != nil {
@ -152,7 +203,7 @@ func (ap *authProvider) Credentials(ctx context.Context, req *auth.CredentialsRe
defer ap.mu.Unlock()
_, ok := ap.loggerCache[req.Host]
ap.loggerCache[req.Host] = struct{}{}
if !ok {
if !ok && ap.logger != nil {
return resp, progresswriter.Wrap(fmt.Sprintf("[auth] sharing credentials for %s", req.Host), ap.logger, func(progresswriter.SubLogger) error {
return err
})

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

@ -11,6 +11,7 @@ import (
"unicode"
"github.com/moby/buildkit/session"
"github.com/moby/buildkit/util/bklog"
"github.com/pkg/errors"
"github.com/tonistiigi/fsutil"
fstypes "github.com/tonistiigi/fsutil/types"
@ -277,7 +278,7 @@ func (sp *fsSyncTarget) DiffCopy(stream FileSend_DiffCopyServer) (err error) {
}
defer func() {
err1 := wc.Close()
if err != nil {
if err == nil {
err = err1
}
}()
@ -308,9 +309,16 @@ func CopyFileWriter(ctx context.Context, md map[string]string, c session.Caller)
client := NewFileSendClient(c.Conn())
opts := make(map[string][]string, len(md))
opts, ok := metadata.FromOutgoingContext(ctx)
if !ok {
opts = make(map[string][]string, len(md))
}
for k, v := range md {
opts[keyExporterMetaPrefix+k] = []string{v}
k := keyExporterMetaPrefix + k
if existingVal, ok := opts[k]; ok {
bklog.G(ctx).Warnf("overwriting grpc metadata key %q from value %+v to %+v", k, existingVal, v)
}
opts[k] = []string{v}
}
ctx = metadata.NewOutgoingContext(ctx, opts)
@ -351,13 +359,13 @@ func decodeOpts(opts map[string][]string) map[string][]string {
md := make(map[string][]string, len(opts))
for k, v := range opts {
out := make([]string, len(v))
var isDecoded bool
var isEncoded bool
if v, ok := opts[k+"-encoded"]; ok && len(v) > 0 {
if b, _ := strconv.ParseBool(v[0]); b {
isDecoded = true
isEncoded = true
}
}
if isDecoded {
if isEncoded {
for i, s := range v {
out[i], _ = url.QueryUnescape(s)
}
@ -373,13 +381,14 @@ func decodeOpts(opts map[string][]string) map[string][]string {
// is backwards compatible and avoids encoding ASCII characters.
func encodeStringForHeader(inputs []string) ([]string, bool) {
var encode bool
loop:
for _, input := range inputs {
for _, runeVal := range input {
// Only encode non-ASCII characters, and characters that have special
// meaning during decoding.
if runeVal > unicode.MaxASCII {
encode = true
break
break loop
}
}
}

7
vendor/github.com/moby/buildkit/session/filesync/filesync.proto generated vendored
View File

@ -7,15 +7,14 @@ option go_package = "filesync";
import "github.com/tonistiigi/fsutil/types/wire.proto";
service FileSync{
rpc DiffCopy(stream fsutil.types.Packet) returns (stream fsutil.types.Packet);
rpc TarStream(stream fsutil.types.Packet) returns (stream fsutil.types.Packet);
rpc DiffCopy(stream fsutil.types.Packet) returns (stream fsutil.types.Packet);
rpc TarStream(stream fsutil.types.Packet) returns (stream fsutil.types.Packet);
}
service FileSend{
rpc DiffCopy(stream BytesMessage) returns (stream BytesMessage);
rpc DiffCopy(stream BytesMessage) returns (stream BytesMessage);
}
// BytesMessage contains a chunk of byte data
message BytesMessage{
bytes data = 1;

2
vendor/github.com/moby/buildkit/session/secrets/secrets.proto generated vendored
View File

@ -5,7 +5,7 @@ package moby.buildkit.secrets.v1;
option go_package = "secrets";
service Secrets{
rpc GetSecret(GetSecretRequest) returns (GetSecretResponse);
rpc GetSecret(GetSecretRequest) returns (GetSecretResponse);
}

23
vendor/github.com/moby/buildkit/solver/errdefs/jobs.go generated vendored Normal file
View File

@ -0,0 +1,23 @@
package errdefs
import (
"fmt"
"google.golang.org/grpc/codes"
)
type UnknownJobError struct {
id string
}
func (e *UnknownJobError) Code() codes.Code {
return codes.NotFound
}
func (e *UnknownJobError) Error() string {
return fmt.Sprintf("no such job %s", e.id)
}
func NewUnknownJobError(id string) error {
return &UnknownJobError{id: id}
}

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

@ -393,14 +393,14 @@ message MergeOp {
}
message LowerDiffInput {
int64 input = 1 [(gogoproto.customtype) = "InputIndex", (gogoproto.nullable) = false];
int64 input = 1 [(gogoproto.customtype) = "InputIndex", (gogoproto.nullable) = false];
}
message UpperDiffInput {
int64 input = 1 [(gogoproto.customtype) = "InputIndex", (gogoproto.nullable) = false];
int64 input = 1 [(gogoproto.customtype) = "InputIndex", (gogoproto.nullable) = false];
}
message DiffOp {
LowerDiffInput lower = 1;
UpperDiffInput upper = 2;
LowerDiffInput lower = 1;
UpperDiffInput upper = 2;
}

19
vendor/github.com/moby/buildkit/util/bklog/log.go generated vendored
View File

@ -63,14 +63,13 @@ func GetLogger(ctx context.Context) (l *logrus.Entry) {
return l
}
// LazyStackTrace lets you include a stack trace as a field's value in a log but only
// call it when the log level is actually enabled.
type LazyStackTrace struct{}
func (LazyStackTrace) String() string {
return string(debug.Stack())
}
func (LazyStackTrace) MarshalText() ([]byte, error) {
return debug.Stack(), nil
// TraceLevelOnlyStack returns a stack trace for the current goroutine only if
// trace level logs are enabled; otherwise it returns an empty string. This ensure
// we only pay the cost of generating a stack trace when the log entry will actually
// be emitted.
func TraceLevelOnlyStack() string {
if logrus.GetLevel() == logrus.TraceLevel {
return string(debug.Stack())
}
return ""
}

24
vendor/github.com/moby/buildkit/util/contentutil/storewithprovider.go generated vendored Normal file
View File

@ -0,0 +1,24 @@
package contentutil
import (
"context"
"github.com/containerd/containerd/content"
ocispecs "github.com/opencontainers/image-spec/specs-go/v1"
)
func NewStoreWithProvider(cs content.Store, p content.Provider) content.Store {
return &storeWithProvider{Store: cs, p: p}
}
type storeWithProvider struct {
content.Store
p content.Provider
}
func (cs *storeWithProvider) ReaderAt(ctx context.Context, desc ocispecs.Descriptor) (content.ReaderAt, error) {
if ra, err := cs.p.ReaderAt(ctx, desc); err == nil {
return ra, nil
}
return cs.Store.ReaderAt(ctx, desc)
}

243
vendor/github.com/moby/buildkit/util/gitutil/git_cli.go generated vendored Normal file
View File

@ -0,0 +1,243 @@
package gitutil
import (
"bytes"
"context"
"io"
"os"
"os/exec"
"strings"
"github.com/pkg/errors"
)
// GitCLI carries config to pass to the git cli to make running multiple
// commands less repetitive.
type GitCLI struct {
git string
exec func(context.Context, *exec.Cmd) error
args []string
dir string
streams StreamFunc
workTree string
gitDir string
sshAuthSock string
sshKnownHosts string
}
// Option provides a variadic option for configuring the git client.
type Option func(b *GitCLI)
// WithGitBinary sets the git binary path.
func WithGitBinary(path string) Option {
return func(b *GitCLI) {
b.git = path
}
}
// WithExec sets the command exec function.
func WithExec(exec func(context.Context, *exec.Cmd) error) Option {
return func(b *GitCLI) {
b.exec = exec
}
}
// WithArgs sets extra args.
func WithArgs(args ...string) Option {
return func(b *GitCLI) {
b.args = append(b.args, args...)
}
}
// WithDir sets working directory.
//
// This should be a path to any directory within a standard git repository.
func WithDir(dir string) Option {
return func(b *GitCLI) {
b.dir = dir
}
}
// WithWorkTree sets the --work-tree arg.
//
// This should be the path to the top-level directory of the checkout. When
// setting this, you also likely need to set WithGitDir.
func WithWorkTree(workTree string) Option {
return func(b *GitCLI) {
b.workTree = workTree
}
}
// WithGitDir sets the --git-dir arg.
//
// This should be the path to the .git directory. When setting this, you may
// also need to set WithWorkTree, unless you are working with a bare
// repository.
func WithGitDir(gitDir string) Option {
return func(b *GitCLI) {
b.gitDir = gitDir
}
}
// WithSSHAuthSock sets the ssh auth sock.
func WithSSHAuthSock(sshAuthSock string) Option {
return func(b *GitCLI) {
b.sshAuthSock = sshAuthSock
}
}
// WithSSHKnownHosts sets the known hosts file.
func WithSSHKnownHosts(sshKnownHosts string) Option {
return func(b *GitCLI) {
b.sshKnownHosts = sshKnownHosts
}
}
type StreamFunc func(context.Context) (io.WriteCloser, io.WriteCloser, func())
// WithStreams configures a callback for getting the streams for a command. The
// stream callback will be called once for each command, and both writers will
// be closed after the command has finished.
func WithStreams(streams StreamFunc) Option {
return func(b *GitCLI) {
b.streams = streams
}
}
// New initializes a new git client
func NewGitCLI(opts ...Option) *GitCLI {
c := &GitCLI{}
for _, opt := range opts {
opt(c)
}
return c
}
// New returns a new git client with the same config as the current one, but
// with the given options applied on top.
func (cli *GitCLI) New(opts ...Option) *GitCLI {
c := &GitCLI{
git: cli.git,
dir: cli.dir,
workTree: cli.workTree,
gitDir: cli.gitDir,
args: append([]string{}, cli.args...),
streams: cli.streams,
sshAuthSock: cli.sshAuthSock,
sshKnownHosts: cli.sshKnownHosts,
}
for _, opt := range opts {
opt(c)
}
return c
}
// Run executes a git command with the given args.
func (cli *GitCLI) Run(ctx context.Context, args ...string) (_ []byte, err error) {
gitBinary := "git"
if cli.git != "" {
gitBinary = cli.git
}
for {
var cmd *exec.Cmd
if cli.exec == nil {
cmd = exec.CommandContext(ctx, gitBinary)
} else {
cmd = exec.Command(gitBinary)
}
cmd.Dir = cli.dir
if cmd.Dir == "" {
cmd.Dir = cli.workTree
}
// Block sneaky repositories from using repos from the filesystem as submodules.
cmd.Args = append(cmd.Args, "-c", "protocol.file.allow=user")
if cli.workTree != "" {
cmd.Args = append(cmd.Args, "--work-tree", cli.workTree)
}
if cli.gitDir != "" {
cmd.Args = append(cmd.Args, "--git-dir", cli.gitDir)
}
cmd.Args = append(cmd.Args, cli.args...)
cmd.Args = append(cmd.Args, args...)
buf := bytes.NewBuffer(nil)
errbuf := bytes.NewBuffer(nil)
cmd.Stdin = nil
cmd.Stdout = buf
cmd.Stderr = errbuf
if cli.streams != nil {
stdout, stderr, flush := cli.streams(ctx)
if stdout != nil {
cmd.Stdout = io.MultiWriter(stdout, cmd.Stdout)
}
if stderr != nil {
cmd.Stderr = io.MultiWriter(stderr, cmd.Stderr)
}
defer stdout.Close()
defer stderr.Close()
defer func() {
if err != nil {
flush()
}
}()
}
cmd.Env = []string{
"PATH=" + os.Getenv("PATH"),
"GIT_TERMINAL_PROMPT=0",
"GIT_SSH_COMMAND=" + getGitSSHCommand(cli.sshKnownHosts),
// "GIT_TRACE=1",
"GIT_CONFIG_NOSYSTEM=1", // Disable reading from system gitconfig.
"HOME=/dev/null", // Disable reading from user gitconfig.
"LC_ALL=C", // Ensure consistent output.
}
if cli.sshAuthSock != "" {
cmd.Env = append(cmd.Env, "SSH_AUTH_SOCK="+cli.sshAuthSock)
}
if cli.exec != nil {
// remote git commands spawn helper processes that inherit FDs and don't
// handle parent death signal so exec.CommandContext can't be used
err = cli.exec(ctx, cmd)
} else {
err = cmd.Run()
}
if err != nil {
if strings.Contains(errbuf.String(), "--depth") || strings.Contains(errbuf.String(), "shallow") {
if newArgs := argsNoDepth(args); len(args) > len(newArgs) {
args = newArgs
continue
}
}
return buf.Bytes(), errors.Errorf("git error: %s\nstderr:\n%s", err, errbuf.String())
}
return buf.Bytes(), nil
}
}
func getGitSSHCommand(knownHosts string) string {
gitSSHCommand := "ssh -F /dev/null"
if knownHosts != "" {
gitSSHCommand += " -o UserKnownHostsFile=" + knownHosts
} else {
gitSSHCommand += " -o StrictHostKeyChecking=no"
}
return gitSSHCommand
}
func argsNoDepth(args []string) []string {
out := make([]string, 0, len(args))
for _, a := range args {
if a != "--depth=1" {
out = append(out, a)
}
}
return out
}

44
vendor/github.com/moby/buildkit/util/gitutil/git_cli_helpers.go generated vendored Normal file
View File

@ -0,0 +1,44 @@
package gitutil
import (
"context"
"path/filepath"
"strings"
"github.com/pkg/errors"
)
func (cli *GitCLI) Dir() string {
if cli.dir != "" {
return cli.dir
}
return cli.workTree
}
func (cli *GitCLI) WorkTree(ctx context.Context) (string, error) {
if cli.workTree != "" {
return cli.workTree, nil
}
return cli.clean(cli.Run(ctx, "rev-parse", "--show-toplevel"))
}
func (cli *GitCLI) GitDir(ctx context.Context) (string, error) {
if cli.gitDir != "" {
return cli.gitDir, nil
}
dir, err := cli.WorkTree(ctx)
if err != nil {
return "", err
}
return filepath.Join(dir, ".git"), nil
}
func (cli *GitCLI) clean(dt []byte, err error) (string, error) {
out := string(dt)
out = strings.ReplaceAll(strings.Split(out, "\n")[0], "'", "")
if err != nil {
err = errors.New(strings.TrimSuffix(err.Error(), "\n"))
}
return out, err
}

46
vendor/github.com/moby/buildkit/util/gitutil/git_protocol.go generated vendored
View File

@ -1,46 +0,0 @@
package gitutil
import (
"strings"
"github.com/moby/buildkit/util/sshutil"
)
const (
HTTPProtocol = iota + 1
HTTPSProtocol
SSHProtocol
GitProtocol
UnknownProtocol
)
// ParseProtocol parses a git URL and returns the remote url and protocol type
func ParseProtocol(remote string) (string, int) {
prefixes := map[string]int{
"http://": HTTPProtocol,
"https://": HTTPSProtocol,
"git://": GitProtocol,
"ssh://": SSHProtocol,
}
protocolType := UnknownProtocol
for prefix, potentialType := range prefixes {
if strings.HasPrefix(remote, prefix) {
remote = strings.TrimPrefix(remote, prefix)
protocolType = potentialType
}
}
if protocolType == UnknownProtocol && sshutil.IsImplicitSSHTransport(remote) {
protocolType = SSHProtocol
}
// remove name from ssh
if protocolType == SSHProtocol {
parts := strings.SplitN(remote, "@", 2)
if len(parts) == 2 {
remote = parts[1]
}
}
return remote, protocolType
}

47
vendor/github.com/moby/buildkit/util/gitutil/git_ref.go generated vendored
View File

@ -1,10 +1,11 @@
package gitutil
import (
"regexp"
"net/url"
"strings"
"github.com/containerd/containerd/errdefs"
"github.com/pkg/errors"
)
// GitRef represents a git ref.
@ -51,35 +52,51 @@ type GitRef struct {
func ParseGitRef(ref string) (*GitRef, error) {
res := &GitRef{}
var (
remote *url.URL
err error
)
if strings.HasPrefix(ref, "github.com/") {
res.IndistinguishableFromLocal = true // Deprecated
} else {
_, proto := ParseProtocol(ref)
switch proto {
case UnknownProtocol:
return nil, errdefs.ErrInvalidArgument
remote = &url.URL{
Scheme: "https",
Host: "github.com",
Path: strings.TrimPrefix(ref, "github.com/"),
}
switch proto {
} else {
remote, err = ParseURL(ref)
if errors.Is(err, ErrUnknownProtocol) {
remote, err = ParseURL("https://" + ref)
}
if err != nil {
return nil, err
}
switch remote.Scheme {
case HTTPProtocol, GitProtocol:
res.UnencryptedTCP = true // Discouraged, but not deprecated
}
switch proto {
switch remote.Scheme {
// An HTTP(S) URL is considered to be a valid git ref only when it has the ".git[...]" suffix.
case HTTPProtocol, HTTPSProtocol:
var gitURLPathWithFragmentSuffix = regexp.MustCompile(`\.git(?:#.+)?$`)
if !gitURLPathWithFragmentSuffix.MatchString(ref) {
if !strings.HasSuffix(remote.Path, ".git") {
return nil, errdefs.ErrInvalidArgument
}
}
}
var fragment string
res.Remote, fragment, _ = strings.Cut(ref, "#")
if len(res.Remote) == 0 {
return res, errdefs.ErrInvalidArgument
res.Commit, res.SubDir = SplitGitFragment(remote.Fragment)
remote.Fragment = ""
res.Remote = remote.String()
if res.IndistinguishableFromLocal {
_, res.Remote, _ = strings.Cut(res.Remote, "://")
}
res.Commit, res.SubDir, _ = strings.Cut(fragment, ":")
repoSplitBySlash := strings.Split(res.Remote, "/")
res.ShortName = strings.TrimSuffix(repoSplitBySlash[len(repoSplitBySlash)-1], ".git")
return res, nil
}

71
vendor/github.com/moby/buildkit/util/gitutil/git_url.go generated vendored Normal file
View File

@ -0,0 +1,71 @@
package gitutil
import (
"net/url"
"regexp"
"strings"
"github.com/moby/buildkit/util/sshutil"
"github.com/pkg/errors"
)
const (
HTTPProtocol string = "http"
HTTPSProtocol string = "https"
SSHProtocol string = "ssh"
GitProtocol string = "git"
)
var (
ErrUnknownProtocol = errors.New("unknown protocol")
ErrInvalidProtocol = errors.New("invalid protocol")
)
var supportedProtos = map[string]struct{}{
HTTPProtocol: {},
HTTPSProtocol: {},
SSHProtocol: {},
GitProtocol: {},
}
var protoRegexp = regexp.MustCompile(`^[a-zA-Z0-9]+://`)
// ParseURL parses a git URL and returns a parsed URL object.
//
// ParseURL understands implicit ssh URLs such as "git@host:repo", and
// returns the same response as if the URL were "ssh://git@host/repo".
func ParseURL(remote string) (*url.URL, error) {
if proto := protoRegexp.FindString(remote); proto != "" {
proto = strings.ToLower(strings.TrimSuffix(proto, "://"))
if _, ok := supportedProtos[proto]; !ok {
return nil, errors.Wrap(ErrInvalidProtocol, proto)
}
return url.Parse(remote)
}
if sshutil.IsImplicitSSHTransport(remote) {
remote, fragment, _ := strings.Cut(remote, "#")
remote, path, _ := strings.Cut(remote, ":")
user, host, _ := strings.Cut(remote, "@")
if !strings.HasPrefix(path, "/") {
path = "/" + path
}
return &url.URL{
Scheme: SSHProtocol,
User: url.User(user),
Host: host,
Path: path,
Fragment: fragment,
}, nil
}
return nil, ErrUnknownProtocol
}
// SplitGitFragments splits a git URL fragment into its respective git
// reference and subdirectory components.
func SplitGitFragment(fragment string) (ref string, subdir string) {
ref, subdir, _ = strings.Cut(fragment, ":")
return ref, subdir
}

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

@ -65,7 +65,7 @@ func (ps *MultiWriter) Write(id string, v interface{}) error {
Sys: v,
meta: ps.meta,
}
return ps.WriteRawProgress(p)
return ps.writeRawProgress(p)
}
func (ps *MultiWriter) WriteRawProgress(p *Progress) error {

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

@ -4,6 +4,7 @@ import (
"bytes"
"container/ring"
"context"
"encoding/json"
"fmt"
"io"
"os"
@ -16,49 +17,67 @@ import (
"github.com/moby/buildkit/client"
"github.com/morikuni/aec"
digest "github.com/opencontainers/go-digest"
"github.com/pkg/errors"
"github.com/tonistiigi/units"
"github.com/tonistiigi/vt100"
"golang.org/x/time/rate"
)
type displaySolveStatusOpts struct {
type displayOpts struct {
phase string
textDesc string
consoleDesc string
}
type DisplaySolveStatusOpt func(b *displaySolveStatusOpts)
func newDisplayOpts(opts ...DisplayOpt) *displayOpts {
dsso := &displayOpts{}
for _, opt := range opts {
opt(dsso)
}
return dsso
}
func WithPhase(phase string) DisplaySolveStatusOpt {
return func(b *displaySolveStatusOpts) {
type DisplayOpt func(b *displayOpts)
func WithPhase(phase string) DisplayOpt {
return func(b *displayOpts) {
b.phase = phase
}
}
func WithDesc(text string, console string) DisplaySolveStatusOpt {
return func(b *displaySolveStatusOpts) {
func WithDesc(text string, console string) DisplayOpt {
return func(b *displayOpts) {
b.textDesc = text
b.consoleDesc = console
}
}
func DisplaySolveStatus(ctx context.Context, c console.Console, w io.Writer, ch chan *client.SolveStatus, opts ...DisplaySolveStatusOpt) ([]client.VertexWarning, error) {
modeConsole := c != nil
type Display struct {
disp display
}
dsso := &displaySolveStatusOpts{}
for _, opt := range opts {
opt(dsso)
}
type display interface {
// init initializes the display and opens any resources
// that are required.
init(displayLimiter *rate.Limiter)
disp := &display{c: c, phase: dsso.phase, desc: dsso.consoleDesc}
printer := &textMux{w: w, desc: dsso.textDesc}
// update sends the signal to update the display.
// Some displays will have buffered output and will not
// display changes for every status update.
update(ss *client.SolveStatus)
if disp.phase == "" {
disp.phase = "Building"
}
// refresh updates the display with the latest state.
// This method only does something with displays that
// have buffered output.
refresh()
t := newTrace(w, modeConsole)
// done is invoked when the display will be closed.
// This method should flush any buffers and close any open
// resources that were opened by init.
done()
}
func (d Display) UpdateFrom(ctx context.Context, ch chan *client.SolveStatus) ([]client.VertexWarning, error) {
tickerTimeout := 150 * time.Millisecond
displayTimeout := 100 * time.Millisecond
@ -69,55 +88,228 @@ func DisplaySolveStatus(ctx context.Context, c console.Console, w io.Writer, ch
}
}
var done bool
ticker := time.NewTicker(tickerTimeout)
// implemented as closure because "ticker" can change
defer func() {
ticker.Stop()
}()
displayLimiter := rate.NewLimiter(rate.Every(displayTimeout), 1)
d.disp.init(displayLimiter)
defer d.disp.done()
var height int
width, _ := disp.getSize()
ticker := time.NewTicker(tickerTimeout)
defer ticker.Stop()
var warnings []client.VertexWarning
for {
select {
case <-ctx.Done():
return nil, ctx.Err()
case <-ticker.C:
d.disp.refresh()
case ss, ok := <-ch:
if ok {
t.update(ss, width)
} else {
done = true
if !ok {
return warnings, nil
}
}
if modeConsole {
width, height = disp.getSize()
if done {
disp.print(t.displayInfo(), width, height, true)
t.printErrorLogs(c)
return t.warnings(), nil
} else if displayLimiter.Allow() {
ticker.Stop()
ticker = time.NewTicker(tickerTimeout)
disp.print(t.displayInfo(), width, height, false)
}
} else {
if done || displayLimiter.Allow() {
printer.print(t)
if done {
t.printErrorLogs(w)
return t.warnings(), nil
}
ticker.Stop()
ticker = time.NewTicker(tickerTimeout)
d.disp.update(ss)
for _, w := range ss.Warnings {
warnings = append(warnings, *w)
}
ticker.Reset(tickerTimeout)
}
}
}
type DisplayMode string
const (
// DefaultMode is the default value for the DisplayMode.
// This is effectively the same as AutoMode.
DefaultMode DisplayMode = ""
// AutoMode will choose TtyMode or PlainMode depending on if the output is
// a tty.
AutoMode DisplayMode = "auto"
// QuietMode discards all output.
QuietMode DisplayMode = "quiet"
// TtyMode enforces the output is a tty and will otherwise cause an error if it isn't.
TtyMode DisplayMode = "tty"
// PlainMode is the human-readable plain text output. This mode is not meant to be read
// by machines.
PlainMode DisplayMode = "plain"
// RawJSONMode is the raw JSON text output. It will marshal the various solve status events
// to JSON to be read by an external program.
RawJSONMode DisplayMode = "rawjson"
)
// NewDisplay constructs a Display that outputs to the given io.Writer with the given DisplayMode.
//
// This method will return an error when the DisplayMode is invalid or if TtyMode is used but the io.Writer
// does not refer to a tty. AutoMode will choose TtyMode or PlainMode depending on if the output is a tty or not.
//
// For TtyMode to work, the io.Writer should also implement console.File.
func NewDisplay(out io.Writer, mode DisplayMode, opts ...DisplayOpt) (Display, error) {
switch mode {
case AutoMode, TtyMode, DefaultMode:
if c, err := consoleFromWriter(out); err == nil {
return newConsoleDisplay(c, opts...), nil
} else if mode == "tty" {
return Display{}, errors.Wrap(err, "failed to get console")
}
fallthrough
case PlainMode:
return newPlainDisplay(out, opts...), nil
case RawJSONMode:
return newRawJSONDisplay(out, opts...), nil
case QuietMode:
return newDiscardDisplay(), nil
default:
return Display{}, errors.Errorf("invalid progress mode %s", mode)
}
}
// consoleFromWriter retrieves a console.Console from an io.Writer.
func consoleFromWriter(out io.Writer) (console.Console, error) {
f, ok := out.(console.File)
if !ok {
return nil, errors.New("output is not a file")
}
return console.ConsoleFromFile(f)
}
type discardDisplay struct{}
func newDiscardDisplay() Display {
return Display{disp: &discardDisplay{}}
}
func (d *discardDisplay) init(displayLimiter *rate.Limiter) {}
func (d *discardDisplay) update(ss *client.SolveStatus) {}
func (d *discardDisplay) refresh() {}
func (d *discardDisplay) done() {}
type consoleDisplay struct {
t *trace
disp *ttyDisplay
width, height int
displayLimiter *rate.Limiter
}
// newConsoleDisplay creates a new Display that prints a TTY
// friendly output.
func newConsoleDisplay(c console.Console, opts ...DisplayOpt) Display {
dsso := newDisplayOpts(opts...)
if dsso.phase == "" {
dsso.phase = "Building"
}
return Display{
disp: &consoleDisplay{
t: newTrace(c, true),
disp: &ttyDisplay{c: c, phase: dsso.phase, desc: dsso.consoleDesc},
},
}
}
func (d *consoleDisplay) init(displayLimiter *rate.Limiter) {
d.displayLimiter = displayLimiter
}
func (d *consoleDisplay) update(ss *client.SolveStatus) {
d.width, d.height = d.disp.getSize()
d.t.update(ss, d.width)
if !d.displayLimiter.Allow() {
// Exit early as we are not allowed to update the display.
return
}
d.refresh()
}
func (d *consoleDisplay) refresh() {
d.disp.print(d.t.displayInfo(), d.width, d.height, false)
}
func (d *consoleDisplay) done() {
d.width, d.height = d.disp.getSize()
d.disp.print(d.t.displayInfo(), d.width, d.height, true)
d.t.printErrorLogs(d.t.w)
}
type plainDisplay struct {
t *trace
printer *textMux
displayLimiter *rate.Limiter
}
// newPlainDisplay creates a new Display that outputs the status
// in a human-readable plain-text format.
func newPlainDisplay(w io.Writer, opts ...DisplayOpt) Display {
dsso := newDisplayOpts(opts...)
return Display{
disp: &plainDisplay{
t: newTrace(w, false),
printer: &textMux{
w: w,
desc: dsso.textDesc,
},
},
}
}
func (d *plainDisplay) init(displayLimiter *rate.Limiter) {
d.displayLimiter = displayLimiter
}
func (d *plainDisplay) update(ss *client.SolveStatus) {
if ss != nil {
d.t.update(ss, 80)
if !d.displayLimiter.Allow() {
// Exit early as we are not allowed to update the display.
return
}
}
d.refresh()
}
func (d *plainDisplay) refresh() {
d.printer.print(d.t)
}
func (d *plainDisplay) done() {
// Force the display to refresh.
d.refresh()
// Print error logs.
d.t.printErrorLogs(d.t.w)
}
type rawJSONDisplay struct {
enc *json.Encoder
w io.Writer
}
// newRawJSONDisplay creates a new Display that outputs an unbuffered
// output of status update events.
func newRawJSONDisplay(w io.Writer, opts ...DisplayOpt) Display {
enc := json.NewEncoder(w)
enc.SetIndent("", " ")
return Display{
disp: &rawJSONDisplay{
enc: enc,
w: w,
},
}
}
func (d *rawJSONDisplay) init(displayLimiter *rate.Limiter) {
// Initialization parameters are ignored for this display.
}
func (d *rawJSONDisplay) update(ss *client.SolveStatus) {
_ = d.enc.Encode(ss)
}
func (d *rawJSONDisplay) refresh() {
// Unbuffered display doesn't have anything to refresh.
}
func (d *rawJSONDisplay) done() {
// No actions needed.
}
const termHeight = 6
const termPad = 10
@ -386,14 +578,6 @@ func newTrace(w io.Writer, modeConsole bool) *trace {
}
}
func (t *trace) warnings() []client.VertexWarning {
var out []client.VertexWarning
for _, v := range t.vertexes {
out = append(out, v.warnings...)
}
return out
}
func (t *trace) triggerVertexEvent(v *client.Vertex) {
if v.Started == nil {
return
@ -734,7 +918,7 @@ func addTime(tm *time.Time, d time.Duration) *time.Time {
return &t
}
type display struct {
type ttyDisplay struct {
c console.Console
phase string
desc string
@ -742,7 +926,7 @@ type display struct {
repeated bool
}
func (disp *display) getSize() (int, int) {
func (disp *ttyDisplay) getSize() (int, int) {
width := 80
height := 10
if disp.c != nil {
@ -789,7 +973,7 @@ func setupTerminals(jobs []*job, height int, all bool) []*job {
return jobs
}
func (disp *display) print(d displayInfo, width, height int, all bool) {
func (disp *ttyDisplay) print(d displayInfo, width, height int, all bool) {
// this output is inspired by Buck
d.jobs = setupTerminals(d.jobs, height, all)
b := aec.EmptyBuilder

19
vendor/github.com/moby/buildkit/util/progress/progresswriter/printer.go generated vendored
View File

@ -7,7 +7,6 @@ import (
"github.com/containerd/console"
"github.com/moby/buildkit/client"
"github.com/moby/buildkit/util/progress/progressui"
"github.com/pkg/errors"
)
type printer struct {
@ -70,24 +69,14 @@ func NewPrinter(ctx context.Context, out console.File, mode string) (Writer, err
mode = v
}
var c console.Console
switch mode {
case "auto", "tty", "":
if cons, err := console.ConsoleFromFile(out); err == nil {
c = cons
} else {
if mode == "tty" {
return nil, errors.Wrap(err, "failed to get console")
}
}
case "plain":
default:
return nil, errors.Errorf("invalid progress mode %s", mode)
d, err := progressui.NewDisplay(out, progressui.DisplayMode(mode))
if err != nil {
return nil, err
}
go func() {
// not using shared context to not disrupt display but let is finish reporting errors
_, pw.err = progressui.DisplaySolveStatus(ctx, c, out, statusCh)
_, pw.err = d.UpdateFrom(ctx, statusCh)
close(doneCh)
}()
return pw, nil

2
vendor/github.com/moby/buildkit/util/resolver/limited/group.go generated vendored
View File

@ -10,7 +10,7 @@ import (
"github.com/containerd/containerd/content"
"github.com/containerd/containerd/images"
"github.com/containerd/containerd/remotes"
"github.com/docker/distribution/reference"
"github.com/distribution/reference"
"github.com/moby/buildkit/util/bklog"
ocispecs "github.com/opencontainers/image-spec/specs-go/v1"
"golang.org/x/sync/semaphore"

16
vendor/github.com/moby/buildkit/util/stack/stack.proto generated vendored
View File

@ -3,15 +3,15 @@ syntax = "proto3";
package stack;
message Stack {
repeated Frame frames = 1;
repeated string cmdline = 2;
int32 pid = 3;
string version = 4;
string revision = 5;
repeated Frame frames = 1;
repeated string cmdline = 2;
int32 pid = 3;
string version = 4;
string revision = 5;
}
message Frame {
string Name = 1;
string File = 2;
int32 Line = 3;
string Name = 1;
string File = 2;
int32 Line = 3;
}

8
vendor/github.com/moby/buildkit/util/testutil/integration/run.go generated vendored
View File

@ -57,8 +57,8 @@ type Sandbox interface {
// BackendConfig is used to configure backends created by a worker.
type BackendConfig struct {
Logs map[string]*bytes.Buffer
ConfigFile string
Logs map[string]*bytes.Buffer
DaemonConfig []ConfigUpdater
}
type Worker interface {
@ -303,7 +303,7 @@ mirrors=["%s"]
`, in, mc)
}
func writeConfig(updaters []ConfigUpdater) (string, error) {
func WriteConfig(updaters []ConfigUpdater) (string, error) {
tmpdir, err := os.MkdirTemp("", "bktest_config")
if err != nil {
return "", err
@ -320,7 +320,7 @@ func writeConfig(updaters []ConfigUpdater) (string, error) {
if err := os.WriteFile(filepath.Join(tmpdir, buildkitdConfigFile), []byte(s), 0644); err != nil {
return "", err
}
return tmpdir, nil
return filepath.Join(tmpdir, buildkitdConfigFile), nil
}
func runMirror(t *testing.T, mirroredImages map[string]string) (host string, _ func() error, err error) {

30
vendor/github.com/moby/buildkit/util/testutil/integration/sandbox.go generated vendored
View File

@ -7,12 +7,12 @@ import (
"fmt"
"os"
"os/exec"
"path/filepath"
"strings"
"testing"
"github.com/google/shlex"
"github.com/moby/buildkit/util/bklog"
"github.com/pkg/errors"
)
const buildkitdConfigFile = "buildkitd.toml"
@ -77,15 +77,14 @@ func newSandbox(ctx context.Context, w Worker, mirror string, mv matrixValue) (s
Logs: make(map[string]*bytes.Buffer),
}
var upt []ConfigUpdater
for _, v := range mv.values {
if u, ok := v.value.(ConfigUpdater); ok {
upt = append(upt, u)
cfg.DaemonConfig = append(cfg.DaemonConfig, u)
}
}
if mirror != "" {
upt = append(upt, withMirrorConfig(mirror))
cfg.DaemonConfig = append(cfg.DaemonConfig, withMirrorConfig(mirror))
}
deferF := &MultiCloser{}
@ -98,17 +97,6 @@ func newSandbox(ctx context.Context, w Worker, mirror string, mv matrixValue) (s
}
}()
if len(upt) > 0 {
dir, err := writeConfig(upt)
if err != nil {
return nil, nil, err
}
deferF.Append(func() error {
return os.RemoveAll(dir)
})
cfg.ConfigFile = filepath.Join(dir, buildkitdConfigFile)
}
b, closer, err := w.New(ctx, cfg)
if err != nil {
return nil, nil, err
@ -126,7 +114,7 @@ func newSandbox(ctx context.Context, w Worker, mirror string, mv matrixValue) (s
}
func RootlessSupported(uid int) bool {
cmd := exec.Command("sudo", "-E", "-u", fmt.Sprintf("#%d", uid), "-i", "--", "exec", "unshare", "-U", "true") //nolint:gosec // test utility
cmd := exec.Command("sudo", "-u", fmt.Sprintf("#%d", uid), "-i", "--", "exec", "unshare", "-U", "true") //nolint:gosec // test utility
b, err := cmd.CombinedOutput()
if err != nil {
bklog.L.Warnf("rootless mode is not supported on this host: %v (%s)", err, string(b))
@ -156,6 +144,13 @@ func FormatLogs(m map[string]*bytes.Buffer) string {
}
func CheckFeatureCompat(t *testing.T, sb Sandbox, features map[string]struct{}, reason ...string) {
t.Helper()
if err := HasFeatureCompat(t, sb, features, reason...); err != nil {
t.Skipf(err.Error())
}
}
func HasFeatureCompat(t *testing.T, sb Sandbox, features map[string]struct{}, reason ...string) error {
t.Helper()
if len(reason) == 0 {
t.Fatal("no reason provided")
@ -172,6 +167,7 @@ func CheckFeatureCompat(t *testing.T, sb Sandbox, features map[string]struct{},
}
}
if len(ereasons) > 0 {
t.Skipf("%s worker can not currently run this test due to missing features (%s)", sb.Name(), strings.Join(ereasons, ", "))
return errors.Errorf("%s worker can not currently run this test due to missing features (%s)", sb.Name(), strings.Join(ereasons, ", "))
}
return nil
}

4
vendor/github.com/moby/buildkit/util/testutil/workers/containerd.go generated vendored
View File

@ -168,7 +168,7 @@ disabled_plugins = ["cri"]
containerdArgs := []string{c.Containerd, "--config", configFile}
rootlessKitState := filepath.Join(tmpdir, "rootlesskit-containerd")
if rootless {
containerdArgs = append(append([]string{"sudo", "-E", "-u", fmt.Sprintf("#%d", c.UID), "-i",
containerdArgs = append(append([]string{"sudo", "-u", fmt.Sprintf("#%d", c.UID), "-i",
fmt.Sprintf("CONTAINERD_ROOTLESS_ROOTLESSKIT_STATE_DIR=%s", rootlessKitState),
// Integration test requires the access to localhost of the host network namespace.
// TODO: remove these configurations
@ -211,7 +211,7 @@ disabled_plugins = ["cri"]
if err != nil {
return nil, nil, err
}
buildkitdArgs = append([]string{"sudo", "-E", "-u", fmt.Sprintf("#%d", c.UID), "-i", "--", "exec",
buildkitdArgs = append([]string{"sudo", "-u", fmt.Sprintf("#%d", c.UID), "-i", "--", "exec",
"nsenter", "-U", "--preserve-credentials", "-m", "-t", fmt.Sprintf("%d", pid)},
append(buildkitdArgs, "--containerd-worker-snapshotter=native")...)
}

32
vendor/github.com/moby/buildkit/util/testutil/workers/dockerd.go generated vendored
View File

@ -76,9 +76,27 @@ func (c Moby) New(ctx context.Context, cfg *integration.BackendConfig) (b integr
return nil, nil, err
}
bkcfg, err := config.LoadFile(cfg.ConfigFile)
deferF := &integration.MultiCloser{}
cl = deferF.F()
defer func() {
if err != nil {
deferF.F()()
cl = nil
}
}()
cfgFile, err := integration.WriteConfig(cfg.DaemonConfig)
if err != nil {
return nil, nil, errors.Wrapf(err, "failed to load buildkit config file %s", cfg.ConfigFile)
return nil, nil, err
}
deferF.Append(func() error {
return os.RemoveAll(filepath.Dir(cfgFile))
})
bkcfg, err := config.LoadFile(cfgFile)
if err != nil {
return nil, nil, errors.Wrapf(err, "failed to load buildkit config file %s", cfgFile)
}
dcfg := dockerd.Config{
@ -107,16 +125,6 @@ func (c Moby) New(ctx context.Context, cfg *integration.BackendConfig) (b integr
return nil, nil, errors.Wrapf(err, "failed to marshal dockerd config")
}
deferF := &integration.MultiCloser{}
cl = deferF.F()
defer func() {
if err != nil {
deferF.F()()
cl = nil
}
}()
var proxyGroup errgroup.Group
deferF.Append(proxyGroup.Wait)

4
vendor/github.com/moby/buildkit/util/testutil/workers/features.go generated vendored
View File

@ -61,3 +61,7 @@ var features = map[string]struct{}{
func CheckFeatureCompat(t *testing.T, sb integration.Sandbox, reason ...string) {
integration.CheckFeatureCompat(t, sb, features, reason...)
}
func HasFeatureCompat(t *testing.T, sb integration.Sandbox, reason ...string) error {
return integration.HasFeatureCompat(t, sb, features, reason...)
}

2
vendor/github.com/moby/buildkit/util/testutil/workers/oci.go generated vendored
View File

@ -66,7 +66,7 @@ func (s *OCI) New(ctx context.Context, cfg *integration.BackendConfig) (integrat
return nil, nil, errors.Errorf("unsupported id pair: uid=%d, gid=%d", s.UID, s.GID)
}
// TODO: make sure the user exists and subuid/subgid are configured.
buildkitdArgs = append([]string{"sudo", "-E", "-u", fmt.Sprintf("#%d", s.UID), "-i", "--", "exec", "rootlesskit"}, buildkitdArgs...)
buildkitdArgs = append([]string{"sudo", "-u", fmt.Sprintf("#%d", s.UID), "-i", "--", "exec", "rootlesskit"}, buildkitdArgs...)
}
var extraEnv []string

31
vendor/github.com/moby/buildkit/util/testutil/workers/util.go generated vendored
View File

@ -4,6 +4,7 @@ import (
"bufio"
"bytes"
"context"
"fmt"
"os"
"os/exec"
"path/filepath"
@ -32,10 +33,6 @@ func runBuildkitd(ctx context.Context, conf *integration.BackendConfig, args []s
}
}()
if conf.ConfigFile != "" {
args = append(args, "--config="+conf.ConfigFile)
}
tmpdir, err := os.MkdirTemp("", "bktest_buildkitd")
if err != nil {
return "", nil, err
@ -49,14 +46,22 @@ func runBuildkitd(ctx context.Context, conf *integration.BackendConfig, args []s
if err := os.Chown(filepath.Join(tmpdir, "tmp"), uid, gid); err != nil {
return "", nil, err
}
deferF.Append(func() error { return os.RemoveAll(tmpdir) })
cfgfile, err := integration.WriteConfig(append(conf.DaemonConfig, withOTELSocketPath(getTraceSocketPath(tmpdir))))
if err != nil {
return "", nil, err
}
deferF.Append(func() error {
return os.RemoveAll(filepath.Dir(cfgfile))
})
args = append(args, "--config="+cfgfile)
address = getBuildkitdAddr(tmpdir)
args = append(args, "--root", tmpdir, "--addr", address, "--debug")
cmd := exec.Command(args[0], args[1:]...) //nolint:gosec // test utility
cmd.Env = append(os.Environ(), "BUILDKIT_DEBUG_EXEC_OUTPUT=1", "BUILDKIT_DEBUG_PANIC_ON_ERROR=1", "BUILDKIT_TRACE_SOCKET="+getTraceSocketPath(tmpdir), "TMPDIR="+filepath.Join(tmpdir, "tmp"))
cmd.Env = append(os.Environ(), "BUILDKIT_DEBUG_EXEC_OUTPUT=1", "BUILDKIT_DEBUG_PANIC_ON_ERROR=1", "TMPDIR="+filepath.Join(tmpdir, "tmp"))
cmd.Env = append(cmd.Env, extraEnv...)
cmd.SysProcAttr = getSysProcAttr()
@ -87,3 +92,17 @@ func runBuildkitd(ctx context.Context, conf *integration.BackendConfig, args []s
return address, cl, err
}
func withOTELSocketPath(socketPath string) integration.ConfigUpdater {
return otelSocketPath(socketPath)
}
type otelSocketPath string
func (osp otelSocketPath) UpdateConfigFile(in string) string {
return fmt.Sprintf(`%s
[otel]
socketPath = %q
`, in, osp)
}