Mirroristas/etcd
2
0
Fork 0
mirror of https://github.com/etcd-io/etcd.git synced 2024-09-27 06:25:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #9708 from gyuho/functional-test

Browse Source 
functional: configure KV stresser weights
This commit is contained in:
Gyuho Lee 2018-05-08 16:50:09 -07:00 committed by GitHub
commit ef23564ebf
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 619 additions and 387 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
functional.yaml
View File

@ -212,9 +212,25 @@ tester-config:
runner-exec-path: ./bin/etcd-runner
external-exec-path: ""
# make up ±70% of workloads with writes
stressers:
- KV
- LEASE
- type: KV_WRITE_SMALL
weight: 0.35
- type: KV_WRITE_LARGE
weight: 0.002
- type: KV_READ_ONE_KEY
weight: 0.07
- type: KV_READ_RANGE
weight: 0.07
- type: KV_DELETE_ONE_KEY
weight: 0.07
- type: KV_DELETE_RANGE
weight: 0.07
- type: KV_TXN_WRITE_DELETE
weight: 0.35
- type: LEASE
weight: 0.0
# - ELECTION_RUNNER
# - WATCH_RUNNER
# - LOCK_RACER_RUNNER

698
functional/rpcpb/rpc.pb.go
View File

@ -13,6 +13,7 @@
Response
Member
Tester
Stresser
Etcd
*/
package rpcpb
@ -25,6 +26,8 @@ import _ "github.com/gogo/protobuf/gogoproto"
import context "golang.org/x/net/context"
import grpc "google.golang.org/grpc"
import binary "encoding/binary"
import io "io"
// Reference imports to suppress errors if they are not otherwise used.
@ -38,6 +41,84 @@ var _ = math.Inf
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type StresserType int32
const (
StresserType_KV_WRITE_SMALL StresserType = 0
StresserType_KV_WRITE_LARGE StresserType = 1
StresserType_KV_READ_ONE_KEY StresserType = 2
StresserType_KV_READ_RANGE StresserType = 3
StresserType_KV_DELETE_ONE_KEY StresserType = 4
StresserType_KV_DELETE_RANGE StresserType = 5
StresserType_KV_TXN_WRITE_DELETE StresserType = 6
StresserType_LEASE StresserType = 10
StresserType_ELECTION_RUNNER StresserType = 20
StresserType_WATCH_RUNNER StresserType = 31
StresserType_LOCK_RACER_RUNNER StresserType = 41
StresserType_LEASE_RUNNER StresserType = 51
)
var StresserType_name = map[int32]string{
0: "KV_WRITE_SMALL",
1: "KV_WRITE_LARGE",
2: "KV_READ_ONE_KEY",
3: "KV_READ_RANGE",
4: "KV_DELETE_ONE_KEY",
5: "KV_DELETE_RANGE",
6: "KV_TXN_WRITE_DELETE",
10: "LEASE",
20: "ELECTION_RUNNER",
31: "WATCH_RUNNER",
41: "LOCK_RACER_RUNNER",
51: "LEASE_RUNNER",
}
var StresserType_value = map[string]int32{
"KV_WRITE_SMALL": 0,
"KV_WRITE_LARGE": 1,
"KV_READ_ONE_KEY": 2,
"KV_READ_RANGE": 3,
"KV_DELETE_ONE_KEY": 4,
"KV_DELETE_RANGE": 5,
"KV_TXN_WRITE_DELETE": 6,
"LEASE": 10,
"ELECTION_RUNNER": 20,
"WATCH_RUNNER": 31,
"LOCK_RACER_RUNNER": 41,
"LEASE_RUNNER": 51,
}
func (x StresserType) String() string {
return proto.EnumName(StresserType_name, int32(x))
}
func (StresserType) EnumDescriptor() ([]byte, []int) { return fileDescriptorRpc, []int{0} }
type Checker int32
const (
Checker_KV_HASH Checker = 0
Checker_LEASE_EXPIRE Checker = 1
Checker_RUNNER Checker = 2
Checker_NO_CHECK Checker = 3
)
var Checker_name = map[int32]string{
0: "KV_HASH",
1: "LEASE_EXPIRE",
2: "RUNNER",
3: "NO_CHECK",
}
var Checker_value = map[string]int32{
"KV_HASH": 0,
"LEASE_EXPIRE": 1,
"RUNNER": 2,
"NO_CHECK": 3,
}
func (x Checker) String() string {
return proto.EnumName(Checker_name, int32(x))
}
func (Checker) EnumDescriptor() ([]byte, []int) { return fileDescriptorRpc, []int{1} }
type Operation int32
const (
@ -118,7 +199,7 @@ var Operation_value = map[string]int32{
func (x Operation) String() string {
return proto.EnumName(Operation_name, int32(x))
}
func (Operation) EnumDescriptor() ([]byte, []int) { return fileDescriptorRpc, []int{0} }
func (Operation) EnumDescriptor() ([]byte, []int) { return fileDescriptorRpc, []int{2} }
// Case defines various system faults or test case in distributed systems,
// in order to verify correct behavior of etcd servers and clients.
@ -505,67 +586,7 @@ var Case_value = map[string]int32{
func (x Case) String() string {
return proto.EnumName(Case_name, int32(x))
}
func (Case) EnumDescriptor() ([]byte, []int) { return fileDescriptorRpc, []int{1} }
type Stresser int32
const (
Stresser_KV Stresser = 0
Stresser_LEASE Stresser = 1
Stresser_ELECTION_RUNNER Stresser = 2
Stresser_WATCH_RUNNER Stresser = 3
Stresser_LOCK_RACER_RUNNER Stresser = 4
Stresser_LEASE_RUNNER Stresser = 5
)
var Stresser_name = map[int32]string{
0: "KV",
1: "LEASE",
2: "ELECTION_RUNNER",
3: "WATCH_RUNNER",
4: "LOCK_RACER_RUNNER",
5: "LEASE_RUNNER",
}
var Stresser_value = map[string]int32{
"KV": 0,
"LEASE": 1,
"ELECTION_RUNNER": 2,
"WATCH_RUNNER": 3,
"LOCK_RACER_RUNNER": 4,
"LEASE_RUNNER": 5,
}
func (x Stresser) String() string {
return proto.EnumName(Stresser_name, int32(x))
}
func (Stresser) EnumDescriptor() ([]byte, []int) { return fileDescriptorRpc, []int{2} }
type Checker int32
const (
Checker_KV_HASH Checker = 0
Checker_LEASE_EXPIRE Checker = 1
Checker_RUNNER Checker = 2
Checker_NO_CHECK Checker = 3
)
var Checker_name = map[int32]string{
0: "KV_HASH",
1: "LEASE_EXPIRE",
2: "RUNNER",
3: "NO_CHECK",
}
var Checker_value = map[string]int32{
"KV_HASH": 0,
"LEASE_EXPIRE": 1,
"RUNNER": 2,
"NO_CHECK": 3,
}
func (x Checker) String() string {
return proto.EnumName(Checker_name, int32(x))
}
func (Checker) EnumDescriptor() ([]byte, []int) { return fileDescriptorRpc, []int{3} }
func (Case) EnumDescriptor() ([]byte, []int) { return fileDescriptorRpc, []int{3} }
type Request struct {
Operation Operation `protobuf:"varint,1,opt,name=Operation,proto3,enum=rpcpb.Operation" json:"Operation,omitempty"`
@ -699,7 +720,7 @@ type Tester struct {
ExternalExecPath string `protobuf:"bytes,42,opt,name=ExternalExecPath,proto3" json:"ExternalExecPath,omitempty" yaml:"external-exec-path"`
// Stressers is the list of stresser types:
// KV, LEASE, ELECTION_RUNNER, WATCH_RUNNER, LOCK_RACER_RUNNER, LEASE_RUNNER.
Stressers []string `protobuf:"bytes,101,rep,name=Stressers" json:"Stressers,omitempty" yaml:"stressers"`
Stressers []*Stresser `protobuf:"bytes,101,rep,name=Stressers" json:"Stressers,omitempty" yaml:"stressers"`
// Checkers is the list of consistency checker types:
// KV_HASH, LEASE_EXPIRE, NO_CHECK, RUNNER.
// Leave empty to skip consistency checks.
@ -728,6 +749,16 @@ func (m *Tester) String() string { return proto.CompactTextString(m)
func (*Tester) ProtoMessage() {}
func (*Tester) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{4} }
type Stresser struct {
Type string `protobuf:"bytes,1,opt,name=Type,proto3" json:"Type,omitempty" yaml:"type"`
Weight float64 `protobuf:"fixed64,2,opt,name=Weight,proto3" json:"Weight,omitempty" yaml:"weight"`
}
func (m *Stresser) Reset() { *m = Stresser{} }
func (m *Stresser) String() string { return proto.CompactTextString(m) }
func (*Stresser) ProtoMessage() {}
func (*Stresser) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{5} }
type Etcd struct {
Name string `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty" yaml:"name"`
DataDir string `protobuf:"bytes,2,opt,name=DataDir,proto3" json:"DataDir,omitempty" yaml:"data-dir"`
@ -768,7 +799,7 @@ type Etcd struct {
func (m *Etcd) Reset() { *m = Etcd{} }
func (m *Etcd) String() string { return proto.CompactTextString(m) }
func (*Etcd) ProtoMessage() {}
func (*Etcd) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{5} }
func (*Etcd) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{6} }
func init() {
proto.RegisterType((*Request)(nil), "rpcpb.Request")
@ -776,11 +807,12 @@ func init() {
proto.RegisterType((*Response)(nil), "rpcpb.Response")
proto.RegisterType((*Member)(nil), "rpcpb.Member")
proto.RegisterType((*Tester)(nil), "rpcpb.Tester")
proto.RegisterType((*Stresser)(nil), "rpcpb.Stresser")
proto.RegisterType((*Etcd)(nil), "rpcpb.Etcd")
proto.RegisterEnum("rpcpb.StresserType", StresserType_name, StresserType_value)
proto.RegisterEnum("rpcpb.Checker", Checker_name, Checker_value)
proto.RegisterEnum("rpcpb.Operation", Operation_name, Operation_value)
proto.RegisterEnum("rpcpb.Case", Case_name, Case_value)
proto.RegisterEnum("rpcpb.Stresser", Stresser_name, Stresser_value)
proto.RegisterEnum("rpcpb.Checker", Checker_name, Checker_value)
}
// Reference imports to suppress errors if they are not otherwise used.
@ -1427,20 +1459,17 @@ func (m *Tester) MarshalTo(dAtA []byte) (int, error) {
i += copy(dAtA[i:], m.ExternalExecPath)
}
if len(m.Stressers) > 0 {
for _, s := range m.Stressers {
for _, msg := range m.Stressers {
dAtA[i] = 0xaa
i++
dAtA[i] = 0x6
i++
l = len(s)
for l >= 1<<7 {
dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
l >>= 7
i++
i = encodeVarintRpc(dAtA, i, uint64(msg.Size()))
n, err := msg.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
dAtA[i] = uint8(l)
i++
i += copy(dAtA[i:], s)
i += n
}
}
if len(m.Checkers) > 0 {
@ -1512,6 +1541,36 @@ func (m *Tester) MarshalTo(dAtA []byte) (int, error) {
return i, nil
}
func (m *Stresser) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *Stresser) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if len(m.Type) > 0 {
dAtA[i] = 0xa
i++
i = encodeVarintRpc(dAtA, i, uint64(len(m.Type)))
i += copy(dAtA[i:], m.Type)
}
if m.Weight != 0 {
dAtA[i] = 0x11
i++
binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Weight))))
i += 8
}
return i, nil
}
func (m *Etcd) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@ -2065,8 +2124,8 @@ func (m *Tester) Size() (n int) {
n += 2 + l + sovRpc(uint64(l))
}
if len(m.Stressers) > 0 {
for _, s := range m.Stressers {
l = len(s)
for _, e := range m.Stressers {
l = e.Size()
n += 2 + l + sovRpc(uint64(l))
}
}
@ -2100,6 +2159,19 @@ func (m *Tester) Size() (n int) {
return n
}
func (m *Stresser) Size() (n int) {
var l int
_ = l
l = len(m.Type)
if l > 0 {
n += 1 + l + sovRpc(uint64(l))
}
if m.Weight != 0 {
n += 9
}
return n
}
func (m *Etcd) Size() (n int) {
var l int
_ = l
@ -3917,7 +3989,7 @@ func (m *Tester) Unmarshal(dAtA []byte) error {
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Stressers", wireType)
}
var stringLen uint64
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowRpc
@ -3927,20 +3999,22 @@ func (m *Tester) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
if msglen < 0 {
return ErrInvalidLengthRpc
}
postIndex := iNdEx + intStringLen
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Stressers = append(m.Stressers, string(dAtA[iNdEx:postIndex]))
m.Stressers = append(m.Stressers, &Stresser{})
if err := m.Stressers[len(m.Stressers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 102:
if wireType != 2 {
@ -4125,6 +4199,96 @@ func (m *Tester) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *Stresser) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowRpc
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: Stresser: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Stresser: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowRpc
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthRpc
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Type = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 1 {
return fmt.Errorf("proto: wrong wireType = %d for field Weight", wireType)
}
var v uint64
if (iNdEx + 8) > l {
return io.ErrUnexpectedEOF
}
v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
iNdEx += 8
m.Weight = float64(math.Float64frombits(v))
default:
iNdEx = preIndex
skippy, err := skipRpc(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthRpc
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *Etcd) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
@ -5021,184 +5185,192 @@ var (
func init() { proto.RegisterFile("rpcpb/rpc.proto", fileDescriptorRpc) }
var fileDescriptorRpc = []byte{
// 2854 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x59, 0xcb, 0x77, 0xdb, 0xc6,
0xf5, 0x36, 0x45, 0x49, 0x96, 0xae, 0x5e, 0xd4, 0xc8, 0xb2, 0xe1, 0x97, 0x20, 0xc3, 0x71, 0x7e,
0xb2, 0x12, 0xd8, 0xf9, 0xd9, 0x39, 0x79, 0x38, 0x4d, 0x1c, 0x90, 0x82, 0x2d, 0x56, 0x10, 0x49,
0x0f, 0x21, 0xdb, 0x59, 0xf1, 0x40, 0xe4, 0x48, 0xe2, 0x31, 0x05, 0x30, 0xc0, 0xd0, 0x91, 0xb2,
0xee, 0x39, 0xdd, 0xb6, 0xe9, 0xe3, 0xb4, 0xe7, 0x74, 0xd5, 0x75, 0xd3, 0xfe, 0x1b, 0xce, 0xab,
0x4d, 0xdb, 0x55, 0xbb, 0xe0, 0x69, 0xd3, 0x4d, 0x57, 0x5d, 0xf0, 0xf4, 0xbd, 0xea, 0x99, 0x19,
0x40, 0x1c, 0x00, 0xa4, 0xa4, 0x95, 0x3d, 0xf7, 0x7e, 0xdf, 0x37, 0x77, 0xe6, 0xce, 0xcc, 0xbd,
0xa0, 0x60, 0xce, 0x6f, 0xd7, 0xdb, 0xdb, 0xb7, 0xfd, 0x76, 0xfd, 0x56, 0xdb, 0xf7, 0xa8, 0x87,
0xc6, 0xb8, 0xe1, 0x92, 0xbe, 0xdb, 0xa4, 0x7b, 0x9d, 0xed, 0x5b, 0x75, 0x6f, 0xff, 0xf6, 0xae,
0xb7, 0xeb, 0xdd, 0xe6, 0xde, 0xed, 0xce, 0x0e, 0x1f, 0xf1, 0x01, 0xff, 0x9f, 0x60, 0x69, 0xdf,
0xcd, 0xc0, 0x59, 0x4c, 0x3e, 0xec, 0x90, 0x80, 0xa2, 0x5b, 0x30, 0x59, 0x6e, 0x13, 0xdf, 0xa1,
0x4d, 0xcf, 0x55, 0x32, 0xcb, 0x99, 0x95, 0xd9, 0x3b, 0xb9, 0x5b, 0x5c, 0xf5, 0xd6, 0x91, 0x1d,
0xf7, 0x21, 0xe8, 0x06, 0x8c, 0x6f, 0x92, 0xfd, 0x6d, 0xe2, 0x2b, 0x23, 0xcb, 0x99, 0x95, 0xa9,
0x3b, 0x33, 0x21, 0x58, 0x18, 0x71, 0xe8, 0x64, 0x30, 0x9b, 0x04, 0x94, 0xf8, 0x4a, 0x36, 0x06,
0x13, 0x46, 0x1c, 0x3a, 0xb5, 0xbf, 0x8e, 0xc0, 0x74, 0xd5, 0x75, 0xda, 0xc1, 0x9e, 0x47, 0x8b,
0xee, 0x8e, 0x87, 0x96, 0x00, 0x84, 0x42, 0xc9, 0xd9, 0x27, 0x3c, 0x9e, 0x49, 0x2c, 0x59, 0xd0,
0x2a, 0xe4, 0xc4, 0xa8, 0xd0, 0x6a, 0x12, 0x97, 0x6e, 0x61, 0x2b, 0x50, 0x46, 0x96, 0xb3, 0x2b,
0x93, 0x38, 0x65, 0x47, 0x5a, 0x5f, 0xbb, 0xe2, 0xd0, 0x3d, 0x1e, 0xc9, 0x24, 0x8e, 0xd9, 0x98,
0x5e, 0x34, 0x7e, 0xd0, 0x6c, 0x91, 0x6a, 0xf3, 0x63, 0xa2, 0x8c, 0x72, 0x5c, 0xca, 0x8e, 0x5e,
0x85, 0xf9, 0xc8, 0x66, 0x7b, 0xd4, 0x69, 0x71, 0xf0, 0x18, 0x07, 0xa7, 0x1d, 0xb2, 0x32, 0x37,
0x6e, 0x90, 0x43, 0x65, 0x7c, 0x39, 0xb3, 0x92, 0xc5, 0x29, 0xbb, 0x1c, 0xe9, 0xba, 0x13, 0xec,
0x29, 0x67, 0x39, 0x2e, 0x66, 0x93, 0xf5, 0x30, 0x79, 0xde, 0x0c, 0x58, 0xbe, 0x26, 0xe2, 0x7a,
0x91, 0x1d, 0x21, 0x18, 0xb5, 0x3d, 0xef, 0x99, 0x32, 0xc9, 0x83, 0xe3, 0xff, 0xd7, 0x7e, 0x96,
0x81, 0x09, 0x4c, 0x82, 0xb6, 0xe7, 0x06, 0x04, 0x29, 0x70, 0xb6, 0xda, 0xa9, 0xd7, 0x49, 0x10,
0xf0, 0x3d, 0x9e, 0xc0, 0xd1, 0x10, 0x9d, 0x87, 0xf1, 0x2a, 0x75, 0x68, 0x27, 0xe0, 0xf9, 0x9d,
0xc4, 0xe1, 0x48, 0xca, 0x7b, 0xf6, 0xb8, 0xbc, 0xbf, 0x19, 0xcf, 0x27, 0xdf, 0xcb, 0xa9, 0x3b,
0x0b, 0x21, 0x58, 0x76, 0xe1, 0x18, 0x50, 0xfb, 0x64, 0x3a, 0x9a, 0x00, 0xbd, 0x06, 0x13, 0x26,
0xad, 0x37, 0xcc, 0x03, 0x52, 0x17, 0x27, 0x20, 0x7f, 0xae, 0xd7, 0x55, 0x73, 0x87, 0xce, 0x7e,
0xeb, 0x9e, 0x46, 0x68, 0xbd, 0xa1, 0x93, 0x03, 0x52, 0xd7, 0xf0, 0x11, 0x0a, 0xdd, 0x85, 0x49,
0x63, 0x97, 0xb8, 0xd4, 0x68, 0x34, 0x7c, 0x65, 0x8a, 0x53, 0x16, 0x7b, 0x5d, 0x75, 0x5e, 0x50,
0x1c, 0xe6, 0xd2, 0x9d, 0x46, 0xc3, 0xd7, 0x70, 0x1f, 0x87, 0x2c, 0x98, 0x7f, 0xe0, 0x34, 0x5b,
0x6d, 0xaf, 0xe9, 0xd2, 0x75, 0xdb, 0xae, 0x70, 0xf2, 0x34, 0x27, 0x2f, 0xf5, 0xba, 0xea, 0x25,
0x41, 0xde, 0x89, 0x20, 0xfa, 0x1e, 0xa5, 0xed, 0x50, 0x25, 0x4d, 0x44, 0x3a, 0x9c, 0xcd, 0x3b,
0x01, 0x59, 0x6b, 0xfa, 0x0a, 0xe1, 0x1a, 0x0b, 0xbd, 0xae, 0x3a, 0x27, 0x34, 0xb6, 0x9d, 0x80,
0xe8, 0x8d, 0xa6, 0xaf, 0xe1, 0x08, 0x83, 0x1e, 0xc2, 0x1c, 0x8b, 0x5e, 0x9c, 0xd6, 0x8a, 0xef,
0x1d, 0x1c, 0x2a, 0x9f, 0xf1, 0x4c, 0xe4, 0xaf, 0xf4, 0xba, 0xaa, 0x22, 0xad, 0xb5, 0xce, 0x21,
0x7a, 0x9b, 0x61, 0x34, 0x9c, 0x64, 0x21, 0x03, 0x66, 0x98, 0xa9, 0x42, 0x88, 0x2f, 0x64, 0x3e,
0x17, 0x32, 0x97, 0x7a, 0x5d, 0xf5, 0xbc, 0x24, 0xd3, 0x26, 0xc4, 0x8f, 0x44, 0xe2, 0x0c, 0x54,
0x01, 0xd4, 0x57, 0x35, 0xdd, 0x06, 0x5f, 0x98, 0xf2, 0x29, 0xcf, 0x7f, 0x5e, 0xed, 0x75, 0xd5,
0xcb, 0xe9, 0x70, 0x48, 0x08, 0xd3, 0xf0, 0x00, 0x2e, 0xfa, 0x7f, 0x18, 0x65, 0x56, 0xe5, 0x97,
0xe2, 0x8d, 0x98, 0x0a, 0xd3, 0xcf, 0x6c, 0xf9, 0xb9, 0x5e, 0x57, 0x9d, 0xea, 0x0b, 0x6a, 0x98,
0x43, 0x51, 0x1e, 0x16, 0xd9, 0xbf, 0x65, 0xb7, 0x7f, 0x98, 0x03, 0xea, 0xf9, 0x44, 0xf9, 0x55,
0x5a, 0x03, 0x0f, 0x86, 0xa2, 0x35, 0x98, 0x15, 0x81, 0x14, 0x88, 0x4f, 0xd7, 0x1c, 0xea, 0x28,
0xdf, 0xe7, 0x77, 0x3e, 0x7f, 0xb9, 0xd7, 0x55, 0x2f, 0x88, 0x39, 0xc3, 0xf8, 0xeb, 0xc4, 0xa7,
0x7a, 0xc3, 0xa1, 0x8e, 0x86, 0x13, 0x9c, 0xb8, 0x0a, 0x7f, 0x38, 0x3e, 0x39, 0x56, 0xa5, 0xed,
0xd0, 0xbd, 0x98, 0x0a, 0x7f, 0x58, 0x0c, 0x98, 0x11, 0x96, 0x0d, 0x72, 0xc8, 0x43, 0xf9, 0x81,
0x10, 0x91, 0xf2, 0x12, 0x8a, 0x3c, 0x23, 0x87, 0x61, 0x24, 0x71, 0x46, 0x4c, 0x82, 0xc7, 0xf1,
0xc3, 0xe3, 0x24, 0x44, 0x18, 0x71, 0x06, 0xb2, 0x61, 0x41, 0x18, 0x6c, 0xbf, 0x13, 0x50, 0xd2,
0x28, 0x18, 0x3c, 0x96, 0x1f, 0x09, 0xa1, 0x6b, 0xbd, 0xae, 0x7a, 0x35, 0x26, 0x44, 0x05, 0x4c,
0xaf, 0x3b, 0x61, 0x48, 0x83, 0xe8, 0x03, 0x54, 0x79, 0x78, 0x3f, 0x3e, 0x85, 0xaa, 0x88, 0x72,
0x10, 0x1d, 0xbd, 0x07, 0xd3, 0xec, 0x4c, 0x1e, 0xe5, 0xee, 0x1f, 0x42, 0xee, 0x62, 0xaf, 0xab,
0x2e, 0x0a, 0x39, 0x7e, 0x86, 0xa5, 0xcc, 0xc5, 0xf0, 0x32, 0x9f, 0x87, 0xf3, 0xcf, 0x63, 0xf8,
0x22, 0x8c, 0x18, 0x1e, 0xbd, 0x03, 0x53, 0x6c, 0x1c, 0xe5, 0xeb, 0x5f, 0x82, 0xae, 0xf4, 0xba,
0xea, 0x39, 0x89, 0xde, 0xcf, 0x96, 0x8c, 0x96, 0xc8, 0x7c, 0xee, 0x7f, 0x0f, 0x27, 0x8b, 0xa9,
0x65, 0x34, 0x2a, 0xc1, 0x3c, 0x1b, 0xc6, 0x73, 0xf4, 0x9f, 0x6c, 0xf2, 0xfe, 0x71, 0x89, 0x54,
0x86, 0xd2, 0xd4, 0x94, 0x1e, 0x0f, 0xe9, 0xbf, 0x27, 0xea, 0x89, 0xc8, 0xd2, 0x54, 0xf4, 0x6e,
0xa2, 0x90, 0xfe, 0x61, 0x34, 0xb9, 0xba, 0x20, 0x74, 0x47, 0x1b, 0x1b, 0xab, 0xb1, 0x6f, 0x25,
0x6a, 0xc2, 0x1f, 0x4f, 0x5d, 0x14, 0x7e, 0x3e, 0x1d, 0xb5, 0x11, 0xec, 0x7d, 0x65, 0x6b, 0x63,
0xef, 0x6b, 0x26, 0xf9, 0xbe, 0xb2, 0x8d, 0x08, 0xdf, 0xd7, 0x10, 0x83, 0x5e, 0x85, 0xb3, 0x25,
0x42, 0x3f, 0xf2, 0xfc, 0x67, 0xa2, 0x8e, 0xe5, 0x51, 0xaf, 0xab, 0xce, 0x0a, 0xb8, 0x2b, 0x1c,
0x1a, 0x8e, 0x20, 0xe8, 0x3a, 0x8c, 0xf2, 0xd7, 0x5f, 0x6c, 0x91, 0xf4, 0x42, 0x89, 0xe7, 0x9e,
0x3b, 0x51, 0x01, 0x66, 0xd7, 0x48, 0xcb, 0x39, 0xb4, 0x1c, 0x4a, 0xdc, 0xfa, 0xe1, 0x66, 0xc0,
0x2b, 0xcd, 0x8c, 0xfc, 0x2c, 0x34, 0x98, 0x5f, 0x6f, 0x09, 0x80, 0xbe, 0x1f, 0x68, 0x38, 0x41,
0x41, 0xdf, 0x86, 0x5c, 0xdc, 0x82, 0x9f, 0xf3, 0x9a, 0x33, 0x23, 0xd7, 0x9c, 0xa4, 0x8c, 0xee,
0x3f, 0xd7, 0x70, 0x8a, 0x87, 0x3e, 0x80, 0xc5, 0xad, 0x76, 0xc3, 0xa1, 0xa4, 0x91, 0x88, 0x6b,
0x86, 0x0b, 0x5e, 0xef, 0x75, 0x55, 0x55, 0x08, 0x76, 0x04, 0x4c, 0x4f, 0xc7, 0x37, 0x58, 0x01,
0xbd, 0x01, 0x80, 0xbd, 0x8e, 0xdb, 0xb0, 0x9a, 0xfb, 0x4d, 0xaa, 0x2c, 0x2e, 0x67, 0x56, 0xc6,
0xf2, 0xe7, 0x7b, 0x5d, 0x15, 0x09, 0x3d, 0x9f, 0xf9, 0xf4, 0x16, 0x73, 0x6a, 0x58, 0x42, 0xa2,
0x3c, 0xcc, 0x9a, 0x07, 0x4d, 0x5a, 0x76, 0x0b, 0x4e, 0x40, 0x58, 0x91, 0x54, 0xce, 0xa7, 0xaa,
0xd1, 0x41, 0x93, 0xea, 0x9e, 0xab, 0xb3, 0xc2, 0xda, 0xf1, 0x89, 0x86, 0x13, 0x0c, 0xf4, 0x36,
0x4c, 0x99, 0xae, 0xb3, 0xdd, 0x22, 0x95, 0xb6, 0xef, 0xed, 0x28, 0x17, 0xb8, 0xc0, 0x85, 0x5e,
0x57, 0x5d, 0x08, 0x05, 0xb8, 0x53, 0x6f, 0x33, 0xaf, 0x86, 0x65, 0x2c, 0xba, 0x07, 0x53, 0x4c,
0x86, 0x2f, 0x66, 0x33, 0x50, 0x54, 0xbe, 0x0f, 0xd2, 0x31, 0xad, 0xf3, 0x42, 0xcc, 0x37, 0x81,
0x2d, 0x5e, 0x06, 0xb3, 0x69, 0xd9, 0xb0, 0xba, 0xd7, 0xd9, 0xd9, 0x69, 0x11, 0x65, 0x39, 0x39,
0x2d, 0xe7, 0x06, 0xc2, 0x1b, 0x52, 0x43, 0x2c, 0x7a, 0x19, 0xc6, 0xd8, 0x30, 0x50, 0xae, 0xb1,
0x4e, 0x34, 0x9f, 0xeb, 0x75, 0xd5, 0xe9, 0x3e, 0x29, 0xd0, 0xb0, 0x70, 0xa3, 0x0d, 0xa9, 0xe3,
0x28, 0x78, 0xfb, 0xfb, 0x8e, 0xdb, 0x08, 0x14, 0x8d, 0x73, 0xae, 0xf6, 0xba, 0xea, 0xc5, 0x64,
0xc7, 0x51, 0x0f, 0x31, 0x72, 0xc3, 0x11, 0xf1, 0xd8, 0x71, 0xc4, 0x1d, 0xd7, 0x25, 0x3e, 0xeb,
0x80, 0xf8, 0xb5, 0xbc, 0x99, 0xac, 0x52, 0x3e, 0xf7, 0xf3, 0x6e, 0x29, 0xaa, 0x52, 0x71, 0x0a,
0x2a, 0x42, 0xce, 0x3c, 0xa0, 0xc4, 0x77, 0x9d, 0xd6, 0x91, 0xcc, 0x2a, 0x97, 0x91, 0x02, 0x22,
0x21, 0x42, 0x16, 0x4a, 0xd1, 0xd0, 0x1d, 0x98, 0xac, 0x52, 0x9f, 0x04, 0x01, 0xf1, 0x03, 0x85,
0xf0, 0x45, 0x49, 0x6d, 0x5b, 0x10, 0xb9, 0x34, 0xdc, 0x87, 0xa1, 0xdb, 0x30, 0x51, 0xd8, 0x23,
0xf5, 0x67, 0x8c, 0xb2, 0xc3, 0x29, 0xd2, 0xad, 0xae, 0x87, 0x1e, 0x0d, 0x1f, 0x81, 0x58, 0x49,
0x14, 0xec, 0x0d, 0x72, 0xc8, 0xdb, 0x6f, 0xde, 0x34, 0x8d, 0xc9, 0xe7, 0x4b, 0xcc, 0xc4, 0x9f,
0xda, 0xa0, 0xf9, 0x31, 0xd1, 0x70, 0x9c, 0x81, 0x1e, 0x01, 0x8a, 0x19, 0x2c, 0xc7, 0xdf, 0x25,
0xa2, 0x6b, 0x1a, 0xcb, 0x2f, 0xf7, 0xba, 0xea, 0x95, 0x81, 0x3a, 0x7a, 0x8b, 0xe1, 0x34, 0x3c,
0x80, 0x8c, 0x9e, 0xc0, 0xb9, 0xbe, 0xb5, 0xb3, 0xb3, 0xd3, 0x3c, 0xc0, 0x8e, 0xbb, 0x4b, 0x94,
0x2f, 0x84, 0xa8, 0xd6, 0xeb, 0xaa, 0x4b, 0x69, 0x51, 0x0e, 0xd4, 0x7d, 0x86, 0xd4, 0xf0, 0x40,
0x01, 0xe4, 0xc0, 0x85, 0x41, 0x76, 0xfb, 0xc0, 0x55, 0xbe, 0x14, 0xda, 0x2f, 0xf7, 0xba, 0xaa,
0x76, 0xac, 0xb6, 0x4e, 0x0f, 0x5c, 0x0d, 0x0f, 0xd3, 0x41, 0xeb, 0x30, 0x77, 0xe4, 0xb2, 0x0f,
0xdc, 0x72, 0x3b, 0x50, 0xbe, 0x12, 0xd2, 0xd2, 0x09, 0x90, 0xa4, 0xe9, 0x81, 0xab, 0x7b, 0xed,
0x40, 0xc3, 0x49, 0x1a, 0x7a, 0x3f, 0xca, 0x8d, 0x28, 0xee, 0x81, 0xe8, 0x20, 0xc7, 0xe4, 0x02,
0x1c, 0xea, 0x88, 0xb6, 0x20, 0x38, 0x4a, 0x4d, 0x48, 0x40, 0xaf, 0x47, 0x47, 0xe8, 0x51, 0xa5,
0x2a, 0x7a, 0xc7, 0x31, 0xb9, 0x8f, 0x0f, 0xd9, 0x1f, 0xb6, 0xfb, 0x87, 0xe8, 0x51, 0xa5, 0xaa,
0x7d, 0x67, 0x4e, 0x74, 0x9b, 0xec, 0x15, 0xef, 0x7f, 0x35, 0xca, 0xaf, 0xb8, 0xeb, 0xec, 0x13,
0x0d, 0x73, 0xa7, 0x5c, 0x47, 0x46, 0x4e, 0x51, 0x47, 0x56, 0x61, 0xfc, 0x89, 0x61, 0x31, 0x74,
0x36, 0x59, 0x46, 0x3e, 0x72, 0x5a, 0x02, 0x1c, 0x22, 0x50, 0x19, 0x16, 0xd6, 0x89, 0xe3, 0xd3,
0x6d, 0xe2, 0xd0, 0xa2, 0x4b, 0x89, 0xff, 0xdc, 0x69, 0x85, 0x55, 0x22, 0x2b, 0xef, 0xe6, 0x5e,
0x04, 0xd2, 0x9b, 0x21, 0x4a, 0xc3, 0x83, 0x98, 0xa8, 0x08, 0xf3, 0x66, 0x8b, 0xd4, 0xd9, 0x77,
0xb7, 0xdd, 0xdc, 0x27, 0x5e, 0x87, 0x6e, 0x06, 0xbc, 0x5a, 0x64, 0xe5, 0x5b, 0x4e, 0x42, 0x88,
0x4e, 0x05, 0x46, 0xc3, 0x69, 0x16, 0xbb, 0xe8, 0x56, 0x33, 0xa0, 0xc4, 0x95, 0xbe, 0x9b, 0x17,
0x93, 0x2f, 0x4f, 0x8b, 0x23, 0xa2, 0x16, 0xbf, 0xe3, 0xb7, 0x02, 0x0d, 0xa7, 0x68, 0x08, 0xc3,
0x82, 0xd1, 0x78, 0x4e, 0x7c, 0xda, 0x0c, 0x88, 0xa4, 0x76, 0x9e, 0xab, 0x49, 0x17, 0xc8, 0x89,
0x40, 0x71, 0xc1, 0x41, 0x64, 0xf4, 0x76, 0xd4, 0xea, 0x1a, 0x1d, 0xea, 0xd9, 0x56, 0x35, 0x7c,
0xf5, 0xa5, 0xdc, 0x38, 0x1d, 0xea, 0xe9, 0x94, 0x09, 0xc4, 0x91, 0xec, 0x1d, 0xec, 0xb7, 0xde,
0x46, 0x87, 0xee, 0x29, 0x0a, 0xe7, 0x0e, 0xe9, 0xd6, 0x9d, 0x4e, 0xa2, 0x5b, 0x67, 0x14, 0xf4,
0x2d, 0x59, 0x84, 0x7d, 0xf0, 0x2b, 0x17, 0x93, 0x1f, 0x9e, 0x9c, 0xbd, 0xd3, 0x64, 0x8f, 0x7f,
0x02, 0xdb, 0x8f, 0x7e, 0x83, 0x1c, 0x72, 0xf2, 0xa5, 0xe4, 0xc9, 0x62, 0x37, 0x47, 0x70, 0xe3,
0x48, 0x64, 0xa5, 0x5a, 0x69, 0x2e, 0x70, 0x39, 0xd9, 0xe8, 0x4b, 0x6d, 0x9a, 0xd0, 0x19, 0x44,
0x63, 0x7b, 0x21, 0xd2, 0xc5, 0x7a, 0x38, 0x9e, 0x15, 0x95, 0x67, 0x45, 0xda, 0x8b, 0x30, 0xc7,
0xbc, 0xf7, 0x13, 0x09, 0x49, 0x50, 0x90, 0x0d, 0xf3, 0x47, 0x29, 0x3a, 0xd2, 0x59, 0xe6, 0x3a,
0xd2, 0x6b, 0xd3, 0x74, 0x9b, 0xb4, 0xe9, 0xb4, 0xf4, 0x7e, 0x96, 0x25, 0xc9, 0xb4, 0x00, 0x2b,
0xcd, 0xec, 0xff, 0x51, 0x7e, 0xaf, 0xf1, 0x1c, 0x25, 0xfb, 0xe3, 0x7e, 0x92, 0x65, 0x30, 0xfb,
0x40, 0xe5, 0x9d, 0x7a, 0x3c, 0xcd, 0x1a, 0x97, 0x90, 0x0e, 0x9c, 0x68, 0xef, 0x53, 0xb9, 0x1e,
0xc0, 0x65, 0x1d, 0x6d, 0xd4, 0xfb, 0xf3, 0xfd, 0xbe, 0x3e, 0xfc, 0x53, 0x41, 0x6c, 0x77, 0x0c,
0x1e, 0x2d, 0x26, 0x4a, 0xf7, 0x4b, 0x43, 0x9b, 0x7d, 0x41, 0x96, 0xc1, 0x68, 0x33, 0xd1, 0x9c,
0x73, 0x85, 0x1b, 0x27, 0xf5, 0xe6, 0x42, 0x28, 0xcd, 0x64, 0x1d, 0x57, 0x51, 0xa4, 0xa2, 0xd0,
0xea, 0xf0, 0x1f, 0xdc, 0x6e, 0x26, 0xcf, 0x4e, 0x94, 0xaa, 0xba, 0x00, 0x68, 0x38, 0xc1, 0x60,
0x37, 0x3a, 0x6e, 0xa9, 0x52, 0x87, 0x92, 0xb0, 0x11, 0x90, 0x36, 0x38, 0x21, 0xa4, 0x07, 0x0c,
0xa6, 0xe1, 0x41, 0xe4, 0xb4, 0xa6, 0xed, 0x3d, 0x23, 0xae, 0xf2, 0xca, 0x49, 0x9a, 0x94, 0xc1,
0x52, 0x9a, 0x9c, 0x8c, 0xee, 0xc3, 0x4c, 0xf4, 0x79, 0x50, 0xf0, 0x3a, 0x2e, 0x55, 0xee, 0xf2,
0xb7, 0x50, 0x2e, 0x30, 0xd1, 0x77, 0x48, 0x9d, 0xf9, 0x59, 0x81, 0x91, 0xf1, 0xc8, 0x82, 0xf9,
0x47, 0x1d, 0x8f, 0x3a, 0x79, 0xa7, 0xfe, 0x8c, 0xb8, 0x8d, 0xfc, 0x21, 0x25, 0x81, 0xf2, 0x3a,
0x17, 0x91, 0xda, 0xef, 0x0f, 0x19, 0x44, 0xdf, 0x16, 0x18, 0x7d, 0x9b, 0x81, 0x34, 0x9c, 0x26,
0xb2, 0x52, 0x52, 0xf1, 0xc9, 0x63, 0x8f, 0x12, 0xe5, 0x7e, 0xf2, 0xb9, 0x6a, 0xfb, 0x44, 0x7f,
0xee, 0xb1, 0xdd, 0x89, 0x30, 0xf2, 0x8e, 0x78, 0xbe, 0xdf, 0x69, 0x53, 0xde, 0xd5, 0x28, 0xef,
0x27, 0x8f, 0xf1, 0xd1, 0x8e, 0x08, 0x94, 0xce, 0xfb, 0x20, 0x69, 0x47, 0x24, 0x32, 0xba, 0x09,
0xe3, 0x96, 0xb7, 0xbb, 0x4b, 0x7c, 0xe5, 0x21, 0xdf, 0xd8, 0xf9, 0x5e, 0x57, 0x9d, 0x09, 0x2f,
0x3a, 0xb7, 0x6b, 0x38, 0x04, 0xb0, 0x96, 0xde, 0xf2, 0x76, 0xcb, 0x1d, 0xda, 0xee, 0xd0, 0x40,
0x59, 0xe7, 0xf7, 0x59, 0x6a, 0xe9, 0x5b, 0xde, 0xae, 0xee, 0x09, 0xa7, 0x86, 0x25, 0x24, 0x6b,
0x6e, 0xd7, 0xc8, 0x76, 0x67, 0x57, 0x29, 0xf2, 0x40, 0xa5, 0xe6, 0xb6, 0xc1, 0xcc, 0x1a, 0x16,
0xee, 0xd5, 0x9f, 0x66, 0xa5, 0x5f, 0x92, 0xd1, 0x1c, 0x4c, 0x95, 0xca, 0x76, 0xad, 0x6a, 0x1b,
0xd8, 0x36, 0xd7, 0x72, 0x67, 0xd0, 0x79, 0x40, 0xc5, 0x52, 0xd1, 0x2e, 0x1a, 0x96, 0x30, 0xd6,
0x4c, 0xbb, 0xb0, 0x96, 0x03, 0x94, 0x83, 0x69, 0x6c, 0x4a, 0x96, 0x29, 0x66, 0xa9, 0x16, 0x1f,
0xda, 0x26, 0xde, 0x14, 0x96, 0x73, 0x68, 0x19, 0xae, 0x54, 0x8b, 0x0f, 0x1f, 0x6d, 0x15, 0x05,
0xa6, 0x66, 0x94, 0xd6, 0x6a, 0xd8, 0xdc, 0x2c, 0x3f, 0x36, 0x6b, 0x6b, 0x86, 0x6d, 0xe4, 0x16,
0xd1, 0x3c, 0xcc, 0x54, 0x8d, 0xc7, 0x66, 0xad, 0x5a, 0x32, 0x2a, 0xd5, 0xf5, 0xb2, 0x9d, 0x5b,
0x42, 0xd7, 0xe0, 0x2a, 0x13, 0x2e, 0x63, 0xb3, 0x16, 0x4d, 0xf0, 0x00, 0x97, 0x37, 0xfb, 0x10,
0x15, 0x5d, 0x84, 0xc5, 0xc1, 0xae, 0x65, 0xc6, 0x4e, 0x4d, 0x69, 0xe0, 0xc2, 0x7a, 0x31, 0x9a,
0x73, 0x05, 0xdd, 0x86, 0x57, 0x8e, 0x8b, 0x8a, 0x8f, 0xab, 0x76, 0xb9, 0x52, 0x33, 0x1e, 0x9a,
0x25, 0x3b, 0x77, 0x13, 0x5d, 0x85, 0x8b, 0x79, 0xcb, 0x28, 0x6c, 0xac, 0x97, 0x2d, 0xb3, 0x56,
0x31, 0x4d, 0x5c, 0xab, 0x94, 0xb1, 0x5d, 0xb3, 0x9f, 0xd6, 0xf0, 0xd3, 0x5c, 0x03, 0xa9, 0x70,
0x79, 0xab, 0x34, 0x1c, 0x40, 0xd0, 0x25, 0x58, 0x5c, 0x33, 0x2d, 0xe3, 0x83, 0x94, 0xeb, 0x45,
0x06, 0x5d, 0x81, 0x0b, 0x5b, 0xa5, 0xc1, 0xde, 0xcf, 0x32, 0xab, 0x7f, 0x03, 0x18, 0x65, 0x9f,
0x20, 0x48, 0x81, 0x73, 0xd1, 0xde, 0x96, 0x4b, 0x66, 0xed, 0x41, 0xd9, 0xb2, 0xca, 0x4f, 0x4c,
0x9c, 0x3b, 0x13, 0xae, 0x26, 0xe5, 0xa9, 0x6d, 0x95, 0xec, 0xa2, 0x55, 0xb3, 0x71, 0xf1, 0xe1,
0x43, 0x13, 0xf7, 0x77, 0x28, 0x83, 0x10, 0xcc, 0x46, 0x04, 0xcb, 0x34, 0xd6, 0x4c, 0x9c, 0x1b,
0x41, 0x37, 0xe1, 0x46, 0xdc, 0x36, 0x8c, 0x9e, 0x95, 0xe9, 0x8f, 0xb6, 0xca, 0x78, 0x6b, 0x33,
0x37, 0xca, 0x0e, 0x4d, 0x64, 0x33, 0x2c, 0x2b, 0x37, 0x86, 0xae, 0x83, 0x1a, 0x6d, 0xb1, 0xb4,
0xbb, 0xb1, 0xc8, 0x01, 0xdd, 0x83, 0x37, 0x4e, 0x00, 0x0d, 0x8b, 0x62, 0x8a, 0xa5, 0x64, 0x00,
0x37, 0x5c, 0xcf, 0x34, 0x7a, 0x1d, 0x5e, 0x1b, 0xea, 0x1e, 0x26, 0x3a, 0x83, 0x1e, 0x40, 0x7e,
0x00, 0x4b, 0xac, 0x32, 0xb4, 0x88, 0x73, 0x19, 0x0a, 0x45, 0xd4, 0xf0, 0x10, 0x16, 0xb0, 0x61,
0x17, 0xd6, 0x73, 0xb3, 0x68, 0x15, 0x5e, 0x1e, 0x7a, 0x1c, 0xe2, 0x9b, 0xd0, 0x40, 0x06, 0xbc,
0x7b, 0x3a, 0xec, 0xb0, 0xb0, 0x09, 0x7a, 0x09, 0x96, 0x87, 0x4b, 0x84, 0x5b, 0xb2, 0x83, 0xde,
0x81, 0x37, 0x4f, 0x42, 0x0d, 0x9b, 0x62, 0xf7, 0xf8, 0x29, 0xc2, 0x63, 0xb0, 0xc7, 0xee, 0xde,
0x70, 0x14, 0x3b, 0x18, 0x4d, 0xf4, 0x7f, 0xa0, 0x0d, 0x3c, 0xec, 0xf1, 0x6d, 0x79, 0x91, 0x41,
0xb7, 0xe0, 0x26, 0x36, 0x4a, 0x6b, 0xe5, 0xcd, 0xda, 0x29, 0xf0, 0x9f, 0x65, 0xd0, 0x7b, 0xf0,
0xf6, 0xc9, 0xc0, 0x61, 0x0b, 0xfc, 0x3c, 0x83, 0x4c, 0x78, 0xff, 0xd4, 0xf3, 0x0d, 0x93, 0xf9,
0x22, 0x83, 0xae, 0xc1, 0x95, 0xc1, 0xfc, 0x30, 0x0f, 0x5f, 0x66, 0xd0, 0x0a, 0x5c, 0x3f, 0x76,
0xa6, 0x10, 0xf9, 0x55, 0x06, 0xbd, 0x05, 0x77, 0x8f, 0x83, 0x0c, 0x0b, 0xe3, 0xd7, 0x19, 0x74,
0x1f, 0xee, 0x9d, 0x62, 0x8e, 0x61, 0x02, 0xbf, 0x39, 0x66, 0x1d, 0x61, 0xb2, 0xbf, 0x3e, 0x79,
0x1d, 0x21, 0xf2, 0xb7, 0x19, 0xb4, 0x04, 0x17, 0x07, 0x43, 0xd8, 0x99, 0xf8, 0x5d, 0x06, 0xdd,
0x80, 0xe5, 0x63, 0x95, 0x18, 0xec, 0xf7, 0x19, 0xa4, 0xc0, 0x42, 0xa9, 0x5c, 0x7b, 0x60, 0x14,
0xad, 0xda, 0x93, 0xa2, 0xbd, 0x5e, 0xab, 0xda, 0xd8, 0xac, 0x56, 0x73, 0xbf, 0x18, 0x61, 0xa1,
0xc4, 0x3c, 0xa5, 0x72, 0xe8, 0xac, 0x3d, 0x28, 0xe3, 0x9a, 0x55, 0x7c, 0x6c, 0x96, 0x18, 0xf2,
0xd3, 0x11, 0x34, 0x07, 0xc0, 0x60, 0x95, 0x72, 0xb1, 0x64, 0x57, 0x73, 0xdf, 0xcb, 0xa2, 0x19,
0x98, 0x30, 0x9f, 0xda, 0x26, 0x2e, 0x19, 0x56, 0xee, 0xef, 0xd9, 0xd5, 0x7d, 0x98, 0x88, 0x7e,
0xe5, 0x40, 0xe3, 0x30, 0xb2, 0xf1, 0x38, 0x77, 0x06, 0x4d, 0xc2, 0x98, 0x65, 0x1a, 0x55, 0x33,
0x97, 0x41, 0x0b, 0x30, 0x67, 0x5a, 0x66, 0xc1, 0x2e, 0x96, 0x4b, 0x35, 0xbc, 0x55, 0x2a, 0xf1,
0xc7, 0x33, 0x07, 0xd3, 0x4f, 0xd8, 0xcd, 0x8f, 0x2c, 0x59, 0xb4, 0x08, 0xf3, 0x56, 0xb9, 0xb0,
0x51, 0xc3, 0x46, 0xc1, 0xc4, 0x91, 0x79, 0x94, 0x01, 0xb9, 0x50, 0x64, 0x19, 0x5b, 0xcd, 0xc3,
0xd9, 0xf0, 0x27, 0x12, 0x34, 0x05, 0x67, 0x37, 0x1e, 0xd7, 0xd6, 0x8d, 0xea, 0x7a, 0xee, 0x4c,
0x1f, 0x69, 0x3e, 0xad, 0x14, 0x31, 0x9b, 0x19, 0x60, 0xfc, 0x68, 0xc2, 0x69, 0x98, 0x28, 0x95,
0x6b, 0x85, 0x75, 0xb3, 0xb0, 0x91, 0xcb, 0xde, 0xb9, 0x0f, 0x93, 0xb6, 0xef, 0xb8, 0x41, 0xdb,
0xf3, 0x29, 0xba, 0x23, 0x0f, 0x66, 0xc3, 0x1f, 0x6a, 0xc3, 0x3f, 0x19, 0x5f, 0x9a, 0x3b, 0x1a,
0x8b, 0xbf, 0x26, 0x6a, 0x67, 0x56, 0x32, 0xaf, 0x65, 0xf2, 0xe7, 0x5e, 0xfc, 0x79, 0xe9, 0xcc,
0x8b, 0x6f, 0x96, 0x32, 0x5f, 0x7f, 0xb3, 0x94, 0xf9, 0xd3, 0x37, 0x4b, 0x99, 0x9f, 0xfc, 0x65,
0xe9, 0xcc, 0xf6, 0x38, 0xff, 0x93, 0xf3, 0xdd, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0x42, 0x92,
0x53, 0x23, 0xbb, 0x1e, 0x00, 0x00,
// 2984 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x59, 0x4b, 0x73, 0xdc, 0xc6,
0xb5, 0x16, 0x38, 0x24, 0x45, 0x36, 0x5f, 0x60, 0x53, 0x94, 0xa0, 0x17, 0x41, 0x41, 0x96, 0x2f,
0x45, 0x1b, 0x92, 0xaf, 0xe4, 0xf2, 0x43, 0xbe, 0xb6, 0x8c, 0x19, 0x82, 0xe4, 0xdc, 0x01, 0x67,
0x46, 0x3d, 0x20, 0x25, 0xdf, 0x0d, 0x0a, 0x9c, 0x69, 0x92, 0x53, 0x1a, 0x02, 0x63, 0xa0, 0x47,
0x26, 0xbd, 0xbe, 0x55, 0xd9, 0x26, 0xce, 0xa3, 0x92, 0xaa, 0xfc, 0x84, 0x38, 0x59, 0xe4, 0x4f,
0xc8, 0xaf, 0xc4, 0x49, 0x56, 0xc9, 0x62, 0x2a, 0x71, 0x36, 0x59, 0x65, 0x31, 0x95, 0xf7, 0x22,
0x95, 0xea, 0x6e, 0x80, 0xd3, 0x00, 0x66, 0x28, 0xae, 0x48, 0x9c, 0xf3, 0x7d, 0x5f, 0x9f, 0xee,
0xd3, 0xdd, 0xe7, 0x34, 0x09, 0xe6, 0x82, 0x76, 0xbd, 0xbd, 0x7b, 0x37, 0x68, 0xd7, 0xef, 0xb4,
0x03, 0x9f, 0xf8, 0x70, 0x8c, 0x19, 0xae, 0xe8, 0xfb, 0x4d, 0x72, 0xd0, 0xd9, 0xbd, 0x53, 0xf7,
0x0f, 0xef, 0xee, 0xfb, 0xfb, 0xfe, 0x5d, 0xe6, 0xdd, 0xed, 0xec, 0xb1, 0x2f, 0xf6, 0xc1, 0x7e,
0xe3, 0x2c, 0xed, 0x5b, 0x12, 0x38, 0x8f, 0xf0, 0x87, 0x1d, 0x1c, 0x12, 0x78, 0x07, 0x4c, 0x56,
0xda, 0x38, 0x70, 0x49, 0xd3, 0xf7, 0x14, 0x69, 0x59, 0x5a, 0x99, 0xbd, 0x27, 0xdf, 0x61, 0xaa,
0x77, 0x4e, 0xec, 0xa8, 0x0f, 0x81, 0xb7, 0xc0, 0xf8, 0x16, 0x3e, 0xdc, 0xc5, 0x81, 0x32, 0xb2,
0x2c, 0xad, 0x4c, 0xdd, 0x9b, 0x89, 0xc0, 0xdc, 0x88, 0x22, 0x27, 0x85, 0xd9, 0x38, 0x24, 0x38,
0x50, 0x72, 0x09, 0x18, 0x37, 0xa2, 0xc8, 0xa9, 0xfd, 0x69, 0x04, 0x4c, 0xd7, 0x3c, 0xb7, 0x1d,
0x1e, 0xf8, 0xa4, 0xe8, 0xed, 0xf9, 0x70, 0x09, 0x00, 0xae, 0x50, 0x76, 0x0f, 0x31, 0x8b, 0x67,
0x12, 0x09, 0x16, 0xb8, 0x0a, 0x64, 0xfe, 0x55, 0x68, 0x35, 0xb1, 0x47, 0xb6, 0x91, 0x15, 0x2a,
0x23, 0xcb, 0xb9, 0x95, 0x49, 0x94, 0xb1, 0x43, 0xad, 0xaf, 0x5d, 0x75, 0xc9, 0x01, 0x8b, 0x64,
0x12, 0x25, 0x6c, 0x54, 0x2f, 0xfe, 0x5e, 0x6f, 0xb6, 0x70, 0xad, 0xf9, 0x31, 0x56, 0x46, 0x19,
0x2e, 0x63, 0x87, 0xaf, 0x82, 0xf9, 0xd8, 0x66, 0xfb, 0xc4, 0x6d, 0x31, 0xf0, 0x18, 0x03, 0x67,
0x1d, 0xa2, 0x32, 0x33, 0x96, 0xf0, 0xb1, 0x32, 0xbe, 0x2c, 0xad, 0xe4, 0x50, 0xc6, 0x2e, 0x46,
0xba, 0xe9, 0x86, 0x07, 0xca, 0x79, 0x86, 0x4b, 0xd8, 0x44, 0x3d, 0x84, 0x9f, 0x35, 0x43, 0x9a,
0xaf, 0x89, 0xa4, 0x5e, 0x6c, 0x87, 0x10, 0x8c, 0xda, 0xbe, 0xff, 0x54, 0x99, 0x64, 0xc1, 0xb1,
0xdf, 0xb5, 0x1f, 0x4b, 0x60, 0x02, 0xe1, 0xb0, 0xed, 0x7b, 0x21, 0x86, 0x0a, 0x38, 0x5f, 0xeb,
0xd4, 0xeb, 0x38, 0x0c, 0xd9, 0x1a, 0x4f, 0xa0, 0xf8, 0x13, 0x5e, 0x04, 0xe3, 0x35, 0xe2, 0x92,
0x4e, 0xc8, 0xf2, 0x3b, 0x89, 0xa2, 0x2f, 0x21, 0xef, 0xb9, 0xd3, 0xf2, 0xfe, 0x66, 0x32, 0x9f,
0x6c, 0x2d, 0xa7, 0xee, 0x2d, 0x44, 0x60, 0xd1, 0x85, 0x12, 0x40, 0xed, 0x93, 0xe9, 0x78, 0x00,
0xf8, 0x1a, 0x98, 0x30, 0x49, 0xbd, 0x61, 0x1e, 0xe1, 0x3a, 0xdf, 0x01, 0xf9, 0x0b, 0xbd, 0xae,
0x2a, 0x1f, 0xbb, 0x87, 0xad, 0x07, 0x1a, 0x26, 0xf5, 0x86, 0x8e, 0x8f, 0x70, 0x5d, 0x43, 0x27,
0x28, 0x78, 0x1f, 0x4c, 0x1a, 0xfb, 0xd8, 0x23, 0x46, 0xa3, 0x11, 0x28, 0x53, 0x8c, 0xb2, 0xd8,
0xeb, 0xaa, 0xf3, 0x9c, 0xe2, 0x52, 0x97, 0xee, 0x36, 0x1a, 0x81, 0x86, 0xfa, 0x38, 0x68, 0x81,
0xf9, 0x75, 0xb7, 0xd9, 0x6a, 0xfb, 0x4d, 0x8f, 0x6c, 0xda, 0x76, 0x95, 0x91, 0xa7, 0x19, 0x79,
0xa9, 0xd7, 0x55, 0xaf, 0x70, 0xf2, 0x5e, 0x0c, 0xd1, 0x0f, 0x08, 0x69, 0x47, 0x2a, 0x59, 0x22,
0xd4, 0xc1, 0xf9, 0xbc, 0x1b, 0xe2, 0xb5, 0x66, 0xa0, 0x60, 0xa6, 0xb1, 0xd0, 0xeb, 0xaa, 0x73,
0x5c, 0x63, 0xd7, 0x0d, 0xb1, 0xde, 0x68, 0x06, 0x1a, 0x8a, 0x31, 0x70, 0x03, 0xcc, 0xd1, 0xe8,
0xf9, 0x6e, 0xad, 0x06, 0xfe, 0xd1, 0xb1, 0xf2, 0x19, 0xcb, 0x44, 0xfe, 0x5a, 0xaf, 0xab, 0x2a,
0xc2, 0x5c, 0xeb, 0x0c, 0xa2, 0xb7, 0x29, 0x46, 0x43, 0x69, 0x16, 0x34, 0xc0, 0x0c, 0x35, 0x55,
0x31, 0x0e, 0xb8, 0xcc, 0xe7, 0x5c, 0xe6, 0x4a, 0xaf, 0xab, 0x5e, 0x14, 0x64, 0xda, 0x18, 0x07,
0xb1, 0x48, 0x92, 0x01, 0xab, 0x00, 0xf6, 0x55, 0x4d, 0xaf, 0xc1, 0x26, 0xa6, 0x7c, 0xca, 0xf2,
0x9f, 0x57, 0x7b, 0x5d, 0xf5, 0x6a, 0x36, 0x1c, 0x1c, 0xc1, 0x34, 0x34, 0x80, 0x0b, 0xff, 0x1b,
0x8c, 0x52, 0xab, 0xf2, 0x53, 0x7e, 0x47, 0x4c, 0x45, 0xe9, 0xa7, 0xb6, 0xfc, 0x5c, 0xaf, 0xab,
0x4e, 0xf5, 0x05, 0x35, 0xc4, 0xa0, 0x30, 0x0f, 0x16, 0xe9, 0xcf, 0x8a, 0xd7, 0xdf, 0xcc, 0x21,
0xf1, 0x03, 0xac, 0xfc, 0x2c, 0xab, 0x81, 0x06, 0x43, 0xe1, 0x1a, 0x98, 0xe5, 0x81, 0x14, 0x70,
0x40, 0xd6, 0x5c, 0xe2, 0x2a, 0xdf, 0x61, 0x67, 0x3e, 0x7f, 0xb5, 0xd7, 0x55, 0x2f, 0xf1, 0x31,
0xa3, 0xf8, 0xeb, 0x38, 0x20, 0x7a, 0xc3, 0x25, 0xae, 0x86, 0x52, 0x9c, 0xa4, 0x0a, 0xbb, 0x38,
0x3e, 0x39, 0x55, 0xa5, 0xed, 0x92, 0x83, 0x84, 0x0a, 0xbb, 0x58, 0x0c, 0x30, 0xc3, 0x2d, 0x25,
0x7c, 0xcc, 0x42, 0xf9, 0x2e, 0x17, 0x11, 0xf2, 0x12, 0x89, 0x3c, 0xc5, 0xc7, 0x51, 0x24, 0x49,
0x46, 0x42, 0x82, 0xc5, 0xf1, 0xbd, 0xd3, 0x24, 0x78, 0x18, 0x49, 0x06, 0xb4, 0xc1, 0x02, 0x37,
0xd8, 0x41, 0x27, 0x24, 0xb8, 0x51, 0x30, 0x58, 0x2c, 0xdf, 0xe7, 0x42, 0x37, 0x7a, 0x5d, 0xf5,
0x7a, 0x42, 0x88, 0x70, 0x98, 0x5e, 0x77, 0xa3, 0x90, 0x06, 0xd1, 0x07, 0xa8, 0xb2, 0xf0, 0x7e,
0x70, 0x06, 0x55, 0x1e, 0xe5, 0x20, 0x3a, 0x7c, 0x0f, 0x4c, 0xd3, 0x3d, 0x79, 0x92, 0xbb, 0xbf,
0x72, 0xb9, 0xcb, 0xbd, 0xae, 0xba, 0xc8, 0xe5, 0xd8, 0x1e, 0x16, 0x32, 0x97, 0xc0, 0x8b, 0x7c,
0x16, 0xce, 0xdf, 0x4e, 0xe1, 0xf3, 0x30, 0x12, 0x78, 0xf8, 0x0e, 0x98, 0xa2, 0xdf, 0x71, 0xbe,
0xfe, 0xce, 0xe9, 0x4a, 0xaf, 0xab, 0x5e, 0x10, 0xe8, 0xfd, 0x6c, 0x89, 0x68, 0x81, 0xcc, 0xc6,
0xfe, 0xc7, 0x70, 0x32, 0x1f, 0x5a, 0x44, 0xc3, 0x32, 0x98, 0xa7, 0x9f, 0xc9, 0x1c, 0xfd, 0x33,
0x97, 0x3e, 0x7f, 0x4c, 0x22, 0x93, 0xa1, 0x2c, 0x35, 0xa3, 0xc7, 0x42, 0xfa, 0xd7, 0x0b, 0xf5,
0x78, 0x64, 0x59, 0x2a, 0x7c, 0x37, 0x55, 0x48, 0x7f, 0x3b, 0x9a, 0x9e, 0x5d, 0x18, 0xb9, 0xe3,
0x85, 0x4d, 0xd4, 0xd8, 0xb7, 0x52, 0x35, 0xe1, 0x77, 0x67, 0x2e, 0x0a, 0x3f, 0x9f, 0x8e, 0xdb,
0x08, 0x7a, 0xbf, 0xd2, 0xb9, 0xd1, 0xfb, 0x55, 0x4a, 0xdf, 0xaf, 0x74, 0x21, 0xa2, 0xfb, 0x35,
0xc2, 0xc0, 0x57, 0xc1, 0xf9, 0x32, 0x26, 0x1f, 0xf9, 0xc1, 0x53, 0x5e, 0xc7, 0xf2, 0xb0, 0xd7,
0x55, 0x67, 0x39, 0xdc, 0xe3, 0x0e, 0x0d, 0xc5, 0x10, 0x78, 0x13, 0x8c, 0xb2, 0xdb, 0x9f, 0x2f,
0x91, 0x70, 0x43, 0xf1, 0xeb, 0x9e, 0x39, 0x61, 0x01, 0xcc, 0xae, 0xe1, 0x96, 0x7b, 0x6c, 0xb9,
0x04, 0x7b, 0xf5, 0xe3, 0xad, 0x90, 0x55, 0x9a, 0x19, 0xf1, 0x5a, 0x68, 0x50, 0xbf, 0xde, 0xe2,
0x00, 0xfd, 0x30, 0xd4, 0x50, 0x8a, 0x02, 0xff, 0x17, 0xc8, 0x49, 0x0b, 0x7a, 0xc6, 0x6a, 0xce,
0x8c, 0x58, 0x73, 0xd2, 0x32, 0x7a, 0xf0, 0x4c, 0x43, 0x19, 0x1e, 0xfc, 0x00, 0x2c, 0x6e, 0xb7,
0x1b, 0x2e, 0xc1, 0x8d, 0x54, 0x5c, 0x33, 0x4c, 0xf0, 0x66, 0xaf, 0xab, 0xaa, 0x5c, 0xb0, 0xc3,
0x61, 0x7a, 0x36, 0xbe, 0xc1, 0x0a, 0xf0, 0x0d, 0x00, 0x90, 0xdf, 0xf1, 0x1a, 0x56, 0xf3, 0xb0,
0x49, 0x94, 0xc5, 0x65, 0x69, 0x65, 0x2c, 0x7f, 0xb1, 0xd7, 0x55, 0x21, 0xd7, 0x0b, 0xa8, 0x4f,
0x6f, 0x51, 0xa7, 0x86, 0x04, 0x24, 0xcc, 0x83, 0x59, 0xf3, 0xa8, 0x49, 0x2a, 0x5e, 0xc1, 0x0d,
0x31, 0x2d, 0x92, 0xca, 0xc5, 0x4c, 0x35, 0x3a, 0x6a, 0x12, 0xdd, 0xf7, 0x74, 0x5a, 0x58, 0x3b,
0x01, 0xd6, 0x50, 0x8a, 0x01, 0xdf, 0x06, 0x53, 0xa6, 0xe7, 0xee, 0xb6, 0x70, 0xb5, 0x1d, 0xf8,
0x7b, 0xca, 0x25, 0x26, 0x70, 0xa9, 0xd7, 0x55, 0x17, 0x22, 0x01, 0xe6, 0xd4, 0xdb, 0xd4, 0xab,
0x21, 0x11, 0x0b, 0x1f, 0x80, 0x29, 0x2a, 0xc3, 0x26, 0xb3, 0x15, 0x2a, 0x2a, 0x5b, 0x07, 0x61,
0x9b, 0xd6, 0x59, 0x21, 0x66, 0x8b, 0x40, 0x27, 0x2f, 0x82, 0xe9, 0xb0, 0xf4, 0xb3, 0x76, 0xd0,
0xd9, 0xdb, 0x6b, 0x61, 0x65, 0x39, 0x3d, 0x2c, 0xe3, 0x86, 0xdc, 0x1b, 0x51, 0x23, 0x2c, 0x7c,
0x19, 0x8c, 0xd1, 0xcf, 0x50, 0xb9, 0x41, 0x3b, 0xd1, 0xbc, 0xdc, 0xeb, 0xaa, 0xd3, 0x7d, 0x52,
0xa8, 0x21, 0xee, 0x86, 0x25, 0xa1, 0xe3, 0x28, 0xf8, 0x87, 0x87, 0xae, 0xd7, 0x08, 0x15, 0x8d,
0x71, 0xae, 0xf7, 0xba, 0xea, 0xe5, 0x74, 0xc7, 0x51, 0x8f, 0x30, 0x62, 0xc3, 0x11, 0xf3, 0xe8,
0x76, 0x44, 0x1d, 0xcf, 0xc3, 0x01, 0xed, 0x80, 0xd8, 0xb1, 0xbc, 0x9d, 0xae, 0x52, 0x01, 0xf3,
0xb3, 0x6e, 0x29, 0xae, 0x52, 0x49, 0x0a, 0x2c, 0x02, 0xd9, 0x3c, 0x22, 0x38, 0xf0, 0xdc, 0xd6,
0x89, 0xcc, 0x2a, 0x93, 0x11, 0x02, 0xc2, 0x11, 0x42, 0x14, 0xca, 0xd0, 0x60, 0x01, 0x4c, 0xd6,
0x48, 0x80, 0xc3, 0x10, 0x07, 0xa1, 0x82, 0x97, 0x73, 0x2b, 0x53, 0xf7, 0xe6, 0xe2, 0x13, 0x1e,
0xd9, 0xc5, 0x3e, 0x2e, 0x8c, 0xb1, 0x1a, 0xea, 0xf3, 0xe0, 0x5d, 0x30, 0x51, 0x38, 0xc0, 0xf5,
0xa7, 0x54, 0x63, 0x8f, 0x2d, 0x8c, 0x70, 0xcc, 0xeb, 0x91, 0x47, 0x43, 0x27, 0x20, 0x5a, 0x23,
0x39, 0xbb, 0x84, 0x8f, 0x59, 0x3f, 0xce, 0xba, 0xa8, 0x31, 0x71, 0xc3, 0xf1, 0x91, 0xd8, 0xdd,
0x1b, 0x36, 0x3f, 0xc6, 0x1a, 0x4a, 0x32, 0xe0, 0x23, 0x00, 0x13, 0x06, 0xcb, 0x0d, 0xf6, 0x31,
0x6f, 0xa3, 0xc6, 0xf2, 0xcb, 0xbd, 0xae, 0x7a, 0x6d, 0xa0, 0x8e, 0xde, 0xa2, 0x38, 0x0d, 0x0d,
0x20, 0xc3, 0xc7, 0xe0, 0x42, 0xdf, 0xda, 0xd9, 0xdb, 0x6b, 0x1e, 0x21, 0xd7, 0xdb, 0xc7, 0xca,
0x17, 0x5c, 0x54, 0xeb, 0x75, 0xd5, 0xa5, 0xac, 0x28, 0x03, 0xea, 0x01, 0x45, 0x6a, 0x68, 0xa0,
0x00, 0x74, 0xc1, 0xa5, 0x41, 0x76, 0xfb, 0xc8, 0x53, 0xbe, 0xe4, 0xda, 0x2f, 0xf7, 0xba, 0xaa,
0x76, 0xaa, 0xb6, 0x4e, 0x8e, 0x3c, 0x0d, 0x0d, 0xd3, 0x81, 0x9b, 0x60, 0xee, 0xc4, 0x65, 0x1f,
0x79, 0x95, 0x76, 0xa8, 0x7c, 0xc5, 0xa5, 0x85, 0x2d, 0x21, 0x48, 0x93, 0x23, 0x4f, 0xf7, 0xdb,
0xa1, 0x86, 0xd2, 0x34, 0xf8, 0x7e, 0x9c, 0x1b, 0x5e, 0xed, 0x43, 0xde, 0x52, 0x8e, 0x89, 0x15,
0x39, 0xd2, 0xe1, 0x7d, 0x42, 0x78, 0x92, 0x9a, 0x88, 0x00, 0x5f, 0x8f, 0xf7, 0xd4, 0xa3, 0x6a,
0x8d, 0x37, 0x93, 0x63, 0x62, 0x63, 0x1f, 0xb1, 0x3f, 0x6c, 0xf7, 0x37, 0xd1, 0xa3, 0x6a, 0x4d,
0xfb, 0x3f, 0x30, 0x11, 0xef, 0x28, 0x7a, 0xb3, 0xdb, 0xc7, 0xed, 0xe8, 0x25, 0x29, 0xde, 0xec,
0xe4, 0xb8, 0x8d, 0x35, 0xc4, 0x9c, 0xf0, 0x36, 0x18, 0x7f, 0x8c, 0x9b, 0xfb, 0x07, 0x84, 0xd5,
0x0a, 0x29, 0x3f, 0xdf, 0xeb, 0xaa, 0x33, 0x1c, 0xf6, 0x11, 0xb3, 0x6b, 0x28, 0x02, 0x68, 0xff,
0x3f, 0xc7, 0x5b, 0x5b, 0x2a, 0xdc, 0x7f, 0xa2, 0x8a, 0xc2, 0x9e, 0x7b, 0x48, 0x85, 0xd9, 0x6b,
0x55, 0x28, 0x5a, 0x23, 0x67, 0x28, 0x5a, 0xab, 0x60, 0xfc, 0xb1, 0x61, 0x51, 0x74, 0x2e, 0x5d,
0xb3, 0x3e, 0x72, 0x5b, 0x1c, 0x1c, 0x21, 0x60, 0x05, 0x2c, 0x6c, 0x62, 0x37, 0x20, 0xbb, 0xd8,
0x25, 0x45, 0x8f, 0xe0, 0xe0, 0x99, 0xdb, 0x8a, 0x4a, 0x52, 0x4e, 0xcc, 0xd4, 0x41, 0x0c, 0xd2,
0x9b, 0x11, 0x4a, 0x43, 0x83, 0x98, 0xb0, 0x08, 0xe6, 0xcd, 0x16, 0xae, 0xd3, 0x47, 0xbe, 0xdd,
0x3c, 0xc4, 0x7e, 0x87, 0x6c, 0x85, 0xac, 0x34, 0xe5, 0xc4, 0x2b, 0x05, 0x47, 0x10, 0x9d, 0x70,
0x8c, 0x86, 0xb2, 0x2c, 0x7a, 0xab, 0x58, 0xcd, 0x90, 0x60, 0x4f, 0x78, 0xa4, 0x2f, 0xa6, 0xaf,
0xb9, 0x16, 0x43, 0xc4, 0xef, 0x89, 0x4e, 0xd0, 0x0a, 0x35, 0x94, 0xa1, 0x41, 0x04, 0x16, 0x8c,
0xc6, 0x33, 0x1c, 0x90, 0x66, 0x88, 0x05, 0xb5, 0x8b, 0x4c, 0x4d, 0x38, 0x9c, 0x6e, 0x0c, 0x4a,
0x0a, 0x0e, 0x22, 0xc3, 0xb7, 0xe3, 0xbe, 0xda, 0xe8, 0x10, 0xdf, 0xb6, 0x6a, 0x51, 0x89, 0x11,
0x72, 0xe3, 0x76, 0x88, 0xaf, 0x13, 0x2a, 0x90, 0x44, 0xd2, 0x4b, 0xb7, 0xdf, 0xe7, 0x1b, 0x1d,
0x72, 0xa0, 0x28, 0x8c, 0x3b, 0xe4, 0x69, 0xe0, 0x76, 0x52, 0x4f, 0x03, 0x4a, 0x81, 0xff, 0x23,
0x8a, 0xac, 0x37, 0x5b, 0x58, 0xb9, 0x9c, 0x7e, 0xe5, 0x32, 0xf6, 0x5e, 0x93, 0x56, 0x9a, 0x14,
0xb6, 0x1f, 0x7d, 0x09, 0x1f, 0x33, 0xf2, 0x95, 0xf4, 0xce, 0xa2, 0xa7, 0x92, 0x73, 0x93, 0x48,
0x68, 0x65, 0xfa, 0x76, 0x26, 0x70, 0x35, 0xfd, 0xaa, 0x10, 0x7a, 0x42, 0xae, 0x33, 0x88, 0x46,
0xd7, 0x82, 0xa7, 0x8b, 0x36, 0x8c, 0x2c, 0x2b, 0x2a, 0xcb, 0x8a, 0xb0, 0x16, 0x51, 0x8e, 0x59,
0xa3, 0xc9, 0x13, 0x92, 0xa2, 0x40, 0x1b, 0xcc, 0x9f, 0xa4, 0xe8, 0x44, 0x67, 0x99, 0xe9, 0x08,
0x37, 0x59, 0xd3, 0x6b, 0x92, 0xa6, 0xdb, 0xd2, 0xfb, 0x59, 0x16, 0x24, 0xb3, 0x02, 0xb4, 0x0f,
0xa0, 0xbf, 0xc7, 0xf9, 0xbd, 0xc1, 0x72, 0x94, 0x6e, 0xc6, 0xfb, 0x49, 0x16, 0xc1, 0xf4, 0x35,
0xcc, 0x9e, 0x05, 0xc9, 0x34, 0x6b, 0x4c, 0x42, 0xd8, 0x70, 0xfc, 0x2d, 0x91, 0xc9, 0xf5, 0x00,
0x2e, 0x6d, 0x9f, 0xe3, 0x87, 0x06, 0x5b, 0xef, 0x9b, 0xc3, 0xdf, 0x25, 0x7c, 0xb9, 0x13, 0xf0,
0x78, 0x32, 0x71, 0xba, 0x5f, 0x1a, 0xfa, 0xb2, 0xe0, 0x64, 0x11, 0x0c, 0xb7, 0x52, 0x2f, 0x01,
0xa6, 0x70, 0xeb, 0x45, 0x0f, 0x01, 0x2e, 0x94, 0x65, 0xd2, 0xf6, 0xae, 0xc8, 0x53, 0x51, 0x68,
0x75, 0xd8, 0x5f, 0xf7, 0x6e, 0xa7, 0xf7, 0x4e, 0x9c, 0xaa, 0x3a, 0x07, 0x68, 0x28, 0xc5, 0xa0,
0x27, 0x3a, 0x69, 0xa9, 0x11, 0x97, 0xe0, 0xa8, 0xeb, 0x10, 0x16, 0x38, 0x25, 0xa4, 0x87, 0x14,
0xa6, 0xa1, 0x41, 0xe4, 0xac, 0xa6, 0xed, 0x3f, 0xc5, 0x9e, 0xf2, 0xca, 0x8b, 0x34, 0x09, 0x85,
0x65, 0x34, 0x19, 0x19, 0x3e, 0x04, 0x33, 0xf1, 0x5b, 0xa4, 0xe0, 0x77, 0x3c, 0xa2, 0xdc, 0x67,
0x77, 0xa1, 0x58, 0xbc, 0xe2, 0x47, 0x4f, 0x9d, 0xfa, 0x69, 0xf1, 0x12, 0xf1, 0xd0, 0x02, 0xf3,
0x8f, 0x3a, 0x3e, 0x71, 0xf3, 0x6e, 0xfd, 0x29, 0xf6, 0x1a, 0xf9, 0x63, 0x82, 0x43, 0xe5, 0x75,
0x26, 0x22, 0xf4, 0xfa, 0x1f, 0x52, 0x88, 0xbe, 0xcb, 0x31, 0xfa, 0x2e, 0x05, 0x69, 0x28, 0x4b,
0xa4, 0xa5, 0xa4, 0x1a, 0xe0, 0x1d, 0x9f, 0x60, 0xe5, 0x61, 0xfa, 0xba, 0x6a, 0x07, 0x58, 0x7f,
0xe6, 0xd3, 0xd5, 0x89, 0x31, 0xe2, 0x8a, 0xf8, 0x41, 0xd0, 0x69, 0x13, 0xd6, 0x31, 0x29, 0xef,
0xa7, 0xb7, 0xf1, 0xc9, 0x8a, 0x70, 0x94, 0xce, 0x7a, 0x2c, 0x61, 0x45, 0x04, 0x32, 0x2d, 0x93,
0x96, 0xbf, 0xbf, 0x8f, 0x03, 0x65, 0x83, 0x2d, 0xac, 0x50, 0x26, 0x5b, 0xcc, 0xae, 0xa1, 0x08,
0x40, 0xdf, 0x0f, 0x96, 0xbf, 0x5f, 0xe9, 0x90, 0x76, 0x87, 0x84, 0xca, 0x26, 0x3b, 0xcf, 0xc2,
0xfb, 0xa1, 0xe5, 0xef, 0xeb, 0x3e, 0x77, 0x6a, 0x48, 0x40, 0xd2, 0x4e, 0x7a, 0x0d, 0xef, 0x76,
0xf6, 0x95, 0x22, 0x0b, 0x54, 0xe8, 0xa4, 0x1b, 0xd4, 0xac, 0x21, 0xee, 0x5e, 0xfd, 0xb7, 0x04,
0xa6, 0xe3, 0x1a, 0xcf, 0x4a, 0x38, 0x04, 0xb3, 0xa5, 0x1d, 0xe7, 0x31, 0x2a, 0xda, 0xa6, 0x53,
0xdb, 0x32, 0x2c, 0x4b, 0x3e, 0x97, 0xb0, 0x59, 0x06, 0xda, 0x30, 0x65, 0x09, 0x2e, 0x80, 0xb9,
0xd2, 0x8e, 0x83, 0x4c, 0x63, 0xcd, 0xa9, 0x94, 0x4d, 0xa7, 0x64, 0x7e, 0x20, 0x8f, 0xc0, 0x79,
0x30, 0x13, 0x1b, 0x91, 0x51, 0xde, 0x30, 0xe5, 0x1c, 0x5c, 0x04, 0xf3, 0xa5, 0x1d, 0x67, 0xcd,
0xb4, 0x4c, 0xdb, 0x3c, 0x41, 0x8e, 0x46, 0xf4, 0xc8, 0xcc, 0xb1, 0x63, 0xf0, 0x12, 0x58, 0x28,
0xed, 0x38, 0xf6, 0x93, 0x72, 0x34, 0x16, 0x77, 0xcb, 0xe3, 0x70, 0x12, 0x8c, 0x59, 0xa6, 0x51,
0x33, 0x65, 0x40, 0x89, 0xa6, 0x65, 0x16, 0xec, 0x62, 0xa5, 0xec, 0xa0, 0xed, 0x72, 0xd9, 0x44,
0xf2, 0x05, 0x28, 0x83, 0xe9, 0xc7, 0x86, 0x5d, 0xd8, 0x8c, 0x2d, 0x2a, 0x1d, 0xd6, 0xaa, 0x14,
0x4a, 0x0e, 0x32, 0x0a, 0x26, 0x8a, 0xcd, 0xb7, 0x29, 0x90, 0x09, 0xc5, 0x96, 0xfb, 0xab, 0x79,
0x70, 0x3e, 0xea, 0x81, 0xe1, 0x14, 0x38, 0x5f, 0xda, 0x71, 0x36, 0x8d, 0xda, 0xa6, 0x7c, 0xae,
0x8f, 0x34, 0x9f, 0x54, 0x8b, 0x88, 0xce, 0x18, 0x80, 0xf1, 0x88, 0x35, 0x02, 0xa7, 0xc1, 0x44,
0xb9, 0xe2, 0x14, 0x36, 0xcd, 0x42, 0x49, 0xce, 0xad, 0xfe, 0x28, 0x27, 0xfc, 0xed, 0x1f, 0xce,
0x81, 0xa9, 0x72, 0xc5, 0x76, 0x6a, 0xb6, 0x81, 0x6c, 0x73, 0x4d, 0x3e, 0x07, 0x2f, 0x02, 0x58,
0x2c, 0x17, 0xed, 0xa2, 0x61, 0x71, 0xa3, 0x63, 0xda, 0x85, 0x35, 0x19, 0xd0, 0x21, 0x90, 0x29,
0x58, 0xa6, 0xa8, 0xa5, 0x56, 0xdc, 0xb0, 0x4d, 0xb4, 0xc5, 0x2d, 0x17, 0xe0, 0x32, 0xb8, 0x56,
0x2b, 0x6e, 0x3c, 0xda, 0x2e, 0x72, 0x8c, 0x63, 0x94, 0xd7, 0x1c, 0x64, 0x6e, 0x55, 0x76, 0x4c,
0x67, 0xcd, 0xb0, 0x0d, 0x79, 0x91, 0xae, 0x79, 0xcd, 0xd8, 0x31, 0x9d, 0x5a, 0xd9, 0xa8, 0xd6,
0x36, 0x2b, 0xb6, 0xbc, 0x04, 0x6f, 0x80, 0xeb, 0x54, 0xb8, 0x82, 0x4c, 0x27, 0x1e, 0x60, 0x1d,
0x55, 0xb6, 0xfa, 0x10, 0x15, 0x5e, 0x06, 0x8b, 0x83, 0x5d, 0xcb, 0x94, 0x9d, 0x19, 0xd2, 0x40,
0x85, 0xcd, 0x62, 0x3c, 0xe6, 0x0a, 0xbc, 0x0b, 0x5e, 0x39, 0x2d, 0x2a, 0xf6, 0x5d, 0xb3, 0x2b,
0x55, 0xc7, 0xd8, 0x30, 0xcb, 0xb6, 0x7c, 0x1b, 0x5e, 0x07, 0x97, 0xf3, 0x96, 0x51, 0x28, 0x6d,
0x56, 0x2c, 0xd3, 0xa9, 0x9a, 0x26, 0x72, 0xaa, 0x15, 0x64, 0x3b, 0xf6, 0x13, 0x07, 0x3d, 0x91,
0x1b, 0x50, 0x05, 0x57, 0xb7, 0xcb, 0xc3, 0x01, 0x18, 0x5e, 0x01, 0x8b, 0x6b, 0xa6, 0x65, 0x7c,
0x90, 0x71, 0x3d, 0x97, 0xe0, 0x35, 0x70, 0x69, 0xbb, 0x3c, 0xd8, 0xfb, 0x99, 0xb4, 0xfa, 0x67,
0x00, 0x46, 0xe9, 0xa3, 0x11, 0x2a, 0xe0, 0x42, 0xbc, 0xb6, 0x74, 0x1b, 0xae, 0x57, 0x2c, 0xab,
0xf2, 0xd8, 0x44, 0xf2, 0xb9, 0x68, 0x36, 0x19, 0x8f, 0xb3, 0x5d, 0xb6, 0x8b, 0x96, 0x63, 0xa3,
0xe2, 0xc6, 0x86, 0x89, 0xfa, 0x2b, 0x24, 0xd1, 0xf3, 0x10, 0x13, 0x2c, 0xd3, 0x58, 0x63, 0x3b,
0xe2, 0x36, 0xb8, 0x95, 0xb4, 0x0d, 0xa3, 0xe7, 0x44, 0xfa, 0xa3, 0xed, 0x0a, 0xda, 0xde, 0x92,
0x47, 0xe9, 0xa6, 0x89, 0x6d, 0xf4, 0xcc, 0x8d, 0xc1, 0x9b, 0x40, 0x8d, 0x97, 0x58, 0x58, 0xdd,
0x44, 0xe4, 0x00, 0x3e, 0x00, 0x6f, 0xbc, 0x00, 0x34, 0x2c, 0x8a, 0x29, 0x9a, 0x92, 0x01, 0xdc,
0x68, 0x3e, 0xd3, 0xf0, 0x75, 0xf0, 0xda, 0x50, 0xf7, 0x30, 0xd1, 0x19, 0xb8, 0x0e, 0xf2, 0x03,
0x58, 0x7c, 0x96, 0x91, 0x85, 0xef, 0xcb, 0x48, 0x28, 0xa6, 0x46, 0x9b, 0xb0, 0x80, 0xe8, 0x29,
0x96, 0x67, 0xe1, 0x2a, 0x78, 0x79, 0xe8, 0x76, 0x48, 0x2e, 0x42, 0x03, 0x1a, 0xe0, 0xdd, 0xb3,
0x61, 0x87, 0x85, 0x8d, 0xe1, 0x4b, 0x60, 0x79, 0xb8, 0x44, 0xb4, 0x24, 0x7b, 0xf0, 0x1d, 0xf0,
0xe6, 0x8b, 0x50, 0xc3, 0x86, 0xd8, 0x3f, 0x7d, 0x88, 0x68, 0x1b, 0x1c, 0xd0, 0xb3, 0x37, 0x1c,
0x45, 0x37, 0x46, 0x13, 0xfe, 0x17, 0xd0, 0x06, 0x6e, 0xf6, 0xe4, 0xb2, 0x3c, 0x97, 0xe0, 0x1d,
0x70, 0x1b, 0x19, 0xe5, 0xb5, 0xca, 0x96, 0x73, 0x06, 0xfc, 0x67, 0x12, 0x7c, 0x0f, 0xbc, 0xfd,
0x62, 0xe0, 0xb0, 0x09, 0x7e, 0x2e, 0x41, 0x13, 0xbc, 0x7f, 0xe6, 0xf1, 0x86, 0xc9, 0x7c, 0x21,
0xc1, 0x1b, 0xe0, 0xda, 0x60, 0x7e, 0x94, 0x87, 0x2f, 0x25, 0xb8, 0x02, 0x6e, 0x9e, 0x3a, 0x52,
0x84, 0xfc, 0x4a, 0x82, 0x6f, 0x81, 0xfb, 0xa7, 0x41, 0x86, 0x85, 0xf1, 0x0b, 0x09, 0x3e, 0x04,
0x0f, 0xce, 0x30, 0xc6, 0x30, 0x81, 0x5f, 0x9e, 0x32, 0x8f, 0x28, 0xd9, 0x5f, 0xbf, 0x78, 0x1e,
0x11, 0xf2, 0x57, 0x12, 0x5c, 0x02, 0x97, 0x07, 0x43, 0xe8, 0x9e, 0xf8, 0xb5, 0x04, 0x6f, 0x81,
0xe5, 0x53, 0x95, 0x28, 0xec, 0x37, 0x12, 0x54, 0xc0, 0x42, 0xb9, 0xe2, 0xac, 0x1b, 0x45, 0xcb,
0x79, 0x5c, 0xb4, 0x37, 0x9d, 0x9a, 0x8d, 0xcc, 0x5a, 0x4d, 0xfe, 0xc9, 0x08, 0x0d, 0x25, 0xe1,
0x29, 0x57, 0x22, 0xa7, 0xb3, 0x5e, 0x41, 0x8e, 0x55, 0xdc, 0x31, 0xcb, 0x14, 0xf9, 0xe9, 0x08,
0x9c, 0x03, 0x80, 0xc2, 0xaa, 0x95, 0x62, 0xd9, 0xae, 0xc9, 0xdf, 0xce, 0xc1, 0x19, 0x30, 0x61,
0x3e, 0xb1, 0x4d, 0x54, 0x36, 0x2c, 0xf9, 0x2f, 0xb9, 0x7b, 0x0f, 0xc1, 0xa4, 0x1d, 0xb8, 0x5e,
0xd8, 0xf6, 0x03, 0x02, 0xef, 0x89, 0x1f, 0xb3, 0xd1, 0x5f, 0xb1, 0xa2, 0xff, 0x98, 0x5f, 0x99,
0x3b, 0xf9, 0xe6, 0xff, 0x4c, 0xd5, 0xce, 0xad, 0x48, 0xaf, 0x49, 0xf9, 0x0b, 0xcf, 0xff, 0xb0,
0x74, 0xee, 0xf9, 0x37, 0x4b, 0xd2, 0xd7, 0xdf, 0x2c, 0x49, 0xbf, 0xff, 0x66, 0x49, 0xfa, 0xe1,
0x1f, 0x97, 0xce, 0xed, 0x8e, 0xb3, 0xff, 0xb8, 0xdf, 0xff, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff,
0x34, 0x49, 0xef, 0x9b, 0xba, 0x1f, 0x00, 0x00,
}

47
functional/rpcpb/rpc.proto
View File

@ -138,7 +138,7 @@ message Tester {
// Stressers is the list of stresser types:
// KV, LEASE, ELECTION_RUNNER, WATCH_RUNNER, LOCK_RACER_RUNNER, LEASE_RUNNER.
repeated string Stressers = 101 [(gogoproto.moretags) = "yaml:\"stressers\""];
repeated Stresser Stressers = 101 [(gogoproto.moretags) = "yaml:\"stressers\""];
// Checkers is the list of consistency checker types:
// KV_HASH, LEASE_EXPIRE, NO_CHECK, RUNNER.
// Leave empty to skip consistency checks.
@ -164,6 +164,35 @@ message Tester {
int32 StressQPS = 302 [(gogoproto.moretags) = "yaml:\"stress-qps\""];
}
enum StresserType {
KV_WRITE_SMALL = 0;
KV_WRITE_LARGE = 1;
KV_READ_ONE_KEY = 2;
KV_READ_RANGE = 3;
KV_DELETE_ONE_KEY = 4;
KV_DELETE_RANGE = 5;
KV_TXN_WRITE_DELETE = 6;
LEASE = 10;
ELECTION_RUNNER = 20;
WATCH_RUNNER = 31;
LOCK_RACER_RUNNER = 41;
LEASE_RUNNER = 51;
}
message Stresser {
string Type = 1 [(gogoproto.moretags) = "yaml:\"type\""];
double Weight = 2 [(gogoproto.moretags) = "yaml:\"weight\""];
}
enum Checker {
KV_HASH = 0;
LEASE_EXPIRE = 1;
RUNNER = 2;
NO_CHECK = 3;
}
message Etcd {
string Name = 1 [(gogoproto.moretags) = "yaml:\"name\""];
string DataDir = 2 [(gogoproto.moretags) = "yaml:\"data-dir\""];
@ -596,19 +625,3 @@ enum Case {
// EXTERNAL runs external failure injection scripts.
EXTERNAL = 500;
}
enum Stresser {
KV = 0;
LEASE = 1;
ELECTION_RUNNER = 2;
WATCH_RUNNER = 3;
LOCK_RACER_RUNNER = 4;
LEASE_RUNNER = 5;
}
enum Checker {
KV_HASH = 0;
LEASE_EXPIRE = 1;
RUNNER = 2;
NO_CHECK = 3;
}

69
functional/tester/cluster_read_config.go
View File

@ -52,6 +52,41 @@ func read(lg *zap.Logger, fpath string) (*Cluster, error) {
}
}
if len(clus.Tester.Cases) == 0 {
return nil, errors.New("Cases not found")
}
if clus.Tester.DelayLatencyMs <= clus.Tester.DelayLatencyMsRv*5 {
return nil, fmt.Errorf("delay latency %d ms must be greater than 5x of delay latency random variable %d ms", clus.Tester.DelayLatencyMs, clus.Tester.DelayLatencyMsRv)
}
if clus.Tester.UpdatedDelayLatencyMs == 0 {
clus.Tester.UpdatedDelayLatencyMs = clus.Tester.DelayLatencyMs
}
for _, v := range clus.Tester.Cases {
if _, ok := rpcpb.Case_value[v]; !ok {
return nil, fmt.Errorf("%q is not defined in 'rpcpb.Case_value'", v)
}
}
for _, s := range clus.Tester.Stressers {
if _, ok := rpcpb.StresserType_value[s.Type]; !ok {
return nil, fmt.Errorf("unknown 'StresserType' %+v", s)
}
}
for _, v := range clus.Tester.Checkers {
if _, ok := rpcpb.Checker_value[v]; !ok {
return nil, fmt.Errorf("Checker is unknown; got %q", v)
}
}
if clus.Tester.StressKeySuffixRangeTxn > 100 {
return nil, fmt.Errorf("StressKeySuffixRangeTxn maximum value is 100, got %v", clus.Tester.StressKeySuffixRangeTxn)
}
if clus.Tester.StressKeyTxnOps > 64 {
return nil, fmt.Errorf("StressKeyTxnOps maximum value is 64, got %v", clus.Tester.StressKeyTxnOps)
}
for i, mem := range clus.Members {
if mem.EtcdExec == "embed" && failpointsEnabled {
return nil, errors.New("EtcdExec 'embed' cannot be run with failpoints enabled")
@ -337,39 +372,5 @@ func read(lg *zap.Logger, fpath string) (*Cluster, error) {
}
}
if len(clus.Tester.Cases) == 0 {
return nil, errors.New("Cases not found")
}
if clus.Tester.DelayLatencyMs <= clus.Tester.DelayLatencyMsRv*5 {
return nil, fmt.Errorf("delay latency %d ms must be greater than 5x of delay latency random variable %d ms", clus.Tester.DelayLatencyMs, clus.Tester.DelayLatencyMsRv)
}
if clus.Tester.UpdatedDelayLatencyMs == 0 {
clus.Tester.UpdatedDelayLatencyMs = clus.Tester.DelayLatencyMs
}
for _, v := range clus.Tester.Cases {
if _, ok := rpcpb.Case_value[v]; !ok {
return nil, fmt.Errorf("%q is not defined in 'rpcpb.Case_value'", v)
}
}
for _, v := range clus.Tester.Stressers {
if _, ok := rpcpb.Stresser_value[v]; !ok {
return nil, fmt.Errorf("Stresser is unknown; got %q", v)
}
}
for _, v := range clus.Tester.Checkers {
if _, ok := rpcpb.Checker_value[v]; !ok {
return nil, fmt.Errorf("Checker is unknown; got %q", v)
}
}
if clus.Tester.StressKeySuffixRangeTxn > 100 {
return nil, fmt.Errorf("StressKeySuffixRangeTxn maximum value is 100, got %v", clus.Tester.StressKeySuffixRangeTxn)
}
if clus.Tester.StressKeyTxnOps > 64 {
return nil, fmt.Errorf("StressKeyTxnOps maximum value is 64, got %v", clus.Tester.StressKeyTxnOps)
}
return clus, err
}

17
functional/tester/cluster_test.go
View File

@ -232,10 +232,19 @@ func Test_read(t *testing.T) {
"NO_FAIL_WITH_STRESS",
"NO_FAIL_WITH_NO_STRESS_FOR_LIVENESS",
},
FailpointCommands: []string{`panic("etcd-tester")`},
RunnerExecPath: "./bin/etcd-runner",
ExternalExecPath: "",
Stressers: []string{"KV", "LEASE"},
FailpointCommands: []string{`panic("etcd-tester")`},
RunnerExecPath: "./bin/etcd-runner",
ExternalExecPath: "",
Stressers: []*rpcpb.Stresser{
{Type: "KV_WRITE_SMALL", Weight: 0.35},
{Type: "KV_WRITE_LARGE", Weight: 0.002},
{Type: "KV_READ_ONE_KEY", Weight: 0.07},
{Type: "KV_READ_RANGE", Weight: 0.07},
{Type: "KV_DELETE_ONE_KEY", Weight: 0.07},
{Type: "KV_DELETE_RANGE", Weight: 0.07},
{Type: "KV_TXN_WRITE_DELETE", Weight: 0.35},
{Type: "LEASE", Weight: 0.0},
},
Checkers: []string{"KV_HASH", "LEASE_EXPIRE"},
StressKeySize: 100,
StressKeySizeLarge: 32769,

94
functional/tester/stresser.go
View File

@ -37,40 +37,60 @@ type Stresser interface {
// newStresser creates stresser from a comma separated list of stresser types.
func newStresser(clus *Cluster, m *rpcpb.Member) (stressers []Stresser) {
stressers = make([]Stresser, len(clus.Tester.Stressers))
for i, stype := range clus.Tester.Stressers {
// TODO: Too intensive stressing clients can panic etcd member with
// 'out of memory' error. Put rate limits in server side.
ks := &keyStresser{
lg: clus.lg,
m: m,
keySize: int(clus.Tester.StressKeySize),
keyLargeSize: int(clus.Tester.StressKeySizeLarge),
keySuffixRange: int(clus.Tester.StressKeySuffixRange),
keyTxnSuffixRange: int(clus.Tester.StressKeySuffixRangeTxn),
keyTxnOps: int(clus.Tester.StressKeyTxnOps),
clientsN: int(clus.Tester.StressClients),
rateLimiter: clus.rateLimiter,
}
ksExist := false
for _, s := range clus.Tester.Stressers {
clus.lg.Info(
"creating stresser",
zap.String("type", stype),
zap.String("type", s.Type),
zap.Float64("weight", s.Weight),
zap.String("endpoint", m.EtcdClientEndpoint),
)
switch stype {
case "KV":
// TODO: Too intensive stressing clients can panic etcd member with
// 'out of memory' error. Put rate limits in server side.
stressers[i] = &keyStresser{
stype: rpcpb.Stresser_KV,
lg: clus.lg,
m: m,
keySize: int(clus.Tester.StressKeySize),
keyLargeSize: int(clus.Tester.StressKeySizeLarge),
keySuffixRange: int(clus.Tester.StressKeySuffixRange),
keyTxnSuffixRange: int(clus.Tester.StressKeySuffixRangeTxn),
keyTxnOps: int(clus.Tester.StressKeyTxnOps),
clientsN: int(clus.Tester.StressClients),
rateLimiter: clus.rateLimiter,
}
switch s.Type {
case "KV_WRITE_SMALL":
ksExist = true
ks.weightKVWriteSmall = s.Weight
case "KV_WRITE_LARGE":
ksExist = true
ks.weightKVWriteLarge = s.Weight
case "KV_READ_ONE_KEY":
ksExist = true
ks.weightKVReadOneKey = s.Weight
case "KV_READ_RANGE":
ksExist = true
ks.weightKVReadRange = s.Weight
case "KV_DELETE_ONE_KEY":
ksExist = true
ks.weightKVDeleteOneKey = s.Weight
case "KV_DELETE_RANGE":
ksExist = true
ks.weightKVDeleteRange = s.Weight
case "KV_TXN_WRITE_DELETE":
ksExist = true
ks.weightKVTxnWriteDelete = s.Weight
case "LEASE":
stressers[i] = &leaseStresser{
stype: rpcpb.Stresser_LEASE,
stressers = append(stressers, &leaseStresser{
stype: rpcpb.StresserType_LEASE,
lg: clus.lg,
m: m,
numLeases: 10, // TODO: configurable
keysPerLease: 10, // TODO: configurable
rateLimiter: clus.rateLimiter,
}
})
case "ELECTION_RUNNER":
reqRate := 100
@ -83,15 +103,15 @@ func newStresser(clus *Cluster, m *rpcpb.Member) (stressers []Stresser) {
"--rounds=0", // runs forever
"--req-rate", fmt.Sprintf("%v", reqRate),
}
stressers[i] = newRunnerStresser(
rpcpb.Stresser_ELECTION_RUNNER,
stressers = append(stressers, newRunnerStresser(
rpcpb.StresserType_ELECTION_RUNNER,
m.EtcdClientEndpoint,
clus.lg,
clus.Tester.RunnerExecPath,
args,
clus.rateLimiter,
reqRate,
)
))
case "WATCH_RUNNER":
reqRate := 100
@ -105,15 +125,15 @@ func newStresser(clus *Cluster, m *rpcpb.Member) (stressers []Stresser) {
"--rounds=0", // runs forever
"--req-rate", fmt.Sprintf("%v", reqRate),
}
stressers[i] = newRunnerStresser(
rpcpb.Stresser_WATCH_RUNNER,
stressers = append(stressers, newRunnerStresser(
rpcpb.StresserType_WATCH_RUNNER,
m.EtcdClientEndpoint,
clus.lg,
clus.Tester.RunnerExecPath,
args,
clus.rateLimiter,
reqRate,
)
))
case "LOCK_RACER_RUNNER":
reqRate := 100
@ -125,15 +145,15 @@ func newStresser(clus *Cluster, m *rpcpb.Member) (stressers []Stresser) {
"--rounds=0", // runs forever
"--req-rate", fmt.Sprintf("%v", reqRate),
}
stressers[i] = newRunnerStresser(
rpcpb.Stresser_LOCK_RACER_RUNNER,
stressers = append(stressers, newRunnerStresser(
rpcpb.StresserType_LOCK_RACER_RUNNER,
m.EtcdClientEndpoint,
clus.lg,
clus.Tester.RunnerExecPath,
args,
clus.rateLimiter,
reqRate,
)
))
case "LEASE_RUNNER":
args := []string{
@ -141,16 +161,20 @@ func newStresser(clus *Cluster, m *rpcpb.Member) (stressers []Stresser) {
"--ttl=30",
"--endpoints", m.EtcdClientEndpoint,
}
stressers[i] = newRunnerStresser(
rpcpb.Stresser_LEASE_RUNNER,
stressers = append(stressers, newRunnerStresser(
rpcpb.StresserType_LEASE_RUNNER,
m.EtcdClientEndpoint,
clus.lg,
clus.Tester.RunnerExecPath,
args,
clus.rateLimiter,
0,
)
))
}
}
if ksExist {
return append(stressers, ks)
}
return stressers
}

55
functional/tester/stresser_key.go
View File

@ -36,11 +36,18 @@ import (
)
type keyStresser struct {
stype rpcpb.Stresser
lg *zap.Logger
lg *zap.Logger
m *rpcpb.Member
weightKVWriteSmall float64
weightKVWriteLarge float64
weightKVReadOneKey float64
weightKVReadRange float64
weightKVDeleteOneKey float64
weightKVDeleteRange float64
weightKVTxnWriteDelete float64
keySize int
keyLargeSize int
keySuffixRange int
@ -75,26 +82,16 @@ func (s *keyStresser) Stress() error {
s.ctx, s.cancel = context.WithCancel(context.Background())
s.wg.Add(s.clientsN)
var stressEntries = []stressEntry{
{weight: 0.7, f: newStressPut(s.cli, s.keySuffixRange, s.keySize)},
{
weight: 0.7 * float32(s.keySize) / float32(s.keyLargeSize),
f: newStressPut(s.cli, s.keySuffixRange, s.keyLargeSize),
},
{weight: 0.07, f: newStressRange(s.cli, s.keySuffixRange)},
{weight: 0.07, f: newStressRangeInterval(s.cli, s.keySuffixRange)},
{weight: 0.07, f: newStressDelete(s.cli, s.keySuffixRange)},
{weight: 0.07, f: newStressDeleteInterval(s.cli, s.keySuffixRange)},
}
if s.keyTxnSuffixRange > 0 {
// adjust to make up ±70% of workloads with writes
stressEntries[0].weight = 0.35
stressEntries = append(stressEntries, stressEntry{
weight: 0.35,
f: newStressTxn(s.cli, s.keyTxnSuffixRange, s.keyTxnOps),
})
}
s.stressTable = createStressTable(stressEntries)
s.stressTable = createStressTable([]stressEntry{
{weight: s.weightKVWriteSmall, f: newStressPut(s.cli, s.keySuffixRange, s.keySize)},
{weight: s.weightKVWriteLarge, f: newStressPut(s.cli, s.keySuffixRange, s.keyLargeSize)},
{weight: s.weightKVReadOneKey, f: newStressRange(s.cli, s.keySuffixRange)},
{weight: s.weightKVReadRange, f: newStressRangeInterval(s.cli, s.keySuffixRange)},
{weight: s.weightKVDeleteOneKey, f: newStressDelete(s.cli, s.keySuffixRange)},
{weight: s.weightKVDeleteRange, f: newStressDeleteInterval(s.cli, s.keySuffixRange)},
{weight: s.weightKVTxnWriteDelete, f: newStressTxn(s.cli, s.keyTxnSuffixRange, s.keyTxnOps)},
})
s.emu.Lock()
s.paused = false
@ -106,7 +103,7 @@ func (s *keyStresser) Stress() error {
s.lg.Info(
"stress START",
zap.String("stress-type", s.stype.String()),
zap.String("stress-type", "KV"),
zap.String("endpoint", s.m.EtcdClientEndpoint),
)
return nil
@ -163,7 +160,7 @@ func (s *keyStresser) run() {
default:
s.lg.Warn(
"stress run exiting",
zap.String("stress-type", s.stype.String()),
zap.String("stress-type", "KV"),
zap.String("endpoint", s.m.EtcdClientEndpoint),
zap.String("error-type", reflect.TypeOf(err).String()),
zap.String("error-desc", rpctypes.ErrorDesc(err)),
@ -198,7 +195,7 @@ func (s *keyStresser) Close() map[string]int {
s.lg.Info(
"stress STOP",
zap.String("stress-type", s.stype.String()),
zap.String("stress-type", "KV"),
zap.String("endpoint", s.m.EtcdClientEndpoint),
)
return ess
@ -211,13 +208,13 @@ func (s *keyStresser) ModifiedKeys() int64 {
type stressFunc func(ctx context.Context) (err error, modifiedKeys int64)
type stressEntry struct {
weight float32
weight float64
f stressFunc
}
type stressTable struct {
entries []stressEntry
sumWeights float32
sumWeights float64
}
func createStressTable(entries []stressEntry) *stressTable {
@ -229,8 +226,8 @@ func createStressTable(entries []stressEntry) *stressTable {
}
func (st *stressTable) choose() stressFunc {
v := rand.Float32() * st.sumWeights
var sum float32
v := rand.Float64() * st.sumWeights
var sum float64
var idx int
for i := range st.entries {
sum += st.entries[i].weight

2
functional/tester/stresser_lease.go
View File

@ -38,7 +38,7 @@ const (
)
type leaseStresser struct {
stype rpcpb.Stresser
stype rpcpb.StresserType
lg *zap.Logger
m *rpcpb.Member

4
functional/tester/stresser_runner.go
View File

@ -27,7 +27,7 @@ import (
)
type runnerStresser struct {
stype rpcpb.Stresser
stype rpcpb.StresserType
etcdClientEndpoint string
lg *zap.Logger
@ -42,7 +42,7 @@ type runnerStresser struct {
}
func newRunnerStresser(
stype rpcpb.Stresser,
stype rpcpb.StresserType,
ep string,
lg *zap.Logger,
cmdStr string,