From 54b30fd5074977d7056ab35163a77e04b1d5c020 Mon Sep 17 00:00:00 2001 From: Nathan VanBenschoten Date: Wed, 17 Jun 2020 13:44:51 -0400 Subject: [PATCH 1/3] util: fix comment on UnresolvedAddr --- pkg/util/unresolved_addr.pb.go | 8 ++++---- pkg/util/unresolved_addr.proto | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/pkg/util/unresolved_addr.pb.go b/pkg/util/unresolved_addr.pb.go index f1b2be5921c0..934ef91f5cc0 100644 --- a/pkg/util/unresolved_addr.pb.go +++ b/pkg/util/unresolved_addr.pb.go @@ -20,7 +20,7 @@ var _ = math.Inf // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package -// / UnresolvedAddr is an unresolved version of net.Addr. +// UnresolvedAddr is an unresolved version of net.Addr. type UnresolvedAddr struct { NetworkField string `protobuf:"bytes,1,opt,name=network_field,json=networkField" json:"network_field"` AddressField string `protobuf:"bytes,2,opt,name=address_field,json=addressField" json:"address_field"` @@ -29,7 +29,7 @@ type UnresolvedAddr struct { func (m *UnresolvedAddr) Reset() { *m = UnresolvedAddr{} } func (*UnresolvedAddr) ProtoMessage() {} func (*UnresolvedAddr) Descriptor() ([]byte, []int) { - return fileDescriptor_unresolved_addr_a6b5b457ac12f1b5, []int{0} + return fileDescriptor_unresolved_addr_0d9480e232c67772, []int{0} } func (m *UnresolvedAddr) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -332,10 +332,10 @@ var ( ) func init() { - proto.RegisterFile("util/unresolved_addr.proto", fileDescriptor_unresolved_addr_a6b5b457ac12f1b5) + proto.RegisterFile("util/unresolved_addr.proto", fileDescriptor_unresolved_addr_0d9480e232c67772) } -var fileDescriptor_unresolved_addr_a6b5b457ac12f1b5 = []byte{ +var fileDescriptor_unresolved_addr_0d9480e232c67772 = []byte{ // 188 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x2a, 0x2d, 0xc9, 0xcc, 0xd1, 0x2f, 0xcd, 0x2b, 0x4a, 0x2d, 0xce, 0xcf, 0x29, 0x4b, 0x4d, 0x89, 0x4f, 0x4c, 0x49, 0x29, diff --git a/pkg/util/unresolved_addr.proto b/pkg/util/unresolved_addr.proto index 21537f8cd5d9..d91c20c1c7ad 100644 --- a/pkg/util/unresolved_addr.proto +++ b/pkg/util/unresolved_addr.proto @@ -14,7 +14,7 @@ option go_package = "util"; import "gogoproto/gogo.proto"; -// / UnresolvedAddr is an unresolved version of net.Addr. +// UnresolvedAddr is an unresolved version of net.Addr. message UnresolvedAddr { option (gogoproto.goproto_stringer) = false; From b7430b5f71a37c9b078fae9e9349ab728747853e Mon Sep 17 00:00:00 2001 From: Nathan VanBenschoten Date: Tue, 23 Jun 2020 00:44:19 -0400 Subject: [PATCH 2/3] kv/kvclient: introduce new tenant Proxy Fixes #47909. This commit starts by adding two RPCs to the Internal service: ``` service Internal { ... rpc RangeFeed (RangeFeedRequest) returns (stream RangeFeedEvent) {} rpc GossipSubscription (GossipSubscriptionRequest) returns (stream GossipSubscriptionEvent) {} } // RangeLookupRequest is a request to proxy a RangeLookup through a Tenant // service. Its fields correspond to a subset of the args of kv.RangeLookup. message RangeLookupRequest { ... } // GossipSubscriptionRequest initiates a game of telephone. It establishes an // indefinite stream that proxies gossip information overheard by the recipient // node back to the caller. Gossip information is filtered down to just those // identified by a key matching any of the specified patterns. // // Upon establishment of the stream, all existing information that matches one // or more of the patterns is returned. After this point, only new information // matching the patterns is returned. message GossipSubscriptionRequest { ... } ``` The commit then introduces new `kvtenant.Proxy` object. Proxy mediates the communication of cluster-wide state to sandboxed SQL-only tenant processes through a restricted interface. A Proxy is seeded with a set of one or more network addresses that reference existing KV nodes in the cluster (or a load-balancer which fans out to some/all KV nodes). On startup, it establishes contact with one of these nodes to learn about the topology of the cluster and bootstrap the rest of SQL <-> KV network communication. Proxy has two main roles: First, Proxy is capable of providing information on each of the KV nodes in the cluster in the form of NodeDescriptors. This obviates the need for SQL-only tenant processes to join the cluster-wide gossip network. In doing so, it satisfies the `NodeDescStore` interface and can be used as an `AddressResolver` with a small adapter. Second, Proxy is capable of providing Range addressing information in the form of RangeDescriptors through delegated RangeLookup requests. This is necessary because SQL-only tenants are restricted from reading Range Metadata keys directly. Instead, the RangeLookup requests are proxied through existing KV nodes while being subject to additional validation (e.g. is the Range being requested owned by the requesting tenant?). In doing so, it satisfies the `RangeDescriptorDB` interface and can be used to delegate all DistSender/RangeCache descriptor lookups to KV nodes. With this commit, we can mostly run a SQL-only tenant process without joining the KV cluster's gossip network. This works if I comment out a few of the uses of gossip due to #49692 and #47150 in SQL. Notably, with the call to `DeprecatedRegisterSystemConfigChannel` in `sql.Server.Start` removed, I can remove `Gossip` from `makeSQLServerArgs` entirely and things "just work". --- c-deps/libroach/protos/roachpb/api.pb.cc | 1174 ++++++++ c-deps/libroach/protos/roachpb/api.pb.h | 1042 +++++++- pkg/ccl/backupccl/backup_test.go | 1 + pkg/ccl/ccl_init.go | 1 + pkg/ccl/kvccl/kvccl.go | 11 + pkg/ccl/kvccl/kvtenantccl/proxy.go | 332 +++ pkg/ccl/kvccl/kvtenantccl/proxy_test.go | 314 +++ pkg/ccl/logictestccl/logic_test.go | 14 +- .../testdata/logic_test/tenant_unsupported | 0 .../serverccl}/server_sql_test.go | 14 +- pkg/gossip/gossip.go | 7 +- pkg/gossip/infostore.go | 1 + pkg/kv/kvclient/kvcoord/range_cache.go | 1 + pkg/kv/kvclient/kvcoord/send_test.go | 12 + pkg/kv/kvclient/kvcoord/transport_test.go | 14 + pkg/kv/kvclient/kvtenant/proxy.go | 64 + pkg/roachpb/api.pb.go | 2356 ++++++++++++----- pkg/roachpb/api.proto | 47 +- pkg/rpc/context.go | 129 +- pkg/rpc/context_test.go | 14 +- pkg/server/node.go | 113 +- pkg/server/server_sql.go | 19 + pkg/server/testserver.go | 56 +- pkg/sql/logictest/logic.go | 90 +- 24 files changed, 5074 insertions(+), 752 deletions(-) create mode 100644 pkg/ccl/kvccl/kvccl.go create mode 100644 pkg/ccl/kvccl/kvtenantccl/proxy.go create mode 100644 pkg/ccl/kvccl/kvtenantccl/proxy_test.go rename pkg/{sql/logictest => ccl/logictestccl}/testdata/logic_test/tenant_unsupported (100%) rename pkg/{server => ccl/serverccl}/server_sql_test.go (87%) create mode 100644 pkg/kv/kvclient/kvtenant/proxy.go diff --git a/c-deps/libroach/protos/roachpb/api.pb.cc b/c-deps/libroach/protos/roachpb/api.pb.cc index f732086f5193..9fb86284838c 100644 --- a/c-deps/libroach/protos/roachpb/api.pb.cc +++ b/c-deps/libroach/protos/roachpb/api.pb.cc @@ -824,6 +824,16 @@ class BatchResponseDefaultTypeInternal { ::google::protobuf::internal::ExplicitlyConstructed _instance; } _BatchResponse_default_instance_; +class RangeLookupRequestDefaultTypeInternal { + public: + ::google::protobuf::internal::ExplicitlyConstructed + _instance; +} _RangeLookupRequest_default_instance_; +class RangeLookupResponseDefaultTypeInternal { + public: + ::google::protobuf::internal::ExplicitlyConstructed + _instance; +} _RangeLookupResponse_default_instance_; class RangeFeedRequestDefaultTypeInternal { public: ::google::protobuf::internal::ExplicitlyConstructed @@ -849,6 +859,16 @@ class RangeFeedEventDefaultTypeInternal { ::google::protobuf::internal::ExplicitlyConstructed _instance; } _RangeFeedEvent_default_instance_; +class GossipSubscriptionRequestDefaultTypeInternal { + public: + ::google::protobuf::internal::ExplicitlyConstructed + _instance; +} _GossipSubscriptionRequest_default_instance_; +class GossipSubscriptionEventDefaultTypeInternal { + public: + ::google::protobuf::internal::ExplicitlyConstructed + _instance; +} _GossipSubscriptionEvent_default_instance_; } // namespace roachpb } // namespace cockroach namespace protobuf_roachpb_2fapi_2eproto { @@ -2718,6 +2738,36 @@ ::google::protobuf::internal::SCCInfo<2> scc_info_BatchResponse = &protobuf_roachpb_2fapi_2eproto::scc_info_BatchResponse_Header.base, &protobuf_roachpb_2fapi_2eproto::scc_info_ResponseUnion.base,}}; +static void InitDefaultsRangeLookupRequest() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::cockroach::roachpb::_RangeLookupRequest_default_instance_; + new (ptr) ::cockroach::roachpb::RangeLookupRequest(); + ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); + } + ::cockroach::roachpb::RangeLookupRequest::InitAsDefaultInstance(); +} + +::google::protobuf::internal::SCCInfo<0> scc_info_RangeLookupRequest = + {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsRangeLookupRequest}, {}}; + +static void InitDefaultsRangeLookupResponse() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::cockroach::roachpb::_RangeLookupResponse_default_instance_; + new (ptr) ::cockroach::roachpb::RangeLookupResponse(); + ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); + } + ::cockroach::roachpb::RangeLookupResponse::InitAsDefaultInstance(); +} + +::google::protobuf::internal::SCCInfo<2> scc_info_RangeLookupResponse = + {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsRangeLookupResponse}, { + &protobuf_roachpb_2fmetadata_2eproto::scc_info_RangeDescriptor.base, + &protobuf_roachpb_2ferrors_2eproto::scc_info_AmbiguousResultError.base,}}; + static void InitDefaultsRangeFeedRequest() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -2797,6 +2847,36 @@ ::google::protobuf::internal::SCCInfo<3> scc_info_RangeFeedEvent = &protobuf_roachpb_2fapi_2eproto::scc_info_RangeFeedCheckpoint.base, &protobuf_roachpb_2fapi_2eproto::scc_info_RangeFeedError.base,}}; +static void InitDefaultsGossipSubscriptionRequest() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::cockroach::roachpb::_GossipSubscriptionRequest_default_instance_; + new (ptr) ::cockroach::roachpb::GossipSubscriptionRequest(); + ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); + } + ::cockroach::roachpb::GossipSubscriptionRequest::InitAsDefaultInstance(); +} + +::google::protobuf::internal::SCCInfo<0> scc_info_GossipSubscriptionRequest = + {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsGossipSubscriptionRequest}, {}}; + +static void InitDefaultsGossipSubscriptionEvent() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::cockroach::roachpb::_GossipSubscriptionEvent_default_instance_; + new (ptr) ::cockroach::roachpb::GossipSubscriptionEvent(); + ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); + } + ::cockroach::roachpb::GossipSubscriptionEvent::InitAsDefaultInstance(); +} + +::google::protobuf::internal::SCCInfo<2> scc_info_GossipSubscriptionEvent = + {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsGossipSubscriptionEvent}, { + &protobuf_roachpb_2fdata_2eproto::scc_info_Value.base, + &protobuf_roachpb_2ferrors_2eproto::scc_info_AmbiguousResultError.base,}}; + void InitDefaults() { ::google::protobuf::internal::InitSCC(&scc_info_RequestHeader.base); ::google::protobuf::internal::InitSCC(&scc_info_ResponseHeader.base); @@ -2912,11 +2992,15 @@ void InitDefaults() { ::google::protobuf::internal::InitSCC(&scc_info_BatchRequest.base); ::google::protobuf::internal::InitSCC(&scc_info_BatchResponse_Header.base); ::google::protobuf::internal::InitSCC(&scc_info_BatchResponse.base); + ::google::protobuf::internal::InitSCC(&scc_info_RangeLookupRequest.base); + ::google::protobuf::internal::InitSCC(&scc_info_RangeLookupResponse.base); ::google::protobuf::internal::InitSCC(&scc_info_RangeFeedRequest.base); ::google::protobuf::internal::InitSCC(&scc_info_RangeFeedValue.base); ::google::protobuf::internal::InitSCC(&scc_info_RangeFeedCheckpoint.base); ::google::protobuf::internal::InitSCC(&scc_info_RangeFeedError.base); ::google::protobuf::internal::InitSCC(&scc_info_RangeFeedEvent.base); + ::google::protobuf::internal::InitSCC(&scc_info_GossipSubscriptionRequest.base); + ::google::protobuf::internal::InitSCC(&scc_info_GossipSubscriptionEvent.base); } } // namespace protobuf_roachpb_2fapi_2eproto @@ -36906,6 +36990,560 @@ ::std::string BatchResponse::GetTypeName() const { } +// =================================================================== + +void RangeLookupRequest::InitAsDefaultInstance() { +} +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int RangeLookupRequest::kKeyFieldNumber; +const int RangeLookupRequest::kReadConsistencyFieldNumber; +const int RangeLookupRequest::kPrefetchNumFieldNumber; +const int RangeLookupRequest::kPrefetchReverseFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +RangeLookupRequest::RangeLookupRequest() + : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) { + ::google::protobuf::internal::InitSCC( + &protobuf_roachpb_2fapi_2eproto::scc_info_RangeLookupRequest.base); + SharedCtor(); + // @@protoc_insertion_point(constructor:cockroach.roachpb.RangeLookupRequest) +} +RangeLookupRequest::RangeLookupRequest(const RangeLookupRequest& from) + : ::google::protobuf::MessageLite(), + _internal_metadata_(NULL) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + key_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (from.key().size() > 0) { + key_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.key_); + } + ::memcpy(&prefetch_num_, &from.prefetch_num_, + static_cast(reinterpret_cast(&prefetch_reverse_) - + reinterpret_cast(&prefetch_num_)) + sizeof(prefetch_reverse_)); + // @@protoc_insertion_point(copy_constructor:cockroach.roachpb.RangeLookupRequest) +} + +void RangeLookupRequest::SharedCtor() { + key_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(&prefetch_num_, 0, static_cast( + reinterpret_cast(&prefetch_reverse_) - + reinterpret_cast(&prefetch_num_)) + sizeof(prefetch_reverse_)); +} + +RangeLookupRequest::~RangeLookupRequest() { + // @@protoc_insertion_point(destructor:cockroach.roachpb.RangeLookupRequest) + SharedDtor(); +} + +void RangeLookupRequest::SharedDtor() { + key_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} + +void RangeLookupRequest::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const RangeLookupRequest& RangeLookupRequest::default_instance() { + ::google::protobuf::internal::InitSCC(&protobuf_roachpb_2fapi_2eproto::scc_info_RangeLookupRequest.base); + return *internal_default_instance(); +} + + +void RangeLookupRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:cockroach.roachpb.RangeLookupRequest) + ::google::protobuf::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + key_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(&prefetch_num_, 0, static_cast( + reinterpret_cast(&prefetch_reverse_) - + reinterpret_cast(&prefetch_num_)) + sizeof(prefetch_reverse_)); + _internal_metadata_.Clear(); +} + +bool RangeLookupRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + ::google::protobuf::internal::LiteUnknownFieldSetter unknown_fields_setter( + &_internal_metadata_); + ::google::protobuf::io::StringOutputStream unknown_fields_output( + unknown_fields_setter.buffer()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_output, false); + // @@protoc_insertion_point(parse_start:cockroach.roachpb.RangeLookupRequest) + for (;;) { + ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + case 1: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_key())); + } else { + goto handle_unusual; + } + break; + } + + // .cockroach.roachpb.ReadConsistencyType read_consistency = 2; + case 2: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + set_read_consistency(static_cast< ::cockroach::roachpb::ReadConsistencyType >(value)); + } else { + goto handle_unusual; + } + break; + } + + // int64 prefetch_num = 3; + case 3: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) { + + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &prefetch_num_))); + } else { + goto handle_unusual; + } + break; + } + + // bool prefetch_reverse = 4; + case 4: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) { + + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &prefetch_reverse_))); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:cockroach.roachpb.RangeLookupRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:cockroach.roachpb.RangeLookupRequest) + return false; +#undef DO_ +} + +void RangeLookupRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:cockroach.roachpb.RangeLookupRequest) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (this->key().size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 1, this->key(), output); + } + + // .cockroach.roachpb.ReadConsistencyType read_consistency = 2; + if (this->read_consistency() != 0) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 2, this->read_consistency(), output); + } + + // int64 prefetch_num = 3; + if (this->prefetch_num() != 0) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(3, this->prefetch_num(), output); + } + + // bool prefetch_reverse = 4; + if (this->prefetch_reverse() != 0) { + ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->prefetch_reverse(), output); + } + + output->WriteRaw((::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()).data(), + static_cast((::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()).size())); + // @@protoc_insertion_point(serialize_end:cockroach.roachpb.RangeLookupRequest) +} + +size_t RangeLookupRequest::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:cockroach.roachpb.RangeLookupRequest) + size_t total_size = 0; + + total_size += (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()).size(); + + if (this->key().size() > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->key()); + } + + // int64 prefetch_num = 3; + if (this->prefetch_num() != 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->prefetch_num()); + } + + // .cockroach.roachpb.ReadConsistencyType read_consistency = 2; + if (this->read_consistency() != 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->read_consistency()); + } + + // bool prefetch_reverse = 4; + if (this->prefetch_reverse() != 0) { + total_size += 1 + 1; + } + + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void RangeLookupRequest::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void RangeLookupRequest::MergeFrom(const RangeLookupRequest& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:cockroach.roachpb.RangeLookupRequest) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.key().size() > 0) { + + key_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.key_); + } + if (from.prefetch_num() != 0) { + set_prefetch_num(from.prefetch_num()); + } + if (from.read_consistency() != 0) { + set_read_consistency(from.read_consistency()); + } + if (from.prefetch_reverse() != 0) { + set_prefetch_reverse(from.prefetch_reverse()); + } +} + +void RangeLookupRequest::CopyFrom(const RangeLookupRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:cockroach.roachpb.RangeLookupRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RangeLookupRequest::IsInitialized() const { + return true; +} + +void RangeLookupRequest::Swap(RangeLookupRequest* other) { + if (other == this) return; + InternalSwap(other); +} +void RangeLookupRequest::InternalSwap(RangeLookupRequest* other) { + using std::swap; + key_.Swap(&other->key_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(prefetch_num_, other->prefetch_num_); + swap(read_consistency_, other->read_consistency_); + swap(prefetch_reverse_, other->prefetch_reverse_); + _internal_metadata_.Swap(&other->_internal_metadata_); +} + +::std::string RangeLookupRequest::GetTypeName() const { + return "cockroach.roachpb.RangeLookupRequest"; +} + + +// =================================================================== + +void RangeLookupResponse::InitAsDefaultInstance() { + ::cockroach::roachpb::_RangeLookupResponse_default_instance_._instance.get_mutable()->error_ = const_cast< ::cockroach::roachpb::Error*>( + ::cockroach::roachpb::Error::internal_default_instance()); +} +void RangeLookupResponse::clear_descriptors() { + descriptors_.Clear(); +} +void RangeLookupResponse::clear_prefetched_descriptors() { + prefetched_descriptors_.Clear(); +} +void RangeLookupResponse::clear_error() { + if (GetArenaNoVirtual() == NULL && error_ != NULL) { + delete error_; + } + error_ = NULL; +} +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int RangeLookupResponse::kDescriptorsFieldNumber; +const int RangeLookupResponse::kPrefetchedDescriptorsFieldNumber; +const int RangeLookupResponse::kErrorFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +RangeLookupResponse::RangeLookupResponse() + : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) { + ::google::protobuf::internal::InitSCC( + &protobuf_roachpb_2fapi_2eproto::scc_info_RangeLookupResponse.base); + SharedCtor(); + // @@protoc_insertion_point(constructor:cockroach.roachpb.RangeLookupResponse) +} +RangeLookupResponse::RangeLookupResponse(const RangeLookupResponse& from) + : ::google::protobuf::MessageLite(), + _internal_metadata_(NULL), + descriptors_(from.descriptors_), + prefetched_descriptors_(from.prefetched_descriptors_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from.has_error()) { + error_ = new ::cockroach::roachpb::Error(*from.error_); + } else { + error_ = NULL; + } + // @@protoc_insertion_point(copy_constructor:cockroach.roachpb.RangeLookupResponse) +} + +void RangeLookupResponse::SharedCtor() { + error_ = NULL; +} + +RangeLookupResponse::~RangeLookupResponse() { + // @@protoc_insertion_point(destructor:cockroach.roachpb.RangeLookupResponse) + SharedDtor(); +} + +void RangeLookupResponse::SharedDtor() { + if (this != internal_default_instance()) delete error_; +} + +void RangeLookupResponse::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const RangeLookupResponse& RangeLookupResponse::default_instance() { + ::google::protobuf::internal::InitSCC(&protobuf_roachpb_2fapi_2eproto::scc_info_RangeLookupResponse.base); + return *internal_default_instance(); +} + + +void RangeLookupResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:cockroach.roachpb.RangeLookupResponse) + ::google::protobuf::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + descriptors_.Clear(); + prefetched_descriptors_.Clear(); + if (GetArenaNoVirtual() == NULL && error_ != NULL) { + delete error_; + } + error_ = NULL; + _internal_metadata_.Clear(); +} + +bool RangeLookupResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + ::google::protobuf::internal::LiteUnknownFieldSetter unknown_fields_setter( + &_internal_metadata_); + ::google::protobuf::io::StringOutputStream unknown_fields_output( + unknown_fields_setter.buffer()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_output, false); + // @@protoc_insertion_point(parse_start:cockroach.roachpb.RangeLookupResponse) + for (;;) { + ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + case 1: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( + input, add_descriptors())); + } else { + goto handle_unusual; + } + break; + } + + case 2: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( + input, add_prefetched_descriptors())); + } else { + goto handle_unusual; + } + break; + } + + // .cockroach.roachpb.Error error = 3; + case 3: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( + input, mutable_error())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:cockroach.roachpb.RangeLookupResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:cockroach.roachpb.RangeLookupResponse) + return false; +#undef DO_ +} + +void RangeLookupResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:cockroach.roachpb.RangeLookupResponse) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + for (unsigned int i = 0, + n = static_cast(this->descriptors_size()); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 1, + this->descriptors(static_cast(i)), + output); + } + + for (unsigned int i = 0, + n = static_cast(this->prefetched_descriptors_size()); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 2, + this->prefetched_descriptors(static_cast(i)), + output); + } + + // .cockroach.roachpb.Error error = 3; + if (this->has_error()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 3, this->_internal_error(), output); + } + + output->WriteRaw((::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()).data(), + static_cast((::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()).size())); + // @@protoc_insertion_point(serialize_end:cockroach.roachpb.RangeLookupResponse) +} + +size_t RangeLookupResponse::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:cockroach.roachpb.RangeLookupResponse) + size_t total_size = 0; + + total_size += (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()).size(); + + { + unsigned int count = static_cast(this->descriptors_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSize( + this->descriptors(static_cast(i))); + } + } + + { + unsigned int count = static_cast(this->prefetched_descriptors_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSize( + this->prefetched_descriptors(static_cast(i))); + } + } + + // .cockroach.roachpb.Error error = 3; + if (this->has_error()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize( + *error_); + } + + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void RangeLookupResponse::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void RangeLookupResponse::MergeFrom(const RangeLookupResponse& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:cockroach.roachpb.RangeLookupResponse) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + descriptors_.MergeFrom(from.descriptors_); + prefetched_descriptors_.MergeFrom(from.prefetched_descriptors_); + if (from.has_error()) { + mutable_error()->::cockroach::roachpb::Error::MergeFrom(from.error()); + } +} + +void RangeLookupResponse::CopyFrom(const RangeLookupResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:cockroach.roachpb.RangeLookupResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RangeLookupResponse::IsInitialized() const { + return true; +} + +void RangeLookupResponse::Swap(RangeLookupResponse* other) { + if (other == this) return; + InternalSwap(other); +} +void RangeLookupResponse::InternalSwap(RangeLookupResponse* other) { + using std::swap; + CastToBase(&descriptors_)->InternalSwap(CastToBase(&other->descriptors_)); + CastToBase(&prefetched_descriptors_)->InternalSwap(CastToBase(&other->prefetched_descriptors_)); + swap(error_, other->error_); + _internal_metadata_.Swap(&other->_internal_metadata_); +} + +::std::string RangeLookupResponse::GetTypeName() const { + return "cockroach.roachpb.RangeLookupResponse"; +} + + // =================================================================== void RangeFeedRequest::InitAsDefaultInstance() { @@ -38156,6 +38794,530 @@ ::std::string RangeFeedEvent::GetTypeName() const { } +// =================================================================== + +void GossipSubscriptionRequest::InitAsDefaultInstance() { +} +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int GossipSubscriptionRequest::kPatternsFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +GossipSubscriptionRequest::GossipSubscriptionRequest() + : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) { + ::google::protobuf::internal::InitSCC( + &protobuf_roachpb_2fapi_2eproto::scc_info_GossipSubscriptionRequest.base); + SharedCtor(); + // @@protoc_insertion_point(constructor:cockroach.roachpb.GossipSubscriptionRequest) +} +GossipSubscriptionRequest::GossipSubscriptionRequest(const GossipSubscriptionRequest& from) + : ::google::protobuf::MessageLite(), + _internal_metadata_(NULL), + patterns_(from.patterns_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:cockroach.roachpb.GossipSubscriptionRequest) +} + +void GossipSubscriptionRequest::SharedCtor() { +} + +GossipSubscriptionRequest::~GossipSubscriptionRequest() { + // @@protoc_insertion_point(destructor:cockroach.roachpb.GossipSubscriptionRequest) + SharedDtor(); +} + +void GossipSubscriptionRequest::SharedDtor() { +} + +void GossipSubscriptionRequest::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const GossipSubscriptionRequest& GossipSubscriptionRequest::default_instance() { + ::google::protobuf::internal::InitSCC(&protobuf_roachpb_2fapi_2eproto::scc_info_GossipSubscriptionRequest.base); + return *internal_default_instance(); +} + + +void GossipSubscriptionRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:cockroach.roachpb.GossipSubscriptionRequest) + ::google::protobuf::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + patterns_.Clear(); + _internal_metadata_.Clear(); +} + +bool GossipSubscriptionRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + ::google::protobuf::internal::LiteUnknownFieldSetter unknown_fields_setter( + &_internal_metadata_); + ::google::protobuf::io::StringOutputStream unknown_fields_output( + unknown_fields_setter.buffer()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_output, false); + // @@protoc_insertion_point(parse_start:cockroach.roachpb.GossipSubscriptionRequest) + for (;;) { + ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated string patterns = 1; + case 1: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_patterns())); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->patterns(this->patterns_size() - 1).data(), + static_cast(this->patterns(this->patterns_size() - 1).length()), + ::google::protobuf::internal::WireFormatLite::PARSE, + "cockroach.roachpb.GossipSubscriptionRequest.patterns")); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:cockroach.roachpb.GossipSubscriptionRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:cockroach.roachpb.GossipSubscriptionRequest) + return false; +#undef DO_ +} + +void GossipSubscriptionRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:cockroach.roachpb.GossipSubscriptionRequest) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated string patterns = 1; + for (int i = 0, n = this->patterns_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->patterns(i).data(), static_cast(this->patterns(i).length()), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "cockroach.roachpb.GossipSubscriptionRequest.patterns"); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->patterns(i), output); + } + + output->WriteRaw((::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()).data(), + static_cast((::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()).size())); + // @@protoc_insertion_point(serialize_end:cockroach.roachpb.GossipSubscriptionRequest) +} + +size_t GossipSubscriptionRequest::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:cockroach.roachpb.GossipSubscriptionRequest) + size_t total_size = 0; + + total_size += (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()).size(); + + // repeated string patterns = 1; + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->patterns_size()); + for (int i = 0, n = this->patterns_size(); i < n; i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->patterns(i)); + } + + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void GossipSubscriptionRequest::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void GossipSubscriptionRequest::MergeFrom(const GossipSubscriptionRequest& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:cockroach.roachpb.GossipSubscriptionRequest) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + patterns_.MergeFrom(from.patterns_); +} + +void GossipSubscriptionRequest::CopyFrom(const GossipSubscriptionRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:cockroach.roachpb.GossipSubscriptionRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GossipSubscriptionRequest::IsInitialized() const { + return true; +} + +void GossipSubscriptionRequest::Swap(GossipSubscriptionRequest* other) { + if (other == this) return; + InternalSwap(other); +} +void GossipSubscriptionRequest::InternalSwap(GossipSubscriptionRequest* other) { + using std::swap; + patterns_.InternalSwap(CastToBase(&other->patterns_)); + _internal_metadata_.Swap(&other->_internal_metadata_); +} + +::std::string GossipSubscriptionRequest::GetTypeName() const { + return "cockroach.roachpb.GossipSubscriptionRequest"; +} + + +// =================================================================== + +void GossipSubscriptionEvent::InitAsDefaultInstance() { + ::cockroach::roachpb::_GossipSubscriptionEvent_default_instance_._instance.get_mutable()->content_ = const_cast< ::cockroach::roachpb::Value*>( + ::cockroach::roachpb::Value::internal_default_instance()); + ::cockroach::roachpb::_GossipSubscriptionEvent_default_instance_._instance.get_mutable()->error_ = const_cast< ::cockroach::roachpb::Error*>( + ::cockroach::roachpb::Error::internal_default_instance()); +} +void GossipSubscriptionEvent::clear_content() { + if (GetArenaNoVirtual() == NULL && content_ != NULL) { + delete content_; + } + content_ = NULL; +} +void GossipSubscriptionEvent::clear_error() { + if (GetArenaNoVirtual() == NULL && error_ != NULL) { + delete error_; + } + error_ = NULL; +} +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int GossipSubscriptionEvent::kKeyFieldNumber; +const int GossipSubscriptionEvent::kContentFieldNumber; +const int GossipSubscriptionEvent::kPatternMatchedFieldNumber; +const int GossipSubscriptionEvent::kErrorFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +GossipSubscriptionEvent::GossipSubscriptionEvent() + : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) { + ::google::protobuf::internal::InitSCC( + &protobuf_roachpb_2fapi_2eproto::scc_info_GossipSubscriptionEvent.base); + SharedCtor(); + // @@protoc_insertion_point(constructor:cockroach.roachpb.GossipSubscriptionEvent) +} +GossipSubscriptionEvent::GossipSubscriptionEvent(const GossipSubscriptionEvent& from) + : ::google::protobuf::MessageLite(), + _internal_metadata_(NULL) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + key_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (from.key().size() > 0) { + key_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.key_); + } + pattern_matched_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (from.pattern_matched().size() > 0) { + pattern_matched_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.pattern_matched_); + } + if (from.has_content()) { + content_ = new ::cockroach::roachpb::Value(*from.content_); + } else { + content_ = NULL; + } + if (from.has_error()) { + error_ = new ::cockroach::roachpb::Error(*from.error_); + } else { + error_ = NULL; + } + // @@protoc_insertion_point(copy_constructor:cockroach.roachpb.GossipSubscriptionEvent) +} + +void GossipSubscriptionEvent::SharedCtor() { + key_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + pattern_matched_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(&content_, 0, static_cast( + reinterpret_cast(&error_) - + reinterpret_cast(&content_)) + sizeof(error_)); +} + +GossipSubscriptionEvent::~GossipSubscriptionEvent() { + // @@protoc_insertion_point(destructor:cockroach.roachpb.GossipSubscriptionEvent) + SharedDtor(); +} + +void GossipSubscriptionEvent::SharedDtor() { + key_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + pattern_matched_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete content_; + if (this != internal_default_instance()) delete error_; +} + +void GossipSubscriptionEvent::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const GossipSubscriptionEvent& GossipSubscriptionEvent::default_instance() { + ::google::protobuf::internal::InitSCC(&protobuf_roachpb_2fapi_2eproto::scc_info_GossipSubscriptionEvent.base); + return *internal_default_instance(); +} + + +void GossipSubscriptionEvent::Clear() { +// @@protoc_insertion_point(message_clear_start:cockroach.roachpb.GossipSubscriptionEvent) + ::google::protobuf::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + key_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + pattern_matched_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (GetArenaNoVirtual() == NULL && content_ != NULL) { + delete content_; + } + content_ = NULL; + if (GetArenaNoVirtual() == NULL && error_ != NULL) { + delete error_; + } + error_ = NULL; + _internal_metadata_.Clear(); +} + +bool GossipSubscriptionEvent::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + ::google::protobuf::internal::LiteUnknownFieldSetter unknown_fields_setter( + &_internal_metadata_); + ::google::protobuf::io::StringOutputStream unknown_fields_output( + unknown_fields_setter.buffer()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_output, false); + // @@protoc_insertion_point(parse_start:cockroach.roachpb.GossipSubscriptionEvent) + for (;;) { + ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string key = 1; + case 1: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_key())); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->key().data(), static_cast(this->key().length()), + ::google::protobuf::internal::WireFormatLite::PARSE, + "cockroach.roachpb.GossipSubscriptionEvent.key")); + } else { + goto handle_unusual; + } + break; + } + + case 2: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( + input, mutable_content())); + } else { + goto handle_unusual; + } + break; + } + + // string pattern_matched = 3; + case 3: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_pattern_matched())); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->pattern_matched().data(), static_cast(this->pattern_matched().length()), + ::google::protobuf::internal::WireFormatLite::PARSE, + "cockroach.roachpb.GossipSubscriptionEvent.pattern_matched")); + } else { + goto handle_unusual; + } + break; + } + + // .cockroach.roachpb.Error error = 4; + case 4: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( + input, mutable_error())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:cockroach.roachpb.GossipSubscriptionEvent) + return true; +failure: + // @@protoc_insertion_point(parse_failure:cockroach.roachpb.GossipSubscriptionEvent) + return false; +#undef DO_ +} + +void GossipSubscriptionEvent::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:cockroach.roachpb.GossipSubscriptionEvent) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string key = 1; + if (this->key().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->key().data(), static_cast(this->key().length()), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "cockroach.roachpb.GossipSubscriptionEvent.key"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->key(), output); + } + + if (this->has_content()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 2, this->_internal_content(), output); + } + + // string pattern_matched = 3; + if (this->pattern_matched().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->pattern_matched().data(), static_cast(this->pattern_matched().length()), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "cockroach.roachpb.GossipSubscriptionEvent.pattern_matched"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 3, this->pattern_matched(), output); + } + + // .cockroach.roachpb.Error error = 4; + if (this->has_error()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 4, this->_internal_error(), output); + } + + output->WriteRaw((::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()).data(), + static_cast((::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()).size())); + // @@protoc_insertion_point(serialize_end:cockroach.roachpb.GossipSubscriptionEvent) +} + +size_t GossipSubscriptionEvent::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:cockroach.roachpb.GossipSubscriptionEvent) + size_t total_size = 0; + + total_size += (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()).size(); + + // string key = 1; + if (this->key().size() > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->key()); + } + + // string pattern_matched = 3; + if (this->pattern_matched().size() > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->pattern_matched()); + } + + if (this->has_content()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize( + *content_); + } + + // .cockroach.roachpb.Error error = 4; + if (this->has_error()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize( + *error_); + } + + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void GossipSubscriptionEvent::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void GossipSubscriptionEvent::MergeFrom(const GossipSubscriptionEvent& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:cockroach.roachpb.GossipSubscriptionEvent) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.key().size() > 0) { + + key_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.key_); + } + if (from.pattern_matched().size() > 0) { + + pattern_matched_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.pattern_matched_); + } + if (from.has_content()) { + mutable_content()->::cockroach::roachpb::Value::MergeFrom(from.content()); + } + if (from.has_error()) { + mutable_error()->::cockroach::roachpb::Error::MergeFrom(from.error()); + } +} + +void GossipSubscriptionEvent::CopyFrom(const GossipSubscriptionEvent& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:cockroach.roachpb.GossipSubscriptionEvent) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GossipSubscriptionEvent::IsInitialized() const { + return true; +} + +void GossipSubscriptionEvent::Swap(GossipSubscriptionEvent* other) { + if (other == this) return; + InternalSwap(other); +} +void GossipSubscriptionEvent::InternalSwap(GossipSubscriptionEvent* other) { + using std::swap; + key_.Swap(&other->key_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + pattern_matched_.Swap(&other->pattern_matched_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(content_, other->content_); + swap(error_, other->error_); + _internal_metadata_.Swap(&other->_internal_metadata_); +} + +::std::string GossipSubscriptionEvent::GetTypeName() const { + return "cockroach.roachpb.GossipSubscriptionEvent"; +} + + // @@protoc_insertion_point(namespace_scope) } // namespace roachpb } // namespace cockroach @@ -38503,6 +39665,12 @@ template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::cockroach::roachpb::BatchRespons template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::cockroach::roachpb::BatchResponse* Arena::CreateMaybeMessage< ::cockroach::roachpb::BatchResponse >(Arena* arena) { return Arena::CreateInternal< ::cockroach::roachpb::BatchResponse >(arena); } +template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::cockroach::roachpb::RangeLookupRequest* Arena::CreateMaybeMessage< ::cockroach::roachpb::RangeLookupRequest >(Arena* arena) { + return Arena::CreateInternal< ::cockroach::roachpb::RangeLookupRequest >(arena); +} +template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::cockroach::roachpb::RangeLookupResponse* Arena::CreateMaybeMessage< ::cockroach::roachpb::RangeLookupResponse >(Arena* arena) { + return Arena::CreateInternal< ::cockroach::roachpb::RangeLookupResponse >(arena); +} template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::cockroach::roachpb::RangeFeedRequest* Arena::CreateMaybeMessage< ::cockroach::roachpb::RangeFeedRequest >(Arena* arena) { return Arena::CreateInternal< ::cockroach::roachpb::RangeFeedRequest >(arena); } @@ -38518,6 +39686,12 @@ template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::cockroach::roachpb::RangeFeedErr template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::cockroach::roachpb::RangeFeedEvent* Arena::CreateMaybeMessage< ::cockroach::roachpb::RangeFeedEvent >(Arena* arena) { return Arena::CreateInternal< ::cockroach::roachpb::RangeFeedEvent >(arena); } +template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::cockroach::roachpb::GossipSubscriptionRequest* Arena::CreateMaybeMessage< ::cockroach::roachpb::GossipSubscriptionRequest >(Arena* arena) { + return Arena::CreateInternal< ::cockroach::roachpb::GossipSubscriptionRequest >(arena); +} +template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::cockroach::roachpb::GossipSubscriptionEvent* Arena::CreateMaybeMessage< ::cockroach::roachpb::GossipSubscriptionEvent >(Arena* arena) { + return Arena::CreateInternal< ::cockroach::roachpb::GossipSubscriptionEvent >(arena); +} } // namespace protobuf } // namespace google diff --git a/c-deps/libroach/protos/roachpb/api.pb.h b/c-deps/libroach/protos/roachpb/api.pb.h index 36ca022c48af..a7e1a1317cf6 100644 --- a/c-deps/libroach/protos/roachpb/api.pb.h +++ b/c-deps/libroach/protos/roachpb/api.pb.h @@ -49,7 +49,7 @@ namespace protobuf_roachpb_2fapi_2eproto { struct TableStruct { static const ::google::protobuf::internal::ParseTableField entries[]; static const ::google::protobuf::internal::AuxillaryParseTableField aux[]; - static const ::google::protobuf::internal::ParseTable schema[119]; + static const ::google::protobuf::internal::ParseTable schema[123]; static const ::google::protobuf::internal::FieldMetadata field_metadata[]; static const ::google::protobuf::internal::SerializationTable serialization_table[]; static const ::google::protobuf::uint32 offsets[]; @@ -228,6 +228,12 @@ extern GetRequestDefaultTypeInternal _GetRequest_default_instance_; class GetResponse; class GetResponseDefaultTypeInternal; extern GetResponseDefaultTypeInternal _GetResponse_default_instance_; +class GossipSubscriptionEvent; +class GossipSubscriptionEventDefaultTypeInternal; +extern GossipSubscriptionEventDefaultTypeInternal _GossipSubscriptionEvent_default_instance_; +class GossipSubscriptionRequest; +class GossipSubscriptionRequestDefaultTypeInternal; +extern GossipSubscriptionRequestDefaultTypeInternal _GossipSubscriptionRequest_default_instance_; class Header; class HeaderDefaultTypeInternal; extern HeaderDefaultTypeInternal _Header_default_instance_; @@ -312,6 +318,12 @@ extern RangeFeedRequestDefaultTypeInternal _RangeFeedRequest_default_instance_; class RangeFeedValue; class RangeFeedValueDefaultTypeInternal; extern RangeFeedValueDefaultTypeInternal _RangeFeedValue_default_instance_; +class RangeLookupRequest; +class RangeLookupRequestDefaultTypeInternal; +extern RangeLookupRequestDefaultTypeInternal _RangeLookupRequest_default_instance_; +class RangeLookupResponse; +class RangeLookupResponseDefaultTypeInternal; +extern RangeLookupResponseDefaultTypeInternal _RangeLookupResponse_default_instance_; class RangeStatsRequest; class RangeStatsRequestDefaultTypeInternal; extern RangeStatsRequestDefaultTypeInternal _RangeStatsRequest_default_instance_; @@ -475,6 +487,8 @@ template<> ::cockroach::roachpb::GCRequest_GCKey* Arena::CreateMaybeMessage<::co template<> ::cockroach::roachpb::GCResponse* Arena::CreateMaybeMessage<::cockroach::roachpb::GCResponse>(Arena*); template<> ::cockroach::roachpb::GetRequest* Arena::CreateMaybeMessage<::cockroach::roachpb::GetRequest>(Arena*); template<> ::cockroach::roachpb::GetResponse* Arena::CreateMaybeMessage<::cockroach::roachpb::GetResponse>(Arena*); +template<> ::cockroach::roachpb::GossipSubscriptionEvent* Arena::CreateMaybeMessage<::cockroach::roachpb::GossipSubscriptionEvent>(Arena*); +template<> ::cockroach::roachpb::GossipSubscriptionRequest* Arena::CreateMaybeMessage<::cockroach::roachpb::GossipSubscriptionRequest>(Arena*); template<> ::cockroach::roachpb::Header* Arena::CreateMaybeMessage<::cockroach::roachpb::Header>(Arena*); template<> ::cockroach::roachpb::HeartbeatTxnRequest* Arena::CreateMaybeMessage<::cockroach::roachpb::HeartbeatTxnRequest>(Arena*); template<> ::cockroach::roachpb::HeartbeatTxnResponse* Arena::CreateMaybeMessage<::cockroach::roachpb::HeartbeatTxnResponse>(Arena*); @@ -503,6 +517,8 @@ template<> ::cockroach::roachpb::RangeFeedError* Arena::CreateMaybeMessage<::coc template<> ::cockroach::roachpb::RangeFeedEvent* Arena::CreateMaybeMessage<::cockroach::roachpb::RangeFeedEvent>(Arena*); template<> ::cockroach::roachpb::RangeFeedRequest* Arena::CreateMaybeMessage<::cockroach::roachpb::RangeFeedRequest>(Arena*); template<> ::cockroach::roachpb::RangeFeedValue* Arena::CreateMaybeMessage<::cockroach::roachpb::RangeFeedValue>(Arena*); +template<> ::cockroach::roachpb::RangeLookupRequest* Arena::CreateMaybeMessage<::cockroach::roachpb::RangeLookupRequest>(Arena*); +template<> ::cockroach::roachpb::RangeLookupResponse* Arena::CreateMaybeMessage<::cockroach::roachpb::RangeLookupResponse>(Arena*); template<> ::cockroach::roachpb::RangeStatsRequest* Arena::CreateMaybeMessage<::cockroach::roachpb::RangeStatsRequest>(Arena*); template<> ::cockroach::roachpb::RangeStatsResponse* Arena::CreateMaybeMessage<::cockroach::roachpb::RangeStatsResponse>(Arena*); template<> ::cockroach::roachpb::RecomputeStatsRequest* Arena::CreateMaybeMessage<::cockroach::roachpb::RecomputeStatsRequest>(Arena*); @@ -16269,6 +16285,266 @@ class BatchResponse : public ::google::protobuf::MessageLite /* @@protoc_inserti }; // ------------------------------------------------------------------- +class RangeLookupRequest : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.RangeLookupRequest) */ { + public: + RangeLookupRequest(); + virtual ~RangeLookupRequest(); + + RangeLookupRequest(const RangeLookupRequest& from); + + inline RangeLookupRequest& operator=(const RangeLookupRequest& from) { + CopyFrom(from); + return *this; + } + #if LANG_CXX11 + RangeLookupRequest(RangeLookupRequest&& from) noexcept + : RangeLookupRequest() { + *this = ::std::move(from); + } + + inline RangeLookupRequest& operator=(RangeLookupRequest&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + #endif + static const RangeLookupRequest& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const RangeLookupRequest* internal_default_instance() { + return reinterpret_cast( + &_RangeLookupRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = + 114; + + void Swap(RangeLookupRequest* other); + friend void swap(RangeLookupRequest& a, RangeLookupRequest& b) { + a.Swap(&b); + } + + // implements Message ---------------------------------------------- + + inline RangeLookupRequest* New() const final { + return CreateMaybeMessage(NULL); + } + + RangeLookupRequest* New(::google::protobuf::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from) + final; + void CopyFrom(const RangeLookupRequest& from); + void MergeFrom(const RangeLookupRequest& from); + void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) final; + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(RangeLookupRequest* other); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return NULL; + } + inline void* MaybeArenaPtr() const { + return NULL; + } + public: + + ::std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + void clear_key(); + static const int kKeyFieldNumber = 1; + const ::std::string& key() const; + void set_key(const ::std::string& value); + #if LANG_CXX11 + void set_key(::std::string&& value); + #endif + void set_key(const char* value); + void set_key(const void* value, size_t size); + ::std::string* mutable_key(); + ::std::string* release_key(); + void set_allocated_key(::std::string* key); + + // int64 prefetch_num = 3; + void clear_prefetch_num(); + static const int kPrefetchNumFieldNumber = 3; + ::google::protobuf::int64 prefetch_num() const; + void set_prefetch_num(::google::protobuf::int64 value); + + // .cockroach.roachpb.ReadConsistencyType read_consistency = 2; + void clear_read_consistency(); + static const int kReadConsistencyFieldNumber = 2; + ::cockroach::roachpb::ReadConsistencyType read_consistency() const; + void set_read_consistency(::cockroach::roachpb::ReadConsistencyType value); + + // bool prefetch_reverse = 4; + void clear_prefetch_reverse(); + static const int kPrefetchReverseFieldNumber = 4; + bool prefetch_reverse() const; + void set_prefetch_reverse(bool value); + + // @@protoc_insertion_point(class_scope:cockroach.roachpb.RangeLookupRequest) + private: + + ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::google::protobuf::internal::ArenaStringPtr key_; + ::google::protobuf::int64 prefetch_num_; + int read_consistency_; + bool prefetch_reverse_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + friend struct ::protobuf_roachpb_2fapi_2eproto::TableStruct; +}; +// ------------------------------------------------------------------- + +class RangeLookupResponse : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.RangeLookupResponse) */ { + public: + RangeLookupResponse(); + virtual ~RangeLookupResponse(); + + RangeLookupResponse(const RangeLookupResponse& from); + + inline RangeLookupResponse& operator=(const RangeLookupResponse& from) { + CopyFrom(from); + return *this; + } + #if LANG_CXX11 + RangeLookupResponse(RangeLookupResponse&& from) noexcept + : RangeLookupResponse() { + *this = ::std::move(from); + } + + inline RangeLookupResponse& operator=(RangeLookupResponse&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + #endif + static const RangeLookupResponse& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const RangeLookupResponse* internal_default_instance() { + return reinterpret_cast( + &_RangeLookupResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = + 115; + + void Swap(RangeLookupResponse* other); + friend void swap(RangeLookupResponse& a, RangeLookupResponse& b) { + a.Swap(&b); + } + + // implements Message ---------------------------------------------- + + inline RangeLookupResponse* New() const final { + return CreateMaybeMessage(NULL); + } + + RangeLookupResponse* New(::google::protobuf::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from) + final; + void CopyFrom(const RangeLookupResponse& from); + void MergeFrom(const RangeLookupResponse& from); + void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) final; + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(RangeLookupResponse* other); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return NULL; + } + inline void* MaybeArenaPtr() const { + return NULL; + } + public: + + ::std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + int descriptors_size() const; + void clear_descriptors(); + static const int kDescriptorsFieldNumber = 1; + ::cockroach::roachpb::RangeDescriptor* mutable_descriptors(int index); + ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::RangeDescriptor >* + mutable_descriptors(); + const ::cockroach::roachpb::RangeDescriptor& descriptors(int index) const; + ::cockroach::roachpb::RangeDescriptor* add_descriptors(); + const ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::RangeDescriptor >& + descriptors() const; + + int prefetched_descriptors_size() const; + void clear_prefetched_descriptors(); + static const int kPrefetchedDescriptorsFieldNumber = 2; + ::cockroach::roachpb::RangeDescriptor* mutable_prefetched_descriptors(int index); + ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::RangeDescriptor >* + mutable_prefetched_descriptors(); + const ::cockroach::roachpb::RangeDescriptor& prefetched_descriptors(int index) const; + ::cockroach::roachpb::RangeDescriptor* add_prefetched_descriptors(); + const ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::RangeDescriptor >& + prefetched_descriptors() const; + + // .cockroach.roachpb.Error error = 3; + bool has_error() const; + void clear_error(); + static const int kErrorFieldNumber = 3; + private: + const ::cockroach::roachpb::Error& _internal_error() const; + public: + const ::cockroach::roachpb::Error& error() const; + ::cockroach::roachpb::Error* release_error(); + ::cockroach::roachpb::Error* mutable_error(); + void set_allocated_error(::cockroach::roachpb::Error* error); + + // @@protoc_insertion_point(class_scope:cockroach.roachpb.RangeLookupResponse) + private: + + ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::RangeDescriptor > descriptors_; + ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::RangeDescriptor > prefetched_descriptors_; + ::cockroach::roachpb::Error* error_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + friend struct ::protobuf_roachpb_2fapi_2eproto::TableStruct; +}; +// ------------------------------------------------------------------- + class RangeFeedRequest : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.RangeFeedRequest) */ { public: RangeFeedRequest(); @@ -16303,7 +16579,7 @@ class RangeFeedRequest : public ::google::protobuf::MessageLite /* @@protoc_inse &_RangeFeedRequest_default_instance_); } static constexpr int kIndexInFileMessages = - 114; + 116; void Swap(RangeFeedRequest* other); friend void swap(RangeFeedRequest& a, RangeFeedRequest& b) { @@ -16428,7 +16704,7 @@ class RangeFeedValue : public ::google::protobuf::MessageLite /* @@protoc_insert &_RangeFeedValue_default_instance_); } static constexpr int kIndexInFileMessages = - 115; + 117; void Swap(RangeFeedValue* other); friend void swap(RangeFeedValue& a, RangeFeedValue& b) { @@ -16560,7 +16836,7 @@ class RangeFeedCheckpoint : public ::google::protobuf::MessageLite /* @@protoc_i &_RangeFeedCheckpoint_default_instance_); } static constexpr int kIndexInFileMessages = - 116; + 118; void Swap(RangeFeedCheckpoint* other); friend void swap(RangeFeedCheckpoint& a, RangeFeedCheckpoint& b) { @@ -16678,7 +16954,7 @@ class RangeFeedError : public ::google::protobuf::MessageLite /* @@protoc_insert &_RangeFeedError_default_instance_); } static constexpr int kIndexInFileMessages = - 117; + 119; void Swap(RangeFeedError* other); friend void swap(RangeFeedError& a, RangeFeedError& b) { @@ -16784,7 +17060,7 @@ class RangeFeedEvent : public ::google::protobuf::MessageLite /* @@protoc_insert &_RangeFeedEvent_default_instance_); } static constexpr int kIndexInFileMessages = - 118; + 120; void Swap(RangeFeedEvent* other); friend void swap(RangeFeedEvent& a, RangeFeedEvent& b) { @@ -16881,6 +17157,272 @@ class RangeFeedEvent : public ::google::protobuf::MessageLite /* @@protoc_insert mutable ::google::protobuf::internal::CachedSize _cached_size_; friend struct ::protobuf_roachpb_2fapi_2eproto::TableStruct; }; +// ------------------------------------------------------------------- + +class GossipSubscriptionRequest : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.GossipSubscriptionRequest) */ { + public: + GossipSubscriptionRequest(); + virtual ~GossipSubscriptionRequest(); + + GossipSubscriptionRequest(const GossipSubscriptionRequest& from); + + inline GossipSubscriptionRequest& operator=(const GossipSubscriptionRequest& from) { + CopyFrom(from); + return *this; + } + #if LANG_CXX11 + GossipSubscriptionRequest(GossipSubscriptionRequest&& from) noexcept + : GossipSubscriptionRequest() { + *this = ::std::move(from); + } + + inline GossipSubscriptionRequest& operator=(GossipSubscriptionRequest&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + #endif + static const GossipSubscriptionRequest& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const GossipSubscriptionRequest* internal_default_instance() { + return reinterpret_cast( + &_GossipSubscriptionRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = + 121; + + void Swap(GossipSubscriptionRequest* other); + friend void swap(GossipSubscriptionRequest& a, GossipSubscriptionRequest& b) { + a.Swap(&b); + } + + // implements Message ---------------------------------------------- + + inline GossipSubscriptionRequest* New() const final { + return CreateMaybeMessage(NULL); + } + + GossipSubscriptionRequest* New(::google::protobuf::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from) + final; + void CopyFrom(const GossipSubscriptionRequest& from); + void MergeFrom(const GossipSubscriptionRequest& from); + void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) final; + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(GossipSubscriptionRequest* other); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return NULL; + } + inline void* MaybeArenaPtr() const { + return NULL; + } + public: + + ::std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated string patterns = 1; + int patterns_size() const; + void clear_patterns(); + static const int kPatternsFieldNumber = 1; + const ::std::string& patterns(int index) const; + ::std::string* mutable_patterns(int index); + void set_patterns(int index, const ::std::string& value); + #if LANG_CXX11 + void set_patterns(int index, ::std::string&& value); + #endif + void set_patterns(int index, const char* value); + void set_patterns(int index, const char* value, size_t size); + ::std::string* add_patterns(); + void add_patterns(const ::std::string& value); + #if LANG_CXX11 + void add_patterns(::std::string&& value); + #endif + void add_patterns(const char* value); + void add_patterns(const char* value, size_t size); + const ::google::protobuf::RepeatedPtrField< ::std::string>& patterns() const; + ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_patterns(); + + // @@protoc_insertion_point(class_scope:cockroach.roachpb.GossipSubscriptionRequest) + private: + + ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::google::protobuf::RepeatedPtrField< ::std::string> patterns_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + friend struct ::protobuf_roachpb_2fapi_2eproto::TableStruct; +}; +// ------------------------------------------------------------------- + +class GossipSubscriptionEvent : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.GossipSubscriptionEvent) */ { + public: + GossipSubscriptionEvent(); + virtual ~GossipSubscriptionEvent(); + + GossipSubscriptionEvent(const GossipSubscriptionEvent& from); + + inline GossipSubscriptionEvent& operator=(const GossipSubscriptionEvent& from) { + CopyFrom(from); + return *this; + } + #if LANG_CXX11 + GossipSubscriptionEvent(GossipSubscriptionEvent&& from) noexcept + : GossipSubscriptionEvent() { + *this = ::std::move(from); + } + + inline GossipSubscriptionEvent& operator=(GossipSubscriptionEvent&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + #endif + static const GossipSubscriptionEvent& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const GossipSubscriptionEvent* internal_default_instance() { + return reinterpret_cast( + &_GossipSubscriptionEvent_default_instance_); + } + static constexpr int kIndexInFileMessages = + 122; + + void Swap(GossipSubscriptionEvent* other); + friend void swap(GossipSubscriptionEvent& a, GossipSubscriptionEvent& b) { + a.Swap(&b); + } + + // implements Message ---------------------------------------------- + + inline GossipSubscriptionEvent* New() const final { + return CreateMaybeMessage(NULL); + } + + GossipSubscriptionEvent* New(::google::protobuf::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from) + final; + void CopyFrom(const GossipSubscriptionEvent& from); + void MergeFrom(const GossipSubscriptionEvent& from); + void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) final; + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(GossipSubscriptionEvent* other); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return NULL; + } + inline void* MaybeArenaPtr() const { + return NULL; + } + public: + + ::std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // string key = 1; + void clear_key(); + static const int kKeyFieldNumber = 1; + const ::std::string& key() const; + void set_key(const ::std::string& value); + #if LANG_CXX11 + void set_key(::std::string&& value); + #endif + void set_key(const char* value); + void set_key(const char* value, size_t size); + ::std::string* mutable_key(); + ::std::string* release_key(); + void set_allocated_key(::std::string* key); + + // string pattern_matched = 3; + void clear_pattern_matched(); + static const int kPatternMatchedFieldNumber = 3; + const ::std::string& pattern_matched() const; + void set_pattern_matched(const ::std::string& value); + #if LANG_CXX11 + void set_pattern_matched(::std::string&& value); + #endif + void set_pattern_matched(const char* value); + void set_pattern_matched(const char* value, size_t size); + ::std::string* mutable_pattern_matched(); + ::std::string* release_pattern_matched(); + void set_allocated_pattern_matched(::std::string* pattern_matched); + + bool has_content() const; + void clear_content(); + static const int kContentFieldNumber = 2; + private: + const ::cockroach::roachpb::Value& _internal_content() const; + public: + const ::cockroach::roachpb::Value& content() const; + ::cockroach::roachpb::Value* release_content(); + ::cockroach::roachpb::Value* mutable_content(); + void set_allocated_content(::cockroach::roachpb::Value* content); + + // .cockroach.roachpb.Error error = 4; + bool has_error() const; + void clear_error(); + static const int kErrorFieldNumber = 4; + private: + const ::cockroach::roachpb::Error& _internal_error() const; + public: + const ::cockroach::roachpb::Error& error() const; + ::cockroach::roachpb::Error* release_error(); + ::cockroach::roachpb::Error* mutable_error(); + void set_allocated_error(::cockroach::roachpb::Error* error); + + // @@protoc_insertion_point(class_scope:cockroach.roachpb.GossipSubscriptionEvent) + private: + + ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::google::protobuf::internal::ArenaStringPtr key_; + ::google::protobuf::internal::ArenaStringPtr pattern_matched_; + ::cockroach::roachpb::Value* content_; + ::cockroach::roachpb::Error* error_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + friend struct ::protobuf_roachpb_2fapi_2eproto::TableStruct; +}; // =================================================================== @@ -34185,6 +34727,208 @@ BatchResponse::responses() const { // ------------------------------------------------------------------- +// RangeLookupRequest + +inline void RangeLookupRequest::clear_key() { + key_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline const ::std::string& RangeLookupRequest::key() const { + // @@protoc_insertion_point(field_get:cockroach.roachpb.RangeLookupRequest.key) + return key_.GetNoArena(); +} +inline void RangeLookupRequest::set_key(const ::std::string& value) { + + key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:cockroach.roachpb.RangeLookupRequest.key) +} +#if LANG_CXX11 +inline void RangeLookupRequest::set_key(::std::string&& value) { + + key_.SetNoArena( + &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:cockroach.roachpb.RangeLookupRequest.key) +} +#endif +inline void RangeLookupRequest::set_key(const char* value) { + GOOGLE_DCHECK(value != NULL); + + key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:cockroach.roachpb.RangeLookupRequest.key) +} +inline void RangeLookupRequest::set_key(const void* value, size_t size) { + + key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:cockroach.roachpb.RangeLookupRequest.key) +} +inline ::std::string* RangeLookupRequest::mutable_key() { + + // @@protoc_insertion_point(field_mutable:cockroach.roachpb.RangeLookupRequest.key) + return key_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* RangeLookupRequest::release_key() { + // @@protoc_insertion_point(field_release:cockroach.roachpb.RangeLookupRequest.key) + + return key_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void RangeLookupRequest::set_allocated_key(::std::string* key) { + if (key != NULL) { + + } else { + + } + key_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), key); + // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.RangeLookupRequest.key) +} + +// .cockroach.roachpb.ReadConsistencyType read_consistency = 2; +inline void RangeLookupRequest::clear_read_consistency() { + read_consistency_ = 0; +} +inline ::cockroach::roachpb::ReadConsistencyType RangeLookupRequest::read_consistency() const { + // @@protoc_insertion_point(field_get:cockroach.roachpb.RangeLookupRequest.read_consistency) + return static_cast< ::cockroach::roachpb::ReadConsistencyType >(read_consistency_); +} +inline void RangeLookupRequest::set_read_consistency(::cockroach::roachpb::ReadConsistencyType value) { + + read_consistency_ = value; + // @@protoc_insertion_point(field_set:cockroach.roachpb.RangeLookupRequest.read_consistency) +} + +// int64 prefetch_num = 3; +inline void RangeLookupRequest::clear_prefetch_num() { + prefetch_num_ = GOOGLE_LONGLONG(0); +} +inline ::google::protobuf::int64 RangeLookupRequest::prefetch_num() const { + // @@protoc_insertion_point(field_get:cockroach.roachpb.RangeLookupRequest.prefetch_num) + return prefetch_num_; +} +inline void RangeLookupRequest::set_prefetch_num(::google::protobuf::int64 value) { + + prefetch_num_ = value; + // @@protoc_insertion_point(field_set:cockroach.roachpb.RangeLookupRequest.prefetch_num) +} + +// bool prefetch_reverse = 4; +inline void RangeLookupRequest::clear_prefetch_reverse() { + prefetch_reverse_ = false; +} +inline bool RangeLookupRequest::prefetch_reverse() const { + // @@protoc_insertion_point(field_get:cockroach.roachpb.RangeLookupRequest.prefetch_reverse) + return prefetch_reverse_; +} +inline void RangeLookupRequest::set_prefetch_reverse(bool value) { + + prefetch_reverse_ = value; + // @@protoc_insertion_point(field_set:cockroach.roachpb.RangeLookupRequest.prefetch_reverse) +} + +// ------------------------------------------------------------------- + +// RangeLookupResponse + +inline int RangeLookupResponse::descriptors_size() const { + return descriptors_.size(); +} +inline ::cockroach::roachpb::RangeDescriptor* RangeLookupResponse::mutable_descriptors(int index) { + // @@protoc_insertion_point(field_mutable:cockroach.roachpb.RangeLookupResponse.descriptors) + return descriptors_.Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::RangeDescriptor >* +RangeLookupResponse::mutable_descriptors() { + // @@protoc_insertion_point(field_mutable_list:cockroach.roachpb.RangeLookupResponse.descriptors) + return &descriptors_; +} +inline const ::cockroach::roachpb::RangeDescriptor& RangeLookupResponse::descriptors(int index) const { + // @@protoc_insertion_point(field_get:cockroach.roachpb.RangeLookupResponse.descriptors) + return descriptors_.Get(index); +} +inline ::cockroach::roachpb::RangeDescriptor* RangeLookupResponse::add_descriptors() { + // @@protoc_insertion_point(field_add:cockroach.roachpb.RangeLookupResponse.descriptors) + return descriptors_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::RangeDescriptor >& +RangeLookupResponse::descriptors() const { + // @@protoc_insertion_point(field_list:cockroach.roachpb.RangeLookupResponse.descriptors) + return descriptors_; +} + +inline int RangeLookupResponse::prefetched_descriptors_size() const { + return prefetched_descriptors_.size(); +} +inline ::cockroach::roachpb::RangeDescriptor* RangeLookupResponse::mutable_prefetched_descriptors(int index) { + // @@protoc_insertion_point(field_mutable:cockroach.roachpb.RangeLookupResponse.prefetched_descriptors) + return prefetched_descriptors_.Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::RangeDescriptor >* +RangeLookupResponse::mutable_prefetched_descriptors() { + // @@protoc_insertion_point(field_mutable_list:cockroach.roachpb.RangeLookupResponse.prefetched_descriptors) + return &prefetched_descriptors_; +} +inline const ::cockroach::roachpb::RangeDescriptor& RangeLookupResponse::prefetched_descriptors(int index) const { + // @@protoc_insertion_point(field_get:cockroach.roachpb.RangeLookupResponse.prefetched_descriptors) + return prefetched_descriptors_.Get(index); +} +inline ::cockroach::roachpb::RangeDescriptor* RangeLookupResponse::add_prefetched_descriptors() { + // @@protoc_insertion_point(field_add:cockroach.roachpb.RangeLookupResponse.prefetched_descriptors) + return prefetched_descriptors_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::RangeDescriptor >& +RangeLookupResponse::prefetched_descriptors() const { + // @@protoc_insertion_point(field_list:cockroach.roachpb.RangeLookupResponse.prefetched_descriptors) + return prefetched_descriptors_; +} + +// .cockroach.roachpb.Error error = 3; +inline bool RangeLookupResponse::has_error() const { + return this != internal_default_instance() && error_ != NULL; +} +inline const ::cockroach::roachpb::Error& RangeLookupResponse::_internal_error() const { + return *error_; +} +inline const ::cockroach::roachpb::Error& RangeLookupResponse::error() const { + const ::cockroach::roachpb::Error* p = error_; + // @@protoc_insertion_point(field_get:cockroach.roachpb.RangeLookupResponse.error) + return p != NULL ? *p : *reinterpret_cast( + &::cockroach::roachpb::_Error_default_instance_); +} +inline ::cockroach::roachpb::Error* RangeLookupResponse::release_error() { + // @@protoc_insertion_point(field_release:cockroach.roachpb.RangeLookupResponse.error) + + ::cockroach::roachpb::Error* temp = error_; + error_ = NULL; + return temp; +} +inline ::cockroach::roachpb::Error* RangeLookupResponse::mutable_error() { + + if (error_ == NULL) { + auto* p = CreateMaybeMessage<::cockroach::roachpb::Error>(GetArenaNoVirtual()); + error_ = p; + } + // @@protoc_insertion_point(field_mutable:cockroach.roachpb.RangeLookupResponse.error) + return error_; +} +inline void RangeLookupResponse::set_allocated_error(::cockroach::roachpb::Error* error) { + ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == NULL) { + delete reinterpret_cast< ::google::protobuf::MessageLite*>(error_); + } + if (error) { + ::google::protobuf::Arena* submessage_arena = NULL; + if (message_arena != submessage_arena) { + error = ::google::protobuf::internal::GetOwnedMessage( + message_arena, error, submessage_arena); + } + + } else { + + } + error_ = error; + // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.RangeLookupResponse.error) +} + +// ------------------------------------------------------------------- + // RangeFeedRequest inline bool RangeFeedRequest::has_header() const { @@ -34766,6 +35510,284 @@ inline void RangeFeedEvent::set_allocated_error(::cockroach::roachpb::RangeFeedE // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.RangeFeedEvent.error) } +// ------------------------------------------------------------------- + +// GossipSubscriptionRequest + +// repeated string patterns = 1; +inline int GossipSubscriptionRequest::patterns_size() const { + return patterns_.size(); +} +inline void GossipSubscriptionRequest::clear_patterns() { + patterns_.Clear(); +} +inline const ::std::string& GossipSubscriptionRequest::patterns(int index) const { + // @@protoc_insertion_point(field_get:cockroach.roachpb.GossipSubscriptionRequest.patterns) + return patterns_.Get(index); +} +inline ::std::string* GossipSubscriptionRequest::mutable_patterns(int index) { + // @@protoc_insertion_point(field_mutable:cockroach.roachpb.GossipSubscriptionRequest.patterns) + return patterns_.Mutable(index); +} +inline void GossipSubscriptionRequest::set_patterns(int index, const ::std::string& value) { + // @@protoc_insertion_point(field_set:cockroach.roachpb.GossipSubscriptionRequest.patterns) + patterns_.Mutable(index)->assign(value); +} +#if LANG_CXX11 +inline void GossipSubscriptionRequest::set_patterns(int index, ::std::string&& value) { + // @@protoc_insertion_point(field_set:cockroach.roachpb.GossipSubscriptionRequest.patterns) + patterns_.Mutable(index)->assign(std::move(value)); +} +#endif +inline void GossipSubscriptionRequest::set_patterns(int index, const char* value) { + GOOGLE_DCHECK(value != NULL); + patterns_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:cockroach.roachpb.GossipSubscriptionRequest.patterns) +} +inline void GossipSubscriptionRequest::set_patterns(int index, const char* value, size_t size) { + patterns_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:cockroach.roachpb.GossipSubscriptionRequest.patterns) +} +inline ::std::string* GossipSubscriptionRequest::add_patterns() { + // @@protoc_insertion_point(field_add_mutable:cockroach.roachpb.GossipSubscriptionRequest.patterns) + return patterns_.Add(); +} +inline void GossipSubscriptionRequest::add_patterns(const ::std::string& value) { + patterns_.Add()->assign(value); + // @@protoc_insertion_point(field_add:cockroach.roachpb.GossipSubscriptionRequest.patterns) +} +#if LANG_CXX11 +inline void GossipSubscriptionRequest::add_patterns(::std::string&& value) { + patterns_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:cockroach.roachpb.GossipSubscriptionRequest.patterns) +} +#endif +inline void GossipSubscriptionRequest::add_patterns(const char* value) { + GOOGLE_DCHECK(value != NULL); + patterns_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:cockroach.roachpb.GossipSubscriptionRequest.patterns) +} +inline void GossipSubscriptionRequest::add_patterns(const char* value, size_t size) { + patterns_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:cockroach.roachpb.GossipSubscriptionRequest.patterns) +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +GossipSubscriptionRequest::patterns() const { + // @@protoc_insertion_point(field_list:cockroach.roachpb.GossipSubscriptionRequest.patterns) + return patterns_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +GossipSubscriptionRequest::mutable_patterns() { + // @@protoc_insertion_point(field_mutable_list:cockroach.roachpb.GossipSubscriptionRequest.patterns) + return &patterns_; +} + +// ------------------------------------------------------------------- + +// GossipSubscriptionEvent + +// string key = 1; +inline void GossipSubscriptionEvent::clear_key() { + key_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline const ::std::string& GossipSubscriptionEvent::key() const { + // @@protoc_insertion_point(field_get:cockroach.roachpb.GossipSubscriptionEvent.key) + return key_.GetNoArena(); +} +inline void GossipSubscriptionEvent::set_key(const ::std::string& value) { + + key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:cockroach.roachpb.GossipSubscriptionEvent.key) +} +#if LANG_CXX11 +inline void GossipSubscriptionEvent::set_key(::std::string&& value) { + + key_.SetNoArena( + &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:cockroach.roachpb.GossipSubscriptionEvent.key) +} +#endif +inline void GossipSubscriptionEvent::set_key(const char* value) { + GOOGLE_DCHECK(value != NULL); + + key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:cockroach.roachpb.GossipSubscriptionEvent.key) +} +inline void GossipSubscriptionEvent::set_key(const char* value, size_t size) { + + key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:cockroach.roachpb.GossipSubscriptionEvent.key) +} +inline ::std::string* GossipSubscriptionEvent::mutable_key() { + + // @@protoc_insertion_point(field_mutable:cockroach.roachpb.GossipSubscriptionEvent.key) + return key_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* GossipSubscriptionEvent::release_key() { + // @@protoc_insertion_point(field_release:cockroach.roachpb.GossipSubscriptionEvent.key) + + return key_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void GossipSubscriptionEvent::set_allocated_key(::std::string* key) { + if (key != NULL) { + + } else { + + } + key_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), key); + // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.GossipSubscriptionEvent.key) +} + +inline bool GossipSubscriptionEvent::has_content() const { + return this != internal_default_instance() && content_ != NULL; +} +inline const ::cockroach::roachpb::Value& GossipSubscriptionEvent::_internal_content() const { + return *content_; +} +inline const ::cockroach::roachpb::Value& GossipSubscriptionEvent::content() const { + const ::cockroach::roachpb::Value* p = content_; + // @@protoc_insertion_point(field_get:cockroach.roachpb.GossipSubscriptionEvent.content) + return p != NULL ? *p : *reinterpret_cast( + &::cockroach::roachpb::_Value_default_instance_); +} +inline ::cockroach::roachpb::Value* GossipSubscriptionEvent::release_content() { + // @@protoc_insertion_point(field_release:cockroach.roachpb.GossipSubscriptionEvent.content) + + ::cockroach::roachpb::Value* temp = content_; + content_ = NULL; + return temp; +} +inline ::cockroach::roachpb::Value* GossipSubscriptionEvent::mutable_content() { + + if (content_ == NULL) { + auto* p = CreateMaybeMessage<::cockroach::roachpb::Value>(GetArenaNoVirtual()); + content_ = p; + } + // @@protoc_insertion_point(field_mutable:cockroach.roachpb.GossipSubscriptionEvent.content) + return content_; +} +inline void GossipSubscriptionEvent::set_allocated_content(::cockroach::roachpb::Value* content) { + ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == NULL) { + delete reinterpret_cast< ::google::protobuf::MessageLite*>(content_); + } + if (content) { + ::google::protobuf::Arena* submessage_arena = NULL; + if (message_arena != submessage_arena) { + content = ::google::protobuf::internal::GetOwnedMessage( + message_arena, content, submessage_arena); + } + + } else { + + } + content_ = content; + // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.GossipSubscriptionEvent.content) +} + +// string pattern_matched = 3; +inline void GossipSubscriptionEvent::clear_pattern_matched() { + pattern_matched_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline const ::std::string& GossipSubscriptionEvent::pattern_matched() const { + // @@protoc_insertion_point(field_get:cockroach.roachpb.GossipSubscriptionEvent.pattern_matched) + return pattern_matched_.GetNoArena(); +} +inline void GossipSubscriptionEvent::set_pattern_matched(const ::std::string& value) { + + pattern_matched_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:cockroach.roachpb.GossipSubscriptionEvent.pattern_matched) +} +#if LANG_CXX11 +inline void GossipSubscriptionEvent::set_pattern_matched(::std::string&& value) { + + pattern_matched_.SetNoArena( + &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:cockroach.roachpb.GossipSubscriptionEvent.pattern_matched) +} +#endif +inline void GossipSubscriptionEvent::set_pattern_matched(const char* value) { + GOOGLE_DCHECK(value != NULL); + + pattern_matched_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:cockroach.roachpb.GossipSubscriptionEvent.pattern_matched) +} +inline void GossipSubscriptionEvent::set_pattern_matched(const char* value, size_t size) { + + pattern_matched_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:cockroach.roachpb.GossipSubscriptionEvent.pattern_matched) +} +inline ::std::string* GossipSubscriptionEvent::mutable_pattern_matched() { + + // @@protoc_insertion_point(field_mutable:cockroach.roachpb.GossipSubscriptionEvent.pattern_matched) + return pattern_matched_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* GossipSubscriptionEvent::release_pattern_matched() { + // @@protoc_insertion_point(field_release:cockroach.roachpb.GossipSubscriptionEvent.pattern_matched) + + return pattern_matched_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void GossipSubscriptionEvent::set_allocated_pattern_matched(::std::string* pattern_matched) { + if (pattern_matched != NULL) { + + } else { + + } + pattern_matched_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), pattern_matched); + // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.GossipSubscriptionEvent.pattern_matched) +} + +// .cockroach.roachpb.Error error = 4; +inline bool GossipSubscriptionEvent::has_error() const { + return this != internal_default_instance() && error_ != NULL; +} +inline const ::cockroach::roachpb::Error& GossipSubscriptionEvent::_internal_error() const { + return *error_; +} +inline const ::cockroach::roachpb::Error& GossipSubscriptionEvent::error() const { + const ::cockroach::roachpb::Error* p = error_; + // @@protoc_insertion_point(field_get:cockroach.roachpb.GossipSubscriptionEvent.error) + return p != NULL ? *p : *reinterpret_cast( + &::cockroach::roachpb::_Error_default_instance_); +} +inline ::cockroach::roachpb::Error* GossipSubscriptionEvent::release_error() { + // @@protoc_insertion_point(field_release:cockroach.roachpb.GossipSubscriptionEvent.error) + + ::cockroach::roachpb::Error* temp = error_; + error_ = NULL; + return temp; +} +inline ::cockroach::roachpb::Error* GossipSubscriptionEvent::mutable_error() { + + if (error_ == NULL) { + auto* p = CreateMaybeMessage<::cockroach::roachpb::Error>(GetArenaNoVirtual()); + error_ = p; + } + // @@protoc_insertion_point(field_mutable:cockroach.roachpb.GossipSubscriptionEvent.error) + return error_; +} +inline void GossipSubscriptionEvent::set_allocated_error(::cockroach::roachpb::Error* error) { + ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == NULL) { + delete reinterpret_cast< ::google::protobuf::MessageLite*>(error_); + } + if (error) { + ::google::protobuf::Arena* submessage_arena = NULL; + if (message_arena != submessage_arena) { + error = ::google::protobuf::internal::GetOwnedMessage( + message_arena, error, submessage_arena); + } + + } else { + + } + error_ = error; + // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.GossipSubscriptionEvent.error) +} + #ifdef __GNUC__ #pragma GCC diagnostic pop #endif // __GNUC__ @@ -35005,6 +36027,14 @@ inline void RangeFeedEvent::set_allocated_error(::cockroach::roachpb::RangeFeedE // ------------------------------------------------------------------- +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + // @@protoc_insertion_point(namespace_scope) diff --git a/pkg/ccl/backupccl/backup_test.go b/pkg/ccl/backupccl/backup_test.go index abe635db4ed2..ffec53b3a7fd 100644 --- a/pkg/ccl/backupccl/backup_test.go +++ b/pkg/ccl/backupccl/backup_test.go @@ -32,6 +32,7 @@ import ( "github.com/cockroachdb/cockroach-go/crdb" "github.com/cockroachdb/cockroach/pkg/base" + _ "github.com/cockroachdb/cockroach/pkg/ccl/kvccl" _ "github.com/cockroachdb/cockroach/pkg/ccl/partitionccl" "github.com/cockroachdb/cockroach/pkg/ccl/storageccl" "github.com/cockroachdb/cockroach/pkg/config" diff --git a/pkg/ccl/ccl_init.go b/pkg/ccl/ccl_init.go index 8db121580d5c..f63cf8dfda90 100644 --- a/pkg/ccl/ccl_init.go +++ b/pkg/ccl/ccl_init.go @@ -21,6 +21,7 @@ import ( _ "github.com/cockroachdb/cockroach/pkg/ccl/followerreadsccl" _ "github.com/cockroachdb/cockroach/pkg/ccl/gssapiccl" _ "github.com/cockroachdb/cockroach/pkg/ccl/importccl" + _ "github.com/cockroachdb/cockroach/pkg/ccl/kvccl" _ "github.com/cockroachdb/cockroach/pkg/ccl/partitionccl" _ "github.com/cockroachdb/cockroach/pkg/ccl/storageccl" _ "github.com/cockroachdb/cockroach/pkg/ccl/storageccl/engineccl" diff --git a/pkg/ccl/kvccl/kvccl.go b/pkg/ccl/kvccl/kvccl.go new file mode 100644 index 000000000000..0988c8179167 --- /dev/null +++ b/pkg/ccl/kvccl/kvccl.go @@ -0,0 +1,11 @@ +// Copyright 2020 The Cockroach Authors. +// +// Licensed as a CockroachDB Enterprise file under the Cockroach Community +// License (the "License"); you may not use this file except in compliance with +// the License. You may obtain a copy of the License at +// +// https://github.com/cockroachdb/cockroach/blob/master/licenses/CCL.txt + +package kvccl + +import _ "github.com/cockroachdb/cockroach/pkg/ccl/kvccl/kvtenantccl" // init hooks diff --git a/pkg/ccl/kvccl/kvtenantccl/proxy.go b/pkg/ccl/kvccl/kvtenantccl/proxy.go new file mode 100644 index 000000000000..e0aee54366a4 --- /dev/null +++ b/pkg/ccl/kvccl/kvtenantccl/proxy.go @@ -0,0 +1,332 @@ +// Copyright 2020 The Cockroach Authors. +// +// Licensed as a CockroachDB Enterprise file under the Cockroach Community +// License (the "License"); you may not use this file except in compliance with +// the License. You may obtain a copy of the License at +// +// https://github.com/cockroachdb/cockroach/blob/master/licenses/CCL.txt + +// Package kvtenantccl provides utilities required by SQL-only tenant processes +// in order to interact with the key-value layer. +package kvtenantccl + +import ( + "context" + "io" + "math/rand" + "time" + + "github.com/cockroachdb/cockroach/pkg/gossip" + "github.com/cockroachdb/cockroach/pkg/kv/kvclient/kvcoord" + "github.com/cockroachdb/cockroach/pkg/kv/kvclient/kvtenant" + "github.com/cockroachdb/cockroach/pkg/roachpb" + "github.com/cockroachdb/cockroach/pkg/rpc" + "github.com/cockroachdb/cockroach/pkg/util/contextutil" + "github.com/cockroachdb/cockroach/pkg/util/log" + "github.com/cockroachdb/cockroach/pkg/util/retry" + "github.com/cockroachdb/cockroach/pkg/util/syncutil" + "github.com/cockroachdb/cockroach/pkg/util/syncutil/singleflight" + "github.com/cockroachdb/errors" + "google.golang.org/grpc" +) + +func init() { + kvtenant.Factory = proxyFactory{} +} + +// Proxy mediates the communication of cluster-wide state to sandboxed SQL-only +// tenant processes through a restricted interface. A Proxy is seeded with a set +// of one or more network addresses that reference existing KV nodes in the +// cluster (or a load-balancer which fans out to some/all KV nodes). On startup, +// it establishes contact with one of these nodes to learn about the topology of +// the cluster and bootstrap the rest of SQL <-> KV network communication. +// +// See below for the Proxy's roles. +type Proxy struct { + log.AmbientContext + + rpcContext *rpc.Context + rpcRetryOptions retry.Options + rpcDialTimeout time.Duration // for testing + rpcDial singleflight.Group + addrs []string + startupC chan struct{} + + mu syncutil.RWMutex + client roachpb.InternalClient + nodeDescs map[roachpb.NodeID]*roachpb.NodeDescriptor +} + +// Proxy is capable of providing information on each of the KV nodes in the +// cluster in the form of NodeDescriptors. This obviates the need for SQL-only +// tenant processes to join the cluster-wide gossip network. +var _ kvcoord.NodeDescStore = (*Proxy)(nil) + +// Proxy is capable of providing Range addressing information in the form of +// RangeDescriptors through delegated RangeLookup requests. This is necessary +// because SQL-only tenants are restricted from reading Range Metadata keys +// directly. Instead, the RangeLookup requests are proxied through existing KV +// nodes while being subject to additional validation (e.g. is the Range being +// requested owned by the requesting tenant?). +var _ kvcoord.RangeDescriptorDB = (*Proxy)(nil) + +// NewProxy creates a new Proxy. +func NewProxy( + ac log.AmbientContext, rpcContext *rpc.Context, rpcRetryOptions retry.Options, addrs []string, +) *Proxy { + ac.AddLogTag("tenant-proxy", nil) + return &Proxy{ + AmbientContext: ac, + rpcContext: rpcContext, + rpcRetryOptions: rpcRetryOptions, + addrs: addrs, + startupC: make(chan struct{}), + nodeDescs: make(map[roachpb.NodeID]*roachpb.NodeDescriptor), + } +} + +// proxyFactory implements kvtenant.ProxyFactory. +type proxyFactory struct{} + +func (proxyFactory) NewProxy( + ac log.AmbientContext, rpcContext *rpc.Context, rpcRetryOptions retry.Options, addrs []string, +) (kvtenant.Proxy, error) { + return NewProxy(ac, rpcContext, rpcRetryOptions, addrs), nil +} + +// Start launches the proxy's worker thread and waits for it to receive an +// initial GossipSubscription event. +func (p *Proxy) Start(ctx context.Context) error { + startupC := p.startupC + p.rpcContext.Stopper.RunWorker(context.Background(), func(ctx context.Context) { + ctx = p.AnnotateCtx(ctx) + ctx, cancel := p.rpcContext.Stopper.WithCancelOnQuiesce(ctx) + defer cancel() + p.runGossipSubscription(ctx) + }) + // Synchronously block until the first GossipSubscription event. + select { + case <-startupC: + return nil + case <-ctx.Done(): + return ctx.Err() + } +} + +func (p *Proxy) runGossipSubscription(ctx context.Context) { + for ctx.Err() == nil { + client, err := p.getClient(ctx) + if err != nil { + continue + } + stream, err := client.GossipSubscription(ctx, &roachpb.GossipSubscriptionRequest{ + Patterns: gossipSubsPatterns, + }) + if err != nil { + log.Warningf(ctx, "error issuing GossipSubscription RPC: %v", err) + p.tryForgetClient(ctx, client) + continue + } + for { + e, err := stream.Recv() + if err != nil { + if err == io.EOF { + break + } + // Soft RPC error. Drop client and retry. + log.Warningf(ctx, "error consuming GossipSubscription RPC: %v", err) + p.tryForgetClient(ctx, client) + break + } + if e.Error != nil { + // Hard logical error. We expect io.EOF next. + log.Errorf(ctx, "error consuming GossipSubscription RPC: %v", e.Error) + continue + } + handler, ok := gossipSubsHandlers[e.PatternMatched] + if !ok { + log.Errorf(ctx, "unknown GossipSubscription pattern: %q", e.PatternMatched) + continue + } + handler(p, ctx, e.Key, e.Content) + if p.startupC != nil { + close(p.startupC) + p.startupC = nil + } + } + } +} + +var gossipSubsHandlers = map[string]func(*Proxy, context.Context, string, roachpb.Value){ + // Subscribe to all *NodeDescriptor updates in the gossip network. + gossip.MakePrefixPattern(gossip.KeyNodeIDPrefix): (*Proxy).updateNodeAddress, + // TODO(nvanbenschoten): subscribe to updates to the tenant zones key. +} + +var gossipSubsPatterns = func() []string { + patterns := make([]string, 0, len(gossipSubsHandlers)) + for pattern := range gossipSubsHandlers { + patterns = append(patterns, pattern) + } + return patterns +}() + +// updateNodeAddress handles updates to "node" gossip keys, performing the +// corresponding update to the Proxy's cached NodeDescriptor set. +func (p *Proxy) updateNodeAddress(ctx context.Context, key string, content roachpb.Value) { + desc := new(roachpb.NodeDescriptor) + if err := content.GetProto(desc); err != nil { + log.Errorf(ctx, "%v", err) + return + } + + // TODO(nvanbenschoten): this doesn't handle NodeDescriptor removal from the + // gossip network. As it turns out, neither does Gossip.updateNodeAddress. + // There is some logic in Gossip.updateNodeAddress that attempts to remove + // replaced network addresses, but that logic has been dead since 5bce267. + // Other than that, gossip callbacks are not invoked on info expiration, so + // nothing ever removes them from Gossip.nodeDescs. Fix this. + p.mu.Lock() + defer p.mu.Unlock() + p.nodeDescs[desc.NodeID] = desc +} + +// GetNodeDescriptor implements the kvcoord.NodeDescStore interface. +func (p *Proxy) GetNodeDescriptor(nodeID roachpb.NodeID) (*roachpb.NodeDescriptor, error) { + p.mu.RLock() + defer p.mu.RUnlock() + desc, ok := p.nodeDescs[nodeID] + if !ok { + return nil, errors.Errorf("unable to look up descriptor for n%d", nodeID) + } + return desc, nil +} + +// RangeLookup implements the kvcoord.RangeDescriptorDB interface. +func (p *Proxy) RangeLookup( + ctx context.Context, key roachpb.RKey, useReverseScan bool, +) ([]roachpb.RangeDescriptor, []roachpb.RangeDescriptor, error) { + // Proxy range lookup requests through the Internal service. + ctx = p.AnnotateCtx(ctx) + for ctx.Err() == nil { + client, err := p.getClient(ctx) + if err != nil { + continue + } + resp, err := client.RangeLookup(ctx, &roachpb.RangeLookupRequest{ + Key: key, + // We perform the range lookup scan with a READ_UNCOMMITTED consistency + // level because we want the scan to return intents as well as committed + // values. The reason for this is because it's not clear whether the + // intent or the previous value points to the correct location of the + // Range. It gets even more complicated when there are split-related + // intents or a txn record co-located with a replica involved in the + // split. Since we cannot know the correct answer, we lookup both the + // pre- and post- transaction values. + ReadConsistency: roachpb.READ_UNCOMMITTED, + // Until we add protection in the Internal service implementation to + // prevent prefetching from traversing into RangeDescriptors owned by + // other tenants, we must disable prefetching. + PrefetchNum: 0, + PrefetchReverse: useReverseScan, + }) + if err != nil { + // Soft RPC error. Drop client and retry. + log.Warningf(ctx, "error issuing RangeLookup RPC: %v", err) + p.tryForgetClient(ctx, client) + continue + } + if resp.Error != nil { + // Hard logical error. + return nil, nil, resp.Error.GoError() + } + return resp.Descriptors, resp.PrefetchedDescriptors, nil + } + return nil, nil, ctx.Err() +} + +// FirstRange implements the kvcoord.RangeDescriptorDB interface. +func (p *Proxy) FirstRange() (*roachpb.RangeDescriptor, error) { + return nil, errors.New("kvtenant.Proxy does not have access to FirstRange") +} + +// getClient returns the singleton InternalClient if one is currently active. If +// not, the method attempts to dial one of the configured addresses. The method +// blocks until either a connection is successfully established or the provided +// context is canceled. +func (p *Proxy) getClient(ctx context.Context) (roachpb.InternalClient, error) { + p.mu.RLock() + if c := p.client; c != nil { + p.mu.RUnlock() + return c, nil + } + ch, _ := p.rpcDial.DoChan("dial", func() (interface{}, error) { + dialCtx := p.AnnotateCtx(context.Background()) + dialCtx, cancel := p.rpcContext.Stopper.WithCancelOnQuiesce(dialCtx) + defer cancel() + err := p.rpcContext.Stopper.RunTaskWithErr(dialCtx, "kvtenant.Proxy: dial", p.dialAddrs) + if err != nil { + return nil, err + } + // NB: read lock not needed. + return p.client, nil + }) + p.mu.RUnlock() + + select { + case res := <-ch: + if res.Err != nil { + return nil, res.Err + } + return res.Val.(roachpb.InternalClient), nil + case <-ctx.Done(): + return nil, ctx.Err() + } +} + +// dialAddrs attempts to dial each of the configured addresses in a retry loop. +// The method will only return a non-nil error on context cancellation. +func (p *Proxy) dialAddrs(ctx context.Context) error { + for r := retry.StartWithCtx(ctx, p.rpcRetryOptions); r.Next(); { + // Try each address on each retry iteration. + randStart := rand.Intn(len(p.addrs)) + for i := range p.addrs { + addr := p.addrs[(i+randStart)%len(p.addrs)] + conn, err := p.dialAddr(ctx, addr) + if err != nil { + log.Warningf(ctx, "error dialing tenant KV address %s: %v", addr, err) + continue + } + client := roachpb.NewInternalClient(conn) + p.mu.Lock() + p.client = client + p.mu.Unlock() + return nil + } + } + return ctx.Err() +} + +func (p *Proxy) dialAddr(ctx context.Context, addr string) (conn *grpc.ClientConn, err error) { + if p.rpcDialTimeout == 0 { + return p.rpcContext.GRPCUnvalidatedDial(addr).Connect(ctx) + } + err = contextutil.RunWithTimeout(ctx, "dial addr", p.rpcDialTimeout, func(ctx context.Context) error { + conn, err = p.rpcContext.GRPCUnvalidatedDial(addr).Connect(ctx) + return err + }) + return conn, err +} + +func (p *Proxy) tryForgetClient(ctx context.Context, c roachpb.InternalClient) { + if ctx.Err() != nil { + // Error (may be) due to context. Don't forget client. + return + } + // Compare-and-swap to avoid thrashing. + p.mu.Lock() + defer p.mu.Unlock() + if p.client == c { + p.client = nil + } +} diff --git a/pkg/ccl/kvccl/kvtenantccl/proxy_test.go b/pkg/ccl/kvccl/kvtenantccl/proxy_test.go new file mode 100644 index 000000000000..64f89000f5e8 --- /dev/null +++ b/pkg/ccl/kvccl/kvtenantccl/proxy_test.go @@ -0,0 +1,314 @@ +// Copyright 2020 The Cockroach Authors. +// +// Licensed as a CockroachDB Enterprise file under the Cockroach Community +// License (the "License"); you may not use this file except in compliance with +// the License. You may obtain a copy of the License at +// +// https://github.com/cockroachdb/cockroach/blob/master/licenses/CCL.txt + +package kvtenantccl + +import ( + "context" + "net" + "testing" + "time" + + "github.com/cockroachdb/cockroach/pkg/gossip" + "github.com/cockroachdb/cockroach/pkg/roachpb" + "github.com/cockroachdb/cockroach/pkg/rpc" + "github.com/cockroachdb/cockroach/pkg/testutils" + "github.com/cockroachdb/cockroach/pkg/util" + "github.com/cockroachdb/cockroach/pkg/util/hlc" + "github.com/cockroachdb/cockroach/pkg/util/leaktest" + "github.com/cockroachdb/cockroach/pkg/util/log" + "github.com/cockroachdb/cockroach/pkg/util/netutil" + "github.com/cockroachdb/cockroach/pkg/util/protoutil" + "github.com/cockroachdb/cockroach/pkg/util/retry" + "github.com/cockroachdb/cockroach/pkg/util/stop" + "github.com/cockroachdb/cockroach/pkg/util/tracing" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +var rpcRetryOpts = retry.Options{ + InitialBackoff: 1 * time.Microsecond, + MaxBackoff: 4 * time.Microsecond, +} + +type mockServer struct { + rangeLookupFn func(context.Context, *roachpb.RangeLookupRequest) (*roachpb.RangeLookupResponse, error) + gossipSubFn func(*roachpb.GossipSubscriptionRequest, roachpb.Internal_GossipSubscriptionServer) error +} + +func (m *mockServer) RangeLookup( + ctx context.Context, req *roachpb.RangeLookupRequest, +) (*roachpb.RangeLookupResponse, error) { + return m.rangeLookupFn(ctx, req) +} + +func (m *mockServer) GossipSubscription( + req *roachpb.GossipSubscriptionRequest, stream roachpb.Internal_GossipSubscriptionServer, +) error { + return m.gossipSubFn(req, stream) +} + +func (*mockServer) Batch(context.Context, *roachpb.BatchRequest) (*roachpb.BatchResponse, error) { + panic("unimplemented") +} + +func (*mockServer) RangeFeed(*roachpb.RangeFeedRequest, roachpb.Internal_RangeFeedServer) error { + panic("unimplemented") +} + +func gossipEventForNodeDesc(desc *roachpb.NodeDescriptor) *roachpb.GossipSubscriptionEvent { + val, err := protoutil.Marshal(desc) + if err != nil { + panic(err) + } + return &roachpb.GossipSubscriptionEvent{ + Key: gossip.MakeNodeIDKey(desc.NodeID), + Content: roachpb.MakeValueFromBytesAndTimestamp(val, hlc.Timestamp{}), + PatternMatched: gossip.MakePrefixPattern(gossip.KeyNodeIDPrefix), + } +} + +func waitForNodeDesc(t *testing.T, p *Proxy, nodeID roachpb.NodeID) { + t.Helper() + testutils.SucceedsSoon(t, func() error { + _, err := p.GetNodeDescriptor(nodeID) + return err + }) +} + +// TestProxyGossipSubscription tests Proxy's role as a kvcoord.NodeDescStore. +func TestProxyGossipSubscription(t *testing.T) { + defer leaktest.AfterTest(t)() + + ctx := context.Background() + stopper := stop.NewStopper() + defer stopper.Stop(ctx) + clock := hlc.NewClock(hlc.UnixNano, time.Nanosecond) + rpcContext := rpc.NewInsecureTestingContext(clock, stopper) + s := rpc.NewServer(rpcContext) + + gossipSubC := make(chan *roachpb.GossipSubscriptionEvent) + defer close(gossipSubC) + gossipSubFn := func(req *roachpb.GossipSubscriptionRequest, stream roachpb.Internal_GossipSubscriptionServer) error { + assert.Len(t, req.Patterns, 1) + assert.Equal(t, "node:.*", req.Patterns[0]) + for gossipSub := range gossipSubC { + if err := stream.Send(gossipSub); err != nil { + return err + } + } + return nil + } + roachpb.RegisterInternalServer(s, &mockServer{gossipSubFn: gossipSubFn}) + ln, err := netutil.ListenAndServeGRPC(stopper, s, util.TestAddr) + require.NoError(t, err) + + addrs := []string{ln.Addr().String()} + p := NewProxy(log.AmbientContext{Tracer: tracing.NewTracer()}, rpcContext, rpcRetryOpts, addrs) + + // Start should block until the first GossipSubscription response. + startedC := make(chan error) + go func() { + startedC <- p.Start(ctx) + }() + select { + case err := <-startedC: + t.Fatalf("Start unexpectedly completed with err=%v", err) + case <-time.After(10 * time.Millisecond): + } + + // Return first GossipSubscription response. + node1 := &roachpb.NodeDescriptor{NodeID: 1, Address: util.MakeUnresolvedAddr("tcp", "1.1.1.1")} + node2 := &roachpb.NodeDescriptor{NodeID: 2, Address: util.MakeUnresolvedAddr("tcp", "2.2.2.2")} + gossipSubC <- gossipEventForNodeDesc(node1) + gossipSubC <- gossipEventForNodeDesc(node2) + require.NoError(t, <-startedC) + + // Test kvcoord.NodeDescStore impl. Wait for full update first. + waitForNodeDesc(t, p, 2) + desc, err := p.GetNodeDescriptor(1) + require.Equal(t, node1, desc) + require.NoError(t, err) + desc, err = p.GetNodeDescriptor(2) + require.Equal(t, node2, desc) + require.NoError(t, err) + desc, err = p.GetNodeDescriptor(3) + require.Nil(t, desc) + require.Regexp(t, "unable to look up descriptor for n3", err) + + // Return updated GossipSubscription response. + node1Up := &roachpb.NodeDescriptor{NodeID: 1, Address: util.MakeUnresolvedAddr("tcp", "1.2.3.4")} + node3 := &roachpb.NodeDescriptor{NodeID: 3, Address: util.MakeUnresolvedAddr("tcp", "2.2.2.2")} + gossipSubC <- gossipEventForNodeDesc(node1Up) + gossipSubC <- gossipEventForNodeDesc(node3) + + // Test kvcoord.NodeDescStore impl. Wait for full update first. + waitForNodeDesc(t, p, 3) + desc, err = p.GetNodeDescriptor(1) + require.Equal(t, node1Up, desc) + require.NoError(t, err) + desc, err = p.GetNodeDescriptor(2) + require.Equal(t, node2, desc) + require.NoError(t, err) + desc, err = p.GetNodeDescriptor(3) + require.Equal(t, node3, desc) + require.NoError(t, err) +} + +// TestProxyGossipSubscription tests Proxy's role as a kvcoord.RangeDescriptorDB. +func TestProxyRangeLookup(t *testing.T) { + defer leaktest.AfterTest(t)() + + ctx := context.Background() + stopper := stop.NewStopper() + defer stopper.Stop(ctx) + clock := hlc.NewClock(hlc.UnixNano, time.Nanosecond) + rpcContext := rpc.NewInsecureTestingContext(clock, stopper) + s := rpc.NewServer(rpcContext) + + rangeLookupRespC := make(chan *roachpb.RangeLookupResponse, 1) + rangeLookupFn := func(_ context.Context, req *roachpb.RangeLookupRequest) (*roachpb.RangeLookupResponse, error) { + // Validate request. + assert.Equal(t, roachpb.RKey("a"), req.Key) + assert.Equal(t, roachpb.READ_UNCOMMITTED, req.ReadConsistency) + assert.Equal(t, int64(0), req.PrefetchNum) + assert.Equal(t, false, req.PrefetchReverse) + + // Respond. + return <-rangeLookupRespC, nil + } + server := &mockServer{rangeLookupFn: rangeLookupFn} + roachpb.RegisterInternalServer(s, server) + ln, err := netutil.ListenAndServeGRPC(stopper, s, util.TestAddr) + require.NoError(t, err) + + addrs := []string{ln.Addr().String()} + p := NewProxy(log.AmbientContext{Tracer: tracing.NewTracer()}, rpcContext, rpcRetryOpts, addrs) + // NOTE: we don't actually start the proxy worker. That's ok, as + // RangeDescriptorDB methods don't require it to be running. + + // Success case. + descs := []roachpb.RangeDescriptor{{RangeID: 1}, {RangeID: 2}} + preDescs := []roachpb.RangeDescriptor{{RangeID: 3}, {RangeID: 4}} + rangeLookupRespC <- &roachpb.RangeLookupResponse{ + Descriptors: descs, PrefetchedDescriptors: preDescs, + } + resDescs, resPreDescs, err := p.RangeLookup(ctx, roachpb.RKey("a"), false /* useReverseScan */) + require.Equal(t, descs, resDescs) + require.Equal(t, preDescs, resPreDescs) + require.NoError(t, err) + + // Error case. + rangeLookupRespC <- &roachpb.RangeLookupResponse{ + Error: roachpb.NewErrorf("hit error"), + } + resDescs, resPreDescs, err = p.RangeLookup(ctx, roachpb.RKey("a"), false /* useReverseScan */) + require.Nil(t, resDescs) + require.Nil(t, resPreDescs) + require.Regexp(t, "hit error", err) + + // Context cancelation. + canceledCtx, cancel := context.WithCancel(ctx) + blockingC := make(chan struct{}) + server.rangeLookupFn = func(ctx context.Context, _ *roachpb.RangeLookupRequest) (*roachpb.RangeLookupResponse, error) { + <-blockingC + <-ctx.Done() + return nil, ctx.Err() + } + go func() { + blockingC <- struct{}{} + cancel() + }() + resDescs, resPreDescs, err = p.RangeLookup(canceledCtx, roachpb.RKey("a"), false /* useReverseScan */) + require.Nil(t, resDescs) + require.Nil(t, resPreDescs) + require.Regexp(t, context.Canceled.Error(), err) + + // FirstRange always returns error. + desc, err := p.FirstRange() + require.Nil(t, desc) + require.Regexp(t, "does not have access to FirstRange", err) +} + +// TestProxyRetriesUnreachable tests that Proxy iterates over each of its +// provided addresses and retries until it is able to establish a connection on +// one of them. +func TestProxyRetriesUnreachable(t *testing.T) { + defer leaktest.AfterTest(t)() + + ctx := context.Background() + stopper := stop.NewStopper() + defer stopper.Stop(ctx) + + clock := hlc.NewClock(hlc.UnixNano, time.Nanosecond) + rpcContext := rpc.NewInsecureTestingContext(clock, stopper) + s := rpc.NewServer(rpcContext) + + node1 := &roachpb.NodeDescriptor{NodeID: 1, Address: util.MakeUnresolvedAddr("tcp", "1.1.1.1")} + node2 := &roachpb.NodeDescriptor{NodeID: 2, Address: util.MakeUnresolvedAddr("tcp", "2.2.2.2")} + gossipSubEvents := []*roachpb.GossipSubscriptionEvent{ + gossipEventForNodeDesc(node1), + gossipEventForNodeDesc(node2), + } + gossipSubFn := func(req *roachpb.GossipSubscriptionRequest, stream roachpb.Internal_GossipSubscriptionServer) error { + assert.Len(t, req.Patterns, 1) + assert.Equal(t, "node:.*", req.Patterns[0]) + for _, event := range gossipSubEvents { + if err := stream.Send(event); err != nil { + return err + } + } + <-stream.Context().Done() + return stream.Context().Err() + } + roachpb.RegisterInternalServer(s, &mockServer{gossipSubFn: gossipSubFn}) + // Decompose netutil.ListenAndServeGRPC so we can listen before serving. + ln, err := net.Listen(util.TestAddr.Network(), util.TestAddr.String()) + require.NoError(t, err) + stopper.RunWorker(ctx, func(context.Context) { + <-stopper.ShouldQuiesce() + netutil.FatalIfUnexpected(ln.Close()) + <-stopper.ShouldStop() + s.Stop() + }) + + // Add listen address into list of other bogus addresses. + addrs := []string{"1.1.1.1:9999", ln.Addr().String(), "2.2.2.2:9999"} + p := NewProxy(log.AmbientContext{Tracer: tracing.NewTracer()}, rpcContext, rpcRetryOpts, addrs) + p.rpcDialTimeout = 5 * time.Millisecond // speed up test + + // Start should block until the first GossipSubscription response. + startedC := make(chan error) + go func() { + startedC <- p.Start(ctx) + }() + select { + case err := <-startedC: + t.Fatalf("Start unexpectedly completed with err=%v", err) + case <-time.After(25 * time.Millisecond): + } + + // Begin serving on gRPC server. Proxy should quickly connect + // and complete startup. + stopper.RunWorker(ctx, func(context.Context) { + netutil.FatalIfUnexpected(s.Serve(ln)) + }) + require.NoError(t, <-startedC) + + // Test kvcoord.NodeDescStore impl. Wait for full update first. + waitForNodeDesc(t, p, 2) + desc, err := p.GetNodeDescriptor(1) + require.Equal(t, node1, desc) + require.NoError(t, err) + desc, err = p.GetNodeDescriptor(2) + require.Equal(t, node2, desc) + require.NoError(t, err) + desc, err = p.GetNodeDescriptor(3) + require.Nil(t, desc) + require.Regexp(t, "unable to look up descriptor for n3", err) +} diff --git a/pkg/ccl/logictestccl/logic_test.go b/pkg/ccl/logictestccl/logic_test.go index 2088f3c1c4c0..6757f5e80d4a 100644 --- a/pkg/ccl/logictestccl/logic_test.go +++ b/pkg/ccl/logictestccl/logic_test.go @@ -16,7 +16,19 @@ import ( "github.com/cockroachdb/cockroach/pkg/util/leaktest" ) +const testdataGlob = "testdata/logic_test/[^.]*" +const logictestPkg = "../../sql/logictest/" + func TestCCLLogic(t *testing.T) { defer leaktest.AfterTest(t)() - logictest.RunLogicTest(t, logictest.TestServerArgs{}, "testdata/logic_test/[^.]*") + logictest.RunLogicTest(t, logictest.TestServerArgs{}, testdataGlob) +} + +// TestTenantLogic runs all non-CCL logic test files under the 3node-tenant +// configuration, which constructs a secondary tenant and runs the test within +// that secondary tenant's sandbox. Test files that blocklist the 3node-tenant +// configuration (i.e. "# LogicTest: !3node-tenant") are not run. +func TestTenantLogic(t *testing.T) { + defer leaktest.AfterTest(t)() + logictest.RunLogicTestWithDefaultConfig(t, logictest.TestServerArgs{}, "3node-tenant", logictestPkg+testdataGlob) } diff --git a/pkg/sql/logictest/testdata/logic_test/tenant_unsupported b/pkg/ccl/logictestccl/testdata/logic_test/tenant_unsupported similarity index 100% rename from pkg/sql/logictest/testdata/logic_test/tenant_unsupported rename to pkg/ccl/logictestccl/testdata/logic_test/tenant_unsupported diff --git a/pkg/server/server_sql_test.go b/pkg/ccl/serverccl/server_sql_test.go similarity index 87% rename from pkg/server/server_sql_test.go rename to pkg/ccl/serverccl/server_sql_test.go index f9924fd1277a..0048e31ffd00 100644 --- a/pkg/server/server_sql_test.go +++ b/pkg/ccl/serverccl/server_sql_test.go @@ -1,17 +1,16 @@ // Copyright 2020 The Cockroach Authors. // -// Use of this software is governed by the Business Source License -// included in the file licenses/BSL.txt. +// Licensed as a CockroachDB Enterprise file under the Cockroach Community +// License (the "License"); you may not use this file except in compliance with +// the License. You may obtain a copy of the License at // -// As of the Change Date specified in that file, in accordance with -// the Business Source License, use of this software will be governed -// by the Apache License, Version 2.0, included in the file -// licenses/APL.txt. +// https://github.com/cockroachdb/cockroach/blob/master/licenses/CCL.txt -package server +package serverccl import ( "context" + "errors" "testing" "github.com/cockroachdb/cockroach/pkg/base" @@ -21,7 +20,6 @@ import ( "github.com/cockroachdb/cockroach/pkg/testutils/sqlutils" "github.com/cockroachdb/cockroach/pkg/util/leaktest" "github.com/cockroachdb/cockroach/pkg/util/log" - "github.com/cockroachdb/errors" "github.com/lib/pq" "github.com/stretchr/testify/require" ) diff --git a/pkg/gossip/gossip.go b/pkg/gossip/gossip.go index 278304c0e966..f217d60419b1 100644 --- a/pkg/gossip/gossip.go +++ b/pkg/gossip/gossip.go @@ -1151,19 +1151,18 @@ func (g *Gossip) GetSystemConfig() *config.SystemConfig { // system config. It is notified after registration (if a system config is // already set), and whenever a new system config is successfully unmarshaled. func (g *Gossip) RegisterSystemConfigChannel() <-chan struct{} { - g.systemConfigMu.Lock() - defer g.systemConfigMu.Unlock() - // Create channel that receives new system config notifications. // The channel has a size of 1 to prevent gossip from blocking on it. c := make(chan struct{}, 1) + + g.systemConfigMu.Lock() + defer g.systemConfigMu.Unlock() g.systemConfigChannels = append(g.systemConfigChannels, c) // Notify the channel right away if we have a config. if g.systemConfig != nil { c <- struct{}{} } - return c } diff --git a/pkg/gossip/infostore.go b/pkg/gossip/infostore.go index d1ec956fc459..85ca4f6895ec 100644 --- a/pkg/gossip/infostore.go +++ b/pkg/gossip/infostore.go @@ -310,6 +310,7 @@ func (is *infoStore) registerCallback( if targetCB == cb { numCBs := len(is.callbacks) is.callbacks[i] = is.callbacks[numCBs-1] + is.callbacks[numCBs-1] = nil // for GC is.callbacks = is.callbacks[:numCBs-1] break } diff --git a/pkg/kv/kvclient/kvcoord/range_cache.go b/pkg/kv/kvclient/kvcoord/range_cache.go index c5f584b24cc1..c35c47d0e91f 100644 --- a/pkg/kv/kvclient/kvcoord/range_cache.go +++ b/pkg/kv/kvclient/kvcoord/range_cache.go @@ -65,6 +65,7 @@ type RangeDescriptorDB interface { // FirstRange returns the descriptor for the first Range. This is the // Range containing all meta1 entries. + // TODO(nvanbenschoten): pull this detail in DistSender. FirstRange() (*roachpb.RangeDescriptor, error) } diff --git a/pkg/kv/kvclient/kvcoord/send_test.go b/pkg/kv/kvclient/kvcoord/send_test.go index 08853f882492..63eace631091 100644 --- a/pkg/kv/kvclient/kvcoord/send_test.go +++ b/pkg/kv/kvclient/kvcoord/send_test.go @@ -45,10 +45,22 @@ func (n Node) Batch( return &roachpb.BatchResponse{}, nil } +func (n Node) RangeLookup( + _ context.Context, _ *roachpb.RangeLookupRequest, +) (*roachpb.RangeLookupResponse, error) { + panic("unimplemented") +} + func (n Node) RangeFeed(_ *roachpb.RangeFeedRequest, _ roachpb.Internal_RangeFeedServer) error { panic("unimplemented") } +func (n Node) GossipSubscription( + _ *roachpb.GossipSubscriptionRequest, _ roachpb.Internal_GossipSubscriptionServer, +) error { + panic("unimplemented") +} + // TestSendToOneClient verifies that Send correctly sends a request // to one server using the heartbeat RPC. func TestSendToOneClient(t *testing.T) { diff --git a/pkg/kv/kvclient/kvcoord/transport_test.go b/pkg/kv/kvclient/kvcoord/transport_test.go index c2c3b59b7c98..472e4c8f8c6b 100644 --- a/pkg/kv/kvclient/kvcoord/transport_test.go +++ b/pkg/kv/kvclient/kvcoord/transport_test.go @@ -159,9 +159,23 @@ func (m *mockInternalClient) Batch( return br, nil } +// RangeLookup implements the roachpb.InternalClient interface. +func (m *mockInternalClient) RangeLookup( + ctx context.Context, rl *roachpb.RangeLookupRequest, _ ...grpc.CallOption, +) (*roachpb.RangeLookupResponse, error) { + return nil, fmt.Errorf("unsupported RangeLookup call") +} + // RangeFeed is part of the roachpb.InternalClient interface. func (m *mockInternalClient) RangeFeed( ctx context.Context, in *roachpb.RangeFeedRequest, opts ...grpc.CallOption, ) (roachpb.Internal_RangeFeedClient, error) { return nil, fmt.Errorf("unsupported RangeFeed call") } + +// GossipSubscription is part of the roachpb.InternalClient interface. +func (m *mockInternalClient) GossipSubscription( + ctx context.Context, args *roachpb.GossipSubscriptionRequest, _ ...grpc.CallOption, +) (roachpb.Internal_GossipSubscriptionClient, error) { + return nil, fmt.Errorf("unsupported GossipSubscripion call") +} diff --git a/pkg/kv/kvclient/kvtenant/proxy.go b/pkg/kv/kvclient/kvtenant/proxy.go new file mode 100644 index 000000000000..e191ff9413b7 --- /dev/null +++ b/pkg/kv/kvclient/kvtenant/proxy.go @@ -0,0 +1,64 @@ +// Copyright 2020 The Cockroach Authors. +// +// Use of this software is governed by the Business Source License +// included in the file licenses/BSL.txt. +// +// As of the Change Date specified in that file, in accordance with +// the Business Source License, use of this software will be governed +// by the Apache License, Version 2.0, included in the file +// licenses/APL.txt. + +// Package kvtenant provides utilities required by SQL-only tenant processes in +// order to interact with the key-value layer. +package kvtenant + +import ( + "context" + + "github.com/cockroachdb/cockroach/pkg/kv/kvclient/kvcoord" + "github.com/cockroachdb/cockroach/pkg/rpc" + "github.com/cockroachdb/cockroach/pkg/util/log" + "github.com/cockroachdb/cockroach/pkg/util/retry" + "github.com/cockroachdb/errors" +) + +// Proxy mediates the communication of cluster-wide state to sandboxed SQL-only +// tenant processes through a restricted interface. A Proxy is seeded with a set +// of one or more network addresses that reference existing KV nodes in the +// cluster (or a load-balancer which fans out to some/all KV nodes). On startup, +// it establishes contact with one of these nodes to learn about the topology of +// the cluster and bootstrap the rest of SQL <-> KV network communication. +type Proxy interface { + // Start starts the proxy. + Start(context.Context) error + + // Proxy is capable of providing information on each of the KV nodes in the + // cluster in the form of NodeDescriptors. This obviates the need for SQL-only + // tenant processes to join the cluster-wide gossip network. + kvcoord.NodeDescStore + + // Proxy is capable of providing Range addressing information in the form of + // RangeDescriptors through delegated RangeLookup requests. This is necessary + // because SQL-only tenants are restricted from reading Range Metadata keys + // directly. Instead, the RangeLookup requests are proxied through existing KV + // nodes while being subject to additional validation (e.g. is the Range being + // requested owned by the requesting tenant?). + kvcoord.RangeDescriptorDB +} + +// ProxyFactory constructs a new tenant proxy from the provide network addresses +// pointing to KV nodes. +type ProxyFactory interface { + NewProxy(_ log.AmbientContext, _ *rpc.Context, _ retry.Options, addrs []string) (Proxy, error) +} + +// Factory is a hook for binaries that include CCL code to inject a ProxyFactory. +var Factory ProxyFactory = requiresCCLBinaryFactory{} + +type requiresCCLBinaryFactory struct{} + +func (requiresCCLBinaryFactory) NewProxy( + _ log.AmbientContext, _ *rpc.Context, _ retry.Options, _ []string, +) (Proxy, error) { + return nil, errors.Errorf(`tenant proxy requires a CCL binary`) +} diff --git a/pkg/roachpb/api.pb.go b/pkg/roachpb/api.pb.go index 695f451f21bc..7a3917269b7b 100644 --- a/pkg/roachpb/api.pb.go +++ b/pkg/roachpb/api.pb.go @@ -72,7 +72,7 @@ func (x ReadConsistencyType) String() string { return proto.EnumName(ReadConsistencyType_name, int32(x)) } func (ReadConsistencyType) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{0} + return fileDescriptor_api_bfad9ab5d8946a01, []int{0} } // ScanFormat is an enumeration of the available response formats for MVCCScan @@ -100,7 +100,7 @@ func (x ScanFormat) String() string { return proto.EnumName(ScanFormat_name, int32(x)) } func (ScanFormat) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{1} + return fileDescriptor_api_bfad9ab5d8946a01, []int{1} } type ChecksumMode int32 @@ -147,7 +147,7 @@ func (x ChecksumMode) String() string { return proto.EnumName(ChecksumMode_name, int32(x)) } func (ChecksumMode) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{2} + return fileDescriptor_api_bfad9ab5d8946a01, []int{2} } // PushTxnType determines what action to take when pushing a transaction. @@ -178,7 +178,7 @@ func (x PushTxnType) String() string { return proto.EnumName(PushTxnType_name, int32(x)) } func (PushTxnType) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{3} + return fileDescriptor_api_bfad9ab5d8946a01, []int{3} } type ExternalStorageProvider int32 @@ -219,7 +219,7 @@ func (x ExternalStorageProvider) String() string { return proto.EnumName(ExternalStorageProvider_name, int32(x)) } func (ExternalStorageProvider) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{4} + return fileDescriptor_api_bfad9ab5d8946a01, []int{4} } type MVCCFilter int32 @@ -242,7 +242,7 @@ func (x MVCCFilter) String() string { return proto.EnumName(MVCCFilter_name, int32(x)) } func (MVCCFilter) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{5} + return fileDescriptor_api_bfad9ab5d8946a01, []int{5} } type ResponseHeader_ResumeReason int32 @@ -268,7 +268,7 @@ func (x ResponseHeader_ResumeReason) String() string { return proto.EnumName(ResponseHeader_ResumeReason_name, int32(x)) } func (ResponseHeader_ResumeReason) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{1, 0} + return fileDescriptor_api_bfad9ab5d8946a01, []int{1, 0} } type CheckConsistencyResponse_Status int32 @@ -310,7 +310,7 @@ func (x CheckConsistencyResponse_Status) String() string { return proto.EnumName(CheckConsistencyResponse_Status_name, int32(x)) } func (CheckConsistencyResponse_Status) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{25, 0} + return fileDescriptor_api_bfad9ab5d8946a01, []int{25, 0} } // RequestHeader is supplied with every storage node request. @@ -331,7 +331,7 @@ func (m *RequestHeader) Reset() { *m = RequestHeader{} } func (m *RequestHeader) String() string { return proto.CompactTextString(m) } func (*RequestHeader) ProtoMessage() {} func (*RequestHeader) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{0} + return fileDescriptor_api_bfad9ab5d8946a01, []int{0} } func (m *RequestHeader) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -402,7 +402,7 @@ func (m *ResponseHeader) Reset() { *m = ResponseHeader{} } func (m *ResponseHeader) String() string { return proto.CompactTextString(m) } func (*ResponseHeader) ProtoMessage() {} func (*ResponseHeader) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{1} + return fileDescriptor_api_bfad9ab5d8946a01, []int{1} } func (m *ResponseHeader) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -436,7 +436,7 @@ func (m *GetRequest) Reset() { *m = GetRequest{} } func (m *GetRequest) String() string { return proto.CompactTextString(m) } func (*GetRequest) ProtoMessage() {} func (*GetRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{2} + return fileDescriptor_api_bfad9ab5d8946a01, []int{2} } func (m *GetRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -479,7 +479,7 @@ func (m *GetResponse) Reset() { *m = GetResponse{} } func (m *GetResponse) String() string { return proto.CompactTextString(m) } func (*GetResponse) ProtoMessage() {} func (*GetResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{3} + return fileDescriptor_api_bfad9ab5d8946a01, []int{3} } func (m *GetResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -522,7 +522,7 @@ func (m *PutRequest) Reset() { *m = PutRequest{} } func (m *PutRequest) String() string { return proto.CompactTextString(m) } func (*PutRequest) ProtoMessage() {} func (*PutRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{4} + return fileDescriptor_api_bfad9ab5d8946a01, []int{4} } func (m *PutRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -556,7 +556,7 @@ func (m *PutResponse) Reset() { *m = PutResponse{} } func (m *PutResponse) String() string { return proto.CompactTextString(m) } func (*PutResponse) ProtoMessage() {} func (*PutResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{5} + return fileDescriptor_api_bfad9ab5d8946a01, []int{5} } func (m *PutResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -638,7 +638,7 @@ func (m *ConditionalPutRequest) Reset() { *m = ConditionalPutRequest{} } func (m *ConditionalPutRequest) String() string { return proto.CompactTextString(m) } func (*ConditionalPutRequest) ProtoMessage() {} func (*ConditionalPutRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{6} + return fileDescriptor_api_bfad9ab5d8946a01, []int{6} } func (m *ConditionalPutRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -673,7 +673,7 @@ func (m *ConditionalPutResponse) Reset() { *m = ConditionalPutResponse{} func (m *ConditionalPutResponse) String() string { return proto.CompactTextString(m) } func (*ConditionalPutResponse) ProtoMessage() {} func (*ConditionalPutResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{7} + return fileDescriptor_api_bfad9ab5d8946a01, []int{7} } func (m *ConditionalPutResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -719,7 +719,7 @@ func (m *InitPutRequest) Reset() { *m = InitPutRequest{} } func (m *InitPutRequest) String() string { return proto.CompactTextString(m) } func (*InitPutRequest) ProtoMessage() {} func (*InitPutRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{8} + return fileDescriptor_api_bfad9ab5d8946a01, []int{8} } func (m *InitPutRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -753,7 +753,7 @@ func (m *InitPutResponse) Reset() { *m = InitPutResponse{} } func (m *InitPutResponse) String() string { return proto.CompactTextString(m) } func (*InitPutResponse) ProtoMessage() {} func (*InitPutResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{9} + return fileDescriptor_api_bfad9ab5d8946a01, []int{9} } func (m *InitPutResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -793,7 +793,7 @@ func (m *IncrementRequest) Reset() { *m = IncrementRequest{} } func (m *IncrementRequest) String() string { return proto.CompactTextString(m) } func (*IncrementRequest) ProtoMessage() {} func (*IncrementRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{10} + return fileDescriptor_api_bfad9ab5d8946a01, []int{10} } func (m *IncrementRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -830,7 +830,7 @@ func (m *IncrementResponse) Reset() { *m = IncrementResponse{} } func (m *IncrementResponse) String() string { return proto.CompactTextString(m) } func (*IncrementResponse) ProtoMessage() {} func (*IncrementResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{11} + return fileDescriptor_api_bfad9ab5d8946a01, []int{11} } func (m *IncrementResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -864,7 +864,7 @@ func (m *DeleteRequest) Reset() { *m = DeleteRequest{} } func (m *DeleteRequest) String() string { return proto.CompactTextString(m) } func (*DeleteRequest) ProtoMessage() {} func (*DeleteRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{12} + return fileDescriptor_api_bfad9ab5d8946a01, []int{12} } func (m *DeleteRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -898,7 +898,7 @@ func (m *DeleteResponse) Reset() { *m = DeleteResponse{} } func (m *DeleteResponse) String() string { return proto.CompactTextString(m) } func (*DeleteResponse) ProtoMessage() {} func (*DeleteResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{13} + return fileDescriptor_api_bfad9ab5d8946a01, []int{13} } func (m *DeleteResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -950,7 +950,7 @@ func (m *DeleteRangeRequest) Reset() { *m = DeleteRangeRequest{} } func (m *DeleteRangeRequest) String() string { return proto.CompactTextString(m) } func (*DeleteRangeRequest) ProtoMessage() {} func (*DeleteRangeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{14} + return fileDescriptor_api_bfad9ab5d8946a01, []int{14} } func (m *DeleteRangeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -987,7 +987,7 @@ func (m *DeleteRangeResponse) Reset() { *m = DeleteRangeResponse{} } func (m *DeleteRangeResponse) String() string { return proto.CompactTextString(m) } func (*DeleteRangeResponse) ProtoMessage() {} func (*DeleteRangeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{15} + return fileDescriptor_api_bfad9ab5d8946a01, []int{15} } func (m *DeleteRangeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1034,7 +1034,7 @@ func (m *ClearRangeRequest) Reset() { *m = ClearRangeRequest{} } func (m *ClearRangeRequest) String() string { return proto.CompactTextString(m) } func (*ClearRangeRequest) ProtoMessage() {} func (*ClearRangeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{16} + return fileDescriptor_api_bfad9ab5d8946a01, []int{16} } func (m *ClearRangeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1068,7 +1068,7 @@ func (m *ClearRangeResponse) Reset() { *m = ClearRangeResponse{} } func (m *ClearRangeResponse) String() string { return proto.CompactTextString(m) } func (*ClearRangeResponse) ProtoMessage() {} func (*ClearRangeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{17} + return fileDescriptor_api_bfad9ab5d8946a01, []int{17} } func (m *ClearRangeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1109,7 +1109,7 @@ func (m *RevertRangeRequest) Reset() { *m = RevertRangeRequest{} } func (m *RevertRangeRequest) String() string { return proto.CompactTextString(m) } func (*RevertRangeRequest) ProtoMessage() {} func (*RevertRangeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{18} + return fileDescriptor_api_bfad9ab5d8946a01, []int{18} } func (m *RevertRangeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1143,7 +1143,7 @@ func (m *RevertRangeResponse) Reset() { *m = RevertRangeResponse{} } func (m *RevertRangeResponse) String() string { return proto.CompactTextString(m) } func (*RevertRangeResponse) ProtoMessage() {} func (*RevertRangeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{19} + return fileDescriptor_api_bfad9ab5d8946a01, []int{19} } func (m *RevertRangeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1194,7 +1194,7 @@ func (m *ScanRequest) Reset() { *m = ScanRequest{} } func (m *ScanRequest) String() string { return proto.CompactTextString(m) } func (*ScanRequest) ProtoMessage() {} func (*ScanRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{20} + return fileDescriptor_api_bfad9ab5d8946a01, []int{20} } func (m *ScanRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1246,7 +1246,7 @@ func (m *ScanResponse) Reset() { *m = ScanResponse{} } func (m *ScanResponse) String() string { return proto.CompactTextString(m) } func (*ScanResponse) ProtoMessage() {} func (*ScanResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{21} + return fileDescriptor_api_bfad9ab5d8946a01, []int{21} } func (m *ScanResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1297,7 +1297,7 @@ func (m *ReverseScanRequest) Reset() { *m = ReverseScanRequest{} } func (m *ReverseScanRequest) String() string { return proto.CompactTextString(m) } func (*ReverseScanRequest) ProtoMessage() {} func (*ReverseScanRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{22} + return fileDescriptor_api_bfad9ab5d8946a01, []int{22} } func (m *ReverseScanRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1349,7 +1349,7 @@ func (m *ReverseScanResponse) Reset() { *m = ReverseScanResponse{} } func (m *ReverseScanResponse) String() string { return proto.CompactTextString(m) } func (*ReverseScanResponse) ProtoMessage() {} func (*ReverseScanResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{23} + return fileDescriptor_api_bfad9ab5d8946a01, []int{23} } func (m *ReverseScanResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1402,7 +1402,7 @@ func (m *CheckConsistencyRequest) Reset() { *m = CheckConsistencyRequest func (m *CheckConsistencyRequest) String() string { return proto.CompactTextString(m) } func (*CheckConsistencyRequest) ProtoMessage() {} func (*CheckConsistencyRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{24} + return fileDescriptor_api_bfad9ab5d8946a01, []int{24} } func (m *CheckConsistencyRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1439,7 +1439,7 @@ func (m *CheckConsistencyResponse) Reset() { *m = CheckConsistencyRespon func (m *CheckConsistencyResponse) String() string { return proto.CompactTextString(m) } func (*CheckConsistencyResponse) ProtoMessage() {} func (*CheckConsistencyResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{25} + return fileDescriptor_api_bfad9ab5d8946a01, []int{25} } func (m *CheckConsistencyResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1483,7 +1483,7 @@ func (m *CheckConsistencyResponse_Result) Reset() { *m = CheckConsistenc func (m *CheckConsistencyResponse_Result) String() string { return proto.CompactTextString(m) } func (*CheckConsistencyResponse_Result) ProtoMessage() {} func (*CheckConsistencyResponse_Result) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{25, 0} + return fileDescriptor_api_bfad9ab5d8946a01, []int{25, 0} } func (m *CheckConsistencyResponse_Result) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1531,7 +1531,7 @@ func (m *RecomputeStatsRequest) Reset() { *m = RecomputeStatsRequest{} } func (m *RecomputeStatsRequest) String() string { return proto.CompactTextString(m) } func (*RecomputeStatsRequest) ProtoMessage() {} func (*RecomputeStatsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{26} + return fileDescriptor_api_bfad9ab5d8946a01, []int{26} } func (m *RecomputeStatsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1567,7 +1567,7 @@ func (m *RecomputeStatsResponse) Reset() { *m = RecomputeStatsResponse{} func (m *RecomputeStatsResponse) String() string { return proto.CompactTextString(m) } func (*RecomputeStatsResponse) ProtoMessage() {} func (*RecomputeStatsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{27} + return fileDescriptor_api_bfad9ab5d8946a01, []int{27} } func (m *RecomputeStatsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1664,7 +1664,7 @@ func (m *EndTxnRequest) Reset() { *m = EndTxnRequest{} } func (m *EndTxnRequest) String() string { return proto.CompactTextString(m) } func (*EndTxnRequest) ProtoMessage() {} func (*EndTxnRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{28} + return fileDescriptor_api_bfad9ab5d8946a01, []int{28} } func (m *EndTxnRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1710,7 +1710,7 @@ func (m *EndTxnResponse) Reset() { *m = EndTxnResponse{} } func (m *EndTxnResponse) String() string { return proto.CompactTextString(m) } func (*EndTxnResponse) ProtoMessage() {} func (*EndTxnResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{29} + return fileDescriptor_api_bfad9ab5d8946a01, []int{29} } func (m *EndTxnResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1771,7 +1771,7 @@ func (m *AdminSplitRequest) Reset() { *m = AdminSplitRequest{} } func (m *AdminSplitRequest) String() string { return proto.CompactTextString(m) } func (*AdminSplitRequest) ProtoMessage() {} func (*AdminSplitRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{30} + return fileDescriptor_api_bfad9ab5d8946a01, []int{30} } func (m *AdminSplitRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1806,7 +1806,7 @@ func (m *AdminSplitResponse) Reset() { *m = AdminSplitResponse{} } func (m *AdminSplitResponse) String() string { return proto.CompactTextString(m) } func (*AdminSplitResponse) ProtoMessage() {} func (*AdminSplitResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{31} + return fileDescriptor_api_bfad9ab5d8946a01, []int{31} } func (m *AdminSplitResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1845,7 +1845,7 @@ func (m *AdminUnsplitRequest) Reset() { *m = AdminUnsplitRequest{} } func (m *AdminUnsplitRequest) String() string { return proto.CompactTextString(m) } func (*AdminUnsplitRequest) ProtoMessage() {} func (*AdminUnsplitRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{32} + return fileDescriptor_api_bfad9ab5d8946a01, []int{32} } func (m *AdminUnsplitRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1880,7 +1880,7 @@ func (m *AdminUnsplitResponse) Reset() { *m = AdminUnsplitResponse{} } func (m *AdminUnsplitResponse) String() string { return proto.CompactTextString(m) } func (*AdminUnsplitResponse) ProtoMessage() {} func (*AdminUnsplitResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{33} + return fileDescriptor_api_bfad9ab5d8946a01, []int{33} } func (m *AdminUnsplitResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1923,7 +1923,7 @@ func (m *AdminMergeRequest) Reset() { *m = AdminMergeRequest{} } func (m *AdminMergeRequest) String() string { return proto.CompactTextString(m) } func (*AdminMergeRequest) ProtoMessage() {} func (*AdminMergeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{34} + return fileDescriptor_api_bfad9ab5d8946a01, []int{34} } func (m *AdminMergeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1958,7 +1958,7 @@ func (m *AdminMergeResponse) Reset() { *m = AdminMergeResponse{} } func (m *AdminMergeResponse) String() string { return proto.CompactTextString(m) } func (*AdminMergeResponse) ProtoMessage() {} func (*AdminMergeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{35} + return fileDescriptor_api_bfad9ab5d8946a01, []int{35} } func (m *AdminMergeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1996,7 +1996,7 @@ func (m *AdminTransferLeaseRequest) Reset() { *m = AdminTransferLeaseReq func (m *AdminTransferLeaseRequest) String() string { return proto.CompactTextString(m) } func (*AdminTransferLeaseRequest) ProtoMessage() {} func (*AdminTransferLeaseRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{36} + return fileDescriptor_api_bfad9ab5d8946a01, []int{36} } func (m *AdminTransferLeaseRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2029,7 +2029,7 @@ func (m *AdminTransferLeaseResponse) Reset() { *m = AdminTransferLeaseRe func (m *AdminTransferLeaseResponse) String() string { return proto.CompactTextString(m) } func (*AdminTransferLeaseResponse) ProtoMessage() {} func (*AdminTransferLeaseResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{37} + return fileDescriptor_api_bfad9ab5d8946a01, []int{37} } func (m *AdminTransferLeaseResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2064,7 +2064,7 @@ func (m *ReplicationChange) Reset() { *m = ReplicationChange{} } func (m *ReplicationChange) String() string { return proto.CompactTextString(m) } func (*ReplicationChange) ProtoMessage() {} func (*ReplicationChange) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{38} + return fileDescriptor_api_bfad9ab5d8946a01, []int{38} } func (m *ReplicationChange) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2122,7 +2122,7 @@ func (m *AdminChangeReplicasRequest) Reset() { *m = AdminChangeReplicasR func (m *AdminChangeReplicasRequest) String() string { return proto.CompactTextString(m) } func (*AdminChangeReplicasRequest) ProtoMessage() {} func (*AdminChangeReplicasRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{39} + return fileDescriptor_api_bfad9ab5d8946a01, []int{39} } func (m *AdminChangeReplicasRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2157,7 +2157,7 @@ func (m *AdminChangeReplicasResponse) Reset() { *m = AdminChangeReplicas func (m *AdminChangeReplicasResponse) String() string { return proto.CompactTextString(m) } func (*AdminChangeReplicasResponse) ProtoMessage() {} func (*AdminChangeReplicasResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{40} + return fileDescriptor_api_bfad9ab5d8946a01, []int{40} } func (m *AdminChangeReplicasResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2194,7 +2194,7 @@ func (m *AdminRelocateRangeRequest) Reset() { *m = AdminRelocateRangeReq func (m *AdminRelocateRangeRequest) String() string { return proto.CompactTextString(m) } func (*AdminRelocateRangeRequest) ProtoMessage() {} func (*AdminRelocateRangeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{41} + return fileDescriptor_api_bfad9ab5d8946a01, []int{41} } func (m *AdminRelocateRangeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2227,7 +2227,7 @@ func (m *AdminRelocateRangeResponse) Reset() { *m = AdminRelocateRangeRe func (m *AdminRelocateRangeResponse) String() string { return proto.CompactTextString(m) } func (*AdminRelocateRangeResponse) ProtoMessage() {} func (*AdminRelocateRangeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{42} + return fileDescriptor_api_bfad9ab5d8946a01, []int{42} } func (m *AdminRelocateRangeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2266,7 +2266,7 @@ func (m *HeartbeatTxnRequest) Reset() { *m = HeartbeatTxnRequest{} } func (m *HeartbeatTxnRequest) String() string { return proto.CompactTextString(m) } func (*HeartbeatTxnRequest) ProtoMessage() {} func (*HeartbeatTxnRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{43} + return fileDescriptor_api_bfad9ab5d8946a01, []int{43} } func (m *HeartbeatTxnRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2303,7 +2303,7 @@ func (m *HeartbeatTxnResponse) Reset() { *m = HeartbeatTxnResponse{} } func (m *HeartbeatTxnResponse) String() string { return proto.CompactTextString(m) } func (*HeartbeatTxnResponse) ProtoMessage() {} func (*HeartbeatTxnResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{44} + return fileDescriptor_api_bfad9ab5d8946a01, []int{44} } func (m *HeartbeatTxnResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2341,7 +2341,7 @@ func (m *GCRequest) Reset() { *m = GCRequest{} } func (m *GCRequest) String() string { return proto.CompactTextString(m) } func (*GCRequest) ProtoMessage() {} func (*GCRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{45} + return fileDescriptor_api_bfad9ab5d8946a01, []int{45} } func (m *GCRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2375,7 +2375,7 @@ func (m *GCRequest_GCKey) Reset() { *m = GCRequest_GCKey{} } func (m *GCRequest_GCKey) String() string { return proto.CompactTextString(m) } func (*GCRequest_GCKey) ProtoMessage() {} func (*GCRequest_GCKey) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{45, 0} + return fileDescriptor_api_bfad9ab5d8946a01, []int{45, 0} } func (m *GCRequest_GCKey) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2409,7 +2409,7 @@ func (m *GCResponse) Reset() { *m = GCResponse{} } func (m *GCResponse) String() string { return proto.CompactTextString(m) } func (*GCResponse) ProtoMessage() {} func (*GCResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{46} + return fileDescriptor_api_bfad9ab5d8946a01, []int{46} } func (m *GCResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2478,7 +2478,7 @@ func (m *PushTxnRequest) Reset() { *m = PushTxnRequest{} } func (m *PushTxnRequest) String() string { return proto.CompactTextString(m) } func (*PushTxnRequest) ProtoMessage() {} func (*PushTxnRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{47} + return fileDescriptor_api_bfad9ab5d8946a01, []int{47} } func (m *PushTxnRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2521,7 +2521,7 @@ func (m *PushTxnResponse) Reset() { *m = PushTxnResponse{} } func (m *PushTxnResponse) String() string { return proto.CompactTextString(m) } func (*PushTxnResponse) ProtoMessage() {} func (*PushTxnResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{48} + return fileDescriptor_api_bfad9ab5d8946a01, []int{48} } func (m *PushTxnResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2568,7 +2568,7 @@ func (m *RecoverTxnRequest) Reset() { *m = RecoverTxnRequest{} } func (m *RecoverTxnRequest) String() string { return proto.CompactTextString(m) } func (*RecoverTxnRequest) ProtoMessage() {} func (*RecoverTxnRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{49} + return fileDescriptor_api_bfad9ab5d8946a01, []int{49} } func (m *RecoverTxnRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2604,7 +2604,7 @@ func (m *RecoverTxnResponse) Reset() { *m = RecoverTxnResponse{} } func (m *RecoverTxnResponse) String() string { return proto.CompactTextString(m) } func (*RecoverTxnResponse) ProtoMessage() {} func (*RecoverTxnResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{50} + return fileDescriptor_api_bfad9ab5d8946a01, []int{50} } func (m *RecoverTxnResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2648,7 +2648,7 @@ func (m *QueryTxnRequest) Reset() { *m = QueryTxnRequest{} } func (m *QueryTxnRequest) String() string { return proto.CompactTextString(m) } func (*QueryTxnRequest) ProtoMessage() {} func (*QueryTxnRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{51} + return fileDescriptor_api_bfad9ab5d8946a01, []int{51} } func (m *QueryTxnRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2687,7 +2687,7 @@ func (m *QueryTxnResponse) Reset() { *m = QueryTxnResponse{} } func (m *QueryTxnResponse) String() string { return proto.CompactTextString(m) } func (*QueryTxnResponse) ProtoMessage() {} func (*QueryTxnResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{52} + return fileDescriptor_api_bfad9ab5d8946a01, []int{52} } func (m *QueryTxnResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2747,7 +2747,7 @@ func (m *QueryIntentRequest) Reset() { *m = QueryIntentRequest{} } func (m *QueryIntentRequest) String() string { return proto.CompactTextString(m) } func (*QueryIntentRequest) ProtoMessage() {} func (*QueryIntentRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{53} + return fileDescriptor_api_bfad9ab5d8946a01, []int{53} } func (m *QueryIntentRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2783,7 +2783,7 @@ func (m *QueryIntentResponse) Reset() { *m = QueryIntentResponse{} } func (m *QueryIntentResponse) String() string { return proto.CompactTextString(m) } func (*QueryIntentResponse) ProtoMessage() {} func (*QueryIntentResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{54} + return fileDescriptor_api_bfad9ab5d8946a01, []int{54} } func (m *QueryIntentResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2829,7 +2829,7 @@ func (m *ResolveIntentRequest) Reset() { *m = ResolveIntentRequest{} } func (m *ResolveIntentRequest) String() string { return proto.CompactTextString(m) } func (*ResolveIntentRequest) ProtoMessage() {} func (*ResolveIntentRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{55} + return fileDescriptor_api_bfad9ab5d8946a01, []int{55} } func (m *ResolveIntentRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2864,7 +2864,7 @@ func (m *ResolveIntentResponse) Reset() { *m = ResolveIntentResponse{} } func (m *ResolveIntentResponse) String() string { return proto.CompactTextString(m) } func (*ResolveIntentResponse) ProtoMessage() {} func (*ResolveIntentResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{56} + return fileDescriptor_api_bfad9ab5d8946a01, []int{56} } func (m *ResolveIntentResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2914,7 +2914,7 @@ func (m *ResolveIntentRangeRequest) Reset() { *m = ResolveIntentRangeReq func (m *ResolveIntentRangeRequest) String() string { return proto.CompactTextString(m) } func (*ResolveIntentRangeRequest) ProtoMessage() {} func (*ResolveIntentRangeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{57} + return fileDescriptor_api_bfad9ab5d8946a01, []int{57} } func (m *ResolveIntentRangeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2949,7 +2949,7 @@ func (m *ResolveIntentRangeResponse) Reset() { *m = ResolveIntentRangeRe func (m *ResolveIntentRangeResponse) String() string { return proto.CompactTextString(m) } func (*ResolveIntentRangeResponse) ProtoMessage() {} func (*ResolveIntentRangeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{58} + return fileDescriptor_api_bfad9ab5d8946a01, []int{58} } func (m *ResolveIntentRangeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2986,7 +2986,7 @@ func (m *MergeRequest) Reset() { *m = MergeRequest{} } func (m *MergeRequest) String() string { return proto.CompactTextString(m) } func (*MergeRequest) ProtoMessage() {} func (*MergeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{59} + return fileDescriptor_api_bfad9ab5d8946a01, []int{59} } func (m *MergeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3020,7 +3020,7 @@ func (m *MergeResponse) Reset() { *m = MergeResponse{} } func (m *MergeResponse) String() string { return proto.CompactTextString(m) } func (*MergeResponse) ProtoMessage() {} func (*MergeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{60} + return fileDescriptor_api_bfad9ab5d8946a01, []int{60} } func (m *MergeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3065,7 +3065,7 @@ func (m *TruncateLogRequest) Reset() { *m = TruncateLogRequest{} } func (m *TruncateLogRequest) String() string { return proto.CompactTextString(m) } func (*TruncateLogRequest) ProtoMessage() {} func (*TruncateLogRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{61} + return fileDescriptor_api_bfad9ab5d8946a01, []int{61} } func (m *TruncateLogRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3099,7 +3099,7 @@ func (m *TruncateLogResponse) Reset() { *m = TruncateLogResponse{} } func (m *TruncateLogResponse) String() string { return proto.CompactTextString(m) } func (*TruncateLogResponse) ProtoMessage() {} func (*TruncateLogResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{62} + return fileDescriptor_api_bfad9ab5d8946a01, []int{62} } func (m *TruncateLogResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3143,7 +3143,7 @@ func (m *RequestLeaseRequest) Reset() { *m = RequestLeaseRequest{} } func (m *RequestLeaseRequest) String() string { return proto.CompactTextString(m) } func (*RequestLeaseRequest) ProtoMessage() {} func (*RequestLeaseRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{63} + return fileDescriptor_api_bfad9ab5d8946a01, []int{63} } func (m *RequestLeaseRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3192,7 +3192,7 @@ func (m *TransferLeaseRequest) Reset() { *m = TransferLeaseRequest{} } func (m *TransferLeaseRequest) String() string { return proto.CompactTextString(m) } func (*TransferLeaseRequest) ProtoMessage() {} func (*TransferLeaseRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{64} + return fileDescriptor_api_bfad9ab5d8946a01, []int{64} } func (m *TransferLeaseRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3229,7 +3229,7 @@ func (m *LeaseInfoRequest) Reset() { *m = LeaseInfoRequest{} } func (m *LeaseInfoRequest) String() string { return proto.CompactTextString(m) } func (*LeaseInfoRequest) ProtoMessage() {} func (*LeaseInfoRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{65} + return fileDescriptor_api_bfad9ab5d8946a01, []int{65} } func (m *LeaseInfoRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3266,7 +3266,7 @@ func (m *LeaseInfoResponse) Reset() { *m = LeaseInfoResponse{} } func (m *LeaseInfoResponse) String() string { return proto.CompactTextString(m) } func (*LeaseInfoResponse) ProtoMessage() {} func (*LeaseInfoResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{66} + return fileDescriptor_api_bfad9ab5d8946a01, []int{66} } func (m *LeaseInfoResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3301,7 +3301,7 @@ func (m *RequestLeaseResponse) Reset() { *m = RequestLeaseResponse{} } func (m *RequestLeaseResponse) String() string { return proto.CompactTextString(m) } func (*RequestLeaseResponse) ProtoMessage() {} func (*RequestLeaseResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{67} + return fileDescriptor_api_bfad9ab5d8946a01, []int{67} } func (m *RequestLeaseResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3356,7 +3356,7 @@ func (m *ComputeChecksumRequest) Reset() { *m = ComputeChecksumRequest{} func (m *ComputeChecksumRequest) String() string { return proto.CompactTextString(m) } func (*ComputeChecksumRequest) ProtoMessage() {} func (*ComputeChecksumRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{68} + return fileDescriptor_api_bfad9ab5d8946a01, []int{68} } func (m *ComputeChecksumRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3393,7 +3393,7 @@ func (m *ComputeChecksumResponse) Reset() { *m = ComputeChecksumResponse func (m *ComputeChecksumResponse) String() string { return proto.CompactTextString(m) } func (*ComputeChecksumResponse) ProtoMessage() {} func (*ComputeChecksumResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{69} + return fileDescriptor_api_bfad9ab5d8946a01, []int{69} } func (m *ComputeChecksumResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3433,7 +3433,7 @@ func (m *ExternalStorage) Reset() { *m = ExternalStorage{} } func (m *ExternalStorage) String() string { return proto.CompactTextString(m) } func (*ExternalStorage) ProtoMessage() {} func (*ExternalStorage) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{70} + return fileDescriptor_api_bfad9ab5d8946a01, []int{70} } func (m *ExternalStorage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3467,7 +3467,7 @@ func (m *ExternalStorage_LocalFilePath) Reset() { *m = ExternalStorage_L func (m *ExternalStorage_LocalFilePath) String() string { return proto.CompactTextString(m) } func (*ExternalStorage_LocalFilePath) ProtoMessage() {} func (*ExternalStorage_LocalFilePath) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{70, 0} + return fileDescriptor_api_bfad9ab5d8946a01, []int{70, 0} } func (m *ExternalStorage_LocalFilePath) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3500,7 +3500,7 @@ func (m *ExternalStorage_Http) Reset() { *m = ExternalStorage_Http{} } func (m *ExternalStorage_Http) String() string { return proto.CompactTextString(m) } func (*ExternalStorage_Http) ProtoMessage() {} func (*ExternalStorage_Http) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{70, 1} + return fileDescriptor_api_bfad9ab5d8946a01, []int{70, 1} } func (m *ExternalStorage_Http) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3540,7 +3540,7 @@ func (m *ExternalStorage_S3) Reset() { *m = ExternalStorage_S3{} } func (m *ExternalStorage_S3) String() string { return proto.CompactTextString(m) } func (*ExternalStorage_S3) ProtoMessage() {} func (*ExternalStorage_S3) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{70, 2} + return fileDescriptor_api_bfad9ab5d8946a01, []int{70, 2} } func (m *ExternalStorage_S3) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3579,7 +3579,7 @@ func (m *ExternalStorage_GCS) Reset() { *m = ExternalStorage_GCS{} } func (m *ExternalStorage_GCS) String() string { return proto.CompactTextString(m) } func (*ExternalStorage_GCS) ProtoMessage() {} func (*ExternalStorage_GCS) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{70, 3} + return fileDescriptor_api_bfad9ab5d8946a01, []int{70, 3} } func (m *ExternalStorage_GCS) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3615,7 +3615,7 @@ func (m *ExternalStorage_Azure) Reset() { *m = ExternalStorage_Azure{} } func (m *ExternalStorage_Azure) String() string { return proto.CompactTextString(m) } func (*ExternalStorage_Azure) ProtoMessage() {} func (*ExternalStorage_Azure) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{70, 4} + return fileDescriptor_api_bfad9ab5d8946a01, []int{70, 4} } func (m *ExternalStorage_Azure) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3654,7 +3654,7 @@ func (m *ExternalStorage_Workload) Reset() { *m = ExternalStorage_Worklo func (m *ExternalStorage_Workload) String() string { return proto.CompactTextString(m) } func (*ExternalStorage_Workload) ProtoMessage() {} func (*ExternalStorage_Workload) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{70, 5} + return fileDescriptor_api_bfad9ab5d8946a01, []int{70, 5} } func (m *ExternalStorage_Workload) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3694,7 +3694,7 @@ func (m *ExternalStorage_FileTable) Reset() { *m = ExternalStorage_FileT func (m *ExternalStorage_FileTable) String() string { return proto.CompactTextString(m) } func (*ExternalStorage_FileTable) ProtoMessage() {} func (*ExternalStorage_FileTable) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{70, 6} + return fileDescriptor_api_bfad9ab5d8946a01, []int{70, 6} } func (m *ExternalStorage_FileTable) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3734,7 +3734,7 @@ func (m *WriteBatchRequest) Reset() { *m = WriteBatchRequest{} } func (m *WriteBatchRequest) String() string { return proto.CompactTextString(m) } func (*WriteBatchRequest) ProtoMessage() {} func (*WriteBatchRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{71} + return fileDescriptor_api_bfad9ab5d8946a01, []int{71} } func (m *WriteBatchRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3768,7 +3768,7 @@ func (m *WriteBatchResponse) Reset() { *m = WriteBatchResponse{} } func (m *WriteBatchResponse) String() string { return proto.CompactTextString(m) } func (*WriteBatchResponse) ProtoMessage() {} func (*WriteBatchResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{72} + return fileDescriptor_api_bfad9ab5d8946a01, []int{72} } func (m *WriteBatchResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3802,7 +3802,7 @@ func (m *FileEncryptionOptions) Reset() { *m = FileEncryptionOptions{} } func (m *FileEncryptionOptions) String() string { return proto.CompactTextString(m) } func (*FileEncryptionOptions) ProtoMessage() {} func (*FileEncryptionOptions) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{73} + return fileDescriptor_api_bfad9ab5d8946a01, []int{73} } func (m *FileEncryptionOptions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3872,7 +3872,7 @@ func (m *ExportRequest) Reset() { *m = ExportRequest{} } func (m *ExportRequest) String() string { return proto.CompactTextString(m) } func (*ExportRequest) ProtoMessage() {} func (*ExportRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{74} + return fileDescriptor_api_bfad9ab5d8946a01, []int{74} } func (m *ExportRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3924,7 +3924,7 @@ func (m *BulkOpSummary) Reset() { *m = BulkOpSummary{} } func (m *BulkOpSummary) String() string { return proto.CompactTextString(m) } func (*BulkOpSummary) ProtoMessage() {} func (*BulkOpSummary) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{75} + return fileDescriptor_api_bfad9ab5d8946a01, []int{75} } func (m *BulkOpSummary) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3960,7 +3960,7 @@ func (m *ExportResponse) Reset() { *m = ExportResponse{} } func (m *ExportResponse) String() string { return proto.CompactTextString(m) } func (*ExportResponse) ProtoMessage() {} func (*ExportResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{76} + return fileDescriptor_api_bfad9ab5d8946a01, []int{76} } func (m *ExportResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4000,7 +4000,7 @@ func (m *ExportResponse_File) Reset() { *m = ExportResponse_File{} } func (m *ExportResponse_File) String() string { return proto.CompactTextString(m) } func (*ExportResponse_File) ProtoMessage() {} func (*ExportResponse_File) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{76, 0} + return fileDescriptor_api_bfad9ab5d8946a01, []int{76, 0} } func (m *ExportResponse_File) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4051,7 +4051,7 @@ func (m *ImportRequest) Reset() { *m = ImportRequest{} } func (m *ImportRequest) String() string { return proto.CompactTextString(m) } func (*ImportRequest) ProtoMessage() {} func (*ImportRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{77} + return fileDescriptor_api_bfad9ab5d8946a01, []int{77} } func (m *ImportRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4086,7 +4086,7 @@ func (m *ImportRequest_File) Reset() { *m = ImportRequest_File{} } func (m *ImportRequest_File) String() string { return proto.CompactTextString(m) } func (*ImportRequest_File) ProtoMessage() {} func (*ImportRequest_File) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{77, 0} + return fileDescriptor_api_bfad9ab5d8946a01, []int{77, 0} } func (m *ImportRequest_File) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4122,7 +4122,7 @@ func (m *ImportRequest_TableRekey) Reset() { *m = ImportRequest_TableRek func (m *ImportRequest_TableRekey) String() string { return proto.CompactTextString(m) } func (*ImportRequest_TableRekey) ProtoMessage() {} func (*ImportRequest_TableRekey) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{77, 1} + return fileDescriptor_api_bfad9ab5d8946a01, []int{77, 1} } func (m *ImportRequest_TableRekey) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4157,7 +4157,7 @@ func (m *ImportResponse) Reset() { *m = ImportResponse{} } func (m *ImportResponse) String() string { return proto.CompactTextString(m) } func (*ImportResponse) ProtoMessage() {} func (*ImportResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{78} + return fileDescriptor_api_bfad9ab5d8946a01, []int{78} } func (m *ImportResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4195,7 +4195,7 @@ func (m *AdminScatterRequest) Reset() { *m = AdminScatterRequest{} } func (m *AdminScatterRequest) String() string { return proto.CompactTextString(m) } func (*AdminScatterRequest) ProtoMessage() {} func (*AdminScatterRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{79} + return fileDescriptor_api_bfad9ab5d8946a01, []int{79} } func (m *AdminScatterRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4230,7 +4230,7 @@ func (m *AdminScatterResponse) Reset() { *m = AdminScatterResponse{} } func (m *AdminScatterResponse) String() string { return proto.CompactTextString(m) } func (*AdminScatterResponse) ProtoMessage() {} func (*AdminScatterResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{80} + return fileDescriptor_api_bfad9ab5d8946a01, []int{80} } func (m *AdminScatterResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4263,7 +4263,7 @@ func (m *AdminScatterResponse_Range) Reset() { *m = AdminScatterResponse func (m *AdminScatterResponse_Range) String() string { return proto.CompactTextString(m) } func (*AdminScatterResponse_Range) ProtoMessage() {} func (*AdminScatterResponse_Range) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{80, 0} + return fileDescriptor_api_bfad9ab5d8946a01, []int{80, 0} } func (m *AdminScatterResponse_Range) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4308,7 +4308,7 @@ func (m *AdminVerifyProtectedTimestampRequest) Reset() { *m = AdminVerif func (m *AdminVerifyProtectedTimestampRequest) String() string { return proto.CompactTextString(m) } func (*AdminVerifyProtectedTimestampRequest) ProtoMessage() {} func (*AdminVerifyProtectedTimestampRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{81} + return fileDescriptor_api_bfad9ab5d8946a01, []int{81} } func (m *AdminVerifyProtectedTimestampRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4346,7 +4346,7 @@ func (m *AdminVerifyProtectedTimestampResponse) Reset() { *m = AdminVeri func (m *AdminVerifyProtectedTimestampResponse) String() string { return proto.CompactTextString(m) } func (*AdminVerifyProtectedTimestampResponse) ProtoMessage() {} func (*AdminVerifyProtectedTimestampResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{82} + return fileDescriptor_api_bfad9ab5d8946a01, []int{82} } func (m *AdminVerifyProtectedTimestampResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4399,7 +4399,7 @@ func (m *AddSSTableRequest) Reset() { *m = AddSSTableRequest{} } func (m *AddSSTableRequest) String() string { return proto.CompactTextString(m) } func (*AddSSTableRequest) ProtoMessage() {} func (*AddSSTableRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{83} + return fileDescriptor_api_bfad9ab5d8946a01, []int{83} } func (m *AddSSTableRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4433,7 +4433,7 @@ func (m *AddSSTableResponse) Reset() { *m = AddSSTableResponse{} } func (m *AddSSTableResponse) String() string { return proto.CompactTextString(m) } func (*AddSSTableResponse) ProtoMessage() {} func (*AddSSTableResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{84} + return fileDescriptor_api_bfad9ab5d8946a01, []int{84} } func (m *AddSSTableResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4477,7 +4477,7 @@ func (m *RefreshRequest) Reset() { *m = RefreshRequest{} } func (m *RefreshRequest) String() string { return proto.CompactTextString(m) } func (*RefreshRequest) ProtoMessage() {} func (*RefreshRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{85} + return fileDescriptor_api_bfad9ab5d8946a01, []int{85} } func (m *RefreshRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4511,7 +4511,7 @@ func (m *RefreshResponse) Reset() { *m = RefreshResponse{} } func (m *RefreshResponse) String() string { return proto.CompactTextString(m) } func (*RefreshResponse) ProtoMessage() {} func (*RefreshResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{86} + return fileDescriptor_api_bfad9ab5d8946a01, []int{86} } func (m *RefreshResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4550,7 +4550,7 @@ func (m *RefreshRangeRequest) Reset() { *m = RefreshRangeRequest{} } func (m *RefreshRangeRequest) String() string { return proto.CompactTextString(m) } func (*RefreshRangeRequest) ProtoMessage() {} func (*RefreshRangeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{87} + return fileDescriptor_api_bfad9ab5d8946a01, []int{87} } func (m *RefreshRangeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4584,7 +4584,7 @@ func (m *RefreshRangeResponse) Reset() { *m = RefreshRangeResponse{} } func (m *RefreshRangeResponse) String() string { return proto.CompactTextString(m) } func (*RefreshRangeResponse) ProtoMessage() {} func (*RefreshRangeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{88} + return fileDescriptor_api_bfad9ab5d8946a01, []int{88} } func (m *RefreshRangeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4633,7 +4633,7 @@ func (m *SubsumeRequest) Reset() { *m = SubsumeRequest{} } func (m *SubsumeRequest) String() string { return proto.CompactTextString(m) } func (*SubsumeRequest) ProtoMessage() {} func (*SubsumeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{89} + return fileDescriptor_api_bfad9ab5d8946a01, []int{89} } func (m *SubsumeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4682,7 +4682,7 @@ func (m *SubsumeResponse) Reset() { *m = SubsumeResponse{} } func (m *SubsumeResponse) String() string { return proto.CompactTextString(m) } func (*SubsumeResponse) ProtoMessage() {} func (*SubsumeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{90} + return fileDescriptor_api_bfad9ab5d8946a01, []int{90} } func (m *SubsumeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4717,7 +4717,7 @@ func (m *RangeStatsRequest) Reset() { *m = RangeStatsRequest{} } func (m *RangeStatsRequest) String() string { return proto.CompactTextString(m) } func (*RangeStatsRequest) ProtoMessage() {} func (*RangeStatsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{91} + return fileDescriptor_api_bfad9ab5d8946a01, []int{91} } func (m *RangeStatsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4759,7 +4759,7 @@ func (m *RangeStatsResponse) Reset() { *m = RangeStatsResponse{} } func (m *RangeStatsResponse) String() string { return proto.CompactTextString(m) } func (*RangeStatsResponse) ProtoMessage() {} func (*RangeStatsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{92} + return fileDescriptor_api_bfad9ab5d8946a01, []int{92} } func (m *RangeStatsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4842,7 +4842,7 @@ func (m *RequestUnion) Reset() { *m = RequestUnion{} } func (m *RequestUnion) String() string { return proto.CompactTextString(m) } func (*RequestUnion) ProtoMessage() {} func (*RequestUnion) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{93} + return fileDescriptor_api_bfad9ab5d8946a01, []int{93} } func (m *RequestUnion) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6292,7 +6292,7 @@ func (m *ResponseUnion) Reset() { *m = ResponseUnion{} } func (m *ResponseUnion) String() string { return proto.CompactTextString(m) } func (*ResponseUnion) ProtoMessage() {} func (*ResponseUnion) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{94} + return fileDescriptor_api_bfad9ab5d8946a01, []int{94} } func (m *ResponseUnion) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7807,7 +7807,7 @@ func (m *Header) Reset() { *m = Header{} } func (m *Header) String() string { return proto.CompactTextString(m) } func (*Header) ProtoMessage() {} func (*Header) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{95} + return fileDescriptor_api_bfad9ab5d8946a01, []int{95} } func (m *Header) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7843,7 +7843,7 @@ type BatchRequest struct { func (m *BatchRequest) Reset() { *m = BatchRequest{} } func (*BatchRequest) ProtoMessage() {} func (*BatchRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{96} + return fileDescriptor_api_bfad9ab5d8946a01, []int{96} } func (m *BatchRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7880,7 +7880,7 @@ type BatchResponse struct { func (m *BatchResponse) Reset() { *m = BatchResponse{} } func (*BatchResponse) ProtoMessage() {} func (*BatchResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{97} + return fileDescriptor_api_bfad9ab5d8946a01, []int{97} } func (m *BatchResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7946,7 +7946,7 @@ func (m *BatchResponse_Header) Reset() { *m = BatchResponse_Header{} } func (m *BatchResponse_Header) String() string { return proto.CompactTextString(m) } func (*BatchResponse_Header) ProtoMessage() {} func (*BatchResponse_Header) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{97, 0} + return fileDescriptor_api_bfad9ab5d8946a01, []int{97, 0} } func (m *BatchResponse_Header) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7971,6 +7971,82 @@ func (m *BatchResponse_Header) XXX_DiscardUnknown() { var xxx_messageInfo_BatchResponse_Header proto.InternalMessageInfo +// RangeLookupRequest is a request to proxy a RangeLookup through a Tenant +// service. Its fields correspond to a subset of the args of kv.RangeLookup. +type RangeLookupRequest struct { + Key RKey `protobuf:"bytes,1,opt,name=key,proto3,casttype=RKey" json:"key,omitempty"` + ReadConsistency ReadConsistencyType `protobuf:"varint,2,opt,name=read_consistency,json=readConsistency,proto3,enum=cockroach.roachpb.ReadConsistencyType" json:"read_consistency,omitempty"` + PrefetchNum int64 `protobuf:"varint,3,opt,name=prefetch_num,json=prefetchNum,proto3" json:"prefetch_num,omitempty"` + PrefetchReverse bool `protobuf:"varint,4,opt,name=prefetch_reverse,json=prefetchReverse,proto3" json:"prefetch_reverse,omitempty"` +} + +func (m *RangeLookupRequest) Reset() { *m = RangeLookupRequest{} } +func (m *RangeLookupRequest) String() string { return proto.CompactTextString(m) } +func (*RangeLookupRequest) ProtoMessage() {} +func (*RangeLookupRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_api_bfad9ab5d8946a01, []int{98} +} +func (m *RangeLookupRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RangeLookupRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (dst *RangeLookupRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_RangeLookupRequest.Merge(dst, src) +} +func (m *RangeLookupRequest) XXX_Size() int { + return m.Size() +} +func (m *RangeLookupRequest) XXX_DiscardUnknown() { + xxx_messageInfo_RangeLookupRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_RangeLookupRequest proto.InternalMessageInfo + +// RangeLookupResponse is returned from a RangeLookup request proxied through a +// Tenant service. Its fields correspond to the return values of kv.RangeLookup. +type RangeLookupResponse struct { + Descriptors []RangeDescriptor `protobuf:"bytes,1,rep,name=descriptors,proto3" json:"descriptors"` + PrefetchedDescriptors []RangeDescriptor `protobuf:"bytes,2,rep,name=prefetched_descriptors,json=prefetchedDescriptors,proto3" json:"prefetched_descriptors"` + // If non-nil, the other fields will be empty. + Error *Error `protobuf:"bytes,3,opt,name=error,proto3" json:"error,omitempty"` +} + +func (m *RangeLookupResponse) Reset() { *m = RangeLookupResponse{} } +func (m *RangeLookupResponse) String() string { return proto.CompactTextString(m) } +func (*RangeLookupResponse) ProtoMessage() {} +func (*RangeLookupResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_api_bfad9ab5d8946a01, []int{99} +} +func (m *RangeLookupResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RangeLookupResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (dst *RangeLookupResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_RangeLookupResponse.Merge(dst, src) +} +func (m *RangeLookupResponse) XXX_Size() int { + return m.Size() +} +func (m *RangeLookupResponse) XXX_DiscardUnknown() { + xxx_messageInfo_RangeLookupResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_RangeLookupResponse proto.InternalMessageInfo + // RangeFeedRequest is a request that expresses the intention to establish a // RangeFeed stream over the provided span, starting at the specified timestamp. type RangeFeedRequest struct { @@ -7985,7 +8061,7 @@ func (m *RangeFeedRequest) Reset() { *m = RangeFeedRequest{} } func (m *RangeFeedRequest) String() string { return proto.CompactTextString(m) } func (*RangeFeedRequest) ProtoMessage() {} func (*RangeFeedRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{98} + return fileDescriptor_api_bfad9ab5d8946a01, []int{100} } func (m *RangeFeedRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -8026,7 +8102,7 @@ func (m *RangeFeedValue) Reset() { *m = RangeFeedValue{} } func (m *RangeFeedValue) String() string { return proto.CompactTextString(m) } func (*RangeFeedValue) ProtoMessage() {} func (*RangeFeedValue) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{99} + return fileDescriptor_api_bfad9ab5d8946a01, []int{101} } func (m *RangeFeedValue) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -8067,7 +8143,7 @@ func (m *RangeFeedCheckpoint) Reset() { *m = RangeFeedCheckpoint{} } func (m *RangeFeedCheckpoint) String() string { return proto.CompactTextString(m) } func (*RangeFeedCheckpoint) ProtoMessage() {} func (*RangeFeedCheckpoint) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{100} + return fileDescriptor_api_bfad9ab5d8946a01, []int{102} } func (m *RangeFeedCheckpoint) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -8104,7 +8180,7 @@ func (m *RangeFeedError) Reset() { *m = RangeFeedError{} } func (m *RangeFeedError) String() string { return proto.CompactTextString(m) } func (*RangeFeedError) ProtoMessage() {} func (*RangeFeedError) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{101} + return fileDescriptor_api_bfad9ab5d8946a01, []int{103} } func (m *RangeFeedError) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -8141,7 +8217,7 @@ func (m *RangeFeedEvent) Reset() { *m = RangeFeedEvent{} } func (m *RangeFeedEvent) String() string { return proto.CompactTextString(m) } func (*RangeFeedEvent) ProtoMessage() {} func (*RangeFeedEvent) Descriptor() ([]byte, []int) { - return fileDescriptor_api_d3d69809727ab49a, []int{102} + return fileDescriptor_api_bfad9ab5d8946a01, []int{104} } func (m *RangeFeedEvent) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -8166,6 +8242,87 @@ func (m *RangeFeedEvent) XXX_DiscardUnknown() { var xxx_messageInfo_RangeFeedEvent proto.InternalMessageInfo +// GossipSubscriptionRequest initiates a game of telephone. It establishes an +// indefinite stream that proxies gossip information overheard by the recipient +// node back to the caller. Gossip information is filtered down to just those +// identified by a key matching any of the specified patterns. +// +// Upon establishment of the stream, all existing information that matches one +// or more of the patterns is returned. After this point, only new information +// matching the patterns is returned. +type GossipSubscriptionRequest struct { + Patterns []string `protobuf:"bytes,1,rep,name=patterns,proto3" json:"patterns,omitempty"` +} + +func (m *GossipSubscriptionRequest) Reset() { *m = GossipSubscriptionRequest{} } +func (m *GossipSubscriptionRequest) String() string { return proto.CompactTextString(m) } +func (*GossipSubscriptionRequest) ProtoMessage() {} +func (*GossipSubscriptionRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_api_bfad9ab5d8946a01, []int{105} +} +func (m *GossipSubscriptionRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GossipSubscriptionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (dst *GossipSubscriptionRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GossipSubscriptionRequest.Merge(dst, src) +} +func (m *GossipSubscriptionRequest) XXX_Size() int { + return m.Size() +} +func (m *GossipSubscriptionRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GossipSubscriptionRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_GossipSubscriptionRequest proto.InternalMessageInfo + +// GossipSubscriptionEvent is a single piece of proxied gossip information. +type GossipSubscriptionEvent struct { + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Content Value `protobuf:"bytes,2,opt,name=content,proto3" json:"content"` + // Which pattern does this gossip information match? + PatternMatched string `protobuf:"bytes,3,opt,name=pattern_matched,json=patternMatched,proto3" json:"pattern_matched,omitempty"` + // If non-nil, the other fields will be empty and this will be the final event + // send on the stream before it is terminated. + Error *Error `protobuf:"bytes,4,opt,name=error,proto3" json:"error,omitempty"` +} + +func (m *GossipSubscriptionEvent) Reset() { *m = GossipSubscriptionEvent{} } +func (m *GossipSubscriptionEvent) String() string { return proto.CompactTextString(m) } +func (*GossipSubscriptionEvent) ProtoMessage() {} +func (*GossipSubscriptionEvent) Descriptor() ([]byte, []int) { + return fileDescriptor_api_bfad9ab5d8946a01, []int{106} +} +func (m *GossipSubscriptionEvent) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GossipSubscriptionEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (dst *GossipSubscriptionEvent) XXX_Merge(src proto.Message) { + xxx_messageInfo_GossipSubscriptionEvent.Merge(dst, src) +} +func (m *GossipSubscriptionEvent) XXX_Size() int { + return m.Size() +} +func (m *GossipSubscriptionEvent) XXX_DiscardUnknown() { + xxx_messageInfo_GossipSubscriptionEvent.DiscardUnknown(m) +} + +var xxx_messageInfo_GossipSubscriptionEvent proto.InternalMessageInfo + func init() { proto.RegisterType((*RequestHeader)(nil), "cockroach.roachpb.RequestHeader") proto.RegisterType((*ResponseHeader)(nil), "cockroach.roachpb.ResponseHeader") @@ -8281,11 +8438,15 @@ func init() { proto.RegisterType((*BatchRequest)(nil), "cockroach.roachpb.BatchRequest") proto.RegisterType((*BatchResponse)(nil), "cockroach.roachpb.BatchResponse") proto.RegisterType((*BatchResponse_Header)(nil), "cockroach.roachpb.BatchResponse.Header") + proto.RegisterType((*RangeLookupRequest)(nil), "cockroach.roachpb.RangeLookupRequest") + proto.RegisterType((*RangeLookupResponse)(nil), "cockroach.roachpb.RangeLookupResponse") proto.RegisterType((*RangeFeedRequest)(nil), "cockroach.roachpb.RangeFeedRequest") proto.RegisterType((*RangeFeedValue)(nil), "cockroach.roachpb.RangeFeedValue") proto.RegisterType((*RangeFeedCheckpoint)(nil), "cockroach.roachpb.RangeFeedCheckpoint") proto.RegisterType((*RangeFeedError)(nil), "cockroach.roachpb.RangeFeedError") proto.RegisterType((*RangeFeedEvent)(nil), "cockroach.roachpb.RangeFeedEvent") + proto.RegisterType((*GossipSubscriptionRequest)(nil), "cockroach.roachpb.GossipSubscriptionRequest") + proto.RegisterType((*GossipSubscriptionEvent)(nil), "cockroach.roachpb.GossipSubscriptionEvent") proto.RegisterEnum("cockroach.roachpb.ReadConsistencyType", ReadConsistencyType_name, ReadConsistencyType_value) proto.RegisterEnum("cockroach.roachpb.ScanFormat", ScanFormat_name, ScanFormat_value) proto.RegisterEnum("cockroach.roachpb.ChecksumMode", ChecksumMode_name, ChecksumMode_value) @@ -10202,7 +10363,9 @@ const _ = grpc.SupportPackageIsVersion4 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. type InternalClient interface { Batch(ctx context.Context, in *BatchRequest, opts ...grpc.CallOption) (*BatchResponse, error) + RangeLookup(ctx context.Context, in *RangeLookupRequest, opts ...grpc.CallOption) (*RangeLookupResponse, error) RangeFeed(ctx context.Context, in *RangeFeedRequest, opts ...grpc.CallOption) (Internal_RangeFeedClient, error) + GossipSubscription(ctx context.Context, in *GossipSubscriptionRequest, opts ...grpc.CallOption) (Internal_GossipSubscriptionClient, error) } type internalClient struct { @@ -10222,6 +10385,15 @@ func (c *internalClient) Batch(ctx context.Context, in *BatchRequest, opts ...gr return out, nil } +func (c *internalClient) RangeLookup(ctx context.Context, in *RangeLookupRequest, opts ...grpc.CallOption) (*RangeLookupResponse, error) { + out := new(RangeLookupResponse) + err := c.cc.Invoke(ctx, "/cockroach.roachpb.Internal/RangeLookup", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *internalClient) RangeFeed(ctx context.Context, in *RangeFeedRequest, opts ...grpc.CallOption) (Internal_RangeFeedClient, error) { stream, err := c.cc.NewStream(ctx, &_Internal_serviceDesc.Streams[0], "/cockroach.roachpb.Internal/RangeFeed", opts...) if err != nil { @@ -10254,10 +10426,44 @@ func (x *internalRangeFeedClient) Recv() (*RangeFeedEvent, error) { return m, nil } +func (c *internalClient) GossipSubscription(ctx context.Context, in *GossipSubscriptionRequest, opts ...grpc.CallOption) (Internal_GossipSubscriptionClient, error) { + stream, err := c.cc.NewStream(ctx, &_Internal_serviceDesc.Streams[1], "/cockroach.roachpb.Internal/GossipSubscription", opts...) + if err != nil { + return nil, err + } + x := &internalGossipSubscriptionClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type Internal_GossipSubscriptionClient interface { + Recv() (*GossipSubscriptionEvent, error) + grpc.ClientStream +} + +type internalGossipSubscriptionClient struct { + grpc.ClientStream +} + +func (x *internalGossipSubscriptionClient) Recv() (*GossipSubscriptionEvent, error) { + m := new(GossipSubscriptionEvent) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + // InternalServer is the server API for Internal service. type InternalServer interface { Batch(context.Context, *BatchRequest) (*BatchResponse, error) + RangeLookup(context.Context, *RangeLookupRequest) (*RangeLookupResponse, error) RangeFeed(*RangeFeedRequest, Internal_RangeFeedServer) error + GossipSubscription(*GossipSubscriptionRequest, Internal_GossipSubscriptionServer) error } func RegisterInternalServer(s *grpc.Server, srv InternalServer) { @@ -10282,6 +10488,24 @@ func _Internal_Batch_Handler(srv interface{}, ctx context.Context, dec func(inte return interceptor(ctx, in, info, handler) } +func _Internal_RangeLookup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RangeLookupRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(InternalServer).RangeLookup(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cockroach.roachpb.Internal/RangeLookup", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(InternalServer).RangeLookup(ctx, req.(*RangeLookupRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _Internal_RangeFeed_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(RangeFeedRequest) if err := stream.RecvMsg(m); err != nil { @@ -10303,6 +10527,27 @@ func (x *internalRangeFeedServer) Send(m *RangeFeedEvent) error { return x.ServerStream.SendMsg(m) } +func _Internal_GossipSubscription_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(GossipSubscriptionRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(InternalServer).GossipSubscription(m, &internalGossipSubscriptionServer{stream}) +} + +type Internal_GossipSubscriptionServer interface { + Send(*GossipSubscriptionEvent) error + grpc.ServerStream +} + +type internalGossipSubscriptionServer struct { + grpc.ServerStream +} + +func (x *internalGossipSubscriptionServer) Send(m *GossipSubscriptionEvent) error { + return x.ServerStream.SendMsg(m) +} + var _Internal_serviceDesc = grpc.ServiceDesc{ ServiceName: "cockroach.roachpb.Internal", HandlerType: (*InternalServer)(nil), @@ -10311,6 +10556,10 @@ var _Internal_serviceDesc = grpc.ServiceDesc{ MethodName: "Batch", Handler: _Internal_Batch_Handler, }, + { + MethodName: "RangeLookup", + Handler: _Internal_RangeLookup_Handler, + }, }, Streams: []grpc.StreamDesc{ { @@ -10318,6 +10567,11 @@ var _Internal_serviceDesc = grpc.ServiceDesc{ Handler: _Internal_RangeFeed_Handler, ServerStreams: true, }, + { + StreamName: "GossipSubscription", + Handler: _Internal_GossipSubscription_Handler, + ServerStreams: true, + }, }, Metadata: "roachpb/api.proto", } @@ -16319,6 +16573,102 @@ func (m *BatchResponse_Header) MarshalTo(dAtA []byte) (int, error) { return i, nil } +func (m *RangeLookupRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RangeLookupRequest) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Key) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintApi(dAtA, i, uint64(len(m.Key))) + i += copy(dAtA[i:], m.Key) + } + if m.ReadConsistency != 0 { + dAtA[i] = 0x10 + i++ + i = encodeVarintApi(dAtA, i, uint64(m.ReadConsistency)) + } + if m.PrefetchNum != 0 { + dAtA[i] = 0x18 + i++ + i = encodeVarintApi(dAtA, i, uint64(m.PrefetchNum)) + } + if m.PrefetchReverse { + dAtA[i] = 0x20 + i++ + if m.PrefetchReverse { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i++ + } + return i, nil +} + +func (m *RangeLookupResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RangeLookupResponse) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Descriptors) > 0 { + for _, msg := range m.Descriptors { + dAtA[i] = 0xa + i++ + i = encodeVarintApi(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.PrefetchedDescriptors) > 0 { + for _, msg := range m.PrefetchedDescriptors { + dAtA[i] = 0x12 + i++ + i = encodeVarintApi(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.Error != nil { + dAtA[i] = 0x1a + i++ + i = encodeVarintApi(dAtA, i, uint64(m.Error.Size())) + n259, err := m.Error.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n259 + } + return i, nil +} + func (m *RangeFeedRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -16337,19 +16687,19 @@ func (m *RangeFeedRequest) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0xa i++ i = encodeVarintApi(dAtA, i, uint64(m.Header.Size())) - n259, err := m.Header.MarshalTo(dAtA[i:]) + n260, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n259 + i += n260 dAtA[i] = 0x12 i++ i = encodeVarintApi(dAtA, i, uint64(m.Span.Size())) - n260, err := m.Span.MarshalTo(dAtA[i:]) + n261, err := m.Span.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n260 + i += n261 if m.WithDiff { dAtA[i] = 0x18 i++ @@ -16387,19 +16737,19 @@ func (m *RangeFeedValue) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x12 i++ i = encodeVarintApi(dAtA, i, uint64(m.Value.Size())) - n261, err := m.Value.MarshalTo(dAtA[i:]) + n262, err := m.Value.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n261 + i += n262 dAtA[i] = 0x1a i++ i = encodeVarintApi(dAtA, i, uint64(m.PrevValue.Size())) - n262, err := m.PrevValue.MarshalTo(dAtA[i:]) + n263, err := m.PrevValue.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n262 + i += n263 return i, nil } @@ -16421,19 +16771,19 @@ func (m *RangeFeedCheckpoint) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0xa i++ i = encodeVarintApi(dAtA, i, uint64(m.Span.Size())) - n263, err := m.Span.MarshalTo(dAtA[i:]) + n264, err := m.Span.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n263 + i += n264 dAtA[i] = 0x12 i++ i = encodeVarintApi(dAtA, i, uint64(m.ResolvedTS.Size())) - n264, err := m.ResolvedTS.MarshalTo(dAtA[i:]) + n265, err := m.ResolvedTS.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n264 + i += n265 return i, nil } @@ -16455,11 +16805,11 @@ func (m *RangeFeedError) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0xa i++ i = encodeVarintApi(dAtA, i, uint64(m.Error.Size())) - n265, err := m.Error.MarshalTo(dAtA[i:]) + n266, err := m.Error.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n265 + i += n266 return i, nil } @@ -16482,31 +16832,112 @@ func (m *RangeFeedEvent) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0xa i++ i = encodeVarintApi(dAtA, i, uint64(m.Val.Size())) - n266, err := m.Val.MarshalTo(dAtA[i:]) + n267, err := m.Val.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n266 + i += n267 } if m.Checkpoint != nil { dAtA[i] = 0x12 i++ i = encodeVarintApi(dAtA, i, uint64(m.Checkpoint.Size())) - n267, err := m.Checkpoint.MarshalTo(dAtA[i:]) + n268, err := m.Checkpoint.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n267 + i += n268 } if m.Error != nil { dAtA[i] = 0x1a i++ i = encodeVarintApi(dAtA, i, uint64(m.Error.Size())) - n268, err := m.Error.MarshalTo(dAtA[i:]) + n269, err := m.Error.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n268 + i += n269 + } + return i, nil +} + +func (m *GossipSubscriptionRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GossipSubscriptionRequest) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Patterns) > 0 { + for _, s := range m.Patterns { + dAtA[i] = 0xa + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } + return i, nil +} + +func (m *GossipSubscriptionEvent) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GossipSubscriptionEvent) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Key) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintApi(dAtA, i, uint64(len(m.Key))) + i += copy(dAtA[i:], m.Key) + } + dAtA[i] = 0x12 + i++ + i = encodeVarintApi(dAtA, i, uint64(m.Content.Size())) + n270, err := m.Content.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n270 + if len(m.PatternMatched) > 0 { + dAtA[i] = 0x1a + i++ + i = encodeVarintApi(dAtA, i, uint64(len(m.PatternMatched))) + i += copy(dAtA[i:], m.PatternMatched) + } + if m.Error != nil { + dAtA[i] = 0x22 + i++ + i = encodeVarintApi(dAtA, i, uint64(m.Error.Size())) + n271, err := m.Error.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n271 } return i, nil } @@ -19562,6 +19993,53 @@ func (m *BatchResponse_Header) Size() (n int) { return n } +func (m *RangeLookupRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Key) + if l > 0 { + n += 1 + l + sovApi(uint64(l)) + } + if m.ReadConsistency != 0 { + n += 1 + sovApi(uint64(m.ReadConsistency)) + } + if m.PrefetchNum != 0 { + n += 1 + sovApi(uint64(m.PrefetchNum)) + } + if m.PrefetchReverse { + n += 2 + } + return n +} + +func (m *RangeLookupResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Descriptors) > 0 { + for _, e := range m.Descriptors { + l = e.Size() + n += 1 + l + sovApi(uint64(l)) + } + } + if len(m.PrefetchedDescriptors) > 0 { + for _, e := range m.PrefetchedDescriptors { + l = e.Size() + n += 1 + l + sovApi(uint64(l)) + } + } + if m.Error != nil { + l = m.Error.Size() + n += 1 + l + sovApi(uint64(l)) + } + return n +} + func (m *RangeFeedRequest) Size() (n int) { if m == nil { return 0 @@ -19640,6 +20118,44 @@ func (m *RangeFeedEvent) Size() (n int) { return n } +func (m *GossipSubscriptionRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Patterns) > 0 { + for _, s := range m.Patterns { + l = len(s) + n += 1 + l + sovApi(uint64(l)) + } + } + return n +} + +func (m *GossipSubscriptionEvent) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Key) + if l > 0 { + n += 1 + l + sovApi(uint64(l)) + } + l = m.Content.Size() + n += 1 + l + sovApi(uint64(l)) + l = len(m.PatternMatched) + if l > 0 { + n += 1 + l + sovApi(uint64(l)) + } + if m.Error != nil { + l = m.Error.Size() + n += 1 + l + sovApi(uint64(l)) + } + return n +} + func sovApi(x uint64) (n int) { for { n++ @@ -37033,39 +37549,323 @@ func (m *BatchResponse_Header) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.CollectedSpans = append(m.CollectedSpans, tracing.RecordedSpan{}) - if err := m.CollectedSpans[len(m.CollectedSpans)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 7: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RangeInfos", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowApi - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthApi - } - postIndex := iNdEx + msglen - if postIndex > l { - return io.ErrUnexpectedEOF + m.CollectedSpans = append(m.CollectedSpans, tracing.RecordedSpan{}) + if err := m.CollectedSpans[len(m.CollectedSpans)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RangeInfos", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RangeInfos = append(m.RangeInfos, RangeInfo{}) + if err := m.RangeInfos[len(m.RangeInfos)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipApi(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthApi + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RangeLookupRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RangeLookupRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RangeLookupRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) + if m.Key == nil { + m.Key = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ReadConsistency", wireType) + } + m.ReadConsistency = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ReadConsistency |= (ReadConsistencyType(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PrefetchNum", wireType) + } + m.PrefetchNum = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.PrefetchNum |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PrefetchReverse", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PrefetchReverse = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipApi(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthApi + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RangeLookupResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RangeLookupResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RangeLookupResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Descriptors", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Descriptors = append(m.Descriptors, RangeDescriptor{}) + if err := m.Descriptors[len(m.Descriptors)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PrefetchedDescriptors", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PrefetchedDescriptors = append(m.PrefetchedDescriptors, RangeDescriptor{}) + if err := m.PrefetchedDescriptors[len(m.PrefetchedDescriptors)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Error == nil { + m.Error = &Error{} } - m.RangeInfos = append(m.RangeInfos, RangeInfo{}) - if err := m.RangeInfos[len(m.RangeInfos)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -37700,6 +38500,256 @@ func (m *RangeFeedEvent) Unmarshal(dAtA []byte) error { } return nil } +func (m *GossipSubscriptionRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GossipSubscriptionRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GossipSubscriptionRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Patterns", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Patterns = append(m.Patterns, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipApi(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthApi + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GossipSubscriptionEvent) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GossipSubscriptionEvent: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GossipSubscriptionEvent: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Content", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Content.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PatternMatched", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PatternMatched = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Error == nil { + m.Error = &Error{} + } + if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipApi(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthApi + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipApi(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 @@ -37805,475 +38855,489 @@ var ( ErrIntOverflowApi = fmt.Errorf("proto: integer overflow") ) -func init() { proto.RegisterFile("roachpb/api.proto", fileDescriptor_api_d3d69809727ab49a) } - -var fileDescriptor_api_d3d69809727ab49a = []byte{ - // 7464 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x7d, 0x6f, 0x6c, 0x23, 0xc9, - 0x95, 0x9f, 0x9a, 0xa4, 0x28, 0xf2, 0x91, 0xa2, 0x5a, 0x25, 0xcd, 0x0c, 0x47, 0xb3, 0x2b, 0x69, - 0xb8, 0xf3, 0x6f, 0xc7, 0xbb, 0xd2, 0xce, 0xcc, 0x6e, 0x76, 0xbd, 0xb3, 0x5e, 0x5b, 0xa2, 0x38, - 0x43, 0x4a, 0x23, 0x8d, 0xa6, 0x49, 0xcd, 0x7a, 0xd7, 0x5e, 0xb4, 0x5b, 0xdd, 0x25, 0xaa, 0x2d, - 0xb2, 0x9b, 0xd3, 0xdd, 0xd4, 0x9f, 0x01, 0x02, 0x38, 0x7f, 0x00, 0x07, 0x46, 0xb0, 0xc8, 0x87, - 0x20, 0x08, 0xe2, 0x18, 0x5e, 0xc0, 0x01, 0x1c, 0xc0, 0xd8, 0x20, 0xc9, 0xb7, 0x04, 0x0e, 0x92, - 0x0f, 0x09, 0xb0, 0x31, 0x1c, 0xc0, 0x08, 0x70, 0x67, 0xe3, 0x80, 0x13, 0xce, 0x63, 0xc0, 0x38, - 0xf8, 0xc3, 0x01, 0xf7, 0xe5, 0x0e, 0x58, 0xe0, 0x0e, 0x87, 0xfa, 0xd3, 0x7f, 0x48, 0x36, 0xff, - 0x68, 0xdc, 0x7b, 0xb7, 0x80, 0xbf, 0x10, 0xec, 0x57, 0xf5, 0x5e, 0x57, 0xbd, 0xaa, 0x7a, 0xf5, - 0x7e, 0x55, 0xaf, 0xaa, 0x61, 0xda, 0x32, 0x15, 0x75, 0xbf, 0xb5, 0xbb, 0xac, 0xb4, 0xf4, 0xa5, - 0x96, 0x65, 0x3a, 0x26, 0x9a, 0x56, 0x4d, 0xf5, 0x80, 0x92, 0x97, 0x78, 0xe2, 0xdc, 0xcd, 0x83, - 0xc3, 0xe5, 0x83, 0x43, 0x1b, 0x5b, 0x87, 0xd8, 0x5a, 0x56, 0x4d, 0x43, 0x6d, 0x5b, 0x16, 0x36, - 0xd4, 0x93, 0xe5, 0x86, 0xa9, 0x1e, 0xd0, 0x1f, 0xdd, 0xa8, 0x33, 0xf6, 0x39, 0xe4, 0x4a, 0xd4, - 0x14, 0x47, 0xe1, 0xb4, 0x59, 0x97, 0x86, 0x2d, 0xcb, 0xb4, 0x6c, 0x4e, 0x3d, 0xef, 0x52, 0x9b, - 0xd8, 0x51, 0x02, 0xb9, 0x2f, 0xd9, 0x8e, 0x69, 0x29, 0x75, 0xbc, 0x8c, 0x8d, 0xba, 0x6e, 0x60, - 0x92, 0xe1, 0x50, 0x55, 0x79, 0xe2, 0x0b, 0xa1, 0x89, 0x77, 0x78, 0x6a, 0xbe, 0xed, 0xe8, 0x8d, - 0xe5, 0xfd, 0x86, 0xba, 0xec, 0xe8, 0x4d, 0x6c, 0x3b, 0x4a, 0xb3, 0xc5, 0x53, 0x16, 0x69, 0x8a, - 0x63, 0x29, 0xaa, 0x6e, 0xd4, 0x97, 0x2d, 0xac, 0x9a, 0x96, 0x86, 0x35, 0xd9, 0x6e, 0x29, 0x86, - 0x5b, 0xc8, 0xba, 0x59, 0x37, 0xe9, 0xdf, 0x65, 0xf2, 0x8f, 0x51, 0x0b, 0x3f, 0x15, 0x60, 0x52, - 0xc2, 0x4f, 0xda, 0xd8, 0x76, 0xca, 0x58, 0xd1, 0xb0, 0x85, 0x2e, 0x42, 0xfc, 0x00, 0x9f, 0xe4, - 0xe3, 0x8b, 0xc2, 0x8d, 0xec, 0xea, 0xc4, 0x67, 0xa7, 0x0b, 0xf1, 0x0d, 0x7c, 0x22, 0x11, 0x1a, - 0x5a, 0x84, 0x09, 0x6c, 0x68, 0x32, 0x49, 0x4e, 0x74, 0x26, 0x27, 0xb1, 0xa1, 0x6d, 0xe0, 0x13, - 0xf4, 0x4d, 0x48, 0xd9, 0x44, 0x9a, 0xa1, 0xe2, 0xfc, 0xf8, 0xa2, 0x70, 0x63, 0x7c, 0xf5, 0x6b, - 0x9f, 0x9d, 0x2e, 0xbc, 0x53, 0xd7, 0x9d, 0xfd, 0xf6, 0xee, 0x92, 0x6a, 0x36, 0x97, 0x3d, 0xed, - 0x6b, 0xbb, 0xfe, 0xff, 0xe5, 0xd6, 0x41, 0x7d, 0xb9, 0xbb, 0xe6, 0x4b, 0xb5, 0x63, 0xa3, 0x8a, - 0x9f, 0x48, 0x9e, 0xc4, 0xb7, 0x13, 0x7f, 0xfe, 0xf1, 0x82, 0xb0, 0x9e, 0x48, 0x09, 0x62, 0x6c, - 0x3d, 0x91, 0x8a, 0x89, 0xf1, 0xc2, 0x8f, 0xe2, 0x90, 0x93, 0xb0, 0xdd, 0x32, 0x0d, 0x1b, 0xf3, - 0xf2, 0xbf, 0x06, 0x71, 0xe7, 0xd8, 0xa0, 0xe5, 0xcf, 0xdc, 0x9e, 0x5f, 0xea, 0x69, 0xed, 0xa5, - 0x9a, 0xa5, 0x18, 0xb6, 0xa2, 0x3a, 0xba, 0x69, 0x48, 0x24, 0x2b, 0x7a, 0x0b, 0x32, 0x16, 0xb6, - 0xdb, 0x4d, 0x4c, 0xd5, 0x45, 0xab, 0x96, 0xb9, 0x7d, 0x21, 0x84, 0xb3, 0xda, 0x52, 0x0c, 0x09, - 0x58, 0x5e, 0xf2, 0x1f, 0x5d, 0x84, 0x94, 0xd1, 0x6e, 0x12, 0x85, 0xd8, 0xb4, 0xba, 0x71, 0x69, - 0xc2, 0x68, 0x37, 0x37, 0xf0, 0x89, 0x8d, 0xbe, 0x0e, 0xe7, 0x35, 0xdc, 0xb2, 0xb0, 0xaa, 0x38, - 0x58, 0x93, 0x2d, 0xc5, 0xa8, 0x63, 0x59, 0x37, 0xf6, 0x4c, 0x3b, 0x9f, 0x5c, 0x8c, 0xdf, 0xc8, - 0xdc, 0x7e, 0x21, 0x44, 0xbe, 0x44, 0x72, 0x55, 0x8c, 0x3d, 0x73, 0x35, 0xf1, 0xe9, 0xe9, 0xc2, - 0x98, 0x34, 0xeb, 0x4b, 0xf0, 0x92, 0x6c, 0x54, 0x85, 0x49, 0x5e, 0x5c, 0x0b, 0x2b, 0xb6, 0x69, - 0xe4, 0x27, 0x16, 0x85, 0x1b, 0xb9, 0xdb, 0x4b, 0x61, 0x02, 0x3b, 0x54, 0x43, 0x1e, 0xdb, 0x4d, - 0x2c, 0x51, 0x2e, 0x29, 0x6b, 0x05, 0x9e, 0xd0, 0x25, 0x48, 0x93, 0x9a, 0xec, 0x9e, 0x38, 0xd8, - 0xce, 0xa7, 0x68, 0x55, 0x48, 0xd5, 0x56, 0xc9, 0x73, 0xe1, 0x5d, 0xc8, 0x06, 0x59, 0x11, 0x82, - 0x9c, 0x54, 0xaa, 0xee, 0x6c, 0x96, 0xe4, 0x9d, 0xad, 0x8d, 0xad, 0x87, 0xef, 0x6d, 0x89, 0x63, - 0x68, 0x16, 0x44, 0x4e, 0xdb, 0x28, 0xbd, 0x2f, 0x3f, 0xa8, 0x6c, 0x56, 0x6a, 0xa2, 0x30, 0x97, - 0xf8, 0x17, 0x3f, 0x9a, 0x1f, 0x2b, 0x3c, 0x06, 0xb8, 0x8f, 0x1d, 0xde, 0xcd, 0xd0, 0x2a, 0x24, - 0xf7, 0x69, 0x79, 0xf2, 0x02, 0xd5, 0xf4, 0x62, 0x68, 0xc1, 0x03, 0x5d, 0x72, 0x35, 0x45, 0xb4, - 0xf1, 0x8b, 0xd3, 0x05, 0x41, 0xe2, 0x9c, 0xac, 0x27, 0x14, 0xfe, 0xa7, 0x00, 0x19, 0x2a, 0x98, - 0xd5, 0x12, 0x15, 0xbb, 0x24, 0x5f, 0x1e, 0xaa, 0x92, 0x5e, 0xd1, 0x68, 0x09, 0xc6, 0x0f, 0x95, - 0x46, 0x1b, 0xe7, 0x63, 0x54, 0x46, 0x3e, 0x44, 0xc6, 0x63, 0x92, 0x2e, 0xb1, 0x6c, 0xe8, 0x2e, - 0x64, 0x75, 0xc3, 0xc1, 0x86, 0x23, 0x33, 0xb6, 0xf8, 0x10, 0xb6, 0x0c, 0xcb, 0x4d, 0x1f, 0x0a, - 0xff, 0x5d, 0x00, 0xd8, 0x6e, 0x47, 0xa9, 0x1a, 0xf4, 0xfa, 0x88, 0xe5, 0xe7, 0x7d, 0x8c, 0xd7, - 0xe2, 0x3c, 0x24, 0x75, 0xa3, 0xa1, 0x1b, 0xac, 0xfc, 0x29, 0x89, 0x3f, 0xa1, 0x59, 0x18, 0xdf, - 0x6d, 0xe8, 0x86, 0x46, 0x47, 0x45, 0x4a, 0x62, 0x0f, 0x5c, 0xfd, 0x12, 0x64, 0x68, 0xd9, 0x23, - 0xd4, 0x7e, 0xe1, 0xe7, 0x31, 0x38, 0x57, 0x34, 0x0d, 0x4d, 0x27, 0xc3, 0x53, 0x69, 0x7c, 0x21, - 0x74, 0xb3, 0x0e, 0x81, 0x81, 0x28, 0xe3, 0xe3, 0xd6, 0x88, 0x2d, 0x8d, 0x7c, 0xae, 0xd2, 0x71, - 0x8b, 0xd2, 0xc2, 0xf5, 0x89, 0x5e, 0x87, 0x0b, 0x4a, 0xa3, 0x61, 0x1e, 0xc9, 0xfa, 0x9e, 0xac, - 0x99, 0xd8, 0x96, 0x0d, 0xd3, 0x91, 0xf1, 0xb1, 0x6e, 0x3b, 0xd4, 0xac, 0xa4, 0xa4, 0x19, 0x9a, - 0x5c, 0xd9, 0x5b, 0x33, 0xb1, 0xbd, 0x65, 0x3a, 0x25, 0x92, 0x44, 0xc6, 0x2c, 0x29, 0x0c, 0x1b, - 0xb3, 0x49, 0x62, 0x90, 0xa5, 0x14, 0x3e, 0x6e, 0xd1, 0x31, 0xcb, 0x9b, 0xe8, 0x43, 0x38, 0xdf, - 0xad, 0xcd, 0x28, 0x5b, 0xeb, 0xff, 0x0b, 0x90, 0xab, 0x18, 0xba, 0xf3, 0x85, 0x68, 0x26, 0x4f, - 0xb5, 0xf1, 0xa0, 0x6a, 0x6f, 0x82, 0xb8, 0xa7, 0xe8, 0x8d, 0x87, 0x46, 0xcd, 0x6c, 0xee, 0xda, - 0x8e, 0x69, 0x60, 0x9b, 0xeb, 0xbe, 0x87, 0xce, 0x75, 0xf6, 0x18, 0xa6, 0xbc, 0x3a, 0x45, 0xa9, - 0xac, 0xa7, 0x20, 0x56, 0x0c, 0xd5, 0xc2, 0x4d, 0x6c, 0x44, 0xaa, 0xad, 0x17, 0x20, 0xad, 0xbb, - 0x72, 0xa9, 0xc6, 0xe2, 0x92, 0x4f, 0xe0, 0x75, 0x6a, 0xc3, 0x74, 0xe0, 0xdd, 0x51, 0x9a, 0x4b, - 0x32, 0x71, 0xe0, 0x23, 0xd9, 0x6f, 0x2f, 0x32, 0x71, 0xe0, 0x23, 0x66, 0xde, 0xde, 0x87, 0xc9, - 0x35, 0xdc, 0xc0, 0x0e, 0x8e, 0xde, 0xf6, 0xef, 0x40, 0xce, 0x15, 0x1d, 0x65, 0x23, 0xfd, 0x40, - 0x00, 0xc4, 0xe5, 0x92, 0x19, 0x37, 0xca, 0x76, 0x5a, 0x20, 0x6e, 0x86, 0xd3, 0xb6, 0x0c, 0xe6, - 0x2f, 0xb0, 0x5e, 0x0a, 0x8c, 0x44, 0x5d, 0x06, 0xdf, 0x06, 0x27, 0x82, 0x36, 0xd8, 0x73, 0x7b, - 0x88, 0xc3, 0x73, 0x04, 0x33, 0x1d, 0xc5, 0x8b, 0xb6, 0x29, 0x13, 0xb4, 0x64, 0xb1, 0xc5, 0x78, - 0xd0, 0xb7, 0xa3, 0xc4, 0xc2, 0x87, 0x30, 0x5d, 0x6c, 0x60, 0xc5, 0x8a, 0x5a, 0x2d, 0xbc, 0x39, - 0xdf, 0x07, 0x14, 0x14, 0x1f, 0x65, 0x93, 0xfe, 0x07, 0x01, 0x90, 0x84, 0x0f, 0xb1, 0xe5, 0x44, - 0xde, 0xa4, 0x6b, 0x90, 0x71, 0x14, 0xab, 0x8e, 0x1d, 0x99, 0xf8, 0xe3, 0xdc, 0x5c, 0xbd, 0x18, - 0x10, 0x44, 0xbc, 0xf2, 0xa5, 0xfd, 0x86, 0xba, 0x54, 0x73, 0xfd, 0x75, 0x6e, 0xb3, 0x80, 0xf1, - 0x11, 0x32, 0xd7, 0xc0, 0x07, 0x30, 0xd3, 0x51, 0xca, 0x28, 0x55, 0xf0, 0x57, 0x02, 0x64, 0xaa, - 0xaa, 0x62, 0x44, 0x59, 0xf7, 0x77, 0x21, 0x63, 0xab, 0x8a, 0x21, 0xef, 0x99, 0x56, 0x53, 0x71, - 0x68, 0x97, 0xcd, 0x75, 0xd4, 0xdd, 0xf3, 0x9a, 0x55, 0xc5, 0xb8, 0x47, 0x33, 0x49, 0x60, 0x7b, - 0xff, 0xd1, 0x23, 0xc8, 0x1c, 0xe0, 0x13, 0x99, 0xa3, 0x2b, 0x3a, 0xcf, 0xe5, 0x6e, 0xbf, 0x16, - 0xe0, 0x3f, 0x38, 0x5c, 0x72, 0x41, 0xd9, 0x52, 0x00, 0x94, 0x2d, 0x11, 0x8e, 0xa5, 0xaa, 0x63, - 0x61, 0xa3, 0xee, 0xec, 0x4b, 0x70, 0x80, 0x4f, 0x1e, 0x30, 0x19, 0xc1, 0x81, 0xb2, 0x9e, 0x48, - 0xc5, 0xc5, 0x44, 0xe1, 0xaf, 0x05, 0xc8, 0xb2, 0x8a, 0x47, 0x39, 0x50, 0xde, 0x80, 0x84, 0x65, - 0x1e, 0xb1, 0x81, 0x92, 0xb9, 0x7d, 0x29, 0x44, 0xc4, 0x06, 0x3e, 0x09, 0xce, 0x50, 0x34, 0x3b, - 0x5a, 0x05, 0xee, 0xfb, 0xc9, 0x94, 0x3b, 0x3e, 0x2a, 0x37, 0x30, 0x2e, 0x89, 0xc8, 0xb8, 0x0e, - 0x53, 0xbb, 0x8a, 0xa3, 0xee, 0xcb, 0x16, 0x2f, 0x24, 0x99, 0xcd, 0xe2, 0x37, 0xb2, 0x52, 0x8e, - 0x92, 0xdd, 0xa2, 0xdb, 0x85, 0xbf, 0x71, 0x7b, 0xbd, 0x8d, 0xff, 0x20, 0x5b, 0xfe, 0x6f, 0x05, - 0x3e, 0x9e, 0xdc, 0xfa, 0xff, 0xa1, 0x75, 0x80, 0x1f, 0xc6, 0xe0, 0x42, 0x71, 0x1f, 0xab, 0x07, - 0x45, 0xd3, 0xb0, 0x75, 0xdb, 0x21, 0x1a, 0x8c, 0xb2, 0x17, 0x5c, 0x82, 0xf4, 0x91, 0xee, 0xec, - 0xcb, 0x9a, 0xbe, 0xb7, 0x47, 0x2d, 0x5f, 0x4a, 0x4a, 0x11, 0xc2, 0x9a, 0xbe, 0xb7, 0x87, 0xee, - 0x40, 0xa2, 0x69, 0x6a, 0xcc, 0x45, 0xce, 0xdd, 0x5e, 0x08, 0x11, 0x4f, 0x8b, 0x66, 0xb7, 0x9b, - 0x9b, 0xa6, 0x86, 0x25, 0x9a, 0x19, 0xcd, 0x03, 0xa8, 0x84, 0xda, 0x32, 0x75, 0xc3, 0xe1, 0x73, - 0x60, 0x80, 0x82, 0xca, 0x90, 0x76, 0xb0, 0xd5, 0xd4, 0x0d, 0xc5, 0xc1, 0xf9, 0x71, 0xaa, 0xbc, - 0x2b, 0xa1, 0x05, 0x6f, 0x35, 0x74, 0x55, 0x59, 0xc3, 0xb6, 0x6a, 0xe9, 0x2d, 0xc7, 0xb4, 0xb8, - 0x16, 0x7d, 0x66, 0x6e, 0x71, 0x3f, 0x4a, 0x40, 0xbe, 0x57, 0x43, 0x51, 0xf6, 0x93, 0x6d, 0x48, - 0x12, 0x94, 0xdd, 0x70, 0x78, 0x4f, 0xb9, 0xdd, 0x4f, 0x11, 0x21, 0x25, 0xa0, 0x68, 0xbd, 0xe1, - 0xf0, 0xc2, 0x73, 0x39, 0x73, 0x3f, 0x15, 0x20, 0xc9, 0x12, 0xd0, 0x2d, 0x48, 0xf1, 0x65, 0x05, - 0x8d, 0x96, 0x31, 0xbe, 0x7a, 0xfe, 0xd9, 0xe9, 0xc2, 0x04, 0x5b, 0x29, 0x58, 0xfb, 0xcc, 0xff, - 0x2b, 0x4d, 0xd0, 0x7c, 0x15, 0x8d, 0xb4, 0x99, 0xed, 0x28, 0x96, 0x43, 0x97, 0x70, 0x62, 0x0c, - 0x31, 0x50, 0xc2, 0x06, 0x3e, 0x41, 0xeb, 0x90, 0xb4, 0x1d, 0xc5, 0x69, 0xdb, 0xbc, 0xd5, 0xce, - 0x54, 0xd8, 0x2a, 0xe5, 0x94, 0xb8, 0x04, 0xe2, 0xca, 0x68, 0xd8, 0x51, 0xf4, 0x06, 0x6d, 0xc6, - 0xb4, 0xc4, 0x9f, 0x0a, 0xdf, 0x17, 0x20, 0xc9, 0xb2, 0xa2, 0x0b, 0x30, 0x23, 0xad, 0x6c, 0xdd, - 0x2f, 0xc9, 0x95, 0xad, 0xb5, 0x52, 0xad, 0x24, 0x6d, 0x56, 0xb6, 0x56, 0x6a, 0x25, 0x71, 0x0c, - 0x9d, 0x07, 0xe4, 0x26, 0x14, 0x1f, 0x6e, 0x55, 0x2b, 0xd5, 0x5a, 0x69, 0xab, 0x26, 0x0a, 0x74, - 0x85, 0x81, 0xd2, 0x03, 0xd4, 0x18, 0xba, 0x02, 0x8b, 0xdd, 0x54, 0xb9, 0x5a, 0x5b, 0xa9, 0x55, - 0xe5, 0x52, 0xb5, 0x56, 0xd9, 0x5c, 0xa9, 0x95, 0xd6, 0xc4, 0xf8, 0x80, 0x5c, 0xe4, 0x25, 0x92, - 0x54, 0x2a, 0xd6, 0xc4, 0x44, 0xe1, 0x29, 0x9c, 0x93, 0xb0, 0x6a, 0x36, 0x5b, 0x6d, 0x07, 0x93, - 0x52, 0xda, 0x51, 0x8e, 0x97, 0x0b, 0x30, 0xa1, 0x59, 0x27, 0xb2, 0xd5, 0x36, 0xf8, 0x68, 0x49, - 0x6a, 0xd6, 0x89, 0xd4, 0x36, 0x78, 0x67, 0xfc, 0xcf, 0x02, 0x9c, 0xef, 0x7e, 0x79, 0x94, 0x5d, - 0xf1, 0x11, 0x64, 0x14, 0x4d, 0xc3, 0x9a, 0xac, 0xe1, 0x86, 0xa3, 0x70, 0x57, 0xe5, 0x66, 0x40, - 0x12, 0x5f, 0x7e, 0x5b, 0xf2, 0x96, 0xdf, 0x36, 0x1f, 0x17, 0x8b, 0xb4, 0x20, 0x6b, 0x84, 0xc3, - 0x35, 0x45, 0x54, 0x08, 0xa5, 0x14, 0xfe, 0x6b, 0x02, 0x26, 0x4b, 0x86, 0x56, 0x3b, 0x8e, 0x74, - 0x76, 0x39, 0x0f, 0x49, 0xd5, 0x6c, 0x36, 0x75, 0xc7, 0x55, 0x13, 0x7b, 0x42, 0x5f, 0x86, 0x94, - 0x86, 0x15, 0xcd, 0x5b, 0xa3, 0x18, 0xe6, 0x68, 0x49, 0x5e, 0x76, 0xf4, 0x2d, 0xb8, 0x40, 0x2c, - 0xa8, 0x65, 0x28, 0x0d, 0x99, 0x49, 0x93, 0x1d, 0x4b, 0xaf, 0xd7, 0xb1, 0xc5, 0x17, 0xfb, 0x6e, - 0x84, 0x94, 0xb3, 0xc2, 0x39, 0x8a, 0x94, 0xa1, 0xc6, 0xf2, 0x4b, 0xe7, 0xf4, 0x30, 0x32, 0x7a, - 0x07, 0x80, 0x4c, 0x4e, 0x74, 0x01, 0xd1, 0xe6, 0xb6, 0xa9, 0xdf, 0x0a, 0xa2, 0x6b, 0x8e, 0x08, - 0x03, 0x79, 0xb6, 0xd1, 0x32, 0x41, 0x06, 0x4f, 0xda, 0xba, 0x85, 0xe5, 0x5b, 0x2d, 0x95, 0x42, - 0xf9, 0xd4, 0x6a, 0xee, 0xd9, 0xe9, 0x02, 0x48, 0x8c, 0x7c, 0x6b, 0xbb, 0x48, 0x90, 0x02, 0xfb, - 0xdf, 0x52, 0xd1, 0x2a, 0xcc, 0x93, 0x09, 0x98, 0xd7, 0x45, 0x71, 0xe4, 0x7d, 0xbd, 0xbe, 0x8f, - 0x2d, 0xd9, 0x5b, 0x15, 0xa6, 0x4b, 0x78, 0x29, 0x69, 0x4e, 0x55, 0x0c, 0x56, 0xd0, 0x15, 0xa7, - 0x4c, 0xb3, 0x78, 0xea, 0x21, 0x7a, 0x6e, 0x99, 0xba, 0x6d, 0x1a, 0xf9, 0x34, 0xd3, 0x33, 0x7b, +func init() { proto.RegisterFile("roachpb/api.proto", fileDescriptor_api_bfad9ab5d8946a01) } + +var fileDescriptor_api_bfad9ab5d8946a01 = []byte{ + // 7688 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x7d, 0x6b, 0x6c, 0x24, 0xc7, + 0xb5, 0x1e, 0x7b, 0x66, 0x48, 0xce, 0x9c, 0x19, 0x0e, 0x9b, 0x45, 0xee, 0xee, 0x2c, 0x57, 0x22, + 0xb9, 0xa3, 0x7d, 0x69, 0x2d, 0x91, 0xda, 0x5d, 0x29, 0x92, 0xb5, 0xb2, 0x6c, 0x72, 0x38, 0xbb, + 0x43, 0x72, 0xc9, 0xe5, 0xf6, 0x0c, 0x57, 0x96, 0x6c, 0xa5, 0xdd, 0xec, 0x2e, 0x0e, 0xdb, 0x9c, + 0xe9, 0x9e, 0xed, 0xee, 0xe1, 0x63, 0x81, 0x00, 0xce, 0x0b, 0x0e, 0x8c, 0x40, 0xc8, 0x8f, 0x20, + 0x08, 0xe2, 0x18, 0x16, 0xe0, 0x00, 0x0e, 0x60, 0x28, 0x08, 0xf2, 0x2f, 0x81, 0xf3, 0xf8, 0x91, + 0x00, 0x8a, 0xe1, 0x00, 0x4e, 0x80, 0xc4, 0x46, 0x80, 0x10, 0xf1, 0x1a, 0x30, 0x02, 0xff, 0x08, + 0x90, 0xfc, 0xb8, 0x17, 0x10, 0x70, 0x2f, 0x2e, 0xea, 0xd1, 0xaf, 0x99, 0x9e, 0x07, 0x57, 0xad, + 0x7b, 0x05, 0xf8, 0xcf, 0x60, 0xfa, 0x54, 0x9d, 0xd3, 0x55, 0xa7, 0xaa, 0x4e, 0x9d, 0xaf, 0xea, + 0x54, 0x35, 0x4c, 0x59, 0xa6, 0xa2, 0xee, 0xb7, 0x76, 0x97, 0x94, 0x96, 0xbe, 0xd8, 0xb2, 0x4c, + 0xc7, 0x44, 0x53, 0xaa, 0xa9, 0x1e, 0x50, 0xf2, 0x22, 0x4f, 0x9c, 0xbd, 0x79, 0x70, 0xb8, 0x74, + 0x70, 0x68, 0x63, 0xeb, 0x10, 0x5b, 0x4b, 0xaa, 0x69, 0xa8, 0x6d, 0xcb, 0xc2, 0x86, 0x7a, 0xb2, + 0xd4, 0x30, 0xd5, 0x03, 0xfa, 0xa3, 0x1b, 0x75, 0xc6, 0x3e, 0x8b, 0x5c, 0x89, 0x9a, 0xe2, 0x28, + 0x9c, 0x36, 0xe3, 0xd2, 0xb0, 0x65, 0x99, 0x96, 0xcd, 0xa9, 0xe7, 0x5d, 0x6a, 0x13, 0x3b, 0x4a, + 0x20, 0xf7, 0x25, 0xdb, 0x31, 0x2d, 0xa5, 0x8e, 0x97, 0xb0, 0x51, 0xd7, 0x0d, 0x4c, 0x32, 0x1c, + 0xaa, 0x2a, 0x4f, 0x7c, 0x21, 0x32, 0xf1, 0x0e, 0x4f, 0x2d, 0xb4, 0x1d, 0xbd, 0xb1, 0xb4, 0xdf, + 0x50, 0x97, 0x1c, 0xbd, 0x89, 0x6d, 0x47, 0x69, 0xb6, 0x78, 0xca, 0x02, 0x4d, 0x71, 0x2c, 0x45, + 0xd5, 0x8d, 0xfa, 0x92, 0x85, 0x55, 0xd3, 0xd2, 0xb0, 0x26, 0xdb, 0x2d, 0xc5, 0x70, 0x0b, 0x59, + 0x37, 0xeb, 0x26, 0xfd, 0xbb, 0x44, 0xfe, 0x31, 0x6a, 0xf1, 0xe7, 0x02, 0x4c, 0x48, 0xf8, 0x49, + 0x1b, 0xdb, 0x4e, 0x05, 0x2b, 0x1a, 0xb6, 0xd0, 0x45, 0x48, 0x1e, 0xe0, 0x93, 0x42, 0x72, 0x41, + 0xb8, 0x91, 0x5b, 0x19, 0xff, 0xec, 0x74, 0x3e, 0xb9, 0x81, 0x4f, 0x24, 0x42, 0x43, 0x0b, 0x30, + 0x8e, 0x0d, 0x4d, 0x26, 0xc9, 0xa9, 0x70, 0xf2, 0x18, 0x36, 0xb4, 0x0d, 0x7c, 0x82, 0xbe, 0x0d, + 0x69, 0x9b, 0x48, 0x33, 0x54, 0x5c, 0x18, 0x5d, 0x10, 0x6e, 0x8c, 0xae, 0x7c, 0xe3, 0xb3, 0xd3, + 0xf9, 0x77, 0xea, 0xba, 0xb3, 0xdf, 0xde, 0x5d, 0x54, 0xcd, 0xe6, 0x92, 0xa7, 0x7d, 0x6d, 0xd7, + 0xff, 0xbf, 0xd4, 0x3a, 0xa8, 0x2f, 0x75, 0xd6, 0x7c, 0xb1, 0x76, 0x6c, 0x54, 0xf1, 0x13, 0xc9, + 0x93, 0xf8, 0x76, 0xea, 0xff, 0x7c, 0x3c, 0x2f, 0xac, 0xa7, 0xd2, 0x82, 0x98, 0x58, 0x4f, 0xa5, + 0x13, 0x62, 0xb2, 0xf8, 0x93, 0x24, 0xe4, 0x25, 0x6c, 0xb7, 0x4c, 0xc3, 0xc6, 0xbc, 0xfc, 0xaf, + 0x41, 0xd2, 0x39, 0x36, 0x68, 0xf9, 0xb3, 0xb7, 0xe7, 0x16, 0xbb, 0x5a, 0x7b, 0xb1, 0x66, 0x29, + 0x86, 0xad, 0xa8, 0x8e, 0x6e, 0x1a, 0x12, 0xc9, 0x8a, 0xde, 0x82, 0xac, 0x85, 0xed, 0x76, 0x13, + 0x53, 0x75, 0xd1, 0xaa, 0x65, 0x6f, 0x5f, 0x88, 0xe0, 0xac, 0xb6, 0x14, 0x43, 0x02, 0x96, 0x97, + 0xfc, 0x47, 0x17, 0x21, 0x6d, 0xb4, 0x9b, 0x44, 0x21, 0x36, 0xad, 0x6e, 0x52, 0x1a, 0x37, 0xda, + 0xcd, 0x0d, 0x7c, 0x62, 0xa3, 0x6f, 0xc2, 0x79, 0x0d, 0xb7, 0x2c, 0xac, 0x2a, 0x0e, 0xd6, 0x64, + 0x4b, 0x31, 0xea, 0x58, 0xd6, 0x8d, 0x3d, 0xd3, 0x2e, 0x8c, 0x2d, 0x24, 0x6f, 0x64, 0x6f, 0xbf, + 0x10, 0x21, 0x5f, 0x22, 0xb9, 0xd6, 0x8c, 0x3d, 0x73, 0x25, 0xf5, 0xe9, 0xe9, 0xfc, 0x88, 0x34, + 0xe3, 0x4b, 0xf0, 0x92, 0x6c, 0x54, 0x85, 0x09, 0x5e, 0x5c, 0x0b, 0x2b, 0xb6, 0x69, 0x14, 0xc6, + 0x17, 0x84, 0x1b, 0xf9, 0xdb, 0x8b, 0x51, 0x02, 0x43, 0xaa, 0x21, 0x8f, 0xed, 0x26, 0x96, 0x28, + 0x97, 0x94, 0xb3, 0x02, 0x4f, 0xe8, 0x12, 0x64, 0x48, 0x4d, 0x76, 0x4f, 0x1c, 0x6c, 0x17, 0xd2, + 0xb4, 0x2a, 0xa4, 0x6a, 0x2b, 0xe4, 0xb9, 0xf8, 0x2e, 0xe4, 0x82, 0xac, 0x08, 0x41, 0x5e, 0x2a, + 0x57, 0x77, 0x36, 0xcb, 0xf2, 0xce, 0xd6, 0xc6, 0xd6, 0xc3, 0xf7, 0xb6, 0xc4, 0x11, 0x34, 0x03, + 0x22, 0xa7, 0x6d, 0x94, 0xdf, 0x97, 0x1f, 0xac, 0x6d, 0xae, 0xd5, 0x44, 0x61, 0x36, 0xf5, 0xf7, + 0x7e, 0x32, 0x37, 0x52, 0x7c, 0x0c, 0x70, 0x1f, 0x3b, 0xbc, 0x9b, 0xa1, 0x15, 0x18, 0xdb, 0xa7, + 0xe5, 0x29, 0x08, 0x54, 0xd3, 0x0b, 0x91, 0x05, 0x0f, 0x74, 0xc9, 0x95, 0x34, 0xd1, 0xc6, 0xaf, + 0x4e, 0xe7, 0x05, 0x89, 0x73, 0xb2, 0x9e, 0x50, 0xfc, 0xf7, 0x02, 0x64, 0xa9, 0x60, 0x56, 0x4b, + 0x54, 0xea, 0x90, 0x7c, 0x79, 0xa0, 0x4a, 0xba, 0x45, 0xa3, 0x45, 0x18, 0x3d, 0x54, 0x1a, 0x6d, + 0x5c, 0x48, 0x50, 0x19, 0x85, 0x08, 0x19, 0x8f, 0x49, 0xba, 0xc4, 0xb2, 0xa1, 0xbb, 0x90, 0xd3, + 0x0d, 0x07, 0x1b, 0x8e, 0xcc, 0xd8, 0x92, 0x03, 0xd8, 0xb2, 0x2c, 0x37, 0x7d, 0x28, 0xfe, 0x1b, + 0x01, 0x60, 0xbb, 0x1d, 0xa7, 0x6a, 0xd0, 0xeb, 0x43, 0x96, 0x9f, 0xf7, 0x31, 0x5e, 0x8b, 0xf3, + 0x30, 0xa6, 0x1b, 0x0d, 0xdd, 0x60, 0xe5, 0x4f, 0x4b, 0xfc, 0x09, 0xcd, 0xc0, 0xe8, 0x6e, 0x43, + 0x37, 0x34, 0x3a, 0x2a, 0xd2, 0x12, 0x7b, 0xe0, 0xea, 0x97, 0x20, 0x4b, 0xcb, 0x1e, 0xa3, 0xf6, + 0x8b, 0xbf, 0x4c, 0xc0, 0xb9, 0x92, 0x69, 0x68, 0x3a, 0x19, 0x9e, 0x4a, 0xe3, 0x4b, 0xa1, 0x9b, + 0x75, 0x08, 0x0c, 0x44, 0x19, 0x1f, 0xb7, 0x86, 0x6c, 0x69, 0xe4, 0x73, 0x95, 0x8f, 0x5b, 0x94, + 0x16, 0xad, 0x4f, 0xf4, 0x3a, 0x5c, 0x50, 0x1a, 0x0d, 0xf3, 0x48, 0xd6, 0xf7, 0x64, 0xcd, 0xc4, + 0xb6, 0x6c, 0x98, 0x8e, 0x8c, 0x8f, 0x75, 0xdb, 0xa1, 0x66, 0x25, 0x2d, 0x4d, 0xd3, 0xe4, 0xb5, + 0xbd, 0x55, 0x13, 0xdb, 0x5b, 0xa6, 0x53, 0x26, 0x49, 0x64, 0xcc, 0x92, 0xc2, 0xb0, 0x31, 0x3b, + 0x46, 0x0c, 0xb2, 0x94, 0xc6, 0xc7, 0x2d, 0x3a, 0x66, 0x79, 0x13, 0x7d, 0x08, 0xe7, 0x3b, 0xb5, + 0x19, 0x67, 0x6b, 0xfd, 0x37, 0x01, 0xf2, 0x6b, 0x86, 0xee, 0x7c, 0x29, 0x9a, 0xc9, 0x53, 0x6d, + 0x32, 0xa8, 0xda, 0x9b, 0x20, 0xee, 0x29, 0x7a, 0xe3, 0xa1, 0x51, 0x33, 0x9b, 0xbb, 0xb6, 0x63, + 0x1a, 0xd8, 0xe6, 0xba, 0xef, 0xa2, 0x73, 0x9d, 0x3d, 0x86, 0x49, 0xaf, 0x4e, 0x71, 0x2a, 0xeb, + 0x29, 0x88, 0x6b, 0x86, 0x6a, 0xe1, 0x26, 0x36, 0x62, 0xd5, 0xd6, 0x0b, 0x90, 0xd1, 0x5d, 0xb9, + 0x54, 0x63, 0x49, 0xc9, 0x27, 0xf0, 0x3a, 0xb5, 0x61, 0x2a, 0xf0, 0xee, 0x38, 0xcd, 0x25, 0x99, + 0x38, 0xf0, 0x91, 0xec, 0xb7, 0x17, 0x99, 0x38, 0xf0, 0x11, 0x33, 0x6f, 0xef, 0xc3, 0xc4, 0x2a, + 0x6e, 0x60, 0x07, 0xc7, 0x6f, 0xfb, 0x77, 0x20, 0xef, 0x8a, 0x8e, 0xb3, 0x91, 0x7e, 0x24, 0x00, + 0xe2, 0x72, 0xc9, 0x8c, 0x1b, 0x67, 0x3b, 0xcd, 0x13, 0x37, 0xc3, 0x69, 0x5b, 0x06, 0xf3, 0x17, + 0x58, 0x2f, 0x05, 0x46, 0xa2, 0x2e, 0x83, 0x6f, 0x83, 0x53, 0x41, 0x1b, 0xec, 0xb9, 0x3d, 0xc4, + 0xe1, 0x39, 0x82, 0xe9, 0x50, 0xf1, 0xe2, 0x6d, 0xca, 0x14, 0x2d, 0x59, 0x62, 0x21, 0x19, 0xf4, + 0xed, 0x28, 0xb1, 0xf8, 0x21, 0x4c, 0x95, 0x1a, 0x58, 0xb1, 0xe2, 0x56, 0x0b, 0x6f, 0xce, 0xf7, + 0x01, 0x05, 0xc5, 0xc7, 0xd9, 0xa4, 0xff, 0x4c, 0x00, 0x24, 0xe1, 0x43, 0x6c, 0x39, 0xb1, 0x37, + 0xe9, 0x2a, 0x64, 0x1d, 0xc5, 0xaa, 0x63, 0x47, 0x26, 0xfe, 0x38, 0x37, 0x57, 0x2f, 0x06, 0x04, + 0x11, 0xaf, 0x7c, 0x71, 0xbf, 0xa1, 0x2e, 0xd6, 0x5c, 0x7f, 0x9d, 0xdb, 0x2c, 0x60, 0x7c, 0x84, + 0xcc, 0x35, 0xf0, 0x01, 0x4c, 0x87, 0x4a, 0x19, 0xa7, 0x0a, 0xfe, 0x44, 0x80, 0x6c, 0x55, 0x55, + 0x8c, 0x38, 0xeb, 0xfe, 0x2e, 0x64, 0x6d, 0x55, 0x31, 0xe4, 0x3d, 0xd3, 0x6a, 0x2a, 0x0e, 0xed, + 0xb2, 0xf9, 0x50, 0xdd, 0x3d, 0xaf, 0x59, 0x55, 0x8c, 0x7b, 0x34, 0x93, 0x04, 0xb6, 0xf7, 0x1f, + 0x3d, 0x82, 0xec, 0x01, 0x3e, 0x91, 0x39, 0xba, 0xa2, 0xf3, 0x5c, 0xfe, 0xf6, 0x6b, 0x01, 0xfe, + 0x83, 0xc3, 0x45, 0x17, 0x94, 0x2d, 0x06, 0x40, 0xd9, 0x22, 0xe1, 0x58, 0xac, 0x3a, 0x16, 0x36, + 0xea, 0xce, 0xbe, 0x04, 0x07, 0xf8, 0xe4, 0x01, 0x93, 0x11, 0x1c, 0x28, 0xeb, 0xa9, 0x74, 0x52, + 0x4c, 0x15, 0xff, 0x54, 0x80, 0x1c, 0xab, 0x78, 0x9c, 0x03, 0xe5, 0x0d, 0x48, 0x59, 0xe6, 0x11, + 0x1b, 0x28, 0xd9, 0xdb, 0x97, 0x22, 0x44, 0x6c, 0xe0, 0x93, 0xe0, 0x0c, 0x45, 0xb3, 0xa3, 0x15, + 0xe0, 0xbe, 0x9f, 0x4c, 0xb9, 0x93, 0xc3, 0x72, 0x03, 0xe3, 0x92, 0x88, 0x8c, 0xeb, 0x30, 0xb9, + 0xab, 0x38, 0xea, 0xbe, 0x6c, 0xf1, 0x42, 0x92, 0xd9, 0x2c, 0x79, 0x23, 0x27, 0xe5, 0x29, 0xd9, + 0x2d, 0xba, 0x5d, 0xfc, 0x33, 0xb7, 0xd7, 0xdb, 0xf8, 0x8f, 0xb2, 0xe5, 0xff, 0x5c, 0xe0, 0xe3, + 0xc9, 0xad, 0xff, 0x1f, 0x5b, 0x07, 0xf8, 0x71, 0x02, 0x2e, 0x94, 0xf6, 0xb1, 0x7a, 0x50, 0x32, + 0x0d, 0x5b, 0xb7, 0x1d, 0xa2, 0xc1, 0x38, 0x7b, 0xc1, 0x25, 0xc8, 0x1c, 0xe9, 0xce, 0xbe, 0xac, + 0xe9, 0x7b, 0x7b, 0xd4, 0xf2, 0xa5, 0xa5, 0x34, 0x21, 0xac, 0xea, 0x7b, 0x7b, 0xe8, 0x0e, 0xa4, + 0x9a, 0xa6, 0xc6, 0x5c, 0xe4, 0xfc, 0xed, 0xf9, 0x08, 0xf1, 0xb4, 0x68, 0x76, 0xbb, 0xb9, 0x69, + 0x6a, 0x58, 0xa2, 0x99, 0xd1, 0x1c, 0x80, 0x4a, 0xa8, 0x2d, 0x53, 0x37, 0x1c, 0x3e, 0x07, 0x06, + 0x28, 0xa8, 0x02, 0x19, 0x07, 0x5b, 0x4d, 0xdd, 0x50, 0x1c, 0x5c, 0x18, 0xa5, 0xca, 0xbb, 0x12, + 0x59, 0xf0, 0x56, 0x43, 0x57, 0x95, 0x55, 0x6c, 0xab, 0x96, 0xde, 0x72, 0x4c, 0x8b, 0x6b, 0xd1, + 0x67, 0xe6, 0x16, 0xf7, 0xa3, 0x14, 0x14, 0xba, 0x35, 0x14, 0x67, 0x3f, 0xd9, 0x86, 0x31, 0x82, + 0xb2, 0x1b, 0x0e, 0xef, 0x29, 0xb7, 0x7b, 0x29, 0x22, 0xa2, 0x04, 0x14, 0xad, 0x37, 0x1c, 0x5e, + 0x78, 0x2e, 0x67, 0xf6, 0xe7, 0x02, 0x8c, 0xb1, 0x04, 0x74, 0x0b, 0xd2, 0x7c, 0x59, 0x41, 0xa3, + 0x65, 0x4c, 0xae, 0x9c, 0x7f, 0x76, 0x3a, 0x3f, 0xce, 0x56, 0x0a, 0x56, 0x3f, 0xf3, 0xff, 0x4a, + 0xe3, 0x34, 0xdf, 0x9a, 0x46, 0xda, 0xcc, 0x76, 0x14, 0xcb, 0xa1, 0x4b, 0x38, 0x09, 0x86, 0x18, + 0x28, 0x61, 0x03, 0x9f, 0xa0, 0x75, 0x18, 0xb3, 0x1d, 0xc5, 0x69, 0xdb, 0xbc, 0xd5, 0xce, 0x54, + 0xd8, 0x2a, 0xe5, 0x94, 0xb8, 0x04, 0xe2, 0xca, 0x68, 0xd8, 0x51, 0xf4, 0x06, 0x6d, 0xc6, 0x8c, + 0xc4, 0x9f, 0x8a, 0x3f, 0x14, 0x60, 0x8c, 0x65, 0x45, 0x17, 0x60, 0x5a, 0x5a, 0xde, 0xba, 0x5f, + 0x96, 0xd7, 0xb6, 0x56, 0xcb, 0xb5, 0xb2, 0xb4, 0xb9, 0xb6, 0xb5, 0x5c, 0x2b, 0x8b, 0x23, 0xe8, + 0x3c, 0x20, 0x37, 0xa1, 0xf4, 0x70, 0xab, 0xba, 0x56, 0xad, 0x95, 0xb7, 0x6a, 0xa2, 0x40, 0x57, + 0x18, 0x28, 0x3d, 0x40, 0x4d, 0xa0, 0x2b, 0xb0, 0xd0, 0x49, 0x95, 0xab, 0xb5, 0xe5, 0x5a, 0x55, + 0x2e, 0x57, 0x6b, 0x6b, 0x9b, 0xcb, 0xb5, 0xf2, 0xaa, 0x98, 0xec, 0x93, 0x8b, 0xbc, 0x44, 0x92, + 0xca, 0xa5, 0x9a, 0x98, 0x2a, 0x3e, 0x85, 0x73, 0x12, 0x56, 0xcd, 0x66, 0xab, 0xed, 0x60, 0x52, + 0x4a, 0x3b, 0xce, 0xf1, 0x72, 0x01, 0xc6, 0x35, 0xeb, 0x44, 0xb6, 0xda, 0x06, 0x1f, 0x2d, 0x63, + 0x9a, 0x75, 0x22, 0xb5, 0x0d, 0xde, 0x19, 0xff, 0xa5, 0x00, 0xe7, 0x3b, 0x5f, 0x1e, 0x67, 0x57, + 0x7c, 0x04, 0x59, 0x45, 0xd3, 0xb0, 0x26, 0x6b, 0xb8, 0xe1, 0x28, 0xdc, 0x55, 0xb9, 0x19, 0x90, + 0xc4, 0x97, 0xdf, 0x16, 0xbd, 0xe5, 0xb7, 0xcd, 0xc7, 0xa5, 0x12, 0x2d, 0xc8, 0x2a, 0xe1, 0x70, + 0x4d, 0x11, 0x15, 0x42, 0x29, 0xc5, 0x7f, 0x95, 0x82, 0x89, 0xb2, 0xa1, 0xd5, 0x8e, 0x63, 0x9d, + 0x5d, 0xce, 0xc3, 0x98, 0x6a, 0x36, 0x9b, 0xba, 0xe3, 0xaa, 0x89, 0x3d, 0xa1, 0xaf, 0x42, 0x5a, + 0xc3, 0x8a, 0xe6, 0xad, 0x51, 0x0c, 0x72, 0xb4, 0x24, 0x2f, 0x3b, 0xfa, 0x0e, 0x5c, 0x20, 0x16, + 0xd4, 0x32, 0x94, 0x86, 0xcc, 0xa4, 0xc9, 0x8e, 0xa5, 0xd7, 0xeb, 0xd8, 0xe2, 0x8b, 0x7d, 0x37, + 0x22, 0xca, 0xb9, 0xc6, 0x39, 0x4a, 0x94, 0xa1, 0xc6, 0xf2, 0x4b, 0xe7, 0xf4, 0x28, 0x32, 0x7a, + 0x07, 0x80, 0x4c, 0x4e, 0x74, 0x01, 0xd1, 0xe6, 0xb6, 0xa9, 0xd7, 0x0a, 0xa2, 0x6b, 0x8e, 0x08, + 0x03, 0x79, 0xb6, 0xd1, 0x12, 0x41, 0x06, 0x4f, 0xda, 0xba, 0x85, 0xe5, 0x5b, 0x2d, 0x95, 0x42, + 0xf9, 0xf4, 0x4a, 0xfe, 0xd9, 0xe9, 0x3c, 0x48, 0x8c, 0x7c, 0x6b, 0xbb, 0x44, 0x90, 0x02, 0xfb, + 0xdf, 0x52, 0xd1, 0x0a, 0xcc, 0x91, 0x09, 0x98, 0xd7, 0x45, 0x71, 0xe4, 0x7d, 0xbd, 0xbe, 0x8f, + 0x2d, 0xd9, 0x5b, 0x15, 0xa6, 0x4b, 0x78, 0x69, 0x69, 0x56, 0x55, 0x0c, 0x56, 0xd0, 0x65, 0xa7, + 0x42, 0xb3, 0x78, 0xea, 0x21, 0x7a, 0x6e, 0x99, 0xba, 0x6d, 0x1a, 0x85, 0x0c, 0xd3, 0x33, 0x7b, 0x42, 0x8f, 0x40, 0xd4, 0x0d, 0x79, 0xaf, 0xa1, 0xd7, 0xf7, 0x1d, 0xf9, 0xc8, 0xd2, 0x1d, 0x6c, - 0xe7, 0xa7, 0x69, 0x85, 0xc2, 0xfa, 0x5d, 0x95, 0xaf, 0xcd, 0x6a, 0xef, 0x91, 0x9c, 0xbc, 0x6a, - 0x39, 0xdd, 0xb8, 0x47, 0xf9, 0x29, 0xd1, 0xf6, 0x66, 0xe7, 0x09, 0x31, 0x55, 0xf8, 0x53, 0x01, - 0x72, 0x6e, 0xa7, 0x89, 0xb2, 0x7f, 0xdf, 0x00, 0xd1, 0x34, 0xb0, 0xdc, 0xda, 0x57, 0x6c, 0xcc, - 0x15, 0xc3, 0xa7, 0x90, 0x9c, 0x69, 0xe0, 0x6d, 0x42, 0x66, 0x9a, 0x40, 0xdb, 0x30, 0x6d, 0x3b, - 0x4a, 0x5d, 0x37, 0xea, 0x01, 0x7d, 0x8d, 0x8f, 0xee, 0xba, 0x8b, 0x9c, 0xdb, 0xa3, 0x77, 0xf8, - 0x1d, 0xbf, 0x14, 0x60, 0x7a, 0x45, 0x6b, 0xea, 0x46, 0xb5, 0xd5, 0xd0, 0x23, 0xc5, 0xf9, 0x57, - 0x20, 0x6d, 0x13, 0x99, 0xbe, 0xf1, 0xf6, 0x31, 0x5a, 0x8a, 0xa6, 0x10, 0x2b, 0xfe, 0x00, 0xa6, - 0xf0, 0x71, 0x4b, 0xb7, 0x14, 0x47, 0x37, 0x0d, 0x06, 0x4b, 0x12, 0xa3, 0xd7, 0x2d, 0xe7, 0xf3, - 0xfa, 0xd0, 0x84, 0xd7, 0xec, 0x7d, 0x40, 0xc1, 0x8a, 0x45, 0x89, 0x4f, 0x64, 0x98, 0xa1, 0xa2, - 0x77, 0x0c, 0x3b, 0x62, 0xad, 0x71, 0xeb, 0xfa, 0x0d, 0x98, 0xed, 0x7c, 0x41, 0x94, 0xa5, 0xff, - 0x90, 0xb7, 0xf8, 0x26, 0xb6, 0x3e, 0x27, 0x68, 0x1c, 0x14, 0x1f, 0x65, 0xc9, 0xbf, 0x27, 0xc0, - 0x45, 0x2a, 0x9b, 0xee, 0x89, 0xec, 0x61, 0xeb, 0x01, 0x56, 0xec, 0x48, 0x11, 0xf2, 0x4b, 0x90, - 0x64, 0x48, 0x97, 0xf6, 0xd8, 0xf1, 0xd5, 0x0c, 0xf1, 0x4b, 0xaa, 0x8e, 0x69, 0x11, 0xbf, 0x84, - 0x27, 0xf1, 0x7a, 0x2a, 0x30, 0x17, 0x56, 0x96, 0x88, 0x97, 0x02, 0xa6, 0xb9, 0x7b, 0x48, 0xba, - 0x78, 0x71, 0x9f, 0xf8, 0x45, 0xa8, 0x04, 0x19, 0x95, 0xfe, 0x93, 0x9d, 0x93, 0x16, 0xa6, 0xf2, - 0x73, 0x83, 0x3c, 0x4b, 0xc6, 0x56, 0x3b, 0x69, 0x61, 0xe2, 0x9e, 0xba, 0xff, 0x89, 0xba, 0x02, - 0x55, 0x1d, 0xe8, 0x9b, 0xd2, 0xf1, 0x45, 0xf3, 0xba, 0xee, 0x5d, 0x87, 0x26, 0xfe, 0x5b, 0x9c, - 0xab, 0x82, 0xbd, 0x89, 0x33, 0x45, 0xea, 0x8d, 0x7c, 0xd0, 0xb1, 0x3d, 0x15, 0xac, 0x7e, 0xec, - 0x0c, 0xd5, 0x0f, 0xac, 0x8b, 0xfb, 0x54, 0xf4, 0x3e, 0x04, 0x56, 0xbe, 0x65, 0x56, 0x33, 0x17, - 0xed, 0x9c, 0x45, 0x29, 0xd3, 0xbe, 0x14, 0x46, 0xb7, 0x51, 0x11, 0x52, 0xf8, 0xb8, 0x25, 0x6b, - 0xd8, 0x56, 0xb9, 0x59, 0x2b, 0xf4, 0xdb, 0x47, 0xeb, 0xf1, 0xff, 0x27, 0xf0, 0x71, 0x8b, 0x10, - 0xd1, 0x0e, 0x99, 0xe1, 0x5c, 0x77, 0x80, 0x16, 0xdb, 0x1e, 0x0e, 0x27, 0xfc, 0xfe, 0xc2, 0xc5, - 0x4d, 0x79, 0x9e, 0x00, 0x13, 0xc1, 0xdb, 0xee, 0x63, 0x01, 0x2e, 0x85, 0xb6, 0x5d, 0x94, 0x93, - 0xdd, 0x3b, 0x90, 0xa0, 0x2a, 0x88, 0x9d, 0x51, 0x05, 0x94, 0xab, 0xf0, 0x13, 0x77, 0xd4, 0x4b, - 0xb8, 0x61, 0x12, 0xf5, 0x7e, 0x0e, 0xeb, 0x62, 0x13, 0x6e, 0xb3, 0xc7, 0xce, 0xdc, 0xec, 0x2e, - 0x6b, 0x97, 0x59, 0xe8, 0x2a, 0x6c, 0x94, 0x66, 0xe1, 0xdf, 0x08, 0x30, 0x53, 0xc6, 0x8a, 0xe5, - 0xec, 0x62, 0xc5, 0x89, 0xd8, 0x9d, 0x7d, 0x03, 0xe2, 0x86, 0x79, 0x74, 0x96, 0xa5, 0x41, 0x92, - 0xdf, 0x9f, 0xb6, 0x3a, 0xcb, 0x15, 0x65, 0xad, 0xff, 0x6f, 0x0c, 0xd2, 0xf7, 0x8b, 0x51, 0xd6, - 0xf5, 0x1d, 0xbe, 0x80, 0xcc, 0x86, 0x7a, 0x58, 0xb7, 0xf4, 0xde, 0xb7, 0x74, 0xbf, 0xb8, 0x81, - 0x4f, 0xdc, 0x6e, 0x49, 0xb8, 0xd0, 0x0a, 0xa4, 0x9d, 0x7d, 0x0b, 0xdb, 0xfb, 0x66, 0x43, 0x3b, - 0x8b, 0xcf, 0xe2, 0x73, 0xcd, 0x1d, 0xc0, 0x38, 0x95, 0xeb, 0x06, 0x31, 0x08, 0x21, 0x41, 0x0c, - 0xe4, 0x35, 0x9e, 0xdb, 0x17, 0x3b, 0xcb, 0x6b, 0x5c, 0x02, 0x6b, 0x1c, 0xcf, 0x37, 0x1a, 0x17, - 0x93, 0x85, 0x47, 0x00, 0xa4, 0x6a, 0x51, 0x36, 0xcf, 0xbf, 0x8c, 0x43, 0x6e, 0xbb, 0x6d, 0xef, - 0x47, 0xdc, 0x1f, 0x8b, 0x00, 0xad, 0xb6, 0x4d, 0xc1, 0xc2, 0xb1, 0xc1, 0xeb, 0x3f, 0x24, 0x4a, - 0xc2, 0x55, 0x00, 0xe3, 0xab, 0x1d, 0x1b, 0xa8, 0xcc, 0x85, 0x60, 0xd9, 0x0f, 0xb5, 0x78, 0x69, - 0x10, 0x96, 0xac, 0x1d, 0x1b, 0x9b, 0xd8, 0x03, 0x91, 0x4c, 0x12, 0x26, 0x92, 0xde, 0x81, 0x09, - 0xf2, 0x20, 0x3b, 0xe6, 0x59, 0x9a, 0x3c, 0x49, 0x78, 0x6a, 0x26, 0xba, 0x0b, 0x69, 0xc6, 0x4d, - 0x26, 0xae, 0x24, 0x9d, 0xb8, 0xc2, 0xea, 0xc2, 0xd5, 0x48, 0xa7, 0xac, 0x14, 0x65, 0x25, 0xd3, - 0xd4, 0x2c, 0x8c, 0xef, 0x99, 0x96, 0x8a, 0x69, 0xfc, 0x44, 0x4a, 0x62, 0x0f, 0xc1, 0x56, 0x5d, - 0x4f, 0xa4, 0x52, 0x62, 0x7a, 0x3d, 0x91, 0x4a, 0x8b, 0x50, 0xf8, 0xbe, 0x00, 0x53, 0x5e, 0x73, - 0x44, 0x69, 0xcb, 0x8b, 0x1d, 0xba, 0x3c, 0x7b, 0x83, 0x10, 0x35, 0x16, 0xfe, 0x1f, 0x75, 0x6c, - 0x54, 0xf3, 0x90, 0xb6, 0x4f, 0x94, 0xfd, 0xe5, 0x2e, 0x0b, 0xa7, 0x89, 0x9d, 0xb5, 0x8d, 0x69, - 0x64, 0xcd, 0x2d, 0x98, 0xd5, 0x9b, 0xc4, 0xca, 0xeb, 0x4e, 0xe3, 0x84, 0xa3, 0x32, 0x07, 0xbb, - 0x3b, 0xb4, 0x33, 0x7e, 0x5a, 0xd1, 0x4d, 0xe2, 0x86, 0x8f, 0xed, 0xd9, 0xf8, 0xf5, 0x89, 0x52, - 0xe1, 0x15, 0x98, 0xb4, 0x98, 0x68, 0xe2, 0x9d, 0x9c, 0x51, 0xe7, 0x59, 0x8f, 0x95, 0xa8, 0xfd, - 0xc7, 0x31, 0x98, 0x7a, 0xd4, 0xc6, 0xd6, 0xc9, 0x17, 0x49, 0xe9, 0xd7, 0x60, 0xea, 0x48, 0xd1, - 0x1d, 0x79, 0xcf, 0xb4, 0xe4, 0x76, 0x4b, 0x53, 0x1c, 0x37, 0xa6, 0x63, 0x92, 0x90, 0xef, 0x99, + 0x17, 0xa6, 0x68, 0x85, 0xa2, 0xfa, 0x5d, 0x95, 0xaf, 0xcd, 0x6a, 0xef, 0x91, 0x9c, 0xbc, 0x6a, + 0x79, 0xdd, 0xb8, 0x47, 0xf9, 0x29, 0xd1, 0xf6, 0x66, 0xe7, 0x71, 0x31, 0x5d, 0xfc, 0x5f, 0x02, + 0xe4, 0xdd, 0x4e, 0x13, 0x67, 0xff, 0xbe, 0x01, 0xa2, 0x69, 0x60, 0xb9, 0xb5, 0xaf, 0xd8, 0x98, + 0x2b, 0x86, 0x4f, 0x21, 0x79, 0xd3, 0xc0, 0xdb, 0x84, 0xcc, 0x34, 0x81, 0xb6, 0x61, 0xca, 0x76, + 0x94, 0xba, 0x6e, 0xd4, 0x03, 0xfa, 0x1a, 0x1d, 0xde, 0x75, 0x17, 0x39, 0xb7, 0x47, 0x0f, 0xf9, + 0x1d, 0xbf, 0x16, 0x60, 0x6a, 0x59, 0x6b, 0xea, 0x46, 0xb5, 0xd5, 0xd0, 0x63, 0xc5, 0xf9, 0x57, + 0x20, 0x63, 0x13, 0x99, 0xbe, 0xf1, 0xf6, 0x31, 0x5a, 0x9a, 0xa6, 0x10, 0x2b, 0xfe, 0x00, 0x26, + 0xf1, 0x71, 0x4b, 0xb7, 0x14, 0x47, 0x37, 0x0d, 0x06, 0x4b, 0x52, 0xc3, 0xd7, 0x2d, 0xef, 0xf3, + 0xfa, 0xd0, 0x84, 0xd7, 0xec, 0x7d, 0x40, 0xc1, 0x8a, 0xc5, 0x89, 0x4f, 0x64, 0x98, 0xa6, 0xa2, + 0x77, 0x0c, 0x3b, 0x66, 0xad, 0x71, 0xeb, 0xfa, 0x2d, 0x98, 0x09, 0xbf, 0x20, 0xce, 0xd2, 0x7f, + 0xc8, 0x5b, 0x7c, 0x13, 0x5b, 0x5f, 0x10, 0x34, 0x0e, 0x8a, 0x8f, 0xb3, 0xe4, 0x3f, 0x10, 0xe0, + 0x22, 0x95, 0x4d, 0xf7, 0x44, 0xf6, 0xb0, 0xf5, 0x00, 0x2b, 0x76, 0xac, 0x08, 0xf9, 0x25, 0x18, + 0x63, 0x48, 0x97, 0xf6, 0xd8, 0xd1, 0x95, 0x2c, 0xf1, 0x4b, 0xaa, 0x8e, 0x69, 0x11, 0xbf, 0x84, + 0x27, 0xf1, 0x7a, 0x2a, 0x30, 0x1b, 0x55, 0x96, 0x98, 0x97, 0x02, 0xa6, 0xb8, 0x7b, 0x48, 0xba, + 0x78, 0x69, 0x9f, 0xf8, 0x45, 0xa8, 0x0c, 0x59, 0x95, 0xfe, 0x93, 0x9d, 0x93, 0x16, 0xa6, 0xf2, + 0xf3, 0xfd, 0x3c, 0x4b, 0xc6, 0x56, 0x3b, 0x69, 0x61, 0xe2, 0x9e, 0xba, 0xff, 0x89, 0xba, 0x02, + 0x55, 0xed, 0xeb, 0x9b, 0xd2, 0xf1, 0x45, 0xf3, 0xba, 0xee, 0x5d, 0x48, 0x13, 0xff, 0x3a, 0xc9, + 0x55, 0xc1, 0xde, 0xc4, 0x99, 0x62, 0xf5, 0x46, 0x3e, 0x08, 0x6d, 0x4f, 0x05, 0xab, 0x9f, 0x38, + 0x43, 0xf5, 0x03, 0xeb, 0xe2, 0x3e, 0x15, 0xbd, 0x0f, 0x81, 0x95, 0x6f, 0x99, 0xd5, 0xcc, 0x45, + 0x3b, 0x67, 0x51, 0xca, 0x94, 0x2f, 0x85, 0xd1, 0x6d, 0x54, 0x82, 0x34, 0x3e, 0x6e, 0xc9, 0x1a, + 0xb6, 0x55, 0x6e, 0xd6, 0x8a, 0xbd, 0xf6, 0xd1, 0xba, 0xfc, 0xff, 0x71, 0x7c, 0xdc, 0x22, 0x44, + 0xb4, 0x43, 0x66, 0x38, 0xd7, 0x1d, 0xa0, 0xc5, 0xb6, 0x07, 0xc3, 0x09, 0xbf, 0xbf, 0x70, 0x71, + 0x93, 0x9e, 0x27, 0xc0, 0x44, 0xf0, 0xb6, 0xfb, 0x58, 0x80, 0x4b, 0x91, 0x6d, 0x17, 0xe7, 0x64, + 0xf7, 0x0e, 0xa4, 0xa8, 0x0a, 0x12, 0x67, 0x54, 0x01, 0xe5, 0x2a, 0xfe, 0xcc, 0x1d, 0xf5, 0x12, + 0x6e, 0x98, 0x44, 0xbd, 0x5f, 0xc0, 0xba, 0xd8, 0xb8, 0xdb, 0xec, 0x89, 0x33, 0x37, 0xbb, 0xcb, + 0xda, 0x61, 0x16, 0x3a, 0x0a, 0x1b, 0xa7, 0x59, 0xf8, 0x47, 0x02, 0x4c, 0x57, 0xb0, 0x62, 0x39, + 0xbb, 0x58, 0x71, 0x62, 0x76, 0x67, 0xdf, 0x80, 0xa4, 0x61, 0x1e, 0x9d, 0x65, 0x69, 0x90, 0xe4, + 0xf7, 0xa7, 0xad, 0x70, 0xb9, 0xe2, 0xac, 0xf5, 0x7f, 0x4e, 0x40, 0xe6, 0x7e, 0x29, 0xce, 0xba, + 0xbe, 0xc3, 0x17, 0x90, 0xd9, 0x50, 0x8f, 0xea, 0x96, 0xde, 0xfb, 0x16, 0xef, 0x97, 0x36, 0xf0, + 0x89, 0xdb, 0x2d, 0x09, 0x17, 0x5a, 0x86, 0x8c, 0xb3, 0x6f, 0x61, 0x7b, 0xdf, 0x6c, 0x68, 0x67, + 0xf1, 0x59, 0x7c, 0xae, 0xd9, 0x03, 0x18, 0xa5, 0x72, 0xdd, 0x20, 0x06, 0x21, 0x22, 0x88, 0x81, + 0xbc, 0xc6, 0x73, 0xfb, 0x12, 0x67, 0x79, 0x8d, 0x4b, 0x60, 0x8d, 0xe3, 0xf9, 0x46, 0xa3, 0xe2, + 0x58, 0xf1, 0x11, 0x00, 0xa9, 0x5a, 0x9c, 0xcd, 0xf3, 0xf7, 0x93, 0x90, 0xdf, 0x6e, 0xdb, 0xfb, + 0x31, 0xf7, 0xc7, 0x12, 0x40, 0xab, 0x6d, 0x53, 0xb0, 0x70, 0x6c, 0xf0, 0xfa, 0x0f, 0x88, 0x92, + 0x70, 0x15, 0xc0, 0xf8, 0x6a, 0xc7, 0x06, 0xaa, 0x70, 0x21, 0x58, 0xf6, 0x43, 0x2d, 0x5e, 0xea, + 0x87, 0x25, 0x6b, 0xc7, 0xc6, 0x26, 0xf6, 0x40, 0x24, 0x93, 0x84, 0x89, 0xa4, 0x77, 0x60, 0x9c, + 0x3c, 0xc8, 0x8e, 0x79, 0x96, 0x26, 0x1f, 0x23, 0x3c, 0x35, 0x13, 0xdd, 0x85, 0x0c, 0xe3, 0x26, + 0x13, 0xd7, 0x18, 0x9d, 0xb8, 0xa2, 0xea, 0xc2, 0xd5, 0x48, 0xa7, 0xac, 0x34, 0x65, 0x25, 0xd3, + 0xd4, 0x0c, 0x8c, 0xee, 0x99, 0x96, 0x8a, 0x69, 0xfc, 0x44, 0x5a, 0x62, 0x0f, 0xc1, 0x56, 0x5d, + 0x4f, 0xa5, 0xd3, 0x62, 0x66, 0x3d, 0x95, 0xce, 0x88, 0x50, 0xfc, 0xa1, 0x00, 0x93, 0x5e, 0x73, + 0xc4, 0x69, 0xcb, 0x4b, 0x21, 0x5d, 0x9e, 0xbd, 0x41, 0x88, 0x1a, 0x8b, 0xff, 0x85, 0x3a, 0x36, + 0xaa, 0x79, 0x48, 0xdb, 0x27, 0xce, 0xfe, 0x72, 0x97, 0x85, 0xd3, 0x24, 0xce, 0xda, 0xc6, 0x34, + 0xb2, 0xe6, 0x16, 0xcc, 0xe8, 0x4d, 0x62, 0xe5, 0x75, 0xa7, 0x71, 0xc2, 0x51, 0x99, 0x83, 0xdd, + 0x1d, 0xda, 0x69, 0x3f, 0xad, 0xe4, 0x26, 0x71, 0xc3, 0xc7, 0xf6, 0x6c, 0xfc, 0xfa, 0xc4, 0xa9, + 0xf0, 0x35, 0x98, 0xb0, 0x98, 0x68, 0xe2, 0x9d, 0x9c, 0x51, 0xe7, 0x39, 0x8f, 0x95, 0xa8, 0xfd, + 0xa7, 0x09, 0x98, 0x7c, 0xd4, 0xc6, 0xd6, 0xc9, 0x97, 0x49, 0xe9, 0xd7, 0x60, 0xf2, 0x48, 0xd1, + 0x1d, 0x79, 0xcf, 0xb4, 0xe4, 0x76, 0x4b, 0x53, 0x1c, 0x37, 0xa6, 0x63, 0x82, 0x90, 0xef, 0x99, 0xd6, 0x0e, 0x25, 0x22, 0x0c, 0xe8, 0xc0, 0x30, 0x8f, 0x0c, 0x99, 0x90, 0x29, 0x1a, 0x3e, 0x36, - 0xf8, 0x62, 0xf2, 0xea, 0x9b, 0x7f, 0x72, 0xba, 0x70, 0x67, 0xa4, 0xa8, 0x2d, 0x1a, 0x77, 0xd6, - 0x6e, 0xeb, 0xda, 0xd2, 0xce, 0x4e, 0x65, 0x4d, 0x12, 0xa9, 0xc8, 0xf7, 0x98, 0xc4, 0xda, 0xb1, - 0xe1, 0xce, 0xe2, 0x9f, 0x09, 0x20, 0xfa, 0x9a, 0x8a, 0xb2, 0x39, 0x4b, 0x90, 0x79, 0xd2, 0xc6, - 0x96, 0xfe, 0x1c, 0x8d, 0x09, 0x9c, 0x91, 0x18, 0xa2, 0x0f, 0x20, 0xdb, 0xa1, 0x87, 0xf8, 0xef, - 0xa7, 0x87, 0xcc, 0x91, 0xaf, 0x82, 0xc2, 0xff, 0x11, 0x00, 0xd1, 0xca, 0x57, 0xd8, 0x3a, 0xfe, - 0x17, 0xa5, 0xa7, 0xdc, 0x00, 0x91, 0x46, 0x2c, 0xca, 0xfa, 0x9e, 0xdc, 0xd4, 0x6d, 0x5b, 0x37, - 0xea, 0xbc, 0xab, 0xe4, 0x28, 0xbd, 0xb2, 0xb7, 0xc9, 0xa8, 0xbc, 0x11, 0xff, 0x31, 0xcc, 0x74, - 0x54, 0x23, 0xca, 0x66, 0xbc, 0x0c, 0xd9, 0x3d, 0xb3, 0x6d, 0x68, 0x32, 0xdb, 0xeb, 0xe0, 0x8b, - 0x7f, 0x19, 0x4a, 0x63, 0xef, 0x2b, 0xfc, 0x65, 0x0c, 0x66, 0x25, 0x6c, 0x9b, 0x8d, 0x43, 0x1c, - 0xbd, 0x22, 0xcb, 0xc0, 0x77, 0x59, 0xe4, 0xe7, 0xd2, 0x67, 0x9a, 0x31, 0xb3, 0x29, 0xad, 0x73, - 0x1d, 0xfd, 0xca, 0xe0, 0xbe, 0xd8, 0xbb, 0x72, 0xce, 0x97, 0xe5, 0x12, 0x1d, 0xcb, 0x72, 0x26, - 0x4c, 0xe9, 0x75, 0xc3, 0x24, 0x36, 0xcb, 0xc6, 0x4f, 0x8c, 0x76, 0xd3, 0xc5, 0x2c, 0x4b, 0x83, - 0x0a, 0x59, 0x61, 0x2c, 0x55, 0xfc, 0x64, 0xab, 0xdd, 0xa4, 0x9e, 0xf3, 0xea, 0x79, 0x52, 0xde, - 0x67, 0xa7, 0x0b, 0xb9, 0x8e, 0x34, 0x5b, 0xca, 0xe9, 0xde, 0x33, 0x91, 0xce, 0x9b, 0xfc, 0x9b, - 0x70, 0xae, 0x4b, 0xe5, 0x51, 0xfa, 0x38, 0xff, 0x2b, 0x0e, 0x17, 0x3b, 0xc5, 0x47, 0x8d, 0x44, - 0xbe, 0xe8, 0xcd, 0x5a, 0x86, 0xc9, 0xa6, 0x6e, 0x3c, 0xdf, 0x42, 0x64, 0xb6, 0xa9, 0x1b, 0xfe, - 0x7a, 0x6e, 0x48, 0x07, 0x49, 0xfe, 0x3d, 0x74, 0x10, 0x05, 0xe6, 0xc2, 0x5a, 0x30, 0xca, 0x5e, - 0xf2, 0x91, 0x00, 0xd9, 0xa8, 0xd7, 0xd6, 0x9e, 0x2f, 0xc6, 0x8c, 0xd7, 0xb9, 0x06, 0x93, 0x9f, - 0xc3, 0x62, 0xdc, 0x8f, 0x05, 0x40, 0x35, 0xab, 0x6d, 0x10, 0x90, 0xfb, 0xc0, 0xac, 0x47, 0x59, - 0xd9, 0x59, 0x18, 0xd7, 0x0d, 0x0d, 0x1f, 0xd3, 0xca, 0x26, 0x24, 0xf6, 0xd0, 0xb1, 0x81, 0x18, - 0x1f, 0x69, 0x03, 0xd1, 0x0f, 0x55, 0xe9, 0x28, 0x68, 0x94, 0x5a, 0xf8, 0x4f, 0x31, 0x98, 0xe1, - 0xd5, 0x89, 0x7c, 0x31, 0xf2, 0x75, 0x18, 0x6f, 0x10, 0x99, 0x03, 0xda, 0x9c, 0xbe, 0xd3, 0x6d, - 0x73, 0x9a, 0x19, 0x7d, 0x05, 0xa0, 0x65, 0xe1, 0x43, 0x99, 0xb1, 0xc6, 0x47, 0x62, 0x4d, 0x13, - 0x0e, 0x4a, 0x40, 0x5f, 0x87, 0x29, 0x32, 0xc2, 0x5b, 0x96, 0xd9, 0x32, 0x6d, 0xe2, 0xa4, 0xd8, - 0xa3, 0x21, 0x9d, 0xe9, 0x67, 0xa7, 0x0b, 0x93, 0x9b, 0xba, 0xb1, 0xcd, 0x19, 0x6b, 0x55, 0x89, - 0x98, 0x0a, 0xef, 0xd1, 0x1d, 0x80, 0x7f, 0x24, 0xc0, 0xec, 0xe7, 0xb6, 0x7c, 0xfb, 0x0f, 0xa1, - 0x31, 0x6f, 0xe6, 0x11, 0xe9, 0x63, 0xc5, 0xd8, 0x33, 0xa3, 0x5f, 0x54, 0xff, 0x48, 0x80, 0xe9, - 0x80, 0xf8, 0x28, 0x3d, 0x99, 0xe7, 0xd2, 0x59, 0xe1, 0x1b, 0xc4, 0xb7, 0x09, 0x76, 0xfb, 0x28, - 0x07, 0xd5, 0xff, 0x88, 0xc1, 0xf9, 0x22, 0xdb, 0x5a, 0x76, 0xe3, 0x2e, 0xa2, 0xec, 0x25, 0x79, - 0x98, 0x38, 0xc4, 0x96, 0xad, 0x9b, 0x6c, 0x86, 0x9d, 0x94, 0xdc, 0x47, 0x34, 0x07, 0x29, 0xdb, - 0x50, 0x5a, 0xf6, 0xbe, 0xe9, 0xee, 0xc6, 0x79, 0xcf, 0x5e, 0x8c, 0xc8, 0xf8, 0xf3, 0xc7, 0x88, - 0x24, 0x07, 0xc7, 0x88, 0x4c, 0xfc, 0xde, 0x31, 0x22, 0x7c, 0xeb, 0xeb, 0x67, 0x02, 0x5c, 0xe8, - 0xd1, 0x5f, 0x94, 0x7d, 0xe6, 0xdb, 0x90, 0x51, 0xb9, 0x60, 0x62, 0x8d, 0xd9, 0xee, 0x5e, 0x85, - 0x64, 0x7b, 0x4e, 0x00, 0xf2, 0xec, 0x74, 0x01, 0xdc, 0xa2, 0x56, 0xd6, 0xb8, 0x8a, 0xc8, 0x7f, - 0xad, 0xf0, 0xc7, 0x59, 0x98, 0x2a, 0x1d, 0xb3, 0xb5, 0xeb, 0x2a, 0xf3, 0x07, 0xd0, 0x3d, 0x48, - 0xb5, 0x2c, 0xf3, 0x50, 0x77, 0xab, 0x91, 0xeb, 0x08, 0x0d, 0x70, 0xab, 0xd1, 0xc5, 0xb5, 0xcd, - 0x39, 0x24, 0x8f, 0x17, 0xd5, 0x20, 0xfd, 0xc0, 0x54, 0x95, 0xc6, 0x3d, 0xbd, 0xe1, 0xf6, 0xff, - 0xd7, 0x86, 0x0b, 0x5a, 0xf2, 0x78, 0xb6, 0x15, 0x67, 0xdf, 0x6d, 0x0a, 0x8f, 0x88, 0x2a, 0x90, - 0x2a, 0x3b, 0x4e, 0x8b, 0x24, 0x72, 0x6b, 0x72, 0x7d, 0x04, 0xa1, 0x84, 0x85, 0xcb, 0xf2, 0xd8, - 0x51, 0x0d, 0xa6, 0xef, 0x9b, 0x66, 0xbd, 0x81, 0x8b, 0x0d, 0xb3, 0xad, 0x15, 0x4d, 0x63, 0x4f, - 0xaf, 0x73, 0x7b, 0x7c, 0x6d, 0x04, 0x99, 0xf7, 0x8b, 0x55, 0xa9, 0x57, 0x00, 0x5a, 0x81, 0x54, - 0xf5, 0x0e, 0x17, 0xc6, 0x1c, 0xb8, 0xab, 0x23, 0x08, 0xab, 0xde, 0x91, 0x3c, 0x36, 0xb4, 0x0e, - 0x99, 0x95, 0xa7, 0x6d, 0x0b, 0x73, 0x29, 0xc9, 0xbe, 0x71, 0x09, 0xdd, 0x52, 0x28, 0x97, 0x14, - 0x64, 0x46, 0x55, 0xc8, 0xbd, 0x67, 0x5a, 0x07, 0x0d, 0x53, 0x71, 0x6b, 0x38, 0x41, 0xc5, 0x7d, - 0x69, 0x04, 0x71, 0x2e, 0xa3, 0xd4, 0x25, 0x02, 0x7d, 0x13, 0xa6, 0x48, 0x63, 0xd4, 0x94, 0xdd, - 0x86, 0x5b, 0xc8, 0x14, 0x95, 0xfa, 0xca, 0x08, 0x52, 0x3d, 0x4e, 0x77, 0xf3, 0xa4, 0x4b, 0xd4, - 0xdc, 0xd7, 0x61, 0xb2, 0xa3, 0x13, 0x20, 0x04, 0x89, 0x16, 0x69, 0x6f, 0x81, 0xc6, 0x0f, 0xd1, - 0xff, 0xe8, 0x55, 0x98, 0x30, 0x4c, 0x0d, 0xbb, 0x23, 0x64, 0x72, 0x75, 0xf6, 0xd9, 0xe9, 0x42, - 0x72, 0xcb, 0xd4, 0x98, 0xbb, 0xc2, 0xff, 0x49, 0x49, 0x92, 0xc9, 0x75, 0x56, 0xe6, 0xae, 0x41, - 0x82, 0xb4, 0x3e, 0x31, 0x52, 0xbb, 0x8a, 0x8d, 0x77, 0x2c, 0x9d, 0xcb, 0x74, 0x1f, 0x79, 0xbe, - 0x5f, 0x09, 0x10, 0xab, 0xde, 0x21, 0x8e, 0xfa, 0x6e, 0x5b, 0x3d, 0xc0, 0x0e, 0xcf, 0xc5, 0x9f, - 0xa8, 0x03, 0x6f, 0xe1, 0x3d, 0x9d, 0xf9, 0x50, 0x69, 0x89, 0x3f, 0xa1, 0x17, 0x01, 0x14, 0x55, - 0xc5, 0xb6, 0x2d, 0xbb, 0xa7, 0xe6, 0xd2, 0x52, 0x9a, 0x51, 0x36, 0xf0, 0x09, 0x61, 0xb3, 0xb1, - 0x6a, 0x61, 0xc7, 0x0d, 0x84, 0x62, 0x4f, 0x84, 0xcd, 0xc1, 0xcd, 0x96, 0xec, 0x98, 0x07, 0xd8, - 0xa0, 0x7d, 0x26, 0x4d, 0x8c, 0x4f, 0xb3, 0x55, 0x23, 0x04, 0x62, 0x37, 0xb1, 0xa1, 0xf9, 0x46, - 0x2e, 0x2d, 0x79, 0xcf, 0x44, 0xa4, 0x85, 0xeb, 0x3a, 0x3f, 0xf8, 0x95, 0x96, 0xf8, 0x13, 0xd1, - 0x98, 0xd2, 0x76, 0xf6, 0x69, 0xab, 0xa4, 0x25, 0xfa, 0x9f, 0x57, 0xed, 0xdf, 0x09, 0x10, 0xbf, - 0x5f, 0xac, 0x9e, 0xb9, 0x6e, 0xae, 0xc4, 0xb8, 0x2f, 0x91, 0xc6, 0x1f, 0xea, 0x8d, 0x86, 0x6e, - 0xd4, 0x89, 0x4b, 0xf3, 0x6d, 0xac, 0xba, 0x35, 0xcb, 0x71, 0xf2, 0x36, 0xa3, 0xa2, 0x45, 0xc8, - 0xa8, 0x16, 0xd6, 0xb0, 0xe1, 0xe8, 0x4a, 0xc3, 0xe6, 0x55, 0x0c, 0x92, 0x78, 0xe1, 0xbe, 0x2b, - 0xc0, 0x38, 0xed, 0xbc, 0xe8, 0x05, 0x48, 0xab, 0xa6, 0xe1, 0x28, 0xba, 0xc1, 0xad, 0x50, 0x5a, - 0xf2, 0x09, 0x7d, 0x0b, 0x79, 0x19, 0xb2, 0x8a, 0xaa, 0x9a, 0x6d, 0xc3, 0x91, 0x0d, 0xa5, 0x89, - 0x79, 0x61, 0x33, 0x9c, 0xb6, 0xa5, 0x34, 0x31, 0x5a, 0x00, 0xf7, 0xd1, 0x3b, 0xbb, 0x98, 0x96, - 0x80, 0x93, 0x36, 0xf0, 0x09, 0x2f, 0xc9, 0xcf, 0x04, 0x48, 0xb9, 0x9d, 0x9e, 0x14, 0xa6, 0x8e, - 0x0d, 0x6c, 0x29, 0x8e, 0xe9, 0x15, 0xc6, 0x23, 0x74, 0xcf, 0x78, 0x69, 0x7f, 0xc6, 0x9b, 0x85, - 0x71, 0x87, 0xf4, 0x6b, 0x5e, 0x0e, 0xf6, 0x40, 0xd7, 0x9a, 0x1b, 0x4a, 0x9d, 0x2d, 0xaf, 0xa5, - 0x25, 0xf6, 0x40, 0xaa, 0xc4, 0x63, 0x68, 0x99, 0x76, 0xf8, 0x13, 0x29, 0x2f, 0x8b, 0xf1, 0xdc, - 0xc5, 0x75, 0xdd, 0xa0, 0x1d, 0x20, 0x2e, 0x01, 0x25, 0xad, 0x12, 0x0a, 0xba, 0x04, 0x69, 0x96, - 0x01, 0x1b, 0x1a, 0xed, 0x05, 0x71, 0x29, 0x45, 0x09, 0x25, 0xf7, 0x70, 0xd6, 0xdc, 0x01, 0xa4, - 0xbd, 0x31, 0x46, 0x1a, 0xb2, 0x6d, 0x7b, 0x4a, 0xa5, 0xff, 0xd1, 0x6b, 0x30, 0xfb, 0xa4, 0xad, - 0x34, 0xf4, 0x3d, 0xba, 0x72, 0x46, 0xb2, 0x31, 0xfd, 0xb1, 0xfa, 0x20, 0x2f, 0x8d, 0x4a, 0xa0, - 0x6a, 0x74, 0x87, 0x64, 0xdc, 0x1f, 0x92, 0xc1, 0xad, 0x90, 0xc2, 0x27, 0x02, 0x4c, 0xb3, 0x30, - 0x20, 0x16, 0x89, 0x1a, 0x9d, 0x83, 0xf1, 0x36, 0xa4, 0x35, 0xc5, 0x51, 0xd8, 0xf9, 0xcc, 0xd8, - 0xc0, 0xf3, 0x99, 0xae, 0xc5, 0x27, 0xf9, 0xe9, 0x19, 0x4d, 0x04, 0x09, 0xf2, 0x9f, 0x1d, 0x68, - 0x95, 0xe8, 0x7f, 0x3f, 0xb0, 0x22, 0x58, 0xdc, 0x28, 0x1d, 0xae, 0x65, 0x38, 0x47, 0xb4, 0x5f, - 0x32, 0x54, 0xeb, 0xa4, 0xe5, 0xe8, 0xa6, 0xf1, 0x90, 0xfe, 0xda, 0x48, 0x0c, 0x6c, 0x4c, 0xd1, - 0xfd, 0x28, 0x5e, 0x96, 0xff, 0x9d, 0x84, 0xc9, 0xd2, 0x71, 0xcb, 0xb4, 0x22, 0x5d, 0xd4, 0x5a, - 0x85, 0x09, 0x8e, 0xf8, 0x07, 0x6c, 0x15, 0x77, 0xd9, 0x6a, 0x77, 0x17, 0x96, 0x33, 0xa2, 0x55, - 0x00, 0x16, 0x33, 0x4a, 0x63, 0x89, 0xe2, 0x67, 0xd8, 0x30, 0xa3, 0x6c, 0x84, 0x8a, 0xb6, 0x20, - 0xd3, 0x3c, 0x54, 0x55, 0x79, 0x4f, 0x6f, 0x38, 0x3c, 0xe8, 0x2e, 0x3c, 0x62, 0x7c, 0xf3, 0x71, - 0xb1, 0x78, 0x8f, 0x66, 0x62, 0xf1, 0x6f, 0xfe, 0xb3, 0x04, 0x44, 0x02, 0xfb, 0x8f, 0x5e, 0x01, - 0x7e, 0x6e, 0x46, 0xb6, 0xdd, 0x23, 0x72, 0xab, 0x93, 0xcf, 0x4e, 0x17, 0xd2, 0x12, 0xa5, 0x56, - 0xab, 0x35, 0x29, 0xcd, 0x32, 0x54, 0x6d, 0x07, 0xbd, 0x04, 0x93, 0x66, 0x53, 0x77, 0x64, 0xd7, - 0x07, 0xe2, 0x6e, 0x63, 0x96, 0x10, 0x5d, 0x1f, 0x09, 0xd5, 0xe0, 0x3a, 0x36, 0xe8, 0x28, 0x20, - 0xf5, 0x94, 0x77, 0xd9, 0x5a, 0xa4, 0xc3, 0xc6, 0xbb, 0x6c, 0xb6, 0x1c, 0xbd, 0xa9, 0x3f, 0xa5, - 0x9b, 0xd5, 0x7c, 0xbf, 0xe8, 0x25, 0x96, 0x9d, 0xd4, 0x6f, 0x95, 0x2e, 0x52, 0xf2, 0xbc, 0x0f, - 0x03, 0x59, 0xd1, 0x77, 0x05, 0x38, 0xcf, 0x15, 0x29, 0xef, 0xd2, 0x90, 0x77, 0xa5, 0xa1, 0x3b, - 0x27, 0xf2, 0xc1, 0x61, 0x3e, 0x45, 0x9d, 0xd3, 0x2f, 0x87, 0x36, 0x48, 0xa0, 0x1f, 0x2c, 0xb9, - 0xcd, 0x72, 0xf2, 0x80, 0x33, 0x6f, 0x1c, 0x96, 0x0c, 0xc7, 0x3a, 0x59, 0xbd, 0xf0, 0xec, 0x74, - 0x61, 0xa6, 0x37, 0xf5, 0xb1, 0x34, 0x63, 0xf7, 0xb2, 0xa0, 0x32, 0x00, 0xf6, 0x7a, 0x23, 0x0d, - 0xf9, 0x0b, 0x77, 0x2f, 0x42, 0xbb, 0xad, 0x14, 0xe0, 0x45, 0x37, 0x40, 0xe4, 0x87, 0x5e, 0xf6, - 0xf4, 0x06, 0x96, 0x6d, 0xfd, 0x29, 0xce, 0x03, 0xb5, 0x41, 0x39, 0x46, 0x27, 0x22, 0xaa, 0xfa, - 0x53, 0x3c, 0xf7, 0x6d, 0xc8, 0xf7, 0x2b, 0x7d, 0x70, 0x20, 0xa4, 0xd9, 0xc6, 0xec, 0x5b, 0x9d, - 0x2b, 0x32, 0x23, 0x74, 0x55, 0x77, 0x55, 0x26, 0xf6, 0x96, 0x6b, 0x82, 0x7e, 0x12, 0x83, 0xc9, - 0xd5, 0x76, 0xe3, 0xe0, 0x61, 0xab, 0xda, 0x6e, 0x36, 0x15, 0xeb, 0x84, 0x98, 0x4a, 0x66, 0x3a, - 0x48, 0x31, 0x05, 0x66, 0x2a, 0xa9, 0x6d, 0xd0, 0x9f, 0x62, 0x32, 0x99, 0x05, 0x0f, 0x69, 0xb3, - 0x90, 0x7e, 0x5a, 0x93, 0xc0, 0xc9, 0x6b, 0xf3, 0xc8, 0x46, 0x6f, 0x41, 0x3e, 0x90, 0x91, 0x2e, - 0x9f, 0xc8, 0xd8, 0x70, 0x2c, 0x1d, 0xb3, 0xe5, 0xc0, 0xb8, 0x14, 0x08, 0xa7, 0xa9, 0x90, 0xe4, - 0x12, 0x4b, 0x45, 0x35, 0xc8, 0x92, 0x8c, 0x27, 0x32, 0x9d, 0x6c, 0xdc, 0x45, 0xdb, 0x5b, 0x21, - 0x95, 0xeb, 0x28, 0xf7, 0x12, 0xd5, 0x52, 0x91, 0xf2, 0xd0, 0xbf, 0x52, 0x06, 0xfb, 0x94, 0xb9, - 0x77, 0x41, 0xec, 0xce, 0x10, 0xd4, 0x68, 0x82, 0x69, 0x74, 0x36, 0xa8, 0xd1, 0x78, 0x40, 0x5b, - 0xeb, 0x89, 0x54, 0x42, 0x1c, 0x2f, 0xfc, 0x3a, 0x0e, 0x39, 0xb7, 0xb3, 0x45, 0x89, 0x66, 0x56, - 0x61, 0x9c, 0x74, 0x0d, 0x37, 0xf8, 0xe3, 0xda, 0x80, 0x3e, 0xce, 0xc3, 0xc7, 0x49, 0x97, 0x71, - 0xf1, 0x30, 0x65, 0x8d, 0xc2, 0xec, 0xcc, 0xfd, 0x93, 0x18, 0x24, 0x28, 0x80, 0xb8, 0x05, 0x09, - 0x3a, 0x75, 0x08, 0xa3, 0x4c, 0x1d, 0x34, 0xab, 0x37, 0xd9, 0xc5, 0x02, 0xfe, 0x27, 0x71, 0xe6, - 0xf6, 0x95, 0x37, 0x6e, 0xdd, 0xa6, 0x26, 0x27, 0x2b, 0xf1, 0x27, 0xb4, 0x4a, 0xa3, 0x92, 0x4c, - 0xcb, 0xc1, 0x1a, 0x77, 0xdc, 0x17, 0x87, 0xb5, 0xaf, 0x3b, 0x4d, 0xb9, 0x7c, 0xe8, 0x22, 0xc4, - 0x89, 0x2d, 0x9b, 0x60, 0x11, 0x0b, 0xcf, 0x4e, 0x17, 0xe2, 0xc4, 0x8a, 0x11, 0x1a, 0x5a, 0x86, - 0x4c, 0xa7, 0xe1, 0x10, 0x6e, 0xa4, 0x99, 0x79, 0x0c, 0x0c, 0x7a, 0x68, 0x78, 0x03, 0x8c, 0x81, - 0x56, 0xde, 0xc6, 0xdf, 0x19, 0x87, 0xc9, 0x4a, 0x33, 0xea, 0x89, 0x65, 0xa5, 0xb3, 0x85, 0xc3, - 0xd0, 0x4e, 0xc7, 0x4b, 0x43, 0x1a, 0xb8, 0x63, 0x4e, 0x8f, 0x9f, 0x6d, 0x4e, 0xaf, 0x10, 0x17, - 0x98, 0xdf, 0xba, 0x10, 0xef, 0x03, 0x6c, 0x3a, 0xdf, 0x4f, 0xbd, 0x18, 0x89, 0xf0, 0xf8, 0x07, - 0x2a, 0x68, 0xd4, 0xc9, 0xbb, 0xd4, 0xd3, 0x66, 0xbd, 0x2c, 0x39, 0x7a, 0x2f, 0x9b, 0xc0, 0x86, - 0x46, 0xa7, 0xb6, 0x4e, 0xbb, 0x3a, 0xf1, 0xfc, 0x76, 0x75, 0xee, 0x29, 0xef, 0xac, 0x6f, 0x43, - 0x5c, 0xd3, 0xdd, 0xc6, 0x19, 0x7d, 0xc2, 0x26, 0x4c, 0x43, 0x7a, 0x6d, 0x22, 0xd8, 0x6b, 0x83, - 0x0b, 0x1c, 0x73, 0x0f, 0x01, 0x7c, 0x0d, 0xa1, 0x45, 0x48, 0x9a, 0x0d, 0xcd, 0x3d, 0x57, 0x32, - 0xb9, 0x9a, 0x7e, 0x76, 0xba, 0x30, 0xfe, 0xb0, 0xa1, 0x55, 0xd6, 0xa4, 0x71, 0xb3, 0xa1, 0x55, - 0x34, 0x7a, 0xf1, 0x05, 0x3e, 0x92, 0xbd, 0x20, 0xb4, 0xac, 0x34, 0x61, 0xe0, 0xa3, 0x35, 0x6c, - 0xab, 0x5d, 0xc1, 0x31, 0xa4, 0x0b, 0xfe, 0x50, 0x80, 0x9c, 0xdb, 0x1a, 0xd1, 0x9a, 0x99, 0x94, - 0xde, 0xe4, 0xc3, 0x2e, 0x7e, 0xb6, 0x61, 0xe7, 0xf2, 0xf1, 0x53, 0xb5, 0xdf, 0x13, 0x78, 0x00, - 0x72, 0x55, 0x55, 0x1c, 0xe2, 0x6c, 0x44, 0x38, 0x54, 0x5e, 0x06, 0xd1, 0x52, 0x0c, 0xcd, 0x6c, - 0xea, 0x4f, 0x31, 0x5b, 0x11, 0xb5, 0xf9, 0xe6, 0xe6, 0x94, 0x47, 0xa7, 0x4b, 0x7e, 0xee, 0x82, - 0xee, 0xef, 0x04, 0x1e, 0xac, 0xec, 0x15, 0x26, 0x4a, 0xa5, 0x6d, 0x40, 0xd2, 0x62, 0x21, 0x8f, - 0x6c, 0xe8, 0xbe, 0x1a, 0x22, 0x24, 0xec, 0xed, 0x2c, 0xa2, 0xd0, 0x1b, 0x3c, 0x54, 0xc4, 0xdc, - 0xd7, 0x60, 0x9c, 0x92, 0x9f, 0xc3, 0xc0, 0x72, 0xcd, 0xff, 0x36, 0x06, 0x57, 0xe8, 0xeb, 0x1e, - 0x63, 0x4b, 0xdf, 0x3b, 0xd9, 0xb6, 0x4c, 0x07, 0xab, 0x0e, 0xd6, 0xfc, 0x63, 0x1c, 0x91, 0x5a, - 0xad, 0x74, 0xcb, 0x7d, 0xc1, 0x99, 0x42, 0xbf, 0x3c, 0x2e, 0xb4, 0x01, 0x53, 0xec, 0x72, 0x1d, - 0x59, 0x69, 0xe8, 0x87, 0x58, 0x56, 0x9c, 0xb3, 0xcc, 0x4d, 0x93, 0x8c, 0x77, 0x85, 0xb0, 0xae, - 0x38, 0x48, 0x83, 0x34, 0x17, 0xa6, 0x6b, 0xfc, 0x46, 0x9d, 0xfb, 0xbf, 0xdf, 0x9a, 0x5f, 0x4a, - 0xa2, 0xf2, 0x2a, 0x6b, 0x52, 0x8a, 0x49, 0xf6, 0xf6, 0x6c, 0x7e, 0x29, 0xc0, 0xd5, 0x21, 0x8a, - 0x8e, 0xb2, 0x9b, 0xcd, 0x41, 0xea, 0x90, 0xbc, 0x48, 0xe7, 0x9a, 0x4e, 0x49, 0xde, 0x33, 0xda, - 0x84, 0xc9, 0x3d, 0x45, 0x6f, 0xb8, 0xd7, 0xe2, 0x0c, 0x8a, 0x17, 0x0c, 0x0f, 0x63, 0xcd, 0x32, - 0x76, 0x9a, 0x48, 0x0f, 0x3a, 0x4e, 0xaf, 0x68, 0x5a, 0xb5, 0xca, 0x2d, 0x58, 0x74, 0xfd, 0xc5, - 0x85, 0x8e, 0x31, 0x1f, 0x3a, 0xa2, 0x57, 0x01, 0x69, 0xba, 0xcd, 0x6e, 0xeb, 0xb0, 0xf7, 0x15, - 0xcd, 0x3c, 0xf2, 0xa3, 0x26, 0xa6, 0xdd, 0x94, 0xaa, 0x9b, 0x80, 0xaa, 0x40, 0x71, 0x8b, 0x6c, - 0x3b, 0x8a, 0xb7, 0xf1, 0x73, 0x75, 0xa4, 0x53, 0x57, 0x0c, 0xd0, 0x78, 0x8f, 0x52, 0x9a, 0xc8, - 0xa1, 0x7f, 0x89, 0x07, 0xae, 0x93, 0xaa, 0x3b, 0xb2, 0x62, 0xbb, 0x47, 0x74, 0xd8, 0x3d, 0x21, - 0x39, 0x46, 0x5f, 0xb1, 0x83, 0x27, 0x6f, 0xd8, 0x09, 0x02, 0x5f, 0x41, 0x51, 0x02, 0xdd, 0xff, - 0x28, 0x40, 0x4e, 0xc2, 0x7b, 0x16, 0xb6, 0x23, 0x05, 0xfc, 0xf7, 0x20, 0x6b, 0x31, 0xa9, 0xf2, - 0x9e, 0x65, 0x36, 0xcf, 0x32, 0xc6, 0x32, 0x9c, 0xf1, 0x9e, 0x65, 0x36, 0x3b, 0xae, 0x4e, 0x78, - 0x0c, 0x53, 0x5e, 0x49, 0xa3, 0x54, 0xc1, 0x27, 0xf4, 0xa4, 0x31, 0x13, 0x1c, 0x75, 0xf8, 0xc2, - 0xe7, 0xa1, 0x07, 0xba, 0xd3, 0x14, 0x2c, 0x6e, 0x94, 0xca, 0xf8, 0x9d, 0x00, 0xb9, 0x6a, 0x7b, - 0x97, 0x5d, 0x16, 0x15, 0x9d, 0x1e, 0x4a, 0x90, 0x6e, 0xe0, 0x3d, 0x47, 0x7e, 0xae, 0xa8, 0xf7, - 0x14, 0x61, 0xa5, 0x91, 0xff, 0xf7, 0x01, 0x2c, 0x7a, 0xae, 0x8d, 0xca, 0x89, 0x9f, 0x51, 0x4e, - 0x9a, 0xf2, 0xfa, 0x4e, 0x4e, 0xe1, 0x93, 0x18, 0x4c, 0x79, 0x95, 0x8d, 0xd2, 0x7a, 0xbe, 0xd7, - 0x61, 0x35, 0xe2, 0x67, 0xb1, 0x1a, 0xd3, 0x3c, 0x7a, 0x23, 0xdc, 0x72, 0x2c, 0xc1, 0x0c, 0x75, - 0x41, 0x64, 0xa5, 0xd5, 0x6a, 0xe8, 0x2e, 0x94, 0xa5, 0x76, 0x29, 0x21, 0x4d, 0xd3, 0xa4, 0x15, - 0x96, 0x42, 0x41, 0x2c, 0xe9, 0x7f, 0x7b, 0x16, 0xc6, 0x4f, 0xb1, 0x4c, 0x51, 0xd5, 0x59, 0xa2, - 0x53, 0x32, 0x8c, 0xb1, 0x4a, 0xf8, 0x78, 0xcf, 0xfb, 0x10, 0xa6, 0xa9, 0x66, 0xa3, 0x3e, 0x5b, - 0xcb, 0x9b, 0xe3, 0x07, 0x31, 0x40, 0x41, 0xf9, 0x9f, 0x5f, 0x8b, 0xc4, 0xa2, 0x6b, 0x91, 0x57, - 0x00, 0xb1, 0x28, 0x44, 0x5b, 0x6e, 0x61, 0x4b, 0xb6, 0xb1, 0x6a, 0xf2, 0x2b, 0x8c, 0x04, 0x49, - 0xe4, 0x29, 0xdb, 0xd8, 0xaa, 0x52, 0x3a, 0xba, 0x0b, 0xe0, 0x5f, 0x25, 0xc7, 0xa7, 0x93, 0x81, - 0x37, 0xc9, 0x49, 0x69, 0xcb, 0xfd, 0x5b, 0xf8, 0x68, 0x0e, 0xb2, 0x5c, 0x93, 0x3b, 0x86, 0x6e, - 0x1a, 0xe8, 0x16, 0xc4, 0xeb, 0x7c, 0x33, 0x20, 0x13, 0xba, 0x1c, 0xe7, 0xdf, 0xda, 0x56, 0x1e, - 0x93, 0x48, 0x5e, 0xc2, 0xd2, 0x6a, 0x3b, 0x21, 0xce, 0x93, 0x1f, 0x6b, 0x1d, 0x64, 0x69, 0xb5, - 0x1d, 0x54, 0x85, 0x29, 0xd5, 0xbf, 0x83, 0x4a, 0x26, 0xec, 0xf1, 0xbe, 0x30, 0x29, 0xf4, 0xee, - 0xaf, 0xf2, 0x98, 0x94, 0x53, 0x3b, 0x12, 0x50, 0x31, 0x78, 0xe9, 0x51, 0xa2, 0x27, 0xac, 0xcb, - 0x3f, 0xc4, 0xdb, 0x79, 0xe1, 0x52, 0x79, 0x2c, 0x70, 0x37, 0x12, 0x7a, 0x1b, 0x92, 0x1a, 0xbd, - 0x4c, 0x87, 0xf7, 0xeb, 0xb0, 0xae, 0xd7, 0x71, 0x7f, 0x51, 0x79, 0x4c, 0xe2, 0x1c, 0x68, 0x1d, - 0xb2, 0xec, 0x1f, 0x73, 0x62, 0x38, 0x76, 0xbc, 0xda, 0x5f, 0x42, 0x60, 0x6a, 0x28, 0x8f, 0x49, - 0x19, 0xcd, 0xa7, 0xa2, 0xd7, 0x21, 0x61, 0xab, 0x8a, 0x8b, 0x1e, 0xe7, 0xfb, 0xdc, 0xa4, 0xe1, - 0x33, 0xd3, 0xdc, 0xe8, 0x2e, 0xbb, 0x8d, 0xd1, 0x39, 0x76, 0x97, 0xf3, 0xc2, 0x8a, 0xdf, 0x71, - 0x3e, 0x9b, 0x14, 0x1f, 0x53, 0x02, 0xba, 0x0f, 0x19, 0x85, 0x78, 0x83, 0x32, 0x3d, 0x0f, 0x49, - 0xd7, 0xef, 0xc2, 0x77, 0xca, 0x7b, 0xce, 0xb2, 0x96, 0xe9, 0x21, 0x70, 0x97, 0xe8, 0x0b, 0x6a, - 0x62, 0xab, 0x8e, 0xf3, 0x99, 0xc1, 0x82, 0x82, 0x61, 0x5c, 0x9e, 0x20, 0x4a, 0x24, 0x5e, 0xe1, - 0xbe, 0x7b, 0xd6, 0x85, 0x56, 0x2a, 0xdb, 0x77, 0x57, 0x36, 0xe4, 0xac, 0x4e, 0x79, 0x4c, 0xca, - 0xee, 0x07, 0xc8, 0x68, 0x09, 0x62, 0x75, 0x35, 0x3f, 0xd9, 0x77, 0x84, 0x78, 0x27, 0x51, 0xca, - 0x63, 0x52, 0xac, 0xae, 0xa2, 0x77, 0x21, 0xc5, 0x8e, 0x12, 0x1c, 0x1b, 0xf9, 0x5c, 0x5f, 0x3b, - 0xd1, 0x79, 0x20, 0xa3, 0x3c, 0x26, 0xd1, 0xd3, 0x0b, 0xe4, 0x7d, 0xdb, 0x90, 0xb3, 0x58, 0x1c, - 0x9c, 0x1b, 0xc1, 0x2a, 0xf6, 0xdd, 0xa9, 0x0e, 0x0b, 0x62, 0x2d, 0x53, 0x74, 0x10, 0xa0, 0xa3, - 0x6f, 0xc1, 0x6c, 0xa7, 0x44, 0xde, 0xd3, 0xa6, 0xfb, 0xee, 0xba, 0xf6, 0x0d, 0xa5, 0x2c, 0x8f, - 0x49, 0xc8, 0xea, 0x49, 0x44, 0x6f, 0xc2, 0x38, 0x6b, 0x35, 0x44, 0x45, 0x86, 0x85, 0x60, 0x74, - 0x35, 0x18, 0xcb, 0x4f, 0x3a, 0xbf, 0xc3, 0x03, 0xc0, 0xe4, 0x86, 0x59, 0xcf, 0xcf, 0xf4, 0xed, - 0xfc, 0xbd, 0x01, 0x6d, 0xa4, 0xf3, 0x3b, 0x3e, 0x95, 0xb4, 0xbb, 0xc5, 0x52, 0x78, 0xbc, 0xd0, - 0x6c, 0xdf, 0x76, 0x0f, 0x89, 0x0b, 0x2b, 0xd3, 0x90, 0x7c, 0x9f, 0x4c, 0x8a, 0x66, 0xb1, 0x6b, - 0x5f, 0x64, 0x3a, 0xa6, 0xce, 0xf5, 0x2d, 0x5a, 0xef, 0xed, 0x38, 0x65, 0xea, 0x35, 0x79, 0x54, - 0xf4, 0x18, 0x44, 0x7e, 0x21, 0x83, 0xbf, 0x77, 0x70, 0x9e, 0xca, 0x7b, 0x39, 0xd4, 0x74, 0x85, - 0x05, 0xd8, 0x94, 0xc7, 0xa4, 0x29, 0xb5, 0x33, 0x05, 0xbd, 0x0f, 0xd3, 0x54, 0x9e, 0xac, 0xfa, - 0x37, 0x69, 0xe4, 0xf3, 0x3d, 0x37, 0x32, 0xf4, 0xbf, 0x74, 0xc3, 0x95, 0x2c, 0xaa, 0x5d, 0x49, - 0xa4, 0x1b, 0xeb, 0x86, 0xee, 0x50, 0x2b, 0x3b, 0xd7, 0xb7, 0x1b, 0x77, 0xde, 0xd9, 0x47, 0xba, - 0xb1, 0xce, 0x28, 0xa4, 0x1b, 0x3b, 0x3c, 0x98, 0x8c, 0x37, 0xc7, 0x0b, 0x7d, 0xbb, 0x71, 0x58, - 0xd4, 0x19, 0xe9, 0xc6, 0x4e, 0x90, 0x4e, 0xba, 0x31, 0x33, 0x10, 0x5d, 0x72, 0x5f, 0xec, 0xdb, - 0x8d, 0xfb, 0x9e, 0x48, 0x26, 0xdd, 0x58, 0xe9, 0x49, 0x44, 0x6b, 0x00, 0xcc, 0xa9, 0xa1, 0x93, - 0xe2, 0x7c, 0xdf, 0xc9, 0xa0, 0x3b, 0x9c, 0x8c, 0x4c, 0x06, 0x0d, 0x97, 0x46, 0x0c, 0x19, 0x85, - 0x52, 0x32, 0xdd, 0x48, 0xcd, 0x2f, 0xf4, 0x35, 0x64, 0x3d, 0x5b, 0x9c, 0xc4, 0x90, 0x1d, 0x79, - 0x44, 0x32, 0xab, 0xb0, 0x55, 0xdd, 0xfc, 0x62, 0x7f, 0xb3, 0x1c, 0xdc, 0xe2, 0xa1, 0x66, 0x99, - 0x12, 0xd0, 0x0a, 0xa4, 0xc9, 0x9c, 0x7f, 0x42, 0xcd, 0xd0, 0xe5, 0xbe, 0xfe, 0x69, 0xd7, 0x99, - 0x93, 0xf2, 0x98, 0x94, 0x7a, 0xc2, 0x49, 0xe4, 0xf5, 0x6c, 0x75, 0x2b, 0x5f, 0xe8, 0xfb, 0xfa, - 0x8e, 0xb5, 0x51, 0xf2, 0x7a, 0xc6, 0x81, 0x54, 0x38, 0xc7, 0xda, 0x8a, 0x1f, 0x08, 0xb6, 0xf8, - 0xe9, 0xd5, 0xfc, 0x4b, 0x54, 0x54, 0xdf, 0xb5, 0xa2, 0xd0, 0x73, 0xca, 0xe5, 0x31, 0x69, 0x46, - 0xe9, 0x4d, 0x25, 0x03, 0x9e, 0x4f, 0x3d, 0x6c, 0x85, 0x29, 0x7f, 0xa5, 0xef, 0x80, 0x0f, 0x59, - 0x93, 0x23, 0x03, 0x5e, 0x09, 0x90, 0xd9, 0x04, 0xa4, 0xc9, 0xb6, 0xcd, 0xb6, 0xdd, 0xaf, 0x0e, - 0x98, 0x80, 0xba, 0xd6, 0x08, 0xd8, 0x04, 0xa4, 0x55, 0x19, 0x27, 0x11, 0xa4, 0x36, 0xb0, 0x62, - 0x71, 0x33, 0x7b, 0xad, 0xaf, 0xa0, 0x9e, 0x7b, 0xf0, 0x88, 0x20, 0xd5, 0x23, 0x12, 0x87, 0xc7, - 0x72, 0x6f, 0x72, 0xe1, 0x0e, 0xe3, 0xf5, 0xbe, 0x0e, 0x4f, 0xe8, 0x85, 0x33, 0xc4, 0xe1, 0xb1, - 0x3a, 0x12, 0xd0, 0x57, 0x60, 0x82, 0x03, 0xba, 0xfc, 0x8d, 0x01, 0x6e, 0x6c, 0x10, 0x89, 0x93, - 0x71, 0xcd, 0x79, 0x98, 0x95, 0x65, 0x40, 0x92, 0x55, 0xef, 0xe5, 0x01, 0x56, 0xb6, 0x07, 0xcb, - 0x32, 0x2b, 0xeb, 0x93, 0x89, 0x95, 0x65, 0xfd, 0x94, 0xcf, 0x75, 0x37, 0xfb, 0x5a, 0xd9, 0xde, - 0x73, 0x2f, 0xc4, 0xca, 0x3e, 0xf1, 0xa9, 0xa4, 0x66, 0x36, 0x03, 0x51, 0xf9, 0x2f, 0xf5, 0xad, - 0x59, 0x27, 0xa6, 0x24, 0x35, 0xe3, 0x3c, 0xa4, 0xd9, 0x98, 0x4b, 0xcc, 0x34, 0xfd, 0x4a, 0xff, - 0xb3, 0xf7, 0xdd, 0xd0, 0x83, 0x34, 0x9b, 0xe5, 0x11, 0x7d, 0x43, 0x65, 0xf1, 0x93, 0xc6, 0x5c, - 0x53, 0xaf, 0x0e, 0x36, 0x54, 0x61, 0x87, 0xa8, 0x3d, 0x43, 0xd5, 0x91, 0x48, 0x8b, 0xca, 0x8e, - 0x8f, 0xd1, 0xf1, 0xbd, 0x34, 0xe0, 0x9a, 0x80, 0xae, 0xa3, 0x7c, 0xb4, 0xa8, 0x1e, 0xd1, 0x1f, - 0x42, 0x6d, 0x76, 0x9f, 0x45, 0x7e, 0x79, 0xf0, 0x10, 0xea, 0xbc, 0x57, 0xc3, 0x1b, 0x42, 0x9c, - 0xec, 0xcd, 0x99, 0xae, 0x87, 0xf1, 0xda, 0xe0, 0x39, 0xb3, 0xdb, 0xb5, 0x60, 0x73, 0x26, 0xf7, - 0x29, 0xfe, 0xa9, 0x00, 0x8b, 0xac, 0x6c, 0x74, 0xbd, 0xef, 0x44, 0xf6, 0xd6, 0x4e, 0x03, 0x87, - 0x1c, 0x6e, 0xd1, 0x17, 0xbc, 0xd9, 0xaf, 0xb8, 0x43, 0xd6, 0x82, 0xcb, 0x63, 0xd2, 0x8b, 0xca, - 0xa0, 0x7c, 0xab, 0x13, 0x7c, 0xe3, 0xd3, 0x3b, 0xc1, 0x39, 0x25, 0x8a, 0xeb, 0x89, 0xd4, 0x05, - 0x31, 0xbf, 0x9e, 0x48, 0x5d, 0x14, 0xe7, 0xd6, 0x13, 0xa9, 0x4b, 0xe2, 0x0b, 0x85, 0xbf, 0xb8, - 0x08, 0x93, 0x2e, 0xf2, 0x63, 0x88, 0xe8, 0x76, 0x10, 0x11, 0xcd, 0xf7, 0x43, 0x44, 0x1c, 0x2b, - 0x72, 0x48, 0x74, 0x3b, 0x08, 0x89, 0xe6, 0xfb, 0x41, 0x22, 0x9f, 0x87, 0x60, 0xa2, 0x5a, 0x3f, - 0x4c, 0xf4, 0xf2, 0x08, 0x98, 0xc8, 0x13, 0xd5, 0x0d, 0x8a, 0xd6, 0x7a, 0x41, 0xd1, 0x95, 0xc1, - 0xa0, 0xc8, 0x13, 0x15, 0x40, 0x45, 0x77, 0xbb, 0x50, 0xd1, 0xe5, 0x01, 0xa8, 0xc8, 0xe3, 0x77, - 0x61, 0xd1, 0x46, 0x28, 0x2c, 0xba, 0x36, 0x0c, 0x16, 0x79, 0x72, 0x3a, 0x70, 0xd1, 0x1b, 0x1d, - 0xb8, 0x68, 0xa1, 0x2f, 0x2e, 0xf2, 0xb8, 0x19, 0x30, 0x7a, 0xa7, 0x1b, 0x18, 0x5d, 0x1e, 0x00, - 0x8c, 0xfc, 0x1a, 0x70, 0x64, 0x54, 0x0e, 0x43, 0x46, 0x57, 0x87, 0x20, 0x23, 0x4f, 0x4a, 0x10, - 0x1a, 0x95, 0xc3, 0xa0, 0xd1, 0xd5, 0x21, 0xd0, 0xa8, 0x4b, 0x12, 0xc3, 0x46, 0x5b, 0xe1, 0xd8, - 0xe8, 0xfa, 0x50, 0x6c, 0xe4, 0x49, 0xeb, 0x04, 0x47, 0xcb, 0x01, 0x70, 0xf4, 0x62, 0x1f, 0x70, - 0xe4, 0xb1, 0x12, 0x74, 0xf4, 0xd5, 0x1e, 0x74, 0x54, 0x18, 0x84, 0x8e, 0x3c, 0x5e, 0x0f, 0x1e, - 0x3d, 0xea, 0x03, 0x8f, 0x6e, 0x0c, 0x87, 0x47, 0x9e, 0xb0, 0x2e, 0x7c, 0xa4, 0x0c, 0xc4, 0x47, - 0xaf, 0x8e, 0x88, 0x8f, 0x3c, 0xe9, 0x61, 0x00, 0xe9, 0xad, 0x4e, 0x80, 0xb4, 0xd8, 0x1f, 0x20, - 0x79, 0x62, 0x38, 0x42, 0xda, 0x08, 0x45, 0x48, 0xd7, 0x86, 0x21, 0x24, 0x7f, 0x1c, 0x04, 0x21, - 0xd2, 0x56, 0x38, 0x44, 0xba, 0x3e, 0x14, 0x22, 0xf9, 0xcd, 0xdf, 0x81, 0x91, 0x36, 0x42, 0x31, - 0xd2, 0xb5, 0x61, 0x18, 0xc9, 0x2f, 0x5c, 0x10, 0x24, 0xbd, 0xd7, 0x17, 0x24, 0xdd, 0x1c, 0x05, - 0x24, 0x79, 0x42, 0x7b, 0x50, 0xd2, 0x07, 0xfd, 0x51, 0xd2, 0x97, 0xce, 0x70, 0x35, 0x61, 0x28, - 0x4c, 0xfa, 0x6a, 0x0f, 0x4c, 0x2a, 0x0c, 0x82, 0x49, 0x7e, 0x7f, 0x76, 0x71, 0x92, 0x32, 0x10, - 0xd5, 0xbc, 0x3a, 0x22, 0xaa, 0xf1, 0x3b, 0x5f, 0x08, 0xac, 0x29, 0x85, 0xc0, 0x9a, 0x2b, 0x83, - 0x61, 0x8d, 0x6f, 0xce, 0x7d, 0x5c, 0x53, 0x0e, 0xc3, 0x35, 0x57, 0x87, 0xe0, 0x1a, 0xdf, 0x0a, - 0x05, 0x80, 0xcd, 0xdd, 0x2e, 0x60, 0x73, 0x79, 0x68, 0x5c, 0x4f, 0x00, 0xd9, 0xac, 0xf6, 0x22, - 0x9b, 0x97, 0x06, 0x22, 0x1b, 0x4f, 0x82, 0x0f, 0x6d, 0xee, 0x76, 0x41, 0x9b, 0xcb, 0x03, 0xa0, - 0x8d, 0x5f, 0x00, 0x8e, 0x6d, 0xb4, 0xc1, 0xd8, 0x66, 0x69, 0x54, 0x6c, 0xe3, 0x09, 0x0e, 0x05, - 0x37, 0x5b, 0xe1, 0xe0, 0xe6, 0xfa, 0x88, 0xbb, 0xec, 0x3d, 0xe8, 0xa6, 0x1c, 0x86, 0x6e, 0xae, - 0x0e, 0x41, 0x37, 0xc1, 0x39, 0xc4, 0x83, 0x37, 0xe5, 0x30, 0x78, 0x73, 0x75, 0x08, 0xbc, 0xf1, - 0x25, 0x05, 0xf0, 0x4d, 0xad, 0x1f, 0xbe, 0x79, 0x79, 0x04, 0x7c, 0xe3, 0x3b, 0x2f, 0x5d, 0x00, - 0xe7, 0xdd, 0x6e, 0x80, 0x53, 0x18, 0x04, 0x70, 0xfc, 0x11, 0xe9, 0x22, 0x9c, 0xad, 0x70, 0x84, - 0x73, 0x7d, 0x28, 0xc2, 0x09, 0x1a, 0xc9, 0x00, 0xc4, 0xd9, 0x08, 0x85, 0x38, 0xd7, 0x86, 0x41, - 0x1c, 0xdf, 0x48, 0x06, 0x31, 0xce, 0xbb, 0xdd, 0x18, 0xa7, 0x30, 0x08, 0xe3, 0xf8, 0x95, 0x73, - 0x41, 0x4e, 0x39, 0x0c, 0xe4, 0x5c, 0x1d, 0x02, 0x72, 0xfc, 0xc6, 0x0b, 0xa0, 0x1c, 0x65, 0x20, - 0xca, 0x79, 0x75, 0x44, 0x94, 0xd3, 0x65, 0xb8, 0x3a, 0x61, 0x4e, 0x39, 0x0c, 0xe6, 0x5c, 0x1d, - 0x02, 0x73, 0x02, 0x85, 0xf5, 0x71, 0xce, 0x56, 0x38, 0xce, 0xb9, 0x3e, 0x14, 0xe7, 0x74, 0x8d, - 0x26, 0x17, 0xe8, 0x6c, 0x84, 0x02, 0x9d, 0x6b, 0xc3, 0x80, 0x4e, 0xd7, 0xc4, 0xc7, 0x9d, 0x83, - 0x7f, 0x36, 0x3a, 0xd2, 0x79, 0xeb, 0xec, 0x48, 0xc7, 0x7b, 0x67, 0x24, 0x50, 0x67, 0x3d, 0x91, - 0x7a, 0x41, 0x7c, 0xb1, 0xf0, 0xdb, 0x71, 0x48, 0x96, 0xbd, 0x58, 0x18, 0xbf, 0x94, 0xc2, 0xf3, - 0x5c, 0x83, 0x84, 0xd6, 0xc8, 0x88, 0xa5, 0x76, 0x6f, 0xf8, 0x8d, 0x77, 0xbd, 0xb7, 0xb1, 0x71, - 0xd6, 0xe7, 0x38, 0x85, 0x8c, 0xde, 0x80, 0xc9, 0xb6, 0x8d, 0x2d, 0xb9, 0x65, 0xe9, 0xa6, 0xa5, - 0x3b, 0xec, 0x44, 0x87, 0xb0, 0x2a, 0x7e, 0x76, 0xba, 0x90, 0xdd, 0xb1, 0xb1, 0xb5, 0xcd, 0xe9, - 0x52, 0xb6, 0x1d, 0x78, 0x72, 0xbf, 0x0c, 0x35, 0x3e, 0xfa, 0x97, 0xa1, 0x1e, 0x81, 0x68, 0x61, - 0x45, 0xeb, 0xf0, 0x40, 0xd8, 0x35, 0x43, 0xe1, 0x7d, 0x86, 0x1e, 0x96, 0x72, 0x73, 0xd2, 0xeb, - 0x86, 0xa6, 0xac, 0x4e, 0x22, 0xba, 0x05, 0xe7, 0x9a, 0xca, 0x31, 0x8d, 0x7a, 0x94, 0x5d, 0xa7, - 0x8e, 0x46, 0x32, 0xb2, 0x8f, 0x2e, 0xa1, 0xa6, 0x72, 0x4c, 0x3f, 0x33, 0xc5, 0x92, 0xe8, 0x77, - 0x21, 0xae, 0x42, 0x4e, 0xd3, 0x6d, 0x47, 0x37, 0x54, 0x87, 0x5f, 0x30, 0xcb, 0x6e, 0x6c, 0x9d, - 0x74, 0xa9, 0xec, 0x16, 0xd9, 0x9b, 0x30, 0xcd, 0x83, 0xe2, 0x03, 0x5b, 0x84, 0xc0, 0x23, 0xcd, - 0x68, 0x82, 0xb7, 0x2b, 0x88, 0x8a, 0x30, 0x55, 0x57, 0x1c, 0x7c, 0xa4, 0x9c, 0xc8, 0xee, 0x89, - 0xaa, 0x0c, 0xbd, 0x9f, 0xf1, 0xd2, 0xb3, 0xd3, 0x85, 0xc9, 0xfb, 0x2c, 0xa9, 0xe7, 0x60, 0xd5, - 0x64, 0x3d, 0x90, 0xa0, 0xa1, 0xeb, 0x30, 0xa5, 0xd8, 0x27, 0x86, 0x4a, 0xd5, 0x83, 0x0d, 0xbb, - 0x6d, 0x53, 0x48, 0x91, 0x92, 0x72, 0x94, 0x5c, 0x74, 0xa9, 0xe8, 0x32, 0x64, 0x79, 0xc4, 0x38, - 0xfb, 0x56, 0xcd, 0x14, 0xad, 0x2a, 0xff, 0x74, 0x02, 0xfd, 0x5c, 0x0d, 0xba, 0x0b, 0x73, 0xfc, - 0x4a, 0xf9, 0x23, 0xc5, 0xd2, 0x64, 0xaa, 0x75, 0xbf, 0x7f, 0x8a, 0x54, 0xec, 0x05, 0x76, 0x85, - 0x3c, 0xc9, 0x40, 0x54, 0x1d, 0xbc, 0x7f, 0x75, 0x42, 0x4c, 0xad, 0x27, 0x52, 0x59, 0x71, 0x72, - 0x3d, 0x91, 0xca, 0x89, 0x53, 0x85, 0x7f, 0x2d, 0x40, 0xb6, 0xe3, 0x14, 0xca, 0xdd, 0xae, 0x4d, - 0xe0, 0x8b, 0xe1, 0xd0, 0xa9, 0x5f, 0xdc, 0x58, 0x8a, 0x37, 0x95, 0x1b, 0x35, 0xb7, 0xd0, 0xdf, - 0xf5, 0xa6, 0x0b, 0x09, 0x6e, 0xe4, 0x81, 0xcb, 0xf6, 0x76, 0xe2, 0xdf, 0x7e, 0xbc, 0x30, 0x56, - 0xf8, 0x24, 0x01, 0x93, 0x9d, 0xa7, 0x4d, 0x2a, 0x5d, 0xe5, 0x0a, 0x33, 0x6d, 0x1d, 0x1c, 0x4b, - 0x03, 0x2e, 0xdd, 0x4b, 0xfb, 0x77, 0xc2, 0xb3, 0x62, 0x2e, 0x0e, 0xd8, 0xea, 0x0e, 0x96, 0xd3, - 0x67, 0x9c, 0xfb, 0xe7, 0x71, 0xcf, 0x44, 0x2c, 0xc1, 0x38, 0xbd, 0x06, 0x86, 0x17, 0x2d, 0xec, - 0x20, 0x73, 0x89, 0xa4, 0x4b, 0x2c, 0x1b, 0x31, 0x29, 0xb5, 0xe7, 0xba, 0x59, 0xcd, 0xbf, 0xc4, - 0xe2, 0xec, 0x1f, 0x6f, 0xe3, 0xf7, 0xeb, 0x8d, 0x9f, 0xed, 0x7e, 0x3d, 0xb6, 0x29, 0xdd, 0x68, - 0x30, 0x73, 0xcd, 0x06, 0x55, 0xb2, 0xe7, 0xb4, 0x30, 0x15, 0xc1, 0xbf, 0xa9, 0xb7, 0x24, 0xf1, - 0x6f, 0xea, 0x05, 0x02, 0x19, 0x73, 0x9e, 0x08, 0x36, 0x02, 0x8b, 0xee, 0x2c, 0xcd, 0x3e, 0xf4, - 0x36, 0x31, 0xf2, 0x87, 0xde, 0xc0, 0xdb, 0xa4, 0xb7, 0x59, 0xcc, 0x2c, 0xef, 0x2f, 0x3f, 0x14, - 0x40, 0xa4, 0x79, 0xef, 0x61, 0xac, 0x45, 0xd2, 0x95, 0xdd, 0x40, 0xcd, 0xd8, 0xe8, 0x91, 0xf0, - 0x1d, 0x17, 0xfd, 0xc7, 0x3b, 0x2f, 0xfa, 0x2f, 0x7c, 0x2c, 0x40, 0xce, 0x2b, 0x21, 0xfb, 0xc4, - 0xd5, 0x80, 0xbb, 0xf7, 0x9e, 0xef, 0xc3, 0x4e, 0xee, 0x75, 0x02, 0x23, 0x7d, 0x75, 0x2b, 0x78, - 0x9d, 0x00, 0xfb, 0x08, 0xd1, 0xbf, 0x17, 0x60, 0xc6, 0x2b, 0x62, 0xd1, 0x3f, 0x2a, 0xfe, 0x1c, - 0x87, 0x02, 0x24, 0xfa, 0xa5, 0x40, 0xb3, 0x71, 0xc8, 0xee, 0x71, 0x18, 0xa9, 0x8f, 0x23, 0x1e, - 0xfe, 0x01, 0x7c, 0xf5, 0x41, 0xab, 0x55, 0xe9, 0x37, 0x04, 0xd9, 0x7f, 0xbb, 0x70, 0x2f, 0xa0, - 0x40, 0x3a, 0x9c, 0x88, 0x96, 0x46, 0x1a, 0x77, 0xae, 0x96, 0x68, 0xe6, 0xc2, 0xcf, 0x83, 0x2d, - 0x51, 0x3a, 0x24, 0x5e, 0xe7, 0x1d, 0x88, 0x1f, 0x2a, 0x8d, 0x41, 0x61, 0x2f, 0x1d, 0x2d, 0x27, - 0x91, 0xdc, 0xe8, 0x5e, 0xc7, 0x09, 0xfb, 0x58, 0x7f, 0x0f, 0xa9, 0x57, 0xa5, 0x1d, 0x27, 0xf1, - 0xdf, 0x74, 0x6b, 0x11, 0x1f, 0xfe, 0xfa, 0xa0, 0x19, 0x79, 0x3b, 0xf1, 0xe9, 0xc7, 0x0b, 0xc2, - 0xcd, 0x2a, 0xcc, 0x84, 0xcc, 0xa7, 0x28, 0x07, 0x10, 0xb8, 0xfe, 0x9f, 0x7f, 0x76, 0x70, 0x65, - 0x4d, 0xde, 0xd9, 0x2a, 0x3e, 0xdc, 0xdc, 0xac, 0xd4, 0x6a, 0xa5, 0x35, 0x51, 0x40, 0x22, 0x64, - 0x3b, 0x3e, 0x1e, 0x10, 0x63, 0x1f, 0x22, 0xbc, 0xf9, 0x8f, 0x00, 0xfc, 0x6f, 0x92, 0x10, 0x59, - 0x1b, 0xa5, 0xf7, 0xe5, 0xc7, 0x2b, 0x0f, 0x76, 0x4a, 0x55, 0x71, 0x0c, 0x21, 0xc8, 0xad, 0xae, - 0xd4, 0x8a, 0x65, 0x59, 0x2a, 0x55, 0xb7, 0x1f, 0x6e, 0x55, 0x4b, 0xee, 0x07, 0x0c, 0x6f, 0xae, - 0x41, 0x36, 0x78, 0x17, 0x01, 0x9a, 0x81, 0xa9, 0x62, 0xb9, 0x54, 0xdc, 0x90, 0x1f, 0x57, 0x56, - 0xe4, 0x47, 0x3b, 0xa5, 0x9d, 0x92, 0x38, 0x46, 0x8b, 0x46, 0x89, 0xf7, 0x76, 0x1e, 0x3c, 0x10, - 0x05, 0x34, 0x05, 0x19, 0xf6, 0x4c, 0x3f, 0x34, 0x20, 0xc6, 0x6e, 0x6e, 0x42, 0x26, 0x70, 0x13, - 0x21, 0x79, 0xdd, 0xf6, 0x4e, 0xb5, 0x2c, 0xd7, 0x2a, 0x9b, 0xa5, 0x6a, 0x6d, 0x65, 0x73, 0x9b, - 0xc9, 0xa0, 0xb4, 0x95, 0xd5, 0x87, 0x52, 0x4d, 0x14, 0xbc, 0xe7, 0xda, 0xc3, 0x9d, 0x62, 0xd9, - 0xad, 0x46, 0x21, 0x91, 0x8a, 0x8b, 0xf1, 0x9b, 0xdf, 0x11, 0xe0, 0x42, 0x9f, 0x13, 0xf9, 0x28, - 0x03, 0x13, 0x3b, 0x06, 0xbd, 0x8a, 0x4d, 0x1c, 0x43, 0x93, 0x81, 0x43, 0xf9, 0xa2, 0x80, 0x52, - 0xec, 0x40, 0xb4, 0x18, 0x43, 0x49, 0x88, 0x55, 0xef, 0x88, 0x71, 0x52, 0xd2, 0xc0, 0x99, 0x76, - 0x31, 0x81, 0xd2, 0xfc, 0x48, 0xae, 0x38, 0x8e, 0xb2, 0xfe, 0x99, 0x58, 0x31, 0x49, 0x44, 0x79, - 0xa7, 0x4a, 0xc5, 0x89, 0x9b, 0x97, 0x21, 0x70, 0x42, 0x0f, 0x01, 0x24, 0x1f, 0x28, 0x0e, 0xb6, - 0x1d, 0x71, 0x0c, 0x4d, 0x40, 0x7c, 0xa5, 0xd1, 0x10, 0x85, 0xdb, 0xff, 0x45, 0x80, 0x94, 0x7b, - 0x95, 0x3e, 0x7a, 0x00, 0xe3, 0x6c, 0x29, 0x61, 0xa1, 0xff, 0x34, 0x47, 0x8d, 0xdc, 0xdc, 0xe2, - 0xb0, 0x79, 0xb0, 0x30, 0x86, 0xde, 0x83, 0xb4, 0xd7, 0x83, 0xd0, 0x4b, 0x83, 0xfa, 0x97, 0x2b, - 0x75, 0x70, 0x27, 0x24, 0x63, 0xa6, 0x30, 0xf6, 0x9a, 0xb0, 0xfa, 0xf2, 0xa7, 0xbf, 0x9e, 0x1f, - 0xfb, 0xf4, 0xd9, 0xbc, 0xf0, 0x8b, 0x67, 0xf3, 0xc2, 0xaf, 0x9e, 0xcd, 0x0b, 0x7f, 0xf6, 0x6c, - 0x5e, 0xf8, 0x57, 0xbf, 0x99, 0x1f, 0xfb, 0xc5, 0x6f, 0xe6, 0xc7, 0x7e, 0xf5, 0x9b, 0xf9, 0xb1, - 0x0f, 0x26, 0x38, 0xf7, 0x6e, 0x92, 0x7e, 0x46, 0xf5, 0xce, 0xdf, 0x05, 0x00, 0x00, 0xff, 0xff, - 0x33, 0xfb, 0x05, 0x9d, 0x69, 0x76, 0x00, 0x00, + 0xf8, 0x62, 0xf2, 0xca, 0x9b, 0xff, 0xf3, 0x74, 0xfe, 0xce, 0x50, 0x51, 0x5b, 0x34, 0xee, 0xac, + 0xdd, 0xd6, 0xb5, 0xc5, 0x9d, 0x9d, 0xb5, 0x55, 0x49, 0xa4, 0x22, 0xdf, 0x63, 0x12, 0x6b, 0xc7, + 0x86, 0x3b, 0x8b, 0x7f, 0x26, 0x80, 0xe8, 0x6b, 0x2a, 0xce, 0xe6, 0x2c, 0x43, 0xf6, 0x49, 0x1b, + 0x5b, 0xfa, 0x73, 0x34, 0x26, 0x70, 0x46, 0x62, 0x88, 0x3e, 0x80, 0x5c, 0x48, 0x0f, 0xc9, 0xcf, + 0xa7, 0x87, 0xec, 0x91, 0xaf, 0x82, 0xe2, 0x7f, 0x12, 0x00, 0xd1, 0xca, 0xaf, 0xb1, 0x75, 0xfc, + 0x2f, 0x4b, 0x4f, 0xb9, 0x01, 0x22, 0x8d, 0x58, 0x94, 0xf5, 0x3d, 0xb9, 0xa9, 0xdb, 0xb6, 0x6e, + 0xd4, 0x79, 0x57, 0xc9, 0x53, 0xfa, 0xda, 0xde, 0x26, 0xa3, 0xf2, 0x46, 0xfc, 0x1b, 0x30, 0x1d, + 0xaa, 0x46, 0x9c, 0xcd, 0x78, 0x19, 0x72, 0x7b, 0x66, 0xdb, 0xd0, 0x64, 0xb6, 0xd7, 0xc1, 0x17, + 0xff, 0xb2, 0x94, 0xc6, 0xde, 0x57, 0xfc, 0x7f, 0x09, 0x98, 0x91, 0xb0, 0x6d, 0x36, 0x0e, 0x71, + 0xfc, 0x8a, 0xac, 0x00, 0xdf, 0x65, 0x91, 0x9f, 0x4b, 0x9f, 0x19, 0xc6, 0xcc, 0xa6, 0xb4, 0xf0, + 0x3a, 0xfa, 0x95, 0xfe, 0x7d, 0xb1, 0x7b, 0xe5, 0x9c, 0x2f, 0xcb, 0xa5, 0x42, 0xcb, 0x72, 0x26, + 0x4c, 0xea, 0x75, 0xc3, 0x24, 0x36, 0xcb, 0xc6, 0x4f, 0x8c, 0x76, 0xd3, 0xc5, 0x2c, 0x8b, 0xfd, + 0x0a, 0xb9, 0xc6, 0x58, 0xaa, 0xf8, 0xc9, 0x56, 0xbb, 0x49, 0x3d, 0xe7, 0x95, 0xf3, 0xa4, 0xbc, + 0xcf, 0x4e, 0xe7, 0xf3, 0xa1, 0x34, 0x5b, 0xca, 0xeb, 0xde, 0x33, 0x91, 0xce, 0x9b, 0xfc, 0xdb, + 0x70, 0xae, 0x43, 0xe5, 0x71, 0xfa, 0x38, 0xff, 0x21, 0x09, 0x17, 0xc3, 0xe2, 0xe3, 0x46, 0x22, + 0x5f, 0xf6, 0x66, 0xad, 0xc0, 0x44, 0x53, 0x37, 0x9e, 0x6f, 0x21, 0x32, 0xd7, 0xd4, 0x0d, 0x7f, + 0x3d, 0x37, 0xa2, 0x83, 0x8c, 0xfd, 0x25, 0x74, 0x10, 0x05, 0x66, 0xa3, 0x5a, 0x30, 0xce, 0x5e, + 0xf2, 0x91, 0x00, 0xb9, 0xb8, 0xd7, 0xd6, 0x9e, 0x2f, 0xc6, 0x8c, 0xd7, 0xb9, 0x06, 0x13, 0x5f, + 0xc0, 0x62, 0xdc, 0x4f, 0x05, 0x40, 0x35, 0xab, 0x6d, 0x10, 0x90, 0xfb, 0xc0, 0xac, 0xc7, 0x59, + 0xd9, 0x19, 0x18, 0xd5, 0x0d, 0x0d, 0x1f, 0xd3, 0xca, 0xa6, 0x24, 0xf6, 0x10, 0xda, 0x40, 0x4c, + 0x0e, 0xb5, 0x81, 0xe8, 0x87, 0xaa, 0x84, 0x0a, 0x1a, 0xa7, 0x16, 0xfe, 0x45, 0x02, 0xa6, 0x79, + 0x75, 0x62, 0x5f, 0x8c, 0x7c, 0x1d, 0x46, 0x1b, 0x44, 0x66, 0x9f, 0x36, 0xa7, 0xef, 0x74, 0xdb, + 0x9c, 0x66, 0x46, 0x5f, 0x03, 0x68, 0x59, 0xf8, 0x50, 0x66, 0xac, 0xc9, 0xa1, 0x58, 0x33, 0x84, + 0x83, 0x12, 0xd0, 0x37, 0x61, 0x92, 0x8c, 0xf0, 0x96, 0x65, 0xb6, 0x4c, 0x9b, 0x38, 0x29, 0xf6, + 0x70, 0x48, 0x67, 0xea, 0xd9, 0xe9, 0xfc, 0xc4, 0xa6, 0x6e, 0x6c, 0x73, 0xc6, 0x5a, 0x55, 0x22, + 0xa6, 0xc2, 0x7b, 0x74, 0x07, 0xe0, 0x7f, 0x17, 0x60, 0xe6, 0x0b, 0x5b, 0xbe, 0xfd, 0xab, 0xd0, + 0x98, 0x37, 0xf3, 0x88, 0xf4, 0x71, 0xcd, 0xd8, 0x33, 0xe3, 0x5f, 0x54, 0xff, 0x48, 0x80, 0xa9, + 0x80, 0xf8, 0x38, 0x3d, 0x99, 0xe7, 0xd2, 0x59, 0xf1, 0x5b, 0xc4, 0xb7, 0x09, 0x76, 0xfb, 0x38, + 0x07, 0xd5, 0xbf, 0x4d, 0xc0, 0xf9, 0x12, 0xdb, 0x5a, 0x76, 0xe3, 0x2e, 0xe2, 0xec, 0x25, 0x05, + 0x18, 0x3f, 0xc4, 0x96, 0xad, 0x9b, 0x6c, 0x86, 0x9d, 0x90, 0xdc, 0x47, 0x34, 0x0b, 0x69, 0xdb, + 0x50, 0x5a, 0xf6, 0xbe, 0xe9, 0xee, 0xc6, 0x79, 0xcf, 0x5e, 0x8c, 0xc8, 0xe8, 0xf3, 0xc7, 0x88, + 0x8c, 0xf5, 0x8f, 0x11, 0x19, 0xff, 0xdc, 0x31, 0x22, 0x7c, 0xeb, 0xeb, 0x17, 0x02, 0x5c, 0xe8, + 0xd2, 0x5f, 0x9c, 0x7d, 0xe6, 0xbb, 0x90, 0x55, 0xb9, 0x60, 0x62, 0x8d, 0xd9, 0xee, 0xde, 0x1a, + 0xc9, 0xf6, 0x9c, 0x00, 0xe4, 0xd9, 0xe9, 0x3c, 0xb8, 0x45, 0x5d, 0x5b, 0xe5, 0x2a, 0x22, 0xff, + 0xb5, 0xe2, 0xff, 0xc8, 0xc1, 0x64, 0xf9, 0x98, 0xad, 0x5d, 0x57, 0x99, 0x3f, 0x80, 0xee, 0x41, + 0xba, 0x65, 0x99, 0x87, 0xba, 0x5b, 0x8d, 0x7c, 0x28, 0x34, 0xc0, 0xad, 0x46, 0x07, 0xd7, 0x36, + 0xe7, 0x90, 0x3c, 0x5e, 0x54, 0x83, 0xcc, 0x03, 0x53, 0x55, 0x1a, 0xf7, 0xf4, 0x86, 0xdb, 0xff, + 0x5f, 0x1b, 0x2c, 0x68, 0xd1, 0xe3, 0xd9, 0x56, 0x9c, 0x7d, 0xb7, 0x29, 0x3c, 0x22, 0x5a, 0x83, + 0x74, 0xc5, 0x71, 0x5a, 0x24, 0x91, 0x5b, 0x93, 0xeb, 0x43, 0x08, 0x25, 0x2c, 0x5c, 0x96, 0xc7, + 0x8e, 0x6a, 0x30, 0x75, 0xdf, 0x34, 0xeb, 0x0d, 0x5c, 0x6a, 0x98, 0x6d, 0xad, 0x64, 0x1a, 0x7b, + 0x7a, 0x9d, 0xdb, 0xe3, 0x6b, 0x43, 0xc8, 0xbc, 0x5f, 0xaa, 0x4a, 0xdd, 0x02, 0xd0, 0x32, 0xa4, + 0xab, 0x77, 0xb8, 0x30, 0xe6, 0xc0, 0x5d, 0x1d, 0x42, 0x58, 0xf5, 0x8e, 0xe4, 0xb1, 0xa1, 0x75, + 0xc8, 0x2e, 0x3f, 0x6d, 0x5b, 0x98, 0x4b, 0x19, 0xeb, 0x19, 0x97, 0xd0, 0x29, 0x85, 0x72, 0x49, + 0x41, 0x66, 0x54, 0x85, 0xfc, 0x7b, 0xa6, 0x75, 0xd0, 0x30, 0x15, 0xb7, 0x86, 0xe3, 0x54, 0xdc, + 0x57, 0x86, 0x10, 0xe7, 0x32, 0x4a, 0x1d, 0x22, 0xd0, 0xb7, 0x61, 0x92, 0x34, 0x46, 0x4d, 0xd9, + 0x6d, 0xb8, 0x85, 0x4c, 0x53, 0xa9, 0xaf, 0x0c, 0x21, 0xd5, 0xe3, 0x74, 0x37, 0x4f, 0x3a, 0x44, + 0xcd, 0x7e, 0x13, 0x26, 0x42, 0x9d, 0x00, 0x21, 0x48, 0xb5, 0x48, 0x7b, 0x0b, 0x34, 0x7e, 0x88, + 0xfe, 0x47, 0xaf, 0xc2, 0xb8, 0x61, 0x6a, 0xd8, 0x1d, 0x21, 0x13, 0x2b, 0x33, 0xcf, 0x4e, 0xe7, + 0xc7, 0xb6, 0x4c, 0x8d, 0xb9, 0x2b, 0xfc, 0x9f, 0x34, 0x46, 0x32, 0xb9, 0xce, 0xca, 0xec, 0x35, + 0x48, 0x91, 0xd6, 0x27, 0x46, 0x6a, 0x57, 0xb1, 0xf1, 0x8e, 0xa5, 0x73, 0x99, 0xee, 0x23, 0xcf, + 0xf7, 0x1b, 0x01, 0x12, 0xd5, 0x3b, 0xc4, 0x51, 0xdf, 0x6d, 0xab, 0x07, 0xd8, 0xe1, 0xb9, 0xf8, + 0x13, 0x75, 0xe0, 0x2d, 0xbc, 0xa7, 0x33, 0x1f, 0x2a, 0x23, 0xf1, 0x27, 0xf4, 0x22, 0x80, 0xa2, + 0xaa, 0xd8, 0xb6, 0x65, 0xf7, 0xd4, 0x5c, 0x46, 0xca, 0x30, 0xca, 0x06, 0x3e, 0x21, 0x6c, 0x36, + 0x56, 0x2d, 0xec, 0xb8, 0x81, 0x50, 0xec, 0x89, 0xb0, 0x39, 0xb8, 0xd9, 0x92, 0x1d, 0xf3, 0x00, + 0x1b, 0xb4, 0xcf, 0x64, 0x88, 0xf1, 0x69, 0xb6, 0x6a, 0x84, 0x40, 0xec, 0x26, 0x36, 0x34, 0xdf, + 0xc8, 0x65, 0x24, 0xef, 0x99, 0x88, 0xb4, 0x70, 0x5d, 0xe7, 0x07, 0xbf, 0x32, 0x12, 0x7f, 0x22, + 0x1a, 0x53, 0xda, 0xce, 0x3e, 0x6d, 0x95, 0x8c, 0x44, 0xff, 0xf3, 0xaa, 0xfd, 0x13, 0x01, 0x92, + 0xf7, 0x4b, 0xd5, 0x33, 0xd7, 0xcd, 0x95, 0x98, 0xf4, 0x25, 0xd2, 0xf8, 0x43, 0xbd, 0xd1, 0xd0, + 0x8d, 0x3a, 0x71, 0x69, 0xbe, 0x8b, 0x55, 0xb7, 0x66, 0x79, 0x4e, 0xde, 0x66, 0x54, 0xb4, 0x00, + 0x59, 0xd5, 0xc2, 0x1a, 0x36, 0x1c, 0x5d, 0x69, 0xd8, 0xbc, 0x8a, 0x41, 0x12, 0x2f, 0xdc, 0xf7, + 0x05, 0x18, 0xa5, 0x9d, 0x17, 0xbd, 0x00, 0x19, 0xd5, 0x34, 0x1c, 0x45, 0x37, 0xb8, 0x15, 0xca, + 0x48, 0x3e, 0xa1, 0x67, 0x21, 0x2f, 0x43, 0x4e, 0x51, 0x55, 0xb3, 0x6d, 0x38, 0xb2, 0xa1, 0x34, + 0x31, 0x2f, 0x6c, 0x96, 0xd3, 0xb6, 0x94, 0x26, 0x46, 0xf3, 0xe0, 0x3e, 0x7a, 0x67, 0x17, 0x33, + 0x12, 0x70, 0xd2, 0x06, 0x3e, 0xe1, 0x25, 0xf9, 0x85, 0x00, 0x69, 0xb7, 0xd3, 0x93, 0xc2, 0xd4, + 0xb1, 0x81, 0x2d, 0xc5, 0x31, 0xbd, 0xc2, 0x78, 0x84, 0xce, 0x19, 0x2f, 0xe3, 0xcf, 0x78, 0x33, + 0x30, 0xea, 0x90, 0x7e, 0xcd, 0xcb, 0xc1, 0x1e, 0xe8, 0x5a, 0x73, 0x43, 0xa9, 0xb3, 0xe5, 0xb5, + 0x8c, 0xc4, 0x1e, 0x48, 0x95, 0x78, 0x0c, 0x2d, 0xd3, 0x0e, 0x7f, 0x22, 0xe5, 0x65, 0x31, 0x9e, + 0xbb, 0xb8, 0xae, 0x1b, 0xb4, 0x03, 0x24, 0x25, 0xa0, 0xa4, 0x15, 0x42, 0x41, 0x97, 0x20, 0xc3, + 0x32, 0x60, 0x43, 0xa3, 0xbd, 0x20, 0x29, 0xa5, 0x29, 0xa1, 0xec, 0x1e, 0xce, 0x9a, 0x3d, 0x80, + 0x8c, 0x37, 0xc6, 0x48, 0x43, 0xb6, 0x6d, 0x4f, 0xa9, 0xf4, 0x3f, 0x7a, 0x0d, 0x66, 0x9e, 0xb4, + 0x95, 0x86, 0xbe, 0x47, 0x57, 0xce, 0x48, 0x36, 0xa6, 0x3f, 0x56, 0x1f, 0xe4, 0xa5, 0x51, 0x09, + 0x54, 0x8d, 0xee, 0x90, 0x4c, 0xfa, 0x43, 0x32, 0xb8, 0x15, 0x52, 0xfc, 0x44, 0x80, 0x29, 0x16, + 0x06, 0xc4, 0x22, 0x51, 0xe3, 0x73, 0x30, 0xde, 0x86, 0x8c, 0xa6, 0x38, 0x0a, 0x3b, 0x9f, 0x99, + 0xe8, 0x7b, 0x3e, 0xd3, 0xb5, 0xf8, 0x24, 0x3f, 0x3d, 0xa3, 0x89, 0x20, 0x45, 0xfe, 0xb3, 0x03, + 0xad, 0x12, 0xfd, 0xef, 0x07, 0x56, 0x04, 0x8b, 0x1b, 0xa7, 0xc3, 0xb5, 0x04, 0xe7, 0x88, 0xf6, + 0xcb, 0x86, 0x6a, 0x9d, 0xb4, 0x1c, 0xdd, 0x34, 0x1e, 0xd2, 0x5f, 0x1b, 0x89, 0x81, 0x8d, 0x29, + 0xba, 0x1f, 0xc5, 0xcb, 0xf2, 0x1f, 0xc7, 0x60, 0xa2, 0x7c, 0xdc, 0x32, 0xad, 0x58, 0x17, 0xb5, + 0x56, 0x60, 0x9c, 0x23, 0xfe, 0x3e, 0x5b, 0xc5, 0x1d, 0xb6, 0xda, 0xdd, 0x85, 0xe5, 0x8c, 0x68, + 0x05, 0x80, 0xc5, 0x8c, 0xd2, 0x58, 0xa2, 0xe4, 0x19, 0x36, 0xcc, 0x28, 0x1b, 0xa1, 0xa2, 0x2d, + 0xc8, 0x36, 0x0f, 0x55, 0x55, 0xde, 0xd3, 0x1b, 0x0e, 0x0f, 0xba, 0x8b, 0x8e, 0x18, 0xdf, 0x7c, + 0x5c, 0x2a, 0xdd, 0xa3, 0x99, 0x58, 0xfc, 0x9b, 0xff, 0x2c, 0x01, 0x91, 0xc0, 0xfe, 0xa3, 0x57, + 0x80, 0x9f, 0x9b, 0x91, 0x6d, 0xf7, 0x88, 0xdc, 0xca, 0xc4, 0xb3, 0xd3, 0xf9, 0x8c, 0x44, 0xa9, + 0xd5, 0x6a, 0x4d, 0xca, 0xb0, 0x0c, 0x55, 0xdb, 0x41, 0x2f, 0xc1, 0x84, 0xd9, 0xd4, 0x1d, 0xd9, + 0xf5, 0x81, 0xb8, 0xdb, 0x98, 0x23, 0x44, 0xd7, 0x47, 0x42, 0x35, 0xb8, 0x8e, 0x0d, 0x3a, 0x0a, + 0x48, 0x3d, 0xe5, 0x5d, 0xb6, 0x16, 0xe9, 0xb0, 0xf1, 0x2e, 0x9b, 0x2d, 0x47, 0x6f, 0xea, 0x4f, + 0xe9, 0x66, 0x35, 0xdf, 0x2f, 0x7a, 0x89, 0x65, 0x27, 0xf5, 0x5b, 0xa1, 0x8b, 0x94, 0x3c, 0xef, + 0xc3, 0x40, 0x56, 0xf4, 0x7d, 0x01, 0xce, 0x73, 0x45, 0xca, 0xbb, 0x34, 0xe4, 0x5d, 0x69, 0xe8, + 0xce, 0x89, 0x7c, 0x70, 0x58, 0x48, 0x53, 0xe7, 0xf4, 0xab, 0x91, 0x0d, 0x12, 0xe8, 0x07, 0x8b, + 0x6e, 0xb3, 0x9c, 0x3c, 0xe0, 0xcc, 0x1b, 0x87, 0x65, 0xc3, 0xb1, 0x4e, 0x56, 0x2e, 0x3c, 0x3b, + 0x9d, 0x9f, 0xee, 0x4e, 0x7d, 0x2c, 0x4d, 0xdb, 0xdd, 0x2c, 0xa8, 0x02, 0x80, 0xbd, 0xde, 0x48, + 0x43, 0xfe, 0xa2, 0xdd, 0x8b, 0xc8, 0x6e, 0x2b, 0x05, 0x78, 0xd1, 0x0d, 0x10, 0xf9, 0xa1, 0x97, + 0x3d, 0xbd, 0x81, 0x65, 0x5b, 0x7f, 0x8a, 0x0b, 0x40, 0x6d, 0x50, 0x9e, 0xd1, 0x89, 0x88, 0xaa, + 0xfe, 0x14, 0xcf, 0x7e, 0x17, 0x0a, 0xbd, 0x4a, 0x1f, 0x1c, 0x08, 0x19, 0xb6, 0x31, 0xfb, 0x56, + 0x78, 0x45, 0x66, 0x88, 0xae, 0xea, 0xae, 0xca, 0x24, 0xde, 0x72, 0x4d, 0xd0, 0xcf, 0x12, 0x30, + 0xb1, 0xd2, 0x6e, 0x1c, 0x3c, 0x6c, 0x55, 0xdb, 0xcd, 0xa6, 0x62, 0x9d, 0x10, 0x53, 0xc9, 0x4c, + 0x07, 0x29, 0xa6, 0xc0, 0x4c, 0x25, 0xb5, 0x0d, 0xfa, 0x53, 0x4c, 0x26, 0xb3, 0xe0, 0x21, 0x6d, + 0x16, 0xd2, 0x4f, 0x6b, 0x12, 0x38, 0x79, 0x6d, 0x1e, 0xd9, 0xe8, 0x2d, 0x28, 0x04, 0x32, 0xd2, + 0xe5, 0x13, 0x19, 0x1b, 0x8e, 0xa5, 0x63, 0xb6, 0x1c, 0x98, 0x94, 0x02, 0xe1, 0x34, 0x6b, 0x24, + 0xb9, 0xcc, 0x52, 0x51, 0x0d, 0x72, 0x24, 0xe3, 0x89, 0x4c, 0x27, 0x1b, 0x77, 0xd1, 0xf6, 0x56, + 0x44, 0xe5, 0x42, 0xe5, 0x5e, 0xa4, 0x5a, 0x2a, 0x51, 0x1e, 0xfa, 0x57, 0xca, 0x62, 0x9f, 0x32, + 0xfb, 0x2e, 0x88, 0x9d, 0x19, 0x82, 0x1a, 0x4d, 0x31, 0x8d, 0xce, 0x04, 0x35, 0x9a, 0x0c, 0x68, + 0x6b, 0x3d, 0x95, 0x4e, 0x89, 0xa3, 0xc5, 0xdf, 0x26, 0x21, 0xef, 0x76, 0xb6, 0x38, 0xd1, 0xcc, + 0x0a, 0x8c, 0x92, 0xae, 0xe1, 0x06, 0x7f, 0x5c, 0xeb, 0xd3, 0xc7, 0x79, 0xf8, 0x38, 0xe9, 0x32, + 0x2e, 0x1e, 0xa6, 0xac, 0x71, 0x98, 0x9d, 0xd9, 0xbf, 0x99, 0x80, 0x14, 0x05, 0x10, 0xb7, 0x20, + 0x45, 0xa7, 0x0e, 0x61, 0x98, 0xa9, 0x83, 0x66, 0xf5, 0x26, 0xbb, 0x44, 0xc0, 0xff, 0x24, 0xce, + 0xdc, 0xbe, 0xf2, 0xc6, 0xad, 0xdb, 0xd4, 0xe4, 0xe4, 0x24, 0xfe, 0x84, 0x56, 0x68, 0x54, 0x92, + 0x69, 0x39, 0x58, 0xe3, 0x8e, 0xfb, 0xc2, 0xa0, 0xf6, 0x75, 0xa7, 0x29, 0x97, 0x0f, 0x5d, 0x84, + 0x24, 0xb1, 0x65, 0xe3, 0x2c, 0x62, 0xe1, 0xd9, 0xe9, 0x7c, 0x92, 0x58, 0x31, 0x42, 0x43, 0x4b, + 0x90, 0x0d, 0x1b, 0x0e, 0xe1, 0x46, 0x86, 0x99, 0xc7, 0xc0, 0xa0, 0x87, 0x86, 0x37, 0xc0, 0x18, + 0x68, 0xe5, 0x6d, 0xfc, 0xbd, 0x51, 0x98, 0x58, 0x6b, 0xc6, 0x3d, 0xb1, 0x2c, 0x87, 0x5b, 0x38, + 0x0a, 0xed, 0x84, 0x5e, 0x1a, 0xd1, 0xc0, 0xa1, 0x39, 0x3d, 0x79, 0xb6, 0x39, 0x7d, 0x8d, 0xb8, + 0xc0, 0xfc, 0xd6, 0x85, 0x64, 0x0f, 0x60, 0x13, 0x7e, 0x3f, 0xf5, 0x62, 0x24, 0xc2, 0xe3, 0x1f, + 0xa8, 0xa0, 0x51, 0x27, 0xef, 0x52, 0x4f, 0x9b, 0xf5, 0xb2, 0xb1, 0xe1, 0x7b, 0xd9, 0x38, 0x36, + 0x34, 0x3a, 0xb5, 0x85, 0xed, 0xea, 0xf8, 0xf3, 0xdb, 0xd5, 0xd9, 0xa7, 0xbc, 0xb3, 0xbe, 0x0d, + 0x49, 0x4d, 0x77, 0x1b, 0x67, 0xf8, 0x09, 0x9b, 0x30, 0x0d, 0xe8, 0xb5, 0xa9, 0x60, 0xaf, 0x0d, + 0x2e, 0x70, 0xcc, 0x3e, 0x04, 0xf0, 0x35, 0x84, 0x16, 0x60, 0xcc, 0x6c, 0x68, 0xee, 0xb9, 0x92, + 0x89, 0x95, 0xcc, 0xb3, 0xd3, 0xf9, 0xd1, 0x87, 0x0d, 0x6d, 0x6d, 0x55, 0x1a, 0x35, 0x1b, 0xda, + 0x9a, 0x46, 0x2f, 0xbe, 0xc0, 0x47, 0xb2, 0x17, 0x84, 0x96, 0x93, 0xc6, 0x0d, 0x7c, 0xb4, 0x8a, + 0x6d, 0xb5, 0x23, 0x38, 0x86, 0x74, 0xc1, 0x1f, 0x0b, 0x90, 0x77, 0x5b, 0x23, 0x5e, 0x33, 0x93, + 0xd6, 0x9b, 0x7c, 0xd8, 0x25, 0xcf, 0x36, 0xec, 0x5c, 0x3e, 0x7e, 0xaa, 0xf6, 0x07, 0x02, 0x0f, + 0x40, 0xae, 0xaa, 0x8a, 0x43, 0x9c, 0x8d, 0x18, 0x87, 0xca, 0xcb, 0x20, 0x5a, 0x8a, 0xa1, 0x99, + 0x4d, 0xfd, 0x29, 0x66, 0x2b, 0xa2, 0x36, 0xdf, 0xdc, 0x9c, 0xf4, 0xe8, 0x74, 0xc9, 0xcf, 0x5d, + 0xd0, 0xfd, 0x83, 0xc0, 0x83, 0x95, 0xbd, 0xc2, 0xc4, 0xa9, 0xb4, 0x0d, 0x18, 0xb3, 0x58, 0xc8, + 0x23, 0x1b, 0xba, 0xaf, 0x46, 0x08, 0x89, 0x7a, 0x3b, 0x8b, 0x28, 0xf4, 0x06, 0x0f, 0x15, 0x31, + 0xfb, 0x0d, 0x18, 0xa5, 0xe4, 0xe7, 0x30, 0xb0, 0x5c, 0xf3, 0xbf, 0x4f, 0xc0, 0x15, 0xfa, 0xba, + 0xc7, 0xd8, 0xd2, 0xf7, 0x4e, 0xb6, 0x2d, 0xd3, 0xc1, 0xaa, 0x83, 0x35, 0xff, 0x18, 0x47, 0xac, + 0x56, 0x2b, 0xd3, 0x72, 0x5f, 0x70, 0xa6, 0xd0, 0x2f, 0x8f, 0x0b, 0x6d, 0xc0, 0x24, 0xbb, 0x5c, + 0x47, 0x56, 0x1a, 0xfa, 0x21, 0x96, 0x15, 0xe7, 0x2c, 0x73, 0xd3, 0x04, 0xe3, 0x5d, 0x26, 0xac, + 0xcb, 0x0e, 0xd2, 0x20, 0xc3, 0x85, 0xe9, 0x1a, 0xbf, 0x51, 0xe7, 0xfe, 0xe7, 0x5b, 0xf3, 0x4b, + 0x4b, 0x54, 0xde, 0xda, 0xaa, 0x94, 0x66, 0x92, 0xbd, 0x3d, 0x9b, 0x5f, 0x0b, 0x70, 0x75, 0x80, + 0xa2, 0xe3, 0xec, 0x66, 0xb3, 0x90, 0x3e, 0x24, 0x2f, 0xd2, 0xb9, 0xa6, 0xd3, 0x92, 0xf7, 0x8c, + 0x36, 0x61, 0x62, 0x4f, 0xd1, 0x1b, 0xee, 0xb5, 0x38, 0xfd, 0xe2, 0x05, 0xa3, 0xc3, 0x58, 0x73, + 0x8c, 0x9d, 0x26, 0xd2, 0x83, 0x8e, 0x53, 0xcb, 0x9a, 0x56, 0xad, 0x72, 0x0b, 0x16, 0x5f, 0x7f, + 0x71, 0xa1, 0x63, 0xc2, 0x87, 0x8e, 0xe8, 0x55, 0x40, 0x9a, 0x6e, 0xb3, 0xdb, 0x3a, 0xec, 0x7d, + 0x45, 0x33, 0x8f, 0xfc, 0xa8, 0x89, 0x29, 0x37, 0xa5, 0xea, 0x26, 0xa0, 0x2a, 0x50, 0xdc, 0x22, + 0xdb, 0x8e, 0xe2, 0x6d, 0xfc, 0x5c, 0x1d, 0xea, 0xd4, 0x15, 0x03, 0x34, 0xde, 0xa3, 0x94, 0x21, + 0x72, 0xe8, 0x5f, 0xe2, 0x81, 0xeb, 0xa4, 0xea, 0x8e, 0xac, 0xd8, 0xee, 0x11, 0x1d, 0x76, 0x4f, + 0x48, 0x9e, 0xd1, 0x97, 0xed, 0xe0, 0xc9, 0x1b, 0x76, 0x82, 0xc0, 0x57, 0x50, 0x9c, 0x40, 0xf7, + 0x9f, 0x0b, 0x90, 0x97, 0xf0, 0x9e, 0x85, 0xed, 0x58, 0x01, 0xff, 0x3d, 0xc8, 0x59, 0x4c, 0xaa, + 0xbc, 0x67, 0x99, 0xcd, 0xb3, 0x8c, 0xb1, 0x2c, 0x67, 0xbc, 0x67, 0x99, 0xcd, 0xd0, 0xd5, 0x09, + 0x8f, 0x61, 0xd2, 0x2b, 0x69, 0x9c, 0x2a, 0xf8, 0x84, 0x9e, 0x34, 0x66, 0x82, 0xe3, 0x0e, 0x5f, + 0xf8, 0x22, 0xf4, 0x40, 0x77, 0x9a, 0x82, 0xc5, 0x8d, 0x53, 0x19, 0x7f, 0x10, 0x20, 0x5f, 0x6d, + 0xef, 0xb2, 0xcb, 0xa2, 0xe2, 0xd3, 0x43, 0x19, 0x32, 0x0d, 0xbc, 0xe7, 0xc8, 0xcf, 0x15, 0xf5, + 0x9e, 0x26, 0xac, 0x34, 0xf2, 0xff, 0x3e, 0x80, 0x45, 0xcf, 0xb5, 0x51, 0x39, 0xc9, 0x33, 0xca, + 0xc9, 0x50, 0x5e, 0xdf, 0xc9, 0x29, 0x7e, 0x92, 0x80, 0x49, 0xaf, 0xb2, 0x71, 0x5a, 0xcf, 0xf7, + 0x42, 0x56, 0x23, 0x79, 0x16, 0xab, 0x31, 0xc5, 0xa3, 0x37, 0xa2, 0x2d, 0xc7, 0x22, 0x4c, 0x53, + 0x17, 0x44, 0x56, 0x5a, 0xad, 0x86, 0xee, 0x42, 0x59, 0x6a, 0x97, 0x52, 0xd2, 0x14, 0x4d, 0x5a, + 0x66, 0x29, 0x14, 0xc4, 0x92, 0xfe, 0xb7, 0x67, 0x61, 0xfc, 0x14, 0xcb, 0x14, 0x55, 0x9d, 0x25, + 0x3a, 0x25, 0xcb, 0x18, 0xab, 0x84, 0x8f, 0xf7, 0xbc, 0x0f, 0x61, 0x8a, 0x6a, 0x36, 0xee, 0xb3, + 0xb5, 0xbc, 0x39, 0x7e, 0x94, 0x00, 0x14, 0x94, 0xff, 0xc5, 0xb5, 0x48, 0x22, 0xbe, 0x16, 0x79, + 0x05, 0x10, 0x8b, 0x42, 0xb4, 0xe5, 0x16, 0xb6, 0x64, 0x1b, 0xab, 0x26, 0xbf, 0xc2, 0x48, 0x90, + 0x44, 0x9e, 0xb2, 0x8d, 0xad, 0x2a, 0xa5, 0xa3, 0xbb, 0x00, 0xfe, 0x55, 0x72, 0x7c, 0x3a, 0xe9, + 0x7b, 0x93, 0x9c, 0x94, 0xb1, 0xdc, 0xbf, 0xc5, 0x8f, 0x66, 0x21, 0xc7, 0x35, 0xb9, 0x63, 0xe8, + 0xa6, 0x81, 0x6e, 0x41, 0xb2, 0xce, 0x37, 0x03, 0xb2, 0x91, 0xcb, 0x71, 0xfe, 0xad, 0x6d, 0x95, + 0x11, 0x89, 0xe4, 0x25, 0x2c, 0xad, 0xb6, 0x13, 0xe1, 0x3c, 0xf9, 0xb1, 0xd6, 0x41, 0x96, 0x56, + 0xdb, 0x41, 0x55, 0x98, 0x54, 0xfd, 0x3b, 0xa8, 0x64, 0xc2, 0x9e, 0xec, 0x09, 0x93, 0x22, 0xef, + 0xfe, 0xaa, 0x8c, 0x48, 0x79, 0x35, 0x94, 0x80, 0x4a, 0xc1, 0x4b, 0x8f, 0x52, 0x5d, 0x61, 0x5d, + 0xfe, 0x21, 0xde, 0xf0, 0x85, 0x4b, 0x95, 0x91, 0xc0, 0xdd, 0x48, 0xe8, 0x6d, 0x18, 0xd3, 0xe8, + 0x65, 0x3a, 0xbc, 0x5f, 0x47, 0x75, 0xbd, 0xd0, 0xfd, 0x45, 0x95, 0x11, 0x89, 0x73, 0xa0, 0x75, + 0xc8, 0xb1, 0x7f, 0xcc, 0x89, 0xe1, 0xd8, 0xf1, 0x6a, 0x6f, 0x09, 0x81, 0xa9, 0xa1, 0x32, 0x22, + 0x65, 0x35, 0x9f, 0x8a, 0x5e, 0x87, 0x94, 0xad, 0x2a, 0x2e, 0x7a, 0x9c, 0xeb, 0x71, 0x93, 0x86, + 0xcf, 0x4c, 0x73, 0xa3, 0xbb, 0xec, 0x36, 0x46, 0xe7, 0xd8, 0x5d, 0xce, 0x8b, 0x2a, 0x7e, 0xe8, + 0x7c, 0x36, 0x29, 0x3e, 0xa6, 0x04, 0x74, 0x1f, 0xb2, 0x0a, 0xf1, 0x06, 0x65, 0x7a, 0x1e, 0x92, + 0xae, 0xdf, 0x45, 0xef, 0x94, 0x77, 0x9d, 0x65, 0xad, 0xd0, 0x43, 0xe0, 0x2e, 0xd1, 0x17, 0xd4, + 0xc4, 0x56, 0x1d, 0x17, 0xb2, 0xfd, 0x05, 0x05, 0xc3, 0xb8, 0x3c, 0x41, 0x94, 0x48, 0xbc, 0xc2, + 0x7d, 0xf7, 0xac, 0x0b, 0xad, 0x54, 0xae, 0xe7, 0xae, 0x6c, 0xc4, 0x59, 0x9d, 0xca, 0x88, 0x94, + 0xdb, 0x0f, 0x90, 0xd1, 0x22, 0x24, 0xea, 0x6a, 0x61, 0xa2, 0xe7, 0x08, 0xf1, 0x4e, 0xa2, 0x54, + 0x46, 0xa4, 0x44, 0x5d, 0x45, 0xef, 0x42, 0x9a, 0x1d, 0x25, 0x38, 0x36, 0x0a, 0xf9, 0x9e, 0x76, + 0x22, 0x7c, 0x20, 0xa3, 0x32, 0x22, 0xd1, 0xd3, 0x0b, 0xe4, 0x7d, 0xdb, 0x90, 0xb7, 0x58, 0x1c, + 0x9c, 0x1b, 0xc1, 0x2a, 0xf6, 0xdc, 0xa9, 0x8e, 0x0a, 0x62, 0xad, 0x50, 0x74, 0x10, 0xa0, 0xa3, + 0xef, 0xc0, 0x4c, 0x58, 0x22, 0xef, 0x69, 0x53, 0x3d, 0x77, 0x5d, 0x7b, 0x86, 0x52, 0x56, 0x46, + 0x24, 0x64, 0x75, 0x25, 0xa2, 0x37, 0x61, 0x94, 0xb5, 0x1a, 0xa2, 0x22, 0xa3, 0x42, 0x30, 0x3a, + 0x1a, 0x8c, 0xe5, 0x27, 0x9d, 0xdf, 0xe1, 0x01, 0x60, 0x72, 0xc3, 0xac, 0x17, 0xa6, 0x7b, 0x76, + 0xfe, 0xee, 0x80, 0x36, 0xd2, 0xf9, 0x1d, 0x9f, 0x4a, 0xda, 0xdd, 0x62, 0x29, 0x3c, 0x5e, 0x68, + 0xa6, 0x67, 0xbb, 0x47, 0xc4, 0x85, 0x55, 0x68, 0x48, 0xbe, 0x4f, 0x26, 0x45, 0xb3, 0xd8, 0xb5, + 0x2f, 0x32, 0x1d, 0x53, 0xe7, 0x7a, 0x16, 0xad, 0xfb, 0x76, 0x9c, 0x0a, 0xf5, 0x9a, 0x3c, 0x2a, + 0x7a, 0x0c, 0x22, 0xbf, 0x90, 0xc1, 0xdf, 0x3b, 0x38, 0x4f, 0xe5, 0xbd, 0x1c, 0x69, 0xba, 0xa2, + 0x02, 0x6c, 0x2a, 0x23, 0xd2, 0xa4, 0x1a, 0x4e, 0x41, 0xef, 0xc3, 0x14, 0x95, 0x27, 0xab, 0xfe, + 0x4d, 0x1a, 0x85, 0x42, 0xd7, 0x8d, 0x0c, 0xbd, 0x2f, 0xdd, 0x70, 0x25, 0x8b, 0x6a, 0x47, 0x12, + 0xe9, 0xc6, 0xba, 0xa1, 0x3b, 0xd4, 0xca, 0xce, 0xf6, 0xec, 0xc6, 0xe1, 0x3b, 0xfb, 0x48, 0x37, + 0xd6, 0x19, 0x85, 0x74, 0x63, 0x87, 0x07, 0x93, 0xf1, 0xe6, 0x78, 0xa1, 0x67, 0x37, 0x8e, 0x8a, + 0x3a, 0x23, 0xdd, 0xd8, 0x09, 0xd2, 0x49, 0x37, 0x66, 0x06, 0xa2, 0x43, 0xee, 0x8b, 0x3d, 0xbb, + 0x71, 0xcf, 0x13, 0xc9, 0xa4, 0x1b, 0x2b, 0x5d, 0x89, 0x68, 0x15, 0x80, 0x39, 0x35, 0x74, 0x52, + 0x9c, 0xeb, 0x39, 0x19, 0x74, 0x86, 0x93, 0x91, 0xc9, 0xa0, 0xe1, 0xd2, 0x88, 0x21, 0xa3, 0x50, + 0x4a, 0xa6, 0x1b, 0xa9, 0x85, 0xf9, 0x9e, 0x86, 0xac, 0x6b, 0x8b, 0x93, 0x18, 0xb2, 0x23, 0x8f, + 0x48, 0x66, 0x15, 0xb6, 0xaa, 0x5b, 0x58, 0xe8, 0x6d, 0x96, 0x83, 0x5b, 0x3c, 0xd4, 0x2c, 0x53, + 0x02, 0x5a, 0x86, 0x0c, 0x99, 0xf3, 0x4f, 0xa8, 0x19, 0xba, 0xdc, 0xd3, 0x3f, 0xed, 0x38, 0x73, + 0x52, 0x19, 0x91, 0xd2, 0x4f, 0x38, 0x89, 0xbc, 0x9e, 0xad, 0x6e, 0x15, 0x8a, 0x3d, 0x5f, 0x1f, + 0x5a, 0x1b, 0x25, 0xaf, 0x67, 0x1c, 0x48, 0x85, 0x73, 0xac, 0xad, 0xf8, 0x81, 0x60, 0x8b, 0x9f, + 0x5e, 0x2d, 0xbc, 0x44, 0x45, 0xf5, 0x5c, 0x2b, 0x8a, 0x3c, 0xa7, 0x5c, 0x19, 0x91, 0xa6, 0x95, + 0xee, 0x54, 0x32, 0xe0, 0xf9, 0xd4, 0xc3, 0x56, 0x98, 0x0a, 0x57, 0x7a, 0x0e, 0xf8, 0x88, 0x35, + 0x39, 0x32, 0xe0, 0x95, 0x00, 0x99, 0x4d, 0x40, 0x9a, 0x6c, 0xdb, 0x6c, 0xdb, 0xfd, 0x6a, 0x9f, + 0x09, 0xa8, 0x63, 0x8d, 0x80, 0x4d, 0x40, 0x5a, 0x95, 0x71, 0x12, 0x41, 0x6a, 0x03, 0x2b, 0x16, + 0x37, 0xb3, 0xd7, 0x7a, 0x0a, 0xea, 0xba, 0x07, 0x8f, 0x08, 0x52, 0x3d, 0x22, 0x71, 0x78, 0x2c, + 0xf7, 0x26, 0x17, 0xee, 0x30, 0x5e, 0xef, 0xe9, 0xf0, 0x44, 0x5e, 0x38, 0x43, 0x1c, 0x1e, 0x2b, + 0x94, 0x80, 0xbe, 0x06, 0xe3, 0x1c, 0xd0, 0x15, 0x6e, 0xf4, 0x71, 0x63, 0x83, 0x48, 0x9c, 0x8c, + 0x6b, 0xce, 0xc3, 0xac, 0x2c, 0x03, 0x92, 0xac, 0x7a, 0x2f, 0xf7, 0xb1, 0xb2, 0x5d, 0x58, 0x96, + 0x59, 0x59, 0x9f, 0x4c, 0xac, 0x2c, 0xeb, 0xa7, 0x7c, 0xae, 0xbb, 0xd9, 0xd3, 0xca, 0x76, 0x9f, + 0x7b, 0x21, 0x56, 0xf6, 0x89, 0x4f, 0x25, 0x35, 0xb3, 0x19, 0x88, 0x2a, 0x7c, 0xa5, 0x67, 0xcd, + 0xc2, 0x98, 0x92, 0xd4, 0x8c, 0xf3, 0x90, 0x66, 0x63, 0x2e, 0x31, 0xd3, 0xf4, 0x2b, 0xbd, 0xcf, + 0xde, 0x77, 0x42, 0x0f, 0xd2, 0x6c, 0x96, 0x47, 0xf4, 0x0d, 0x95, 0xc5, 0x4f, 0x1a, 0x73, 0x4d, + 0xbd, 0xda, 0xdf, 0x50, 0x45, 0x1d, 0xa2, 0xf6, 0x0c, 0x55, 0x28, 0x91, 0x16, 0x95, 0x1d, 0x1f, + 0xa3, 0xe3, 0x7b, 0xb1, 0xcf, 0x35, 0x01, 0x1d, 0x47, 0xf9, 0x68, 0x51, 0x3d, 0xa2, 0x3f, 0x84, + 0xda, 0xec, 0x3e, 0x8b, 0xc2, 0x52, 0xff, 0x21, 0x14, 0xbe, 0x57, 0xc3, 0x1b, 0x42, 0x9c, 0xec, + 0xcd, 0x99, 0xae, 0x87, 0xf1, 0x5a, 0xff, 0x39, 0xb3, 0xd3, 0xb5, 0x60, 0x73, 0x26, 0xf7, 0x29, + 0xfe, 0x96, 0x00, 0x0b, 0xac, 0x6c, 0x74, 0xbd, 0xef, 0x44, 0xf6, 0xd6, 0x4e, 0x03, 0x87, 0x1c, + 0x6e, 0xd1, 0x17, 0xbc, 0xd9, 0xab, 0xb8, 0x03, 0xd6, 0x82, 0x2b, 0x23, 0xd2, 0x8b, 0x4a, 0xbf, + 0x7c, 0x2b, 0xe3, 0x7c, 0xe3, 0xd3, 0x3b, 0xc1, 0x39, 0x29, 0x8a, 0xeb, 0xa9, 0xf4, 0x05, 0xb1, + 0xb0, 0x9e, 0x4a, 0x5f, 0x14, 0x67, 0xd7, 0x53, 0xe9, 0x4b, 0xe2, 0x0b, 0xc5, 0xff, 0x7b, 0x11, + 0x26, 0x5c, 0xe4, 0xc7, 0x10, 0xd1, 0xed, 0x20, 0x22, 0x9a, 0xeb, 0x85, 0x88, 0x38, 0x56, 0xe4, + 0x90, 0xe8, 0x76, 0x10, 0x12, 0xcd, 0xf5, 0x82, 0x44, 0x3e, 0x0f, 0xc1, 0x44, 0xb5, 0x5e, 0x98, + 0xe8, 0xe5, 0x21, 0x30, 0x91, 0x27, 0xaa, 0x13, 0x14, 0xad, 0x76, 0x83, 0xa2, 0x2b, 0xfd, 0x41, + 0x91, 0x27, 0x2a, 0x80, 0x8a, 0xee, 0x76, 0xa0, 0xa2, 0xcb, 0x7d, 0x50, 0x91, 0xc7, 0xef, 0xc2, + 0xa2, 0x8d, 0x48, 0x58, 0x74, 0x6d, 0x10, 0x2c, 0xf2, 0xe4, 0x84, 0x70, 0xd1, 0x1b, 0x21, 0x5c, + 0x34, 0xdf, 0x13, 0x17, 0x79, 0xdc, 0x0c, 0x18, 0xbd, 0xd3, 0x09, 0x8c, 0x2e, 0xf7, 0x01, 0x46, + 0x7e, 0x0d, 0x38, 0x32, 0xaa, 0x44, 0x21, 0xa3, 0xab, 0x03, 0x90, 0x91, 0x27, 0x25, 0x08, 0x8d, + 0x2a, 0x51, 0xd0, 0xe8, 0xea, 0x00, 0x68, 0xd4, 0x21, 0x89, 0x61, 0xa3, 0xad, 0x68, 0x6c, 0x74, + 0x7d, 0x20, 0x36, 0xf2, 0xa4, 0x85, 0xc1, 0xd1, 0x52, 0x00, 0x1c, 0xbd, 0xd8, 0x03, 0x1c, 0x79, + 0xac, 0x04, 0x1d, 0x7d, 0xbd, 0x0b, 0x1d, 0x15, 0xfb, 0xa1, 0x23, 0x8f, 0xd7, 0x83, 0x47, 0x8f, + 0x7a, 0xc0, 0xa3, 0x1b, 0x83, 0xe1, 0x91, 0x27, 0xac, 0x03, 0x1f, 0x29, 0x7d, 0xf1, 0xd1, 0xab, + 0x43, 0xe2, 0x23, 0x4f, 0x7a, 0x14, 0x40, 0x7a, 0x2b, 0x0c, 0x90, 0x16, 0x7a, 0x03, 0x24, 0x4f, + 0x0c, 0x47, 0x48, 0x1b, 0x91, 0x08, 0xe9, 0xda, 0x20, 0x84, 0xe4, 0x8f, 0x83, 0x20, 0x44, 0xda, + 0x8a, 0x86, 0x48, 0xd7, 0x07, 0x42, 0x24, 0xbf, 0xf9, 0x43, 0x18, 0x69, 0x23, 0x12, 0x23, 0x5d, + 0x1b, 0x84, 0x91, 0xfc, 0xc2, 0x05, 0x41, 0xd2, 0x7b, 0x3d, 0x41, 0xd2, 0xcd, 0x61, 0x40, 0x92, + 0x27, 0xb4, 0x0b, 0x25, 0x7d, 0xd0, 0x1b, 0x25, 0x7d, 0xe5, 0x0c, 0x57, 0x13, 0x46, 0xc2, 0xa4, + 0xaf, 0x77, 0xc1, 0xa4, 0x62, 0x3f, 0x98, 0xe4, 0xf7, 0x67, 0x17, 0x27, 0x29, 0x7d, 0x51, 0xcd, + 0xab, 0x43, 0xa2, 0x1a, 0xbf, 0xf3, 0x45, 0xc0, 0x9a, 0x72, 0x04, 0xac, 0xb9, 0xd2, 0x1f, 0xd6, + 0xf8, 0xe6, 0xdc, 0xc7, 0x35, 0x95, 0x28, 0x5c, 0x73, 0x75, 0x00, 0xae, 0xf1, 0xad, 0x50, 0x00, + 0xd8, 0xdc, 0xed, 0x00, 0x36, 0x97, 0x07, 0xc6, 0xf5, 0x04, 0x90, 0xcd, 0x4a, 0x37, 0xb2, 0x79, + 0xa9, 0x2f, 0xb2, 0xf1, 0x24, 0xf8, 0xd0, 0xe6, 0x6e, 0x07, 0xb4, 0xb9, 0xdc, 0x07, 0xda, 0xf8, + 0x05, 0xe0, 0xd8, 0x46, 0xeb, 0x8f, 0x6d, 0x16, 0x87, 0xc5, 0x36, 0x9e, 0xe0, 0x48, 0x70, 0xb3, + 0x15, 0x0d, 0x6e, 0xae, 0x0f, 0xb9, 0xcb, 0xde, 0x85, 0x6e, 0x2a, 0x51, 0xe8, 0xe6, 0xea, 0x00, + 0x74, 0x13, 0x9c, 0x43, 0x3c, 0x78, 0x53, 0x89, 0x82, 0x37, 0x57, 0x07, 0xc0, 0x1b, 0x5f, 0x52, + 0x00, 0xdf, 0xd4, 0x7a, 0xe1, 0x9b, 0x97, 0x87, 0xc0, 0x37, 0xbe, 0xf3, 0xd2, 0x01, 0x70, 0xde, + 0xed, 0x04, 0x38, 0xc5, 0x7e, 0x00, 0xc7, 0x1f, 0x91, 0x2e, 0xc2, 0xd9, 0x8a, 0x46, 0x38, 0xd7, + 0x07, 0x22, 0x9c, 0xa0, 0x91, 0x0c, 0x40, 0x9c, 0x8d, 0x48, 0x88, 0x73, 0x6d, 0x10, 0xc4, 0xf1, + 0x8d, 0x64, 0x10, 0xe3, 0xbc, 0xdb, 0x89, 0x71, 0x8a, 0xfd, 0x30, 0x8e, 0x5f, 0x39, 0x17, 0xe4, + 0x54, 0xa2, 0x40, 0xce, 0xd5, 0x01, 0x20, 0xc7, 0x6f, 0xbc, 0x00, 0xca, 0x51, 0xfa, 0xa2, 0x9c, + 0x57, 0x87, 0x44, 0x39, 0x1d, 0x86, 0x2b, 0x0c, 0x73, 0x2a, 0x51, 0x30, 0xe7, 0xea, 0x00, 0x98, + 0x13, 0x28, 0xac, 0x8f, 0x73, 0xb6, 0xa2, 0x71, 0xce, 0xf5, 0x81, 0x38, 0xa7, 0x63, 0x34, 0xb9, + 0x40, 0x67, 0x23, 0x12, 0xe8, 0x5c, 0x1b, 0x04, 0x74, 0x3a, 0x26, 0x3e, 0xee, 0x1c, 0xfc, 0xed, + 0xe1, 0x91, 0xce, 0x5b, 0x67, 0x47, 0x3a, 0xde, 0x3b, 0x63, 0x81, 0x3a, 0xeb, 0xa9, 0xf4, 0x0b, + 0xe2, 0x8b, 0xc5, 0xdf, 0x8f, 0xc2, 0x58, 0xc5, 0x8b, 0x85, 0xf1, 0x4b, 0x29, 0x3c, 0xcf, 0x35, + 0x48, 0x68, 0x95, 0x8c, 0x58, 0x6a, 0xf7, 0x06, 0xdf, 0x78, 0xd7, 0x7d, 0x1b, 0x1b, 0x67, 0x7d, + 0x8e, 0x53, 0xc8, 0xe8, 0x0d, 0x98, 0x68, 0xdb, 0xd8, 0x92, 0x5b, 0x96, 0x6e, 0x5a, 0xba, 0xc3, + 0x4e, 0x74, 0x08, 0x2b, 0xe2, 0x67, 0xa7, 0xf3, 0xb9, 0x1d, 0x1b, 0x5b, 0xdb, 0x9c, 0x2e, 0xe5, + 0xda, 0x81, 0x27, 0xf7, 0xcb, 0x50, 0xa3, 0xc3, 0x7f, 0x19, 0xea, 0x11, 0x88, 0x16, 0x56, 0xb4, + 0x90, 0x07, 0xc2, 0xae, 0x19, 0x8a, 0xee, 0x33, 0xf4, 0xb0, 0x94, 0x9b, 0x93, 0x5e, 0x37, 0x34, + 0x69, 0x85, 0x89, 0xe8, 0x16, 0x9c, 0x6b, 0x2a, 0xc7, 0x34, 0xea, 0x51, 0x76, 0x9d, 0x3a, 0x1a, + 0xc9, 0xc8, 0x3e, 0xba, 0x84, 0x9a, 0xca, 0x31, 0xfd, 0xcc, 0x14, 0x4b, 0xa2, 0xdf, 0x85, 0xb8, + 0x0a, 0x79, 0x4d, 0xb7, 0x1d, 0xdd, 0x50, 0x1d, 0x7e, 0xc1, 0x2c, 0xbb, 0xb1, 0x75, 0xc2, 0xa5, + 0xb2, 0x5b, 0x64, 0x6f, 0xc2, 0x14, 0x0f, 0x8a, 0x0f, 0x6c, 0x11, 0x02, 0x8f, 0x34, 0xa3, 0x09, + 0xde, 0xae, 0x20, 0x2a, 0xc1, 0x64, 0x5d, 0x71, 0xf0, 0x91, 0x72, 0x22, 0xbb, 0x27, 0xaa, 0xb2, + 0xf4, 0x7e, 0xc6, 0x4b, 0xcf, 0x4e, 0xe7, 0x27, 0xee, 0xb3, 0xa4, 0xae, 0x83, 0x55, 0x13, 0xf5, + 0x40, 0x82, 0x86, 0xae, 0xc3, 0xa4, 0x62, 0x9f, 0x18, 0x2a, 0x55, 0x0f, 0x36, 0xec, 0xb6, 0x4d, + 0x21, 0x45, 0x5a, 0xca, 0x53, 0x72, 0xc9, 0xa5, 0xa2, 0xcb, 0x90, 0xe3, 0x11, 0xe3, 0xec, 0x5b, + 0x35, 0x93, 0xb4, 0xaa, 0xfc, 0xd3, 0x09, 0xf4, 0x73, 0x35, 0xe8, 0x2e, 0xcc, 0xf2, 0x2b, 0xe5, + 0x8f, 0x14, 0x4b, 0x93, 0xa9, 0xd6, 0xfd, 0xfe, 0x29, 0x52, 0xb1, 0x17, 0xd8, 0x15, 0xf2, 0x24, + 0x03, 0x51, 0x75, 0xf0, 0xfe, 0xd5, 0x71, 0x31, 0xbd, 0x9e, 0x4a, 0xe7, 0xc4, 0x89, 0xf5, 0x54, + 0x3a, 0x2f, 0x4e, 0x16, 0xff, 0xa1, 0x00, 0xb9, 0xd0, 0x29, 0x94, 0xbb, 0x1d, 0x9b, 0xc0, 0x17, + 0xa3, 0xa1, 0x53, 0xaf, 0xb8, 0xb1, 0x34, 0x6f, 0x2a, 0x37, 0x6a, 0x6e, 0xbe, 0xb7, 0xeb, 0x4d, + 0x17, 0x12, 0xdc, 0xc8, 0x03, 0x97, 0xed, 0xed, 0xd4, 0x3f, 0xfe, 0x78, 0x7e, 0xa4, 0xf8, 0x49, + 0x0a, 0x26, 0xc2, 0xa7, 0x4d, 0xd6, 0x3a, 0xca, 0x15, 0x65, 0xda, 0x42, 0x1c, 0x8b, 0x7d, 0x2e, + 0xdd, 0xcb, 0xf8, 0x77, 0xc2, 0xb3, 0x62, 0x2e, 0xf4, 0xd9, 0xea, 0x0e, 0x96, 0xd3, 0x67, 0x9c, + 0xfd, 0x3b, 0x49, 0xcf, 0x44, 0x2c, 0xc2, 0x28, 0xbd, 0x06, 0x86, 0x17, 0x2d, 0xea, 0x20, 0x73, + 0x99, 0xa4, 0x4b, 0x2c, 0x1b, 0x31, 0x29, 0xb5, 0xe7, 0xba, 0x59, 0xcd, 0xbf, 0xc4, 0xe2, 0xec, + 0x1f, 0x6f, 0xe3, 0xf7, 0xeb, 0x8d, 0x9e, 0xed, 0x7e, 0x3d, 0xb6, 0x29, 0xdd, 0x68, 0x30, 0x73, + 0xcd, 0x06, 0xd5, 0x58, 0xd7, 0x69, 0x61, 0x2a, 0x82, 0x7f, 0x53, 0x6f, 0x51, 0xe2, 0xdf, 0xd4, + 0x0b, 0x04, 0x32, 0xe6, 0x3d, 0x11, 0x6c, 0x04, 0x96, 0xdc, 0x59, 0x9a, 0x7d, 0xe8, 0x6d, 0x7c, + 0xe8, 0x0f, 0xbd, 0x81, 0xb7, 0x49, 0x6f, 0xb3, 0x98, 0x59, 0xde, 0x5f, 0xfe, 0xab, 0xc0, 0x23, + 0x1a, 0x1e, 0x98, 0xe6, 0x41, 0xdb, 0x8b, 0x85, 0x9c, 0x0d, 0xde, 0x6e, 0x97, 0xfe, 0xec, 0x74, + 0x3e, 0x25, 0x79, 0xd7, 0xdb, 0x45, 0x99, 0xac, 0xc4, 0xe7, 0x33, 0x59, 0x97, 0x21, 0xd7, 0xb2, + 0xf0, 0x1e, 0x76, 0xd4, 0x7d, 0xd9, 0x68, 0x37, 0xf9, 0x81, 0x87, 0xac, 0x4b, 0xdb, 0x6a, 0x37, + 0xd1, 0xcb, 0x20, 0x7a, 0x59, 0x38, 0x38, 0xe4, 0xe7, 0xbd, 0x27, 0x5d, 0x3a, 0x87, 0x92, 0xc5, + 0xff, 0x2f, 0xc0, 0x74, 0xa8, 0x4e, 0x7c, 0x24, 0xac, 0x43, 0x56, 0xf3, 0x26, 0x09, 0xbb, 0x20, + 0x9c, 0x31, 0x26, 0x30, 0xc8, 0x8c, 0x64, 0x38, 0xef, 0xbe, 0x96, 0xde, 0x78, 0xee, 0x8b, 0x4d, + 0x9c, 0x51, 0xec, 0x39, 0x5f, 0xce, 0x6a, 0xe0, 0x05, 0xde, 0xd0, 0x48, 0x0e, 0x35, 0x34, 0x8a, + 0x3f, 0x16, 0x40, 0xa4, 0x2f, 0xb8, 0x87, 0xb1, 0x16, 0x8b, 0x4d, 0x72, 0x23, 0x6e, 0x13, 0xc3, + 0x1f, 0x69, 0x08, 0x7d, 0xb1, 0x21, 0x19, 0xfe, 0x62, 0x43, 0xf1, 0x63, 0x01, 0xf2, 0x5e, 0x09, + 0xd9, 0xb7, 0xca, 0xfa, 0x5c, 0xa2, 0xf8, 0x7c, 0x5f, 0xe8, 0x72, 0xef, 0x85, 0x18, 0xea, 0xf3, + 0x69, 0xc1, 0x7b, 0x21, 0xd8, 0xd7, 0xa4, 0xfe, 0xa9, 0xdb, 0x73, 0x48, 0x11, 0x4b, 0xfe, 0x99, + 0xff, 0xe7, 0x38, 0xdd, 0x21, 0xd1, 0x4f, 0x3e, 0x9a, 0x8d, 0x43, 0x76, 0x21, 0xc7, 0x50, 0xc6, + 0x0a, 0xf1, 0x38, 0x1e, 0xe0, 0xcb, 0x48, 0x5a, 0xad, 0x4a, 0x3f, 0x06, 0xc9, 0xfe, 0xdb, 0xc5, + 0x7b, 0x01, 0x05, 0xd2, 0xc6, 0x27, 0x5a, 0x1a, 0xca, 0x80, 0xba, 0x5a, 0x62, 0x7d, 0xe5, 0x97, + 0xc1, 0x96, 0x28, 0x1f, 0x12, 0xf8, 0x70, 0x07, 0x92, 0x87, 0x4a, 0xa3, 0x5f, 0xfc, 0x52, 0xa8, + 0xe5, 0x24, 0x92, 0x1b, 0xdd, 0x0b, 0x5d, 0x95, 0x90, 0xe8, 0xed, 0xea, 0x76, 0xab, 0x34, 0x74, + 0xa5, 0xc2, 0x9b, 0xe1, 0xbe, 0xde, 0xf7, 0xf5, 0xc1, 0x4e, 0xff, 0x76, 0xea, 0xd3, 0x8f, 0xe7, + 0x85, 0xe2, 0x9b, 0x70, 0xf1, 0xbe, 0x69, 0xdb, 0x7a, 0x8b, 0xc0, 0x1b, 0x3a, 0x80, 0x88, 0xed, + 0xf6, 0x2c, 0x59, 0xba, 0x45, 0x81, 0xae, 0xc1, 0x46, 0x7c, 0x46, 0xf2, 0x9e, 0x8b, 0xff, 0x4e, + 0x80, 0x0b, 0xdd, 0x9c, 0x4c, 0x21, 0x51, 0xa7, 0xc7, 0xc6, 0x55, 0xd3, 0xbf, 0x3a, 0x6c, 0x70, + 0xc7, 0x72, 0xb3, 0x13, 0x37, 0x86, 0xbf, 0x53, 0x6e, 0x2a, 0x74, 0xa4, 0xf3, 0x13, 0xae, 0x79, + 0x4e, 0xde, 0x64, 0x54, 0x7f, 0xd0, 0xa7, 0x86, 0x1a, 0xf4, 0x37, 0xab, 0x30, 0x1d, 0x61, 0x5f, + 0x51, 0x1e, 0x20, 0xf0, 0x05, 0x0b, 0xfe, 0xe5, 0xcc, 0xe5, 0x55, 0x79, 0x67, 0xab, 0xf4, 0x70, + 0x73, 0x73, 0xad, 0x56, 0x2b, 0xaf, 0x8a, 0x02, 0x12, 0x21, 0x17, 0xfa, 0xfe, 0x45, 0x82, 0x7d, + 0x4b, 0xf3, 0xe6, 0x5f, 0x03, 0xf0, 0x3f, 0xab, 0x43, 0x64, 0x6d, 0x94, 0xdf, 0x97, 0x1f, 0x2f, + 0x3f, 0xd8, 0x29, 0x57, 0xc5, 0x11, 0x84, 0x20, 0xbf, 0xb2, 0x5c, 0x2b, 0x55, 0x64, 0xa9, 0x5c, + 0xdd, 0x7e, 0xb8, 0x55, 0x2d, 0xbb, 0xdf, 0xe0, 0xbc, 0xb9, 0x0a, 0xb9, 0xe0, 0x75, 0x1a, 0x68, + 0x1a, 0x26, 0x4b, 0x95, 0x72, 0x69, 0x43, 0x7e, 0xbc, 0xb6, 0x2c, 0x3f, 0xda, 0x29, 0xef, 0x94, + 0xc5, 0x11, 0x5a, 0x34, 0x4a, 0xbc, 0xb7, 0xf3, 0xe0, 0x81, 0x28, 0xa0, 0x49, 0xc8, 0xb2, 0x67, + 0xfa, 0xad, 0x0c, 0x31, 0x71, 0x73, 0x13, 0xb2, 0x81, 0xcb, 0x34, 0xc9, 0xeb, 0xb6, 0x77, 0xaa, + 0x15, 0xb9, 0xb6, 0xb6, 0x59, 0xae, 0xd6, 0x96, 0x37, 0xb7, 0x99, 0x0c, 0x4a, 0x5b, 0x5e, 0x79, + 0x28, 0xd5, 0x44, 0xc1, 0x7b, 0xae, 0x3d, 0xdc, 0x29, 0x55, 0xdc, 0x6a, 0x14, 0x53, 0xe9, 0xa4, + 0x98, 0xbc, 0xf9, 0x3d, 0x01, 0x2e, 0xf4, 0xb8, 0x54, 0x02, 0x65, 0x61, 0x7c, 0xc7, 0xa0, 0xb7, + 0x09, 0x8a, 0x23, 0x68, 0x22, 0x70, 0xaf, 0x84, 0x28, 0xa0, 0x34, 0x3b, 0xd3, 0x2f, 0x26, 0xd0, + 0x18, 0x24, 0xaa, 0x77, 0xc4, 0x24, 0x29, 0x69, 0xe0, 0x5a, 0x06, 0x31, 0x85, 0x32, 0xfc, 0x54, + 0xb9, 0x38, 0x8a, 0x72, 0xfe, 0xb1, 0x6e, 0x71, 0x8c, 0x88, 0xf2, 0x0e, 0x46, 0x8b, 0xe3, 0x37, + 0x2f, 0x43, 0xe0, 0x90, 0x29, 0x02, 0x18, 0x7b, 0xa0, 0x38, 0xd8, 0x76, 0xc4, 0x11, 0x34, 0x0e, + 0xc9, 0xe5, 0x46, 0x43, 0x14, 0x6e, 0xff, 0xdd, 0x24, 0xa4, 0xdd, 0xaf, 0x41, 0xa0, 0x07, 0x30, + 0xca, 0x56, 0xc3, 0xe6, 0x7b, 0x7b, 0x6a, 0xb4, 0x6f, 0xcf, 0x2e, 0x0c, 0x72, 0xe5, 0x8a, 0x23, + 0xe8, 0xaf, 0x43, 0x36, 0x30, 0x17, 0xa2, 0x9e, 0x88, 0x3e, 0x34, 0xff, 0xcf, 0x5e, 0x1b, 0x94, + 0xcd, 0x93, 0xff, 0x1e, 0x64, 0xbc, 0xb1, 0x89, 0x5e, 0xea, 0x37, 0x72, 0x5d, 0xd9, 0xfd, 0x87, + 0x37, 0x19, 0x7c, 0xc5, 0x91, 0xd7, 0x04, 0x64, 0x01, 0xea, 0x1e, 0x9b, 0x28, 0x6a, 0x93, 0xb4, + 0xe7, 0xe0, 0x9f, 0xbd, 0x39, 0x54, 0x6e, 0xef, 0x9d, 0x2b, 0x2f, 0x7f, 0xfa, 0xdb, 0xb9, 0x91, + 0x4f, 0x9f, 0xcd, 0x09, 0xbf, 0x7a, 0x36, 0x27, 0xfc, 0xe6, 0xd9, 0x9c, 0xf0, 0xbf, 0x9f, 0xcd, + 0x09, 0xff, 0xe0, 0x77, 0x73, 0x23, 0xbf, 0xfa, 0xdd, 0xdc, 0xc8, 0x6f, 0x7e, 0x37, 0x37, 0xf2, + 0xc1, 0x38, 0x17, 0xb3, 0x3b, 0x46, 0xbf, 0x6e, 0x7c, 0xe7, 0x2f, 0x02, 0x00, 0x00, 0xff, 0xff, + 0x86, 0x8a, 0x7d, 0x48, 0x00, 0x7a, 0x00, 0x00, } diff --git a/pkg/roachpb/api.proto b/pkg/roachpb/api.proto index 23427baa3517..351fd5ee1ca7 100644 --- a/pkg/roachpb/api.proto +++ b/pkg/roachpb/api.proto @@ -2051,6 +2051,24 @@ message BatchResponse { repeated ResponseUnion responses = 2 [(gogoproto.nullable) = false]; } +// RangeLookupRequest is a request to proxy a RangeLookup through a Tenant +// service. Its fields correspond to a subset of the args of kv.RangeLookup. +message RangeLookupRequest { + bytes key = 1 [(gogoproto.casttype) = "RKey"]; + ReadConsistencyType read_consistency = 2; + int64 prefetch_num = 3; + bool prefetch_reverse = 4; +} + +// RangeLookupResponse is returned from a RangeLookup request proxied through a +// Tenant service. Its fields correspond to the return values of kv.RangeLookup. +message RangeLookupResponse { + repeated RangeDescriptor descriptors = 1 [(gogoproto.nullable) = false]; + repeated RangeDescriptor prefetched_descriptors = 2 [(gogoproto.nullable) = false]; + // If non-nil, the other fields will be empty. + Error error = 3; +} + // RangeFeedRequest is a request that expresses the intention to establish a // RangeFeed stream over the provided span, starting at the specified timestamp. message RangeFeedRequest { @@ -2104,8 +2122,33 @@ message RangeFeedEvent { RangeFeedError error = 3; } +// GossipSubscriptionRequest initiates a game of telephone. It establishes an +// indefinite stream that proxies gossip information overheard by the recipient +// node back to the caller. Gossip information is filtered down to just those +// identified by a key matching any of the specified patterns. +// +// Upon establishment of the stream, all existing information that matches one +// or more of the patterns is returned. After this point, only new information +// matching the patterns is returned. +message GossipSubscriptionRequest { + repeated string patterns = 1; +} + +// GossipSubscriptionEvent is a single piece of proxied gossip information. +message GossipSubscriptionEvent { + string key = 1; + Value content = 2 [(gogoproto.nullable) = false]; + // Which pattern does this gossip information match? + string pattern_matched = 3; + // If non-nil, the other fields will be empty and this will be the final event + // send on the stream before it is terminated. + Error error = 4; +} + // Batch and RangeFeed service implemeted by nodes for KV API requests. service Internal { - rpc Batch (BatchRequest) returns (BatchResponse) {} - rpc RangeFeed (RangeFeedRequest) returns (stream RangeFeedEvent) {} + rpc Batch (BatchRequest) returns (BatchResponse) {} + rpc RangeLookup (RangeLookupRequest) returns (RangeLookupResponse) {} + rpc RangeFeed (RangeFeedRequest) returns (stream RangeFeedEvent) {} + rpc GossipSubscription (GossipSubscriptionRequest) returns (stream GossipSubscriptionEvent) {} } diff --git a/pkg/rpc/context.go b/pkg/rpc/context.go index a922f888b59a..024ef8ccf1c8 100644 --- a/pkg/rpc/context.go +++ b/pkg/rpc/context.go @@ -506,29 +506,59 @@ type internalClientAdapter struct { roachpb.InternalServer } +// Batch implements the roachpb.InternalClient interface. func (a internalClientAdapter) Batch( ctx context.Context, ba *roachpb.BatchRequest, _ ...grpc.CallOption, ) (*roachpb.BatchResponse, error) { return a.InternalServer.Batch(ctx, ba) } -type rangeFeedClientAdapter struct { - ctx context.Context - eventC chan *roachpb.RangeFeedEvent - errC chan error +// RangeLookup implements the roachpb.InternalClient interface. +func (a internalClientAdapter) RangeLookup( + ctx context.Context, rl *roachpb.RangeLookupRequest, _ ...grpc.CallOption, +) (*roachpb.RangeLookupResponse, error) { + return a.InternalServer.RangeLookup(ctx, rl) } -// roachpb.Internal_RangeFeedServer methods. -func (a rangeFeedClientAdapter) Recv() (*roachpb.RangeFeedEvent, error) { - // Prioritize eventC. Both channels are buffered and the only guarantee we +type respStreamClientAdapter struct { + ctx context.Context + respC chan interface{} + errC chan error +} + +func makeRespStreamClientAdapter(ctx context.Context) respStreamClientAdapter { + return respStreamClientAdapter{ + ctx: ctx, + respC: make(chan interface{}, 128), + errC: make(chan error, 1), + } +} + +// grpc.ClientStream methods. +func (respStreamClientAdapter) Header() (metadata.MD, error) { panic("unimplemented") } +func (respStreamClientAdapter) Trailer() metadata.MD { panic("unimplemented") } +func (respStreamClientAdapter) CloseSend() error { panic("unimplemented") } + +// grpc.ServerStream methods. +func (respStreamClientAdapter) SetHeader(metadata.MD) error { panic("unimplemented") } +func (respStreamClientAdapter) SendHeader(metadata.MD) error { panic("unimplemented") } +func (respStreamClientAdapter) SetTrailer(metadata.MD) { panic("unimplemented") } + +// grpc.Stream methods. +func (a respStreamClientAdapter) Context() context.Context { return a.ctx } +func (respStreamClientAdapter) SendMsg(m interface{}) error { panic("unimplemented") } +func (respStreamClientAdapter) RecvMsg(m interface{}) error { panic("unimplemented") } + +func (a respStreamClientAdapter) recvInternal() (interface{}, error) { + // Prioritize respC. Both channels are buffered and the only guarantee we // have is that once an error is sent on errC no other events will be sent - // on eventC again. + // on respC again. select { - case e := <-a.eventC: + case e := <-a.respC: return e, nil case err := <-a.errC: select { - case e := <-a.eventC: + case e := <-a.respC: a.errC <- err return e, nil default: @@ -537,42 +567,43 @@ func (a rangeFeedClientAdapter) Recv() (*roachpb.RangeFeedEvent, error) { } } -// roachpb.Internal_RangeFeedServer methods. -func (a rangeFeedClientAdapter) Send(e *roachpb.RangeFeedEvent) error { +func (a respStreamClientAdapter) sendInternal(e interface{}) error { select { - case a.eventC <- e: + case a.respC <- e: return nil case <-a.ctx.Done(): return a.ctx.Err() } } -// grpc.ClientStream methods. -func (rangeFeedClientAdapter) Header() (metadata.MD, error) { panic("unimplemented") } -func (rangeFeedClientAdapter) Trailer() metadata.MD { panic("unimplemented") } -func (rangeFeedClientAdapter) CloseSend() error { panic("unimplemented") } +type rangeFeedClientAdapter struct { + respStreamClientAdapter +} -// grpc.ServerStream methods. -func (rangeFeedClientAdapter) SetHeader(metadata.MD) error { panic("unimplemented") } -func (rangeFeedClientAdapter) SendHeader(metadata.MD) error { panic("unimplemented") } -func (rangeFeedClientAdapter) SetTrailer(metadata.MD) { panic("unimplemented") } +// roachpb.Internal_RangeFeedServer methods. +func (a rangeFeedClientAdapter) Recv() (*roachpb.RangeFeedEvent, error) { + e, err := a.recvInternal() + if err != nil { + return nil, err + } + return e.(*roachpb.RangeFeedEvent), nil +} -// grpc.Stream methods. -func (a rangeFeedClientAdapter) Context() context.Context { return a.ctx } -func (rangeFeedClientAdapter) SendMsg(m interface{}) error { panic("unimplemented") } -func (rangeFeedClientAdapter) RecvMsg(m interface{}) error { panic("unimplemented") } +// roachpb.Internal_RangeFeedServer methods. +func (a rangeFeedClientAdapter) Send(e *roachpb.RangeFeedEvent) error { + return a.sendInternal(e) +} var _ roachpb.Internal_RangeFeedClient = rangeFeedClientAdapter{} var _ roachpb.Internal_RangeFeedServer = rangeFeedClientAdapter{} +// RangeFeed implements the roachpb.InternalClient interface. func (a internalClientAdapter) RangeFeed( ctx context.Context, args *roachpb.RangeFeedRequest, _ ...grpc.CallOption, ) (roachpb.Internal_RangeFeedClient, error) { ctx, cancel := context.WithCancel(ctx) rfAdapter := rangeFeedClientAdapter{ - ctx: ctx, - eventC: make(chan *roachpb.RangeFeedEvent, 128), - errC: make(chan error, 1), + respStreamClientAdapter: makeRespStreamClientAdapter(ctx), } go func() { @@ -587,6 +618,48 @@ func (a internalClientAdapter) RangeFeed( return rfAdapter, nil } +type gossipSubscriptionClientAdapter struct { + respStreamClientAdapter +} + +// roachpb.Internal_GossipSubscriptionServer methods. +func (a gossipSubscriptionClientAdapter) Recv() (*roachpb.GossipSubscriptionEvent, error) { + e, err := a.recvInternal() + if err != nil { + return nil, err + } + return e.(*roachpb.GossipSubscriptionEvent), nil +} + +// roachpb.Internal_GossipSubscriptionServer methods. +func (a gossipSubscriptionClientAdapter) Send(e *roachpb.GossipSubscriptionEvent) error { + return a.sendInternal(e) +} + +var _ roachpb.Internal_GossipSubscriptionClient = gossipSubscriptionClientAdapter{} +var _ roachpb.Internal_GossipSubscriptionServer = gossipSubscriptionClientAdapter{} + +// GossipSubscription implements the roachpb.InternalClient interface. +func (a internalClientAdapter) GossipSubscription( + ctx context.Context, args *roachpb.GossipSubscriptionRequest, _ ...grpc.CallOption, +) (roachpb.Internal_GossipSubscriptionClient, error) { + ctx, cancel := context.WithCancel(ctx) + gsAdapter := gossipSubscriptionClientAdapter{ + respStreamClientAdapter: makeRespStreamClientAdapter(ctx), + } + + go func() { + defer cancel() + err := a.InternalServer.GossipSubscription(args, gsAdapter) + if err == nil { + err = io.EOF + } + gsAdapter.errC <- err + }() + + return gsAdapter, nil +} + var _ roachpb.InternalClient = internalClientAdapter{} // IsLocal returns true if the given InternalClient is local. diff --git a/pkg/rpc/context_test.go b/pkg/rpc/context_test.go index 6fd9f2c00e73..7d79922e3aeb 100644 --- a/pkg/rpc/context_test.go +++ b/pkg/rpc/context_test.go @@ -168,8 +168,20 @@ func (*internalServer) Batch( return nil, nil } +func (*internalServer) RangeLookup( + context.Context, *roachpb.RangeLookupRequest, +) (*roachpb.RangeLookupResponse, error) { + panic("unimplemented") +} + func (*internalServer) RangeFeed( - _ *roachpb.RangeFeedRequest, _ roachpb.Internal_RangeFeedServer, + *roachpb.RangeFeedRequest, roachpb.Internal_RangeFeedServer, +) error { + panic("unimplemented") +} + +func (*internalServer) GossipSubscription( + *roachpb.GossipSubscriptionRequest, roachpb.Internal_GossipSubscriptionServer, ) error { panic("unimplemented") } diff --git a/pkg/server/node.go b/pkg/server/node.go index 014f6425fe67..c2b69cd8edde 100644 --- a/pkg/server/node.go +++ b/pkg/server/node.go @@ -35,13 +35,13 @@ import ( "github.com/cockroachdb/cockroach/pkg/sql/sqlbase" "github.com/cockroachdb/cockroach/pkg/storage" "github.com/cockroachdb/cockroach/pkg/util" - "github.com/cockroachdb/cockroach/pkg/util/growstack" "github.com/cockroachdb/cockroach/pkg/util/grpcutil" "github.com/cockroachdb/cockroach/pkg/util/hlc" "github.com/cockroachdb/cockroach/pkg/util/log" "github.com/cockroachdb/cockroach/pkg/util/metric" "github.com/cockroachdb/cockroach/pkg/util/retry" "github.com/cockroachdb/cockroach/pkg/util/stop" + "github.com/cockroachdb/cockroach/pkg/util/syncutil" "github.com/cockroachdb/cockroach/pkg/util/timeutil" "github.com/cockroachdb/cockroach/pkg/util/tracing" "github.com/cockroachdb/cockroach/pkg/util/uuid" @@ -947,12 +947,41 @@ func (n *Node) setupSpanForIncomingRPC( return ctx, finishSpan } +// RangeLookup implements the roachpb.InternalServer interface. +func (n *Node) RangeLookup( + ctx context.Context, req *roachpb.RangeLookupRequest, +) (*roachpb.RangeLookupResponse, error) { + ctx = n.storeCfg.AmbientCtx.AnnotateCtx(ctx) + + // Proxy the RangeLookup through the local DB. Note that this does not use + // the local RangeDescriptorCache itself (for the direct range descriptor). + // To be able to do so, we'd have to let tenant's evict descriptors from our + // cache in order to avoid serving the same stale descriptor over and over + // again. Because of that, using our own cache doesn't seem worth it, at + // least for now. + sender := n.storeCfg.DB.NonTransactionalSender() + rs, preRs, err := kv.RangeLookup( + ctx, + sender, + req.Key.AsRawKey(), + req.ReadConsistency, + req.PrefetchNum, + req.PrefetchReverse, + ) + resp := new(roachpb.RangeLookupResponse) + if err != nil { + resp.Error = roachpb.NewError(err) + } else { + resp.Descriptors = rs + resp.PrefetchedDescriptors = preRs + } + return resp, nil +} + // RangeFeed implements the roachpb.InternalServer interface. func (n *Node) RangeFeed( args *roachpb.RangeFeedRequest, stream roachpb.Internal_RangeFeedServer, ) error { - growstack.Grow() - pErr := n.stores.RangeFeed(args, stream) if pErr != nil { var event roachpb.RangeFeedEvent @@ -963,3 +992,81 @@ func (n *Node) RangeFeed( } return nil } + +// GossipSubscription implements the roachpb.InternalServer interface. +func (n *Node) GossipSubscription( + args *roachpb.GossipSubscriptionRequest, stream roachpb.Internal_GossipSubscriptionServer, +) error { + ctx := n.storeCfg.AmbientCtx.AnnotateCtx(stream.Context()) + ctxDone := ctx.Done() + + // Register a callback for each of the requested patterns. We don't want to + // block the gossip callback goroutine on a slow consumer, so we instead + // handle all communication asynchronously. We could pick a channel size and + // say that if the channel ever blocks, terminate the subscription. Doing so + // feels fragile, though, especially during the initial information dump. + // Instead, we say that if the channel ever blocks for more than some + // duration, terminate the subscription. + entC := make(chan *roachpb.GossipSubscriptionEvent, 256) + entCClosed := false + var callbackMu syncutil.Mutex + const maxBlockDur = 1 * time.Millisecond + for _, pattern := range args.Patterns { + pattern := pattern + // TODO(nvanbenschoten): add some form of access control here. Tenants + // should only be able to subscribe to certain patterns, such as: + // - "node:.*" + // - "system-db:zones/1/tenants" + // + // Note that the SystemConfig pattern here doesn't refer to a real key. + // Instead, it's keying into the single SystemConfig gossip key. That's + // necessary to avoid leaking privileged information to callers, but it + // means that we have a little more work to do in order to destructure + // and filter system config updates. Luckily, SystemConfigDeltaFilter + // supports a "keyPrefix" that should help here. We'll also want to use + // RegisterSystemConfigChannel for any SystemConfig patterns. + + callback := func(key string, content roachpb.Value) { + callbackMu.Lock() + defer callbackMu.Unlock() + if entCClosed { + return + } + event := &roachpb.GossipSubscriptionEvent{ + Key: key, Content: content, PatternMatched: pattern, + } + select { + case entC <- event: + default: + select { + case entC <- event: + case <-time.After(maxBlockDur): + // entC blocking for too long. The consumer must not be + // keeping up. Terminate the subscription. + close(entC) + entCClosed = true + } + } + } + unregister := n.storeCfg.Gossip.RegisterCallback(pattern, callback) + defer unregister() + } + + for { + select { + case e, ok := <-entC: + if !ok { + // The consumer was not keeping up with gossip updates, so its + // subscription was terminated to avoid blocking gossip. + err := roachpb.NewErrorf("subscription terminated due to slow consumption") + log.Warningf(ctx, "%v", err) + e = &roachpb.GossipSubscriptionEvent{Error: err} + } + if err := stream.Send(e); err != nil { + return err + } + case <-ctxDone: + return ctx.Err() + } + } +} diff --git a/pkg/server/server_sql.go b/pkg/server/server_sql.go index 1ff0d16be787..5c2c467cd820 100644 --- a/pkg/server/server_sql.go +++ b/pkg/server/server_sql.go @@ -27,6 +27,7 @@ import ( "github.com/cockroachdb/cockroach/pkg/kv" "github.com/cockroachdb/cockroach/pkg/kv/bulk" "github.com/cockroachdb/cockroach/pkg/kv/kvclient/kvcoord" + "github.com/cockroachdb/cockroach/pkg/kv/kvclient/kvtenant" "github.com/cockroachdb/cockroach/pkg/kv/kvserver/kvserverbase" "github.com/cockroachdb/cockroach/pkg/kv/kvserver/protectedts" "github.com/cockroachdb/cockroach/pkg/roachpb" @@ -70,6 +71,7 @@ type sqlServer struct { internalExecutor *sql.InternalExecutor leaseMgr *lease.Manager blobService *blobs.Service + tenantProxy kvtenant.Proxy // sessionRegistry can be queried for info on running SQL sessions. It is // shared between the sql.Server and the statusServer. sessionRegistry *sql.SessionRegistry @@ -94,11 +96,13 @@ type sqlServerOptionalArgs struct { // DistSQL uses rpcContext to set up flows. Less centrally, the executor // also uses rpcContext in a number of places to learn whether the server // is running insecure, and to read the cluster name. + // TODO(nvanbenschoten): move off this struct. rpcContext *rpc.Context // SQL mostly uses the DistSender "wrapped" under a *kv.DB, but SQL also // uses range descriptors and leaseholders, which DistSender maintains, // for debugging and DistSQL planning purposes. + // TODO(nvanbenschoten): move off this struct. distSender *kvcoord.DistSender // statusServer gives access to the Status service. statusServer serverpb.OptionalStatusServer @@ -109,6 +113,7 @@ type sqlServerOptionalArgs struct { // diagnostics registry, and the lease manager. gossip gossip.DeprecatedGossip // Used by DistSQLConfig and DistSQLPlanner. + // TODO(nvanbenschoten): move off this struct. nodeDialer *nodedialer.Dialer // To register blob and DistSQL servers. grpcServer *grpc.Server @@ -122,6 +127,11 @@ type sqlServerOptionalArgs struct { // Used by backup/restore. externalStorage cloud.ExternalStorageFactory externalStorageFromURI cloud.ExternalStorageFromURIFactory + + // TODO(nvanbenschoten): Move to a second "optional" args struct. One for + // dependencies that are only available if the SQL server runs NOT as part + // of a KV node. + tenantProxy kvtenant.Proxy } type sqlServerArgs struct { @@ -559,6 +569,7 @@ func newSQLServer(ctx context.Context, cfg sqlServerArgs) (*sqlServer, error) { internalExecutor: cfg.circularInternalExecutor, leaseMgr: leaseMgr, blobService: blobService, + tenantProxy: cfg.tenantProxy, sessionRegistry: cfg.sessionRegistry, jobRegistry: jobRegistry, statsRefresher: statsRefresher, @@ -579,6 +590,14 @@ func (s *sqlServer) start( socketFile string, orphanedLeasesTimeThresholdNanos int64, ) error { + // If necessary, start the tenant proxy first, to ensure all other + // components can properly route to KV nodes. + if s.tenantProxy != nil { + if err := s.tenantProxy.Start(ctx); err != nil { + return err + } + } + s.temporaryObjectCleaner.Start(ctx, stopper) s.distSQLServer.Start() s.pgServer.Start(ctx, stopper) diff --git a/pkg/server/testserver.go b/pkg/server/testserver.go index 22fba14449b9..ed037df36760 100644 --- a/pkg/server/testserver.go +++ b/pkg/server/testserver.go @@ -32,6 +32,7 @@ import ( "github.com/cockroachdb/cockroach/pkg/keys" "github.com/cockroachdb/cockroach/pkg/kv" "github.com/cockroachdb/cockroach/pkg/kv/kvclient/kvcoord" + "github.com/cockroachdb/cockroach/pkg/kv/kvclient/kvtenant" "github.com/cockroachdb/cockroach/pkg/kv/kvserver" "github.com/cockroachdb/cockroach/pkg/kv/kvserver/protectedts" "github.com/cockroachdb/cockroach/pkg/kv/kvserver/protectedts/ptpb" @@ -437,7 +438,7 @@ const fakeNodeID = roachpb.NodeID(123456789) func makeSQLServerArgs( stopper *stop.Stopper, kvClusterName string, baseCfg BaseConfig, sqlCfg SQLConfig, -) sqlServerArgs { +) (sqlServerArgs, error) { st := baseCfg.Settings baseCfg.AmbientCtx.AddLogTag("sql", nil) // TODO(tbg): this is needed so that the RPC heartbeats between the testcluster @@ -449,6 +450,10 @@ func makeSQLServerArgs( clock := hlc.NewClock(hlc.UnixNano, time.Duration(baseCfg.MaxOffset)) + // TODO(tbg): expose this registry via prometheus. See: + // https://github.com/cockroachdb/cockroach/issues/47905 + registry := metric.NewRegistry() + var rpcTestingKnobs rpc.ContextTestingKnobs if p, ok := baseCfg.TestingKnobs.Server.(*TestingKnobs); ok { rpcTestingKnobs = p.ContextTestingKnobs @@ -462,18 +467,14 @@ func makeSQLServerArgs( Knobs: rpcTestingKnobs, }) - // TODO(tbg): expose this registry via prometheus. See: - // https://github.com/cockroachdb/cockroach/issues/47905 - registry := metric.NewRegistry() - var dsKnobs kvcoord.ClientTestingKnobs if dsKnobsP, ok := baseCfg.TestingKnobs.DistSQL.(*kvcoord.ClientTestingKnobs); ok { dsKnobs = *dsKnobsP } rpcRetryOptions := base.DefaultRetryOptions() - // TODO(nvb): this use of Gossip needs to go. Tracked in: - // https://github.com/cockroachdb/cockroach/issues/47909 + // TODO(ajwerner): this use of Gossip needs to go. Tracked in: + // https://github.com/cockroachdb/cockroach/issues/47150 var g *gossip.Gossip { var nodeID base.NodeIDContainer @@ -493,21 +494,28 @@ func makeSQLServerArgs( ) } - nodeDialer := nodedialer.New( + tenantProxy, err := kvtenant.Factory.NewProxy( + baseCfg.AmbientCtx, rpcContext, - gossip.AddressResolver(g), // TODO(nvb): break gossip dep + rpcRetryOptions, + sqlCfg.TenantKVAddrs, ) + if err != nil { + return sqlServerArgs{}, err + } + resolver := kvcoord.AddressResolver(tenantProxy, baseCfg.Locality) + nodeDialer := nodedialer.New(rpcContext, resolver) + dsCfg := kvcoord.DistSenderConfig{ - AmbientCtx: baseCfg.AmbientCtx, - Settings: st, - Clock: clock, - NodeDescs: g, - RPCRetryOptions: &rpcRetryOptions, - RPCContext: rpcContext, - NodeDialer: nodeDialer, - RangeDescriptorDB: nil, // use DistSender itself - FirstRangeProvider: g, - TestingKnobs: dsKnobs, + AmbientCtx: baseCfg.AmbientCtx, + Settings: st, + Clock: clock, + NodeDescs: tenantProxy, + RPCRetryOptions: &rpcRetryOptions, + RPCContext: rpcContext, + NodeDialer: nodeDialer, + RangeDescriptorDB: tenantProxy, + TestingKnobs: dsKnobs, } ds := kvcoord.NewDistSender(dsCfg) @@ -586,6 +594,7 @@ func makeSQLServerArgs( uri, user string) (cloud.ExternalStorage, error) { return nil, errors.New("external uri storage is not available to secondary tenants") }, + tenantProxy: tenantProxy, }, SQLConfig: &sqlCfg, BaseConfig: &baseCfg, @@ -598,7 +607,7 @@ func makeSQLServerArgs( circularInternalExecutor: circularInternalExecutor, circularJobRegistry: &jobs.Registry{}, protectedtsProvider: protectedTSProvider, - } + }, nil } // StartTenant starts a SQL tenant communicating with this TestServer. @@ -639,7 +648,10 @@ func StartTenant( baseCfg BaseConfig, sqlCfg SQLConfig, ) (pgAddr string, _ error) { - args := makeSQLServerArgs(stopper, kvClusterName, baseCfg, sqlCfg) + args, err := makeSQLServerArgs(stopper, kvClusterName, baseCfg, sqlCfg) + if err != nil { + return "", err + } s, err := newSQLServer(ctx, args) if err != nil { return "", err @@ -677,6 +689,8 @@ func StartTenant( ) orphanedLeasesTimeThresholdNanos := args.clock.Now().WallTime + // TODO(ajwerner): this use of Gossip needs to go. Tracked in: + // https://github.com/cockroachdb/cockroach/issues/47150 { rs := make([]resolver.Resolver, len(sqlCfg.TenantKVAddrs)) for i := range rs { diff --git a/pkg/sql/logictest/logic.go b/pkg/sql/logictest/logic.go index 029eaee05ea2..d7471fdb27bb 100644 --- a/pkg/sql/logictest/logic.go +++ b/pkg/sql/logictest/logic.go @@ -620,6 +620,12 @@ var logicTestConfigs = []testClusterConfig{ }, } +// An index in the above slice. +type logicTestConfigIdx int + +// A collection of configurations. +type configSet []logicTestConfigIdx + var logicTestConfigIdxToName = make(map[logicTestConfigIdx]string) func init() { @@ -628,8 +634,8 @@ func init() { } } -func parseTestConfig(names []string) []logicTestConfigIdx { - ret := make([]logicTestConfigIdx, len(names)) +func parseTestConfig(names []string) configSet { + ret := make(configSet, len(names)) for i, name := range names { idx, ok := findLogicTestConfig(name) if !ok { @@ -655,7 +661,6 @@ var ( "fakedist-metadata", "fakedist-disk", "fakedist-spec-planning", - "3node-tenant", } // fiveNodeDefaultConfigName is a special alias for all 5 node configs. fiveNodeDefaultConfigName = "5node-default-configs" @@ -671,9 +676,6 @@ var ( fiveNodeDefaultConfig = parseTestConfig(fiveNodeDefaultConfigNames) ) -// An index in the above slice. -type logicTestConfigIdx int - func findLogicTestConfig(name string) (logicTestConfigIdx, bool) { for i, cfg := range logicTestConfigs { if cfg.name == name { @@ -1454,22 +1456,20 @@ CREATE DATABASE test; t.unsupported = 0 } -// applyBlocklistToConfigIdxs applies the given blocklist to config idxs, -// returning the result. -func applyBlocklistToConfigIdxs( - configIdxs []logicTestConfigIdx, blocklist map[string]int, -) []logicTestConfigIdx { +// applyBlocklistToConfigs applies the given blocklist to configs, returning the +// result. +func applyBlocklistToConfigs(configs configSet, blocklist map[string]int) configSet { if len(blocklist) == 0 { - return configIdxs + return configs } - var newConfigIdxs []logicTestConfigIdx - for _, idx := range configIdxs { + var newConfigs configSet + for _, idx := range configs { if _, ok := blocklist[logicTestConfigIdxToName[idx]]; ok { continue } - newConfigIdxs = append(newConfigIdxs, idx) + newConfigs = append(newConfigs, idx) } - return newConfigIdxs + return newConfigs } // getBlocklistIssueNo takes a blocklist directive with an optional issue number @@ -1491,7 +1491,7 @@ func getBlocklistIssueNo(blocklistDirective string) (string, int) { // processConfigs, given a list of configNames, returns the list of // corresponding logicTestConfigIdxs. -func processConfigs(t *testing.T, path string, configNames []string) []logicTestConfigIdx { +func processConfigs(t *testing.T, path string, defaults configSet, configNames []string) configSet { const blocklistChar = '!' // blocklist is a map from a blocked config to a corresponding issue number. // If 0, there is no associated issue. @@ -1510,10 +1510,10 @@ func processConfigs(t *testing.T, path string, configNames []string) []logicTest blocklist[blockedConfig] = issueNo } - var configs []logicTestConfigIdx + var configs configSet if len(blocklist) != 0 && allConfigNamesAreBlocklistDirectives { - // No configs specified, this blocklist applies to the default config. - return applyBlocklistToConfigIdxs(defaultConfig, blocklist) + // No configs specified, this blocklist applies to the default configs. + return applyBlocklistToConfigs(defaults, blocklist) } for _, configName := range configNames { @@ -1528,9 +1528,9 @@ func processConfigs(t *testing.T, path string, configNames []string) []logicTest if !ok { switch configName { case defaultConfigName: - configs = append(configs, applyBlocklistToConfigIdxs(defaultConfig, blocklist)...) + configs = append(configs, applyBlocklistToConfigs(defaults, blocklist)...) case fiveNodeDefaultConfigName: - configs = append(configs, applyBlocklistToConfigIdxs(fiveNodeDefaultConfig, blocklist)...) + configs = append(configs, applyBlocklistToConfigs(fiveNodeDefaultConfig, blocklist)...) default: t.Fatalf("%s: unknown config name %s", path, configName) } @@ -1551,7 +1551,7 @@ func processConfigs(t *testing.T, path string, configNames []string) []logicTest // # LogicTest: default distsql // // If the file doesn't contain a directive, the default config is returned. -func readTestFileConfigs(t *testing.T, path string) []logicTestConfigIdx { +func readTestFileConfigs(t *testing.T, path string, defaults configSet) configSet { file, err := os.Open(path) if err != nil { t.Fatal(err) @@ -1575,11 +1575,11 @@ func readTestFileConfigs(t *testing.T, path string) []logicTestConfigIdx { if len(fields) == 2 { t.Fatalf("%s: empty LogicTest directive", path) } - return processConfigs(t, path, fields[2:]) + return processConfigs(t, path, defaults, fields[2:]) } } // No directive found, return the default config. - return defaultConfig + return defaults } type subtestDetails struct { @@ -2660,6 +2660,16 @@ type TestServerArgs struct { // RunLogicTest is the main entry point for the logic test. The globs parameter // specifies the default sets of files to run. func RunLogicTest(t *testing.T, serverArgs TestServerArgs, globs ...string) { + RunLogicTestWithDefaultConfig(t, serverArgs, *overrideConfig, globs...) +} + +// RunLogicTestWithDefaultConfig is the main entry point for the logic test. +// The globs parameter specifies the default sets of files to run. The config +// override parameter, if not empty, specifies the set of configurations to run +// those files in. If empty, the default set of configurations is used. +func RunLogicTestWithDefaultConfig( + t *testing.T, serverArgs TestServerArgs, configOverride string, globs ...string, +) { // Note: there is special code in teamcity-trigger/main.go to run this package // with less concurrency in the nightly stress runs. If you see problems // please make adjustments there. @@ -2707,16 +2717,32 @@ func RunLogicTest(t *testing.T, serverArgs TestServerArgs, globs ...string) { // Read the configuration directives from all the files and accumulate a list // of paths per config. configPaths := make([][]string, len(logicTestConfigs)) - var configs []logicTestConfigIdx - if *overrideConfig != "" { - configs = parseTestConfig(strings.Split(*overrideConfig, ",")) + configDefaults := defaultConfig + var configFilter map[string]struct{} + if configOverride != "" { + // If a config override is provided, we use it to replace the default + // config set. This ensures that the overrides are used for files where: + // 1. no config directive is present + // 2. a config directive containing only a blocklist is present + // 3. a config directive containing "default-configs" is present + // + // We also create a filter to restrict configs to only those in the + // override list. + names := strings.Split(configOverride, ",") + configDefaults = parseTestConfig(names) + configFilter = make(map[string]struct{}) + for _, name := range names { + configFilter[name] = struct{}{} + } } - for _, path := range paths { - if *overrideConfig == "" { - configs = readTestFileConfigs(t, path) - } + configs := readTestFileConfigs(t, path, configDefaults) for _, idx := range configs { + configName := logicTestConfigs[idx].name + if _, ok := configFilter[configName]; configFilter != nil && !ok { + // Config filter present but not containing test. + continue + } configPaths[idx] = append(configPaths[idx], path) } } From b19794de2ec160fe2f0197f1c260778d7c3b68d5 Mon Sep 17 00:00:00 2001 From: Nathan VanBenschoten Date: Mon, 13 Jul 2020 00:55:10 -0400 Subject: [PATCH 3/3] kvccl: move followerreadsccl under kvccl Package movement. --- pkg/ccl/ccl_init.go | 1 - pkg/ccl/kvccl/kvccl.go | 6 +++++- .../kvfollowerreadsccl}/followerreads.go | 4 ++-- .../kvfollowerreadsccl}/followerreads_test.go | 2 +- 4 files changed, 8 insertions(+), 5 deletions(-) rename pkg/ccl/{followerreadsccl => kvccl/kvfollowerreadsccl}/followerreads.go (98%) rename pkg/ccl/{followerreadsccl => kvccl/kvfollowerreadsccl}/followerreads_test.go (99%) diff --git a/pkg/ccl/ccl_init.go b/pkg/ccl/ccl_init.go index f63cf8dfda90..bdcd07caba02 100644 --- a/pkg/ccl/ccl_init.go +++ b/pkg/ccl/ccl_init.go @@ -18,7 +18,6 @@ import ( _ "github.com/cockroachdb/cockroach/pkg/ccl/buildccl" _ "github.com/cockroachdb/cockroach/pkg/ccl/changefeedccl" _ "github.com/cockroachdb/cockroach/pkg/ccl/cliccl" - _ "github.com/cockroachdb/cockroach/pkg/ccl/followerreadsccl" _ "github.com/cockroachdb/cockroach/pkg/ccl/gssapiccl" _ "github.com/cockroachdb/cockroach/pkg/ccl/importccl" _ "github.com/cockroachdb/cockroach/pkg/ccl/kvccl" diff --git a/pkg/ccl/kvccl/kvccl.go b/pkg/ccl/kvccl/kvccl.go index 0988c8179167..a6c24d9eae72 100644 --- a/pkg/ccl/kvccl/kvccl.go +++ b/pkg/ccl/kvccl/kvccl.go @@ -8,4 +8,8 @@ package kvccl -import _ "github.com/cockroachdb/cockroach/pkg/ccl/kvccl/kvtenantccl" // init hooks +import ( + // ccl init hooks. + _ "github.com/cockroachdb/cockroach/pkg/ccl/kvccl/kvfollowerreadsccl" + _ "github.com/cockroachdb/cockroach/pkg/ccl/kvccl/kvtenantccl" +) diff --git a/pkg/ccl/followerreadsccl/followerreads.go b/pkg/ccl/kvccl/kvfollowerreadsccl/followerreads.go similarity index 98% rename from pkg/ccl/followerreadsccl/followerreads.go rename to pkg/ccl/kvccl/kvfollowerreadsccl/followerreads.go index 60393fd067cf..f89d8b934a00 100644 --- a/pkg/ccl/followerreadsccl/followerreads.go +++ b/pkg/ccl/kvccl/kvfollowerreadsccl/followerreads.go @@ -6,9 +6,9 @@ // // https://github.com/cockroachdb/cockroach/blob/master/licenses/CCL.txt -// Package followerreadsccl implements and injects the functionality needed to +// Package kvfollowerreadsccl implements and injects the functionality needed to // expose follower reads to clients. -package followerreadsccl +package kvfollowerreadsccl import ( "fmt" diff --git a/pkg/ccl/followerreadsccl/followerreads_test.go b/pkg/ccl/kvccl/kvfollowerreadsccl/followerreads_test.go similarity index 99% rename from pkg/ccl/followerreadsccl/followerreads_test.go rename to pkg/ccl/kvccl/kvfollowerreadsccl/followerreads_test.go index e1610df71b1d..0155b4a39341 100644 --- a/pkg/ccl/followerreadsccl/followerreads_test.go +++ b/pkg/ccl/kvccl/kvfollowerreadsccl/followerreads_test.go @@ -6,7 +6,7 @@ // // https://github.com/cockroachdb/cockroach/blob/master/licenses/CCL.txt -package followerreadsccl +package kvfollowerreadsccl import ( "context"