github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-07-30 23:15:14 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #30121 from feiskyer/kuberuntime-getpods

Browse Source 
Automatic merge from submit-queue

Kubelet: implement GetPods for new runtime API

Implement GetPods for kuberuntime. Part of #28789 .

CC @yujuhong @Random-Liu
This commit is contained in:
Kubernetes Submit Queue 2016-08-22 10:24:23 -07:00 committed by GitHub
commit 969ce77757
9 changed files with 537 additions and 185 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

357
pkg/kubelet/api/v1alpha1/runtime/api.pb.go
View File

@ -1659,7 +1659,10 @@ type Container struct {
// State is the state of the container.
State *ContainerState `protobuf:"varint,5,opt,name=state,enum=runtime.ContainerState" json:"state,omitempty"`
// Labels are key value pairs that may be used to scope and select individual resources.
Labels map[string]string `protobuf:"bytes,6,rep,name=labels" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
Labels map[string]string `protobuf:"bytes,6,rep,name=labels" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
// Annotations is an unstructured key value map that may be set by external
// tools to store and retrieve arbitrary metadata.
Annotations map[string]string `protobuf:"bytes,7,rep,name=annotations" json:"annotations,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
XXX_unrecognized []byte `json:"-"`
}
@ -1710,6 +1713,13 @@ func (m *Container) GetLabels() map[string]string {
return nil
}
func (m *Container) GetAnnotations() map[string]string {
if m != nil {
return m.Annotations
}
return nil
}
type ListContainersResponse struct {
// List of containers
Containers []*Container `protobuf:"bytes,1,rep,name=containers" json:"containers,omitempty"`
@ -3012,176 +3022,177 @@ var _ImageService_serviceDesc = grpc.ServiceDesc{
}
var fileDescriptorApi = []byte{
// 2735 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xcc, 0x19, 0x4d, 0x73, 0x1b, 0x49,
0x35, 0xb2, 0x2c, 0x5b, 0x7a, 0xb2, 0x64, 0xb9, 0xe3, 0xd8, 0x8a, 0xb2, 0x49, 0x9c, 0x61, 0x17,
0x12, 0xef, 0xae, 0x2b, 0x18, 0x8a, 0x25, 0xd9, 0xdd, 0x6c, 0xbc, 0xb6, 0x49, 0x79, 0xe3, 0x38,
0x66, 0x94, 0x84, 0xcd, 0x49, 0x35, 0xd1, 0xb4, 0xed, 0x49, 0xa4, 0x99, 0xd9, 0x99, 0x91, 0x89,
0xb8, 0xf2, 0x1b, 0xa8, 0xe2, 0xc8, 0x81, 0x2a, 0x4e, 0x5c, 0xa8, 0xe2, 0x4f, 0x40, 0x71, 0xe2,
0x77, 0x70, 0xe2, 0xc2, 0x85, 0x82, 0xd7, 0x1f, 0xd3, 0xd3, 0xf3, 0x21, 0x47, 0xce, 0x52, 0x64,
0x6f, 0xdd, 0xef, 0xbd, 0x7e, 0xfd, 0xfa, 0xbd, 0xd7, 0xef, 0xa3, 0x1b, 0x6a, 0x96, 0xef, 0x6c,
0xf8, 0x81, 0x17, 0x79, 0x64, 0x3e, 0x18, 0xb9, 0x91, 0x33, 0xa4, 0xc6, 0x3a, 0x34, 0x9f, 0xd1,
0x20, 0x74, 0x3c, 0xd7, 0xa4, 0xdf, 0x8c, 0x68, 0x18, 0x91, 0x36, 0xcc, 0x9f, 0x0a, 0x48, 0xbb,
0xb4, 0x56, 0xba, 0x59, 0x33, 0xe3, 0xa9, 0xf1, 0x87, 0x12, 0x2c, 0x2a, 0xe2, 0xd0, 0xf7, 0xdc,
0x90, 0x4e, 0xa6, 0x26, 0x37, 0x60, 0x41, 0x6e, 0xd2, 0x73, 0xad, 0x21, 0x6d, 0xcf, 0x70, 0x74,
0x5d, 0xc2, 0x0e, 0x10, 0x44, 0x7e, 0x00, 0x8b, 0x31, 0x49, 0xcc, 0xa4, 0xcc, 0xa9, 0x9a, 0x12,
0x2c, 0x77, 0x23, 0x1b, 0x70, 0x31, 0x26, 0xc4, 0x33, 0x28, 0xe2, 0x59, 0x4e, 0xbc, 0x24, 0x51,
0x5b, 0xbe, 0x23, 0xe9, 0x8d, 0x2d, 0xa8, 0xed, 0x1c, 0x74, 0x1f, 0xfb, 0x11, 0x5b, 0x8c, 0x22,
0x86, 0x34, 0x60, 0x6b, 0x50, 0xc4, 0x32, 0x13, 0x51, 0x4e, 0x49, 0x07, 0xaa, 0x21, 0xb5, 0x82,
0xfe, 0x09, 0x0d, 0x51, 0x3c, 0x86, 0x52, 0x73, 0xe3, 0x8f, 0x25, 0xa8, 0x1f, 0x7a, 0x41, 0xf4,
0xc8, 0xf2, 0x7d, 0xc7, 0x3d, 0x26, 0x04, 0x66, 0xf9, 0x31, 0xc4, 0x29, 0xf9, 0x98, 0x7c, 0x0c,
0x55, 0xae, 0xce, 0xbe, 0x37, 0xe0, 0xc7, 0x6b, 0x6e, 0x2e, 0x6d, 0x48, 0x61, 0x36, 0x0e, 0x25,
0xc2, 0x54, 0x24, 0xe4, 0x03, 0x68, 0xf6, 0x3d, 0x37, 0xb2, 0x1c, 0x97, 0x06, 0x3d, 0x1f, 0x79,
0xf3, 0xd3, 0x56, 0xcc, 0x86, 0x82, 0xb2, 0x0d, 0xc9, 0x15, 0xa8, 0x9d, 0x78, 0x61, 0x24, 0x28,
0x66, 0x39, 0x45, 0x95, 0x01, 0x38, 0x72, 0x15, 0xe6, 0x39, 0xd2, 0xf1, 0xdb, 0x15, 0x2e, 0xc9,
0x1c, 0x9b, 0xee, 0xf9, 0xc6, 0xef, 0x4b, 0x50, 0x79, 0xe4, 0xe1, 0xe6, 0x85, 0x92, 0xa6, 0xb7,
0xb6, 0xa2, 0x13, 0x69, 0x0e, 0x6d, 0x6b, 0x04, 0x26, 0x5b, 0x33, 0x0a, 0x61, 0x0a, 0xb1, 0x35,
0x43, 0xa2, 0xb6, 0x02, 0x6a, 0xd9, 0x9e, 0x3b, 0x18, 0x73, 0xb1, 0xaa, 0xa6, 0x9a, 0x33, 0x4b,
0x86, 0x74, 0xe0, 0xb8, 0xa3, 0xd7, 0xbd, 0x80, 0x0e, 0xac, 0x17, 0x74, 0xc0, 0xc5, 0xab, 0x9a,
0x4d, 0x09, 0x36, 0x05, 0xd4, 0x78, 0x09, 0x8b, 0xcc, 0xf4, 0xa1, 0x6f, 0xf5, 0xa9, 0xb4, 0x0f,
0x3a, 0x0a, 0xdf, 0xd4, 0xa5, 0xd1, 0x2f, 0xbd, 0xe0, 0x15, 0x97, 0xbb, 0x6a, 0xd6, 0x19, 0xec,
0x40, 0x80, 0xc8, 0x65, 0xa8, 0x0a, 0xb9, 0x1c, 0x9b, 0x0b, 0x5e, 0x35, 0xb9, 0x16, 0x0e, 0x1d,
0x5b, 0xa1, 0x1c, 0xbf, 0xcf, 0x25, 0x96, 0xa8, 0x3d, 0xbf, 0x6f, 0xfc, 0xba, 0x04, 0x97, 0xf6,
0xd9, 0xe6, 0x87, 0x9e, 0xdd, 0xb5, 0x5c, 0xfb, 0x85, 0xf7, 0x7a, 0xdb, 0x73, 0x8f, 0x9c, 0x63,
0xf2, 0x3d, 0x68, 0xf4, 0x8f, 0x03, 0x6f, 0xe4, 0xe3, 0x49, 0x03, 0xea, 0x46, 0x52, 0x57, 0x0b,
0x02, 0x78, 0xc8, 0x61, 0x64, 0x17, 0x96, 0xdc, 0x58, 0xd4, 0x9e, 0xc7, 0x65, 0x0d, 0xf9, 0xee,
0xf5, 0xcd, 0xb6, 0x32, 0x73, 0xe6, 0x30, 0x66, 0xcb, 0x4d, 0x03, 0x42, 0xe3, 0x37, 0xb3, 0xd0,
0xca, 0x09, 0x50, 0x64, 0xa3, 0x8e, 0x38, 0x89, 0x76, 0x59, 0xd4, 0x9c, 0x09, 0x3c, 0xf0, 0x8e,
0x7b, 0xb6, 0x13, 0xd0, 0x7e, 0xe4, 0x05, 0x63, 0x69, 0x9c, 0x05, 0x04, 0xee, 0xc4, 0x30, 0xf2,
0x23, 0xa8, 0xdb, 0x6e, 0xa8, 0x44, 0x9d, 0xe5, 0xa2, 0x12, 0x25, 0xaa, 0xba, 0x11, 0x26, 0x20,
0x99, 0x14, 0x8f, 0xdc, 0x81, 0x06, 0x73, 0xb4, 0xde, 0x50, 0xf8, 0x79, 0x88, 0x76, 0x2b, 0xe3,
0xb2, 0xe5, 0xc4, 0x91, 0x93, 0x4b, 0x60, 0x2e, 0xf8, 0xc9, 0x24, 0x24, 0x9f, 0xc3, 0x1c, 0x37,
0x6a, 0xd8, 0x9e, 0xe3, 0x6b, 0x3e, 0xd0, 0xd6, 0xa4, 0xcf, 0xbb, 0xb1, 0xcf, 0xe9, 0x76, 0xdd,
0x28, 0x18, 0x9b, 0x72, 0x11, 0xd9, 0x87, 0xba, 0xe5, 0xba, 0x5e, 0x64, 0x09, 0x71, 0xe7, 0x39,
0x8f, 0xf5, 0xc9, 0x3c, 0xb6, 0x12, 0x62, 0xc1, 0x48, 0x5f, 0x4e, 0x7e, 0x0c, 0x15, 0xee, 0x68,
0xed, 0x2a, 0x3f, 0xf6, 0x35, 0xc5, 0xa7, 0xd0, 0x03, 0x4c, 0x41, 0xdc, 0xb9, 0x03, 0x75, 0x4d,
0x34, 0xd2, 0x82, 0xf2, 0x2b, 0x3a, 0x96, 0x56, 0x61, 0x43, 0xb2, 0x0c, 0x95, 0x53, 0x6b, 0x30,
0x8a, 0x2d, 0x22, 0x26, 0x77, 0x67, 0x7e, 0x5a, 0xea, 0xdc, 0x83, 0x56, 0x56, 0xa2, 0xf3, 0xac,
0x37, 0xf6, 0x61, 0x75, 0x1b, 0xef, 0x4f, 0x44, 0x13, 0xd9, 0xe2, 0x10, 0xfc, 0x43, 0x98, 0xeb,
0x73, 0x31, 0x39, 0xa7, 0xfa, 0xe6, 0xe5, 0x89, 0x4a, 0x31, 0x25, 0xa1, 0x71, 0x1f, 0xda, 0x79,
0x6e, 0x32, 0x46, 0xbf, 0x0f, 0x4d, 0xdf, 0xb3, 0x7b, 0xa1, 0x00, 0xf7, 0xf0, 0x0e, 0x49, 0x77,
0xf7, 0x15, 0xed, 0x9e, 0x6d, 0x7c, 0x0e, 0x97, 0xba, 0x91, 0xe7, 0xe7, 0xa5, 0x99, 0x6e, 0x79,
0x1b, 0x56, 0xb2, 0xcb, 0xc5, 0xf6, 0xc6, 0x17, 0xb0, 0x6a, 0xd2, 0xa1, 0x77, 0x4a, 0xdf, 0x96,
0x75, 0x07, 0xda, 0x79, 0x06, 0x09, 0xf3, 0x04, 0xda, 0x45, 0x63, 0x8c, 0xc2, 0xf3, 0x31, 0xbf,
0xa5, 0x33, 0x90, 0xf1, 0x46, 0xf0, 0x21, 0x4d, 0x98, 0xc1, 0x30, 0x2b, 0x16, 0xe1, 0xc8, 0x78,
0x0e, 0x35, 0x75, 0xdd, 0x59, 0x56, 0xd1, 0x03, 0x16, 0x66, 0x15, 0x39, 0x25, 0x9b, 0x30, 0x3f,
0x6d, 0xb4, 0x88, 0x09, 0x8d, 0x87, 0xb9, 0x48, 0x25, 0x65, 0xd8, 0x04, 0x50, 0x11, 0x25, 0x94,
0xee, 0x40, 0xf2, 0xfc, 0x4c, 0x8d, 0xca, 0xf8, 0x4f, 0x59, 0x8f, 0x38, 0xda, 0x61, 0x6c, 0x75,
0x18, 0x5b, 0x45, 0xa0, 0x19, 0x2d, 0x02, 0x6d, 0x40, 0x25, 0x44, 0x6a, 0xca, 0xa3, 0x4b, 0x53,
0x93, 0x5b, 0x72, 0xfb, 0x52, 0x70, 0xa3, 0xa6, 0x20, 0x23, 0x57, 0x01, 0xfa, 0xdc, 0xe9, 0xec,
0x9e, 0x25, 0x52, 0x55, 0xd9, 0xac, 0x49, 0xc8, 0x56, 0x44, 0xee, 0x26, 0x2a, 0xaa, 0x70, 0xc1,
0xd7, 0x0a, 0xfc, 0x38, 0xa5, 0xf2, 0x44, 0x89, 0xea, 0x3a, 0xcf, 0x9d, 0x7d, 0x9d, 0xe5, 0x3a,
0x41, 0xac, 0x45, 0xa4, 0xf9, 0x89, 0x11, 0x49, 0xac, 0x98, 0x26, 0x22, 0x55, 0x27, 0x46, 0x24,
0xc9, 0xe3, 0xcc, 0x88, 0xf4, 0x2e, 0x63, 0xcb, 0x23, 0x68, 0xe7, 0x6f, 0x85, 0x8c, 0x06, 0x18,
0x5c, 0x42, 0x0e, 0x39, 0x23, 0xb8, 0xc8, 0x25, 0x92, 0xd0, 0xf8, 0x77, 0x49, 0x77, 0xa8, 0x9f,
0x39, 0x83, 0x88, 0x06, 0x85, 0x29, 0x4c, 0x38, 0xd9, 0x8c, 0x72, 0xb2, 0xf3, 0x3a, 0x54, 0x17,
0x9a, 0xdc, 0x14, 0x3d, 0xac, 0x1a, 0x78, 0x52, 0x43, 0xa7, 0x62, 0x36, 0xf8, 0xa8, 0x40, 0x46,
0x21, 0x86, 0xb0, 0x63, 0x57, 0x92, 0x0b, 0x2b, 0x34, 0x06, 0x3a, 0xac, 0x73, 0x1f, 0x48, 0x9e,
0xe8, 0x5c, 0xea, 0xfc, 0x8a, 0xdd, 0x4e, 0x56, 0x80, 0x15, 0x04, 0xea, 0x23, 0x2e, 0xc6, 0x19,
0xba, 0x14, 0x72, 0x9a, 0x92, 0xd0, 0xf8, 0x67, 0x09, 0x20, 0x41, 0xbe, 0x8b, 0x6b, 0xf9, 0x89,
0xba, 0x24, 0x22, 0xd5, 0x5f, 0x2f, 0x10, 0xba, 0xe8, 0x7a, 0x7c, 0x0b, 0x87, 0x36, 0xb6, 0x61,
0x25, 0xab, 0x41, 0xe9, 0x8e, 0xb7, 0xa0, 0xe2, 0x44, 0x74, 0x28, 0x6a, 0xf3, 0xfa, 0xe6, 0xc5,
0x02, 0x61, 0x4c, 0x41, 0x61, 0xdc, 0x80, 0xda, 0xde, 0xd0, 0x3a, 0xa6, 0x5d, 0x9f, 0xf6, 0xd9,
0x5e, 0x0e, 0x9b, 0xc8, 0xfd, 0xc5, 0xc4, 0xd8, 0x84, 0xea, 0x43, 0x3a, 0x7e, 0xc6, 0xf6, 0x9d,
0x56, 0x3e, 0xe3, 0xaf, 0x25, 0x58, 0xe5, 0x51, 0x65, 0x3b, 0xae, 0x85, 0x51, 0x38, 0x6f, 0x14,
0x60, 0x28, 0xe5, 0xaa, 0xf4, 0x47, 0x3d, 0x9f, 0x06, 0x8e, 0x27, 0xcc, 0xc4, 0x54, 0xe9, 0x8f,
0x0e, 0x39, 0x80, 0xd5, 0xcb, 0x0c, 0xfd, 0xcd, 0x08, 0xaf, 0x2a, 0x67, 0x5a, 0x36, 0xab, 0x08,
0xf8, 0x39, 0x9b, 0xc7, 0x6b, 0xc3, 0x13, 0x2c, 0x27, 0x43, 0x6e, 0x3b, 0xb1, 0xb6, 0xcb, 0x01,
0xe8, 0x3b, 0x97, 0x86, 0x98, 0xd5, 0x82, 0x71, 0x6f, 0xe0, 0x0c, 0x1d, 0x2c, 0x60, 0xdd, 0xde,
0x8b, 0x71, 0x44, 0x43, 0x69, 0x30, 0x22, 0x90, 0xfb, 0x0c, 0xb7, 0xe7, 0x7e, 0xc9, 0x30, 0xc4,
0x80, 0x86, 0xe7, 0x0d, 0x7b, 0x61, 0xdf, 0x0b, 0xb0, 0x11, 0xb2, 0x5f, 0xf2, 0xb0, 0x5a, 0x36,
0xeb, 0x08, 0xec, 0x32, 0xd8, 0x96, 0xfd, 0xd2, 0xb0, 0xa0, 0xd1, 0xdd, 0xe5, 0xc7, 0x91, 0xe5,
0x35, 0x7a, 0xd4, 0x28, 0x94, 0x1e, 0x8a, 0x1e, 0xc5, 0xc6, 0x0c, 0x16, 0x78, 0x03, 0xe5, 0x65,
0x6c, 0xcc, 0x60, 0xd1, 0xd8, 0xa7, 0xb2, 0xb2, 0xe4, 0x63, 0xa6, 0xb0, 0x01, 0x3d, 0xc5, 0x62,
0x5e, 0x74, 0x5a, 0x62, 0x62, 0xd8, 0x00, 0xdb, 0x96, 0x6f, 0xbd, 0x70, 0x06, 0x4e, 0x34, 0x46,
0x03, 0xb6, 0x2c, 0xdb, 0xee, 0xf5, 0x63, 0x88, 0x43, 0xe3, 0x3e, 0x6b, 0x11, 0xe1, 0xdb, 0x1a,
0x98, 0x7c, 0x08, 0x4b, 0x76, 0xe0, 0xf9, 0x69, 0x5a, 0xd1, 0x78, 0xb5, 0x18, 0x42, 0x27, 0x36,
0xfe, 0x55, 0x82, 0xe5, 0xb4, 0x59, 0x64, 0xed, 0x7c, 0x0f, 0x6a, 0x41, 0x6c, 0x20, 0x79, 0xef,
0xd6, 0xd2, 0xe9, 0x21, 0x6f, 0x48, 0x33, 0x59, 0x82, 0xfe, 0xbf, 0x90, 0x11, 0xa0, 0x94, 0x72,
0xbc, 0xe4, 0x6c, 0x66, 0x8a, 0x90, 0x7c, 0x91, 0x34, 0x39, 0x71, 0x82, 0x2f, 0xf3, 0xb5, 0x2b,
0x6a, 0x6d, 0x4a, 0xf5, 0xaa, 0xf9, 0x89, 0x6b, 0xed, 0xef, 0x4b, 0x53, 0x64, 0x2b, 0x73, 0xbe,
0xe6, 0x29, 0x62, 0x84, 0x79, 0x8c, 0xaf, 0xa1, 0xa6, 0x40, 0xcc, 0x8d, 0x47, 0x4e, 0xec, 0x7b,
0x6c, 0xc8, 0x20, 0xc7, 0x32, 0xcc, 0x22, 0x04, 0x87, 0xac, 0xfd, 0x42, 0x5d, 0x3b, 0x6c, 0x17,
0x6b, 0xd0, 0x43, 0x08, 0x93, 0xac, 0x8c, 0xd8, 0x66, 0x02, 0x7e, 0x80, 0x50, 0xe3, 0xef, 0x15,
0x58, 0xcc, 0xea, 0xb3, 0x28, 0x90, 0xdf, 0x8c, 0x6f, 0xd7, 0x4c, 0x46, 0x54, 0x75, 0x01, 0xe5,
0x8d, 0x63, 0x75, 0x50, 0xdf, 0x1b, 0x0e, 0xf1, 0xa6, 0xf2, 0x2d, 0xb1, 0x0e, 0x92, 0x53, 0xc6,
0xd7, 0x0a, 0x8e, 0x43, 0x1e, 0xc2, 0x91, 0x2f, 0x1b, 0x93, 0xeb, 0x50, 0x67, 0xe9, 0x1d, 0xdb,
0x07, 0xd6, 0xcb, 0xc8, 0x16, 0x16, 0x24, 0x08, 0x3b, 0x19, 0x6c, 0x54, 0x67, 0xa9, 0x7b, 0x1a,
0x77, 0x14, 0x49, 0x3b, 0x1d, 0xdf, 0x6a, 0x93, 0xa3, 0x51, 0x93, 0x73, 0x43, 0xd6, 0xec, 0xc6,
0x89, 0xbe, 0xa9, 0x08, 0x79, 0x0f, 0x6c, 0x4a, 0x2c, 0xf9, 0x4c, 0xc5, 0x3a, 0x91, 0xcc, 0xdf,
0x4f, 0xac, 0x9c, 0xd6, 0x42, 0x61, 0x3d, 0xf0, 0x30, 0x5d, 0x0f, 0xd4, 0x38, 0x8b, 0x5b, 0x13,
0x59, 0x9c, 0xdd, 0xa0, 0x5c, 0x03, 0xf0, 0x03, 0xe7, 0xd4, 0x19, 0xd0, 0x63, 0x6a, 0xb7, 0x81,
0xb7, 0xaa, 0x1a, 0x84, 0x3f, 0x86, 0xc8, 0x76, 0xba, 0x17, 0x78, 0x5e, 0x74, 0x14, 0xb6, 0xeb,
0xa2, 0x85, 0x8e, 0xc1, 0x26, 0x87, 0xb2, 0x8e, 0x97, 0xf5, 0x82, 0xbc, 0x47, 0x5f, 0x10, 0xa5,
0x27, 0xce, 0x79, 0x8b, 0xbe, 0xcc, 0x32, 0x85, 0xed, 0xb8, 0xed, 0x06, 0x5f, 0x29, 0x26, 0x2c,
0x10, 0xf1, 0x41, 0xcf, 0x73, 0xfb, 0xb4, 0xdd, 0xe4, 0xa8, 0x1a, 0x87, 0x3c, 0x46, 0x00, 0x73,
0xa7, 0x28, 0x1a, 0xb7, 0x17, 0x39, 0x9c, 0x0d, 0xb1, 0x91, 0x94, 0xc5, 0x57, 0x8b, 0x5b, 0xff,
0xea, 0x84, 0xdb, 0xf5, 0x9d, 0x69, 0xa5, 0xfe, 0x54, 0x82, 0x15, 0xd1, 0xfd, 0x68, 0x37, 0xff,
0x1c, 0x4d, 0x00, 0xb9, 0xad, 0x1a, 0xae, 0x6c, 0xc5, 0x9e, 0x3d, 0xac, 0xa4, 0x23, 0xf7, 0xa1,
0x19, 0xf3, 0x94, 0x2b, 0xcb, 0x6f, 0x6a, 0xd5, 0x1a, 0xa1, 0x3e, 0x35, 0x3e, 0x8b, 0xfb, 0x3f,
0x3d, 0x5a, 0x89, 0x9c, 0x78, 0x03, 0x23, 0x94, 0x7a, 0xad, 0x51, 0x22, 0xd7, 0x15, 0x0c, 0xdb,
0x96, 0xbb, 0xac, 0x5b, 0xb3, 0x82, 0x28, 0x77, 0xe0, 0x29, 0xd6, 0xf2, 0x56, 0x2d, 0xbd, 0x56,
0x76, 0x53, 0x5d, 0x58, 0x66, 0x4d, 0xdc, 0x5b, 0x30, 0x65, 0x71, 0x80, 0x1d, 0xdb, 0x1b, 0x45,
0x32, 0x30, 0xc5, 0x53, 0x63, 0x55, 0x34, 0x96, 0xf9, 0xdd, 0x3e, 0x85, 0x15, 0xd1, 0xd7, 0xbd,
0xcd, 0x21, 0x2e, 0xc7, 0x5d, 0x65, 0x9e, 0xef, 0xef, 0x66, 0xb4, 0x20, 0x77, 0x8e, 0x6a, 0xf5,
0xe3, 0x74, 0x9d, 0xb5, 0x9a, 0x77, 0x82, 0x54, 0x99, 0x95, 0x77, 0xad, 0xd9, 0x02, 0xd7, 0x32,
0x73, 0x25, 0xad, 0xa8, 0xba, 0x3e, 0xcc, 0x73, 0xff, 0x3f, 0x56, 0xb4, 0x7b, 0xa2, 0xa2, 0x55,
0x5b, 0xab, 0xa6, 0xf9, 0x76, 0xa6, 0xa2, 0x6d, 0x4f, 0x12, 0x53, 0x15, 0xb4, 0xbf, 0x9d, 0x81,
0x9a, 0xc2, 0x4d, 0x55, 0xcf, 0xaa, 0xe4, 0x52, 0x7e, 0x53, 0x72, 0xc1, 0xfa, 0x8a, 0x0f, 0x7a,
0x01, 0x3d, 0x92, 0xda, 0xad, 0x72, 0x80, 0x49, 0x8f, 0x12, 0x73, 0x55, 0xa6, 0x32, 0xd7, 0x4f,
0x32, 0xaf, 0x55, 0xd7, 0xf2, 0xf4, 0xff, 0xeb, 0xaa, 0x77, 0x5f, 0x54, 0xbd, 0xba, 0x96, 0xe5,
0x0d, 0xc7, 0xb6, 0x5e, 0x39, 0x73, 0x5c, 0xfa, 0x92, 0xbc, 0x40, 0xa6, 0x46, 0xc5, 0xae, 0x4b,
0xea, 0x64, 0xc9, 0x4b, 0xc7, 0x14, 0xd7, 0xe5, 0x1f, 0xb3, 0xda, 0x9d, 0x38, 0xc7, 0x93, 0xc0,
0x39, 0xef, 0xc4, 0x1b, 0x5a, 0x0f, 0x9e, 0x89, 0x30, 0xf2, 0x08, 0xb4, 0xa8, 0x5e, 0x6b, 0x12,
0x82, 0x68, 0xac, 0x0e, 0x8e, 0x1c, 0xd7, 0x09, 0x4f, 0x04, 0x7e, 0x8e, 0xe3, 0x21, 0x06, 0x6d,
0xf1, 0xa7, 0x71, 0xfa, 0x1a, 0x6b, 0xe5, 0xbe, 0x67, 0x53, 0xcc, 0xfc, 0xfc, 0x69, 0x9c, 0x01,
0xb6, 0x71, 0x9e, 0xb8, 0x55, 0xf5, 0x5c, 0x6e, 0x55, 0xcb, 0xb8, 0xd5, 0x0a, 0xcc, 0xa1, 0xbc,
0xa1, 0xe7, 0xf2, 0x1c, 0x5d, 0x33, 0xe5, 0x4c, 0x2b, 0x25, 0xea, 0x93, 0x4a, 0x89, 0x33, 0x9e,
0x16, 0x32, 0xa5, 0xc4, 0xc2, 0xa4, 0x52, 0x62, 0x9a, 0x97, 0x05, 0xad, 0xfa, 0x69, 0x9c, 0x55,
0xfd, 0xbc, 0xcb, 0x94, 0xfc, 0x10, 0xb3, 0x5b, 0xd6, 0x59, 0xa5, 0xef, 0xdf, 0xce, 0x3c, 0x40,
0xb4, 0x27, 0x69, 0x41, 0xbd, 0x3f, 0xbc, 0x84, 0xfa, 0xee, 0x6b, 0x34, 0xdf, 0xf4, 0xd9, 0x08,
0x45, 0xed, 0x0f, 0x6d, 0xd9, 0x5b, 0xb0, 0x61, 0x5c, 0xe5, 0x94, 0x93, 0x2a, 0x47, 0x15, 0x4b,
0xcc, 0x4d, 0x17, 0x64, 0xb1, 0x64, 0xdc, 0x83, 0x05, 0xb1, 0x97, 0x94, 0x76, 0x85, 0x49, 0x6b,
0xb3, 0xb4, 0x56, 0xe2, 0x64, 0x72, 0x26, 0xe1, 0x34, 0x08, 0xf8, 0xd9, 0x05, 0x1c, 0x67, 0xc6,
0x27, 0x50, 0xe7, 0xfe, 0x26, 0xf3, 0xce, 0x4d, 0xbd, 0x4d, 0x3d, 0xcb, 0x29, 0x8d, 0x2d, 0x58,
0x62, 0xc1, 0x82, 0xc3, 0xd5, 0xcd, 0xfe, 0x28, 0x13, 0x8e, 0x97, 0xd3, 0xeb, 0x33, 0xa1, 0xf8,
0x15, 0x54, 0x38, 0x38, 0x77, 0xb3, 0xaf, 0xb0, 0x96, 0xc9, 0xf7, 0x7a, 0x91, 0x75, 0xac, 0x7e,
0xba, 0x18, 0xe0, 0x09, 0xce, 0xf9, 0x47, 0x1d, 0x43, 0xda, 0x0e, 0x6e, 0x1c, 0x85, 0xb2, 0x8c,
0xaf, 0x33, 0xd8, 0x8e, 0x00, 0xb1, 0xc8, 0x10, 0x3a, 0xbf, 0xa2, 0x5c, 0x53, 0xb3, 0x26, 0x1f,
0x63, 0xfd, 0x42, 0x74, 0x79, 0xa5, 0xba, 0xd0, 0x35, 0xf9, 0x71, 0xe2, 0xa0, 0xd6, 0x4c, 0x0b,
0x6c, 0x4a, 0x2c, 0xaa, 0x99, 0x08, 0x0d, 0xa4, 0x02, 0xd9, 0xf4, 0xda, 0xfa, 0x14, 0x2e, 0xa6,
0xd6, 0xab, 0xa7, 0xee, 0x14, 0x83, 0xec, 0xee, 0x72, 0xf1, 0xdf, 0x4a, 0x00, 0x5b, 0xa3, 0xe8,
0x44, 0x36, 0x40, 0x1d, 0xa8, 0xb2, 0xb6, 0x4b, 0xab, 0x0f, 0xd4, 0x9c, 0xe1, 0x7c, 0x2b, 0x0c,
0xb1, 0x43, 0x89, 0x2b, 0x05, 0x35, 0xe7, 0x0d, 0xce, 0x48, 0x7d, 0x94, 0xf1, 0x31, 0xfb, 0x68,
0x13, 0xbf, 0x8b, 0xd8, 0x9f, 0xdb, 0xd8, 0x73, 0x86, 0x32, 0x6d, 0x35, 0x04, 0x74, 0x4b, 0x00,
0x19, 0x99, 0x63, 0x53, 0x14, 0x2d, 0x1a, 0xf7, 0x22, 0xef, 0x15, 0x75, 0x65, 0x2b, 0xd4, 0x88,
0xa1, 0x4f, 0x18, 0x90, 0x91, 0x05, 0xf4, 0x18, 0xb5, 0x1c, 0xc4, 0x64, 0x73, 0x82, 0x2c, 0x86,
0x72, 0x32, 0xf6, 0x31, 0xdb, 0x3a, 0x1c, 0x0d, 0x06, 0xe2, 0x90, 0xe7, 0xd5, 0x25, 0x76, 0x1e,
0xe2, 0x1c, 0xd9, 0x46, 0x38, 0x51, 0x91, 0x3c, 0xdc, 0xb7, 0x2f, 0x7a, 0x2f, 0xc2, 0x92, 0x26,
0xa8, 0xac, 0xd7, 0xd0, 0x17, 0x44, 0x29, 0xf7, 0x76, 0xf2, 0x1b, 0x97, 0xe0, 0x62, 0x6a, 0xbd,
0x60, 0xbb, 0xfe, 0x1e, 0x54, 0xe3, 0x4f, 0x58, 0x32, 0x0f, 0xe5, 0x27, 0xdb, 0x87, 0xad, 0x0b,
0x6c, 0xf0, 0x74, 0xe7, 0xb0, 0x55, 0x5a, 0x5f, 0x87, 0xc5, 0xcc, 0xf3, 0x19, 0xa9, 0x41, 0xc5,
0xdc, 0xdd, 0xda, 0x79, 0x8e, 0x64, 0x0b, 0x50, 0x3d, 0x78, 0xfc, 0x44, 0xcc, 0x4a, 0xeb, 0xdb,
0xd0, 0x4c, 0xa7, 0x3b, 0x52, 0x87, 0xf9, 0x6d, 0xc4, 0x3e, 0xd9, 0xdd, 0x41, 0x62, 0x9c, 0x98,
0x4f, 0x0f, 0x0e, 0xf6, 0x0e, 0x1e, 0xb4, 0x4a, 0x04, 0x60, 0x6e, 0xf7, 0xeb, 0x3d, 0x86, 0x98,
0x61, 0x88, 0xa7, 0x07, 0x0f, 0x0f, 0x1e, 0xff, 0xe2, 0xa0, 0x55, 0xde, 0xfc, 0x4b, 0x15, 0x9a,
0xa6, 0x38, 0x42, 0x17, 0x7d, 0xc1, 0xc1, 0xce, 0xeb, 0x1e, 0xcc, 0xc7, 0x3f, 0xdc, 0x49, 0x62,
0x4d, 0x7f, 0xc7, 0x77, 0xda, 0x79, 0x84, 0x54, 0xdb, 0x05, 0xf2, 0x1c, 0x5a, 0xd9, 0x4f, 0x1f,
0x92, 0x3c, 0x85, 0x4c, 0xf8, 0x5d, 0xea, 0xdc, 0x38, 0x83, 0x42, 0xb1, 0xee, 0x42, 0x33, 0xfd,
0x9d, 0x43, 0x92, 0x7a, 0xa9, 0xf0, 0x9b, 0xa8, 0x73, 0x7d, 0x22, 0x5e, 0x97, 0x37, 0xfb, 0x91,
0xa3, 0xc9, 0x3b, 0xe1, 0x93, 0x48, 0x93, 0x77, 0xe2, 0x2f, 0x10, 0x67, 0x9d, 0xfb, 0xf2, 0x58,
0x9b, 0xfc, 0xb2, 0x9d, 0x63, 0x3d, 0xe9, 0xb9, 0x5c, 0xa8, 0x22, 0xfd, 0x76, 0x49, 0xf4, 0xdf,
0x88, 0x82, 0x67, 0x61, 0x4d, 0x15, 0xc5, 0x8f, 0x9e, 0xc8, 0xf4, 0x19, 0x96, 0x63, 0xe9, 0xee,
0x8f, 0x5c, 0xcf, 0xd8, 0x25, 0xdb, 0x15, 0x75, 0xd6, 0x26, 0x13, 0xa4, 0xed, 0xa6, 0xf7, 0x76,
0x29, 0xbb, 0x15, 0x34, 0x8c, 0x29, 0xbb, 0x15, 0x36, 0x85, 0x17, 0xc8, 0x21, 0x34, 0x52, 0x1d,
0x1c, 0xb9, 0x9a, 0xb2, 0x75, 0x8e, 0xe5, 0xb5, 0x49, 0x68, 0xfd, 0xf8, 0x99, 0xee, 0x4d, 0x3b,
0x7e, 0x71, 0x53, 0xd8, 0x59, 0x9b, 0x4c, 0x90, 0xb5, 0x55, 0x52, 0x71, 0x67, 0x6c, 0x95, 0x6b,
0x78, 0x32, 0xb6, 0xca, 0x97, 0xea, 0xd2, 0x56, 0x99, 0xd2, 0xf9, 0xfa, 0xc4, 0x9a, 0x25, 0x6f,
0xab, 0xe2, 0x32, 0x08, 0xf9, 0xde, 0x81, 0x59, 0x56, 0x6a, 0x90, 0x24, 0xa9, 0x6b, 0x55, 0x4e,
0xe7, 0x52, 0x06, 0x1a, 0x2f, 0xbb, 0x59, 0xba, 0x5d, 0xda, 0xfc, 0xf3, 0x0c, 0x2c, 0x88, 0x38,
0x28, 0x43, 0xc9, 0x03, 0x80, 0x24, 0x1b, 0x93, 0x4e, 0xea, 0x50, 0xa9, 0x92, 0xa2, 0x73, 0xa5,
0x10, 0xa7, 0x84, 0xfa, 0x4a, 0xd6, 0x2f, 0xf2, 0xa0, 0x57, 0x32, 0x61, 0x37, 0x75, 0xc8, 0xf7,
0x8a, 0x91, 0x8a, 0xd7, 0x0e, 0xd4, 0x54, 0xb4, 0x27, 0x5a, 0x92, 0xc8, 0xa4, 0xaa, 0x4e, 0xa7,
0x08, 0xa5, 0x4b, 0xa4, 0x85, 0x77, 0x4d, 0xa2, 0x7c, 0xd2, 0xd0, 0x24, 0x2a, 0xc8, 0x08, 0xc6,
0x85, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0x00, 0x73, 0xab, 0x16, 0x03, 0x25, 0x00, 0x00,
// 2747 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xcc, 0x1a, 0x4d, 0x73, 0xdb, 0xc6,
0xd5, 0x14, 0x45, 0x89, 0x7c, 0x14, 0x29, 0x6a, 0x2d, 0x4b, 0x34, 0x1d, 0xdb, 0x32, 0x92, 0xb4,
0xb6, 0x92, 0x68, 0x5c, 0xb5, 0xd3, 0xd4, 0x4e, 0xe2, 0x58, 0x91, 0x54, 0x8f, 0x62, 0x59, 0x56,
0x41, 0xdb, 0x8d, 0x4f, 0x18, 0x98, 0x58, 0x49, 0xb0, 0x49, 0x00, 0x01, 0x40, 0xd5, 0xea, 0xb5,
0xbf, 0xa1, 0xe7, 0xf6, 0xd0, 0x99, 0x9e, 0x7a, 0xe9, 0x4c, 0xff, 0x44, 0x3b, 0x3d, 0xf5, 0x77,
0xf4, 0xd4, 0x4b, 0x2f, 0x9d, 0xf6, 0xed, 0x07, 0x16, 0x8b, 0x0f, 0xca, 0x92, 0x33, 0x53, 0xe7,
0x86, 0x7d, 0xef, 0xed, 0xdb, 0xb7, 0xef, 0xbd, 0x7d, 0x1f, 0xbb, 0x80, 0x86, 0x1d, 0xb8, 0x6b,
0x41, 0xe8, 0xc7, 0x3e, 0x99, 0x0d, 0xc7, 0x5e, 0xec, 0x8e, 0xa8, 0xb1, 0x0a, 0xed, 0x67, 0x34,
0x8c, 0x5c, 0xdf, 0x33, 0xe9, 0xb7, 0x63, 0x1a, 0xc5, 0xa4, 0x0b, 0xb3, 0xc7, 0x02, 0xd2, 0xad,
0xac, 0x54, 0x6e, 0x36, 0xcc, 0x64, 0x68, 0xfc, 0xb1, 0x02, 0xf3, 0x8a, 0x38, 0x0a, 0x7c, 0x2f,
0xa2, 0x93, 0xa9, 0xc9, 0x0d, 0x98, 0x93, 0x8b, 0x58, 0x9e, 0x3d, 0xa2, 0xdd, 0x29, 0x8e, 0x6e,
0x4a, 0xd8, 0x1e, 0x82, 0xc8, 0x0f, 0x61, 0x3e, 0x21, 0x49, 0x98, 0x54, 0x39, 0x55, 0x5b, 0x82,
0xe5, 0x6a, 0x64, 0x0d, 0x2e, 0x26, 0x84, 0xb8, 0x07, 0x45, 0x3c, 0xcd, 0x89, 0x17, 0x24, 0x6a,
0x23, 0x70, 0x25, 0xbd, 0xb1, 0x01, 0x8d, 0xad, 0xbd, 0xfe, 0xe3, 0x20, 0x66, 0x93, 0x51, 0xc4,
0x88, 0x86, 0x6c, 0x0e, 0x8a, 0x58, 0x65, 0x22, 0xca, 0x21, 0xe9, 0x41, 0x3d, 0xa2, 0x76, 0x38,
0x38, 0xa2, 0x11, 0x8a, 0xc7, 0x50, 0x6a, 0x6c, 0xfc, 0xa9, 0x02, 0xcd, 0x7d, 0x3f, 0x8c, 0x1f,
0xd9, 0x41, 0xe0, 0x7a, 0x87, 0x84, 0xc0, 0x34, 0xdf, 0x86, 0xd8, 0x25, 0xff, 0x26, 0x9f, 0x40,
0x9d, 0xab, 0x73, 0xe0, 0x0f, 0xf9, 0xf6, 0xda, 0xeb, 0x0b, 0x6b, 0x52, 0x98, 0xb5, 0x7d, 0x89,
0x30, 0x15, 0x09, 0xf9, 0x10, 0xda, 0x03, 0xdf, 0x8b, 0x6d, 0xd7, 0xa3, 0xa1, 0x15, 0x20, 0x6f,
0xbe, 0xdb, 0x9a, 0xd9, 0x52, 0x50, 0xb6, 0x20, 0xb9, 0x02, 0x8d, 0x23, 0x3f, 0x8a, 0x05, 0xc5,
0x34, 0xa7, 0xa8, 0x33, 0x00, 0x47, 0x2e, 0xc3, 0x2c, 0x47, 0xba, 0x41, 0xb7, 0xc6, 0x25, 0x99,
0x61, 0xc3, 0x9d, 0xc0, 0xf8, 0x43, 0x05, 0x6a, 0x8f, 0x7c, 0x5c, 0xbc, 0x54, 0xd2, 0xec, 0xd2,
0x76, 0x7c, 0x24, 0xcd, 0xa1, 0x2d, 0x8d, 0xc0, 0x74, 0x69, 0x46, 0x21, 0x4c, 0x21, 0x96, 0x66,
0x48, 0xd4, 0x56, 0x48, 0x6d, 0xc7, 0xf7, 0x86, 0x27, 0x5c, 0xac, 0xba, 0xa9, 0xc6, 0xcc, 0x92,
0x11, 0x1d, 0xba, 0xde, 0xf8, 0xb5, 0x15, 0xd2, 0xa1, 0xfd, 0x82, 0x0e, 0xb9, 0x78, 0x75, 0xb3,
0x2d, 0xc1, 0xa6, 0x80, 0x1a, 0x2f, 0x61, 0x9e, 0x99, 0x3e, 0x0a, 0xec, 0x01, 0x95, 0xf6, 0x41,
0x47, 0xe1, 0x8b, 0x7a, 0x34, 0xfe, 0x95, 0x1f, 0xbe, 0xe2, 0x72, 0xd7, 0xcd, 0x26, 0x83, 0xed,
0x09, 0x10, 0xb9, 0x0c, 0x75, 0x21, 0x97, 0xeb, 0x70, 0xc1, 0xeb, 0x26, 0xd7, 0xc2, 0xbe, 0xeb,
0x28, 0x94, 0x1b, 0x0c, 0xb8, 0xc4, 0x12, 0xb5, 0x13, 0x0c, 0x8c, 0xdf, 0x54, 0xe0, 0xd2, 0x2e,
0x5b, 0x7c, 0xdf, 0x77, 0xfa, 0xb6, 0xe7, 0xbc, 0xf0, 0x5f, 0x6f, 0xfa, 0xde, 0x81, 0x7b, 0x48,
0xde, 0x87, 0xd6, 0xe0, 0x30, 0xf4, 0xc7, 0x01, 0xee, 0x34, 0xa4, 0x5e, 0x2c, 0x75, 0x35, 0x27,
0x80, 0xfb, 0x1c, 0x46, 0xb6, 0x61, 0xc1, 0x4b, 0x44, 0xb5, 0x7c, 0x2e, 0x6b, 0xc4, 0x57, 0x6f,
0xae, 0x77, 0x95, 0x99, 0x73, 0x9b, 0x31, 0x3b, 0x5e, 0x16, 0x10, 0x19, 0xbf, 0x9d, 0x86, 0x4e,
0x41, 0x80, 0x32, 0x1b, 0xf5, 0xc4, 0x4e, 0xb4, 0xc3, 0xa2, 0xc6, 0x4c, 0xe0, 0xa1, 0x7f, 0x68,
0x39, 0x6e, 0x48, 0x07, 0xb1, 0x1f, 0x9e, 0x48, 0xe3, 0xcc, 0x21, 0x70, 0x2b, 0x81, 0x91, 0x1f,
0x43, 0xd3, 0xf1, 0x22, 0x25, 0xea, 0x34, 0x17, 0x95, 0x28, 0x51, 0xd5, 0x89, 0x30, 0x01, 0xc9,
0xa4, 0x78, 0xe4, 0x0e, 0xb4, 0x98, 0xa3, 0x59, 0x23, 0xe1, 0xe7, 0x11, 0xda, 0xad, 0x8a, 0xd3,
0x16, 0x53, 0x47, 0x4e, 0x0f, 0x81, 0x39, 0x17, 0xa4, 0x83, 0x88, 0x7c, 0x01, 0x33, 0xdc, 0xa8,
0x51, 0x77, 0x86, 0xcf, 0xf9, 0x50, 0x9b, 0x93, 0xdd, 0xef, 0xda, 0x2e, 0xa7, 0xdb, 0xf6, 0xe2,
0xf0, 0xc4, 0x94, 0x93, 0xc8, 0x2e, 0x34, 0x6d, 0xcf, 0xf3, 0x63, 0x5b, 0x88, 0x3b, 0xcb, 0x79,
0xac, 0x4e, 0xe6, 0xb1, 0x91, 0x12, 0x0b, 0x46, 0xfa, 0x74, 0xf2, 0x13, 0xa8, 0x71, 0x47, 0xeb,
0xd6, 0xf9, 0xb6, 0xaf, 0x29, 0x3e, 0xa5, 0x1e, 0x60, 0x0a, 0xe2, 0xde, 0x1d, 0x68, 0x6a, 0xa2,
0x91, 0x0e, 0x54, 0x5f, 0xd1, 0x13, 0x69, 0x15, 0xf6, 0x49, 0x16, 0xa1, 0x76, 0x6c, 0x0f, 0xc7,
0x89, 0x45, 0xc4, 0xe0, 0xee, 0xd4, 0xcf, 0x2a, 0xbd, 0x7b, 0xd0, 0xc9, 0x4b, 0x74, 0x9e, 0xf9,
0xc6, 0x2e, 0x2c, 0x6f, 0xe2, 0xf9, 0x89, 0x69, 0x2a, 0x5b, 0x12, 0x82, 0x7f, 0x04, 0x33, 0x03,
0x2e, 0x26, 0xe7, 0xd4, 0x5c, 0xbf, 0x3c, 0x51, 0x29, 0xa6, 0x24, 0x34, 0xee, 0x43, 0xb7, 0xc8,
0x4d, 0xc6, 0xe8, 0x0f, 0xa0, 0x1d, 0xf8, 0x8e, 0x15, 0x09, 0xb0, 0x85, 0x67, 0x48, 0xba, 0x7b,
0xa0, 0x68, 0x77, 0x1c, 0xe3, 0x0b, 0xb8, 0xd4, 0x8f, 0xfd, 0xa0, 0x28, 0xcd, 0xd9, 0xa6, 0x77,
0x61, 0x29, 0x3f, 0x5d, 0x2c, 0x6f, 0x7c, 0x09, 0xcb, 0x26, 0x1d, 0xf9, 0xc7, 0xf4, 0x6d, 0x59,
0xf7, 0xa0, 0x5b, 0x64, 0x90, 0x32, 0x4f, 0xa1, 0x7d, 0x34, 0xc6, 0x38, 0x3a, 0x1f, 0xf3, 0x5b,
0x3a, 0x03, 0x19, 0x6f, 0x04, 0x1f, 0xd2, 0x86, 0x29, 0x0c, 0xb3, 0x62, 0x12, 0x7e, 0x19, 0xcf,
0xa1, 0xa1, 0x8e, 0x3b, 0xcb, 0x2a, 0x7a, 0xc0, 0xc2, 0xac, 0x22, 0x87, 0x64, 0x1d, 0x66, 0xcf,
0x1a, 0x2d, 0x12, 0x42, 0xe3, 0x61, 0x21, 0x52, 0x49, 0x19, 0xd6, 0x01, 0x54, 0x44, 0x89, 0xa4,
0x3b, 0x90, 0x22, 0x3f, 0x53, 0xa3, 0x32, 0xfe, 0x5b, 0xd5, 0x23, 0x8e, 0xb6, 0x19, 0x47, 0x6d,
0xc6, 0x51, 0x11, 0x68, 0x4a, 0x8b, 0x40, 0x6b, 0x50, 0x8b, 0x90, 0x9a, 0xf2, 0xe8, 0xd2, 0xd6,
0xe4, 0x96, 0xdc, 0xbe, 0x12, 0xdc, 0xa8, 0x29, 0xc8, 0xc8, 0x55, 0x80, 0x01, 0x77, 0x3a, 0xc7,
0xb2, 0x45, 0xaa, 0xaa, 0x9a, 0x0d, 0x09, 0xd9, 0x88, 0xc9, 0xdd, 0x54, 0x45, 0x35, 0x2e, 0xf8,
0x4a, 0x89, 0x1f, 0x67, 0x54, 0x9e, 0x2a, 0x51, 0x1d, 0xe7, 0x99, 0xd3, 0x8f, 0xb3, 0x9c, 0x27,
0x88, 0xb5, 0x88, 0x34, 0x3b, 0x31, 0x22, 0x89, 0x19, 0x67, 0x89, 0x48, 0xf5, 0x89, 0x11, 0x49,
0xf2, 0x38, 0x35, 0x22, 0xbd, 0xcb, 0xd8, 0xf2, 0x08, 0xba, 0xc5, 0x53, 0x21, 0xa3, 0x01, 0x06,
0x97, 0x88, 0x43, 0x4e, 0x09, 0x2e, 0x72, 0x8a, 0x24, 0x34, 0xfe, 0x53, 0xd1, 0x1d, 0xea, 0xe7,
0xee, 0x30, 0xa6, 0x61, 0x69, 0x0a, 0x13, 0x4e, 0x36, 0xa5, 0x9c, 0xec, 0xbc, 0x0e, 0xd5, 0x87,
0x36, 0x37, 0x85, 0x85, 0x55, 0x03, 0x4f, 0x6a, 0xe8, 0x54, 0xcc, 0x06, 0x1f, 0x97, 0xc8, 0x28,
0xc4, 0x10, 0x76, 0xec, 0x4b, 0x72, 0x61, 0x85, 0xd6, 0x50, 0x87, 0xf5, 0xee, 0x03, 0x29, 0x12,
0x9d, 0x4b, 0x9d, 0x5f, 0xb3, 0xd3, 0xc9, 0x0a, 0xb0, 0x92, 0x40, 0x7d, 0xc0, 0xc5, 0x38, 0x45,
0x97, 0x42, 0x4e, 0x53, 0x12, 0x1a, 0xff, 0xaa, 0x00, 0xa4, 0xc8, 0x77, 0x71, 0x2c, 0x3f, 0x55,
0x87, 0x44, 0xa4, 0xfa, 0xeb, 0x25, 0x42, 0x97, 0x1d, 0x8f, 0xef, 0xe0, 0xd0, 0xc6, 0x26, 0x2c,
0xe5, 0x35, 0x28, 0xdd, 0xf1, 0x16, 0xd4, 0xdc, 0x98, 0x8e, 0x44, 0x6d, 0xde, 0x5c, 0xbf, 0x58,
0x22, 0x8c, 0x29, 0x28, 0x8c, 0x1b, 0xd0, 0xd8, 0x19, 0xd9, 0x87, 0xb4, 0x1f, 0xd0, 0x01, 0x5b,
0xcb, 0x65, 0x03, 0xb9, 0xbe, 0x18, 0x18, 0xeb, 0x50, 0x7f, 0x48, 0x4f, 0x9e, 0xb1, 0x75, 0xcf,
0x2a, 0x9f, 0xf1, 0xb7, 0x0a, 0x2c, 0xf3, 0xa8, 0xb2, 0x99, 0xd4, 0xc2, 0x28, 0x9c, 0x3f, 0x0e,
0x31, 0x94, 0x72, 0x55, 0x06, 0x63, 0x2b, 0xa0, 0xa1, 0xeb, 0x0b, 0x33, 0x31, 0x55, 0x06, 0xe3,
0x7d, 0x0e, 0x60, 0xf5, 0x32, 0x43, 0x7f, 0x3b, 0xc6, 0xa3, 0xca, 0x99, 0x56, 0xcd, 0x3a, 0x02,
0x7e, 0xc1, 0xc6, 0xc9, 0xdc, 0xe8, 0x08, 0xcb, 0xc9, 0x88, 0xdb, 0x4e, 0xcc, 0xed, 0x73, 0x00,
0xfa, 0xce, 0xa5, 0x11, 0x66, 0xb5, 0xf0, 0xc4, 0x1a, 0xba, 0x23, 0x17, 0x0b, 0x58, 0xcf, 0x7a,
0x71, 0x12, 0xd3, 0x48, 0x1a, 0x8c, 0x08, 0xe4, 0x2e, 0xc3, 0xed, 0x78, 0x5f, 0x31, 0x0c, 0x31,
0xa0, 0xe5, 0xfb, 0x23, 0x2b, 0x1a, 0xf8, 0x21, 0x36, 0x42, 0xce, 0x4b, 0x1e, 0x56, 0xab, 0x66,
0x13, 0x81, 0x7d, 0x06, 0xdb, 0x70, 0x5e, 0x1a, 0x36, 0xb4, 0xfa, 0xdb, 0x7c, 0x3b, 0xb2, 0xbc,
0x46, 0x8f, 0x1a, 0x47, 0xd2, 0x43, 0xd1, 0xa3, 0xd8, 0x37, 0x83, 0x85, 0xfe, 0x50, 0x79, 0x19,
0xfb, 0x66, 0xb0, 0xf8, 0x24, 0xa0, 0xb2, 0xb2, 0xe4, 0xdf, 0x4c, 0x61, 0x43, 0x7a, 0x8c, 0xc5,
0xbc, 0xe8, 0xb4, 0xc4, 0xc0, 0x70, 0x00, 0x36, 0xed, 0xc0, 0x7e, 0xe1, 0x0e, 0xdd, 0xf8, 0x04,
0x0d, 0xd8, 0xb1, 0x1d, 0xc7, 0x1a, 0x24, 0x10, 0x97, 0x26, 0x7d, 0xd6, 0x3c, 0xc2, 0x37, 0x35,
0x30, 0xf9, 0x08, 0x16, 0x9c, 0xd0, 0x0f, 0xb2, 0xb4, 0xa2, 0xf1, 0xea, 0x30, 0x84, 0x4e, 0x6c,
0xfc, 0xbb, 0x02, 0x8b, 0x59, 0xb3, 0xc8, 0xda, 0xf9, 0x1e, 0x34, 0xc2, 0xc4, 0x40, 0xf2, 0xdc,
0xad, 0x64, 0xd3, 0x43, 0xd1, 0x90, 0x66, 0x3a, 0x05, 0xfd, 0x7f, 0x2e, 0x27, 0x40, 0x25, 0xe3,
0x78, 0xe9, 0xde, 0xcc, 0x0c, 0x21, 0xf9, 0x32, 0x6d, 0x72, 0x92, 0x04, 0x5f, 0xe5, 0x73, 0x97,
0xd4, 0xdc, 0x8c, 0xea, 0x55, 0xf3, 0x93, 0xd4, 0xda, 0x3f, 0x90, 0xa6, 0xc8, 0x57, 0xe6, 0x7c,
0xce, 0x53, 0xc4, 0x08, 0xf3, 0x18, 0xdf, 0x40, 0x43, 0x81, 0x98, 0x1b, 0x8f, 0xdd, 0xc4, 0xf7,
0xd8, 0x27, 0x83, 0x1c, 0xca, 0x30, 0x8b, 0x10, 0xfc, 0x64, 0xed, 0x17, 0xea, 0xda, 0x65, 0xab,
0xd8, 0x43, 0x0b, 0x21, 0x4c, 0xb2, 0x2a, 0x62, 0xdb, 0x29, 0xf8, 0x01, 0x42, 0x8d, 0x7f, 0xd4,
0x60, 0x3e, 0xaf, 0xcf, 0xb2, 0x40, 0x7e, 0x33, 0x39, 0x5d, 0x53, 0x39, 0x51, 0xd5, 0x01, 0x94,
0x27, 0x8e, 0xd5, 0x41, 0x03, 0x7f, 0x34, 0xc2, 0x93, 0xca, 0x97, 0xc4, 0x3a, 0x48, 0x0e, 0x19,
0x5f, 0x3b, 0x3c, 0x8c, 0x78, 0x08, 0x47, 0xbe, 0xec, 0x9b, 0x5c, 0x87, 0x26, 0x4b, 0xef, 0xd8,
0x3e, 0xb0, 0x5e, 0x46, 0xb6, 0xb0, 0x20, 0x41, 0xd8, 0xc9, 0x60, 0xa3, 0x3a, 0x4d, 0xbd, 0xe3,
0xa4, 0xa3, 0x48, 0xdb, 0xe9, 0xe4, 0x54, 0x9b, 0x1c, 0x8d, 0x9a, 0x9c, 0x19, 0xb1, 0x66, 0x37,
0x49, 0xf4, 0x6d, 0x45, 0xc8, 0x7b, 0x60, 0x53, 0x62, 0xc9, 0xe7, 0x2a, 0xd6, 0x89, 0x64, 0xfe,
0x41, 0x6a, 0xe5, 0xac, 0x16, 0x4a, 0xeb, 0x81, 0x87, 0xd9, 0x7a, 0xa0, 0xc1, 0x59, 0xdc, 0x9a,
0xc8, 0xe2, 0xf4, 0x06, 0xe5, 0x1a, 0x40, 0x10, 0xba, 0xc7, 0xee, 0x90, 0x1e, 0x52, 0xa7, 0x0b,
0xbc, 0x55, 0xd5, 0x20, 0xfc, 0x32, 0x44, 0xb6, 0xd3, 0x56, 0xe8, 0xfb, 0xf1, 0x41, 0xd4, 0x6d,
0x8a, 0x16, 0x3a, 0x01, 0x9b, 0x1c, 0xca, 0x3a, 0x5e, 0xd6, 0x0b, 0xf2, 0x1e, 0x7d, 0x4e, 0x94,
0x9e, 0x38, 0xe6, 0x2d, 0xfa, 0x22, 0xcb, 0x14, 0x8e, 0xeb, 0x75, 0x5b, 0x7c, 0xa6, 0x18, 0xb0,
0x40, 0xc4, 0x3f, 0x2c, 0xdf, 0x1b, 0xd0, 0x6e, 0x9b, 0xa3, 0x1a, 0x1c, 0xf2, 0x18, 0x01, 0xcc,
0x9d, 0xe2, 0xf8, 0xa4, 0x3b, 0xcf, 0xe1, 0xec, 0x13, 0x1b, 0x49, 0x59, 0x7c, 0x75, 0xb8, 0xf5,
0xaf, 0x4e, 0x38, 0x5d, 0xdf, 0x9b, 0x56, 0xea, 0xcf, 0x15, 0x58, 0x12, 0xdd, 0x8f, 0x76, 0xf2,
0xcf, 0xd1, 0x04, 0x90, 0xdb, 0xaa, 0xe1, 0xca, 0x57, 0xec, 0xf9, 0xcd, 0x4a, 0x3a, 0x72, 0x1f,
0xda, 0x09, 0x4f, 0x39, 0xb3, 0xfa, 0xa6, 0x56, 0xad, 0x15, 0xe9, 0x43, 0xe3, 0xf3, 0xa4, 0xff,
0xd3, 0xa3, 0x95, 0xc8, 0x89, 0x37, 0x30, 0x42, 0xa9, 0xdb, 0x1a, 0x25, 0x72, 0x53, 0xc1, 0xb0,
0x6d, 0xb9, 0xcb, 0xba, 0x35, 0x3b, 0x8c, 0x0b, 0x1b, 0x3e, 0xc3, 0x5c, 0xde, 0xaa, 0x65, 0xe7,
0xca, 0x6e, 0xaa, 0x0f, 0x8b, 0xac, 0x89, 0x7b, 0x0b, 0xa6, 0x2c, 0x0e, 0xb0, 0x6d, 0xfb, 0xe3,
0x58, 0x06, 0xa6, 0x64, 0x68, 0x2c, 0x8b, 0xc6, 0xb2, 0xb8, 0xda, 0x67, 0xb0, 0x24, 0xfa, 0xba,
0xb7, 0xd9, 0xc4, 0xe5, 0xa4, 0xab, 0x2c, 0xf2, 0xfd, 0xfd, 0x94, 0x16, 0xe4, 0xce, 0x51, 0xad,
0x7e, 0x92, 0xad, 0xb3, 0x96, 0x8b, 0x4e, 0x90, 0x29, 0xb3, 0x8a, 0xae, 0x35, 0x5d, 0xe2, 0x5a,
0x66, 0xa1, 0xa4, 0x15, 0x55, 0xd7, 0x47, 0x45, 0xee, 0xff, 0xc7, 0x8a, 0x76, 0x47, 0x54, 0xb4,
0x6a, 0x69, 0xd5, 0x34, 0xdf, 0xce, 0x55, 0xb4, 0xdd, 0x49, 0x62, 0xaa, 0x82, 0xf6, 0x77, 0x55,
0x68, 0x28, 0xdc, 0x99, 0xea, 0x59, 0x95, 0x5c, 0xaa, 0x6f, 0x4a, 0x2e, 0x58, 0x5f, 0xf1, 0x0f,
0x2b, 0xa4, 0x07, 0x52, 0xbb, 0x75, 0x0e, 0x30, 0xe9, 0x41, 0x6a, 0xae, 0xda, 0x99, 0xcc, 0xf5,
0xd3, 0xdc, 0x6d, 0xd5, 0xb5, 0x22, 0x7d, 0x69, 0x12, 0xd8, 0x2e, 0xbb, 0xa6, 0x7a, 0xbf, 0x64,
0xf2, 0xf7, 0xb6, 0x1b, 0xdc, 0x15, 0xc5, 0xb7, 0x6e, 0x6c, 0x19, 0x68, 0xd6, 0xb1, 0x44, 0x55,
0x50, 0x59, 0x81, 0x93, 0xe2, 0xd6, 0x4c, 0x8d, 0x8a, 0x9d, 0xda, 0x8c, 0x82, 0xd3, 0x0b, 0x97,
0x33, 0x9c, 0xda, 0x7f, 0x4e, 0x6b, 0x47, 0xf3, 0x1c, 0x37, 0x13, 0xe7, 0x3c, 0x9a, 0x6f, 0xe8,
0x80, 0x78, 0x42, 0xc4, 0x00, 0x28, 0xd0, 0xa2, 0x88, 0x6e, 0x48, 0x08, 0xa2, 0xb1, 0x48, 0x39,
0x70, 0x3d, 0x37, 0x3a, 0x12, 0xf8, 0x19, 0x8e, 0x87, 0x04, 0xb4, 0xc1, 0x6f, 0xe8, 0xe9, 0x6b,
0x2c, 0xd9, 0x07, 0xbe, 0x43, 0xd1, 0x21, 0xf8, 0x0d, 0x3d, 0x03, 0x6c, 0xe2, 0x38, 0xf5, 0xee,
0xfa, 0xb9, 0xbc, 0xbb, 0x91, 0xf3, 0xee, 0x25, 0x98, 0x41, 0x79, 0x23, 0xdf, 0xe3, 0xa5, 0x42,
0xc3, 0x94, 0x23, 0xad, 0xa2, 0x69, 0x4e, 0xaa, 0x68, 0x4e, 0xb9, 0xe1, 0xc8, 0x55, 0x34, 0x73,
0x93, 0x2a, 0x9a, 0xb3, 0x5c, 0x70, 0x68, 0x45, 0x58, 0xeb, 0xb4, 0x22, 0xec, 0x5d, 0xba, 0xfe,
0x43, 0x4c, 0xb2, 0x79, 0x67, 0x95, 0xbe, 0x7f, 0x3b, 0x77, 0x0f, 0xd2, 0x9d, 0xa4, 0x05, 0x75,
0x0d, 0xf2, 0x12, 0x9a, 0xdb, 0xaf, 0xd1, 0x7c, 0x67, 0x4f, 0x8a, 0x28, 0xea, 0x60, 0xe4, 0xc8,
0x16, 0x87, 0x7d, 0x26, 0xc5, 0x56, 0x35, 0x2d, 0xb6, 0x54, 0xcd, 0xc6, 0xdc, 0x74, 0x4e, 0xd6,
0x6c, 0xc6, 0x3d, 0x98, 0x13, 0x6b, 0x49, 0x69, 0x97, 0x98, 0xb4, 0x0e, 0xcb, 0xae, 0x15, 0x4e,
0x26, 0x47, 0x12, 0x4e, 0xc3, 0x90, 0xef, 0x5d, 0xc0, 0x71, 0x64, 0x7c, 0x0a, 0x4d, 0xee, 0x6f,
0x32, 0xfd, 0xdd, 0xd4, 0xbb, 0xe5, 0xd3, 0x9c, 0xd2, 0xd8, 0x80, 0x05, 0x16, 0x2c, 0x38, 0x5c,
0x9d, 0xec, 0x8f, 0x73, 0x59, 0x61, 0x31, 0x3b, 0x3f, 0x97, 0x11, 0x5e, 0x41, 0x8d, 0x83, 0x0b,
0x27, 0xfb, 0x0a, 0xeb, 0xdc, 0x02, 0xdf, 0x8a, 0xed, 0x43, 0xf5, 0xe0, 0xc6, 0x00, 0x4f, 0x70,
0xcc, 0xdf, 0x0b, 0x19, 0xd2, 0x71, 0x71, 0xe1, 0x38, 0x92, 0xdd, 0x44, 0x93, 0xc1, 0xb6, 0x04,
0x88, 0x45, 0x86, 0xc8, 0xfd, 0x35, 0xe5, 0x9a, 0x9a, 0x36, 0xf9, 0x37, 0x96, 0x51, 0x44, 0x97,
0x57, 0xaa, 0x0b, 0x5d, 0x93, 0x6f, 0x27, 0x09, 0x6a, 0xed, 0xac, 0xc0, 0xa6, 0xc4, 0xa2, 0x9a,
0x89, 0xd0, 0x40, 0x26, 0x90, 0x9d, 0x5d, 0x5b, 0x9f, 0xc1, 0xc5, 0xcc, 0x7c, 0x75, 0xe3, 0x9e,
0x61, 0x90, 0x5f, 0x5d, 0x4e, 0xfe, 0x7b, 0x05, 0x60, 0x63, 0x1c, 0x1f, 0xc9, 0x3e, 0xac, 0x07,
0x75, 0xd6, 0xfd, 0x69, 0x65, 0x8a, 0x1a, 0x33, 0x5c, 0x60, 0x47, 0x11, 0x36, 0x4a, 0x49, 0xc1,
0xa2, 0xc6, 0xbc, 0xcf, 0x1a, 0xab, 0xf7, 0x3a, 0xfe, 0xcd, 0xde, 0xfb, 0xc4, 0x23, 0xa7, 0x85,
0x0d, 0x20, 0xb6, 0xbe, 0x91, 0xcc, 0x9e, 0x2d, 0x01, 0xdd, 0x10, 0x40, 0x46, 0xe6, 0x3a, 0x14,
0x45, 0x8b, 0x4f, 0xac, 0xd8, 0x7f, 0x45, 0x3d, 0xd9, 0x91, 0xb5, 0x12, 0xe8, 0x13, 0x06, 0x64,
0x64, 0x21, 0x3d, 0x44, 0x2d, 0x87, 0x09, 0xd9, 0x8c, 0x20, 0x4b, 0xa0, 0x9c, 0x8c, 0xbd, 0x0f,
0x77, 0xf6, 0xc7, 0xc3, 0xa1, 0xd8, 0xe4, 0x79, 0x75, 0x89, 0x0d, 0x90, 0xd8, 0x47, 0xbe, 0x1f,
0x4f, 0x55, 0x24, 0x37, 0xf7, 0xdd, 0x6b, 0xef, 0x8b, 0xb0, 0xa0, 0x09, 0x2a, 0xcb, 0x46, 0xf4,
0x05, 0x51, 0x51, 0xbe, 0x9d, 0xfc, 0xc6, 0x25, 0xb8, 0x98, 0x99, 0x2f, 0xd8, 0xae, 0xbe, 0x07,
0xf5, 0xe4, 0x2d, 0x98, 0xcc, 0x42, 0xf5, 0xc9, 0xe6, 0x7e, 0xe7, 0x02, 0xfb, 0x78, 0xba, 0xb5,
0xdf, 0xa9, 0xac, 0xae, 0xc2, 0x7c, 0xee, 0x16, 0x8f, 0x34, 0xa0, 0x66, 0x6e, 0x6f, 0x6c, 0x3d,
0x47, 0xb2, 0x39, 0xa8, 0xef, 0x3d, 0x7e, 0x22, 0x46, 0x95, 0xd5, 0x4d, 0x68, 0x67, 0xd3, 0x1d,
0x69, 0xc2, 0xec, 0x26, 0x62, 0x9f, 0x6c, 0x6f, 0x21, 0x31, 0x0e, 0xcc, 0xa7, 0x7b, 0x7b, 0x3b,
0x7b, 0x0f, 0x3a, 0x15, 0x02, 0x30, 0xb3, 0xfd, 0xcd, 0x0e, 0x43, 0x4c, 0x31, 0xc4, 0xd3, 0xbd,
0x87, 0x7b, 0x8f, 0x7f, 0xb9, 0xd7, 0xa9, 0xae, 0xff, 0xb5, 0x0e, 0x6d, 0x53, 0x6c, 0xa1, 0x8f,
0xbe, 0xe0, 0x62, 0x03, 0x78, 0x0f, 0x66, 0x93, 0x87, 0xf6, 0x34, 0xb1, 0x66, 0xff, 0x0a, 0xe8,
0x75, 0x8b, 0x08, 0xa9, 0xb6, 0x0b, 0xe4, 0x39, 0x74, 0xf2, 0x6f, 0x4f, 0x24, 0xbd, 0x91, 0x99,
0xf0, 0xc8, 0xd5, 0xbb, 0x71, 0x0a, 0x85, 0x62, 0xdd, 0x87, 0x76, 0xf6, 0x55, 0x89, 0xa4, 0x65,
0x5b, 0xe9, 0x6b, 0x55, 0xef, 0xfa, 0x44, 0xbc, 0x2e, 0x6f, 0xfe, 0x3d, 0x49, 0x93, 0x77, 0xc2,
0x5b, 0x95, 0x26, 0xef, 0xc4, 0xc7, 0x28, 0xce, 0xba, 0xf0, 0xf2, 0xb2, 0x32, 0xf9, 0x82, 0xbd,
0xc0, 0x7a, 0xd2, 0xad, 0xbd, 0x50, 0x45, 0xf6, 0x0a, 0x95, 0xe8, 0x8f, 0x22, 0x25, 0xb7, 0xd3,
0x9a, 0x2a, 0xca, 0xef, 0x5e, 0x91, 0xe9, 0x33, 0x2c, 0xc7, 0xb2, 0x4d, 0x28, 0xb9, 0x9e, 0xb3,
0x4b, 0xbe, 0x39, 0xeb, 0xad, 0x4c, 0x26, 0xc8, 0xda, 0x4d, 0x6f, 0x31, 0x33, 0x76, 0x2b, 0xe9,
0x5b, 0x33, 0x76, 0x2b, 0xed, 0x4d, 0x2f, 0x90, 0x7d, 0x68, 0x65, 0x1a, 0x49, 0x72, 0x35, 0x63,
0xeb, 0x02, 0xcb, 0x6b, 0x93, 0xd0, 0xfa, 0xf6, 0x73, 0x4d, 0xa4, 0xb6, 0xfd, 0xf2, 0xde, 0xb4,
0xb7, 0x32, 0x99, 0x20, 0x6f, 0xab, 0xb4, 0xe2, 0xce, 0xd9, 0xaa, 0xd0, 0x77, 0xe5, 0x6c, 0x55,
0x2c, 0xd5, 0xa5, 0xad, 0x72, 0xa5, 0xf3, 0xf5, 0x89, 0x35, 0x4b, 0xd1, 0x56, 0xe5, 0x65, 0x10,
0xf2, 0xbd, 0x03, 0xd3, 0xac, 0xd4, 0x20, 0x69, 0x52, 0xd7, 0xaa, 0x9c, 0xde, 0xa5, 0x1c, 0x34,
0x99, 0x76, 0xb3, 0x72, 0xbb, 0xb2, 0xfe, 0x97, 0x29, 0x98, 0x13, 0x71, 0x50, 0x86, 0x92, 0x07,
0x00, 0x69, 0x36, 0x26, 0xbd, 0xcc, 0xa6, 0x32, 0x25, 0x45, 0xef, 0x4a, 0x29, 0x4e, 0x09, 0xf5,
0xb5, 0xac, 0x5f, 0xe4, 0x46, 0xaf, 0xe4, 0xc2, 0x6e, 0x66, 0x93, 0xef, 0x95, 0x23, 0x15, 0xaf,
0x2d, 0x68, 0xa8, 0x68, 0x4f, 0xb4, 0x24, 0x91, 0x4b, 0x55, 0xbd, 0x5e, 0x19, 0x4a, 0x97, 0x48,
0x0b, 0xef, 0x9a, 0x44, 0xc5, 0xa4, 0xa1, 0x49, 0x54, 0x92, 0x11, 0x8c, 0x0b, 0xff, 0x0b, 0x00,
0x00, 0xff, 0xff, 0x3e, 0xe9, 0xdd, 0x26, 0x8a, 0x25, 0x00, 0x00,
}

3
pkg/kubelet/api/v1alpha1/runtime/api.proto
View File

@ -495,6 +495,9 @@ message Container {
optional ContainerState state = 5;
// Labels are key value pairs that may be used to scope and select individual resources.
map<string, string> labels = 6;
// Annotations is an unstructured key value map that may be set by external
// tools to store and retrieve arbitrary metadata.
map<string, string> annotations = 7;
}
message ListContainersResponse {

49
pkg/kubelet/kuberuntime/helpers.go
View File

@ -40,10 +40,22 @@ const (
milliCPUToCPU = 1000
// 100000 is equivalent to 100ms
quotaPeriod = 100000
quotaPeriod = 100 * minQuotaPeriod
minQuotaPeriod = 1000
)
type podsByID []*kubecontainer.Pod
func (b podsByID) Len() int { return len(b) }
func (b podsByID) Swap(i, j int) { b[i], b[j] = b[j], b[i] }
func (b podsByID) Less(i, j int) bool { return b[i].ID < b[j].ID }
type containersByID []*kubecontainer.Container
func (b containersByID) Len() int { return len(b) }
func (b containersByID) Swap(i, j int) { b[i], b[j] = b[j], b[i] }
func (b containersByID) Less(i, j int) bool { return b[i].ID.ID < b[j].ID.ID }
// buildSandboxName creates a name which can be reversed to identify sandbox full name
func buildSandboxName(pod *api.Pod) string {
_, sandboxName, _ := buildKubeGenericName(pod, kubeSandboxNamePrefix)
@ -107,7 +119,23 @@ func parseContainerName(name string) (podName, podNamespace, podUID, containerNa
return parts[2], parts[3], parts[4], containerName, hash, nil
}
// toRuntimeProtocol converts api.Protocol to runtimeApi.Protocol
// toKubeContainerState converts runtimeApi.ContainerState to kubecontainer.ContainerState.
func toKubeContainerState(state runtimeApi.ContainerState) kubecontainer.ContainerState {
switch state {
case runtimeApi.ContainerState_CREATED:
return kubecontainer.ContainerStateCreated
case runtimeApi.ContainerState_RUNNING:
return kubecontainer.ContainerStateRunning
case runtimeApi.ContainerState_EXITED:
return kubecontainer.ContainerStateExited
case runtimeApi.ContainerState_UNKNOWN:
return kubecontainer.ContainerStateUnknown
}
return kubecontainer.ContainerStateUnknown
}
// toRuntimeProtocol converts api.Protocol to runtimeApi.Protocol.
func toRuntimeProtocol(protocol api.Protocol) runtimeApi.Protocol {
switch protocol {
case api.ProtocolTCP:
@ -120,6 +148,23 @@ func toRuntimeProtocol(protocol api.Protocol) runtimeApi.Protocol {
return runtimeApi.Protocol_TCP
}
// toKubeContainer converts runtimeApi.Container to kubecontainer.Container.
func (m *kubeGenericRuntimeManager) toKubeContainer(c *runtimeApi.Container) (*kubecontainer.Container, error) {
if c == nil || c.Id == nil || c.Image == nil || c.State == nil {
return nil, fmt.Errorf("unable to convert a nil pointer to a runtime container")
}
labeledInfo := getContainerInfoFromLabels(c.Labels)
annotatedInfo := getContainerInfoFromAnnotations(c.Annotations)
return &kubecontainer.Container{
ID: kubecontainer.ContainerID{Type: m.runtimeName, ID: c.GetId()},
Name: labeledInfo.ContainerName,
Image: c.Image.GetImage(),
Hash: annotatedInfo.Hash,
State: toKubeContainerState(c.GetState()),
}, nil
}
// milliCPUToShares converts milliCPU to CPU shares
func milliCPUToShares(milliCPU int64) int64 {
if milliCPU == 0 {

31
pkg/kubelet/kuberuntime/kuberuntime_container.go
View File

@ -191,6 +191,37 @@ func makeMounts(cid string, opts *kubecontainer.RunContainerOptions, container *
return volumeMounts
}
// getKubeletContainers lists containers managed by kubelet.
// The boolean parameter specifies whether returns all containers including
// those already exited and dead containers (used for garbage collection).
func (m *kubeGenericRuntimeManager) getKubeletContainers(allContainers bool) ([]*runtimeApi.Container, error) {
filter := &runtimeApi.ContainerFilter{
LabelSelector: map[string]string{kubernetesManagedLabel: "true"},
}
if !allContainers {
runningState := runtimeApi.ContainerState_RUNNING
filter.State = &runningState
}
containers, err := m.getContainersHelper(filter)
if err != nil {
glog.Errorf("getKubeletContainers failed: %v", err)
return nil, err
}
return containers, nil
}
// getContainers lists containers by filter.
func (m *kubeGenericRuntimeManager) getContainersHelper(filter *runtimeApi.ContainerFilter) ([]*runtimeApi.Container, error) {
resp, err := m.runtimeService.ListContainers(filter)
if err != nil {
return nil, err
}
return resp, err
}
// AttachContainer attaches to the container's console
func (m *kubeGenericRuntimeManager) AttachContainer(id kubecontainer.ContainerID, stdin io.Reader, stdout, stderr io.WriteCloser, tty bool, resize <-chan term.Size) (err error) {
return fmt.Errorf("not implemented")

8
pkg/kubelet/kuberuntime/kuberuntime_image_test.go
View File

@ -25,7 +25,7 @@ import (
)
func TestPullImage(t *testing.T) {
_, _, fakeManager, err := createTestFakeRuntimeManager()
_, _, fakeManager, err := createTestRuntimeManager()
assert.NoError(t, err)
err = fakeManager.PullImage(kubecontainer.ImageSpec{Image: "busybox"}, nil)
@ -38,7 +38,7 @@ func TestPullImage(t *testing.T) {
}
func TestListImages(t *testing.T) {
_, fakeImageService, fakeManager, err := createTestFakeRuntimeManager()
_, fakeImageService, fakeManager, err := createTestRuntimeManager()
assert.NoError(t, err)
images := []string{"1111", "2222", "3333"}
@ -56,7 +56,7 @@ func TestListImages(t *testing.T) {
}
func TestIsImagePresent(t *testing.T) {
_, fakeImageService, fakeManager, err := createTestFakeRuntimeManager()
_, fakeImageService, fakeManager, err := createTestRuntimeManager()
assert.NoError(t, err)
image := "busybox"
@ -67,7 +67,7 @@ func TestIsImagePresent(t *testing.T) {
}
func TestRemoveImage(t *testing.T) {
_, fakeImageService, fakeManager, err := createTestFakeRuntimeManager()
_, fakeImageService, fakeManager, err := createTestRuntimeManager()
assert.NoError(t, err)
err = fakeManager.PullImage(kubecontainer.ImageSpec{Image: "busybox"}, nil)

48
pkg/kubelet/kuberuntime/kuberuntime_manager.go
View File

@ -223,7 +223,53 @@ func (m *kubeGenericRuntimeManager) Status() error {
// specifies whether the runtime returns all containers including those already
// exited and dead containers (used for garbage collection).
func (m *kubeGenericRuntimeManager) GetPods(all bool) ([]*kubecontainer.Pod, error) {
return nil, fmt.Errorf("not implemented")
pods := make(map[kubetypes.UID]*kubecontainer.Pod)
sandboxes, err := m.getKubeletSandboxes(all)
if err != nil {
return nil, err
}
for _, s := range sandboxes {
name, namespace, uid, _ := parseSandboxName(s.GetName())
podUID := kubetypes.UID(uid)
pods[podUID] = &kubecontainer.Pod{
ID: podUID,
Name: name,
Namespace: namespace,
}
}
containers, err := m.getKubeletContainers(all)
if err != nil {
return nil, err
}
for _, c := range containers {
labelledInfo := getContainerInfoFromLabels(c.Labels)
pod, found := pods[labelledInfo.PodUID]
if !found {
pod = &kubecontainer.Pod{
ID: labelledInfo.PodUID,
Name: labelledInfo.PodName,
Namespace: labelledInfo.PodNamespace,
}
pods[labelledInfo.PodUID] = pod
}
converted, err := m.toKubeContainer(c)
if err != nil {
glog.Warningf("Convert %s container %v of pod %q failed: %v", m.runtimeName, c, labelledInfo.PodUID, err)
continue
}
pod.Containers = append(pod.Containers, converted)
}
// Convert map to list.
var result []*kubecontainer.Pod
for _, pod := range pods {
result = append(result, pod)
}
return result, nil
}
// SyncPod syncs the running pod into the desired pod.

180
pkg/kubelet/kuberuntime/kuberuntime_manager_test.go
View File

@ -17,17 +17,27 @@ limitations under the License.
package kuberuntime
import (
"reflect"
"sort"
"testing"
"github.com/stretchr/testify/assert"
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/apis/componentconfig"
apitest "k8s.io/kubernetes/pkg/kubelet/api/testing"
runtimeApi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
containertest "k8s.io/kubernetes/pkg/kubelet/container/testing"
"k8s.io/kubernetes/pkg/kubelet/network"
nettest "k8s.io/kubernetes/pkg/kubelet/network/testing"
kubetypes "k8s.io/kubernetes/pkg/types"
)
func createTestFakeRuntimeManager() (*apitest.FakeRuntimeService, *apitest.FakeImageService, *kubeGenericRuntimeManager, error) {
var (
fakeCreatedAt int64 = 1
)
func createTestRuntimeManager() (*apitest.FakeRuntimeService, *apitest.FakeImageService, *kubeGenericRuntimeManager, error) {
fakeRuntimeService := apitest.NewFakeRuntimeService()
fakeImageService := apitest.NewFakeImageService()
networkPlugin, _ := network.InitNetworkPlugin(
@ -42,13 +52,113 @@ func createTestFakeRuntimeManager() (*apitest.FakeRuntimeService, *apitest.FakeI
return fakeRuntimeService, fakeImageService, manager, err
}
func makeAndSetFakePod(m *kubeGenericRuntimeManager, fakeRuntime *apitest.FakeRuntimeService, pod *api.Pod) (*apitest.FakePodSandbox, []*apitest.FakeContainer, error) {
fakePodSandbox, err := makeFakePodSandbox(m, pod)
if err != nil {
return nil, nil, err
}
fakeContainers, err := makeFakeContainers(m, pod, pod.Spec.Containers)
if err != nil {
return nil, nil, err
}
fakeRuntime.SetFakeSandboxes([]*apitest.FakePodSandbox{fakePodSandbox})
fakeRuntime.SetFakeContainers(fakeContainers)
return fakePodSandbox, fakeContainers, nil
}
func makeFakePodSandbox(m *kubeGenericRuntimeManager, pod *api.Pod) (*apitest.FakePodSandbox, error) {
config, err := m.generatePodSandboxConfig(pod, "")
if err != nil {
return nil, err
}
podSandboxID := config.GetName()
readyState := runtimeApi.PodSandBoxState_READY
return &apitest.FakePodSandbox{
PodSandbox: runtimeApi.PodSandbox{
Id: &podSandboxID,
Name: config.Name,
State: &readyState,
CreatedAt: &fakeCreatedAt,
Labels: config.Labels,
},
Annotations: config.Annotations,
}, nil
}
func makeFakeContainer(m *kubeGenericRuntimeManager, pod *api.Pod, container api.Container, sandboxConfig *runtimeApi.PodSandboxConfig) (*apitest.FakeContainer, error) {
containerConfig, err := m.generateContainerConfig(&container, pod, 0, "")
if err != nil {
return nil, err
}
containerID := containerConfig.GetName()
runningState := runtimeApi.ContainerState_RUNNING
imageRef := containerConfig.Image.GetImage()
return &apitest.FakeContainer{
ContainerStatus: runtimeApi.ContainerStatus{
Id: &containerID,
Name: containerConfig.Name,
Image: containerConfig.Image,
ImageRef: &imageRef,
CreatedAt: &fakeCreatedAt,
State: &runningState,
Labels: containerConfig.Labels,
Annotations: containerConfig.Annotations,
},
SandboxID: sandboxConfig.GetName(),
}, nil
}
func makeFakeContainers(m *kubeGenericRuntimeManager, pod *api.Pod, containers []api.Container) ([]*apitest.FakeContainer, error) {
sandboxConfig, err := m.generatePodSandboxConfig(pod, "")
if err != nil {
return nil, err
}
result := make([]*apitest.FakeContainer, len(containers))
for idx, c := range containers {
containerWithState, err := makeFakeContainer(m, pod, c, sandboxConfig)
if err != nil {
return nil, err
}
result[idx] = containerWithState
}
return result, nil
}
// verifyPods returns true if the two pod slices are equal.
func verifyPods(a, b []*kubecontainer.Pod) bool {
if len(a) != len(b) {
return false
}
// Sort the containers within a pod.
for i := range a {
sort.Sort(containersByID(a[i].Containers))
}
for i := range b {
sort.Sort(containersByID(b[i].Containers))
}
// Sort the pods by UID.
sort.Sort(podsByID(a))
sort.Sort(podsByID(b))
return reflect.DeepEqual(a, b)
}
func TestNewKubeRuntimeManager(t *testing.T) {
_, _, _, err := createTestFakeRuntimeManager()
_, _, _, err := createTestRuntimeManager()
assert.NoError(t, err)
}
func TestVersion(t *testing.T) {
_, _, m, err := createTestFakeRuntimeManager()
_, _, m, err := createTestRuntimeManager()
assert.NoError(t, err)
version, err := m.Version()
@ -57,9 +167,71 @@ func TestVersion(t *testing.T) {
}
func TestContainerRuntimeType(t *testing.T) {
_, _, m, err := createTestFakeRuntimeManager()
_, _, m, err := createTestRuntimeManager()
assert.NoError(t, err)
runtimeType := m.Type()
assert.Equal(t, "fakeRuntime", runtimeType)
}
func TestGetPods(t *testing.T) {
fakeRuntime, _, m, err := createTestRuntimeManager()
assert.NoError(t, err)
pod := &api.Pod{
ObjectMeta: api.ObjectMeta{
UID: "12345678",
Name: "foo",
Namespace: "new",
},
Spec: api.PodSpec{
Containers: []api.Container{
{
Name: "foo1",
Image: "busybox",
},
{
Name: "foo2",
Image: "busybox",
},
},
},
}
// Set fake sandbox and fake containers to fakeRuntime.
_, fakeContainers, err := makeAndSetFakePod(m, fakeRuntime, pod)
assert.NoError(t, err)
// Convert the fakeContainers to kubecontainer.Container
containers := make([]*kubecontainer.Container, len(fakeContainers))
for i := range containers {
fakeContainer := fakeContainers[i]
c, err := m.toKubeContainer(&runtimeApi.Container{
Id: fakeContainer.Id,
Name: fakeContainer.Name,
State: fakeContainer.State,
Image: fakeContainer.Image,
ImageRef: fakeContainer.ImageRef,
Labels: fakeContainer.Labels,
})
if err != nil {
t.Fatalf("unexpected error %v", err)
}
containers[i] = c
}
expected := []*kubecontainer.Pod{
{
ID: kubetypes.UID("12345678"),
Name: "foo",
Namespace: "new",
Containers: []*kubecontainer.Container{containers[0], containers[1]},
},
}
actual, err := m.GetPods(false)
assert.NoError(t, err)
if !verifyPods(expected, actual) {
t.Errorf("expected %#v, got %#v", expected, actual)
}
}

30
pkg/kubelet/kuberuntime/kuberuntime_sandbox.go
View File

@ -17,6 +17,7 @@ limitations under the License.
package kuberuntime
import (
"github.com/golang/glog"
"k8s.io/kubernetes/pkg/api"
runtimeApi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
@ -105,3 +106,32 @@ func generatePodSandboxLinuxConfig(pod *api.Pod, cgroupParent string) *runtimeAp
return linuxPodSandboxConfig
}
// getKubeletSandboxes lists all (or just the running) sandboxes managed by kubelet.
func (m *kubeGenericRuntimeManager) getKubeletSandboxes(all bool) ([]*runtimeApi.PodSandbox, error) {
var filter *runtimeApi.PodSandboxFilter
if !all {
readyState := runtimeApi.PodSandBoxState_READY
filter = &runtimeApi.PodSandboxFilter{
State: &readyState,
}
}
resp, err := m.runtimeService.ListPodSandbox(filter)
if err != nil {
glog.Errorf("ListPodSandbox failed: %v", err)
return nil, err
}
result := []*runtimeApi.PodSandbox{}
for _, s := range resp {
if !isManagedByKubelet(s.Labels) {
glog.V(5).Infof("Sandbox %s is not managed by kubelet", s.GetName())
continue
}
result = append(result, s)
}
return result, nil
}

16
pkg/kubelet/kuberuntime/labels.go
View File

@ -39,6 +39,9 @@ const (
containerTerminationMessagePathLabel = "io.kubernetes.container.terminationMessagePath"
containerPreStopHandlerLabel = "io.kubernetes.container.preStopHandler"
containerPortsLabel = "io.kubernetes.container.ports"
// kubernetesManagedLabel is used to distinguish whether a container/sandbox is managed by kubelet or not
kubernetesManagedLabel = "io.kubernetes.managed"
)
type labeledPodSandboxInfo struct {
@ -83,6 +86,7 @@ func newPodLabels(pod *api.Pod) map[string]string {
labels[types.KubernetesPodNameLabel] = pod.Name
labels[types.KubernetesPodNamespaceLabel] = pod.Namespace
labels[types.KubernetesPodUIDLabel] = string(pod.UID)
labels[kubernetesManagedLabel] = "true"
return labels
}
@ -99,6 +103,7 @@ func newContainerLabels(container *api.Container, pod *api.Pod) map[string]strin
labels[types.KubernetesPodNamespaceLabel] = pod.Namespace
labels[types.KubernetesPodUIDLabel] = string(pod.UID)
labels[types.KubernetesContainerNameLabel] = container.Name
labels[kubernetesManagedLabel] = "true"
return labels
}
@ -150,7 +155,7 @@ func getPodSandboxInfoFromLabels(labels map[string]string) *labeledPodSandboxInf
// Remain only labels from api.Pod
for k, v := range labels {
if k != types.KubernetesPodNameLabel && k != types.KubernetesPodNamespaceLabel && k != types.KubernetesPodUIDLabel {
if k != types.KubernetesPodNameLabel && k != types.KubernetesPodNamespaceLabel && k != types.KubernetesPodUIDLabel && k != kubernetesManagedLabel {
podSandboxInfo.Labels[k] = v
}
}
@ -175,6 +180,15 @@ func getContainerInfoFromLabels(labels map[string]string) *labeledContainerInfo
}
}
// isManagedByKubelet returns true is the sandbox/container is managed by kubelet.
func isManagedByKubelet(labels map[string]string) bool {
if _, ok := labels[kubernetesManagedLabel]; ok {
return true
}
return false
}
// getContainerInfoFromAnnotations gets annotatedContainerInfo from annotations.
func getContainerInfoFromAnnotations(annotations map[string]string) *annotatedContainerInfo {
var err error