diff --git a/proto/snpb/log_io.pb.go b/proto/snpb/log_io.pb.go index fad557e11..0e18403d9 100644 --- a/proto/snpb/log_io.pb.go +++ b/proto/snpb/log_io.pb.go @@ -4,6 +4,7 @@ package snpb import ( + bytes "bytes" context "context" fmt "fmt" io "io" @@ -824,64 +825,101 @@ func init() { func init() { proto.RegisterFile("proto/snpb/log_io.proto", fileDescriptor_7692726f23e518ee) } var fileDescriptor_7692726f23e518ee = []byte{ - // 907 bytes of a gzipped FileDescriptorProto + // 923 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x57, 0x41, 0x8f, 0xdb, 0x44, 0x14, 0xce, 0x24, 0xde, 0x66, 0xf3, 0xb2, 0xad, 0xca, 0x2c, 0xa5, 0x59, 0x57, 0x8d, 0x23, 0x0b, - 0xa1, 0x45, 0x62, 0xed, 0x6a, 0x11, 0x2a, 0x48, 0x45, 0x82, 0x68, 0xb7, 0xd5, 0x8a, 0x74, 0x41, - 0x4e, 0xd4, 0x03, 0x12, 0xac, 0xec, 0x78, 0x30, 0xd6, 0x4e, 0x3c, 0xc6, 0x76, 0x90, 0x22, 0x2e, - 0xdc, 0xb8, 0xf6, 0x27, 0xf0, 0x23, 0x38, 0x70, 0xe1, 0xde, 0x63, 0x2f, 0x48, 0x1c, 0x50, 0x0e, - 0x09, 0xff, 0x01, 0xd1, 0x13, 0x9a, 0xf1, 0xd8, 0xb1, 0xb7, 0x89, 0xba, 0x11, 0xe4, 0xd0, 0xbd, - 0x79, 0x66, 0xde, 0xfb, 0xe6, 0xbd, 0xef, 0x7d, 0x7a, 0xf3, 0x0c, 0xb7, 0xc3, 0x88, 0x25, 0xcc, - 0x8c, 0x83, 0xd0, 0x31, 0x29, 0xf3, 0xce, 0x7c, 0x66, 0x88, 0x1d, 0xdc, 0xfc, 0xde, 0x8e, 0x28, - 0xf3, 0x0c, 0x7e, 0xa2, 0x1e, 0x78, 0x7e, 0xf2, 0xed, 0xd8, 0x31, 0x86, 0x6c, 0x64, 0x7a, 0xcc, - 0x63, 0xa6, 0xb0, 0x71, 0xc6, 0xdf, 0x88, 0x55, 0x0a, 0xc1, 0xbf, 0x52, 0x5f, 0xf5, 0x8e, 0xc7, - 0x98, 0x47, 0xc9, 0xc2, 0x8a, 0x8c, 0xc2, 0x64, 0x22, 0x0f, 0x6f, 0xa7, 0xc0, 0xa1, 0x63, 0x8e, - 0x48, 0x62, 0xbb, 0x76, 0x62, 0xcb, 0x83, 0x5d, 0x11, 0x44, 0x79, 0x53, 0xff, 0x0b, 0xc1, 0xf5, - 0x4f, 0xc3, 0x90, 0x04, 0xae, 0x45, 0xbe, 0x1b, 0x93, 0x38, 0xc1, 0x7d, 0xd8, 0x4e, 0x58, 0xe8, - 0x0f, 0xcf, 0x7c, 0xb7, 0x85, 0x3a, 0x68, 0x7f, 0xab, 0xfb, 0xe1, 0x6c, 0xaa, 0xd5, 0x07, 0x7c, - 0xef, 0xe4, 0xe8, 0xc5, 0x54, 0x7b, 0xb7, 0x10, 0xec, 0xb9, 0x7d, 0x6e, 0x33, 0x33, 0xbd, 0xd1, - 0x0c, 0xcf, 0x3d, 0x33, 0x99, 0x84, 0x24, 0x36, 0xa4, 0xb1, 0x55, 0x17, 0x48, 0x27, 0x2e, 0x76, - 0xe1, 0x3a, 0xcf, 0x3e, 0x4e, 0x22, 0x62, 0x8f, 0x38, 0x72, 0x55, 0x20, 0x7f, 0x32, 0x9b, 0x6a, - 0xcd, 0x1e, 0xf3, 0xfa, 0x62, 0x5f, 0xa0, 0x1f, 0xbc, 0x1a, 0xbd, 0xe0, 0x60, 0x35, 0x69, 0xbe, - 0x70, 0x71, 0x0b, 0xea, 0xa1, 0x3d, 0xa1, 0xcc, 0x76, 0x5b, 0xb5, 0x4e, 0x6d, 0x7f, 0xc7, 0xca, - 0x96, 0xfa, 0x57, 0xb0, 0x93, 0x65, 0x19, 0x8f, 0x69, 0x82, 0xef, 0x83, 0xc2, 0x89, 0x10, 0x09, - 0x36, 0x0f, 0xef, 0x1a, 0xb2, 0x18, 0x19, 0x75, 0xfc, 0x8a, 0xe3, 0x20, 0x89, 0x26, 0x8f, 0x49, - 0x62, 0x77, 0x95, 0x67, 0x53, 0xad, 0x62, 0x09, 0x07, 0xfc, 0x26, 0x6c, 0x91, 0x28, 0x62, 0x91, - 0x48, 0xa0, 0x61, 0xa5, 0x0b, 0xfd, 0x33, 0xb8, 0x91, 0xc3, 0x87, 0x2c, 0x88, 0x09, 0xfe, 0x08, - 0xea, 0x91, 0xb8, 0x2a, 0x6e, 0xa1, 0x4e, 0x6d, 0xbf, 0x79, 0xb8, 0x67, 0x14, 0x0a, 0x6e, 0x14, - 0x83, 0x91, 0xf8, 0x99, 0xbd, 0xfe, 0xb4, 0x0a, 0x4d, 0x8b, 0xd8, 0x79, 0x41, 0x1e, 0x82, 0xe2, - 0xd1, 0x38, 0x10, 0xb1, 0x2a, 0xdd, 0xc3, 0xd9, 0x54, 0x53, 0x1e, 0xf5, 0xfa, 0xa7, 0x2f, 0xa6, - 0xda, 0x3b, 0xaf, 0xe6, 0x8a, 0x5b, 0x5a, 0xc2, 0xbf, 0x54, 0xd8, 0xea, 0xc6, 0x0a, 0x5b, 0xdb, - 0x40, 0x61, 0xf5, 0x5f, 0x11, 0xec, 0xa4, 0x94, 0x48, 0x7a, 0xff, 0x2f, 0x4e, 0x1e, 0x82, 0x42, - 0x39, 0x4e, 0x75, 0x81, 0xd3, 0xbb, 0x34, 0x4e, 0x4f, 0xe0, 0x70, 0xff, 0xb2, 0xf2, 0x50, 0x51, - 0x79, 0x7f, 0x57, 0xe1, 0x66, 0x7f, 0xec, 0xc4, 0xc3, 0xc8, 0x77, 0x48, 0x56, 0xd2, 0x27, 0x00, - 0xfc, 0xfa, 0x33, 0x87, 0x78, 0x7e, 0x96, 0xc4, 0xfd, 0xd9, 0x54, 0x6b, 0xf0, 0xd0, 0xba, 0x7c, - 0x73, 0x8d, 0x4c, 0x1a, 0x1c, 0x4a, 0x38, 0xe1, 0x2f, 0x60, 0x5b, 0xe0, 0x92, 0xc0, 0x95, 0x29, - 0x7d, 0xc0, 0x4b, 0xcc, 0xcd, 0x8e, 0x03, 0x77, 0x0d, 0xcc, 0x3a, 0x87, 0x39, 0x0e, 0xdc, 0x92, - 0x68, 0x6a, 0x1b, 0x13, 0x8d, 0xb2, 0x09, 0xd1, 0xfc, 0x86, 0xe0, 0x8d, 0x02, 0xf3, 0xaf, 0x9d, - 0x72, 0xfe, 0xa9, 0x02, 0xce, 0xe3, 0x1f, 0xb0, 0x2b, 0xd0, 0x9f, 0x9f, 0x00, 0xd0, 0x85, 0xec, - 0x6b, 0x0b, 0xd9, 0xf7, 0xd6, 0x93, 0xbd, 0xa0, 0xaf, 0x41, 0x8b, 0xb2, 0xa7, 0x99, 0xec, 0x95, - 0x85, 0xec, 0x7b, 0xeb, 0xc8, 0x5e, 0x60, 0xd6, 0x69, 0x2a, 0x7b, 0xbd, 0x0f, 0xbb, 0x25, 0xea, - 0xa5, 0x78, 0x1e, 0x40, 0x83, 0xd3, 0x44, 0xf8, 0xd3, 0x20, 0xdf, 0x8e, 0xbd, 0x95, 0x6f, 0x87, - 0xec, 0xeb, 0xdb, 0x54, 0xae, 0xf5, 0x5f, 0x10, 0xdc, 0x1a, 0x44, 0xfe, 0xe8, 0x88, 0x84, 0x11, - 0x19, 0xda, 0x09, 0xd9, 0xec, 0x9b, 0x9b, 0x29, 0xbd, 0xfa, 0xdf, 0x94, 0xae, 0xff, 0x8e, 0xa0, - 0x95, 0x97, 0xf4, 0xb1, 0x1c, 0x1f, 0x5e, 0x7f, 0x35, 0xea, 0x3f, 0xc0, 0xde, 0x92, 0xb4, 0x64, - 0xa5, 0xbf, 0x86, 0x5b, 0x85, 0x10, 0x5c, 0xc2, 0xa5, 0x10, 0x26, 0x2c, 0x92, 0x55, 0x7f, 0x7b, - 0x59, 0xd5, 0x53, 0xa8, 0xa3, 0xdc, 0x56, 0x0a, 0x60, 0x97, 0xbe, 0x7c, 0xa4, 0xff, 0x89, 0x40, - 0xcb, 0x5d, 0x2c, 0x12, 0x52, 0x7f, 0x68, 0x5f, 0x21, 0x6e, 0x7f, 0x42, 0xd0, 0x59, 0x9d, 0x9e, - 0xe4, 0x78, 0x08, 0xb8, 0x10, 0x4a, 0x94, 0x5a, 0x49, 0x82, 0xcd, 0xd2, 0xb8, 0xb4, 0x0a, 0xea, - 0x25, 0xae, 0x6f, 0xd2, 0x0b, 0x96, 0x87, 0x3f, 0x2a, 0xb0, 0xd5, 0x63, 0xde, 0xc9, 0xe7, 0xf8, - 0x11, 0x5c, 0x4b, 0xc7, 0x2e, 0xac, 0x2e, 0x9d, 0xc5, 0x04, 0xe9, 0xea, 0x9d, 0xe5, 0x73, 0x9a, - 0x88, 0x58, 0xaf, 0xec, 0xa3, 0x7b, 0x08, 0x7f, 0x0c, 0x0a, 0x1f, 0x46, 0x70, 0xab, 0x64, 0x5a, - 0x18, 0xd9, 0xd4, 0xbd, 0x25, 0x27, 0x19, 0x04, 0x3e, 0x85, 0x46, 0xde, 0x5b, 0xf0, 0xdd, 0x92, - 0xe5, 0xc5, 0x41, 0x41, 0x6d, 0xaf, 0x3a, 0xce, 0xd0, 0xee, 0x21, 0x3c, 0x80, 0x66, 0xa1, 0x57, - 0x61, 0x6d, 0xb9, 0x4b, 0xfe, 0x80, 0xa8, 0x9d, 0xd5, 0x06, 0x05, 0xd4, 0x53, 0xb8, 0x51, 0xee, - 0x55, 0x58, 0x2f, 0xf9, 0x2d, 0x6d, 0x64, 0xea, 0x5b, 0x46, 0xfa, 0x6b, 0x62, 0x64, 0xbf, 0x26, - 0xc6, 0x31, 0xff, 0x35, 0xd1, 0x2b, 0x78, 0x52, 0x68, 0x22, 0x17, 0xaa, 0x88, 0xdf, 0xbb, 0x54, - 0xb1, 0xb3, 0x3b, 0x0e, 0x2e, 0x69, 0x9d, 0x25, 0xd3, 0x7d, 0xf0, 0x6c, 0xd6, 0x46, 0xcf, 0x67, - 0x6d, 0xf4, 0x74, 0xde, 0xae, 0xfc, 0x3c, 0x6f, 0xa3, 0xe7, 0xf3, 0x76, 0xe5, 0x8f, 0x79, 0xbb, - 0xf2, 0xa5, 0xbe, 0x52, 0xe2, 0xf9, 0x5f, 0x9b, 0x73, 0x4d, 0x7c, 0xbf, 0xff, 0x6f, 0x00, 0x00, - 0x00, 0xff, 0xff, 0x09, 0x66, 0x9b, 0x7b, 0xca, 0x0d, 0x00, 0x00, + 0xa1, 0x45, 0x62, 0xed, 0x6a, 0x11, 0x2a, 0xa0, 0x22, 0x41, 0xb4, 0xdb, 0x6a, 0x45, 0xba, 0x20, + 0x67, 0xd5, 0x03, 0x12, 0xac, 0xec, 0x78, 0x30, 0xd6, 0x4e, 0x3c, 0xc6, 0x76, 0x90, 0x22, 0x2e, + 0xdc, 0xb8, 0xf6, 0x27, 0xec, 0x8f, 0xe0, 0xd0, 0x0b, 0xf7, 0x1e, 0x7b, 0x41, 0xe2, 0x80, 0x72, + 0xc8, 0x5e, 0x38, 0x73, 0x01, 0x7a, 0x42, 0x33, 0x1e, 0x3b, 0xf6, 0x36, 0x51, 0x37, 0xa2, 0x39, + 0x74, 0x6f, 0x9e, 0x99, 0xf7, 0xbe, 0x79, 0xef, 0x7b, 0x9f, 0xde, 0x3c, 0xc3, 0xcd, 0x30, 0x62, + 0x09, 0x33, 0xe3, 0x20, 0x74, 0x4c, 0xca, 0xbc, 0x63, 0x9f, 0x19, 0x62, 0x07, 0x37, 0x7f, 0xb0, + 0x23, 0xca, 0x3c, 0x83, 0x9f, 0xa8, 0x3b, 0x9e, 0x9f, 0x7c, 0x37, 0x72, 0x8c, 0x01, 0x1b, 0x9a, + 0x1e, 0xf3, 0x98, 0x29, 0x6c, 0x9c, 0xd1, 0xb7, 0x62, 0x95, 0x42, 0xf0, 0xaf, 0xd4, 0x57, 0xbd, + 0xe5, 0x31, 0xe6, 0x51, 0x32, 0xb3, 0x22, 0xc3, 0x30, 0x19, 0xcb, 0xc3, 0x9b, 0x29, 0x70, 0xe8, + 0x98, 0x43, 0x92, 0xd8, 0xae, 0x9d, 0xd8, 0xf2, 0x60, 0x53, 0x04, 0x51, 0xde, 0xd4, 0xff, 0x42, + 0x70, 0xf5, 0xb3, 0x30, 0x24, 0x81, 0x6b, 0x91, 0xef, 0x47, 0x24, 0x4e, 0x70, 0x1f, 0xd6, 0x13, + 0x16, 0xfa, 0x83, 0x63, 0xdf, 0x6d, 0xa1, 0x0e, 0xda, 0x5e, 0xeb, 0x7e, 0x38, 0x9d, 0x68, 0xf5, + 0x23, 0xbe, 0x77, 0xb0, 0xf7, 0x7c, 0xa2, 0xbd, 0x5b, 0x08, 0xf6, 0xc4, 0x3e, 0xb1, 0x99, 0x99, + 0xde, 0x68, 0x86, 0x27, 0x9e, 0x99, 0x8c, 0x43, 0x12, 0x1b, 0xd2, 0xd8, 0xaa, 0x0b, 0xa4, 0x03, + 0x17, 0xbb, 0x70, 0x95, 0x67, 0x1f, 0x27, 0x11, 0xb1, 0x87, 0x1c, 0xb9, 0x2a, 0x90, 0x3f, 0x9d, + 0x4e, 0xb4, 0x66, 0x8f, 0x79, 0x7d, 0xb1, 0x2f, 0xd0, 0x77, 0x5e, 0x8e, 0x5e, 0x70, 0xb0, 0x9a, + 0x34, 0x5f, 0xb8, 0xb8, 0x05, 0xf5, 0xd0, 0x1e, 0x53, 0x66, 0xbb, 0xad, 0x5a, 0xa7, 0xb6, 0xbd, + 0x61, 0x65, 0xcb, 0x8f, 0x37, 0x9e, 0x9c, 0x6a, 0xe8, 0xcf, 0x53, 0x0d, 0xfd, 0x73, 0xaa, 0x21, + 0xfd, 0x6b, 0xd8, 0xc8, 0x72, 0x8e, 0x47, 0x34, 0xc1, 0x77, 0x41, 0xe1, 0xb4, 0x88, 0x74, 0x9b, + 0xbb, 0xb7, 0x0d, 0x59, 0x9a, 0x8c, 0x48, 0x7e, 0xe1, 0x7e, 0x90, 0x44, 0xe3, 0x87, 0x24, 0xb1, + 0xbb, 0xca, 0xd3, 0x89, 0x56, 0xb1, 0x84, 0x03, 0x7e, 0x13, 0xd6, 0x48, 0x14, 0xb1, 0x48, 0xa4, + 0xd3, 0xb0, 0xd2, 0x85, 0xfe, 0x39, 0x5c, 0xcb, 0xe1, 0x43, 0x16, 0xc4, 0x04, 0x7f, 0x04, 0xf5, + 0x48, 0x5c, 0x15, 0xb7, 0x50, 0xa7, 0xb6, 0xdd, 0xdc, 0xdd, 0x32, 0x0a, 0xe5, 0x37, 0x8a, 0xc1, + 0x48, 0xfc, 0xcc, 0x5e, 0x7f, 0x5c, 0x85, 0xa6, 0x45, 0xec, 0xbc, 0x3c, 0xf7, 0x41, 0xf1, 0x68, + 0x1c, 0x88, 0x58, 0x95, 0xee, 0xee, 0x74, 0xa2, 0x29, 0x0f, 0x7a, 0xfd, 0xc3, 0xe7, 0x13, 0xed, + 0x9d, 0x97, 0x33, 0xc7, 0x2d, 0x2d, 0xe1, 0x5f, 0x2a, 0x73, 0x75, 0x65, 0x65, 0xae, 0xad, 0xa0, + 0xcc, 0xfa, 0x13, 0x04, 0x1b, 0x29, 0x25, 0x92, 0xde, 0x57, 0xc5, 0xc9, 0x7d, 0x50, 0x28, 0xc7, + 0xa9, 0xce, 0x70, 0x7a, 0x17, 0xc6, 0xe9, 0x09, 0x1c, 0xee, 0x5f, 0xd6, 0x21, 0x2a, 0xe8, 0x50, + 0xff, 0xbb, 0x0a, 0xd7, 0xfb, 0x23, 0x27, 0x1e, 0x44, 0xbe, 0x43, 0xb2, 0x92, 0x3e, 0x02, 0xe0, + 0xd7, 0x1f, 0x3b, 0xc4, 0xf3, 0xb3, 0x24, 0xee, 0x4e, 0x27, 0x5a, 0x83, 0x87, 0xd6, 0xe5, 0x9b, + 0x4b, 0x64, 0xd2, 0xe0, 0x50, 0xc2, 0x09, 0x7f, 0x09, 0xeb, 0x02, 0x97, 0x04, 0xae, 0x4c, 0xe9, + 0x03, 0x5e, 0x62, 0x6e, 0xb6, 0x1f, 0xb8, 0x4b, 0x60, 0xd6, 0x39, 0xcc, 0x7e, 0xe0, 0x96, 0x44, + 0x53, 0x5b, 0x99, 0x68, 0x94, 0x55, 0x88, 0xe6, 0x57, 0x04, 0x6f, 0x14, 0x98, 0x7f, 0xed, 0x94, + 0xf3, 0x6f, 0x15, 0x70, 0x1e, 0xff, 0x11, 0xbb, 0x04, 0xdd, 0xfa, 0x11, 0x00, 0x9d, 0xc9, 0xbe, + 0x36, 0x93, 0x7d, 0x6f, 0x39, 0xd9, 0x0b, 0xfa, 0x1a, 0xb4, 0x28, 0x7b, 0x9a, 0xc9, 0x5e, 0x99, + 0xc9, 0xbe, 0xb7, 0x8c, 0xec, 0x05, 0x66, 0x9d, 0xa6, 0xb2, 0xd7, 0xfb, 0xb0, 0x59, 0xa2, 0x5e, + 0x8a, 0xe7, 0x1e, 0x34, 0x38, 0x4d, 0x84, 0x3f, 0x0d, 0xf2, 0xed, 0xd8, 0x5a, 0xf8, 0x76, 0xc8, + 0xbe, 0xbe, 0x4e, 0xe5, 0x5a, 0xff, 0x05, 0xc1, 0x8d, 0xa3, 0xc8, 0x1f, 0xee, 0x91, 0x30, 0x22, + 0x03, 0x3b, 0x21, 0xab, 0x7d, 0x81, 0x33, 0xa5, 0x57, 0xff, 0x9f, 0xd2, 0xf5, 0xdf, 0x10, 0xb4, + 0xf2, 0x92, 0x3e, 0x94, 0xc3, 0xc4, 0xeb, 0xaf, 0x46, 0xfd, 0x47, 0xd8, 0x9a, 0x93, 0x96, 0xac, + 0xf4, 0x37, 0x70, 0xa3, 0x10, 0x82, 0x4b, 0xb8, 0x14, 0xc2, 0x84, 0x45, 0xb2, 0xea, 0x6f, 0xcf, + 0xab, 0x7a, 0x0a, 0xb5, 0x97, 0xdb, 0x4a, 0x01, 0x6c, 0xd2, 0x17, 0x8f, 0xf4, 0x3f, 0x10, 0x68, + 0xb9, 0x8b, 0x45, 0x42, 0xea, 0x0f, 0xec, 0x4b, 0xc4, 0xed, 0xcf, 0x08, 0x3a, 0x8b, 0xd3, 0x93, + 0x1c, 0x0f, 0x00, 0x17, 0x42, 0x89, 0x52, 0x2b, 0x49, 0xb0, 0x59, 0x1a, 0x97, 0x16, 0x41, 0xbd, + 0xc0, 0xf5, 0x75, 0x7a, 0xce, 0x72, 0xf7, 0x27, 0x05, 0xd6, 0x7a, 0xcc, 0x3b, 0xf8, 0x02, 0x3f, + 0x80, 0x2b, 0xe9, 0xd8, 0x85, 0xd5, 0xb9, 0xb3, 0x98, 0x20, 0x5d, 0xbd, 0x35, 0x7f, 0x4e, 0x13, + 0x11, 0xeb, 0x95, 0x6d, 0x74, 0x07, 0xe1, 0x4f, 0x40, 0xe1, 0xc3, 0x08, 0x6e, 0x95, 0x4c, 0x0b, + 0x23, 0x9b, 0xba, 0x35, 0xe7, 0x24, 0x83, 0xc0, 0x87, 0xd0, 0xc8, 0x7b, 0x0b, 0xbe, 0x5d, 0xb2, + 0x3c, 0x3f, 0x28, 0xa8, 0xed, 0x45, 0xc7, 0x19, 0xda, 0x1d, 0x84, 0x8f, 0xa0, 0x59, 0xe8, 0x55, + 0x58, 0x9b, 0xef, 0x92, 0x3f, 0x20, 0x6a, 0x67, 0xb1, 0x41, 0x01, 0xf5, 0x10, 0xae, 0x95, 0x7b, + 0x15, 0xd6, 0x4b, 0x7e, 0x73, 0x1b, 0x99, 0xfa, 0x96, 0x91, 0xfe, 0xa8, 0x18, 0xd9, 0x8f, 0x8a, + 0xb1, 0xcf, 0x7f, 0x54, 0xf4, 0x0a, 0x1e, 0x17, 0x9a, 0xc8, 0xb9, 0x2a, 0xe2, 0xf7, 0x2e, 0x54, + 0xec, 0xec, 0x8e, 0x9d, 0x0b, 0x5a, 0x67, 0xc9, 0x74, 0xef, 0x3d, 0x9d, 0xb6, 0xd1, 0xb3, 0x69, + 0x1b, 0x3d, 0x3e, 0x6b, 0x57, 0x4e, 0xcf, 0xda, 0xe8, 0xd9, 0x59, 0xbb, 0xf2, 0xfb, 0x59, 0xbb, + 0xf2, 0x95, 0xbe, 0x50, 0xe2, 0xf9, 0x3f, 0x9c, 0x73, 0x45, 0x7c, 0xbf, 0xff, 0x5f, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x98, 0x1d, 0x9c, 0x2d, 0xd8, 0x0d, 0x00, 0x00, +} + +func (this *AppendRequest) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*AppendRequest) + if !ok { + that2, ok := that.(AppendRequest) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.TopicID != that1.TopicID { + return false + } + if this.LogStreamID != that1.LogStreamID { + return false + } + if len(this.Payload) != len(that1.Payload) { + return false + } + for i := range this.Payload { + if !bytes.Equal(this.Payload[i], that1.Payload[i]) { + return false + } + } + return true } // Reference imports to suppress errors if they are not otherwise used. @@ -1833,6 +1871,102 @@ func encodeVarintLogIo(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } +func NewPopulatedAppendRequest(r randyLogIo, easy bool) *AppendRequest { + this := &AppendRequest{} + this.TopicID = github_com_kakao_varlog_pkg_types.TopicID(r.Int31()) + if r.Intn(2) == 0 { + this.TopicID *= -1 + } + this.LogStreamID = github_com_kakao_varlog_pkg_types.LogStreamID(r.Int31()) + if r.Intn(2) == 0 { + this.LogStreamID *= -1 + } + v1 := r.Intn(10) + this.Payload = make([][]byte, v1) + for i := 0; i < v1; i++ { + v2 := r.Intn(100) + this.Payload[i] = make([]byte, v2) + for j := 0; j < v2; j++ { + this.Payload[i][j] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +type randyLogIo interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneLogIo(r randyLogIo) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringLogIo(r randyLogIo) string { + v3 := r.Intn(100) + tmps := make([]rune, v3) + for i := 0; i < v3; i++ { + tmps[i] = randUTF8RuneLogIo(r) + } + return string(tmps) +} +func randUnrecognizedLogIo(r randyLogIo, maxFieldNumber int) (dAtA []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + dAtA = randFieldLogIo(dAtA, r, fieldNumber, wire) + } + return dAtA +} +func randFieldLogIo(dAtA []byte, r randyLogIo, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + dAtA = encodeVarintPopulateLogIo(dAtA, uint64(key)) + v4 := r.Int63() + if r.Intn(2) == 0 { + v4 *= -1 + } + dAtA = encodeVarintPopulateLogIo(dAtA, uint64(v4)) + case 1: + dAtA = encodeVarintPopulateLogIo(dAtA, uint64(key)) + dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + dAtA = encodeVarintPopulateLogIo(dAtA, uint64(key)) + ll := r.Intn(100) + dAtA = encodeVarintPopulateLogIo(dAtA, uint64(ll)) + for j := 0; j < ll; j++ { + dAtA = append(dAtA, byte(r.Intn(256))) + } + default: + dAtA = encodeVarintPopulateLogIo(dAtA, uint64(key)) + dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return dAtA +} +func encodeVarintPopulateLogIo(dAtA []byte, v uint64) []byte { + for v >= 1<<7 { + dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + dAtA = append(dAtA, uint8(v)) + return dAtA +} func (m *AppendRequest) ProtoSize() (n int) { if m == nil { return 0 diff --git a/proto/snpb/log_io.proto b/proto/snpb/log_io.proto index 0927643b6..2c16018d2 100644 --- a/proto/snpb/log_io.proto +++ b/proto/snpb/log_io.proto @@ -20,6 +20,10 @@ option (gogoproto.goproto_sizecache_all) = false; // AppendRequest is a message to send a payload to a storage node. It contains // a vector of storage nodes to replicate the payload. message AppendRequest { + option (gogoproto.equal) = true; + option (gogoproto.populate) = true; + option (gogoproto.testgen) = true; + int32 topic_id = 1 [ (gogoproto.casttype) = "github.com/kakao/varlog/pkg/types.TopicID", (gogoproto.customname) = "TopicID" diff --git a/proto/snpb/log_iopb_test.go b/proto/snpb/log_iopb_test.go new file mode 100644 index 000000000..ec33accb3 --- /dev/null +++ b/proto/snpb/log_iopb_test.go @@ -0,0 +1,151 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: proto/snpb/log_io.proto + +package snpb + +import ( + fmt "fmt" + math "math" + math_rand "math/rand" + testing "testing" + time "time" + + _ "github.com/gogo/protobuf/gogoproto" + github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb" + github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" + proto "github.com/gogo/protobuf/proto" + _ "github.com/gogo/protobuf/types" + + _ "github.com/kakao/varlog/proto/varlogpb" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestAppendRequestProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAppendRequest(popr, false) + dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AppendRequest{} + if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(dAtA)) + copy(littlefuzz, dAtA) + for i := range dAtA { + dAtA[i] = byte(popr.Intn(256)) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAppendRequestMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAppendRequest(popr, false) + size := p.ProtoSize() + dAtA := make([]byte, size) + for i := range dAtA { + dAtA[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(dAtA) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AppendRequest{} + if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range dAtA { + dAtA[i] = byte(popr.Intn(256)) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAppendRequestJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAppendRequest(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AppendRequest{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAppendRequestProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAppendRequest(popr, true) + dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AppendRequest{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAppendRequestProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAppendRequest(popr, true) + dAtA := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AppendRequest{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAppendRequestProtoSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAppendRequest(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.ProtoSize() + if len(dAtA) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/proto/snpb/replicator.pb.go b/proto/snpb/replicator.pb.go index 07d825eda..139a31eb6 100644 --- a/proto/snpb/replicator.pb.go +++ b/proto/snpb/replicator.pb.go @@ -4,6 +4,7 @@ package snpb import ( + bytes "bytes" context "context" fmt "fmt" io "io" @@ -663,70 +664,71 @@ func init() { func init() { proto.RegisterFile("proto/snpb/replicator.proto", fileDescriptor_85705cb817486b63) } var fileDescriptor_85705cb817486b63 = []byte{ - // 1000 bytes of a gzipped FileDescriptorProto + // 1012 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x56, 0xcf, 0x6f, 0xe3, 0x44, - 0x14, 0x8e, 0x13, 0xa7, 0x4d, 0x5e, 0xda, 0x92, 0x4e, 0x59, 0x1a, 0x02, 0xb5, 0xb3, 0x46, 0x42, - 0xe1, 0xc7, 0xc6, 0x52, 0x57, 0x2c, 0xcb, 0x6a, 0xa5, 0x85, 0x96, 0xb4, 0x44, 0x0a, 0x6d, 0x35, + 0x14, 0x8e, 0x13, 0x67, 0x9b, 0xbc, 0xb4, 0x25, 0x9d, 0xb2, 0x34, 0x04, 0x6a, 0x67, 0x83, 0x84, + 0xc2, 0x8f, 0x8d, 0xa5, 0xae, 0x58, 0x96, 0x6a, 0xa5, 0x85, 0x96, 0xb4, 0x44, 0x0a, 0x6d, 0x35, 0xae, 0x10, 0x82, 0x43, 0x71, 0x9d, 0x59, 0x63, 0xd5, 0xf1, 0x18, 0x7b, 0x82, 0xe8, 0x7f, 0x80, - 0x7a, 0x42, 0xdc, 0x2b, 0x56, 0xa2, 0x42, 0x70, 0xe3, 0x08, 0xff, 0x41, 0x8f, 0x7b, 0xe4, 0x14, - 0x89, 0xf4, 0xc2, 0xdf, 0xb0, 0x27, 0x34, 0xe3, 0xb1, 0x93, 0xa6, 0x5b, 0xda, 0x0a, 0x6e, 0xdc, - 0xec, 0x79, 0xdf, 0xfb, 0xe6, 0xcd, 0xfb, 0xbe, 0x37, 0x36, 0xbc, 0x12, 0x46, 0x94, 0x51, 0x33, - 0x0e, 0xc2, 0x7d, 0x33, 0x22, 0xa1, 0xef, 0x39, 0x36, 0xa3, 0x51, 0x4b, 0xac, 0xa2, 0xca, 0xd7, - 0x76, 0xe4, 0x53, 0xb7, 0xc5, 0xa3, 0x75, 0xdd, 0xa5, 0xd4, 0xf5, 0x89, 0x29, 0x42, 0xfb, 0x83, - 0xc7, 0x26, 0xf3, 0xfa, 0x24, 0x66, 0x76, 0x3f, 0x4c, 0xd0, 0xf5, 0x3b, 0xae, 0xc7, 0xbe, 0x1c, - 0xec, 0xb7, 0x1c, 0xda, 0x37, 0x5d, 0xea, 0xd2, 0x31, 0x92, 0xbf, 0x25, 0xfb, 0xf0, 0x27, 0x09, - 0x5f, 0x4e, 0xc8, 0xc3, 0x7d, 0xb3, 0x4f, 0x98, 0xdd, 0xb3, 0x99, 0x9d, 0x04, 0x8c, 0x5f, 0xf2, - 0x50, 0xc5, 0xb2, 0x14, 0x82, 0xc9, 0x57, 0x03, 0x12, 0x33, 0x64, 0x41, 0x89, 0xd1, 0xd0, 0x73, - 0xf6, 0xbc, 0x5e, 0x4d, 0x69, 0x28, 0xcd, 0xe2, 0xda, 0xfd, 0xd1, 0x50, 0x9f, 0xdd, 0xe5, 0x6b, - 0x9d, 0x0f, 0x9f, 0x0d, 0xf5, 0x37, 0x26, 0x76, 0x3f, 0xb0, 0x0f, 0x6c, 0x6a, 0x26, 0xfc, 0x66, - 0x78, 0xe0, 0x9a, 0xec, 0x30, 0x24, 0x71, 0x4b, 0x82, 0xf1, 0xac, 0x60, 0xea, 0xf4, 0x50, 0x0f, - 0xe6, 0x7d, 0xea, 0xee, 0xc5, 0x2c, 0x22, 0x76, 0x9f, 0x33, 0xe7, 0x05, 0xf3, 0xfb, 0xa3, 0xa1, - 0x5e, 0xe9, 0x52, 0xd7, 0x12, 0xeb, 0x82, 0xfd, 0xce, 0xd5, 0xec, 0x13, 0x09, 0xb8, 0xe2, 0x67, - 0x2f, 0x3d, 0xb4, 0x01, 0xaa, 0xef, 0xc7, 0x41, 0xad, 0xd0, 0x28, 0x34, 0xd5, 0xb5, 0xd5, 0xd1, - 0x50, 0x57, 0xbb, 0x5d, 0x6b, 0xeb, 0xd9, 0x50, 0x7f, 0xfd, 0x1a, 0xac, 0x5d, 0x6b, 0x0b, 0x8b, - 0x7c, 0x84, 0x40, 0xe5, 0x5d, 0xaa, 0xa9, 0x8d, 0x42, 0x73, 0x0e, 0x8b, 0x67, 0x63, 0x09, 0x16, - 0x27, 0x5a, 0x15, 0x87, 0x34, 0x88, 0x89, 0x71, 0xa2, 0xc0, 0x9c, 0x75, 0x18, 0x38, 0x3b, 0x34, - 0xf6, 0x98, 0x47, 0x83, 0xac, 0x02, 0xde, 0xb8, 0x7f, 0x53, 0xc1, 0x06, 0xa8, 0x2e, 0xe7, 0xc9, - 0x8f, 0x79, 0x36, 0xaf, 0xcd, 0xb3, 0x29, 0x78, 0x78, 0xfe, 0x03, 0xf5, 0xaf, 0x27, 0xba, 0x62, - 0xfc, 0xa6, 0x40, 0x99, 0x97, 0x89, 0xed, 0xc0, 0x25, 0xe8, 0x13, 0x80, 0xc7, 0x5e, 0x14, 0xb3, - 0xbd, 0x89, 0x4a, 0xdf, 0x1d, 0x0d, 0xf5, 0xf2, 0x06, 0x5f, 0xbd, 0x61, 0xb9, 0x65, 0x41, 0xd5, - 0xe5, 0x35, 0x5b, 0x50, 0xf6, 0xed, 0x94, 0x36, 0x29, 0xfc, 0xde, 0x68, 0xa8, 0x97, 0xba, 0xf6, - 0x8d, 0x59, 0x4b, 0x9c, 0x88, 0x93, 0x1a, 0x3f, 0x14, 0xe0, 0x05, 0x5e, 0x7a, 0x27, 0xf0, 0x58, - 0xea, 0xd0, 0xcf, 0x01, 0x1c, 0x7f, 0x10, 0x33, 0x12, 0x8d, 0x3d, 0xfa, 0x90, 0x1f, 0x60, 0x3d, - 0x59, 0x15, 0x3e, 0x7a, 0xeb, 0xea, 0xad, 0x32, 0x38, 0x2e, 0x4b, 0xbe, 0x4e, 0x0f, 0x3d, 0x82, - 0x99, 0x98, 0x0e, 0x22, 0x87, 0x88, 0x23, 0x54, 0x56, 0x6f, 0xb7, 0xe4, 0x68, 0xa6, 0x43, 0x34, - 0xb6, 0x9f, 0xf4, 0xc3, 0x9a, 0x7a, 0x3a, 0xd4, 0x73, 0x58, 0xa6, 0xa1, 0x0e, 0x54, 0x7a, 0x24, - 0x66, 0x5e, 0x60, 0x73, 0x47, 0xd4, 0x0a, 0x37, 0x63, 0x99, 0xcc, 0x45, 0xab, 0x50, 0x8c, 0xb8, - 0x64, 0x35, 0x55, 0x90, 0xbc, 0xd4, 0x9a, 0xb8, 0x25, 0x5a, 0x99, 0xa0, 0x32, 0x33, 0x81, 0x22, - 0x0a, 0x4b, 0x42, 0x05, 0x87, 0xf6, 0xfb, 0x1e, 0x63, 0xa4, 0x97, 0xe8, 0x51, 0x14, 0x7a, 0x3c, - 0x1a, 0x0d, 0xf5, 0x45, 0xae, 0xc7, 0x7a, 0x1a, 0xbd, 0xa1, 0x30, 0x8b, 0xfe, 0xb9, 0x64, 0xae, - 0xd0, 0x06, 0x54, 0xc7, 0x02, 0x25, 0x73, 0x31, 0x2e, 0x5c, 0xb9, 0x76, 0xe1, 0xc6, 0x9f, 0x0a, - 0x00, 0x0f, 0x59, 0xcc, 0x66, 0x83, 0x18, 0xbd, 0x0d, 0xc5, 0x98, 0xd9, 0x2c, 0xa1, 0x58, 0x78, - 0x0e, 0x05, 0xc7, 0x11, 0x9c, 0x80, 0xd0, 0x3b, 0x50, 0x14, 0x46, 0x94, 0xa2, 0xbd, 0x7c, 0x01, - 0x9d, 0x4e, 0x68, 0xba, 0xa7, 0x40, 0xa3, 0xbb, 0xa0, 0xf2, 0x03, 0x49, 0x91, 0xae, 0xcc, 0x12, - 0x60, 0xf4, 0x1e, 0xcc, 0x3a, 0x83, 0x28, 0x22, 0x01, 0x93, 0xba, 0x5c, 0x99, 0x97, 0xe2, 0x8d, - 0xef, 0x15, 0xa8, 0x88, 0xb8, 0x7d, 0xe8, 0x53, 0xbb, 0x87, 0xda, 0xb0, 0x90, 0xe8, 0xb4, 0xe7, - 0xd0, 0x80, 0x91, 0x6f, 0x98, 0x6c, 0x98, 0x76, 0xc1, 0x2e, 0x49, 0xcf, 0xd7, 0x13, 0x14, 0x9e, - 0x77, 0x26, 0x5f, 0xd1, 0x3d, 0x28, 0xf3, 0xdb, 0x95, 0x04, 0x2c, 0x3a, 0x9c, 0xee, 0xc0, 0xa4, - 0xe1, 0xda, 0x1c, 0x80, 0x4b, 0xbe, 0x7c, 0x7a, 0xa0, 0x9e, 0xf2, 0xdb, 0xe1, 0xf7, 0x3c, 0xbc, - 0x28, 0x34, 0x99, 0xfe, 0x12, 0xfc, 0x6f, 0xe6, 0xec, 0x3e, 0xcc, 0x86, 0x89, 0x22, 0x52, 0xd1, - 0xda, 0x45, 0x45, 0x93, 0x78, 0x2a, 0xa8, 0x84, 0x1b, 0x1f, 0xc1, 0xad, 0xa9, 0xd6, 0xc9, 0x09, - 0x30, 0x61, 0x26, 0x16, 0x46, 0x96, 0x8a, 0x2e, 0x3f, 0xd7, 0xbf, 0x83, 0x18, 0x4b, 0xd8, 0x9b, - 0x3f, 0xc9, 0x3b, 0x5a, 0xd8, 0x1a, 0xad, 0x40, 0xb1, 0x8d, 0xf1, 0x36, 0xae, 0xe6, 0xea, 0xe8, - 0xe8, 0xb8, 0xb1, 0x90, 0x45, 0xda, 0x51, 0x44, 0x23, 0xd4, 0x84, 0x4a, 0x67, 0x6b, 0x6f, 0x07, - 0x6f, 0x6f, 0xe2, 0xb6, 0x65, 0x55, 0x95, 0xfa, 0xf2, 0xd1, 0x71, 0x63, 0x29, 0x03, 0x75, 0x82, - 0x9d, 0x88, 0xba, 0x11, 0x89, 0x63, 0xf4, 0x1a, 0x94, 0xd6, 0xb7, 0x3f, 0xde, 0xe9, 0xb6, 0x77, - 0xdb, 0xd5, 0x7c, 0xfd, 0xd6, 0xd1, 0x71, 0x63, 0x31, 0x83, 0xad, 0xd3, 0x7e, 0xe8, 0x93, 0x64, - 0x37, 0x6b, 0xf7, 0x03, 0xbc, 0x5b, 0x2d, 0x4c, 0xed, 0x66, 0x31, 0x3b, 0x62, 0xf5, 0xb9, 0x6f, - 0x7f, 0xd4, 0x72, 0x3f, 0x9f, 0x68, 0xb9, 0x5f, 0x4f, 0x34, 0x65, 0xf5, 0x2c, 0x0f, 0x80, 0xb3, - 0xff, 0x17, 0xb4, 0x05, 0xe5, 0xec, 0xf4, 0x68, 0xe5, 0xdc, 0x29, 0xa7, 0x0d, 0x55, 0xd7, 0x2e, - 0x0b, 0xcb, 0xcf, 0x69, 0xae, 0xa9, 0xa0, 0x0e, 0x94, 0xd2, 0xeb, 0x04, 0xbd, 0x7a, 0xa1, 0x69, - 0x13, 0x9f, 0x81, 0xfa, 0xca, 0x25, 0xd1, 0x94, 0x0c, 0x7d, 0x0a, 0xf3, 0xe7, 0xc4, 0x41, 0xb7, - 0x2f, 0xde, 0x43, 0xd3, 0x25, 0x1a, 0xff, 0x04, 0xc9, 0x98, 0xbf, 0x80, 0xa5, 0x73, 0xa1, 0xc4, - 0x61, 0xff, 0x19, 0x7f, 0x53, 0x59, 0x7b, 0x78, 0x3a, 0xd2, 0x94, 0xa7, 0x23, 0x4d, 0xf9, 0xee, - 0x4c, 0xcb, 0x3d, 0x39, 0xd3, 0x94, 0xa7, 0x67, 0x5a, 0xee, 0x8f, 0x33, 0x2d, 0xf7, 0x99, 0x71, - 0xe9, 0xc0, 0x65, 0xff, 0x97, 0xfb, 0x33, 0xe2, 0xf9, 0xee, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, - 0xc7, 0x56, 0x67, 0x23, 0x74, 0x0a, 0x00, 0x00, + 0x7a, 0x42, 0xdc, 0x2b, 0x2a, 0x51, 0x21, 0x8e, 0xdc, 0x58, 0xfe, 0x83, 0x1e, 0xf7, 0xc8, 0x29, + 0x12, 0xe9, 0x85, 0x3f, 0x01, 0xed, 0x09, 0xcd, 0x78, 0xec, 0xa4, 0xc9, 0x96, 0xb6, 0x82, 0x1b, + 0x37, 0x7b, 0xde, 0xf7, 0xbe, 0x79, 0xf3, 0xbe, 0xef, 0x8d, 0x0d, 0xaf, 0x04, 0x21, 0x65, 0xd4, + 0x88, 0xfc, 0x60, 0xdf, 0x08, 0x49, 0xe0, 0xb9, 0xb6, 0xc5, 0x68, 0xd8, 0x14, 0xab, 0xa8, 0xf4, + 0xb5, 0x15, 0x7a, 0xd4, 0x69, 0xf2, 0x68, 0x55, 0x77, 0x28, 0x75, 0x3c, 0x62, 0x88, 0xd0, 0x7e, + 0xff, 0xb1, 0xc1, 0xdc, 0x1e, 0x89, 0x98, 0xd5, 0x0b, 0x62, 0x74, 0xf5, 0xae, 0xe3, 0xb2, 0x2f, + 0xfb, 0xfb, 0x4d, 0x9b, 0xf6, 0x0c, 0x87, 0x3a, 0x74, 0x84, 0xe4, 0x6f, 0xf1, 0x3e, 0xfc, 0x49, + 0xc2, 0x97, 0x62, 0xf2, 0x60, 0xdf, 0xe8, 0x11, 0x66, 0x75, 0x2d, 0x66, 0xc5, 0x81, 0xfa, 0xaf, + 0x59, 0x28, 0x63, 0x59, 0x0a, 0xc1, 0xe4, 0xab, 0x3e, 0x89, 0x18, 0x32, 0xa1, 0xc0, 0x68, 0xe0, + 0xda, 0x7b, 0x6e, 0xb7, 0xa2, 0xd4, 0x94, 0x46, 0x7e, 0xed, 0xc1, 0x70, 0xa0, 0xcf, 0xec, 0xf2, + 0xb5, 0xf6, 0x87, 0xcf, 0x06, 0xfa, 0x1b, 0x63, 0xbb, 0x1f, 0x58, 0x07, 0x16, 0x35, 0x62, 0x7e, + 0x23, 0x38, 0x70, 0x0c, 0x76, 0x18, 0x90, 0xa8, 0x29, 0xc1, 0x78, 0x46, 0x30, 0xb5, 0xbb, 0xa8, + 0x0b, 0x73, 0x1e, 0x75, 0xf6, 0x22, 0x16, 0x12, 0xab, 0xc7, 0x99, 0xb3, 0x82, 0xf9, 0xfd, 0xe1, + 0x40, 0x2f, 0x75, 0xa8, 0x63, 0x8a, 0x75, 0xc1, 0x7e, 0xf7, 0x6a, 0xf6, 0xb1, 0x04, 0x5c, 0xf2, + 0xd2, 0x97, 0x2e, 0xda, 0x00, 0xd5, 0xf3, 0x22, 0xbf, 0x92, 0xab, 0xe5, 0x1a, 0xea, 0xda, 0xca, + 0x70, 0xa0, 0xab, 0x9d, 0x8e, 0xb9, 0xf5, 0x6c, 0xa0, 0xbf, 0x7e, 0x0d, 0xd6, 0x8e, 0xb9, 0x85, + 0x45, 0x3e, 0x42, 0xa0, 0xf2, 0x2e, 0x55, 0xd4, 0x5a, 0xae, 0x31, 0x8b, 0xc5, 0xf3, 0xea, 0xec, + 0x93, 0x13, 0x5d, 0xf9, 0xf3, 0x44, 0x57, 0xfe, 0x3a, 0xd1, 0x95, 0xfa, 0x22, 0x2c, 0x8c, 0x35, + 0x2e, 0x0a, 0xa8, 0x1f, 0x91, 0xfa, 0xa9, 0x02, 0xb3, 0xe6, 0xa1, 0x6f, 0xef, 0xd0, 0xc8, 0x65, + 0x2e, 0xf5, 0xd3, 0x7a, 0x78, 0x1b, 0xff, 0x4d, 0x3d, 0x1b, 0xa0, 0x3a, 0x9c, 0x27, 0x3b, 0xe2, + 0xd9, 0xbc, 0x36, 0xcf, 0xa6, 0xe0, 0xe1, 0xf9, 0xab, 0x2a, 0xaf, 0xbf, 0xfe, 0x44, 0x81, 0x22, + 0x2f, 0x13, 0x5b, 0xbe, 0x43, 0xd0, 0x27, 0x00, 0x8f, 0xdd, 0x30, 0x62, 0x7b, 0x63, 0x95, 0xbe, + 0x3b, 0x1c, 0xe8, 0xc5, 0x0d, 0xbe, 0x7a, 0xc3, 0x72, 0x8b, 0x82, 0xaa, 0xc3, 0x6b, 0x36, 0xa1, + 0xe8, 0x59, 0x09, 0x6d, 0x5c, 0xf8, 0xfd, 0xe1, 0x40, 0x2f, 0x74, 0xac, 0x1b, 0xb3, 0x16, 0x38, + 0x11, 0x27, 0xad, 0xff, 0x90, 0x83, 0x17, 0x78, 0xe9, 0x6d, 0xdf, 0x65, 0x89, 0x5f, 0x3f, 0x07, + 0xb0, 0xbd, 0x7e, 0xc4, 0x48, 0x38, 0x72, 0xec, 0x43, 0x7e, 0x80, 0xf5, 0x78, 0x55, 0xb8, 0xea, + 0xad, 0xab, 0xb7, 0x4a, 0xe1, 0xb8, 0x28, 0xf9, 0xda, 0x5d, 0xf4, 0x08, 0x6e, 0x45, 0xb4, 0x1f, + 0xda, 0x44, 0x1c, 0xa1, 0xb4, 0x72, 0xa7, 0x29, 0x07, 0x35, 0x19, 0xa9, 0x91, 0x19, 0xa5, 0x1f, + 0xd6, 0xd4, 0xb3, 0x81, 0x9e, 0xc1, 0x32, 0x0d, 0xb5, 0xa1, 0xd4, 0x25, 0x11, 0x73, 0x7d, 0x8b, + 0x3b, 0xa2, 0x92, 0xbb, 0x19, 0xcb, 0x78, 0x2e, 0x5a, 0x81, 0x7c, 0xc8, 0x25, 0xab, 0xa8, 0x82, + 0xe4, 0xa5, 0xe6, 0xd8, 0x9d, 0xd1, 0x4c, 0x05, 0x95, 0x99, 0x31, 0x14, 0x51, 0x58, 0x14, 0x2a, + 0xd8, 0xb4, 0xd7, 0x73, 0x19, 0x23, 0xdd, 0x58, 0x8f, 0xbc, 0xd0, 0xe3, 0xd1, 0x70, 0xa0, 0x2f, + 0x70, 0x3d, 0xd6, 0x93, 0xe8, 0x0d, 0x85, 0x59, 0xf0, 0x2e, 0x24, 0x73, 0x85, 0x36, 0xa0, 0x3c, + 0x12, 0x28, 0x9e, 0x8b, 0x51, 0xe1, 0xca, 0xb5, 0x0b, 0xaf, 0xff, 0xa1, 0x00, 0xf0, 0x90, 0xc9, + 0x2c, 0xd6, 0x8f, 0xd0, 0xdb, 0x90, 0x8f, 0x98, 0xc5, 0x62, 0x8a, 0xf9, 0xe7, 0x50, 0x70, 0x1c, + 0xc1, 0x31, 0x08, 0xbd, 0x03, 0x79, 0x61, 0x44, 0x29, 0xda, 0xcb, 0x53, 0xe8, 0x64, 0x42, 0x93, + 0x3d, 0x05, 0x1a, 0xdd, 0x03, 0x95, 0x1f, 0x48, 0x8a, 0x74, 0x65, 0x96, 0x00, 0xa3, 0xf7, 0x60, + 0xc6, 0xee, 0x87, 0x21, 0xf1, 0x99, 0xd4, 0xe5, 0xca, 0xbc, 0x04, 0x5f, 0xff, 0x5e, 0x81, 0x92, + 0x88, 0x5b, 0x87, 0x1e, 0xb5, 0xba, 0xa8, 0x05, 0xf3, 0xb1, 0x4e, 0x7b, 0x36, 0xf5, 0x19, 0xf9, + 0x86, 0xc9, 0x86, 0x69, 0x53, 0x76, 0x89, 0x7b, 0xbe, 0x1e, 0xa3, 0xf0, 0x9c, 0x3d, 0xfe, 0x8a, + 0xee, 0x43, 0x91, 0xdf, 0xb5, 0xc4, 0x67, 0xe1, 0xe1, 0x64, 0x07, 0xc6, 0x0d, 0xd7, 0xe2, 0x00, + 0x5c, 0xf0, 0xe4, 0xd3, 0xaa, 0x7a, 0xc6, 0x6f, 0x87, 0xdf, 0xb2, 0xf0, 0xa2, 0xd0, 0x64, 0xf2, + 0xbb, 0xf0, 0xbf, 0x99, 0xb3, 0x07, 0x30, 0x13, 0xc4, 0x8a, 0x48, 0x45, 0x2b, 0xd3, 0x8a, 0xc6, + 0xf1, 0x44, 0x50, 0x09, 0xaf, 0x7f, 0x04, 0xb7, 0x27, 0x5a, 0x27, 0x27, 0xc0, 0x80, 0x5b, 0x91, + 0x30, 0xb2, 0x54, 0x74, 0xe9, 0xb9, 0xfe, 0xed, 0x47, 0x58, 0xc2, 0xde, 0xfc, 0x49, 0xde, 0xd1, + 0xc2, 0xd6, 0x68, 0x19, 0xf2, 0x2d, 0x8c, 0xb7, 0x71, 0x39, 0x53, 0x45, 0x47, 0xc7, 0xb5, 0xf9, + 0x34, 0xd2, 0x0a, 0x43, 0x1a, 0xa2, 0x06, 0x94, 0xda, 0x5b, 0x7b, 0x3b, 0x78, 0x7b, 0x13, 0xb7, + 0x4c, 0xb3, 0xac, 0x54, 0x97, 0x8e, 0x8e, 0x6b, 0x8b, 0x29, 0xa8, 0xed, 0xef, 0x84, 0xd4, 0x09, + 0x49, 0x14, 0xa1, 0xd7, 0xa0, 0xb0, 0xbe, 0xfd, 0xf1, 0x4e, 0xa7, 0xb5, 0xdb, 0x2a, 0x67, 0xab, + 0xb7, 0x8f, 0x8e, 0x6b, 0x0b, 0x29, 0x6c, 0x9d, 0xf6, 0x02, 0x8f, 0xc4, 0xbb, 0x99, 0xbb, 0x1f, + 0xe0, 0xdd, 0x72, 0x6e, 0x62, 0x37, 0x93, 0x59, 0x21, 0xab, 0xce, 0x7e, 0xfb, 0xa3, 0x96, 0xf9, + 0xf9, 0x54, 0xcb, 0xfc, 0x72, 0xaa, 0x29, 0x2b, 0xe7, 0x59, 0x00, 0x9c, 0xfe, 0xcd, 0xa0, 0x2d, + 0x28, 0xa6, 0xa7, 0x47, 0xcb, 0x17, 0x4e, 0x39, 0x69, 0xa8, 0xaa, 0x76, 0x59, 0x58, 0x7e, 0x4e, + 0x33, 0x0d, 0x05, 0xb5, 0xa1, 0x90, 0x5c, 0x27, 0xe8, 0xd5, 0xa9, 0xa6, 0x8d, 0x7d, 0x06, 0xaa, + 0xcb, 0x97, 0x44, 0x13, 0x32, 0xf4, 0x29, 0xcc, 0x5d, 0x10, 0x07, 0xdd, 0x99, 0xbe, 0x87, 0x26, + 0x4b, 0xac, 0xff, 0x13, 0x24, 0x65, 0xfe, 0x02, 0x16, 0x2f, 0x84, 0x62, 0x87, 0xfd, 0x67, 0xfc, + 0x0d, 0x65, 0xed, 0xe1, 0xd9, 0x50, 0x53, 0x9e, 0x0e, 0x35, 0xe5, 0xbb, 0x73, 0x2d, 0x73, 0x72, + 0xae, 0x29, 0x4f, 0xcf, 0xb5, 0xcc, 0xef, 0xe7, 0x5a, 0xe6, 0xb3, 0xfa, 0xa5, 0x03, 0x97, 0xfe, + 0x6d, 0xee, 0xdf, 0x12, 0xcf, 0xf7, 0xfe, 0x0e, 0x00, 0x00, 0xff, 0xff, 0x1f, 0x25, 0x79, 0x9a, + 0x82, 0x0a, 0x00, 0x00, } func (x SyncState) String() string { @@ -736,6 +738,49 @@ func (x SyncState) String() string { } return strconv.Itoa(int(x)) } +func (this *ReplicateRequest) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*ReplicateRequest) + if !ok { + that2, ok := that.(ReplicateRequest) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.TopicID != that1.TopicID { + return false + } + if this.LogStreamID != that1.LogStreamID { + return false + } + if len(this.LLSN) != len(that1.LLSN) { + return false + } + for i := range this.LLSN { + if this.LLSN[i] != that1.LLSN[i] { + return false + } + } + if len(this.Data) != len(that1.Data) { + return false + } + for i := range this.Data { + if !bytes.Equal(this.Data[i], that1.Data[i]) { + return false + } + } + return true +} func (this *SyncPosition) Equal(that interface{}) bool { if that == nil { return this == nil @@ -1567,6 +1612,107 @@ func encodeVarintReplicator(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } +func NewPopulatedReplicateRequest(r randyReplicator, easy bool) *ReplicateRequest { + this := &ReplicateRequest{} + this.TopicID = github_com_kakao_varlog_pkg_types.TopicID(r.Int31()) + if r.Intn(2) == 0 { + this.TopicID *= -1 + } + this.LogStreamID = github_com_kakao_varlog_pkg_types.LogStreamID(r.Int31()) + if r.Intn(2) == 0 { + this.LogStreamID *= -1 + } + v1 := r.Intn(10) + this.LLSN = make([]github_com_kakao_varlog_pkg_types.LLSN, v1) + for i := 0; i < v1; i++ { + this.LLSN[i] = github_com_kakao_varlog_pkg_types.LLSN(uint64(r.Uint32())) + } + v2 := r.Intn(10) + this.Data = make([][]byte, v2) + for i := 0; i < v2; i++ { + v3 := r.Intn(100) + this.Data[i] = make([]byte, v3) + for j := 0; j < v3; j++ { + this.Data[i][j] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +type randyReplicator interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneReplicator(r randyReplicator) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringReplicator(r randyReplicator) string { + v4 := r.Intn(100) + tmps := make([]rune, v4) + for i := 0; i < v4; i++ { + tmps[i] = randUTF8RuneReplicator(r) + } + return string(tmps) +} +func randUnrecognizedReplicator(r randyReplicator, maxFieldNumber int) (dAtA []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + dAtA = randFieldReplicator(dAtA, r, fieldNumber, wire) + } + return dAtA +} +func randFieldReplicator(dAtA []byte, r randyReplicator, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + dAtA = encodeVarintPopulateReplicator(dAtA, uint64(key)) + v5 := r.Int63() + if r.Intn(2) == 0 { + v5 *= -1 + } + dAtA = encodeVarintPopulateReplicator(dAtA, uint64(v5)) + case 1: + dAtA = encodeVarintPopulateReplicator(dAtA, uint64(key)) + dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + dAtA = encodeVarintPopulateReplicator(dAtA, uint64(key)) + ll := r.Intn(100) + dAtA = encodeVarintPopulateReplicator(dAtA, uint64(ll)) + for j := 0; j < ll; j++ { + dAtA = append(dAtA, byte(r.Intn(256))) + } + default: + dAtA = encodeVarintPopulateReplicator(dAtA, uint64(key)) + dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return dAtA +} +func encodeVarintPopulateReplicator(dAtA []byte, v uint64) []byte { + for v >= 1<<7 { + dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + dAtA = append(dAtA, uint8(v)) + return dAtA +} func (m *ReplicateRequest) ProtoSize() (n int) { if m == nil { return 0 diff --git a/proto/snpb/replicator.proto b/proto/snpb/replicator.proto index 2bfe1ee32..0e8c3a637 100644 --- a/proto/snpb/replicator.proto +++ b/proto/snpb/replicator.proto @@ -17,6 +17,10 @@ option (gogoproto.goproto_unrecognized_all) = false; option (gogoproto.goproto_sizecache_all) = false; message ReplicateRequest { + option (gogoproto.equal) = true; + option (gogoproto.populate) = true; + option (gogoproto.testgen) = true; + int32 topic_id = 1 [ (gogoproto.casttype) = "github.com/kakao/varlog/pkg/types.TopicID", (gogoproto.customname) = "TopicID" diff --git a/proto/snpb/replicatorpb_test.go b/proto/snpb/replicatorpb_test.go new file mode 100644 index 000000000..5798e8b51 --- /dev/null +++ b/proto/snpb/replicatorpb_test.go @@ -0,0 +1,151 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: proto/snpb/replicator.proto + +package snpb + +import ( + fmt "fmt" + math "math" + math_rand "math/rand" + testing "testing" + time "time" + + _ "github.com/gogo/protobuf/gogoproto" + github_com_gogo_protobuf_jsonpb "github.com/gogo/protobuf/jsonpb" + github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" + proto "github.com/gogo/protobuf/proto" + _ "google.golang.org/protobuf/types/known/timestamppb" + + _ "github.com/kakao/varlog/proto/varlogpb" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestReplicateRequestProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedReplicateRequest(popr, false) + dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &ReplicateRequest{} + if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(dAtA)) + copy(littlefuzz, dAtA) + for i := range dAtA { + dAtA[i] = byte(popr.Intn(256)) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestReplicateRequestMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedReplicateRequest(popr, false) + size := p.ProtoSize() + dAtA := make([]byte, size) + for i := range dAtA { + dAtA[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(dAtA) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &ReplicateRequest{} + if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range dAtA { + dAtA[i] = byte(popr.Intn(256)) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestReplicateRequestJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedReplicateRequest(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &ReplicateRequest{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestReplicateRequestProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedReplicateRequest(popr, true) + dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &ReplicateRequest{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestReplicateRequestProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedReplicateRequest(popr, true) + dAtA := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &ReplicateRequest{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestReplicateRequestProtoSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedReplicateRequest(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.ProtoSize() + if len(dAtA) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/github.com/gogo/protobuf/jsonpb/jsonpb.go b/vendor/github.com/gogo/protobuf/jsonpb/jsonpb.go new file mode 100644 index 000000000..e8134ec8b --- /dev/null +++ b/vendor/github.com/gogo/protobuf/jsonpb/jsonpb.go @@ -0,0 +1,1435 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2015 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +/* +Package jsonpb provides marshaling and unmarshaling between protocol buffers and JSON. +It follows the specification at https://developers.google.com/protocol-buffers/docs/proto3#json. + +This package produces a different output than the standard "encoding/json" package, +which does not operate correctly on protocol buffers. +*/ +package jsonpb + +import ( + "bytes" + "encoding/json" + "errors" + "fmt" + "io" + "math" + "reflect" + "sort" + "strconv" + "strings" + "time" + + "github.com/gogo/protobuf/proto" + "github.com/gogo/protobuf/types" +) + +const secondInNanos = int64(time.Second / time.Nanosecond) +const maxSecondsInDuration = 315576000000 + +// Marshaler is a configurable object for converting between +// protocol buffer objects and a JSON representation for them. +type Marshaler struct { + // Whether to render enum values as integers, as opposed to string values. + EnumsAsInts bool + + // Whether to render fields with zero values. + EmitDefaults bool + + // A string to indent each level by. The presence of this field will + // also cause a space to appear between the field separator and + // value, and for newlines to be appear between fields and array + // elements. + Indent string + + // Whether to use the original (.proto) name for fields. + OrigName bool + + // A custom URL resolver to use when marshaling Any messages to JSON. + // If unset, the default resolution strategy is to extract the + // fully-qualified type name from the type URL and pass that to + // proto.MessageType(string). + AnyResolver AnyResolver +} + +// AnyResolver takes a type URL, present in an Any message, and resolves it into +// an instance of the associated message. +type AnyResolver interface { + Resolve(typeUrl string) (proto.Message, error) +} + +func defaultResolveAny(typeUrl string) (proto.Message, error) { + // Only the part of typeUrl after the last slash is relevant. + mname := typeUrl + if slash := strings.LastIndex(mname, "/"); slash >= 0 { + mname = mname[slash+1:] + } + mt := proto.MessageType(mname) + if mt == nil { + return nil, fmt.Errorf("unknown message type %q", mname) + } + return reflect.New(mt.Elem()).Interface().(proto.Message), nil +} + +// JSONPBMarshaler is implemented by protobuf messages that customize the +// way they are marshaled to JSON. Messages that implement this should +// also implement JSONPBUnmarshaler so that the custom format can be +// parsed. +// +// The JSON marshaling must follow the proto to JSON specification: +// https://developers.google.com/protocol-buffers/docs/proto3#json +type JSONPBMarshaler interface { + MarshalJSONPB(*Marshaler) ([]byte, error) +} + +// JSONPBUnmarshaler is implemented by protobuf messages that customize +// the way they are unmarshaled from JSON. Messages that implement this +// should also implement JSONPBMarshaler so that the custom format can be +// produced. +// +// The JSON unmarshaling must follow the JSON to proto specification: +// https://developers.google.com/protocol-buffers/docs/proto3#json +type JSONPBUnmarshaler interface { + UnmarshalJSONPB(*Unmarshaler, []byte) error +} + +// Marshal marshals a protocol buffer into JSON. +func (m *Marshaler) Marshal(out io.Writer, pb proto.Message) error { + v := reflect.ValueOf(pb) + if pb == nil || (v.Kind() == reflect.Ptr && v.IsNil()) { + return errors.New("Marshal called with nil") + } + // Check for unset required fields first. + if err := checkRequiredFields(pb); err != nil { + return err + } + writer := &errWriter{writer: out} + return m.marshalObject(writer, pb, "", "") +} + +// MarshalToString converts a protocol buffer object to JSON string. +func (m *Marshaler) MarshalToString(pb proto.Message) (string, error) { + var buf bytes.Buffer + if err := m.Marshal(&buf, pb); err != nil { + return "", err + } + return buf.String(), nil +} + +type int32Slice []int32 + +var nonFinite = map[string]float64{ + `"NaN"`: math.NaN(), + `"Infinity"`: math.Inf(1), + `"-Infinity"`: math.Inf(-1), +} + +// For sorting extensions ids to ensure stable output. +func (s int32Slice) Len() int { return len(s) } +func (s int32Slice) Less(i, j int) bool { return s[i] < s[j] } +func (s int32Slice) Swap(i, j int) { s[i], s[j] = s[j], s[i] } + +type isWkt interface { + XXX_WellKnownType() string +} + +var ( + wktType = reflect.TypeOf((*isWkt)(nil)).Elem() + messageType = reflect.TypeOf((*proto.Message)(nil)).Elem() +) + +// marshalObject writes a struct to the Writer. +func (m *Marshaler) marshalObject(out *errWriter, v proto.Message, indent, typeURL string) error { + if jsm, ok := v.(JSONPBMarshaler); ok { + b, err := jsm.MarshalJSONPB(m) + if err != nil { + return err + } + if typeURL != "" { + // we are marshaling this object to an Any type + var js map[string]*json.RawMessage + if err = json.Unmarshal(b, &js); err != nil { + return fmt.Errorf("type %T produced invalid JSON: %v", v, err) + } + turl, err := json.Marshal(typeURL) + if err != nil { + return fmt.Errorf("failed to marshal type URL %q to JSON: %v", typeURL, err) + } + js["@type"] = (*json.RawMessage)(&turl) + if m.Indent != "" { + b, err = json.MarshalIndent(js, indent, m.Indent) + } else { + b, err = json.Marshal(js) + } + if err != nil { + return err + } + } + + out.write(string(b)) + return out.err + } + + s := reflect.ValueOf(v).Elem() + + // Handle well-known types. + if wkt, ok := v.(isWkt); ok { + switch wkt.XXX_WellKnownType() { + case "DoubleValue", "FloatValue", "Int64Value", "UInt64Value", + "Int32Value", "UInt32Value", "BoolValue", "StringValue", "BytesValue": + // "Wrappers use the same representation in JSON + // as the wrapped primitive type, ..." + sprop := proto.GetProperties(s.Type()) + return m.marshalValue(out, sprop.Prop[0], s.Field(0), indent) + case "Any": + // Any is a bit more involved. + return m.marshalAny(out, v, indent) + case "Duration": + s, ns := s.Field(0).Int(), s.Field(1).Int() + if s < -maxSecondsInDuration || s > maxSecondsInDuration { + return fmt.Errorf("seconds out of range %v", s) + } + if ns <= -secondInNanos || ns >= secondInNanos { + return fmt.Errorf("ns out of range (%v, %v)", -secondInNanos, secondInNanos) + } + if (s > 0 && ns < 0) || (s < 0 && ns > 0) { + return errors.New("signs of seconds and nanos do not match") + } + // Generated output always contains 0, 3, 6, or 9 fractional digits, + // depending on required precision, followed by the suffix "s". + f := "%d.%09d" + if ns < 0 { + ns = -ns + if s == 0 { + f = "-%d.%09d" + } + } + x := fmt.Sprintf(f, s, ns) + x = strings.TrimSuffix(x, "000") + x = strings.TrimSuffix(x, "000") + x = strings.TrimSuffix(x, ".000") + out.write(`"`) + out.write(x) + out.write(`s"`) + return out.err + case "Struct", "ListValue": + // Let marshalValue handle the `Struct.fields` map or the `ListValue.values` slice. + // TODO: pass the correct Properties if needed. + return m.marshalValue(out, &proto.Properties{}, s.Field(0), indent) + case "Timestamp": + // "RFC 3339, where generated output will always be Z-normalized + // and uses 0, 3, 6 or 9 fractional digits." + s, ns := s.Field(0).Int(), s.Field(1).Int() + if ns < 0 || ns >= secondInNanos { + return fmt.Errorf("ns out of range [0, %v)", secondInNanos) + } + t := time.Unix(s, ns).UTC() + // time.RFC3339Nano isn't exactly right (we need to get 3/6/9 fractional digits). + x := t.Format("2006-01-02T15:04:05.000000000") + x = strings.TrimSuffix(x, "000") + x = strings.TrimSuffix(x, "000") + x = strings.TrimSuffix(x, ".000") + out.write(`"`) + out.write(x) + out.write(`Z"`) + return out.err + case "Value": + // Value has a single oneof. + kind := s.Field(0) + if kind.IsNil() { + // "absence of any variant indicates an error" + return errors.New("nil Value") + } + // oneof -> *T -> T -> T.F + x := kind.Elem().Elem().Field(0) + // TODO: pass the correct Properties if needed. + return m.marshalValue(out, &proto.Properties{}, x, indent) + } + } + + out.write("{") + if m.Indent != "" { + out.write("\n") + } + + firstField := true + + if typeURL != "" { + if err := m.marshalTypeURL(out, indent, typeURL); err != nil { + return err + } + firstField = false + } + + for i := 0; i < s.NumField(); i++ { + value := s.Field(i) + valueField := s.Type().Field(i) + if strings.HasPrefix(valueField.Name, "XXX_") { + continue + } + + //this is not a protobuf field + if valueField.Tag.Get("protobuf") == "" && valueField.Tag.Get("protobuf_oneof") == "" { + continue + } + + // IsNil will panic on most value kinds. + switch value.Kind() { + case reflect.Chan, reflect.Func, reflect.Interface: + if value.IsNil() { + continue + } + } + + if !m.EmitDefaults { + switch value.Kind() { + case reflect.Bool: + if !value.Bool() { + continue + } + case reflect.Int32, reflect.Int64: + if value.Int() == 0 { + continue + } + case reflect.Uint32, reflect.Uint64: + if value.Uint() == 0 { + continue + } + case reflect.Float32, reflect.Float64: + if value.Float() == 0 { + continue + } + case reflect.String: + if value.Len() == 0 { + continue + } + case reflect.Map, reflect.Ptr, reflect.Slice: + if value.IsNil() { + continue + } + } + } + + // Oneof fields need special handling. + if valueField.Tag.Get("protobuf_oneof") != "" { + // value is an interface containing &T{real_value}. + sv := value.Elem().Elem() // interface -> *T -> T + value = sv.Field(0) + valueField = sv.Type().Field(0) + } + prop := jsonProperties(valueField, m.OrigName) + if !firstField { + m.writeSep(out) + } + // If the map value is a cast type, it may not implement proto.Message, therefore + // allow the struct tag to declare the underlying message type. Change the property + // of the child types, use CustomType as a passer. CastType currently property is + // not used in json encoding. + if value.Kind() == reflect.Map { + if tag := valueField.Tag.Get("protobuf"); tag != "" { + for _, v := range strings.Split(tag, ",") { + if !strings.HasPrefix(v, "castvaluetype=") { + continue + } + v = strings.TrimPrefix(v, "castvaluetype=") + prop.MapValProp.CustomType = v + break + } + } + } + if err := m.marshalField(out, prop, value, indent); err != nil { + return err + } + firstField = false + } + + // Handle proto2 extensions. + if ep, ok := v.(proto.Message); ok { + extensions := proto.RegisteredExtensions(v) + // Sort extensions for stable output. + ids := make([]int32, 0, len(extensions)) + for id, desc := range extensions { + if !proto.HasExtension(ep, desc) { + continue + } + ids = append(ids, id) + } + sort.Sort(int32Slice(ids)) + for _, id := range ids { + desc := extensions[id] + if desc == nil { + // unknown extension + continue + } + ext, extErr := proto.GetExtension(ep, desc) + if extErr != nil { + return extErr + } + value := reflect.ValueOf(ext) + var prop proto.Properties + prop.Parse(desc.Tag) + prop.JSONName = fmt.Sprintf("[%s]", desc.Name) + if !firstField { + m.writeSep(out) + } + if err := m.marshalField(out, &prop, value, indent); err != nil { + return err + } + firstField = false + } + + } + + if m.Indent != "" { + out.write("\n") + out.write(indent) + } + out.write("}") + return out.err +} + +func (m *Marshaler) writeSep(out *errWriter) { + if m.Indent != "" { + out.write(",\n") + } else { + out.write(",") + } +} + +func (m *Marshaler) marshalAny(out *errWriter, any proto.Message, indent string) error { + // "If the Any contains a value that has a special JSON mapping, + // it will be converted as follows: {"@type": xxx, "value": yyy}. + // Otherwise, the value will be converted into a JSON object, + // and the "@type" field will be inserted to indicate the actual data type." + v := reflect.ValueOf(any).Elem() + turl := v.Field(0).String() + val := v.Field(1).Bytes() + + var msg proto.Message + var err error + if m.AnyResolver != nil { + msg, err = m.AnyResolver.Resolve(turl) + } else { + msg, err = defaultResolveAny(turl) + } + if err != nil { + return err + } + + if err := proto.Unmarshal(val, msg); err != nil { + return err + } + + if _, ok := msg.(isWkt); ok { + out.write("{") + if m.Indent != "" { + out.write("\n") + } + if err := m.marshalTypeURL(out, indent, turl); err != nil { + return err + } + m.writeSep(out) + if m.Indent != "" { + out.write(indent) + out.write(m.Indent) + out.write(`"value": `) + } else { + out.write(`"value":`) + } + if err := m.marshalObject(out, msg, indent+m.Indent, ""); err != nil { + return err + } + if m.Indent != "" { + out.write("\n") + out.write(indent) + } + out.write("}") + return out.err + } + + return m.marshalObject(out, msg, indent, turl) +} + +func (m *Marshaler) marshalTypeURL(out *errWriter, indent, typeURL string) error { + if m.Indent != "" { + out.write(indent) + out.write(m.Indent) + } + out.write(`"@type":`) + if m.Indent != "" { + out.write(" ") + } + b, err := json.Marshal(typeURL) + if err != nil { + return err + } + out.write(string(b)) + return out.err +} + +// marshalField writes field description and value to the Writer. +func (m *Marshaler) marshalField(out *errWriter, prop *proto.Properties, v reflect.Value, indent string) error { + if m.Indent != "" { + out.write(indent) + out.write(m.Indent) + } + out.write(`"`) + out.write(prop.JSONName) + out.write(`":`) + if m.Indent != "" { + out.write(" ") + } + if err := m.marshalValue(out, prop, v, indent); err != nil { + return err + } + return nil +} + +// marshalValue writes the value to the Writer. +func (m *Marshaler) marshalValue(out *errWriter, prop *proto.Properties, v reflect.Value, indent string) error { + + v = reflect.Indirect(v) + + // Handle nil pointer + if v.Kind() == reflect.Invalid { + out.write("null") + return out.err + } + + // Handle repeated elements. + if v.Kind() == reflect.Slice && v.Type().Elem().Kind() != reflect.Uint8 { + out.write("[") + comma := "" + for i := 0; i < v.Len(); i++ { + sliceVal := v.Index(i) + out.write(comma) + if m.Indent != "" { + out.write("\n") + out.write(indent) + out.write(m.Indent) + out.write(m.Indent) + } + if err := m.marshalValue(out, prop, sliceVal, indent+m.Indent); err != nil { + return err + } + comma = "," + } + if m.Indent != "" { + out.write("\n") + out.write(indent) + out.write(m.Indent) + } + out.write("]") + return out.err + } + + // Handle well-known types. + // Most are handled up in marshalObject (because 99% are messages). + if v.Type().Implements(wktType) { + wkt := v.Interface().(isWkt) + switch wkt.XXX_WellKnownType() { + case "NullValue": + out.write("null") + return out.err + } + } + + if t, ok := v.Interface().(time.Time); ok { + ts, err := types.TimestampProto(t) + if err != nil { + return err + } + return m.marshalValue(out, prop, reflect.ValueOf(ts), indent) + } + + if d, ok := v.Interface().(time.Duration); ok { + dur := types.DurationProto(d) + return m.marshalValue(out, prop, reflect.ValueOf(dur), indent) + } + + // Handle enumerations. + if !m.EnumsAsInts && prop.Enum != "" { + // Unknown enum values will are stringified by the proto library as their + // value. Such values should _not_ be quoted or they will be interpreted + // as an enum string instead of their value. + enumStr := v.Interface().(fmt.Stringer).String() + var valStr string + if v.Kind() == reflect.Ptr { + valStr = strconv.Itoa(int(v.Elem().Int())) + } else { + valStr = strconv.Itoa(int(v.Int())) + } + + if m, ok := v.Interface().(interface { + MarshalJSON() ([]byte, error) + }); ok { + data, err := m.MarshalJSON() + if err != nil { + return err + } + enumStr = string(data) + enumStr, err = strconv.Unquote(enumStr) + if err != nil { + return err + } + } + + isKnownEnum := enumStr != valStr + + if isKnownEnum { + out.write(`"`) + } + out.write(enumStr) + if isKnownEnum { + out.write(`"`) + } + return out.err + } + + // Handle nested messages. + if v.Kind() == reflect.Struct { + i := v + if v.CanAddr() { + i = v.Addr() + } else { + i = reflect.New(v.Type()) + i.Elem().Set(v) + } + iface := i.Interface() + if iface == nil { + out.write(`null`) + return out.err + } + + if m, ok := v.Interface().(interface { + MarshalJSON() ([]byte, error) + }); ok { + data, err := m.MarshalJSON() + if err != nil { + return err + } + out.write(string(data)) + return nil + } + + pm, ok := iface.(proto.Message) + if !ok { + if prop.CustomType == "" { + return fmt.Errorf("%v does not implement proto.Message", v.Type()) + } + t := proto.MessageType(prop.CustomType) + if t == nil || !i.Type().ConvertibleTo(t) { + return fmt.Errorf("%v declared custom type %s but it is not convertible to %v", v.Type(), prop.CustomType, t) + } + pm = i.Convert(t).Interface().(proto.Message) + } + return m.marshalObject(out, pm, indent+m.Indent, "") + } + + // Handle maps. + // Since Go randomizes map iteration, we sort keys for stable output. + if v.Kind() == reflect.Map { + out.write(`{`) + keys := v.MapKeys() + sort.Sort(mapKeys(keys)) + for i, k := range keys { + if i > 0 { + out.write(`,`) + } + if m.Indent != "" { + out.write("\n") + out.write(indent) + out.write(m.Indent) + out.write(m.Indent) + } + + // TODO handle map key prop properly + b, err := json.Marshal(k.Interface()) + if err != nil { + return err + } + s := string(b) + + // If the JSON is not a string value, encode it again to make it one. + if !strings.HasPrefix(s, `"`) { + b, err := json.Marshal(s) + if err != nil { + return err + } + s = string(b) + } + + out.write(s) + out.write(`:`) + if m.Indent != "" { + out.write(` `) + } + + vprop := prop + if prop != nil && prop.MapValProp != nil { + vprop = prop.MapValProp + } + if err := m.marshalValue(out, vprop, v.MapIndex(k), indent+m.Indent); err != nil { + return err + } + } + if m.Indent != "" { + out.write("\n") + out.write(indent) + out.write(m.Indent) + } + out.write(`}`) + return out.err + } + + // Handle non-finite floats, e.g. NaN, Infinity and -Infinity. + if v.Kind() == reflect.Float32 || v.Kind() == reflect.Float64 { + f := v.Float() + var sval string + switch { + case math.IsInf(f, 1): + sval = `"Infinity"` + case math.IsInf(f, -1): + sval = `"-Infinity"` + case math.IsNaN(f): + sval = `"NaN"` + } + if sval != "" { + out.write(sval) + return out.err + } + } + + // Default handling defers to the encoding/json library. + b, err := json.Marshal(v.Interface()) + if err != nil { + return err + } + needToQuote := string(b[0]) != `"` && (v.Kind() == reflect.Int64 || v.Kind() == reflect.Uint64) + if needToQuote { + out.write(`"`) + } + out.write(string(b)) + if needToQuote { + out.write(`"`) + } + return out.err +} + +// Unmarshaler is a configurable object for converting from a JSON +// representation to a protocol buffer object. +type Unmarshaler struct { + // Whether to allow messages to contain unknown fields, as opposed to + // failing to unmarshal. + AllowUnknownFields bool + + // A custom URL resolver to use when unmarshaling Any messages from JSON. + // If unset, the default resolution strategy is to extract the + // fully-qualified type name from the type URL and pass that to + // proto.MessageType(string). + AnyResolver AnyResolver +} + +// UnmarshalNext unmarshals the next protocol buffer from a JSON object stream. +// This function is lenient and will decode any options permutations of the +// related Marshaler. +func (u *Unmarshaler) UnmarshalNext(dec *json.Decoder, pb proto.Message) error { + inputValue := json.RawMessage{} + if err := dec.Decode(&inputValue); err != nil { + return err + } + if err := u.unmarshalValue(reflect.ValueOf(pb).Elem(), inputValue, nil); err != nil { + return err + } + return checkRequiredFields(pb) +} + +// Unmarshal unmarshals a JSON object stream into a protocol +// buffer. This function is lenient and will decode any options +// permutations of the related Marshaler. +func (u *Unmarshaler) Unmarshal(r io.Reader, pb proto.Message) error { + dec := json.NewDecoder(r) + return u.UnmarshalNext(dec, pb) +} + +// UnmarshalNext unmarshals the next protocol buffer from a JSON object stream. +// This function is lenient and will decode any options permutations of the +// related Marshaler. +func UnmarshalNext(dec *json.Decoder, pb proto.Message) error { + return new(Unmarshaler).UnmarshalNext(dec, pb) +} + +// Unmarshal unmarshals a JSON object stream into a protocol +// buffer. This function is lenient and will decode any options +// permutations of the related Marshaler. +func Unmarshal(r io.Reader, pb proto.Message) error { + return new(Unmarshaler).Unmarshal(r, pb) +} + +// UnmarshalString will populate the fields of a protocol buffer based +// on a JSON string. This function is lenient and will decode any options +// permutations of the related Marshaler. +func UnmarshalString(str string, pb proto.Message) error { + return new(Unmarshaler).Unmarshal(strings.NewReader(str), pb) +} + +// unmarshalValue converts/copies a value into the target. +// prop may be nil. +func (u *Unmarshaler) unmarshalValue(target reflect.Value, inputValue json.RawMessage, prop *proto.Properties) error { + targetType := target.Type() + + // Allocate memory for pointer fields. + if targetType.Kind() == reflect.Ptr { + // If input value is "null" and target is a pointer type, then the field should be treated as not set + // UNLESS the target is structpb.Value, in which case it should be set to structpb.NullValue. + _, isJSONPBUnmarshaler := target.Interface().(JSONPBUnmarshaler) + if string(inputValue) == "null" && targetType != reflect.TypeOf(&types.Value{}) && !isJSONPBUnmarshaler { + return nil + } + target.Set(reflect.New(targetType.Elem())) + + return u.unmarshalValue(target.Elem(), inputValue, prop) + } + + if jsu, ok := target.Addr().Interface().(JSONPBUnmarshaler); ok { + return jsu.UnmarshalJSONPB(u, []byte(inputValue)) + } + + // Handle well-known types that are not pointers. + if w, ok := target.Addr().Interface().(isWkt); ok { + switch w.XXX_WellKnownType() { + case "DoubleValue", "FloatValue", "Int64Value", "UInt64Value", + "Int32Value", "UInt32Value", "BoolValue", "StringValue", "BytesValue": + return u.unmarshalValue(target.Field(0), inputValue, prop) + case "Any": + // Use json.RawMessage pointer type instead of value to support pre-1.8 version. + // 1.8 changed RawMessage.MarshalJSON from pointer type to value type, see + // https://github.com/golang/go/issues/14493 + var jsonFields map[string]*json.RawMessage + if err := json.Unmarshal(inputValue, &jsonFields); err != nil { + return err + } + + val, ok := jsonFields["@type"] + if !ok || val == nil { + return errors.New("Any JSON doesn't have '@type'") + } + + var turl string + if err := json.Unmarshal([]byte(*val), &turl); err != nil { + return fmt.Errorf("can't unmarshal Any's '@type': %q", *val) + } + target.Field(0).SetString(turl) + + var m proto.Message + var err error + if u.AnyResolver != nil { + m, err = u.AnyResolver.Resolve(turl) + } else { + m, err = defaultResolveAny(turl) + } + if err != nil { + return err + } + + if _, ok := m.(isWkt); ok { + val, ok := jsonFields["value"] + if !ok { + return errors.New("Any JSON doesn't have 'value'") + } + + if err = u.unmarshalValue(reflect.ValueOf(m).Elem(), *val, nil); err != nil { + return fmt.Errorf("can't unmarshal Any nested proto %T: %v", m, err) + } + } else { + delete(jsonFields, "@type") + nestedProto, uerr := json.Marshal(jsonFields) + if uerr != nil { + return fmt.Errorf("can't generate JSON for Any's nested proto to be unmarshaled: %v", uerr) + } + + if err = u.unmarshalValue(reflect.ValueOf(m).Elem(), nestedProto, nil); err != nil { + return fmt.Errorf("can't unmarshal Any nested proto %T: %v", m, err) + } + } + + b, err := proto.Marshal(m) + if err != nil { + return fmt.Errorf("can't marshal proto %T into Any.Value: %v", m, err) + } + target.Field(1).SetBytes(b) + + return nil + case "Duration": + unq, err := unquote(string(inputValue)) + if err != nil { + return err + } + + d, err := time.ParseDuration(unq) + if err != nil { + return fmt.Errorf("bad Duration: %v", err) + } + + ns := d.Nanoseconds() + s := ns / 1e9 + ns %= 1e9 + target.Field(0).SetInt(s) + target.Field(1).SetInt(ns) + return nil + case "Timestamp": + unq, err := unquote(string(inputValue)) + if err != nil { + return err + } + + t, err := time.Parse(time.RFC3339Nano, unq) + if err != nil { + return fmt.Errorf("bad Timestamp: %v", err) + } + + target.Field(0).SetInt(t.Unix()) + target.Field(1).SetInt(int64(t.Nanosecond())) + return nil + case "Struct": + var m map[string]json.RawMessage + if err := json.Unmarshal(inputValue, &m); err != nil { + return fmt.Errorf("bad StructValue: %v", err) + } + target.Field(0).Set(reflect.ValueOf(map[string]*types.Value{})) + for k, jv := range m { + pv := &types.Value{} + if err := u.unmarshalValue(reflect.ValueOf(pv).Elem(), jv, prop); err != nil { + return fmt.Errorf("bad value in StructValue for key %q: %v", k, err) + } + target.Field(0).SetMapIndex(reflect.ValueOf(k), reflect.ValueOf(pv)) + } + return nil + case "ListValue": + var s []json.RawMessage + if err := json.Unmarshal(inputValue, &s); err != nil { + return fmt.Errorf("bad ListValue: %v", err) + } + + target.Field(0).Set(reflect.ValueOf(make([]*types.Value, len(s)))) + for i, sv := range s { + if err := u.unmarshalValue(target.Field(0).Index(i), sv, prop); err != nil { + return err + } + } + return nil + case "Value": + ivStr := string(inputValue) + if ivStr == "null" { + target.Field(0).Set(reflect.ValueOf(&types.Value_NullValue{})) + } else if v, err := strconv.ParseFloat(ivStr, 0); err == nil { + target.Field(0).Set(reflect.ValueOf(&types.Value_NumberValue{NumberValue: v})) + } else if v, err := unquote(ivStr); err == nil { + target.Field(0).Set(reflect.ValueOf(&types.Value_StringValue{StringValue: v})) + } else if v, err := strconv.ParseBool(ivStr); err == nil { + target.Field(0).Set(reflect.ValueOf(&types.Value_BoolValue{BoolValue: v})) + } else if err := json.Unmarshal(inputValue, &[]json.RawMessage{}); err == nil { + lv := &types.ListValue{} + target.Field(0).Set(reflect.ValueOf(&types.Value_ListValue{ListValue: lv})) + return u.unmarshalValue(reflect.ValueOf(lv).Elem(), inputValue, prop) + } else if err := json.Unmarshal(inputValue, &map[string]json.RawMessage{}); err == nil { + sv := &types.Struct{} + target.Field(0).Set(reflect.ValueOf(&types.Value_StructValue{StructValue: sv})) + return u.unmarshalValue(reflect.ValueOf(sv).Elem(), inputValue, prop) + } else { + return fmt.Errorf("unrecognized type for Value %q", ivStr) + } + return nil + } + } + + if t, ok := target.Addr().Interface().(*time.Time); ok { + ts := &types.Timestamp{} + if err := u.unmarshalValue(reflect.ValueOf(ts).Elem(), inputValue, prop); err != nil { + return err + } + tt, err := types.TimestampFromProto(ts) + if err != nil { + return err + } + *t = tt + return nil + } + + if d, ok := target.Addr().Interface().(*time.Duration); ok { + dur := &types.Duration{} + if err := u.unmarshalValue(reflect.ValueOf(dur).Elem(), inputValue, prop); err != nil { + return err + } + dd, err := types.DurationFromProto(dur) + if err != nil { + return err + } + *d = dd + return nil + } + + // Handle enums, which have an underlying type of int32, + // and may appear as strings. + // The case of an enum appearing as a number is handled + // at the bottom of this function. + if inputValue[0] == '"' && prop != nil && prop.Enum != "" { + vmap := proto.EnumValueMap(prop.Enum) + // Don't need to do unquoting; valid enum names + // are from a limited character set. + s := inputValue[1 : len(inputValue)-1] + n, ok := vmap[string(s)] + if !ok { + return fmt.Errorf("unknown value %q for enum %s", s, prop.Enum) + } + if target.Kind() == reflect.Ptr { // proto2 + target.Set(reflect.New(targetType.Elem())) + target = target.Elem() + } + if targetType.Kind() != reflect.Int32 { + return fmt.Errorf("invalid target %q for enum %s", targetType.Kind(), prop.Enum) + } + target.SetInt(int64(n)) + return nil + } + + if prop != nil && len(prop.CustomType) > 0 && target.CanAddr() { + if m, ok := target.Addr().Interface().(interface { + UnmarshalJSON([]byte) error + }); ok { + return json.Unmarshal(inputValue, m) + } + } + + // Handle nested messages. + if targetType.Kind() == reflect.Struct { + var jsonFields map[string]json.RawMessage + if err := json.Unmarshal(inputValue, &jsonFields); err != nil { + return err + } + + consumeField := func(prop *proto.Properties) (json.RawMessage, bool) { + // Be liberal in what names we accept; both orig_name and camelName are okay. + fieldNames := acceptedJSONFieldNames(prop) + + vOrig, okOrig := jsonFields[fieldNames.orig] + vCamel, okCamel := jsonFields[fieldNames.camel] + if !okOrig && !okCamel { + return nil, false + } + // If, for some reason, both are present in the data, favour the camelName. + var raw json.RawMessage + if okOrig { + raw = vOrig + delete(jsonFields, fieldNames.orig) + } + if okCamel { + raw = vCamel + delete(jsonFields, fieldNames.camel) + } + return raw, true + } + + sprops := proto.GetProperties(targetType) + for i := 0; i < target.NumField(); i++ { + ft := target.Type().Field(i) + if strings.HasPrefix(ft.Name, "XXX_") { + continue + } + valueForField, ok := consumeField(sprops.Prop[i]) + if !ok { + continue + } + + if err := u.unmarshalValue(target.Field(i), valueForField, sprops.Prop[i]); err != nil { + return err + } + } + // Check for any oneof fields. + if len(jsonFields) > 0 { + for _, oop := range sprops.OneofTypes { + raw, ok := consumeField(oop.Prop) + if !ok { + continue + } + nv := reflect.New(oop.Type.Elem()) + target.Field(oop.Field).Set(nv) + if err := u.unmarshalValue(nv.Elem().Field(0), raw, oop.Prop); err != nil { + return err + } + } + } + // Handle proto2 extensions. + if len(jsonFields) > 0 { + if ep, ok := target.Addr().Interface().(proto.Message); ok { + for _, ext := range proto.RegisteredExtensions(ep) { + name := fmt.Sprintf("[%s]", ext.Name) + raw, ok := jsonFields[name] + if !ok { + continue + } + delete(jsonFields, name) + nv := reflect.New(reflect.TypeOf(ext.ExtensionType).Elem()) + if err := u.unmarshalValue(nv.Elem(), raw, nil); err != nil { + return err + } + if err := proto.SetExtension(ep, ext, nv.Interface()); err != nil { + return err + } + } + } + } + if !u.AllowUnknownFields && len(jsonFields) > 0 { + // Pick any field to be the scapegoat. + var f string + for fname := range jsonFields { + f = fname + break + } + return fmt.Errorf("unknown field %q in %v", f, targetType) + } + return nil + } + + // Handle arrays + if targetType.Kind() == reflect.Slice { + if targetType.Elem().Kind() == reflect.Uint8 { + outRef := reflect.New(targetType) + outVal := outRef.Interface() + //CustomType with underlying type []byte + if _, ok := outVal.(interface { + UnmarshalJSON([]byte) error + }); ok { + if err := json.Unmarshal(inputValue, outVal); err != nil { + return err + } + target.Set(outRef.Elem()) + return nil + } + // Special case for encoded bytes. Pre-go1.5 doesn't support unmarshalling + // strings into aliased []byte types. + // https://github.com/golang/go/commit/4302fd0409da5e4f1d71471a6770dacdc3301197 + // https://github.com/golang/go/commit/c60707b14d6be26bf4213114d13070bff00d0b0a + var out []byte + if err := json.Unmarshal(inputValue, &out); err != nil { + return err + } + target.SetBytes(out) + return nil + } + + var slc []json.RawMessage + if err := json.Unmarshal(inputValue, &slc); err != nil { + return err + } + if slc != nil { + l := len(slc) + target.Set(reflect.MakeSlice(targetType, l, l)) + for i := 0; i < l; i++ { + if err := u.unmarshalValue(target.Index(i), slc[i], prop); err != nil { + return err + } + } + } + return nil + } + + // Handle maps (whose keys are always strings) + if targetType.Kind() == reflect.Map { + var mp map[string]json.RawMessage + if err := json.Unmarshal(inputValue, &mp); err != nil { + return err + } + if mp != nil { + target.Set(reflect.MakeMap(targetType)) + for ks, raw := range mp { + // Unmarshal map key. The core json library already decoded the key into a + // string, so we handle that specially. Other types were quoted post-serialization. + var k reflect.Value + if targetType.Key().Kind() == reflect.String { + k = reflect.ValueOf(ks) + } else { + k = reflect.New(targetType.Key()).Elem() + var kprop *proto.Properties + if prop != nil && prop.MapKeyProp != nil { + kprop = prop.MapKeyProp + } + if err := u.unmarshalValue(k, json.RawMessage(ks), kprop); err != nil { + return err + } + } + + if !k.Type().AssignableTo(targetType.Key()) { + k = k.Convert(targetType.Key()) + } + + // Unmarshal map value. + v := reflect.New(targetType.Elem()).Elem() + var vprop *proto.Properties + if prop != nil && prop.MapValProp != nil { + vprop = prop.MapValProp + } + if err := u.unmarshalValue(v, raw, vprop); err != nil { + return err + } + target.SetMapIndex(k, v) + } + } + return nil + } + + // Non-finite numbers can be encoded as strings. + isFloat := targetType.Kind() == reflect.Float32 || targetType.Kind() == reflect.Float64 + if isFloat { + if num, ok := nonFinite[string(inputValue)]; ok { + target.SetFloat(num) + return nil + } + } + + // integers & floats can be encoded as strings. In this case we drop + // the quotes and proceed as normal. + isNum := targetType.Kind() == reflect.Int64 || targetType.Kind() == reflect.Uint64 || + targetType.Kind() == reflect.Int32 || targetType.Kind() == reflect.Uint32 || + targetType.Kind() == reflect.Float32 || targetType.Kind() == reflect.Float64 + if isNum && strings.HasPrefix(string(inputValue), `"`) { + inputValue = inputValue[1 : len(inputValue)-1] + } + + // Use the encoding/json for parsing other value types. + return json.Unmarshal(inputValue, target.Addr().Interface()) +} + +func unquote(s string) (string, error) { + var ret string + err := json.Unmarshal([]byte(s), &ret) + return ret, err +} + +// jsonProperties returns parsed proto.Properties for the field and corrects JSONName attribute. +func jsonProperties(f reflect.StructField, origName bool) *proto.Properties { + var prop proto.Properties + prop.Init(f.Type, f.Name, f.Tag.Get("protobuf"), &f) + if origName || prop.JSONName == "" { + prop.JSONName = prop.OrigName + } + return &prop +} + +type fieldNames struct { + orig, camel string +} + +func acceptedJSONFieldNames(prop *proto.Properties) fieldNames { + opts := fieldNames{orig: prop.OrigName, camel: prop.OrigName} + if prop.JSONName != "" { + opts.camel = prop.JSONName + } + return opts +} + +// Writer wrapper inspired by https://blog.golang.org/errors-are-values +type errWriter struct { + writer io.Writer + err error +} + +func (w *errWriter) write(str string) { + if w.err != nil { + return + } + _, w.err = w.writer.Write([]byte(str)) +} + +// Map fields may have key types of non-float scalars, strings and enums. +// The easiest way to sort them in some deterministic order is to use fmt. +// If this turns out to be inefficient we can always consider other options, +// such as doing a Schwartzian transform. +// +// Numeric keys are sorted in numeric order per +// https://developers.google.com/protocol-buffers/docs/proto#maps. +type mapKeys []reflect.Value + +func (s mapKeys) Len() int { return len(s) } +func (s mapKeys) Swap(i, j int) { s[i], s[j] = s[j], s[i] } +func (s mapKeys) Less(i, j int) bool { + if k := s[i].Kind(); k == s[j].Kind() { + switch k { + case reflect.String: + return s[i].String() < s[j].String() + case reflect.Int32, reflect.Int64: + return s[i].Int() < s[j].Int() + case reflect.Uint32, reflect.Uint64: + return s[i].Uint() < s[j].Uint() + } + } + return fmt.Sprint(s[i].Interface()) < fmt.Sprint(s[j].Interface()) +} + +// checkRequiredFields returns an error if any required field in the given proto message is not set. +// This function is used by both Marshal and Unmarshal. While required fields only exist in a +// proto2 message, a proto3 message can contain proto2 message(s). +func checkRequiredFields(pb proto.Message) error { + // Most well-known type messages do not contain required fields. The "Any" type may contain + // a message that has required fields. + // + // When an Any message is being marshaled, the code will invoked proto.Unmarshal on Any.Value + // field in order to transform that into JSON, and that should have returned an error if a + // required field is not set in the embedded message. + // + // When an Any message is being unmarshaled, the code will have invoked proto.Marshal on the + // embedded message to store the serialized message in Any.Value field, and that should have + // returned an error if a required field is not set. + if _, ok := pb.(isWkt); ok { + return nil + } + + v := reflect.ValueOf(pb) + // Skip message if it is not a struct pointer. + if v.Kind() != reflect.Ptr { + return nil + } + v = v.Elem() + if v.Kind() != reflect.Struct { + return nil + } + + for i := 0; i < v.NumField(); i++ { + field := v.Field(i) + sfield := v.Type().Field(i) + + if sfield.PkgPath != "" { + // blank PkgPath means the field is exported; skip if not exported + continue + } + + if strings.HasPrefix(sfield.Name, "XXX_") { + continue + } + + // Oneof field is an interface implemented by wrapper structs containing the actual oneof + // field, i.e. an interface containing &T{real_value}. + if sfield.Tag.Get("protobuf_oneof") != "" { + if field.Kind() != reflect.Interface { + continue + } + v := field.Elem() + if v.Kind() != reflect.Ptr || v.IsNil() { + continue + } + v = v.Elem() + if v.Kind() != reflect.Struct || v.NumField() < 1 { + continue + } + field = v.Field(0) + sfield = v.Type().Field(0) + } + + protoTag := sfield.Tag.Get("protobuf") + if protoTag == "" { + continue + } + var prop proto.Properties + prop.Init(sfield.Type, sfield.Name, protoTag, &sfield) + + switch field.Kind() { + case reflect.Map: + if field.IsNil() { + continue + } + // Check each map value. + keys := field.MapKeys() + for _, k := range keys { + v := field.MapIndex(k) + if err := checkRequiredFieldsInValue(v); err != nil { + return err + } + } + case reflect.Slice: + // Handle non-repeated type, e.g. bytes. + if !prop.Repeated { + if prop.Required && field.IsNil() { + return fmt.Errorf("required field %q is not set", prop.Name) + } + continue + } + + // Handle repeated type. + if field.IsNil() { + continue + } + // Check each slice item. + for i := 0; i < field.Len(); i++ { + v := field.Index(i) + if err := checkRequiredFieldsInValue(v); err != nil { + return err + } + } + case reflect.Ptr: + if field.IsNil() { + if prop.Required { + return fmt.Errorf("required field %q is not set", prop.Name) + } + continue + } + if err := checkRequiredFieldsInValue(field); err != nil { + return err + } + } + } + + // Handle proto2 extensions. + for _, ext := range proto.RegisteredExtensions(pb) { + if !proto.HasExtension(pb, ext) { + continue + } + ep, err := proto.GetExtension(pb, ext) + if err != nil { + return err + } + err = checkRequiredFieldsInValue(reflect.ValueOf(ep)) + if err != nil { + return err + } + } + + return nil +} + +func checkRequiredFieldsInValue(v reflect.Value) error { + if v.Type().Implements(messageType) { + return checkRequiredFields(v.Interface().(proto.Message)) + } + return nil +} diff --git a/vendor/modules.txt b/vendor/modules.txt index 2e301f619..aed340fed 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -137,6 +137,7 @@ github.com/gogo/googleapis/google/rpc # github.com/gogo/protobuf v1.3.2 ## explicit; go 1.15 github.com/gogo/protobuf/gogoproto +github.com/gogo/protobuf/jsonpb github.com/gogo/protobuf/proto github.com/gogo/protobuf/protoc-gen-gogo/descriptor github.com/gogo/protobuf/sortkeys