github.com/cockroachdb/cockroach@v20.2.0-alpha.1+incompatible/pkg/rpc/heartbeat.pb.go (about) 1 // Code generated by protoc-gen-gogo. DO NOT EDIT. 2 // source: rpc/heartbeat.proto 3 4 package rpc 5 6 import proto "github.com/gogo/protobuf/proto" 7 import fmt "fmt" 8 import math "math" 9 import roachpb "github.com/cockroachdb/cockroach/pkg/roachpb" 10 11 import github_com_cockroachdb_cockroach_pkg_util_uuid "github.com/cockroachdb/cockroach/pkg/util/uuid" 12 import github_com_cockroachdb_cockroach_pkg_roachpb "github.com/cockroachdb/cockroach/pkg/roachpb" 13 14 import ( 15 context "context" 16 grpc "google.golang.org/grpc" 17 ) 18 19 import io "io" 20 21 // Reference imports to suppress errors if they are not otherwise used. 22 var _ = proto.Marshal 23 var _ = fmt.Errorf 24 var _ = math.Inf 25 26 // This is a compile-time assertion to ensure that this generated file 27 // is compatible with the proto package it is being compiled against. 28 // A compilation error at this line likely means your copy of the 29 // proto package needs to be updated. 30 const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package 31 32 // RemoteOffset keeps track of this client's estimate of its offset from a 33 // remote server. Uncertainty is the maximum error in the reading of this 34 // offset, so that the real offset should be in the interval 35 // [Offset - Uncertainty, Offset + Uncertainty]. If the last heartbeat timed 36 // out, Offset = 0. 37 // 38 // Offset and Uncertainty are measured using the remote clock reading technique 39 // described in http://se.inf.tu-dresden.de/pubs/papers/SRDS1994.pdf, page 6. 40 type RemoteOffset struct { 41 // The estimated offset from the remote server, in nanoseconds. 42 Offset int64 `protobuf:"varint,1,opt,name=offset" json:"offset"` 43 // The maximum error of the measured offset, in nanoseconds. 44 Uncertainty int64 `protobuf:"varint,2,opt,name=uncertainty" json:"uncertainty"` 45 // Measurement time, in nanoseconds from unix epoch. 46 MeasuredAt int64 `protobuf:"varint,3,opt,name=measured_at,json=measuredAt" json:"measured_at"` 47 } 48 49 func (m *RemoteOffset) Reset() { *m = RemoteOffset{} } 50 func (*RemoteOffset) ProtoMessage() {} 51 func (*RemoteOffset) Descriptor() ([]byte, []int) { 52 return fileDescriptor_heartbeat_b9adbf29944dc273, []int{0} 53 } 54 func (m *RemoteOffset) XXX_Unmarshal(b []byte) error { 55 return m.Unmarshal(b) 56 } 57 func (m *RemoteOffset) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 58 b = b[:cap(b)] 59 n, err := m.MarshalTo(b) 60 if err != nil { 61 return nil, err 62 } 63 return b[:n], nil 64 } 65 func (dst *RemoteOffset) XXX_Merge(src proto.Message) { 66 xxx_messageInfo_RemoteOffset.Merge(dst, src) 67 } 68 func (m *RemoteOffset) XXX_Size() int { 69 return m.Size() 70 } 71 func (m *RemoteOffset) XXX_DiscardUnknown() { 72 xxx_messageInfo_RemoteOffset.DiscardUnknown(m) 73 } 74 75 var xxx_messageInfo_RemoteOffset proto.InternalMessageInfo 76 77 // A PingRequest specifies the string to echo in response. 78 // Fields are exported so that they will be serialized in the rpc call. 79 type PingRequest struct { 80 // Echo this string with PingResponse. 81 Ping string `protobuf:"bytes,1,opt,name=ping" json:"ping"` 82 // The last offset the client measured with the server. 83 Offset RemoteOffset `protobuf:"bytes,2,opt,name=offset" json:"offset"` 84 // The address of the client. 85 Addr string `protobuf:"bytes,3,opt,name=addr" json:"addr"` 86 // The configured maximum clock offset (in nanoseconds) on the server. 87 MaxOffsetNanos int64 `protobuf:"varint,4,opt,name=max_offset_nanos,json=maxOffsetNanos" json:"max_offset_nanos"` 88 // Cluster ID to prevent connections between nodes in different clusters. 89 ClusterID *github_com_cockroachdb_cockroach_pkg_util_uuid.UUID `protobuf:"bytes,5,opt,name=cluster_id,json=clusterId,customtype=github.com/cockroachdb/cockroach/pkg/util/uuid.UUID" json:"cluster_id,omitempty"` 90 ServerVersion roachpb.Version `protobuf:"bytes,6,opt,name=server_version,json=serverVersion" json:"server_version"` 91 // Node ID to prevent connections from being misrouted to an invalid node inside the cluster. 92 NodeID github_com_cockroachdb_cockroach_pkg_roachpb.NodeID `protobuf:"varint,7,opt,name=node_id,json=nodeId,customtype=github.com/cockroachdb/cockroach/pkg/roachpb.NodeID" json:"node_id"` 93 } 94 95 func (m *PingRequest) Reset() { *m = PingRequest{} } 96 func (m *PingRequest) String() string { return proto.CompactTextString(m) } 97 func (*PingRequest) ProtoMessage() {} 98 func (*PingRequest) Descriptor() ([]byte, []int) { 99 return fileDescriptor_heartbeat_b9adbf29944dc273, []int{1} 100 } 101 func (m *PingRequest) XXX_Unmarshal(b []byte) error { 102 return m.Unmarshal(b) 103 } 104 func (m *PingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 105 b = b[:cap(b)] 106 n, err := m.MarshalTo(b) 107 if err != nil { 108 return nil, err 109 } 110 return b[:n], nil 111 } 112 func (dst *PingRequest) XXX_Merge(src proto.Message) { 113 xxx_messageInfo_PingRequest.Merge(dst, src) 114 } 115 func (m *PingRequest) XXX_Size() int { 116 return m.Size() 117 } 118 func (m *PingRequest) XXX_DiscardUnknown() { 119 xxx_messageInfo_PingRequest.DiscardUnknown(m) 120 } 121 122 var xxx_messageInfo_PingRequest proto.InternalMessageInfo 123 124 // A PingResponse contains the echoed ping request string. 125 type PingResponse struct { 126 // An echo of value sent with PingRequest. 127 Pong string `protobuf:"bytes,1,opt,name=pong" json:"pong"` 128 ServerTime int64 `protobuf:"varint,2,opt,name=server_time,json=serverTime" json:"server_time"` 129 ServerVersion roachpb.Version `protobuf:"bytes,3,opt,name=server_version,json=serverVersion" json:"server_version"` 130 // Cluster name to prevent joining a new node to the wrong cluster. 131 ClusterName string `protobuf:"bytes,4,opt,name=cluster_name,json=clusterName" json:"cluster_name"` 132 // Skip cluster name check if either side's name is empty / not configured. 133 DisableClusterNameVerification bool `protobuf:"varint,5,opt,name=disable_cluster_name_verification,json=disableClusterNameVerification" json:"disable_cluster_name_verification"` 134 } 135 136 func (m *PingResponse) Reset() { *m = PingResponse{} } 137 func (m *PingResponse) String() string { return proto.CompactTextString(m) } 138 func (*PingResponse) ProtoMessage() {} 139 func (*PingResponse) Descriptor() ([]byte, []int) { 140 return fileDescriptor_heartbeat_b9adbf29944dc273, []int{2} 141 } 142 func (m *PingResponse) XXX_Unmarshal(b []byte) error { 143 return m.Unmarshal(b) 144 } 145 func (m *PingResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 146 b = b[:cap(b)] 147 n, err := m.MarshalTo(b) 148 if err != nil { 149 return nil, err 150 } 151 return b[:n], nil 152 } 153 func (dst *PingResponse) XXX_Merge(src proto.Message) { 154 xxx_messageInfo_PingResponse.Merge(dst, src) 155 } 156 func (m *PingResponse) XXX_Size() int { 157 return m.Size() 158 } 159 func (m *PingResponse) XXX_DiscardUnknown() { 160 xxx_messageInfo_PingResponse.DiscardUnknown(m) 161 } 162 163 var xxx_messageInfo_PingResponse proto.InternalMessageInfo 164 165 func init() { 166 proto.RegisterType((*RemoteOffset)(nil), "cockroach.rpc.RemoteOffset") 167 proto.RegisterType((*PingRequest)(nil), "cockroach.rpc.PingRequest") 168 proto.RegisterType((*PingResponse)(nil), "cockroach.rpc.PingResponse") 169 } 170 171 // Reference imports to suppress errors if they are not otherwise used. 172 var _ context.Context 173 var _ grpc.ClientConn 174 175 // This is a compile-time assertion to ensure that this generated file 176 // is compatible with the grpc package it is being compiled against. 177 const _ = grpc.SupportPackageIsVersion4 178 179 // HeartbeatClient is the client API for Heartbeat service. 180 // 181 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. 182 type HeartbeatClient interface { 183 Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PingResponse, error) 184 } 185 186 type heartbeatClient struct { 187 cc *grpc.ClientConn 188 } 189 190 func NewHeartbeatClient(cc *grpc.ClientConn) HeartbeatClient { 191 return &heartbeatClient{cc} 192 } 193 194 func (c *heartbeatClient) Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PingResponse, error) { 195 out := new(PingResponse) 196 err := c.cc.Invoke(ctx, "/cockroach.rpc.Heartbeat/Ping", in, out, opts...) 197 if err != nil { 198 return nil, err 199 } 200 return out, nil 201 } 202 203 // HeartbeatServer is the server API for Heartbeat service. 204 type HeartbeatServer interface { 205 Ping(context.Context, *PingRequest) (*PingResponse, error) 206 } 207 208 func RegisterHeartbeatServer(s *grpc.Server, srv HeartbeatServer) { 209 s.RegisterService(&_Heartbeat_serviceDesc, srv) 210 } 211 212 func _Heartbeat_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 213 in := new(PingRequest) 214 if err := dec(in); err != nil { 215 return nil, err 216 } 217 if interceptor == nil { 218 return srv.(HeartbeatServer).Ping(ctx, in) 219 } 220 info := &grpc.UnaryServerInfo{ 221 Server: srv, 222 FullMethod: "/cockroach.rpc.Heartbeat/Ping", 223 } 224 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 225 return srv.(HeartbeatServer).Ping(ctx, req.(*PingRequest)) 226 } 227 return interceptor(ctx, in, info, handler) 228 } 229 230 var _Heartbeat_serviceDesc = grpc.ServiceDesc{ 231 ServiceName: "cockroach.rpc.Heartbeat", 232 HandlerType: (*HeartbeatServer)(nil), 233 Methods: []grpc.MethodDesc{ 234 { 235 MethodName: "Ping", 236 Handler: _Heartbeat_Ping_Handler, 237 }, 238 }, 239 Streams: []grpc.StreamDesc{}, 240 Metadata: "rpc/heartbeat.proto", 241 } 242 243 // TestingHeartbeatStreamClient is the client API for TestingHeartbeatStream service. 244 // 245 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. 246 type TestingHeartbeatStreamClient interface { 247 PingStream(ctx context.Context, opts ...grpc.CallOption) (TestingHeartbeatStream_PingStreamClient, error) 248 } 249 250 type testingHeartbeatStreamClient struct { 251 cc *grpc.ClientConn 252 } 253 254 func NewTestingHeartbeatStreamClient(cc *grpc.ClientConn) TestingHeartbeatStreamClient { 255 return &testingHeartbeatStreamClient{cc} 256 } 257 258 func (c *testingHeartbeatStreamClient) PingStream(ctx context.Context, opts ...grpc.CallOption) (TestingHeartbeatStream_PingStreamClient, error) { 259 stream, err := c.cc.NewStream(ctx, &_TestingHeartbeatStream_serviceDesc.Streams[0], "/cockroach.rpc.TestingHeartbeatStream/PingStream", opts...) 260 if err != nil { 261 return nil, err 262 } 263 x := &testingHeartbeatStreamPingStreamClient{stream} 264 return x, nil 265 } 266 267 type TestingHeartbeatStream_PingStreamClient interface { 268 Send(*PingRequest) error 269 Recv() (*PingResponse, error) 270 grpc.ClientStream 271 } 272 273 type testingHeartbeatStreamPingStreamClient struct { 274 grpc.ClientStream 275 } 276 277 func (x *testingHeartbeatStreamPingStreamClient) Send(m *PingRequest) error { 278 return x.ClientStream.SendMsg(m) 279 } 280 281 func (x *testingHeartbeatStreamPingStreamClient) Recv() (*PingResponse, error) { 282 m := new(PingResponse) 283 if err := x.ClientStream.RecvMsg(m); err != nil { 284 return nil, err 285 } 286 return m, nil 287 } 288 289 // TestingHeartbeatStreamServer is the server API for TestingHeartbeatStream service. 290 type TestingHeartbeatStreamServer interface { 291 PingStream(TestingHeartbeatStream_PingStreamServer) error 292 } 293 294 func RegisterTestingHeartbeatStreamServer(s *grpc.Server, srv TestingHeartbeatStreamServer) { 295 s.RegisterService(&_TestingHeartbeatStream_serviceDesc, srv) 296 } 297 298 func _TestingHeartbeatStream_PingStream_Handler(srv interface{}, stream grpc.ServerStream) error { 299 return srv.(TestingHeartbeatStreamServer).PingStream(&testingHeartbeatStreamPingStreamServer{stream}) 300 } 301 302 type TestingHeartbeatStream_PingStreamServer interface { 303 Send(*PingResponse) error 304 Recv() (*PingRequest, error) 305 grpc.ServerStream 306 } 307 308 type testingHeartbeatStreamPingStreamServer struct { 309 grpc.ServerStream 310 } 311 312 func (x *testingHeartbeatStreamPingStreamServer) Send(m *PingResponse) error { 313 return x.ServerStream.SendMsg(m) 314 } 315 316 func (x *testingHeartbeatStreamPingStreamServer) Recv() (*PingRequest, error) { 317 m := new(PingRequest) 318 if err := x.ServerStream.RecvMsg(m); err != nil { 319 return nil, err 320 } 321 return m, nil 322 } 323 324 var _TestingHeartbeatStream_serviceDesc = grpc.ServiceDesc{ 325 ServiceName: "cockroach.rpc.TestingHeartbeatStream", 326 HandlerType: (*TestingHeartbeatStreamServer)(nil), 327 Methods: []grpc.MethodDesc{}, 328 Streams: []grpc.StreamDesc{ 329 { 330 StreamName: "PingStream", 331 Handler: _TestingHeartbeatStream_PingStream_Handler, 332 ServerStreams: true, 333 ClientStreams: true, 334 }, 335 }, 336 Metadata: "rpc/heartbeat.proto", 337 } 338 339 func (m *RemoteOffset) Marshal() (dAtA []byte, err error) { 340 size := m.Size() 341 dAtA = make([]byte, size) 342 n, err := m.MarshalTo(dAtA) 343 if err != nil { 344 return nil, err 345 } 346 return dAtA[:n], nil 347 } 348 349 func (m *RemoteOffset) MarshalTo(dAtA []byte) (int, error) { 350 var i int 351 _ = i 352 var l int 353 _ = l 354 dAtA[i] = 0x8 355 i++ 356 i = encodeVarintHeartbeat(dAtA, i, uint64(m.Offset)) 357 dAtA[i] = 0x10 358 i++ 359 i = encodeVarintHeartbeat(dAtA, i, uint64(m.Uncertainty)) 360 dAtA[i] = 0x18 361 i++ 362 i = encodeVarintHeartbeat(dAtA, i, uint64(m.MeasuredAt)) 363 return i, nil 364 } 365 366 func (m *PingRequest) Marshal() (dAtA []byte, err error) { 367 size := m.Size() 368 dAtA = make([]byte, size) 369 n, err := m.MarshalTo(dAtA) 370 if err != nil { 371 return nil, err 372 } 373 return dAtA[:n], nil 374 } 375 376 func (m *PingRequest) MarshalTo(dAtA []byte) (int, error) { 377 var i int 378 _ = i 379 var l int 380 _ = l 381 dAtA[i] = 0xa 382 i++ 383 i = encodeVarintHeartbeat(dAtA, i, uint64(len(m.Ping))) 384 i += copy(dAtA[i:], m.Ping) 385 dAtA[i] = 0x12 386 i++ 387 i = encodeVarintHeartbeat(dAtA, i, uint64(m.Offset.Size())) 388 n1, err := m.Offset.MarshalTo(dAtA[i:]) 389 if err != nil { 390 return 0, err 391 } 392 i += n1 393 dAtA[i] = 0x1a 394 i++ 395 i = encodeVarintHeartbeat(dAtA, i, uint64(len(m.Addr))) 396 i += copy(dAtA[i:], m.Addr) 397 dAtA[i] = 0x20 398 i++ 399 i = encodeVarintHeartbeat(dAtA, i, uint64(m.MaxOffsetNanos)) 400 if m.ClusterID != nil { 401 dAtA[i] = 0x2a 402 i++ 403 i = encodeVarintHeartbeat(dAtA, i, uint64(m.ClusterID.Size())) 404 n2, err := m.ClusterID.MarshalTo(dAtA[i:]) 405 if err != nil { 406 return 0, err 407 } 408 i += n2 409 } 410 dAtA[i] = 0x32 411 i++ 412 i = encodeVarintHeartbeat(dAtA, i, uint64(m.ServerVersion.Size())) 413 n3, err := m.ServerVersion.MarshalTo(dAtA[i:]) 414 if err != nil { 415 return 0, err 416 } 417 i += n3 418 dAtA[i] = 0x38 419 i++ 420 i = encodeVarintHeartbeat(dAtA, i, uint64(m.NodeID)) 421 return i, nil 422 } 423 424 func (m *PingResponse) Marshal() (dAtA []byte, err error) { 425 size := m.Size() 426 dAtA = make([]byte, size) 427 n, err := m.MarshalTo(dAtA) 428 if err != nil { 429 return nil, err 430 } 431 return dAtA[:n], nil 432 } 433 434 func (m *PingResponse) MarshalTo(dAtA []byte) (int, error) { 435 var i int 436 _ = i 437 var l int 438 _ = l 439 dAtA[i] = 0xa 440 i++ 441 i = encodeVarintHeartbeat(dAtA, i, uint64(len(m.Pong))) 442 i += copy(dAtA[i:], m.Pong) 443 dAtA[i] = 0x10 444 i++ 445 i = encodeVarintHeartbeat(dAtA, i, uint64(m.ServerTime)) 446 dAtA[i] = 0x1a 447 i++ 448 i = encodeVarintHeartbeat(dAtA, i, uint64(m.ServerVersion.Size())) 449 n4, err := m.ServerVersion.MarshalTo(dAtA[i:]) 450 if err != nil { 451 return 0, err 452 } 453 i += n4 454 dAtA[i] = 0x22 455 i++ 456 i = encodeVarintHeartbeat(dAtA, i, uint64(len(m.ClusterName))) 457 i += copy(dAtA[i:], m.ClusterName) 458 dAtA[i] = 0x28 459 i++ 460 if m.DisableClusterNameVerification { 461 dAtA[i] = 1 462 } else { 463 dAtA[i] = 0 464 } 465 i++ 466 return i, nil 467 } 468 469 func encodeVarintHeartbeat(dAtA []byte, offset int, v uint64) int { 470 for v >= 1<<7 { 471 dAtA[offset] = uint8(v&0x7f | 0x80) 472 v >>= 7 473 offset++ 474 } 475 dAtA[offset] = uint8(v) 476 return offset + 1 477 } 478 func (m *RemoteOffset) Size() (n int) { 479 if m == nil { 480 return 0 481 } 482 var l int 483 _ = l 484 n += 1 + sovHeartbeat(uint64(m.Offset)) 485 n += 1 + sovHeartbeat(uint64(m.Uncertainty)) 486 n += 1 + sovHeartbeat(uint64(m.MeasuredAt)) 487 return n 488 } 489 490 func (m *PingRequest) Size() (n int) { 491 if m == nil { 492 return 0 493 } 494 var l int 495 _ = l 496 l = len(m.Ping) 497 n += 1 + l + sovHeartbeat(uint64(l)) 498 l = m.Offset.Size() 499 n += 1 + l + sovHeartbeat(uint64(l)) 500 l = len(m.Addr) 501 n += 1 + l + sovHeartbeat(uint64(l)) 502 n += 1 + sovHeartbeat(uint64(m.MaxOffsetNanos)) 503 if m.ClusterID != nil { 504 l = m.ClusterID.Size() 505 n += 1 + l + sovHeartbeat(uint64(l)) 506 } 507 l = m.ServerVersion.Size() 508 n += 1 + l + sovHeartbeat(uint64(l)) 509 n += 1 + sovHeartbeat(uint64(m.NodeID)) 510 return n 511 } 512 513 func (m *PingResponse) Size() (n int) { 514 if m == nil { 515 return 0 516 } 517 var l int 518 _ = l 519 l = len(m.Pong) 520 n += 1 + l + sovHeartbeat(uint64(l)) 521 n += 1 + sovHeartbeat(uint64(m.ServerTime)) 522 l = m.ServerVersion.Size() 523 n += 1 + l + sovHeartbeat(uint64(l)) 524 l = len(m.ClusterName) 525 n += 1 + l + sovHeartbeat(uint64(l)) 526 n += 2 527 return n 528 } 529 530 func sovHeartbeat(x uint64) (n int) { 531 for { 532 n++ 533 x >>= 7 534 if x == 0 { 535 break 536 } 537 } 538 return n 539 } 540 func sozHeartbeat(x uint64) (n int) { 541 return sovHeartbeat(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 542 } 543 func (m *RemoteOffset) Unmarshal(dAtA []byte) error { 544 l := len(dAtA) 545 iNdEx := 0 546 for iNdEx < l { 547 preIndex := iNdEx 548 var wire uint64 549 for shift := uint(0); ; shift += 7 { 550 if shift >= 64 { 551 return ErrIntOverflowHeartbeat 552 } 553 if iNdEx >= l { 554 return io.ErrUnexpectedEOF 555 } 556 b := dAtA[iNdEx] 557 iNdEx++ 558 wire |= (uint64(b) & 0x7F) << shift 559 if b < 0x80 { 560 break 561 } 562 } 563 fieldNum := int32(wire >> 3) 564 wireType := int(wire & 0x7) 565 if wireType == 4 { 566 return fmt.Errorf("proto: RemoteOffset: wiretype end group for non-group") 567 } 568 if fieldNum <= 0 { 569 return fmt.Errorf("proto: RemoteOffset: illegal tag %d (wire type %d)", fieldNum, wire) 570 } 571 switch fieldNum { 572 case 1: 573 if wireType != 0 { 574 return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType) 575 } 576 m.Offset = 0 577 for shift := uint(0); ; shift += 7 { 578 if shift >= 64 { 579 return ErrIntOverflowHeartbeat 580 } 581 if iNdEx >= l { 582 return io.ErrUnexpectedEOF 583 } 584 b := dAtA[iNdEx] 585 iNdEx++ 586 m.Offset |= (int64(b) & 0x7F) << shift 587 if b < 0x80 { 588 break 589 } 590 } 591 case 2: 592 if wireType != 0 { 593 return fmt.Errorf("proto: wrong wireType = %d for field Uncertainty", wireType) 594 } 595 m.Uncertainty = 0 596 for shift := uint(0); ; shift += 7 { 597 if shift >= 64 { 598 return ErrIntOverflowHeartbeat 599 } 600 if iNdEx >= l { 601 return io.ErrUnexpectedEOF 602 } 603 b := dAtA[iNdEx] 604 iNdEx++ 605 m.Uncertainty |= (int64(b) & 0x7F) << shift 606 if b < 0x80 { 607 break 608 } 609 } 610 case 3: 611 if wireType != 0 { 612 return fmt.Errorf("proto: wrong wireType = %d for field MeasuredAt", wireType) 613 } 614 m.MeasuredAt = 0 615 for shift := uint(0); ; shift += 7 { 616 if shift >= 64 { 617 return ErrIntOverflowHeartbeat 618 } 619 if iNdEx >= l { 620 return io.ErrUnexpectedEOF 621 } 622 b := dAtA[iNdEx] 623 iNdEx++ 624 m.MeasuredAt |= (int64(b) & 0x7F) << shift 625 if b < 0x80 { 626 break 627 } 628 } 629 default: 630 iNdEx = preIndex 631 skippy, err := skipHeartbeat(dAtA[iNdEx:]) 632 if err != nil { 633 return err 634 } 635 if skippy < 0 { 636 return ErrInvalidLengthHeartbeat 637 } 638 if (iNdEx + skippy) > l { 639 return io.ErrUnexpectedEOF 640 } 641 iNdEx += skippy 642 } 643 } 644 645 if iNdEx > l { 646 return io.ErrUnexpectedEOF 647 } 648 return nil 649 } 650 func (m *PingRequest) Unmarshal(dAtA []byte) error { 651 l := len(dAtA) 652 iNdEx := 0 653 for iNdEx < l { 654 preIndex := iNdEx 655 var wire uint64 656 for shift := uint(0); ; shift += 7 { 657 if shift >= 64 { 658 return ErrIntOverflowHeartbeat 659 } 660 if iNdEx >= l { 661 return io.ErrUnexpectedEOF 662 } 663 b := dAtA[iNdEx] 664 iNdEx++ 665 wire |= (uint64(b) & 0x7F) << shift 666 if b < 0x80 { 667 break 668 } 669 } 670 fieldNum := int32(wire >> 3) 671 wireType := int(wire & 0x7) 672 if wireType == 4 { 673 return fmt.Errorf("proto: PingRequest: wiretype end group for non-group") 674 } 675 if fieldNum <= 0 { 676 return fmt.Errorf("proto: PingRequest: illegal tag %d (wire type %d)", fieldNum, wire) 677 } 678 switch fieldNum { 679 case 1: 680 if wireType != 2 { 681 return fmt.Errorf("proto: wrong wireType = %d for field Ping", wireType) 682 } 683 var stringLen uint64 684 for shift := uint(0); ; shift += 7 { 685 if shift >= 64 { 686 return ErrIntOverflowHeartbeat 687 } 688 if iNdEx >= l { 689 return io.ErrUnexpectedEOF 690 } 691 b := dAtA[iNdEx] 692 iNdEx++ 693 stringLen |= (uint64(b) & 0x7F) << shift 694 if b < 0x80 { 695 break 696 } 697 } 698 intStringLen := int(stringLen) 699 if intStringLen < 0 { 700 return ErrInvalidLengthHeartbeat 701 } 702 postIndex := iNdEx + intStringLen 703 if postIndex > l { 704 return io.ErrUnexpectedEOF 705 } 706 m.Ping = string(dAtA[iNdEx:postIndex]) 707 iNdEx = postIndex 708 case 2: 709 if wireType != 2 { 710 return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType) 711 } 712 var msglen int 713 for shift := uint(0); ; shift += 7 { 714 if shift >= 64 { 715 return ErrIntOverflowHeartbeat 716 } 717 if iNdEx >= l { 718 return io.ErrUnexpectedEOF 719 } 720 b := dAtA[iNdEx] 721 iNdEx++ 722 msglen |= (int(b) & 0x7F) << shift 723 if b < 0x80 { 724 break 725 } 726 } 727 if msglen < 0 { 728 return ErrInvalidLengthHeartbeat 729 } 730 postIndex := iNdEx + msglen 731 if postIndex > l { 732 return io.ErrUnexpectedEOF 733 } 734 if err := m.Offset.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 735 return err 736 } 737 iNdEx = postIndex 738 case 3: 739 if wireType != 2 { 740 return fmt.Errorf("proto: wrong wireType = %d for field Addr", wireType) 741 } 742 var stringLen uint64 743 for shift := uint(0); ; shift += 7 { 744 if shift >= 64 { 745 return ErrIntOverflowHeartbeat 746 } 747 if iNdEx >= l { 748 return io.ErrUnexpectedEOF 749 } 750 b := dAtA[iNdEx] 751 iNdEx++ 752 stringLen |= (uint64(b) & 0x7F) << shift 753 if b < 0x80 { 754 break 755 } 756 } 757 intStringLen := int(stringLen) 758 if intStringLen < 0 { 759 return ErrInvalidLengthHeartbeat 760 } 761 postIndex := iNdEx + intStringLen 762 if postIndex > l { 763 return io.ErrUnexpectedEOF 764 } 765 m.Addr = string(dAtA[iNdEx:postIndex]) 766 iNdEx = postIndex 767 case 4: 768 if wireType != 0 { 769 return fmt.Errorf("proto: wrong wireType = %d for field MaxOffsetNanos", wireType) 770 } 771 m.MaxOffsetNanos = 0 772 for shift := uint(0); ; shift += 7 { 773 if shift >= 64 { 774 return ErrIntOverflowHeartbeat 775 } 776 if iNdEx >= l { 777 return io.ErrUnexpectedEOF 778 } 779 b := dAtA[iNdEx] 780 iNdEx++ 781 m.MaxOffsetNanos |= (int64(b) & 0x7F) << shift 782 if b < 0x80 { 783 break 784 } 785 } 786 case 5: 787 if wireType != 2 { 788 return fmt.Errorf("proto: wrong wireType = %d for field ClusterID", wireType) 789 } 790 var byteLen int 791 for shift := uint(0); ; shift += 7 { 792 if shift >= 64 { 793 return ErrIntOverflowHeartbeat 794 } 795 if iNdEx >= l { 796 return io.ErrUnexpectedEOF 797 } 798 b := dAtA[iNdEx] 799 iNdEx++ 800 byteLen |= (int(b) & 0x7F) << shift 801 if b < 0x80 { 802 break 803 } 804 } 805 if byteLen < 0 { 806 return ErrInvalidLengthHeartbeat 807 } 808 postIndex := iNdEx + byteLen 809 if postIndex > l { 810 return io.ErrUnexpectedEOF 811 } 812 var v github_com_cockroachdb_cockroach_pkg_util_uuid.UUID 813 m.ClusterID = &v 814 if err := m.ClusterID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 815 return err 816 } 817 iNdEx = postIndex 818 case 6: 819 if wireType != 2 { 820 return fmt.Errorf("proto: wrong wireType = %d for field ServerVersion", wireType) 821 } 822 var msglen int 823 for shift := uint(0); ; shift += 7 { 824 if shift >= 64 { 825 return ErrIntOverflowHeartbeat 826 } 827 if iNdEx >= l { 828 return io.ErrUnexpectedEOF 829 } 830 b := dAtA[iNdEx] 831 iNdEx++ 832 msglen |= (int(b) & 0x7F) << shift 833 if b < 0x80 { 834 break 835 } 836 } 837 if msglen < 0 { 838 return ErrInvalidLengthHeartbeat 839 } 840 postIndex := iNdEx + msglen 841 if postIndex > l { 842 return io.ErrUnexpectedEOF 843 } 844 if err := m.ServerVersion.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 845 return err 846 } 847 iNdEx = postIndex 848 case 7: 849 if wireType != 0 { 850 return fmt.Errorf("proto: wrong wireType = %d for field NodeID", wireType) 851 } 852 m.NodeID = 0 853 for shift := uint(0); ; shift += 7 { 854 if shift >= 64 { 855 return ErrIntOverflowHeartbeat 856 } 857 if iNdEx >= l { 858 return io.ErrUnexpectedEOF 859 } 860 b := dAtA[iNdEx] 861 iNdEx++ 862 m.NodeID |= (github_com_cockroachdb_cockroach_pkg_roachpb.NodeID(b) & 0x7F) << shift 863 if b < 0x80 { 864 break 865 } 866 } 867 default: 868 iNdEx = preIndex 869 skippy, err := skipHeartbeat(dAtA[iNdEx:]) 870 if err != nil { 871 return err 872 } 873 if skippy < 0 { 874 return ErrInvalidLengthHeartbeat 875 } 876 if (iNdEx + skippy) > l { 877 return io.ErrUnexpectedEOF 878 } 879 iNdEx += skippy 880 } 881 } 882 883 if iNdEx > l { 884 return io.ErrUnexpectedEOF 885 } 886 return nil 887 } 888 func (m *PingResponse) Unmarshal(dAtA []byte) error { 889 l := len(dAtA) 890 iNdEx := 0 891 for iNdEx < l { 892 preIndex := iNdEx 893 var wire uint64 894 for shift := uint(0); ; shift += 7 { 895 if shift >= 64 { 896 return ErrIntOverflowHeartbeat 897 } 898 if iNdEx >= l { 899 return io.ErrUnexpectedEOF 900 } 901 b := dAtA[iNdEx] 902 iNdEx++ 903 wire |= (uint64(b) & 0x7F) << shift 904 if b < 0x80 { 905 break 906 } 907 } 908 fieldNum := int32(wire >> 3) 909 wireType := int(wire & 0x7) 910 if wireType == 4 { 911 return fmt.Errorf("proto: PingResponse: wiretype end group for non-group") 912 } 913 if fieldNum <= 0 { 914 return fmt.Errorf("proto: PingResponse: illegal tag %d (wire type %d)", fieldNum, wire) 915 } 916 switch fieldNum { 917 case 1: 918 if wireType != 2 { 919 return fmt.Errorf("proto: wrong wireType = %d for field Pong", wireType) 920 } 921 var stringLen uint64 922 for shift := uint(0); ; shift += 7 { 923 if shift >= 64 { 924 return ErrIntOverflowHeartbeat 925 } 926 if iNdEx >= l { 927 return io.ErrUnexpectedEOF 928 } 929 b := dAtA[iNdEx] 930 iNdEx++ 931 stringLen |= (uint64(b) & 0x7F) << shift 932 if b < 0x80 { 933 break 934 } 935 } 936 intStringLen := int(stringLen) 937 if intStringLen < 0 { 938 return ErrInvalidLengthHeartbeat 939 } 940 postIndex := iNdEx + intStringLen 941 if postIndex > l { 942 return io.ErrUnexpectedEOF 943 } 944 m.Pong = string(dAtA[iNdEx:postIndex]) 945 iNdEx = postIndex 946 case 2: 947 if wireType != 0 { 948 return fmt.Errorf("proto: wrong wireType = %d for field ServerTime", wireType) 949 } 950 m.ServerTime = 0 951 for shift := uint(0); ; shift += 7 { 952 if shift >= 64 { 953 return ErrIntOverflowHeartbeat 954 } 955 if iNdEx >= l { 956 return io.ErrUnexpectedEOF 957 } 958 b := dAtA[iNdEx] 959 iNdEx++ 960 m.ServerTime |= (int64(b) & 0x7F) << shift 961 if b < 0x80 { 962 break 963 } 964 } 965 case 3: 966 if wireType != 2 { 967 return fmt.Errorf("proto: wrong wireType = %d for field ServerVersion", wireType) 968 } 969 var msglen int 970 for shift := uint(0); ; shift += 7 { 971 if shift >= 64 { 972 return ErrIntOverflowHeartbeat 973 } 974 if iNdEx >= l { 975 return io.ErrUnexpectedEOF 976 } 977 b := dAtA[iNdEx] 978 iNdEx++ 979 msglen |= (int(b) & 0x7F) << shift 980 if b < 0x80 { 981 break 982 } 983 } 984 if msglen < 0 { 985 return ErrInvalidLengthHeartbeat 986 } 987 postIndex := iNdEx + msglen 988 if postIndex > l { 989 return io.ErrUnexpectedEOF 990 } 991 if err := m.ServerVersion.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 992 return err 993 } 994 iNdEx = postIndex 995 case 4: 996 if wireType != 2 { 997 return fmt.Errorf("proto: wrong wireType = %d for field ClusterName", wireType) 998 } 999 var stringLen uint64 1000 for shift := uint(0); ; shift += 7 { 1001 if shift >= 64 { 1002 return ErrIntOverflowHeartbeat 1003 } 1004 if iNdEx >= l { 1005 return io.ErrUnexpectedEOF 1006 } 1007 b := dAtA[iNdEx] 1008 iNdEx++ 1009 stringLen |= (uint64(b) & 0x7F) << shift 1010 if b < 0x80 { 1011 break 1012 } 1013 } 1014 intStringLen := int(stringLen) 1015 if intStringLen < 0 { 1016 return ErrInvalidLengthHeartbeat 1017 } 1018 postIndex := iNdEx + intStringLen 1019 if postIndex > l { 1020 return io.ErrUnexpectedEOF 1021 } 1022 m.ClusterName = string(dAtA[iNdEx:postIndex]) 1023 iNdEx = postIndex 1024 case 5: 1025 if wireType != 0 { 1026 return fmt.Errorf("proto: wrong wireType = %d for field DisableClusterNameVerification", wireType) 1027 } 1028 var v int 1029 for shift := uint(0); ; shift += 7 { 1030 if shift >= 64 { 1031 return ErrIntOverflowHeartbeat 1032 } 1033 if iNdEx >= l { 1034 return io.ErrUnexpectedEOF 1035 } 1036 b := dAtA[iNdEx] 1037 iNdEx++ 1038 v |= (int(b) & 0x7F) << shift 1039 if b < 0x80 { 1040 break 1041 } 1042 } 1043 m.DisableClusterNameVerification = bool(v != 0) 1044 default: 1045 iNdEx = preIndex 1046 skippy, err := skipHeartbeat(dAtA[iNdEx:]) 1047 if err != nil { 1048 return err 1049 } 1050 if skippy < 0 { 1051 return ErrInvalidLengthHeartbeat 1052 } 1053 if (iNdEx + skippy) > l { 1054 return io.ErrUnexpectedEOF 1055 } 1056 iNdEx += skippy 1057 } 1058 } 1059 1060 if iNdEx > l { 1061 return io.ErrUnexpectedEOF 1062 } 1063 return nil 1064 } 1065 func skipHeartbeat(dAtA []byte) (n int, err error) { 1066 l := len(dAtA) 1067 iNdEx := 0 1068 for iNdEx < l { 1069 var wire uint64 1070 for shift := uint(0); ; shift += 7 { 1071 if shift >= 64 { 1072 return 0, ErrIntOverflowHeartbeat 1073 } 1074 if iNdEx >= l { 1075 return 0, io.ErrUnexpectedEOF 1076 } 1077 b := dAtA[iNdEx] 1078 iNdEx++ 1079 wire |= (uint64(b) & 0x7F) << shift 1080 if b < 0x80 { 1081 break 1082 } 1083 } 1084 wireType := int(wire & 0x7) 1085 switch wireType { 1086 case 0: 1087 for shift := uint(0); ; shift += 7 { 1088 if shift >= 64 { 1089 return 0, ErrIntOverflowHeartbeat 1090 } 1091 if iNdEx >= l { 1092 return 0, io.ErrUnexpectedEOF 1093 } 1094 iNdEx++ 1095 if dAtA[iNdEx-1] < 0x80 { 1096 break 1097 } 1098 } 1099 return iNdEx, nil 1100 case 1: 1101 iNdEx += 8 1102 return iNdEx, nil 1103 case 2: 1104 var length int 1105 for shift := uint(0); ; shift += 7 { 1106 if shift >= 64 { 1107 return 0, ErrIntOverflowHeartbeat 1108 } 1109 if iNdEx >= l { 1110 return 0, io.ErrUnexpectedEOF 1111 } 1112 b := dAtA[iNdEx] 1113 iNdEx++ 1114 length |= (int(b) & 0x7F) << shift 1115 if b < 0x80 { 1116 break 1117 } 1118 } 1119 iNdEx += length 1120 if length < 0 { 1121 return 0, ErrInvalidLengthHeartbeat 1122 } 1123 return iNdEx, nil 1124 case 3: 1125 for { 1126 var innerWire uint64 1127 var start int = iNdEx 1128 for shift := uint(0); ; shift += 7 { 1129 if shift >= 64 { 1130 return 0, ErrIntOverflowHeartbeat 1131 } 1132 if iNdEx >= l { 1133 return 0, io.ErrUnexpectedEOF 1134 } 1135 b := dAtA[iNdEx] 1136 iNdEx++ 1137 innerWire |= (uint64(b) & 0x7F) << shift 1138 if b < 0x80 { 1139 break 1140 } 1141 } 1142 innerWireType := int(innerWire & 0x7) 1143 if innerWireType == 4 { 1144 break 1145 } 1146 next, err := skipHeartbeat(dAtA[start:]) 1147 if err != nil { 1148 return 0, err 1149 } 1150 iNdEx = start + next 1151 } 1152 return iNdEx, nil 1153 case 4: 1154 return iNdEx, nil 1155 case 5: 1156 iNdEx += 4 1157 return iNdEx, nil 1158 default: 1159 return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 1160 } 1161 } 1162 panic("unreachable") 1163 } 1164 1165 var ( 1166 ErrInvalidLengthHeartbeat = fmt.Errorf("proto: negative length found during unmarshaling") 1167 ErrIntOverflowHeartbeat = fmt.Errorf("proto: integer overflow") 1168 ) 1169 1170 func init() { proto.RegisterFile("rpc/heartbeat.proto", fileDescriptor_heartbeat_b9adbf29944dc273) } 1171 1172 var fileDescriptor_heartbeat_b9adbf29944dc273 = []byte{ 1173 // 594 bytes of a gzipped FileDescriptorProto 1174 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x53, 0x41, 0x4f, 0xd4, 0x40, 1175 0x14, 0x6e, 0xd9, 0xb2, 0xb8, 0xb3, 0x0b, 0x31, 0xa3, 0x21, 0xcd, 0x62, 0xba, 0xb8, 0x09, 0xba, 1176 0xa7, 0xd6, 0xe0, 0x49, 0x6f, 0x2c, 0x18, 0xdd, 0x98, 0x2c, 0x66, 0x05, 0x0e, 0x1e, 0x6c, 0x66, 1177 0x3b, 0x8f, 0x32, 0x81, 0xce, 0xd4, 0xe9, 0x94, 0xe0, 0xd1, 0x7f, 0x60, 0x3c, 0x79, 0xf4, 0x77, 1178 0xf8, 0x0b, 0x38, 0x72, 0x24, 0x1e, 0x88, 0x2e, 0x7f, 0xc4, 0x4c, 0xa7, 0xbb, 0x14, 0xe4, 0x60, 1179 0xb8, 0xbd, 0xbe, 0xf7, 0xbd, 0xf7, 0xbe, 0x6f, 0xbe, 0x57, 0xf4, 0x40, 0xa6, 0x51, 0x70, 0x00, 1180 0x44, 0xaa, 0x31, 0x10, 0xe5, 0xa7, 0x52, 0x28, 0x81, 0x17, 0x23, 0x11, 0x1d, 0x4a, 0x41, 0xa2, 1181 0x03, 0x5f, 0xa6, 0x51, 0x7b, 0xb9, 0x08, 0xd3, 0x71, 0x90, 0x80, 0x22, 0x94, 0x28, 0x62, 0x60, 1182 0xed, 0x87, 0xb1, 0x88, 0x45, 0x11, 0x06, 0x3a, 0x32, 0xd9, 0xee, 0x17, 0x1b, 0xb5, 0x46, 0x90, 1183 0x08, 0x05, 0xdb, 0xfb, 0xfb, 0x19, 0x28, 0xfc, 0x08, 0xd5, 0x45, 0x11, 0xb9, 0xf6, 0xaa, 0xdd, 1184 0xab, 0xf5, 0x9d, 0xd3, 0x8b, 0x8e, 0x35, 0x2a, 0x73, 0xf8, 0x09, 0x6a, 0xe6, 0x3c, 0x02, 0xa9, 1185 0x08, 0xe3, 0xea, 0xb3, 0x3b, 0x57, 0x81, 0x54, 0x0b, 0x78, 0x0d, 0x35, 0x13, 0x20, 0x59, 0x2e, 1186 0x81, 0x86, 0x44, 0xb9, 0xb5, 0x0a, 0x0e, 0x4d, 0x0b, 0x1b, 0xea, 0xa5, 0xf3, 0xfd, 0x47, 0xc7, 1187 0xea, 0xfe, 0xac, 0xa1, 0xe6, 0x3b, 0xc6, 0xe3, 0x11, 0x7c, 0xca, 0x21, 0x53, 0xd8, 0x45, 0x4e, 1188 0xca, 0x78, 0x5c, 0x10, 0x68, 0x94, 0x5d, 0x45, 0x06, 0xbf, 0x98, 0x91, 0xd3, 0x9b, 0x9b, 0xeb, 1189 0x2b, 0xfe, 0x35, 0xed, 0x7e, 0x55, 0xc9, 0x0d, 0xe6, 0x2e, 0x72, 0x08, 0xa5, 0xb2, 0xa0, 0x32, 1190 0x1b, 0xaa, 0x33, 0xd8, 0x47, 0xf7, 0x13, 0x72, 0x12, 0x1a, 0x5c, 0xc8, 0x09, 0x17, 0x99, 0xeb, 1191 0x54, 0x08, 0x2f, 0x25, 0xe4, 0xc4, 0x8c, 0x1c, 0xea, 0x1a, 0x8e, 0x10, 0x8a, 0x8e, 0xf2, 0x4c, 1192 0x81, 0x0c, 0x19, 0x75, 0xe7, 0x57, 0xed, 0x5e, 0xab, 0xbf, 0xf5, 0xeb, 0xa2, 0xf3, 0x3c, 0x66, 1193 0xea, 0x20, 0x1f, 0xfb, 0x91, 0x48, 0x82, 0x19, 0x2d, 0x3a, 0xbe, 0x8a, 0x83, 0xf4, 0x30, 0x0e, 1194 0x72, 0xc5, 0x8e, 0x82, 0x3c, 0x67, 0xd4, 0xdf, 0xdd, 0x1d, 0x6c, 0x4d, 0x2e, 0x3a, 0x8d, 0x4d, 1195 0x33, 0x6c, 0xb0, 0x35, 0x6a, 0x94, 0x73, 0x07, 0x14, 0xbf, 0x46, 0x4b, 0x19, 0xc8, 0x63, 0x90, 1196 0xe1, 0x31, 0xc8, 0x8c, 0x09, 0xee, 0xd6, 0x0b, 0xc5, 0xed, 0xaa, 0x62, 0x63, 0xb4, 0xbf, 0x67, 1197 0x10, 0x25, 0xdd, 0x45, 0xd3, 0x57, 0x26, 0xf1, 0x47, 0xb4, 0xc0, 0x05, 0x05, 0x4d, 0x75, 0x61, 1198 0xd5, 0xee, 0xcd, 0xf7, 0x5f, 0x69, 0xd4, 0x7f, 0xd3, 0x9d, 0xee, 0x18, 0x0a, 0x0a, 0x05, 0xdd, 1199 0xba, 0x89, 0x46, 0x75, 0x3d, 0x75, 0x40, 0xbb, 0xdf, 0xe6, 0x50, 0xcb, 0x98, 0x97, 0xa5, 0x82, 1200 0x67, 0x50, 0xb8, 0x27, 0xfe, 0x71, 0x4f, 0xf0, 0x58, 0x1f, 0x45, 0xa9, 0x49, 0xb1, 0x04, 0xae, 1201 0x1d, 0x0f, 0x32, 0x85, 0x1d, 0x96, 0xc0, 0x2d, 0xd2, 0x6b, 0x77, 0x93, 0xfe, 0x14, 0xb5, 0xa6, 1202 0x46, 0x71, 0x92, 0x40, 0x61, 0xea, 0x94, 0x51, 0xb3, 0xac, 0x0c, 0x49, 0x02, 0x78, 0x1b, 0x3d, 1203 0xa6, 0x2c, 0x23, 0xe3, 0x23, 0x08, 0xab, 0x0d, 0x7a, 0x3f, 0xdb, 0x67, 0x11, 0x51, 0x9a, 0x84, 1204 0x36, 0xfa, 0x5e, 0xd9, 0xed, 0x95, 0xf0, 0xcd, 0xab, 0x21, 0x7b, 0x15, 0xec, 0xfa, 0x10, 0x35, 1205 0xde, 0x4c, 0xff, 0x52, 0xbc, 0x81, 0x1c, 0xfd, 0x40, 0xb8, 0x7d, 0xe3, 0x58, 0x2b, 0x27, 0xdf, 1206 0x5e, 0xb9, 0xb5, 0x66, 0x5e, 0xb4, 0x6b, 0xad, 0x03, 0x5a, 0xde, 0x81, 0x4c, 0x31, 0x1e, 0xcf, 1207 0xc6, 0xbe, 0x57, 0x12, 0x48, 0x82, 0xdf, 0x22, 0xa4, 0xb1, 0xe5, 0xd7, 0xdd, 0x57, 0xf4, 0xec, 1208 0x67, 0x76, 0x7f, 0xed, 0xf4, 0x8f, 0x67, 0x9d, 0x4e, 0x3c, 0xfb, 0x6c, 0xe2, 0xd9, 0xe7, 0x13, 1209 0xcf, 0xfe, 0x3d, 0xf1, 0xec, 0xaf, 0x97, 0x9e, 0x75, 0x76, 0xe9, 0x59, 0xe7, 0x97, 0x9e, 0xf5, 1210 0xa1, 0x26, 0xd3, 0xe8, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x08, 0x36, 0xe1, 0x9a, 0x86, 0x04, 1211 0x00, 0x00, 1212 }