zolfa
/
tendermint
1
0
Fork 0
Code Issues 0 Pull Requests 0 Projects 0 Releases 221 Wiki Activity
Browse Source

abci: fix protobuf lint issues 

Fix some linter issues to conform with the Protobuf style guide.

The state sync enum changes are ok to break since it's not released yet. Personally I find the uppercase kind of ugly, but that's what the guide says. Couldn't find a way to generate camel case in Go, short of specifying custom names for each and every enum variant.

Another option would be to simply disable the enum case lint.
pull/4816/head
Erik Grinaker 5 years ago
committed by GitHub
parent
678010c45e
commit
81c2798df0
No known key found for this signature in database GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 304 additions and 296 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +2
    -2
      abci/example/kvstore/persistent_kvstore.go
  2. +218
    -216
      abci/types/types.pb.go
  3. +30
    -24
      abci/types/types.proto
  4. +10
    -10
      statesync/syncer.go
  5. +44
    -44
      statesync/syncer_test.go

+ 2
- 2
abci/example/kvstore/persistent_kvstore.go View File

@ -156,12 +156,12 @@ func (app *PersistentKVStoreApplication) LoadSnapshotChunk(
func (app *PersistentKVStoreApplication) OfferSnapshot(
req types.RequestOfferSnapshot) types.ResponseOfferSnapshot {
return types.ResponseOfferSnapshot{Result: types.ResponseOfferSnapshot_abort}
return types.ResponseOfferSnapshot{Result: types.ResponseOfferSnapshot_ABORT}
}
func (app *PersistentKVStoreApplication) ApplySnapshotChunk(
req types.RequestApplySnapshotChunk) types.ResponseApplySnapshotChunk {
return types.ResponseApplySnapshotChunk{Result: types.ResponseApplySnapshotChunk_abort}
return types.ResponseApplySnapshotChunk{Result: types.ResponseApplySnapshotChunk_ABORT}
}
//---------------------------------------------


+ 218
- 216
abci/types/types.pb.go View File

@ -64,27 +64,27 @@ func (CheckTxType) EnumDescriptor() ([]byte, []int) {
type ResponseOfferSnapshot_Result int32
const (
ResponseOfferSnapshot_accept ResponseOfferSnapshot_Result = 0
ResponseOfferSnapshot_abort ResponseOfferSnapshot_Result = 1
ResponseOfferSnapshot_reject ResponseOfferSnapshot_Result = 2
ResponseOfferSnapshot_reject_format ResponseOfferSnapshot_Result = 3
ResponseOfferSnapshot_reject_sender ResponseOfferSnapshot_Result = 4
ResponseOfferSnapshot_ACCEPT ResponseOfferSnapshot_Result = 0
ResponseOfferSnapshot_ABORT ResponseOfferSnapshot_Result = 1
ResponseOfferSnapshot_REJECT ResponseOfferSnapshot_Result = 2
ResponseOfferSnapshot_REJECT_FORMAT ResponseOfferSnapshot_Result = 3
ResponseOfferSnapshot_REJECT_SENDER ResponseOfferSnapshot_Result = 4
)
var ResponseOfferSnapshot_Result_name = map[int32]string{
0: "accept",
1: "abort",
2: "reject",
3: "reject_format",
4: "reject_sender",
0: "ACCEPT",
1: "ABORT",
2: "REJECT",
3: "REJECT_FORMAT",
4: "REJECT_SENDER",
}
var ResponseOfferSnapshot_Result_value = map[string]int32{
"accept": 0,
"abort": 1,
"reject": 2,
"reject_format": 3,
"reject_sender": 4,
"ACCEPT": 0,
"ABORT": 1,
"REJECT": 2,
"REJECT_FORMAT": 3,
"REJECT_SENDER": 4,
}
func (x ResponseOfferSnapshot_Result) String() string {
@ -98,27 +98,27 @@ func (ResponseOfferSnapshot_Result) EnumDescriptor() ([]byte, []int) {
type ResponseApplySnapshotChunk_Result int32
const (
ResponseApplySnapshotChunk_accept ResponseApplySnapshotChunk_Result = 0
ResponseApplySnapshotChunk_abort ResponseApplySnapshotChunk_Result = 1
ResponseApplySnapshotChunk_retry ResponseApplySnapshotChunk_Result = 2
ResponseApplySnapshotChunk_retry_snapshot ResponseApplySnapshotChunk_Result = 3
ResponseApplySnapshotChunk_reject_snapshot ResponseApplySnapshotChunk_Result = 4
ResponseApplySnapshotChunk_ACCEPT ResponseApplySnapshotChunk_Result = 0
ResponseApplySnapshotChunk_ABORT ResponseApplySnapshotChunk_Result = 1
ResponseApplySnapshotChunk_RETRY ResponseApplySnapshotChunk_Result = 2
ResponseApplySnapshotChunk_RETRY_SNAPSHOT ResponseApplySnapshotChunk_Result = 3
ResponseApplySnapshotChunk_REJECT_SNAPSHOT ResponseApplySnapshotChunk_Result = 4
)
var ResponseApplySnapshotChunk_Result_name = map[int32]string{
0: "accept",
1: "abort",
2: "retry",
3: "retry_snapshot",
4: "reject_snapshot",
0: "ACCEPT",
1: "ABORT",
2: "RETRY",
3: "RETRY_SNAPSHOT",
4: "REJECT_SNAPSHOT",
}
var ResponseApplySnapshotChunk_Result_value = map[string]int32{
"accept": 0,
"abort": 1,
"retry": 2,
"retry_snapshot": 3,
"reject_snapshot": 4,
"ACCEPT": 0,
"ABORT": 1,
"RETRY": 2,
"RETRY_SNAPSHOT": 3,
"REJECT_SNAPSHOT": 4,
}
func (x ResponseApplySnapshotChunk_Result) String() string {
@ -2404,7 +2404,7 @@ func (m *ResponseOfferSnapshot) GetResult() ResponseOfferSnapshot_Result {
if m != nil {
return m.Result
}
return ResponseOfferSnapshot_accept
return ResponseOfferSnapshot_ACCEPT
}
type ResponseLoadSnapshotChunk struct {
@ -2500,7 +2500,7 @@ func (m *ResponseApplySnapshotChunk) GetResult() ResponseApplySnapshotChunk_Resu
if m != nil {
return m.Result
}
return ResponseApplySnapshotChunk_accept
return ResponseApplySnapshotChunk_ACCEPT
}
func (m *ResponseApplySnapshotChunk) GetRefetchChunks() []uint32 {
@ -3734,190 +3734,192 @@ func init() { proto.RegisterFile("abci/types/types.proto", fileDescriptor_9f1eaa
func init() { golang_proto.RegisterFile("abci/types/types.proto", fileDescriptor_9f1eaa49c51fa1ac) }
var fileDescriptor_9f1eaa49c51fa1ac = []byte{
// 2928 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x5a, 0x3d, 0x90, 0x23, 0x47,
0xf5, 0xdf, 0x91, 0xb4, 0x92, 0xe6, 0x69, 0xf5, 0x71, 0x7d, 0xeb, 0xb3, 0xac, 0xbf, 0xbd, 0x7b,
0x35, 0xe7, 0xfb, 0xb2, 0xfd, 0xdf, 0x3d, 0xaf, 0xcb, 0x94, 0xcd, 0x19, 0x53, 0xab, 0xbd, 0x33,
0xda, 0xf2, 0xf9, 0x7c, 0x9e, 0xfb, 0xc0, 0x40, 0x95, 0x87, 0xd6, 0x4c, 0xaf, 0x34, 0x3e, 0x69,
0x66, 0x3c, 0xd3, 0x5a, 0xaf, 0x28, 0x02, 0x8a, 0x84, 0xa2, 0x8a, 0x00, 0x02, 0xaa, 0x48, 0xc8,
0x09, 0x09, 0xa8, 0xb2, 0x43, 0x12, 0xaa, 0x1c, 0x12, 0x10, 0x9f, 0x61, 0x21, 0x02, 0x42, 0x02,
0x42, 0xaa, 0x3f, 0xe6, 0x4b, 0x2b, 0x69, 0x46, 0xe6, 0x32, 0x92, 0xdd, 0xe9, 0x9e, 0xf7, 0x5e,
0x77, 0xbf, 0x9e, 0xfe, 0xbd, 0xdf, 0x7b, 0x6a, 0xb8, 0x80, 0xfb, 0xa6, 0xbd, 0x4b, 0xa7, 0x1e,
0x09, 0xc4, 0xdf, 0x1d, 0xcf, 0x77, 0xa9, 0x8b, 0x9e, 0xa1, 0xc4, 0xb1, 0x88, 0x3f, 0xb6, 0x1d,
0xba, 0xc3, 0x44, 0x76, 0xf8, 0xcb, 0xce, 0x15, 0x3a, 0xb4, 0x7d, 0xcb, 0xf0, 0xb0, 0x4f, 0xa7,
0xbb, 0x5c, 0x72, 0x77, 0xe0, 0x0e, 0xdc, 0xf8, 0x49, 0xa8, 0x77, 0x3a, 0xa6, 0x3f, 0xf5, 0xa8,
0xbb, 0x3b, 0x26, 0xfe, 0xe3, 0x11, 0x91, 0xff, 0xe4, 0xbb, 0xed, 0x81, 0xeb, 0x0e, 0x46, 0x44,
0xa8, 0xf7, 0x27, 0x47, 0xbb, 0xd4, 0x1e, 0x93, 0x80, 0xe2, 0xb1, 0x27, 0x05, 0xb6, 0x66, 0x05,
0xac, 0x89, 0x8f, 0xa9, 0xed, 0x3a, 0xe2, 0xbd, 0xf6, 0x8f, 0x2a, 0x54, 0x74, 0xf2, 0xc9, 0x84,
0x04, 0x14, 0xbd, 0x01, 0x25, 0x62, 0x0e, 0xdd, 0x76, 0xe1, 0xa2, 0x72, 0xad, 0xb6, 0xa7, 0xed,
0xcc, 0x9d, 0xf6, 0x8e, 0x94, 0xbe, 0x6d, 0x0e, 0xdd, 0xde, 0x9a, 0xce, 0x35, 0xd0, 0x4d, 0x58,
0x3f, 0x1a, 0x4d, 0x82, 0x61, 0xbb, 0xc8, 0x55, 0x2f, 0x2d, 0x57, 0x7d, 0x87, 0x89, 0xf6, 0xd6,
0x74, 0xa1, 0xc3, 0x86, 0xb5, 0x9d, 0x23, 0xb7, 0x5d, 0xca, 0x33, 0xec, 0xa1, 0x73, 0xc4, 0x87,
0x65, 0x1a, 0xa8, 0x07, 0x10, 0x10, 0x6a, 0xb8, 0x1e, 0x5b, 0x50, 0x7b, 0x9d, 0xeb, 0x5f, 0x5d,
0xae, 0x7f, 0x9f, 0xd0, 0xf7, 0xb9, 0x78, 0x6f, 0x4d, 0x57, 0x83, 0xb0, 0xc1, 0x2c, 0xd9, 0x8e,
0x4d, 0x0d, 0x73, 0x88, 0x6d, 0xa7, 0x5d, 0xce, 0x63, 0xe9, 0xd0, 0xb1, 0xe9, 0x01, 0x13, 0x67,
0x96, 0xec, 0xb0, 0xc1, 0x5c, 0xf1, 0xc9, 0x84, 0xf8, 0xd3, 0x76, 0x25, 0x8f, 0x2b, 0x3e, 0x60,
0xa2, 0xcc, 0x15, 0x5c, 0x07, 0xbd, 0x0b, 0xb5, 0x3e, 0x19, 0xd8, 0x8e, 0xd1, 0x1f, 0xb9, 0xe6,
0xe3, 0x76, 0x95, 0x9b, 0xb8, 0xb6, 0xdc, 0x44, 0x97, 0x29, 0x74, 0x99, 0x7c, 0x6f, 0x4d, 0x87,
0x7e, 0xd4, 0x42, 0x5d, 0xa8, 0x9a, 0x43, 0x62, 0x3e, 0x36, 0xe8, 0x49, 0x5b, 0xe5, 0x96, 0x2e,
0x2f, 0xb7, 0x74, 0xc0, 0xa4, 0x1f, 0x9c, 0xf4, 0xd6, 0xf4, 0x8a, 0x29, 0x1e, 0x99, 0x5f, 0x2c,
0x32, 0xb2, 0x8f, 0x89, 0xcf, 0xac, 0x9c, 0xcf, 0xe3, 0x97, 0x5b, 0x42, 0x9e, 0xdb, 0x51, 0xad,
0xb0, 0x81, 0x6e, 0x83, 0x4a, 0x1c, 0x4b, 0x2e, 0xac, 0xc6, 0x0d, 0x5d, 0xc9, 0xf8, 0xc2, 0x1c,
0x2b, 0x5c, 0x56, 0x95, 0xc8, 0x67, 0xf4, 0x36, 0x94, 0x4d, 0x77, 0x3c, 0xb6, 0x69, 0x7b, 0x83,
0xdb, 0x78, 0x31, 0x63, 0x49, 0x5c, 0xb6, 0xb7, 0xa6, 0x4b, 0x2d, 0xf4, 0x00, 0x1a, 0x23, 0x3b,
0xa0, 0x46, 0xe0, 0x60, 0x2f, 0x18, 0xba, 0x34, 0x68, 0xd7, 0xb9, 0x9d, 0x97, 0x97, 0xdb, 0xb9,
0x63, 0x07, 0xf4, 0x7e, 0xa8, 0xd2, 0x5b, 0xd3, 0xeb, 0xa3, 0x64, 0x07, 0xb3, 0xea, 0x1e, 0x1d,
0x11, 0x3f, 0x32, 0xdb, 0x6e, 0xe4, 0xb1, 0xfa, 0x3e, 0xd3, 0x09, 0xad, 0x30, 0xab, 0x6e, 0xb2,
0x03, 0x61, 0x38, 0x3f, 0x72, 0xb1, 0x15, 0x19, 0x35, 0xcc, 0xe1, 0xc4, 0x79, 0xdc, 0x6e, 0x72,
0xd3, 0xbb, 0x19, 0x13, 0x76, 0xb1, 0x15, 0x1a, 0x3a, 0x60, 0x6a, 0xbd, 0x35, 0xfd, 0xdc, 0x68,
0xb6, 0x13, 0x59, 0xb0, 0x89, 0x3d, 0x6f, 0x34, 0x9d, 0x1d, 0xa3, 0xc5, 0xc7, 0xb8, 0xb1, 0x7c,
0x8c, 0x7d, 0xa6, 0x39, 0x3b, 0x08, 0xc2, 0x67, 0x7a, 0xbb, 0x15, 0x58, 0x3f, 0xc6, 0xa3, 0x09,
0xd1, 0xae, 0x42, 0x2d, 0x01, 0x1f, 0xa8, 0x0d, 0x95, 0x31, 0x09, 0x02, 0x3c, 0x20, 0x6d, 0xe5,
0xa2, 0x72, 0x4d, 0xd5, 0xc3, 0xa6, 0xd6, 0x80, 0x8d, 0x24, 0x58, 0x68, 0xe3, 0x48, 0x91, 0x01,
0x00, 0x53, 0x3c, 0x26, 0x7e, 0xc0, 0x4e, 0xbd, 0x54, 0x94, 0x4d, 0x74, 0x09, 0xea, 0xfc, 0x13,
0x33, 0xc2, 0xf7, 0x0c, 0xcc, 0x4a, 0xfa, 0x06, 0xef, 0x7c, 0x24, 0x85, 0xb6, 0xa1, 0xe6, 0xed,
0x79, 0x91, 0x48, 0x91, 0x8b, 0x80, 0xb7, 0xe7, 0x49, 0x01, 0xed, 0xeb, 0xd0, 0x9a, 0xc5, 0x0b,
0xd4, 0x82, 0xe2, 0x63, 0x32, 0x95, 0xe3, 0xb1, 0x47, 0xb4, 0x29, 0x97, 0xc5, 0xc7, 0x50, 0x75,
0xb9, 0xc6, 0xdf, 0x16, 0x22, 0xe5, 0x08, 0x22, 0x18, 0xc6, 0x31, 0x64, 0xe6, 0xda, 0xb5, 0xbd,
0xce, 0x8e, 0x40, 0xe5, 0x9d, 0x10, 0x95, 0x77, 0x1e, 0x84, 0xb0, 0xdd, 0xad, 0x7e, 0xf1, 0x64,
0x7b, 0xed, 0xe7, 0x5f, 0x6e, 0x2b, 0x3a, 0xd7, 0x40, 0xcf, 0xb1, 0x53, 0x8c, 0x6d, 0xc7, 0xb0,
0x2d, 0x39, 0x4e, 0x85, 0xb7, 0x0f, 0x2d, 0xf4, 0x01, 0xb4, 0x4c, 0xd7, 0x09, 0x88, 0x13, 0x4c,
0x02, 0x16, 0x46, 0xf0, 0x38, 0x90, 0x00, 0xbc, 0xe8, 0x64, 0x1d, 0x84, 0xe2, 0xf7, 0xb8, 0xb4,
0xde, 0x34, 0xd3, 0x1d, 0xe8, 0x0e, 0xc0, 0x31, 0x1e, 0xd9, 0x16, 0xa6, 0xae, 0x1f, 0xb4, 0x4b,
0x17, 0x8b, 0x4b, 0x8c, 0x3d, 0x0a, 0x05, 0x1f, 0x7a, 0x16, 0xa6, 0xa4, 0x5b, 0x62, 0x33, 0xd7,
0x13, 0xfa, 0xe8, 0x0a, 0x34, 0xb1, 0xe7, 0x19, 0x01, 0xc5, 0x94, 0x18, 0xfd, 0x29, 0x25, 0x01,
0x07, 0xe9, 0x0d, 0xbd, 0x8e, 0x3d, 0xef, 0x3e, 0xeb, 0xed, 0xb2, 0x4e, 0xcd, 0x8a, 0x76, 0x9b,
0xe3, 0x21, 0x42, 0x50, 0xb2, 0x30, 0xc5, 0xdc, 0x5b, 0x1b, 0x3a, 0x7f, 0x66, 0x7d, 0x1e, 0xa6,
0x43, 0xe9, 0x03, 0xfe, 0x8c, 0x2e, 0x40, 0x79, 0x48, 0xec, 0xc1, 0x90, 0xf2, 0x65, 0x17, 0x75,
0xd9, 0x62, 0x1b, 0xe3, 0xf9, 0xee, 0x31, 0xe1, 0x21, 0xa5, 0xaa, 0x8b, 0x86, 0xf6, 0xcb, 0x02,
0x9c, 0x3b, 0x83, 0x99, 0xcc, 0xee, 0x10, 0x07, 0xc3, 0x70, 0x2c, 0xf6, 0x8c, 0x6e, 0x32, 0xbb,
0xd8, 0x22, 0xbe, 0x0c, 0x85, 0x2f, 0x2c, 0xf0, 0x40, 0x8f, 0x0b, 0xc9, 0x85, 0x4b, 0x15, 0xf4,
0x10, 0x5a, 0x23, 0x1c, 0x50, 0x43, 0x00, 0x8e, 0xc1, 0x43, 0x5b, 0x71, 0x29, 0xfc, 0xde, 0xc1,
0x21, 0x50, 0xb1, 0x8f, 0x5b, 0x9a, 0x6b, 0x8c, 0x52, 0xbd, 0xe8, 0x43, 0xd8, 0xec, 0x4f, 0x7f,
0x80, 0x1d, 0x6a, 0x3b, 0xc4, 0x38, 0xb3, 0x47, 0xdb, 0x0b, 0x4c, 0xdf, 0x3e, 0xb6, 0x2d, 0xe2,
0x98, 0xe1, 0xe6, 0x9c, 0x8f, 0x4c, 0x44, 0x9b, 0x17, 0x68, 0x1f, 0x42, 0x23, 0x1d, 0x00, 0x50,
0x03, 0x0a, 0xf4, 0x44, 0x7a, 0xa4, 0x40, 0x4f, 0xd0, 0xd7, 0xa0, 0xc4, 0xcc, 0x71, 0x6f, 0x34,
0x16, 0x46, 0x68, 0xa9, 0xfd, 0x60, 0xea, 0x11, 0x9d, 0xcb, 0x6b, 0x5a, 0x74, 0x12, 0xa2, 0xa0,
0x30, 0x6b, 0x5b, 0xbb, 0x0e, 0xcd, 0x19, 0xbc, 0x4f, 0x6c, 0xab, 0x92, 0xdc, 0x56, 0xad, 0x09,
0xf5, 0x14, 0xac, 0x6b, 0x17, 0x60, 0x73, 0x1e, 0x3e, 0x6b, 0x4e, 0xd4, 0x9f, 0x42, 0x58, 0x74,
0x13, 0xaa, 0x11, 0x40, 0x8b, 0x93, 0xb8, 0xc8, 0x6f, 0xa1, 0x8a, 0x1e, 0x29, 0xb0, 0x83, 0xc8,
0x3e, 0x66, 0xfe, 0xb1, 0x14, 0xf8, 0xf4, 0x2b, 0xd8, 0xf3, 0x7a, 0x38, 0x18, 0x6a, 0xdf, 0x87,
0xf6, 0x22, 0xd8, 0x9d, 0x59, 0x4c, 0x29, 0xfa, 0x46, 0x2f, 0x40, 0xf9, 0xc8, 0xf5, 0xc7, 0x98,
0x72, 0x63, 0x75, 0x5d, 0xb6, 0xd8, 0xb7, 0x2b, 0x20, 0xb8, 0xc8, 0xbb, 0x45, 0x43, 0x33, 0xe0,
0xb9, 0x85, 0xa0, 0xcb, 0x54, 0x6c, 0xc7, 0x22, 0xc2, 0xab, 0x75, 0x5d, 0x34, 0x62, 0x43, 0x62,
0xb2, 0xa2, 0xc1, 0x86, 0x0d, 0xf8, 0x8a, 0xb9, 0x7d, 0x55, 0x97, 0x2d, 0xed, 0x0f, 0x2a, 0x54,
0x75, 0x12, 0x78, 0x0c, 0x0f, 0x50, 0x0f, 0x54, 0x72, 0x62, 0x12, 0x41, 0xab, 0x94, 0x0c, 0x12,
0x22, 0x74, 0x6e, 0x87, 0xf2, 0x2c, 0xea, 0x47, 0xca, 0xe8, 0xcd, 0x14, 0xa5, 0xbc, 0x94, 0x65,
0x24, 0xc9, 0x29, 0xdf, 0x4a, 0x73, 0xca, 0x17, 0x33, 0x74, 0x67, 0x48, 0xe5, 0x9b, 0x29, 0x52,
0x99, 0x35, 0x70, 0x8a, 0x55, 0x1e, 0xce, 0x61, 0x95, 0x59, 0xcb, 0x5f, 0x40, 0x2b, 0x0f, 0xe7,
0xd0, 0xca, 0x6b, 0x99, 0x73, 0x99, 0xcb, 0x2b, 0xdf, 0x4a, 0xf3, 0xca, 0x2c, 0x77, 0xcc, 0x10,
0xcb, 0x3b, 0xf3, 0x88, 0xe5, 0xf5, 0x0c, 0x1b, 0x0b, 0x99, 0xe5, 0xc1, 0x19, 0x66, 0x79, 0x25,
0xc3, 0xd4, 0x1c, 0x6a, 0x79, 0x98, 0xa2, 0x96, 0x90, 0xcb, 0x37, 0x0b, 0xb8, 0xe5, 0x3b, 0x67,
0xb9, 0xe5, 0xd5, 0xac, 0x4f, 0x6d, 0x1e, 0xb9, 0xfc, 0xe6, 0x0c, 0xb9, 0xbc, 0x9c, 0xb5, 0xaa,
0x59, 0x76, 0xf9, 0x70, 0x01, 0xbb, 0x7c, 0x25, 0xc3, 0x50, 0x06, 0xbd, 0x7c, 0xb8, 0x80, 0x5e,
0x66, 0x99, 0xcd, 0xe0, 0x97, 0xfd, 0x65, 0xfc, 0xf2, 0x46, 0xd6, 0x94, 0xf3, 0x11, 0x4c, 0xb2,
0x94, 0x60, 0xbe, 0x9a, 0x31, 0xc8, 0xea, 0x0c, 0xf3, 0x3a, 0x8b, 0xf1, 0x33, 0x90, 0xc4, 0xa0,
0x90, 0xf8, 0xbe, 0xeb, 0x4b, 0xf2, 0x26, 0x1a, 0xda, 0x35, 0xc6, 0x3a, 0x62, 0xe0, 0x59, 0xc2,
0x46, 0x79, 0xe0, 0x49, 0xc0, 0x8c, 0xf6, 0xb9, 0x12, 0xeb, 0xf2, 0xe8, 0x9c, 0x64, 0x2c, 0xaa,
0x64, 0x2c, 0x09, 0x92, 0x5a, 0x48, 0x93, 0xd4, 0x6d, 0xa8, 0xb1, 0x50, 0x32, 0xc3, 0x3f, 0xb1,
0x17, 0xf2, 0x4f, 0xf4, 0x12, 0x9c, 0xe3, 0x1c, 0x42, 0x50, 0x59, 0x19, 0x3f, 0x4a, 0x3c, 0x18,
0x36, 0xd9, 0x0b, 0xf1, 0xe9, 0x8a, 0x40, 0xf2, 0xff, 0x70, 0x3e, 0x21, 0x1b, 0x85, 0x28, 0x41,
0xb4, 0x5a, 0x91, 0xf4, 0xbe, 0x8c, 0x55, 0xef, 0xc5, 0x0e, 0x8a, 0xb9, 0x2d, 0x82, 0x92, 0xe9,
0x5a, 0x44, 0x06, 0x10, 0xfe, 0xcc, 0xf8, 0xee, 0xc8, 0x1d, 0xc8, 0x30, 0xc1, 0x1e, 0x99, 0x54,
0x84, 0xa9, 0xaa, 0x00, 0x4b, 0xed, 0x77, 0x4a, 0x6c, 0x2f, 0xa6, 0xbb, 0xf3, 0x98, 0xa9, 0xf2,
0x34, 0x99, 0x69, 0xe1, 0xbf, 0x63, 0xa6, 0xda, 0xbf, 0x94, 0x78, 0x4b, 0x23, 0xce, 0xf9, 0xd5,
0x5c, 0x10, 0x87, 0xdf, 0x75, 0xbe, 0x41, 0x32, 0xfc, 0xca, 0x74, 0xa1, 0xcc, 0xb7, 0x21, 0x9d,
0x2e, 0x54, 0x44, 0x40, 0xe6, 0x0d, 0xf4, 0x3a, 0xe7, 0xaa, 0xee, 0x91, 0xc4, 0xe4, 0x14, 0x21,
0x11, 0x85, 0x9f, 0x1d, 0x59, 0xf1, 0xb9, 0xc7, 0xc4, 0x74, 0x21, 0x9d, 0xa0, 0x15, 0x6a, 0x8a,
0xfa, 0x3e, 0x0f, 0x2a, 0x9b, 0x7a, 0xe0, 0x61, 0x93, 0x70, 0x50, 0x55, 0xf5, 0xb8, 0x43, 0xb3,
0x00, 0x9d, 0x05, 0x77, 0x74, 0x17, 0xca, 0xe4, 0x98, 0x38, 0x94, 0xed, 0x11, 0x73, 0xeb, 0xf3,
0x0b, 0xc9, 0x24, 0x71, 0x68, 0xb7, 0xcd, 0x9c, 0xf9, 0xf7, 0x27, 0xdb, 0x2d, 0xa1, 0xf3, 0x8a,
0x3b, 0xb6, 0x29, 0x19, 0x7b, 0x74, 0xaa, 0x4b, 0x2b, 0xda, 0x4f, 0x0a, 0x8c, 0xd3, 0xa5, 0x80,
0x7f, 0xae, 0x7b, 0xc3, 0x43, 0x53, 0x48, 0xd0, 0xfc, 0x7c, 0x2e, 0x7f, 0x01, 0x60, 0x80, 0x03,
0xe3, 0x53, 0xec, 0x50, 0x62, 0x49, 0xbf, 0xab, 0x03, 0x1c, 0x7c, 0x9b, 0x77, 0x30, 0xaa, 0xc6,
0x5e, 0x4f, 0x02, 0x62, 0xf1, 0x0d, 0x28, 0xea, 0x95, 0x01, 0x0e, 0x1e, 0x06, 0xc4, 0x4a, 0xac,
0xb5, 0xf2, 0x34, 0xd6, 0x9a, 0xf6, 0x77, 0x75, 0xd6, 0xdf, 0x3f, 0x2d, 0xc4, 0xa7, 0x23, 0xa6,
0xc0, 0xff, 0x9b, 0xbe, 0xf8, 0x35, 0xcf, 0x8b, 0xd3, 0xd1, 0x17, 0x7d, 0x07, 0xce, 0x45, 0xa7,
0xd2, 0x98, 0xf0, 0xd3, 0x1a, 0x7e, 0x85, 0xab, 0x1d, 0xee, 0xd6, 0x71, 0xba, 0x3b, 0x40, 0x1f,
0xc1, 0xb3, 0x33, 0x18, 0x14, 0x0d, 0x50, 0x58, 0x09, 0x8a, 0x9e, 0x49, 0x43, 0x51, 0x68, 0x3f,
0xf6, 0x5e, 0xf1, 0xa9, 0x9c, 0x9a, 0x43, 0x96, 0x86, 0x25, 0x79, 0xc5, 0xdc, 0x6f, 0xe2, 0x12,
0xd4, 0x7d, 0x42, 0xb1, 0xed, 0x18, 0xa9, 0xcc, 0x77, 0x43, 0x74, 0x8a, 0x90, 0xa0, 0x3d, 0x82,
0x67, 0xe6, 0x32, 0x0b, 0xf4, 0x0d, 0x50, 0x63, 0x6a, 0xa2, 0x2c, 0xcd, 0x1c, 0xa3, 0x0c, 0x28,
0xd6, 0xd0, 0x3e, 0x53, 0x62, 0xc3, 0xe9, 0xcc, 0xea, 0x5d, 0x28, 0xfb, 0x24, 0x98, 0x8c, 0x44,
0x96, 0xd3, 0xd8, 0x7b, 0x6d, 0x15, 0x66, 0xc2, 0x7a, 0x27, 0x23, 0xaa, 0x4b, 0x13, 0xda, 0x07,
0x50, 0x16, 0x3d, 0x08, 0xa0, 0x8c, 0x4d, 0x16, 0xc5, 0x5b, 0x6b, 0x48, 0x85, 0x75, 0xdc, 0x77,
0x7d, 0xda, 0x52, 0x58, 0xb7, 0x4f, 0x3e, 0x26, 0x26, 0x6d, 0x15, 0xd0, 0x39, 0xe6, 0x10, 0xf6,
0x6c, 0x88, 0x04, 0xaa, 0x55, 0x4c, 0x74, 0x89, 0xe4, 0xa6, 0x55, 0xd2, 0x5e, 0x65, 0xf9, 0xd3,
0x02, 0xe2, 0x12, 0x67, 0x4a, 0x4a, 0x22, 0x53, 0xd2, 0x7e, 0x51, 0x80, 0xce, 0x62, 0x1e, 0x82,
0xee, 0xcd, 0xac, 0xf8, 0x8d, 0x95, 0xa9, 0xcc, 0xcc, 0xb2, 0xd1, 0x65, 0x68, 0xf8, 0xe4, 0x88,
0x50, 0x73, 0x28, 0x38, 0x92, 0x88, 0x72, 0x75, 0xbd, 0x2e, 0x7b, 0xb9, 0x52, 0x20, 0xc4, 0x12,
0xab, 0x13, 0xdf, 0x9f, 0xaa, 0xcb, 0x35, 0xdf, 0x17, 0x9d, 0xda, 0xfd, 0x2c, 0x27, 0xaa, 0xb0,
0xee, 0x13, 0xea, 0x4f, 0x5b, 0x05, 0x84, 0x98, 0x49, 0xea, 0xc7, 0x24, 0xad, 0x55, 0x44, 0xe7,
0xa1, 0x19, 0x0e, 0x13, 0x76, 0x96, 0xb4, 0x3f, 0x29, 0xd0, 0x9c, 0x39, 0x1e, 0xe8, 0x0d, 0x58,
0x17, 0xc4, 0x5b, 0x59, 0x5a, 0xbf, 0xe7, 0xe7, 0x5d, 0x9e, 0x28, 0xa1, 0x80, 0xf6, 0xa1, 0x4a,
0x64, 0x7d, 0x42, 0x1e, 0xc9, 0xcb, 0x19, 0x65, 0x0c, 0xa9, 0x1f, 0xa9, 0xa1, 0x5b, 0xa0, 0x46,
0x07, 0x3f, 0xa3, 0xf6, 0x15, 0xe1, 0x86, 0x34, 0x12, 0x2b, 0x6a, 0x07, 0x50, 0x4b, 0x4c, 0x0f,
0xfd, 0x1f, 0xa8, 0x63, 0x7c, 0x22, 0x0b, 0x56, 0xa2, 0x04, 0x51, 0x1d, 0xe3, 0x13, 0x5e, 0xab,
0x42, 0xcf, 0x42, 0x85, 0xbd, 0x1c, 0x60, 0x01, 0x23, 0x45, 0xbd, 0x3c, 0xc6, 0x27, 0xdf, 0xc2,
0x81, 0xf6, 0x33, 0x05, 0x1a, 0xe9, 0x79, 0xa2, 0x97, 0x01, 0x31, 0x59, 0x3c, 0x20, 0x86, 0x33,
0x19, 0x0b, 0x86, 0x16, 0x5a, 0x6c, 0x8e, 0xf1, 0xc9, 0xfe, 0x80, 0xdc, 0x9d, 0x8c, 0xf9, 0xd0,
0x01, 0x7a, 0x0f, 0x5a, 0xa1, 0x70, 0xf8, 0x1b, 0x8d, 0xf4, 0xca, 0x73, 0x67, 0xca, 0x85, 0xb7,
0xa4, 0x80, 0xa8, 0x16, 0xfe, 0xea, 0xcb, 0x6d, 0x45, 0x6f, 0x08, 0x7b, 0xe1, 0x1b, 0xed, 0x75,
0x68, 0xce, 0xac, 0x18, 0x69, 0x50, 0xf7, 0x26, 0x7d, 0xe3, 0x31, 0x99, 0x1a, 0xdc, 0x25, 0x1c,
0x01, 0x54, 0xbd, 0xe6, 0x4d, 0xfa, 0xef, 0x92, 0xe9, 0x03, 0xd6, 0xa5, 0x99, 0xd0, 0x48, 0x97,
0xa3, 0xd8, 0xe9, 0xf0, 0xdd, 0x89, 0x63, 0xf1, 0x79, 0xaf, 0xeb, 0xa2, 0x81, 0x6e, 0xc2, 0xfa,
0xb1, 0x2b, 0xb0, 0x74, 0x19, 0x8a, 0x3c, 0x72, 0x29, 0x49, 0x14, 0xb5, 0x84, 0x8e, 0x76, 0x97,
0x79, 0x8a, 0x38, 0x74, 0x9f, 0x52, 0xdf, 0xee, 0x4f, 0x28, 0x49, 0x16, 0x57, 0x37, 0xe6, 0x14,
0x57, 0x23, 0xb6, 0x14, 0x71, 0xad, 0xa2, 0xa8, 0xec, 0xf1, 0x86, 0xf6, 0x23, 0x05, 0xd6, 0xb9,
0x41, 0x06, 0x99, 0xbc, 0x52, 0x25, 0x79, 0x38, 0x7b, 0x46, 0x26, 0x00, 0x0e, 0x07, 0x0a, 0xe7,
0x7b, 0x79, 0x19, 0x58, 0x47, 0xd3, 0xea, 0x3e, 0x2f, 0x51, 0x7b, 0x33, 0x36, 0x90, 0x40, 0xee,
0x84, 0x59, 0xed, 0x9f, 0x25, 0x28, 0x8b, 0x72, 0x20, 0x7a, 0x3b, 0x5d, 0x9c, 0xae, 0xed, 0x6d,
0x2d, 0x72, 0x8e, 0x90, 0x92, 0xbe, 0x89, 0xb2, 0x83, 0x2b, 0xb3, 0x15, 0xdf, 0x6e, 0xed, 0xf4,
0xc9, 0x76, 0x85, 0x33, 0xeb, 0xc3, 0x5b, 0x71, 0xf9, 0x77, 0x51, 0xf5, 0x33, 0xac, 0x35, 0x97,
0x56, 0xae, 0x35, 0xf7, 0xa0, 0x9e, 0x48, 0x25, 0x6c, 0x4b, 0x16, 0x3f, 0xb6, 0x96, 0x1d, 0xe9,
0xc3, 0x5b, 0x72, 0xfe, 0xb5, 0x28, 0xd5, 0x38, 0xb4, 0xd0, 0xb5, 0x74, 0x11, 0x94, 0x67, 0x24,
0x82, 0x0a, 0x27, 0xea, 0x9a, 0x2c, 0x1f, 0x61, 0x87, 0x8d, 0x05, 0x36, 0x21, 0x22, 0x98, 0x71,
0x95, 0x75, 0xf0, 0x97, 0x57, 0xa1, 0x19, 0x93, 0x76, 0x21, 0x52, 0x15, 0x56, 0xe2, 0x6e, 0x2e,
0x78, 0x03, 0x36, 0x1d, 0x72, 0x42, 0x8d, 0x59, 0x69, 0x95, 0x4b, 0x23, 0xf6, 0xee, 0x51, 0x5a,
0xe3, 0x32, 0x34, 0x62, 0x7a, 0xc0, 0x65, 0x41, 0x94, 0xa6, 0xa3, 0x5e, 0x2e, 0x96, 0xac, 0xfa,
0xd5, 0x52, 0x55, 0xbf, 0x28, 0x49, 0x13, 0xf0, 0x2d, 0x8d, 0x6c, 0x70, 0x19, 0x9e, 0xa4, 0x09,
0xf8, 0x15, 0x66, 0x2e, 0x41, 0x3d, 0xc4, 0x2c, 0x21, 0x57, 0xe7, 0x72, 0x1b, 0x61, 0x27, 0x17,
0xba, 0x0e, 0x2d, 0xcf, 0x77, 0x3d, 0x37, 0x20, 0xbe, 0x81, 0x2d, 0xcb, 0x27, 0x41, 0xc0, 0x13,
0xfd, 0x0d, 0xbd, 0x19, 0xf6, 0xef, 0x8b, 0x6e, 0xed, 0x55, 0xa8, 0x84, 0xb9, 0xe2, 0x26, 0xac,
0x77, 0x23, 0xfc, 0x2d, 0xe9, 0xa2, 0xc1, 0x0e, 0xd4, 0xbe, 0xe7, 0xc9, 0x5f, 0x3f, 0xd8, 0xa3,
0x36, 0x82, 0x8a, 0xdc, 0xb0, 0xb9, 0x35, 0xef, 0xf7, 0x60, 0xc3, 0xc3, 0x3e, 0x5b, 0x46, 0xb2,
0xf2, 0xbd, 0xa8, 0xcc, 0x74, 0x0f, 0xfb, 0xf4, 0x3e, 0xa1, 0xa9, 0x02, 0x78, 0x8d, 0xeb, 0x8b,
0x2e, 0xed, 0x4d, 0xa8, 0xa7, 0x64, 0xd8, 0x34, 0xa9, 0x4b, 0xf1, 0x28, 0x84, 0x11, 0xde, 0x88,
0x66, 0x52, 0x88, 0x67, 0xa2, 0xdd, 0x04, 0x35, 0xda, 0x2b, 0x96, 0x44, 0x87, 0xae, 0x50, 0xa4,
0xfb, 0x45, 0x93, 0x17, 0xf9, 0xdd, 0x4f, 0x65, 0x21, 0xb3, 0xa8, 0x8b, 0x86, 0x46, 0x12, 0xb0,
0x27, 0x98, 0x1a, 0x7a, 0x0b, 0x2a, 0x12, 0xf6, 0xe4, 0x79, 0x5c, 0x54, 0xce, 0xbf, 0xc7, 0x71,
0x30, 0x2c, 0xe7, 0x0b, 0x54, 0x8c, 0x87, 0x29, 0x24, 0x87, 0xf9, 0x21, 0x54, 0x43, 0x68, 0x4b,
0xc7, 0x20, 0x31, 0xc2, 0xc5, 0xac, 0x18, 0x24, 0x07, 0x89, 0x15, 0xd9, 0xd7, 0x14, 0xd8, 0x03,
0x87, 0x58, 0x46, 0x7c, 0x04, 0xf9, 0x98, 0x55, 0xbd, 0x29, 0x5e, 0xdc, 0x09, 0xcf, 0x97, 0x76,
0x03, 0xca, 0x62, 0xae, 0x73, 0xf1, 0x6e, 0x0e, 0x6d, 0xd4, 0xfe, 0xa6, 0x40, 0x35, 0x0c, 0x4e,
0x73, 0x95, 0x52, 0x8b, 0x28, 0x7c, 0xd5, 0x45, 0x3c, 0x7d, 0x48, 0x7a, 0x05, 0x10, 0xff, 0x52,
0x8c, 0x63, 0x97, 0xda, 0xce, 0xc0, 0x10, 0x7b, 0x21, 0xb2, 0x9c, 0x16, 0x7f, 0xf3, 0x88, 0xbf,
0xb8, 0xc7, 0xb7, 0xe5, 0xc7, 0x0a, 0x54, 0x23, 0x4e, 0xba, 0x6a, 0xe5, 0xfd, 0x02, 0x94, 0x25,
0xef, 0x12, 0xa5, 0x77, 0xd9, 0x8a, 0xbe, 0xd1, 0x52, 0xe2, 0xb4, 0x74, 0xa0, 0x3a, 0x26, 0x14,
0x73, 0x3f, 0x8b, 0x4a, 0x4b, 0xd4, 0x7e, 0xe9, 0x12, 0xd4, 0x12, 0x3f, 0x85, 0xa0, 0x0a, 0x14,
0xef, 0x92, 0x4f, 0x5b, 0x6b, 0xa8, 0x06, 0x15, 0x9d, 0xf0, 0xea, 0x67, 0x4b, 0xd9, 0xfb, 0xac,
0x06, 0xcd, 0xfd, 0xee, 0xc1, 0x21, 0xa3, 0x85, 0xb6, 0xc9, 0x43, 0x36, 0x7a, 0x1f, 0x4a, 0xbc,
0x10, 0x95, 0xe3, 0xe6, 0x45, 0x27, 0x4f, 0x29, 0x1d, 0xe9, 0xb0, 0xce, 0xeb, 0x55, 0x28, 0xcf,
0x85, 0x8c, 0x4e, 0xae, 0x0a, 0x3b, 0x9b, 0x24, 0xff, 0xea, 0x73, 0xdc, 0xd3, 0xe8, 0xe4, 0x29,
0xbb, 0xa3, 0x8f, 0x40, 0x8d, 0x0b, 0x51, 0x79, 0x6f, 0x6f, 0x74, 0x72, 0x17, 0xe4, 0x99, 0xfd,
0x38, 0xf5, 0xce, 0x7b, 0x77, 0xa1, 0x93, 0xbb, 0x12, 0x8d, 0x3e, 0x84, 0x4a, 0x58, 0xe4, 0xc8,
0x77, 0xbf, 0xa2, 0x93, 0xb3, 0x58, 0xce, 0xb6, 0x4f, 0xd4, 0xa6, 0xf2, 0x5c, 0x22, 0xe9, 0xe4,
0xfa, 0x45, 0x00, 0x3d, 0x84, 0xb2, 0xcc, 0x2e, 0x73, 0xdd, 0x9c, 0xe8, 0xe4, 0x2b, 0x81, 0x33,
0x27, 0xc7, 0xd5, 0xbf, 0xbc, 0x17, 0x67, 0x3a, 0xb9, 0x7f, 0x0a, 0x41, 0x18, 0x20, 0x51, 0xb0,
0xca, 0x7d, 0x23, 0xa6, 0x93, 0xff, 0x27, 0x0e, 0xf4, 0x3d, 0xa8, 0x46, 0x65, 0x89, 0x9c, 0x37,
0x53, 0x3a, 0x79, 0x7f, 0x65, 0x40, 0x1f, 0x43, 0x3d, 0x9d, 0x89, 0xaf, 0x72, 0xdf, 0xa4, 0xb3,
0xd2, 0xcf, 0x07, 0x6c, 0xac, 0x74, 0x72, 0xbe, 0xca, 0x2d, 0x94, 0xce, 0x4a, 0xbf, 0x29, 0xa0,
0x63, 0x38, 0x77, 0x36, 0x9f, 0x5e, 0xf5, 0x6a, 0x4a, 0x67, 0xe5, 0xdf, 0x1a, 0xd0, 0x14, 0xd0,
0x9c, 0x9c, 0x7c, 0xe5, 0xfb, 0x2a, 0x9d, 0xd5, 0x7f, 0x80, 0xe8, 0x1e, 0xfe, 0xfb, 0x2f, 0x5b,
0xca, 0x6f, 0x4e, 0xb7, 0x94, 0xcf, 0x4f, 0xb7, 0x94, 0x2f, 0x4e, 0xb7, 0x94, 0x3f, 0x9e, 0x6e,
0x29, 0x7f, 0x3e, 0xdd, 0x52, 0x7e, 0xff, 0xd7, 0x2d, 0xe5, 0xbb, 0x2f, 0x0f, 0x6c, 0x3a, 0x9c,
0xf4, 0x77, 0x4c, 0x77, 0xbc, 0x1b, 0x9b, 0x4e, 0x3e, 0xc6, 0x97, 0x04, 0xfb, 0x65, 0x1e, 0x00,
0x5f, 0xfb, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x3d, 0xc7, 0x11, 0xb1, 0x39, 0x28, 0x00, 0x00,
// 2950 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x5a, 0x4d, 0x70, 0x23, 0x47,
0xf5, 0xf7, 0x48, 0xb2, 0xa4, 0x79, 0xb2, 0x3e, 0xb6, 0xd7, 0xd9, 0x28, 0xfa, 0x27, 0xf6, 0xd6,
0x6c, 0xf6, 0x2b, 0xc9, 0xdf, 0xde, 0x38, 0x15, 0x2a, 0x61, 0x43, 0x28, 0xcb, 0xeb, 0x20, 0x93,
0xfd, 0x70, 0xc6, 0xde, 0x25, 0x81, 0xaa, 0x0c, 0x2d, 0x4d, 0x5b, 0x9a, 0xac, 0x34, 0x33, 0x99,
0x69, 0x39, 0x16, 0xc5, 0x81, 0xe2, 0x42, 0x51, 0xc5, 0x01, 0x0e, 0x54, 0x71, 0xe1, 0xce, 0x91,
0x03, 0x55, 0xc9, 0x91, 0x0b, 0x55, 0x39, 0x72, 0xe0, 0x9c, 0xc0, 0xc2, 0x09, 0x38, 0x72, 0xe0,
0x48, 0xf5, 0xc7, 0x7c, 0xc9, 0x92, 0x66, 0x14, 0xf6, 0xc6, 0xc5, 0x9e, 0x7e, 0xf3, 0xde, 0xeb,
0xee, 0xd7, 0xd3, 0xbf, 0xfe, 0xbd, 0xa7, 0x86, 0x4b, 0xb8, 0xdb, 0xb3, 0xb6, 0xe9, 0xc4, 0x25,
0xbe, 0xf8, 0xbb, 0xe5, 0x7a, 0x0e, 0x75, 0xd0, 0x33, 0x94, 0xd8, 0x26, 0xf1, 0x46, 0x96, 0x4d,
0xb7, 0x98, 0xca, 0x16, 0x7f, 0xd9, 0x6a, 0xf5, 0xbc, 0x89, 0x4b, 0x9d, 0xed, 0x11, 0xf1, 0x1e,
0x0f, 0x89, 0xfc, 0x27, 0x4c, 0x5a, 0x1b, 0x7d, 0xc7, 0xe9, 0x0f, 0xc9, 0x36, 0x6f, 0x75, 0xc7,
0x27, 0xdb, 0xe6, 0xd8, 0xc3, 0xd4, 0x72, 0x6c, 0xf9, 0x7e, 0x73, 0xfa, 0x3d, 0xb5, 0x46, 0xc4,
0xa7, 0x78, 0xe4, 0x4a, 0x85, 0x6b, 0x74, 0x60, 0x79, 0xa6, 0xe1, 0x62, 0x8f, 0x4e, 0x84, 0xd6,
0x76, 0xdf, 0xe9, 0x3b, 0xd1, 0x93, 0xd0, 0xd3, 0xfe, 0x51, 0x86, 0x92, 0x4e, 0x3e, 0x1e, 0x13,
0x9f, 0xa2, 0x37, 0xa0, 0x40, 0x7a, 0x03, 0xa7, 0x99, 0xbb, 0xac, 0xdc, 0xa8, 0xec, 0x68, 0x5b,
0x33, 0x87, 0xbd, 0x25, 0xb5, 0xf7, 0x7b, 0x03, 0xa7, 0xb3, 0xa2, 0x73, 0x0b, 0x74, 0x1b, 0x56,
0x4f, 0x86, 0x63, 0x7f, 0xd0, 0xcc, 0x73, 0xd3, 0x2b, 0x8b, 0x4d, 0xdf, 0x61, 0xaa, 0x9d, 0x15,
0x5d, 0xd8, 0xb0, 0x6e, 0x2d, 0xfb, 0xc4, 0x69, 0x16, 0xb2, 0x74, 0x7b, 0x60, 0x9f, 0xf0, 0x6e,
0x99, 0x05, 0xea, 0x00, 0xf8, 0x84, 0x1a, 0x8e, 0xcb, 0x22, 0xd3, 0x5c, 0xe5, 0xf6, 0xd7, 0x17,
0xdb, 0x1f, 0x11, 0xfa, 0x80, 0xab, 0x77, 0x56, 0x74, 0xd5, 0x0f, 0x1a, 0xcc, 0x93, 0x65, 0x5b,
0xd4, 0xe8, 0x0d, 0xb0, 0x65, 0x37, 0x8b, 0x59, 0x3c, 0x1d, 0xd8, 0x16, 0xdd, 0x63, 0xea, 0xcc,
0x93, 0x15, 0x34, 0x58, 0x28, 0x3e, 0x1e, 0x13, 0x6f, 0xd2, 0x2c, 0x65, 0x09, 0xc5, 0x7b, 0x4c,
0x95, 0x85, 0x82, 0xdb, 0xa0, 0x77, 0xa1, 0xd2, 0x25, 0x7d, 0xcb, 0x36, 0xba, 0x43, 0xa7, 0xf7,
0xb8, 0x59, 0xe6, 0x2e, 0x6e, 0x2c, 0x76, 0xd1, 0x66, 0x06, 0x6d, 0xa6, 0xdf, 0x59, 0xd1, 0xa1,
0x1b, 0xb6, 0x50, 0x1b, 0xca, 0xbd, 0x01, 0xe9, 0x3d, 0x36, 0xe8, 0x59, 0x53, 0xe5, 0x9e, 0xae,
0x2e, 0xf6, 0xb4, 0xc7, 0xb4, 0x8f, 0xcf, 0x3a, 0x2b, 0x7a, 0xa9, 0x27, 0x1e, 0x59, 0x5c, 0x4c,
0x32, 0xb4, 0x4e, 0x89, 0xc7, 0xbc, 0x5c, 0xcc, 0x12, 0x97, 0x3b, 0x42, 0x9f, 0xfb, 0x51, 0xcd,
0xa0, 0x81, 0xf6, 0x41, 0x25, 0xb6, 0x29, 0x27, 0x56, 0xe1, 0x8e, 0xae, 0xa5, 0x7c, 0x61, 0xb6,
0x19, 0x4c, 0xab, 0x4c, 0xe4, 0x33, 0x7a, 0x1b, 0x8a, 0x3d, 0x67, 0x34, 0xb2, 0x68, 0x73, 0x8d,
0xfb, 0x78, 0x31, 0x65, 0x4a, 0x5c, 0xb7, 0xb3, 0xa2, 0x4b, 0x2b, 0x74, 0x0c, 0xb5, 0xa1, 0xe5,
0x53, 0xc3, 0xb7, 0xb1, 0xeb, 0x0f, 0x1c, 0xea, 0x37, 0xab, 0xdc, 0xcf, 0xcb, 0x8b, 0xfd, 0xdc,
0xb5, 0x7c, 0x7a, 0x14, 0x98, 0x74, 0x56, 0xf4, 0xea, 0x30, 0x2e, 0x60, 0x5e, 0x9d, 0x93, 0x13,
0xe2, 0x85, 0x6e, 0x9b, 0xb5, 0x2c, 0x5e, 0x1f, 0x30, 0x9b, 0xc0, 0x0b, 0xf3, 0xea, 0xc4, 0x05,
0x08, 0xc3, 0xc5, 0xa1, 0x83, 0xcd, 0xd0, 0xa9, 0xd1, 0x1b, 0x8c, 0xed, 0xc7, 0xcd, 0x3a, 0x77,
0xbd, 0x9d, 0x32, 0x60, 0x07, 0x9b, 0x81, 0xa3, 0x3d, 0x66, 0xd6, 0x59, 0xd1, 0x2f, 0x0c, 0xa7,
0x85, 0xc8, 0x84, 0x75, 0xec, 0xba, 0xc3, 0xc9, 0x74, 0x1f, 0x0d, 0xde, 0xc7, 0xad, 0xc5, 0x7d,
0xec, 0x32, 0xcb, 0xe9, 0x4e, 0x10, 0x3e, 0x27, 0x6d, 0x97, 0x60, 0xf5, 0x14, 0x0f, 0xc7, 0x44,
0xbb, 0x0e, 0x95, 0x18, 0x7c, 0xa0, 0x26, 0x94, 0x46, 0xc4, 0xf7, 0x71, 0x9f, 0x34, 0x95, 0xcb,
0xca, 0x0d, 0x55, 0x0f, 0x9a, 0x5a, 0x0d, 0xd6, 0xe2, 0x60, 0xa1, 0x8d, 0x42, 0x43, 0x06, 0x00,
0xcc, 0xf0, 0x94, 0x78, 0x3e, 0xdb, 0xf5, 0xd2, 0x50, 0x36, 0xd1, 0x15, 0xa8, 0xf2, 0x4f, 0xcc,
0x08, 0xde, 0x33, 0x30, 0x2b, 0xe8, 0x6b, 0x5c, 0xf8, 0x48, 0x2a, 0x6d, 0x42, 0xc5, 0xdd, 0x71,
0x43, 0x95, 0x3c, 0x57, 0x01, 0x77, 0xc7, 0x95, 0x0a, 0xda, 0xd7, 0xa1, 0x31, 0x8d, 0x17, 0xa8,
0x01, 0xf9, 0xc7, 0x64, 0x22, 0xfb, 0x63, 0x8f, 0x68, 0x5d, 0x4e, 0x8b, 0xf7, 0xa1, 0xea, 0x72,
0x8e, 0xbf, 0xcd, 0x85, 0xc6, 0x21, 0x44, 0x30, 0x8c, 0x63, 0x08, 0xcd, 0xad, 0x2b, 0x3b, 0xad,
0x2d, 0x01, 0xdf, 0x5b, 0x01, 0x7c, 0x6f, 0x1d, 0x07, 0xf0, 0xdd, 0x2e, 0x7f, 0xfe, 0xc5, 0xe6,
0xca, 0xcf, 0xbf, 0xdc, 0x54, 0x74, 0x6e, 0x81, 0x9e, 0x63, 0xbb, 0x18, 0x5b, 0xb6, 0x61, 0x99,
0xb2, 0x9f, 0x12, 0x6f, 0x1f, 0x98, 0xe8, 0x3d, 0x68, 0xf4, 0x1c, 0xdb, 0x27, 0xb6, 0x3f, 0xf6,
0x19, 0xd2, 0xe3, 0x91, 0x2f, 0x01, 0x78, 0xde, 0xce, 0xda, 0x0b, 0xd4, 0x0f, 0xb9, 0xb6, 0x5e,
0xef, 0x25, 0x05, 0xe8, 0x2e, 0xc0, 0x29, 0x1e, 0x5a, 0x26, 0xa6, 0x8e, 0xe7, 0x37, 0x0b, 0x97,
0xf3, 0x0b, 0x9c, 0x3d, 0x0a, 0x14, 0x1f, 0xba, 0x26, 0xa6, 0xa4, 0x5d, 0x60, 0x23, 0xd7, 0x63,
0xf6, 0xe8, 0x1a, 0xd4, 0xb1, 0xeb, 0x1a, 0x3e, 0xc5, 0x94, 0x18, 0xdd, 0x09, 0x25, 0x3e, 0x07,
0xe9, 0x35, 0xbd, 0x8a, 0x5d, 0xf7, 0x88, 0x49, 0xdb, 0x4c, 0xa8, 0x99, 0xe1, 0x6a, 0x73, 0x3c,
0x44, 0x08, 0x0a, 0x26, 0xa6, 0x98, 0x47, 0x6b, 0x4d, 0xe7, 0xcf, 0x4c, 0xe6, 0x62, 0x3a, 0x90,
0x31, 0xe0, 0xcf, 0xe8, 0x12, 0x14, 0x07, 0xc4, 0xea, 0x0f, 0x28, 0x9f, 0x76, 0x5e, 0x97, 0x2d,
0xb6, 0x30, 0xae, 0xe7, 0x9c, 0x12, 0x7e, 0xa4, 0x94, 0x75, 0xd1, 0xd0, 0x7e, 0x99, 0x83, 0x0b,
0xe7, 0x30, 0x93, 0xf9, 0x1d, 0x60, 0x7f, 0x10, 0xf4, 0xc5, 0x9e, 0xd1, 0x6d, 0xe6, 0x17, 0x9b,
0xc4, 0x93, 0x47, 0xe1, 0x0b, 0x73, 0x22, 0xd0, 0xe1, 0x4a, 0x72, 0xe2, 0xd2, 0x04, 0x3d, 0x84,
0xc6, 0x10, 0xfb, 0xd4, 0x10, 0x80, 0x63, 0xf0, 0xa3, 0x2d, 0xbf, 0x10, 0x7e, 0xef, 0xe2, 0x00,
0xa8, 0xd8, 0xc7, 0x2d, 0xdd, 0xd5, 0x86, 0x09, 0x29, 0x7a, 0x1f, 0xd6, 0xbb, 0x93, 0x1f, 0x60,
0x9b, 0x5a, 0x36, 0x31, 0xce, 0xad, 0xd1, 0xe6, 0x1c, 0xd7, 0xfb, 0xa7, 0x96, 0x49, 0xec, 0x5e,
0xb0, 0x38, 0x17, 0x43, 0x17, 0xe1, 0xe2, 0xf9, 0xda, 0xfb, 0x50, 0x4b, 0x1e, 0x00, 0xa8, 0x06,
0x39, 0x7a, 0x26, 0x23, 0x92, 0xa3, 0x67, 0xe8, 0x6b, 0x50, 0x60, 0xee, 0x78, 0x34, 0x6a, 0x73,
0x4f, 0x68, 0x69, 0x7d, 0x3c, 0x71, 0x89, 0xce, 0xf5, 0x35, 0x2d, 0xdc, 0x09, 0xe1, 0xa1, 0x30,
0xed, 0x5b, 0xbb, 0x09, 0xf5, 0x29, 0xbc, 0x8f, 0x2d, 0xab, 0x12, 0x5f, 0x56, 0xad, 0x0e, 0xd5,
0x04, 0xac, 0x6b, 0x97, 0x60, 0x7d, 0x16, 0x3e, 0x6b, 0x76, 0x28, 0x4f, 0x20, 0x2c, 0xba, 0x0d,
0xe5, 0x10, 0xa0, 0xc5, 0x4e, 0x9c, 0x17, 0xb7, 0xc0, 0x44, 0x0f, 0x0d, 0xd8, 0x46, 0x64, 0x1f,
0x33, 0xff, 0x58, 0x72, 0x7c, 0xf8, 0x25, 0xec, 0xba, 0x1d, 0xec, 0x0f, 0xb4, 0xef, 0x43, 0x73,
0x1e, 0xec, 0x4e, 0x4d, 0xa6, 0x10, 0x7e, 0xa3, 0x97, 0xa0, 0x78, 0xe2, 0x78, 0x23, 0x4c, 0xb9,
0xb3, 0xaa, 0x2e, 0x5b, 0xec, 0xdb, 0x15, 0x10, 0x9c, 0xe7, 0x62, 0xd1, 0xd0, 0x0c, 0x78, 0x6e,
0x2e, 0xe8, 0x32, 0x13, 0xcb, 0x36, 0x89, 0x88, 0x6a, 0x55, 0x17, 0x8d, 0xc8, 0x91, 0x18, 0xac,
0x68, 0xb0, 0x6e, 0x7d, 0x3e, 0x63, 0xee, 0x5f, 0xd5, 0x65, 0x4b, 0xfb, 0x83, 0x0a, 0x65, 0x9d,
0xf8, 0x2e, 0xc3, 0x03, 0xd4, 0x01, 0x95, 0x9c, 0xf5, 0x88, 0xa0, 0x55, 0x4a, 0x0a, 0x09, 0x11,
0x36, 0xfb, 0x81, 0x3e, 0x3b, 0xf5, 0x43, 0x63, 0xf4, 0x66, 0x82, 0x52, 0x5e, 0x49, 0x73, 0x12,
0xe7, 0x94, 0x6f, 0x25, 0x39, 0xe5, 0x8b, 0x29, 0xb6, 0x53, 0xa4, 0xf2, 0xcd, 0x04, 0xa9, 0x4c,
0xeb, 0x38, 0xc1, 0x2a, 0x0f, 0x66, 0xb0, 0xca, 0xb4, 0xe9, 0xcf, 0xa1, 0x95, 0x07, 0x33, 0x68,
0xe5, 0x8d, 0xd4, 0xb1, 0xcc, 0xe4, 0x95, 0x6f, 0x25, 0x79, 0x65, 0x5a, 0x38, 0xa6, 0x88, 0xe5,
0xdd, 0x59, 0xc4, 0xf2, 0x66, 0x8a, 0x8f, 0xb9, 0xcc, 0x72, 0xef, 0x1c, 0xb3, 0xbc, 0x96, 0xe2,
0x6a, 0x06, 0xb5, 0x3c, 0x48, 0x50, 0x4b, 0xc8, 0x14, 0x9b, 0x39, 0xdc, 0xf2, 0x9d, 0xf3, 0xdc,
0xf2, 0x7a, 0xda, 0xa7, 0x36, 0x8b, 0x5c, 0x7e, 0x73, 0x8a, 0x5c, 0x5e, 0x4d, 0x9b, 0xd5, 0x34,
0xbb, 0x7c, 0x38, 0x87, 0x5d, 0xbe, 0x92, 0xe2, 0x28, 0x85, 0x5e, 0x3e, 0x9c, 0x43, 0x2f, 0xd3,
0xdc, 0xa6, 0xf0, 0xcb, 0xee, 0x22, 0x7e, 0x79, 0x2b, 0x6d, 0xc8, 0xd9, 0x08, 0x26, 0x59, 0x48,
0x30, 0x5f, 0x4d, 0xe9, 0x64, 0x79, 0x86, 0x79, 0x93, 0x9d, 0xf1, 0x53, 0x90, 0xc4, 0xa0, 0x90,
0x78, 0x9e, 0xe3, 0x49, 0xf2, 0x26, 0x1a, 0xda, 0x0d, 0xc6, 0x3a, 0x22, 0xe0, 0x59, 0xc0, 0x46,
0xf9, 0xc1, 0x13, 0x83, 0x19, 0xed, 0x33, 0x25, 0xb2, 0xe5, 0xa7, 0x73, 0x9c, 0xb1, 0xa8, 0x92,
0xb1, 0xc4, 0x48, 0x6a, 0x2e, 0x49, 0x52, 0x37, 0xa1, 0xc2, 0x8e, 0x92, 0x29, 0xfe, 0x89, 0xdd,
0x80, 0x7f, 0xa2, 0x97, 0xe0, 0x02, 0xe7, 0x10, 0x82, 0xca, 0xca, 0xf3, 0xa3, 0xc0, 0x0f, 0xc3,
0x3a, 0x7b, 0x21, 0x3e, 0x5d, 0x71, 0x90, 0xfc, 0x3f, 0x5c, 0x8c, 0xe9, 0x86, 0x47, 0x94, 0x20,
0x5a, 0x8d, 0x50, 0x7b, 0x57, 0x9e, 0x55, 0xf7, 0xa2, 0x00, 0x45, 0xdc, 0x16, 0x41, 0xa1, 0xe7,
0x98, 0x44, 0x1e, 0x20, 0xfc, 0x99, 0xf1, 0xdd, 0xa1, 0xd3, 0x97, 0xc7, 0x04, 0x7b, 0x64, 0x5a,
0x21, 0xa6, 0xaa, 0x02, 0x2c, 0xb5, 0xdf, 0x29, 0x91, 0xbf, 0x88, 0xee, 0xce, 0x62, 0xa6, 0xca,
0xd3, 0x64, 0xa6, 0xb9, 0xff, 0x8e, 0x99, 0x6a, 0xff, 0x52, 0xa2, 0x25, 0x0d, 0x39, 0xe7, 0x57,
0x0b, 0x41, 0x74, 0xfc, 0xae, 0xf2, 0x05, 0x92, 0xc7, 0xaf, 0x4c, 0x17, 0x8a, 0x7c, 0x19, 0x92,
0xe9, 0x42, 0x49, 0x1c, 0xc8, 0xbc, 0x81, 0x5e, 0xe7, 0x5c, 0xd5, 0x39, 0x91, 0x98, 0x9c, 0x20,
0x24, 0xa2, 0x40, 0xb4, 0x25, 0x2b, 0x43, 0x87, 0x4c, 0x4d, 0x17, 0xda, 0x31, 0x5a, 0xa1, 0x26,
0xa8, 0xef, 0xf3, 0xa0, 0xb2, 0xa1, 0xfb, 0x2e, 0xee, 0x11, 0x0e, 0xaa, 0xaa, 0x1e, 0x09, 0x34,
0x13, 0xd0, 0x79, 0x70, 0x47, 0xf7, 0xa1, 0x48, 0x4e, 0x89, 0x4d, 0xd9, 0x1a, 0xb1, 0xb0, 0x3e,
0x3f, 0x97, 0x4c, 0x12, 0x9b, 0xb6, 0x9b, 0x2c, 0x98, 0x7f, 0xff, 0x62, 0xb3, 0x21, 0x6c, 0x5e,
0x71, 0x46, 0x16, 0x25, 0x23, 0x97, 0x4e, 0x74, 0xe9, 0x45, 0xfb, 0x49, 0x8e, 0x71, 0xba, 0x04,
0xf0, 0xcf, 0x0c, 0x6f, 0xb0, 0x69, 0x72, 0x31, 0x9a, 0x9f, 0x2d, 0xe4, 0x2f, 0x00, 0xf4, 0xb1,
0x6f, 0x7c, 0x82, 0x6d, 0x4a, 0x4c, 0x19, 0x77, 0xb5, 0x8f, 0xfd, 0xef, 0x70, 0x01, 0xa3, 0x6a,
0xec, 0xf5, 0xd8, 0x27, 0x26, 0x5f, 0x80, 0xbc, 0x5e, 0xea, 0x63, 0xff, 0xa1, 0x4f, 0xcc, 0xd8,
0x5c, 0x4b, 0x4f, 0x63, 0xae, 0xc9, 0x78, 0x97, 0xa7, 0xe3, 0xfd, 0xd3, 0x5c, 0xb4, 0x3b, 0x22,
0x0a, 0xfc, 0xbf, 0x19, 0x8b, 0x5f, 0xf3, 0xbc, 0x38, 0x79, 0xfa, 0xa2, 0x0f, 0xe0, 0x42, 0xb8,
0x2b, 0x8d, 0x31, 0xdf, 0xad, 0xc1, 0x57, 0xb8, 0xdc, 0xe6, 0x6e, 0x9c, 0x26, 0xc5, 0x3e, 0xfa,
0x10, 0x9e, 0x9d, 0xc2, 0xa0, 0xb0, 0x83, 0xdc, 0x52, 0x50, 0xf4, 0x4c, 0x12, 0x8a, 0x02, 0xff,
0x51, 0xf4, 0xf2, 0x4f, 0x65, 0xd7, 0x1c, 0xb0, 0x34, 0x2c, 0xce, 0x2b, 0x66, 0x7e, 0x13, 0x57,
0xa0, 0xea, 0x11, 0x8a, 0x2d, 0xdb, 0x48, 0x64, 0xbe, 0x6b, 0x42, 0x28, 0x8e, 0x04, 0xed, 0x11,
0x3c, 0x33, 0x93, 0x59, 0xa0, 0x6f, 0x80, 0x1a, 0x51, 0x13, 0x65, 0x61, 0xe6, 0x18, 0x66, 0x40,
0x91, 0x85, 0xf6, 0xa9, 0x12, 0x39, 0x4e, 0x66, 0x56, 0xef, 0x42, 0xd1, 0x23, 0xfe, 0x78, 0x28,
0xb2, 0x9c, 0xda, 0xce, 0x6b, 0xcb, 0x30, 0x13, 0x26, 0x1d, 0x0f, 0xa9, 0x2e, 0x5d, 0x68, 0xef,
0x41, 0x51, 0x48, 0x10, 0x40, 0x71, 0x77, 0x6f, 0x6f, 0xff, 0xf0, 0xb8, 0xb1, 0x82, 0x54, 0x58,
0xdd, 0x6d, 0x3f, 0xd0, 0x8f, 0x1b, 0x0a, 0x13, 0xeb, 0xfb, 0xdf, 0xde, 0xdf, 0x3b, 0x6e, 0xe4,
0xd0, 0x05, 0xa8, 0x8a, 0x67, 0xe3, 0x9d, 0x07, 0xfa, 0xbd, 0xdd, 0xe3, 0x46, 0x3e, 0x26, 0x3a,
0xda, 0xbf, 0x7f, 0x67, 0x5f, 0x6f, 0x14, 0xb4, 0x57, 0x59, 0xfe, 0x34, 0x87, 0xb8, 0x44, 0x99,
0x92, 0x12, 0xcb, 0x94, 0xb4, 0x5f, 0xe4, 0xa0, 0x35, 0x9f, 0x87, 0xa0, 0xc3, 0xa9, 0x19, 0xbf,
0xb1, 0x34, 0x95, 0x99, 0x9a, 0x36, 0xba, 0x0a, 0x35, 0x8f, 0x9c, 0x10, 0xda, 0x1b, 0x08, 0x8e,
0x24, 0x4e, 0xb9, 0xaa, 0x5e, 0x95, 0x52, 0x6e, 0xe4, 0x0b, 0xb5, 0x8f, 0x48, 0x8f, 0x1a, 0x22,
0x75, 0x13, 0xdf, 0x9f, 0xca, 0xd4, 0x98, 0xf4, 0x48, 0x08, 0xb5, 0xa3, 0xb4, 0x20, 0xaa, 0xb0,
0xaa, 0xef, 0x1f, 0xeb, 0x1f, 0x34, 0x72, 0x08, 0x41, 0x8d, 0x3f, 0x1a, 0x47, 0xf7, 0x77, 0x0f,
0x8f, 0x3a, 0x0f, 0x58, 0x10, 0x2f, 0x42, 0x3d, 0x08, 0x62, 0x20, 0x2c, 0x68, 0x7f, 0x52, 0xa0,
0x3e, 0xb5, 0x3d, 0xd0, 0x1b, 0xb0, 0x2a, 0x88, 0xb7, 0xb2, 0xb0, 0x7e, 0xcf, 0xf7, 0xbb, 0xdc,
0x51, 0xc2, 0x00, 0xed, 0x42, 0x99, 0xc8, 0xfa, 0x84, 0xdc, 0x92, 0x57, 0x53, 0xca, 0x18, 0xd2,
0x3e, 0x34, 0x43, 0x77, 0x40, 0x0d, 0x37, 0x7e, 0x4a, 0xed, 0x2b, 0xc4, 0x0d, 0xe9, 0x24, 0x32,
0xd4, 0xf6, 0xa0, 0x12, 0x1b, 0x1e, 0xfa, 0x3f, 0x50, 0x47, 0xf8, 0x4c, 0x16, 0xac, 0x44, 0x09,
0xa2, 0x3c, 0xc2, 0x67, 0xbc, 0x56, 0x85, 0x9e, 0x85, 0x12, 0x7b, 0xd9, 0xc7, 0x02, 0x46, 0xf2,
0x7a, 0x71, 0x84, 0xcf, 0xbe, 0x85, 0x7d, 0xed, 0x67, 0x0a, 0xd4, 0x92, 0xe3, 0x44, 0x2f, 0x03,
0x62, 0xba, 0xb8, 0x4f, 0x0c, 0x7b, 0x3c, 0x12, 0x0c, 0x2d, 0xf0, 0x58, 0x1f, 0xe1, 0xb3, 0xdd,
0x3e, 0xb9, 0x3f, 0x1e, 0xf1, 0xae, 0x7d, 0x74, 0x0f, 0x1a, 0x81, 0x72, 0xf0, 0x63, 0x8f, 0x8c,
0xca, 0x73, 0xe7, 0xca, 0x85, 0x77, 0xa4, 0x82, 0xa8, 0x16, 0xfe, 0xea, 0xcb, 0x4d, 0x45, 0xaf,
0x09, 0x7f, 0xc1, 0x1b, 0xed, 0x75, 0xa8, 0x4f, 0xcd, 0x18, 0x69, 0x50, 0x75, 0xc7, 0x5d, 0xe3,
0x31, 0x99, 0x18, 0x3c, 0x24, 0x1c, 0x01, 0x54, 0xbd, 0xe2, 0x8e, 0xbb, 0xef, 0x92, 0xc9, 0x31,
0x13, 0x69, 0x3d, 0xa8, 0x25, 0xcb, 0x51, 0x6c, 0x77, 0x78, 0xce, 0xd8, 0x36, 0xf9, 0xb8, 0x57,
0x75, 0xd1, 0x40, 0xb7, 0x61, 0xf5, 0xd4, 0x11, 0x58, 0xba, 0x08, 0x45, 0x1e, 0x39, 0x94, 0xc4,
0x8a, 0x5a, 0xc2, 0x46, 0xbb, 0xcf, 0x22, 0x45, 0x6c, 0xba, 0x4b, 0xa9, 0x67, 0x75, 0xc7, 0x94,
0xc4, 0x8b, 0xab, 0x6b, 0x33, 0x8a, 0xab, 0x21, 0x5b, 0x0a, 0xb9, 0x56, 0x5e, 0x54, 0xf6, 0x78,
0x43, 0xfb, 0x91, 0x02, 0xab, 0xdc, 0x21, 0x83, 0x4c, 0x5e, 0xa9, 0x92, 0x3c, 0x9c, 0x3d, 0xa3,
0x1e, 0x00, 0x0e, 0x3a, 0x0a, 0xc6, 0x7b, 0x75, 0x11, 0x58, 0x87, 0xc3, 0x6a, 0x3f, 0x2f, 0x51,
0x7b, 0x3d, 0x72, 0x10, 0x43, 0xee, 0x98, 0x5b, 0xed, 0x9f, 0x05, 0x28, 0x8a, 0x72, 0x20, 0x7a,
0x3b, 0x59, 0x9c, 0xae, 0xec, 0x6c, 0xcc, 0x0b, 0x8e, 0xd0, 0x92, 0xb1, 0x09, 0xb3, 0x83, 0x6b,
0xd3, 0x15, 0xdf, 0x76, 0xe5, 0xc9, 0x17, 0x9b, 0x25, 0xce, 0xac, 0x0f, 0xee, 0x44, 0xe5, 0xdf,
0x79, 0xd5, 0xcf, 0xa0, 0xd6, 0x5c, 0x58, 0xba, 0xd6, 0xdc, 0x81, 0x6a, 0x2c, 0x95, 0xb0, 0x4c,
0x59, 0xfc, 0xd8, 0x58, 0xb4, 0xa5, 0x0f, 0xee, 0xc8, 0xf1, 0x57, 0xc2, 0x54, 0xe3, 0xc0, 0x44,
0x37, 0x92, 0x45, 0x50, 0x9e, 0x91, 0x08, 0x2a, 0x1c, 0xab, 0x6b, 0xb2, 0x7c, 0x84, 0x6d, 0x36,
0x76, 0xb0, 0x09, 0x15, 0xc1, 0x8c, 0xcb, 0x4c, 0xc0, 0x5f, 0x5e, 0x87, 0x7a, 0x44, 0xda, 0x85,
0x4a, 0x59, 0x78, 0x89, 0xc4, 0x5c, 0xf1, 0x16, 0xac, 0xdb, 0xe4, 0x8c, 0x1a, 0xd3, 0xda, 0x2a,
0xd7, 0x46, 0xec, 0xdd, 0xa3, 0xa4, 0xc5, 0x55, 0xa8, 0x45, 0xf4, 0x80, 0xeb, 0x82, 0x28, 0x4d,
0x87, 0x52, 0xae, 0x16, 0xaf, 0xfa, 0x55, 0x12, 0x55, 0xbf, 0x30, 0x49, 0x13, 0xf0, 0x2d, 0x9d,
0xac, 0x71, 0x1d, 0x9e, 0xa4, 0x09, 0xf8, 0x15, 0x6e, 0xae, 0x40, 0x35, 0xc0, 0x2c, 0xa1, 0x57,
0xe5, 0x7a, 0x6b, 0x81, 0x90, 0x2b, 0xdd, 0x84, 0x86, 0xeb, 0x39, 0xae, 0xe3, 0x13, 0xcf, 0xc0,
0xa6, 0xe9, 0x11, 0xdf, 0xe7, 0x89, 0xfe, 0x9a, 0x5e, 0x0f, 0xe4, 0xbb, 0x42, 0xac, 0xbd, 0x0a,
0xa5, 0x20, 0x57, 0x5c, 0x87, 0xd5, 0x76, 0x88, 0xbf, 0x05, 0x5d, 0x34, 0xd8, 0x86, 0xda, 0x75,
0x5d, 0xf9, 0xeb, 0x07, 0x7b, 0xd4, 0x86, 0x50, 0x92, 0x0b, 0x36, 0xb3, 0xe6, 0x7d, 0x0f, 0xd6,
0x5c, 0xec, 0xb1, 0x69, 0xc4, 0x2b, 0xdf, 0xf3, 0xca, 0x4c, 0x87, 0xd8, 0xa3, 0x47, 0x84, 0x26,
0x0a, 0xe0, 0x15, 0x6e, 0x2f, 0x44, 0xda, 0x9b, 0x50, 0x4d, 0xe8, 0xb0, 0x61, 0x52, 0x87, 0xe2,
0x61, 0x00, 0x23, 0xbc, 0x11, 0x8e, 0x24, 0x17, 0x8d, 0x44, 0xbb, 0x0d, 0x6a, 0xb8, 0x56, 0x2c,
0x89, 0x0e, 0x42, 0xa1, 0xc8, 0xf0, 0x8b, 0x26, 0x2f, 0xf2, 0x3b, 0x9f, 0xc8, 0x42, 0x66, 0x5e,
0x17, 0x0d, 0x8d, 0xc4, 0x60, 0x4f, 0x30, 0x35, 0xf4, 0x16, 0x94, 0x24, 0xec, 0xc9, 0xfd, 0x38,
0xaf, 0x9c, 0x7f, 0xc8, 0x71, 0x30, 0x28, 0xe7, 0x0b, 0x54, 0x8c, 0xba, 0xc9, 0xc5, 0xbb, 0xf9,
0x21, 0x94, 0x03, 0x68, 0x4b, 0x9e, 0x41, 0xa2, 0x87, 0xcb, 0x69, 0x67, 0x90, 0xec, 0x24, 0x32,
0x64, 0x5f, 0x93, 0x6f, 0xf5, 0x6d, 0x62, 0x1a, 0xd1, 0x16, 0xe4, 0x7d, 0x96, 0xf5, 0xba, 0x78,
0x71, 0x37, 0xd8, 0x5f, 0xda, 0x2d, 0x28, 0x8a, 0xb1, 0xce, 0xc4, 0xbb, 0x19, 0xb4, 0x51, 0xfb,
0x9b, 0x02, 0xe5, 0xe0, 0x70, 0x9a, 0x69, 0x94, 0x98, 0x44, 0xee, 0xab, 0x4e, 0xe2, 0xe9, 0x43,
0xd2, 0x2b, 0x80, 0xf8, 0x97, 0x62, 0x9c, 0x3a, 0xd4, 0xb2, 0xfb, 0x86, 0x58, 0x0b, 0x91, 0xe5,
0x34, 0xf8, 0x9b, 0x47, 0xfc, 0xc5, 0x21, 0x5f, 0x96, 0x1f, 0x2b, 0x50, 0x0e, 0x39, 0xe9, 0xb2,
0x95, 0xf7, 0x4b, 0x50, 0x94, 0xbc, 0x4b, 0x94, 0xde, 0x65, 0x2b, 0xfc, 0x46, 0x0b, 0xb1, 0xdd,
0xd2, 0x82, 0xf2, 0x88, 0x50, 0xcc, 0xe3, 0x2c, 0x2a, 0x2d, 0x61, 0xfb, 0xa5, 0x2b, 0x50, 0x89,
0xfd, 0x14, 0x82, 0x4a, 0x90, 0xbf, 0x4f, 0x3e, 0x69, 0xac, 0xa0, 0x0a, 0x94, 0x74, 0xc2, 0xab,
0x9f, 0x0d, 0x65, 0xe7, 0xd3, 0x0a, 0xd4, 0x77, 0xdb, 0x7b, 0x07, 0x8c, 0x16, 0x5a, 0x3d, 0x7e,
0x64, 0xa3, 0x07, 0x50, 0xe0, 0x85, 0xa8, 0x0c, 0x37, 0x2f, 0x5a, 0x59, 0x4a, 0xe9, 0x48, 0x87,
0x55, 0x5e, 0xaf, 0x42, 0x59, 0x2e, 0x64, 0xb4, 0x32, 0x55, 0xd8, 0xd9, 0x20, 0xf9, 0x57, 0x9f,
0xe1, 0x9e, 0x46, 0x2b, 0x4b, 0xd9, 0x1d, 0x7d, 0x08, 0x6a, 0x54, 0x88, 0xca, 0x7a, 0x7b, 0xa3,
0x95, 0xb9, 0x20, 0xcf, 0xfc, 0x47, 0xa9, 0x77, 0xd6, 0xbb, 0x0b, 0xad, 0xcc, 0x95, 0x68, 0xf4,
0x3e, 0x94, 0x82, 0x22, 0x47, 0xb6, 0xfb, 0x15, 0xad, 0x8c, 0xc5, 0x72, 0xb6, 0x7c, 0xa2, 0x36,
0x95, 0xe5, 0x12, 0x49, 0x2b, 0xd3, 0x2f, 0x02, 0xe8, 0x21, 0x14, 0x65, 0x76, 0x99, 0xe9, 0xe6,
0x44, 0x2b, 0x5b, 0x09, 0x9c, 0x05, 0x39, 0xaa, 0xfe, 0x65, 0xbd, 0x38, 0xd3, 0xca, 0xfc, 0x53,
0x08, 0xc2, 0x00, 0xb1, 0x82, 0x55, 0xe6, 0x1b, 0x31, 0xad, 0xec, 0x3f, 0x71, 0xa0, 0xef, 0x41,
0x39, 0x2c, 0x4b, 0x64, 0xbc, 0x99, 0xd2, 0xca, 0xfa, 0x2b, 0x03, 0xfa, 0x08, 0xaa, 0xc9, 0x4c,
0x7c, 0x99, 0xfb, 0x26, 0xad, 0xa5, 0x7e, 0x3e, 0x60, 0x7d, 0x25, 0x93, 0xf3, 0x65, 0x6e, 0xa1,
0xb4, 0x96, 0xfa, 0x4d, 0x01, 0x9d, 0xc2, 0x85, 0xf3, 0xf9, 0xf4, 0xb2, 0x57, 0x53, 0x5a, 0x4b,
0xff, 0xd6, 0x80, 0x26, 0x80, 0x66, 0xe4, 0xe4, 0x4b, 0xdf, 0x57, 0x69, 0x2d, 0xff, 0x03, 0x44,
0xfb, 0xe0, 0xdf, 0x7f, 0xd9, 0x50, 0x7e, 0xf3, 0x64, 0x43, 0xf9, 0xec, 0xc9, 0x86, 0xf2, 0xf9,
0x93, 0x0d, 0xe5, 0x8f, 0x4f, 0x36, 0x94, 0x3f, 0x3f, 0xd9, 0x50, 0x7e, 0xff, 0xd7, 0x0d, 0xe5,
0xbb, 0x2f, 0xf7, 0x2d, 0x3a, 0x18, 0x77, 0xb7, 0x7a, 0xce, 0x68, 0x3b, 0x72, 0x1d, 0x7f, 0x8c,
0x2e, 0x09, 0x76, 0x8b, 0xfc, 0x00, 0x7c, 0xed, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x2f, 0x81,
0x24, 0x89, 0x39, 0x28, 0x00, 0x00,
}
func (this *Request) Equal(that interface{}) bool {


+ 30
- 24
abci/types/types.proto View File

@ -4,10 +4,10 @@ option go_package = "github.com/tendermint/tendermint/abci/types";
// For more information on gogo.proto, see:
// https://github.com/gogo/protobuf/blob/master/extensions.md
import "third_party/proto/gogoproto/gogo.proto";
import "crypto/merkle/merkle.proto";
import "google/protobuf/timestamp.proto";
import "google/protobuf/duration.proto";
import "google/protobuf/timestamp.proto";
import "third_party/proto/gogoproto/gogo.proto";
// This file is copied from http://github.com/tendermint/abci
// NOTE: When using custom types, mind the warnings.
@ -64,8 +64,9 @@ message RequestSetOption {
}
message RequestInitChain {
google.protobuf.Timestamp time = 1 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true];
string chain_id = 2;
google.protobuf.Timestamp time = 1
[(gogoproto.nullable) = false, (gogoproto.stdtime) = true];
string chain_id = 2;
ConsensusParams consensus_params = 3;
repeated ValidatorUpdate validators = 4 [(gogoproto.nullable) = false];
bytes app_state_bytes = 5;
@ -230,7 +231,8 @@ message ResponseDeliverTx {
}
message ResponseEndBlock {
repeated ValidatorUpdate validator_updates = 1 [(gogoproto.nullable) = false];
repeated ValidatorUpdate validator_updates = 1
[(gogoproto.nullable) = false];
ConsensusParams consensus_param_updates = 2;
repeated Event events = 3
[(gogoproto.nullable) = false, (gogoproto.jsontag) = "events,omitempty"];
@ -250,11 +252,11 @@ message ResponseOfferSnapshot {
Result result = 1;
enum Result {
accept = 0; // Snapshot accepted, apply chunks
abort = 1; // Abort all snapshot restoration
reject = 2; // Reject this specific snapshot, and try a different one
reject_format = 3; // Reject all snapshots of this format, and try a different one
reject_sender = 4; // Reject all snapshots from the sender(s), and try a different one
ACCEPT = 0; // Snapshot accepted, apply chunks
ABORT = 1; // Abort all snapshot restoration
REJECT = 2; // Reject this specific snapshot, try others
REJECT_FORMAT = 3; // Reject all snapshots of this format, try others
REJECT_SENDER = 4; // Reject all snapshots from the sender(s), try others
}
}
@ -264,15 +266,15 @@ message ResponseLoadSnapshotChunk {
message ResponseApplySnapshotChunk {
Result result = 1;
repeated uint32 refetch_chunks = 2; // Chunks to refetch and reapply (regardless of result)
repeated string reject_senders = 3; // Chunk senders to reject and ban (regardless of result)
repeated uint32 refetch_chunks = 2; // Chunks to refetch and reapply
repeated string reject_senders = 3; // Chunk senders to reject and ban
enum Result {
accept = 0; // Chunk successfully accepted
abort = 1; // Abort all snapshot restoration
retry = 2; // Retry chunk, combine with refetch and reject as appropriate
retry_snapshot = 3; // Retry snapshot, combine with refetch and reject as appropriate
reject_snapshot = 4; // Reject this snapshot, try a different one but keep sender rejections
ACCEPT = 0; // Chunk successfully accepted
ABORT = 1; // Abort all snapshot restoration
RETRY = 2; // Retry chunk (combine with refetch and reject)
RETRY_SNAPSHOT = 3; // Retry snapshot (combine with refetch and reject)
REJECT_SNAPSHOT = 4; // Reject this snapshot, try others
}
}
@ -321,9 +323,10 @@ message EventAttribute {
}
message Event {
string type = 1;
repeated EventAttribute attributes = 2
[(gogoproto.nullable) = false, (gogoproto.jsontag) = "attributes,omitempty"];
string type = 1;
repeated EventAttribute attributes = 2 [
(gogoproto.nullable) = false,
(gogoproto.jsontag) = "attributes,omitempty"];
}
//----------------------------------------
@ -334,7 +337,8 @@ message Header {
Version version = 1 [(gogoproto.nullable) = false];
string chain_id = 2 [(gogoproto.customname) = "ChainID"];
int64 height = 3;
google.protobuf.Timestamp time = 4 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true];
google.protobuf.Timestamp time = 4
[(gogoproto.nullable) = false, (gogoproto.stdtime) = true];
// prev block info
BlockID last_block_id = 5 [(gogoproto.nullable) = false];
@ -348,7 +352,7 @@ message Header {
bytes next_validators_hash = 9; // validators for the next block
bytes consensus_hash = 10; // consensus params for current block
bytes app_hash = 11; // state after txs from the previous block
bytes last_results_hash = 12; // root hash of all results from the txs from the previous block
bytes last_results_hash = 12; // root hash of tx results from prev block
// consensus info
bytes evidence_hash = 13; // evidence included in the block
@ -398,7 +402,9 @@ message Evidence {
string type = 1;
Validator validator = 2 [(gogoproto.nullable) = false];
int64 height = 3;
google.protobuf.Timestamp time = 4 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true];
google.protobuf.Timestamp time = 4 [
(gogoproto.nullable) = false,
(gogoproto.stdtime) = true];
int64 total_voting_power = 5;
}
@ -409,7 +415,7 @@ message Snapshot {
uint64 height = 1; // The height at which the snapshot was taken
uint32 format = 2; // The application-specific snapshot format
uint32 chunks = 3; // Number of chunks in the snapshot
bytes hash = 4; // Arbitrary snapshot hash - should be equal only for identical snapshots
bytes hash = 4; // Arbitrary snapshot hash, equal only if identical
bytes metadata = 5; // Arbitrary application metadata
}


+ 10
- 10
statesync/syncer.go View File

@ -290,17 +290,17 @@ func (s *syncer) offerSnapshot(snapshot *snapshot) error {
return fmt.Errorf("failed to offer snapshot: %w", err)
}
switch resp.Result {
case abci.ResponseOfferSnapshot_accept:
case abci.ResponseOfferSnapshot_ACCEPT:
s.logger.Info("Snapshot accepted, restoring", "height", snapshot.Height,
"format", snapshot.Format, "hash", fmt.Sprintf("%X", snapshot.Hash))
return nil
case abci.ResponseOfferSnapshot_abort:
case abci.ResponseOfferSnapshot_ABORT:
return errAbort
case abci.ResponseOfferSnapshot_reject:
case abci.ResponseOfferSnapshot_REJECT:
return errRejectSnapshot
case abci.ResponseOfferSnapshot_reject_format:
case abci.ResponseOfferSnapshot_REJECT_FORMAT:
return errRejectFormat
case abci.ResponseOfferSnapshot_reject_sender:
case abci.ResponseOfferSnapshot_REJECT_SENDER:
return errRejectSender
default:
return fmt.Errorf("invalid ResponseOfferSnapshot result %v", resp.Result)
@ -349,14 +349,14 @@ func (s *syncer) applyChunks(chunks *chunkQueue) error {
}
switch resp.Result {
case abci.ResponseApplySnapshotChunk_accept:
case abci.ResponseApplySnapshotChunk_abort:
case abci.ResponseApplySnapshotChunk_ACCEPT:
case abci.ResponseApplySnapshotChunk_ABORT:
return errAbort
case abci.ResponseApplySnapshotChunk_retry:
case abci.ResponseApplySnapshotChunk_RETRY:
chunks.Retry(chunk.Index)
case abci.ResponseApplySnapshotChunk_retry_snapshot:
case abci.ResponseApplySnapshotChunk_RETRY_SNAPSHOT:
return errRetrySnapshot
case abci.ResponseApplySnapshotChunk_reject_snapshot:
case abci.ResponseApplySnapshotChunk_REJECT_SNAPSHOT:
return errRejectSnapshot
default:
return fmt.Errorf("unknown ResponseApplySnapshotChunk result %v", resp.Result)


+ 44
- 44
statesync/syncer_test.go View File

@ -124,7 +124,7 @@ func TestSyncer_SyncAny(t *testing.T) {
Hash: []byte{1},
},
AppHash: []byte("app_hash_2"),
}).Return(&abci.ResponseOfferSnapshot{Result: abci.ResponseOfferSnapshot_reject_format}, nil)
}).Return(&abci.ResponseOfferSnapshot{Result: abci.ResponseOfferSnapshot_REJECT_FORMAT}, nil)
connSnapshot.On("OfferSnapshotSync", abci.RequestOfferSnapshot{
Snapshot: &abci.Snapshot{
Height: s.Height,
@ -134,7 +134,7 @@ func TestSyncer_SyncAny(t *testing.T) {
Metadata: s.Metadata,
},
AppHash: []byte("app_hash"),
}).Times(2).Return(&abci.ResponseOfferSnapshot{Result: abci.ResponseOfferSnapshot_accept}, nil)
}).Times(2).Return(&abci.ResponseOfferSnapshot{Result: abci.ResponseOfferSnapshot_ACCEPT}, nil)
chunkRequests := make(map[uint32]int)
chunkRequestsMtx := sync.Mutex{}
@ -164,19 +164,19 @@ func TestSyncer_SyncAny(t *testing.T) {
Index: 2, Chunk: []byte{1, 1, 2},
}).Once().Run(func(args mock.Arguments) { time.Sleep(2 * time.Second) }).Return(
&abci.ResponseApplySnapshotChunk{
Result: abci.ResponseApplySnapshotChunk_retry_snapshot,
Result: abci.ResponseApplySnapshotChunk_RETRY_SNAPSHOT,
RefetchChunks: []uint32{1},
}, nil)
connSnapshot.On("ApplySnapshotChunkSync", abci.RequestApplySnapshotChunk{
Index: 0, Chunk: []byte{1, 1, 0},
}).Times(2).Return(&abci.ResponseApplySnapshotChunk{Result: abci.ResponseApplySnapshotChunk_accept}, nil)
}).Times(2).Return(&abci.ResponseApplySnapshotChunk{Result: abci.ResponseApplySnapshotChunk_ACCEPT}, nil)
connSnapshot.On("ApplySnapshotChunkSync", abci.RequestApplySnapshotChunk{
Index: 1, Chunk: []byte{1, 1, 1},
}).Times(2).Return(&abci.ResponseApplySnapshotChunk{Result: abci.ResponseApplySnapshotChunk_accept}, nil)
}).Times(2).Return(&abci.ResponseApplySnapshotChunk{Result: abci.ResponseApplySnapshotChunk_ACCEPT}, nil)
connSnapshot.On("ApplySnapshotChunkSync", abci.RequestApplySnapshotChunk{
Index: 2, Chunk: []byte{1, 1, 2},
}).Once().Return(&abci.ResponseApplySnapshotChunk{Result: abci.ResponseApplySnapshotChunk_accept}, nil)
}).Once().Return(&abci.ResponseApplySnapshotChunk{Result: abci.ResponseApplySnapshotChunk_ACCEPT}, nil)
connQuery.On("InfoSync", proxy.RequestInfo).Return(&abci.ResponseInfo{
AppVersion: 9,
LastBlockHeight: 1,
@ -209,14 +209,14 @@ func TestSyncer_SyncAny_noSnapshots(t *testing.T) {
assert.Equal(t, errNoSnapshots, err)
}
func TestSyncer_SyncAny_abort(t *testing.T) {
func TestSyncer_SyncAny_ABORT(t *testing.T) {
syncer, connSnapshot := setupOfferSyncer(t)
s := &snapshot{Height: 1, Format: 1, Chunks: 3, Hash: []byte{1, 2, 3}}
syncer.AddSnapshot(simplePeer("id"), s)
connSnapshot.On("OfferSnapshotSync", abci.RequestOfferSnapshot{
Snapshot: toABCI(s), AppHash: []byte("app_hash"),
}).Once().Return(&abci.ResponseOfferSnapshot{Result: abci.ResponseOfferSnapshot_abort}, nil)
}).Once().Return(&abci.ResponseOfferSnapshot{Result: abci.ResponseOfferSnapshot_ABORT}, nil)
_, _, err := syncer.SyncAny(0)
assert.Equal(t, errAbort, err)
@ -236,22 +236,22 @@ func TestSyncer_SyncAny_reject(t *testing.T) {
connSnapshot.On("OfferSnapshotSync", abci.RequestOfferSnapshot{
Snapshot: toABCI(s22), AppHash: []byte("app_hash"),
}).Once().Return(&abci.ResponseOfferSnapshot{Result: abci.ResponseOfferSnapshot_reject}, nil)
}).Once().Return(&abci.ResponseOfferSnapshot{Result: abci.ResponseOfferSnapshot_REJECT}, nil)
connSnapshot.On("OfferSnapshotSync", abci.RequestOfferSnapshot{
Snapshot: toABCI(s12), AppHash: []byte("app_hash"),
}).Once().Return(&abci.ResponseOfferSnapshot{Result: abci.ResponseOfferSnapshot_reject}, nil)
}).Once().Return(&abci.ResponseOfferSnapshot{Result: abci.ResponseOfferSnapshot_REJECT}, nil)
connSnapshot.On("OfferSnapshotSync", abci.RequestOfferSnapshot{
Snapshot: toABCI(s11), AppHash: []byte("app_hash"),
}).Once().Return(&abci.ResponseOfferSnapshot{Result: abci.ResponseOfferSnapshot_reject}, nil)
}).Once().Return(&abci.ResponseOfferSnapshot{Result: abci.ResponseOfferSnapshot_REJECT}, nil)
_, _, err := syncer.SyncAny(0)
assert.Equal(t, errNoSnapshots, err)
connSnapshot.AssertExpectations(t)
}
func TestSyncer_SyncAny_reject_format(t *testing.T) {
func TestSyncer_SyncAny_REJECT_FORMAT(t *testing.T) {
syncer, connSnapshot := setupOfferSyncer(t)
// s22 is tried first, which reject s22 and s12, then s11 will abort.
@ -264,11 +264,11 @@ func TestSyncer_SyncAny_reject_format(t *testing.T) {
connSnapshot.On("OfferSnapshotSync", abci.RequestOfferSnapshot{
Snapshot: toABCI(s22), AppHash: []byte("app_hash"),
}).Once().Return(&abci.ResponseOfferSnapshot{Result: abci.ResponseOfferSnapshot_reject_format}, nil)
}).Once().Return(&abci.ResponseOfferSnapshot{Result: abci.ResponseOfferSnapshot_REJECT_FORMAT}, nil)
connSnapshot.On("OfferSnapshotSync", abci.RequestOfferSnapshot{
Snapshot: toABCI(s11), AppHash: []byte("app_hash"),
}).Once().Return(&abci.ResponseOfferSnapshot{Result: abci.ResponseOfferSnapshot_abort}, nil)
}).Once().Return(&abci.ResponseOfferSnapshot{Result: abci.ResponseOfferSnapshot_ABORT}, nil)
_, _, err := syncer.SyncAny(0)
assert.Equal(t, errAbort, err)
@ -302,11 +302,11 @@ func TestSyncer_SyncAny_reject_sender(t *testing.T) {
connSnapshot.On("OfferSnapshotSync", abci.RequestOfferSnapshot{
Snapshot: toABCI(sbc), AppHash: []byte("app_hash"),
}).Once().Return(&abci.ResponseOfferSnapshot{Result: abci.ResponseOfferSnapshot_reject_sender}, nil)
}).Once().Return(&abci.ResponseOfferSnapshot{Result: abci.ResponseOfferSnapshot_REJECT_SENDER}, nil)
connSnapshot.On("OfferSnapshotSync", abci.RequestOfferSnapshot{
Snapshot: toABCI(sa), AppHash: []byte("app_hash"),
}).Once().Return(&abci.ResponseOfferSnapshot{Result: abci.ResponseOfferSnapshot_reject}, nil)
}).Once().Return(&abci.ResponseOfferSnapshot{Result: abci.ResponseOfferSnapshot_REJECT}, nil)
_, _, err = syncer.SyncAny(0)
assert.Equal(t, errNoSnapshots, err)
@ -337,11 +337,11 @@ func TestSyncer_offerSnapshot(t *testing.T) {
err error
expectErr error
}{
"accept": {abci.ResponseOfferSnapshot_accept, nil, nil},
"abort": {abci.ResponseOfferSnapshot_abort, nil, errAbort},
"reject": {abci.ResponseOfferSnapshot_reject, nil, errRejectSnapshot},
"reject_format": {abci.ResponseOfferSnapshot_reject_format, nil, errRejectFormat},
"reject_sender": {abci.ResponseOfferSnapshot_reject_sender, nil, errRejectSender},
"accept": {abci.ResponseOfferSnapshot_ACCEPT, nil, nil},
"abort": {abci.ResponseOfferSnapshot_ABORT, nil, errAbort},
"reject": {abci.ResponseOfferSnapshot_REJECT, nil, errRejectSnapshot},
"reject_format": {abci.ResponseOfferSnapshot_REJECT_FORMAT, nil, errRejectFormat},
"reject_sender": {abci.ResponseOfferSnapshot_REJECT_SENDER, nil, errRejectSender},
"error": {0, boom, boom},
"unknown result": {9, nil, unknownErr},
}
@ -377,11 +377,11 @@ func TestSyncer_applyChunks_Results(t *testing.T) {
err error
expectErr error
}{
"accept": {abci.ResponseApplySnapshotChunk_accept, nil, nil},
"abort": {abci.ResponseApplySnapshotChunk_abort, nil, errAbort},
"retry": {abci.ResponseApplySnapshotChunk_retry, nil, nil},
"retry_snapshot": {abci.ResponseApplySnapshotChunk_retry_snapshot, nil, errRetrySnapshot},
"reject_snapshot": {abci.ResponseApplySnapshotChunk_reject_snapshot, nil, errRejectSnapshot},
"accept": {abci.ResponseApplySnapshotChunk_ACCEPT, nil, nil},
"abort": {abci.ResponseApplySnapshotChunk_ABORT, nil, errAbort},
"retry": {abci.ResponseApplySnapshotChunk_RETRY, nil, nil},
"retry_snapshot": {abci.ResponseApplySnapshotChunk_RETRY_SNAPSHOT, nil, errRetrySnapshot},
"reject_snapshot": {abci.ResponseApplySnapshotChunk_REJECT_SNAPSHOT, nil, errRejectSnapshot},
"error": {0, boom, boom},
"unknown result": {9, nil, unknownErr},
}
@ -402,11 +402,11 @@ func TestSyncer_applyChunks_Results(t *testing.T) {
connSnapshot.On("ApplySnapshotChunkSync", abci.RequestApplySnapshotChunk{
Index: 0, Chunk: body,
}).Once().Return(&abci.ResponseApplySnapshotChunk{Result: tc.result}, tc.err)
if tc.result == abci.ResponseApplySnapshotChunk_retry {
if tc.result == abci.ResponseApplySnapshotChunk_RETRY {
connSnapshot.On("ApplySnapshotChunkSync", abci.RequestApplySnapshotChunk{
Index: 0, Chunk: body,
}).Once().Return(&abci.ResponseApplySnapshotChunk{
Result: abci.ResponseApplySnapshotChunk_accept}, nil)
Result: abci.ResponseApplySnapshotChunk_ACCEPT}, nil)
}
err = syncer.applyChunks(chunks)
@ -429,11 +429,11 @@ func TestSyncer_applyChunks_RefetchChunks(t *testing.T) {
testcases := map[string]struct {
result abci.ResponseApplySnapshotChunk_Result
}{
"accept": {abci.ResponseApplySnapshotChunk_accept},
"abort": {abci.ResponseApplySnapshotChunk_abort},
"retry": {abci.ResponseApplySnapshotChunk_retry},
"retry_snapshot": {abci.ResponseApplySnapshotChunk_retry_snapshot},
"reject_snapshot": {abci.ResponseApplySnapshotChunk_reject_snapshot},
"accept": {abci.ResponseApplySnapshotChunk_ACCEPT},
"abort": {abci.ResponseApplySnapshotChunk_ABORT},
"retry": {abci.ResponseApplySnapshotChunk_RETRY},
"retry_snapshot": {abci.ResponseApplySnapshotChunk_RETRY_SNAPSHOT},
"reject_snapshot": {abci.ResponseApplySnapshotChunk_REJECT_SNAPSHOT},
}
for name, tc := range testcases {
tc := tc
@ -459,10 +459,10 @@ func TestSyncer_applyChunks_RefetchChunks(t *testing.T) {
// The first two chunks are accepted, before the last one asks for 1 to be refetched
connSnapshot.On("ApplySnapshotChunkSync", abci.RequestApplySnapshotChunk{
Index: 0, Chunk: []byte{0},
}).Once().Return(&abci.ResponseApplySnapshotChunk{Result: abci.ResponseApplySnapshotChunk_accept}, nil)
}).Once().Return(&abci.ResponseApplySnapshotChunk{Result: abci.ResponseApplySnapshotChunk_ACCEPT}, nil)
connSnapshot.On("ApplySnapshotChunkSync", abci.RequestApplySnapshotChunk{
Index: 1, Chunk: []byte{1},
}).Once().Return(&abci.ResponseApplySnapshotChunk{Result: abci.ResponseApplySnapshotChunk_accept}, nil)
}).Once().Return(&abci.ResponseApplySnapshotChunk{Result: abci.ResponseApplySnapshotChunk_ACCEPT}, nil)
connSnapshot.On("ApplySnapshotChunkSync", abci.RequestApplySnapshotChunk{
Index: 2, Chunk: []byte{2},
}).Once().Return(&abci.ResponseApplySnapshotChunk{
@ -492,11 +492,11 @@ func TestSyncer_applyChunks_RejectSenders(t *testing.T) {
testcases := map[string]struct {
result abci.ResponseApplySnapshotChunk_Result
}{
"accept": {abci.ResponseApplySnapshotChunk_accept},
"abort": {abci.ResponseApplySnapshotChunk_abort},
"retry": {abci.ResponseApplySnapshotChunk_retry},
"retry_snapshot": {abci.ResponseApplySnapshotChunk_retry_snapshot},
"reject_snapshot": {abci.ResponseApplySnapshotChunk_reject_snapshot},
"accept": {abci.ResponseApplySnapshotChunk_ACCEPT},
"abort": {abci.ResponseApplySnapshotChunk_ABORT},
"retry": {abci.ResponseApplySnapshotChunk_RETRY},
"retry_snapshot": {abci.ResponseApplySnapshotChunk_RETRY_SNAPSHOT},
"reject_snapshot": {abci.ResponseApplySnapshotChunk_REJECT_SNAPSHOT},
}
for name, tc := range testcases {
tc := tc
@ -537,10 +537,10 @@ func TestSyncer_applyChunks_RejectSenders(t *testing.T) {
// The first two chunks are accepted, before the last one asks for b sender to be rejected
connSnapshot.On("ApplySnapshotChunkSync", abci.RequestApplySnapshotChunk{
Index: 0, Chunk: []byte{0}, Sender: "a",
}).Once().Return(&abci.ResponseApplySnapshotChunk{Result: abci.ResponseApplySnapshotChunk_accept}, nil)
}).Once().Return(&abci.ResponseApplySnapshotChunk{Result: abci.ResponseApplySnapshotChunk_ACCEPT}, nil)
connSnapshot.On("ApplySnapshotChunkSync", abci.RequestApplySnapshotChunk{
Index: 1, Chunk: []byte{1}, Sender: "b",
}).Once().Return(&abci.ResponseApplySnapshotChunk{Result: abci.ResponseApplySnapshotChunk_accept}, nil)
}).Once().Return(&abci.ResponseApplySnapshotChunk{Result: abci.ResponseApplySnapshotChunk_ACCEPT}, nil)
connSnapshot.On("ApplySnapshotChunkSync", abci.RequestApplySnapshotChunk{
Index: 2, Chunk: []byte{2}, Sender: "c",
}).Once().Return(&abci.ResponseApplySnapshotChunk{
@ -549,10 +549,10 @@ func TestSyncer_applyChunks_RejectSenders(t *testing.T) {
}, nil)
// On retry, the last chunk will be tried again, so we just accept it then.
if tc.result == abci.ResponseApplySnapshotChunk_retry {
if tc.result == abci.ResponseApplySnapshotChunk_RETRY {
connSnapshot.On("ApplySnapshotChunkSync", abci.RequestApplySnapshotChunk{
Index: 2, Chunk: []byte{2}, Sender: "c",
}).Once().Return(&abci.ResponseApplySnapshotChunk{Result: abci.ResponseApplySnapshotChunk_accept}, nil)
}).Once().Return(&abci.ResponseApplySnapshotChunk{Result: abci.ResponseApplySnapshotChunk_ACCEPT}, nil)
}
// We don't really care about the result of applyChunks, since it has separate test.


Write Preview
Loading…
Cancel
Save