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
Unified 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( func (app *PersistentKVStoreApplication) OfferSnapshot(
req types.RequestOfferSnapshot) types.ResponseOfferSnapshot { req types.RequestOfferSnapshot) types.ResponseOfferSnapshot {
return types.ResponseOfferSnapshot{Result: types.ResponseOfferSnapshot_abort}
return types.ResponseOfferSnapshot{Result: types.ResponseOfferSnapshot_ABORT}
} }
func (app *PersistentKVStoreApplication) ApplySnapshotChunk( func (app *PersistentKVStoreApplication) ApplySnapshotChunk(
req types.RequestApplySnapshotChunk) types.ResponseApplySnapshotChunk { 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 type ResponseOfferSnapshot_Result int32
const ( 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{ 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{ 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 { func (x ResponseOfferSnapshot_Result) String() string {
@ -98,27 +98,27 @@ func (ResponseOfferSnapshot_Result) EnumDescriptor() ([]byte, []int) {
type ResponseApplySnapshotChunk_Result int32 type ResponseApplySnapshotChunk_Result int32
const ( 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{ 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{ 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 { func (x ResponseApplySnapshotChunk_Result) String() string {
@ -2404,7 +2404,7 @@ func (m *ResponseOfferSnapshot) GetResult() ResponseOfferSnapshot_Result {
if m != nil { if m != nil {
return m.Result return m.Result
} }
return ResponseOfferSnapshot_accept
return ResponseOfferSnapshot_ACCEPT
} }
type ResponseLoadSnapshotChunk struct { type ResponseLoadSnapshotChunk struct {
@ -2500,7 +2500,7 @@ func (m *ResponseApplySnapshotChunk) GetResult() ResponseApplySnapshotChunk_Resu
if m != nil { if m != nil {
return m.Result return m.Result
} }
return ResponseApplySnapshotChunk_accept
return ResponseApplySnapshotChunk_ACCEPT
} }
func (m *ResponseApplySnapshotChunk) GetRefetchChunks() []uint32 { 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) } func init() { golang_proto.RegisterFile("abci/types/types.proto", fileDescriptor_9f1eaa49c51fa1ac) }
var fileDescriptor_9f1eaa49c51fa1ac = []byte{ 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 { 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: // For more information on gogo.proto, see:
// https://github.com/gogo/protobuf/blob/master/extensions.md // https://github.com/gogo/protobuf/blob/master/extensions.md
import "third_party/proto/gogoproto/gogo.proto";
import "crypto/merkle/merkle.proto"; import "crypto/merkle/merkle.proto";
import "google/protobuf/timestamp.proto";
import "google/protobuf/duration.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 // This file is copied from http://github.com/tendermint/abci
// NOTE: When using custom types, mind the warnings. // NOTE: When using custom types, mind the warnings.
@ -64,8 +64,9 @@ message RequestSetOption {
} }
message RequestInitChain { 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; ConsensusParams consensus_params = 3;
repeated ValidatorUpdate validators = 4 [(gogoproto.nullable) = false]; repeated ValidatorUpdate validators = 4 [(gogoproto.nullable) = false];
bytes app_state_bytes = 5; bytes app_state_bytes = 5;
@ -230,7 +231,8 @@ message ResponseDeliverTx {
} }
message ResponseEndBlock { message ResponseEndBlock {
repeated ValidatorUpdate validator_updates = 1 [(gogoproto.nullable) = false];
repeated ValidatorUpdate validator_updates = 1
[(gogoproto.nullable) = false];
ConsensusParams consensus_param_updates = 2; ConsensusParams consensus_param_updates = 2;
repeated Event events = 3 repeated Event events = 3
[(gogoproto.nullable) = false, (gogoproto.jsontag) = "events,omitempty"]; [(gogoproto.nullable) = false, (gogoproto.jsontag) = "events,omitempty"];
@ -250,11 +252,11 @@ message ResponseOfferSnapshot {
Result result = 1; Result result = 1;
enum Result { 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 { message ResponseApplySnapshotChunk {
Result result = 1; 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 { 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 { 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]; Version version = 1 [(gogoproto.nullable) = false];
string chain_id = 2 [(gogoproto.customname) = "ChainID"]; string chain_id = 2 [(gogoproto.customname) = "ChainID"];
int64 height = 3; 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 // prev block info
BlockID last_block_id = 5 [(gogoproto.nullable) = false]; 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 next_validators_hash = 9; // validators for the next block
bytes consensus_hash = 10; // consensus params for current block bytes consensus_hash = 10; // consensus params for current block
bytes app_hash = 11; // state after txs from the previous 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 // consensus info
bytes evidence_hash = 13; // evidence included in the block bytes evidence_hash = 13; // evidence included in the block
@ -398,7 +402,9 @@ message Evidence {
string type = 1; string type = 1;
Validator validator = 2 [(gogoproto.nullable) = false]; Validator validator = 2 [(gogoproto.nullable) = false];
int64 height = 3; 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; int64 total_voting_power = 5;
} }
@ -409,7 +415,7 @@ message Snapshot {
uint64 height = 1; // The height at which the snapshot was taken uint64 height = 1; // The height at which the snapshot was taken
uint32 format = 2; // The application-specific snapshot format uint32 format = 2; // The application-specific snapshot format
uint32 chunks = 3; // Number of chunks in the snapshot 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 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) return fmt.Errorf("failed to offer snapshot: %w", err)
} }
switch resp.Result { switch resp.Result {
case abci.ResponseOfferSnapshot_accept:
case abci.ResponseOfferSnapshot_ACCEPT:
s.logger.Info("Snapshot accepted, restoring", "height", snapshot.Height, s.logger.Info("Snapshot accepted, restoring", "height", snapshot.Height,
"format", snapshot.Format, "hash", fmt.Sprintf("%X", snapshot.Hash)) "format", snapshot.Format, "hash", fmt.Sprintf("%X", snapshot.Hash))
return nil return nil
case abci.ResponseOfferSnapshot_abort:
case abci.ResponseOfferSnapshot_ABORT:
return errAbort return errAbort
case abci.ResponseOfferSnapshot_reject:
case abci.ResponseOfferSnapshot_REJECT:
return errRejectSnapshot return errRejectSnapshot
case abci.ResponseOfferSnapshot_reject_format:
case abci.ResponseOfferSnapshot_REJECT_FORMAT:
return errRejectFormat return errRejectFormat
case abci.ResponseOfferSnapshot_reject_sender:
case abci.ResponseOfferSnapshot_REJECT_SENDER:
return errRejectSender return errRejectSender
default: default:
return fmt.Errorf("invalid ResponseOfferSnapshot result %v", resp.Result) return fmt.Errorf("invalid ResponseOfferSnapshot result %v", resp.Result)
@ -349,14 +349,14 @@ func (s *syncer) applyChunks(chunks *chunkQueue) error {
} }
switch resp.Result { switch resp.Result {
case abci.ResponseApplySnapshotChunk_accept:
case abci.ResponseApplySnapshotChunk_abort:
case abci.ResponseApplySnapshotChunk_ACCEPT:
case abci.ResponseApplySnapshotChunk_ABORT:
return errAbort return errAbort
case abci.ResponseApplySnapshotChunk_retry:
case abci.ResponseApplySnapshotChunk_RETRY:
chunks.Retry(chunk.Index) chunks.Retry(chunk.Index)
case abci.ResponseApplySnapshotChunk_retry_snapshot:
case abci.ResponseApplySnapshotChunk_RETRY_SNAPSHOT:
return errRetrySnapshot return errRetrySnapshot
case abci.ResponseApplySnapshotChunk_reject_snapshot:
case abci.ResponseApplySnapshotChunk_REJECT_SNAPSHOT:
return errRejectSnapshot return errRejectSnapshot
default: default:
return fmt.Errorf("unknown ResponseApplySnapshotChunk result %v", resp.Result) 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}, Hash: []byte{1},
}, },
AppHash: []byte("app_hash_2"), 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{ connSnapshot.On("OfferSnapshotSync", abci.RequestOfferSnapshot{
Snapshot: &abci.Snapshot{ Snapshot: &abci.Snapshot{
Height: s.Height, Height: s.Height,
@ -134,7 +134,7 @@ func TestSyncer_SyncAny(t *testing.T) {
Metadata: s.Metadata, Metadata: s.Metadata,
}, },
AppHash: []byte("app_hash"), 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) chunkRequests := make(map[uint32]int)
chunkRequestsMtx := sync.Mutex{} chunkRequestsMtx := sync.Mutex{}
@ -164,19 +164,19 @@ func TestSyncer_SyncAny(t *testing.T) {
Index: 2, Chunk: []byte{1, 1, 2}, Index: 2, Chunk: []byte{1, 1, 2},
}).Once().Run(func(args mock.Arguments) { time.Sleep(2 * time.Second) }).Return( }).Once().Run(func(args mock.Arguments) { time.Sleep(2 * time.Second) }).Return(
&abci.ResponseApplySnapshotChunk{ &abci.ResponseApplySnapshotChunk{
Result: abci.ResponseApplySnapshotChunk_retry_snapshot,
Result: abci.ResponseApplySnapshotChunk_RETRY_SNAPSHOT,
RefetchChunks: []uint32{1}, RefetchChunks: []uint32{1},
}, nil) }, nil)
connSnapshot.On("ApplySnapshotChunkSync", abci.RequestApplySnapshotChunk{ connSnapshot.On("ApplySnapshotChunkSync", abci.RequestApplySnapshotChunk{
Index: 0, Chunk: []byte{1, 1, 0}, 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{ connSnapshot.On("ApplySnapshotChunkSync", abci.RequestApplySnapshotChunk{
Index: 1, Chunk: []byte{1, 1, 1}, 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{ connSnapshot.On("ApplySnapshotChunkSync", abci.RequestApplySnapshotChunk{
Index: 2, Chunk: []byte{1, 1, 2}, 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{ connQuery.On("InfoSync", proxy.RequestInfo).Return(&abci.ResponseInfo{
AppVersion: 9, AppVersion: 9,
LastBlockHeight: 1, LastBlockHeight: 1,
@ -209,14 +209,14 @@ func TestSyncer_SyncAny_noSnapshots(t *testing.T) {
assert.Equal(t, errNoSnapshots, err) assert.Equal(t, errNoSnapshots, err)
} }
func TestSyncer_SyncAny_abort(t *testing.T) {
func TestSyncer_SyncAny_ABORT(t *testing.T) {
syncer, connSnapshot := setupOfferSyncer(t) syncer, connSnapshot := setupOfferSyncer(t)
s := &snapshot{Height: 1, Format: 1, Chunks: 3, Hash: []byte{1, 2, 3}} s := &snapshot{Height: 1, Format: 1, Chunks: 3, Hash: []byte{1, 2, 3}}
syncer.AddSnapshot(simplePeer("id"), s) syncer.AddSnapshot(simplePeer("id"), s)
connSnapshot.On("OfferSnapshotSync", abci.RequestOfferSnapshot{ connSnapshot.On("OfferSnapshotSync", abci.RequestOfferSnapshot{
Snapshot: toABCI(s), AppHash: []byte("app_hash"), 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) _, _, err := syncer.SyncAny(0)
assert.Equal(t, errAbort, err) assert.Equal(t, errAbort, err)
@ -236,22 +236,22 @@ func TestSyncer_SyncAny_reject(t *testing.T) {
connSnapshot.On("OfferSnapshotSync", abci.RequestOfferSnapshot{ connSnapshot.On("OfferSnapshotSync", abci.RequestOfferSnapshot{
Snapshot: toABCI(s22), AppHash: []byte("app_hash"), 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{ connSnapshot.On("OfferSnapshotSync", abci.RequestOfferSnapshot{
Snapshot: toABCI(s12), AppHash: []byte("app_hash"), 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{ connSnapshot.On("OfferSnapshotSync", abci.RequestOfferSnapshot{
Snapshot: toABCI(s11), AppHash: []byte("app_hash"), 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) _, _, err := syncer.SyncAny(0)
assert.Equal(t, errNoSnapshots, err) assert.Equal(t, errNoSnapshots, err)
connSnapshot.AssertExpectations(t) connSnapshot.AssertExpectations(t)
} }
func TestSyncer_SyncAny_reject_format(t *testing.T) {
func TestSyncer_SyncAny_REJECT_FORMAT(t *testing.T) {
syncer, connSnapshot := setupOfferSyncer(t) syncer, connSnapshot := setupOfferSyncer(t)
// s22 is tried first, which reject s22 and s12, then s11 will abort. // 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{ connSnapshot.On("OfferSnapshotSync", abci.RequestOfferSnapshot{
Snapshot: toABCI(s22), AppHash: []byte("app_hash"), 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{ connSnapshot.On("OfferSnapshotSync", abci.RequestOfferSnapshot{
Snapshot: toABCI(s11), AppHash: []byte("app_hash"), 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) _, _, err := syncer.SyncAny(0)
assert.Equal(t, errAbort, err) assert.Equal(t, errAbort, err)
@ -302,11 +302,11 @@ func TestSyncer_SyncAny_reject_sender(t *testing.T) {
connSnapshot.On("OfferSnapshotSync", abci.RequestOfferSnapshot{ connSnapshot.On("OfferSnapshotSync", abci.RequestOfferSnapshot{
Snapshot: toABCI(sbc), AppHash: []byte("app_hash"), 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{ connSnapshot.On("OfferSnapshotSync", abci.RequestOfferSnapshot{
Snapshot: toABCI(sa), AppHash: []byte("app_hash"), 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) _, _, err = syncer.SyncAny(0)
assert.Equal(t, errNoSnapshots, err) assert.Equal(t, errNoSnapshots, err)
@ -337,11 +337,11 @@ func TestSyncer_offerSnapshot(t *testing.T) {
err error err error
expectErr 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}, "error": {0, boom, boom},
"unknown result": {9, nil, unknownErr}, "unknown result": {9, nil, unknownErr},
} }
@ -377,11 +377,11 @@ func TestSyncer_applyChunks_Results(t *testing.T) {
err error err error
expectErr 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}, "error": {0, boom, boom},
"unknown result": {9, nil, unknownErr}, "unknown result": {9, nil, unknownErr},
} }
@ -402,11 +402,11 @@ func TestSyncer_applyChunks_Results(t *testing.T) {
connSnapshot.On("ApplySnapshotChunkSync", abci.RequestApplySnapshotChunk{ connSnapshot.On("ApplySnapshotChunkSync", abci.RequestApplySnapshotChunk{
Index: 0, Chunk: body, Index: 0, Chunk: body,
}).Once().Return(&abci.ResponseApplySnapshotChunk{Result: tc.result}, tc.err) }).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{ connSnapshot.On("ApplySnapshotChunkSync", abci.RequestApplySnapshotChunk{
Index: 0, Chunk: body, Index: 0, Chunk: body,
}).Once().Return(&abci.ResponseApplySnapshotChunk{ }).Once().Return(&abci.ResponseApplySnapshotChunk{
Result: abci.ResponseApplySnapshotChunk_accept}, nil)
Result: abci.ResponseApplySnapshotChunk_ACCEPT}, nil)
} }
err = syncer.applyChunks(chunks) err = syncer.applyChunks(chunks)
@ -429,11 +429,11 @@ func TestSyncer_applyChunks_RefetchChunks(t *testing.T) {
testcases := map[string]struct { testcases := map[string]struct {
result abci.ResponseApplySnapshotChunk_Result 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 { for name, tc := range testcases {
tc := tc 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 // The first two chunks are accepted, before the last one asks for 1 to be refetched
connSnapshot.On("ApplySnapshotChunkSync", abci.RequestApplySnapshotChunk{ connSnapshot.On("ApplySnapshotChunkSync", abci.RequestApplySnapshotChunk{
Index: 0, Chunk: []byte{0}, 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{ connSnapshot.On("ApplySnapshotChunkSync", abci.RequestApplySnapshotChunk{
Index: 1, Chunk: []byte{1}, 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{ connSnapshot.On("ApplySnapshotChunkSync", abci.RequestApplySnapshotChunk{
Index: 2, Chunk: []byte{2}, Index: 2, Chunk: []byte{2},
}).Once().Return(&abci.ResponseApplySnapshotChunk{ }).Once().Return(&abci.ResponseApplySnapshotChunk{
@ -492,11 +492,11 @@ func TestSyncer_applyChunks_RejectSenders(t *testing.T) {
testcases := map[string]struct { testcases := map[string]struct {
result abci.ResponseApplySnapshotChunk_Result 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 { for name, tc := range testcases {
tc := tc 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 // The first two chunks are accepted, before the last one asks for b sender to be rejected
connSnapshot.On("ApplySnapshotChunkSync", abci.RequestApplySnapshotChunk{ connSnapshot.On("ApplySnapshotChunkSync", abci.RequestApplySnapshotChunk{
Index: 0, Chunk: []byte{0}, Sender: "a", 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{ connSnapshot.On("ApplySnapshotChunkSync", abci.RequestApplySnapshotChunk{
Index: 1, Chunk: []byte{1}, Sender: "b", 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{ connSnapshot.On("ApplySnapshotChunkSync", abci.RequestApplySnapshotChunk{
Index: 2, Chunk: []byte{2}, Sender: "c", Index: 2, Chunk: []byte{2}, Sender: "c",
}).Once().Return(&abci.ResponseApplySnapshotChunk{ }).Once().Return(&abci.ResponseApplySnapshotChunk{
@ -549,10 +549,10 @@ func TestSyncer_applyChunks_RejectSenders(t *testing.T) {
}, nil) }, nil)
// On retry, the last chunk will be tried again, so we just accept it then. // 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{ connSnapshot.On("ApplySnapshotChunkSync", abci.RequestApplySnapshotChunk{
Index: 2, Chunk: []byte{2}, Sender: "c", 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. // We don't really care about the result of applyChunks, since it has separate test.


Write Preview
Loading…
Cancel
Save