github.com/cockroachdb/cockroach@v20.2.0-alpha.1+incompatible/pkg/roachpb/metadata.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: roachpb/metadata.proto

package roachpb

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import util "github.com/cockroachdb/cockroach/pkg/util"
import hlc "github.com/cockroachdb/cockroach/pkg/util/hlc"

import bytes "bytes"

import encoding_binary "encoding/binary"

import io "io"

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package

// ReplicaType identifies which raft activities a replica participates in. In
// normal operation, VOTER_FULL and LEARNER are the only used states. However,
// atomic replication changes require a transition through a "joint config"; in
// this joint config, the VOTER_DEMOTING and VOTER_INCOMING types are used as
// well to denote voters which are being downgraded to learners and newly added
// by the change, respectively. A demoting voter is turning into a learner,
// which we prefer over a direct removal, which was used prior to v20.1 and
// uses the VOTER_OUTGOING type instead (see VersionChangeReplicasDemotion for
// details on why we're not doing that any more).
//
// All voter types indicate a replica that participates in all raft activities,
// including voting for leadership and committing entries. Typically, this
// requires a majority of voters to reach a decision. In a joint config, two
// separate majorities are required: one from the set of replicas that have
// either type VOTER or VOTER_OUTOING or VOTER_DEMOTING, as well as that of the
// set of types VOTER and VOTER_INCOMING . For example, when type VOTER_FULL is
// assigned to replicas 1 and 2, while 3 is VOTER_OUTGOING and 4 is
// VOTER_INCOMING, then the two sets over which quorums need to be achieved are
// {1,2,3} and {1,2,4}. Thus, {1,2} is a quorum of both, {1,3} is a quorum of
// the first but not the second, {1,4} is a quorum of the second but not the
// first, and {3,4} is a quorum of neither.
type ReplicaType int32

const (
	// VOTER_FULL indicates a replica that is a voter both in the
	// incoming and outgoing set.
	VOTER_FULL ReplicaType = 0
	// VOTER_INCOMING indicates a voting replica that will be a
	// VOTER_FULL once the ongoing atomic replication change is finalized; that is,
	// it is in the process of being added. In practice, this replica type should
	// be treated like a VOTER_FULL.
	VOTER_INCOMING ReplicaType = 2
	// VOTER_OUTGOING indicates a voting replica that will not be part
	// of the descriptor once the ongoing atomic replication change is finalized;
	// that is, it is in the process of being removed. In practice, a replica of
	// this type should be treated accordingly and no work should be assigned to
	// it.
	VOTER_OUTGOING ReplicaType = 3
	// VOTER_DEMOTING indicates a voting replica that will become a learner once
	// the ongoing atomic replication change is finalized; that is, it is in the
	// process of being demoted. Since learners are currently short-lived, this
	// replica is really being removed, with an intermediate step, and no work
	// should be assigned to it.
	VOTER_DEMOTING ReplicaType = 4
	// LEARNER indicates a replica that applies committed entries, but does not
	// count towards the quorum(s). Candidates will not ask for (or take into
	// account) votes of (peers they consider) LEARNERs for leadership nor do
	// their acknowledged log entries get taken into account for determining the
	// committed index. At the time of writing, learners in CockroachDB are a
	// short-term transient state: a replica being added and on its way to being a
	// VOTER_{FULL,INCOMING}, or a VOTER_DEMOTING being removed.
	LEARNER ReplicaType = 1
)

var ReplicaType_name = map[int32]string{
	0: "VOTER_FULL",
	2: "VOTER_INCOMING",
	3: "VOTER_OUTGOING",
	4: "VOTER_DEMOTING",
	1: "LEARNER",
}
var ReplicaType_value = map[string]int32{
	"VOTER_FULL":     0,
	"VOTER_INCOMING": 2,
	"VOTER_OUTGOING": 3,
	"VOTER_DEMOTING": 4,
	"LEARNER":        1,
}

func (x ReplicaType) Enum() *ReplicaType {
	p := new(ReplicaType)
	*p = x
	return p
}
func (x ReplicaType) String() string {
	return proto.EnumName(ReplicaType_name, int32(x))
}
func (x *ReplicaType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ReplicaType_value, data, "ReplicaType")
	if err != nil {
		return err
	}
	*x = ReplicaType(value)
	return nil
}
func (ReplicaType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_metadata_4d08fb4df4010e8b, []int{0}
}

// Attributes specifies a list of arbitrary strings describing
// node topology, store type, and machine capabilities.
type Attributes struct {
	Attrs []string `protobuf:"bytes,1,rep,name=attrs" json:"attrs,omitempty" yaml:"attrs,flow"`
}

func (m *Attributes) Reset()      { *m = Attributes{} }
func (*Attributes) ProtoMessage() {}
func (*Attributes) Descriptor() ([]byte, []int) {
	return fileDescriptor_metadata_4d08fb4df4010e8b, []int{0}
}
func (m *Attributes) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Attributes) 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 *Attributes) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Attributes.Merge(dst, src)
}
func (m *Attributes) XXX_Size() int {
	return m.Size()
}
func (m *Attributes) XXX_DiscardUnknown() {
	xxx_messageInfo_Attributes.DiscardUnknown(m)
}

var xxx_messageInfo_Attributes proto.InternalMessageInfo

// ReplicationTarget identifies a node/store pair.
type ReplicationTarget struct {
	NodeID  NodeID  `protobuf:"varint,1,opt,name=node_id,json=nodeId,casttype=NodeID" json:"node_id"`
	StoreID StoreID `protobuf:"varint,2,opt,name=store_id,json=storeId,casttype=StoreID" json:"store_id"`
}

func (m *ReplicationTarget) Reset()      { *m = ReplicationTarget{} }
func (*ReplicationTarget) ProtoMessage() {}
func (*ReplicationTarget) Descriptor() ([]byte, []int) {
	return fileDescriptor_metadata_4d08fb4df4010e8b, []int{1}
}
func (m *ReplicationTarget) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ReplicationTarget) 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 *ReplicationTarget) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReplicationTarget.Merge(dst, src)
}
func (m *ReplicationTarget) XXX_Size() int {
	return m.Size()
}
func (m *ReplicationTarget) XXX_DiscardUnknown() {
	xxx_messageInfo_ReplicationTarget.DiscardUnknown(m)
}

var xxx_messageInfo_ReplicationTarget proto.InternalMessageInfo

// ReplicaDescriptor describes a replica location by node ID
// (corresponds to a host:port via lookup on gossip network) and store
// ID (identifies the device).
// TODO(jeffreyxiao): All nullable fields in ReplicaDescriptor can be made
// non-nullable if #38302 is guaranteed to be on all nodes (I.E. 20.1).
type ReplicaDescriptor struct {
	NodeID  NodeID  `protobuf:"varint,1,opt,name=node_id,json=nodeId,casttype=NodeID" json:"node_id"`
	StoreID StoreID `protobuf:"varint,2,opt,name=store_id,json=storeId,casttype=StoreID" json:"store_id"`
	// replica_id uniquely identifies a replica instance. If a range is removed from
	// a store and then re-added to the same store, the new instance will have a
	// higher replica_id.
	ReplicaID ReplicaID `protobuf:"varint,3,opt,name=replica_id,json=replicaId,casttype=ReplicaID" json:"replica_id"`
	// Type indicates which raft activities a replica participates in. A nil type
	// is equivalent to VOTER.
	Type *ReplicaType `protobuf:"varint,4,opt,name=type,enum=cockroach.roachpb.ReplicaType" json:"type,omitempty"`
}

func (m *ReplicaDescriptor) Reset()      { *m = ReplicaDescriptor{} }
func (*ReplicaDescriptor) ProtoMessage() {}
func (*ReplicaDescriptor) Descriptor() ([]byte, []int) {
	return fileDescriptor_metadata_4d08fb4df4010e8b, []int{2}
}
func (m *ReplicaDescriptor) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ReplicaDescriptor) 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 *ReplicaDescriptor) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReplicaDescriptor.Merge(dst, src)
}
func (m *ReplicaDescriptor) XXX_Size() int {
	return m.Size()
}
func (m *ReplicaDescriptor) XXX_DiscardUnknown() {
	xxx_messageInfo_ReplicaDescriptor.DiscardUnknown(m)
}

var xxx_messageInfo_ReplicaDescriptor proto.InternalMessageInfo

// ReplicaIdent uniquely identifies a specific replica.
type ReplicaIdent struct {
	RangeID RangeID           `protobuf:"varint,1,opt,name=range_id,json=rangeId,casttype=RangeID" json:"range_id"`
	Replica ReplicaDescriptor `protobuf:"bytes,2,opt,name=replica" json:"replica"`
}

func (m *ReplicaIdent) Reset()         { *m = ReplicaIdent{} }
func (m *ReplicaIdent) String() string { return proto.CompactTextString(m) }
func (*ReplicaIdent) ProtoMessage()    {}
func (*ReplicaIdent) Descriptor() ([]byte, []int) {
	return fileDescriptor_metadata_4d08fb4df4010e8b, []int{3}
}
func (m *ReplicaIdent) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ReplicaIdent) 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 *ReplicaIdent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReplicaIdent.Merge(dst, src)
}
func (m *ReplicaIdent) XXX_Size() int {
	return m.Size()
}
func (m *ReplicaIdent) XXX_DiscardUnknown() {
	xxx_messageInfo_ReplicaIdent.DiscardUnknown(m)
}

var xxx_messageInfo_ReplicaIdent proto.InternalMessageInfo

// RangeDescriptor is the value stored in a range metadata key.
// A range is described using an inclusive start key, a non-inclusive end key,
// and a list of replicas where the range is stored.
//
// NOTE: Care must be taken when changing the encoding of this proto
// because it is used as part of conditional put operations.
// TODO(jeffreyxiao): All nullable fields in RangeDescriptor can be made
// non-nullable if #38302 is guaranteed to be on all nodes (I.E. 20.1).
type RangeDescriptor struct {
	RangeID RangeID `protobuf:"varint,1,opt,name=range_id,json=rangeId,casttype=RangeID" json:"range_id"`
	// start_key is the first key which may be contained by this range.
	StartKey RKey `protobuf:"bytes,2,opt,name=start_key,json=startKey,casttype=RKey" json:"start_key,omitempty"`
	// end_key marks the end of the range's possible keys.  EndKey itself is not
	// contained in this range - it will be contained in the immediately
	// subsequent range.
	EndKey RKey `protobuf:"bytes,3,opt,name=end_key,json=endKey,casttype=RKey" json:"end_key,omitempty"`
	// InternalReplicas is the is the set of nodes/stores on which replicas of
	// this range are stored. DO NOT USE this field directly, use the `Replicas`
	// method instead. The ordering is arbitrary and subject to permutation.
	InternalReplicas []ReplicaDescriptor `protobuf:"bytes,4,rep,name=internal_replicas,json=internalReplicas" json:"internal_replicas"`
	// next_replica_id is a counter used to generate replica IDs.
	NextReplicaID ReplicaID `protobuf:"varint,5,opt,name=next_replica_id,json=nextReplicaId,casttype=ReplicaID" json:"next_replica_id"`
	// generation is incremented on every split, merge, and every replica change,
	// i.e., whenever the span of the range or replica set changes. It is
	// initialized to zero when the range is first created. The generation
	// counter was first introduced to allow the range descriptor resulting from
	// a split and then merge to be distinguishable from the initial range
	// descriptor. This is important since changes to the range descriptors use
	// CPuts to ensure mutual exclusion.
	//
	// See #28071 for details on the above.
	//
	// Generations are also useful to make local replicaGC decisions when applying
	// a snapshot on keyspace that has overlapping replicas (but note that we do
	// not use this at the time of writing due to migration concerns; see below).
	//
	// We want to be able to compare the snapshot range's generation counter to
	// that of the overlapping replicas to draw a conclusion about whether the
	// snapshot can be applied (in which case the overlapping replicas need to be
	// safely removable). To that end, on a split, not only do we increment the
	// left hand side's generation, we also copy the resultant generation to the
	// newly created right hand side. On merges, we update the left hand side's
	// generation so that it exceeds by one the maximum of the left hand side and
	// the right hand side's generations from before the merge.
	//
	// If two replicas (perhaps one of them represented by a raft or preemptive
	// snapshot) as defined by their full range descriptor (including, notably,
	// the generation) overlap, then one of them has to be stale. This is because
	// the keyspace cleanly shards into non-overlapping ranges at all times (i.e.
	// for all consistent snapshots). Since meta ranges (or more generally, range
	// descriptors) are only ever updated transactionally, mutations to the meta
	// ranges can be serialized (i.e. put into some sequential ordering). We know
	// that the descriptors corresponding to both of our replicas can't be from
	// the same consistent snapshot of the meta ranges, so there is a version of
	// the meta ranges that includes only the first replica, and there is a
	// version that includes only the second replica. Without loss of generality,
	// assume that the first version is "older". This means that there is a finite
	// sequence of splits and merges that were applied to the consistent snapshot
	// corresponding to the first version which resulted in the second version of
	// the meta ranges.
	//
	// Each individual operation, thanks to the generational semantics above, has
	// the invariant that the resulting descriptors have a strictly larger
	// generation than any descriptors from the previous version that they cover.
	// For example, if a descriptor [a,c) at generation 5 is split into [a,b) and
	// [b,c), both of those latter range descriptors have generation 6. If [c,d)
	// is at generation 12 and [d, f) is at generation 17, then the resulting
	// merged range [c,f) will have generation 18.
	//
	// At the end of the day, for incoming snapshots, this means that we only have
	// to collect the overlapping replicas and their generations. Any replica with
	// a smaller generation is stale by the above argument and can be replicaGC'ed
	// right away. Any replica with a larger generation indicates that the snapshot
	// is stale and should be discarded. A replica with the same generation is
	// necessarily a replica of the range the snapshot is addressing (this is the
	// usual case, in which a snapshot "overlaps" precisely one replica, which is
	// the replica it's supposed to update, and no splits and merges have taken
	// place at all).
	//
	// For a third note, observe that the generational semantics above may
	// possibly allow range merges without colocation, at least in the sense that
	// the counter examples in #28071 are defused. This is because the
	// generational counter can answer the question whether the overlapping
	// replica is gc'able or not. If it is not gc'able, then by definition the
	// replica applying the merge is.
	Generation int64 `protobuf:"varint,6,opt,name=generation" json:"generation"`
	// The presence of the sticky_bit indicates that the range should not be
	// automatically merged by the merge queue with the range to its left. It is
	// set during a split operation and unset during an unsplit operation. Note
	// that the unsplit operation is a different operation from the merge
	// operation. Unsplit only unsets sticky_bit. It is represented by a
	// timestamp that indicates when it expires. After the expiration time has
	// passed, the split is eligible for automatic merging. A nil sticky bit is
	// equivalent to hlc.Timestamp{}.
	//
	// The reason the sticky_bit exists is because when the merge queue is
	// enabled and a manual split happens, the split ranges would immediately be
	// merged by the merge queue. Previous, we threw an error when a user
	// attempted to execute ALTER TABLE/INDEX ... SPLIT AT ... when the merge
	// queue is enabled. With sticky_bit, users can manually split ranges without
	// diabling the merge queue.
	StickyBit *hlc.Timestamp `protobuf:"bytes,7,opt,name=sticky_bit,json=stickyBit" json:"sticky_bit,omitempty"`
}

func (m *RangeDescriptor) Reset()      { *m = RangeDescriptor{} }
func (*RangeDescriptor) ProtoMessage() {}
func (*RangeDescriptor) Descriptor() ([]byte, []int) {
	return fileDescriptor_metadata_4d08fb4df4010e8b, []int{4}
}
func (m *RangeDescriptor) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RangeDescriptor) 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 *RangeDescriptor) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RangeDescriptor.Merge(dst, src)
}
func (m *RangeDescriptor) XXX_Size() int {
	return m.Size()
}
func (m *RangeDescriptor) XXX_DiscardUnknown() {
	xxx_messageInfo_RangeDescriptor.DiscardUnknown(m)
}

var xxx_messageInfo_RangeDescriptor proto.InternalMessageInfo

// Percentiles contains a handful of hard-coded percentiles meant to summarize
// a distribution.
type Percentiles struct {
	P10  float64 `protobuf:"fixed64,1,opt,name=p10" json:"p10"`
	P25  float64 `protobuf:"fixed64,2,opt,name=p25" json:"p25"`
	P50  float64 `protobuf:"fixed64,3,opt,name=p50" json:"p50"`
	P75  float64 `protobuf:"fixed64,4,opt,name=p75" json:"p75"`
	P90  float64 `protobuf:"fixed64,5,opt,name=p90" json:"p90"`
	PMax float64 `protobuf:"fixed64,6,opt,name=pMax" json:"pMax"`
}

func (m *Percentiles) Reset()      { *m = Percentiles{} }
func (*Percentiles) ProtoMessage() {}
func (*Percentiles) Descriptor() ([]byte, []int) {
	return fileDescriptor_metadata_4d08fb4df4010e8b, []int{5}
}
func (m *Percentiles) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Percentiles) 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 *Percentiles) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Percentiles.Merge(dst, src)
}
func (m *Percentiles) XXX_Size() int {
	return m.Size()
}
func (m *Percentiles) XXX_DiscardUnknown() {
	xxx_messageInfo_Percentiles.DiscardUnknown(m)
}

var xxx_messageInfo_Percentiles proto.InternalMessageInfo

// StoreCapacity contains capacity information for a storage device.
type StoreCapacity struct {
	// Total capacity of the disk used by the store, including space used by the
	// operating system and other applications.
	Capacity int64 `protobuf:"varint,1,opt,name=capacity" json:"capacity"`
	// Available space remaining on the disk used by the store.
	Available int64 `protobuf:"varint,2,opt,name=available" json:"available"`
	// Amount of disk space used by the data in the CockroachDB store. Note that
	// this is going to be less than (capacity - available), because those two
	// fields consider the entire disk and everything on it, while this only
	// tracks the store's disk usage.
	Used int64 `protobuf:"varint,8,opt,name=used" json:"used"`
	// Amount of logical bytes stored in the store, ignoring RocksDB space
	// overhead. Useful for rebalancing so that moving a replica from one store
	// to another actually removes its bytes from the source store even though
	// RocksDB may not actually reclaim the physical disk space for a while.
	LogicalBytes int64 `protobuf:"varint,9,opt,name=logical_bytes,json=logicalBytes" json:"logical_bytes"`
	RangeCount   int32 `protobuf:"varint,3,opt,name=range_count,json=rangeCount" json:"range_count"`
	LeaseCount   int32 `protobuf:"varint,4,opt,name=lease_count,json=leaseCount" json:"lease_count"`
	// queries_per_second tracks the average number of queries processed per
	// second by replicas in the store. The stat is tracked over the time period
	// defined in storage/replica_stats.go, which as of July 2018 is 30 minutes.
	QueriesPerSecond float64 `protobuf:"fixed64,10,opt,name=queries_per_second,json=queriesPerSecond" json:"queries_per_second"`
	// writes_per_second tracks the average number of keys written per second
	// by ranges in the store. The stat is tracked over the time period defined
	// in storage/replica_stats.go, which as of July 2018 is 30 minutes.
	WritesPerSecond float64 `protobuf:"fixed64,5,opt,name=writes_per_second,json=writesPerSecond" json:"writes_per_second"`
	// bytes_per_replica and writes_per_replica contain percentiles for the
	// number of bytes and writes-per-second to each replica in the store.
	// This information can be used for rebalancing decisions.
	BytesPerReplica  Percentiles `protobuf:"bytes,6,opt,name=bytes_per_replica,json=bytesPerReplica" json:"bytes_per_replica"`
	WritesPerReplica Percentiles `protobuf:"bytes,7,opt,name=writes_per_replica,json=writesPerReplica" json:"writes_per_replica"`
}

func (m *StoreCapacity) Reset()      { *m = StoreCapacity{} }
func (*StoreCapacity) ProtoMessage() {}
func (*StoreCapacity) Descriptor() ([]byte, []int) {
	return fileDescriptor_metadata_4d08fb4df4010e8b, []int{6}
}
func (m *StoreCapacity) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StoreCapacity) 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 *StoreCapacity) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StoreCapacity.Merge(dst, src)
}
func (m *StoreCapacity) XXX_Size() int {
	return m.Size()
}
func (m *StoreCapacity) XXX_DiscardUnknown() {
	xxx_messageInfo_StoreCapacity.DiscardUnknown(m)
}

var xxx_messageInfo_StoreCapacity proto.InternalMessageInfo

// NodeDescriptor holds details on node physical/network topology.
type NodeDescriptor struct {
	NodeID          NodeID              `protobuf:"varint,1,opt,name=node_id,json=nodeId,casttype=NodeID" json:"node_id"`
	Address         util.UnresolvedAddr `protobuf:"bytes,2,opt,name=address" json:"address"`
	Attrs           Attributes          `protobuf:"bytes,3,opt,name=attrs" json:"attrs"`
	Locality        Locality            `protobuf:"bytes,4,opt,name=locality" json:"locality"`
	ServerVersion   Version             `protobuf:"bytes,5,opt,name=ServerVersion" json:"ServerVersion"`
	BuildTag        string              `protobuf:"bytes,6,opt,name=build_tag,json=buildTag" json:"build_tag"`
	StartedAt       int64               `protobuf:"varint,7,opt,name=started_at,json=startedAt" json:"started_at"`
	LocalityAddress []LocalityAddress   `protobuf:"bytes,8,rep,name=locality_address,json=localityAddress" json:"locality_address"`
	ClusterName     string              `protobuf:"bytes,9,opt,name=cluster_name,json=clusterName" json:"cluster_name"`
	// The SQL address. If empty, indicates that the base address field
	// is also used to accept SQL connections.
	SQLAddress util.UnresolvedAddr `protobuf:"bytes,10,opt,name=sql_address,json=sqlAddress" json:"sql_address"`
}

func (m *NodeDescriptor) Reset()         { *m = NodeDescriptor{} }
func (m *NodeDescriptor) String() string { return proto.CompactTextString(m) }
func (*NodeDescriptor) ProtoMessage()    {}
func (*NodeDescriptor) Descriptor() ([]byte, []int) {
	return fileDescriptor_metadata_4d08fb4df4010e8b, []int{7}
}
func (m *NodeDescriptor) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *NodeDescriptor) 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 *NodeDescriptor) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NodeDescriptor.Merge(dst, src)
}
func (m *NodeDescriptor) XXX_Size() int {
	return m.Size()
}
func (m *NodeDescriptor) XXX_DiscardUnknown() {
	xxx_messageInfo_NodeDescriptor.DiscardUnknown(m)
}

var xxx_messageInfo_NodeDescriptor proto.InternalMessageInfo

// LocalityAddress holds the private address accessible only from other nodes
// in the corresponding locality.
type LocalityAddress struct {
	Address      util.UnresolvedAddr `protobuf:"bytes,1,opt,name=address" json:"address"`
	LocalityTier Tier                `protobuf:"bytes,2,opt,name=locality_tier,json=localityTier" json:"locality_tier"`
}

func (m *LocalityAddress) Reset()         { *m = LocalityAddress{} }
func (m *LocalityAddress) String() string { return proto.CompactTextString(m) }
func (*LocalityAddress) ProtoMessage()    {}
func (*LocalityAddress) Descriptor() ([]byte, []int) {
	return fileDescriptor_metadata_4d08fb4df4010e8b, []int{8}
}
func (m *LocalityAddress) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LocalityAddress) 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 *LocalityAddress) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LocalityAddress.Merge(dst, src)
}
func (m *LocalityAddress) XXX_Size() int {
	return m.Size()
}
func (m *LocalityAddress) XXX_DiscardUnknown() {
	xxx_messageInfo_LocalityAddress.DiscardUnknown(m)
}

var xxx_messageInfo_LocalityAddress proto.InternalMessageInfo

// StoreDescriptor holds store information including store attributes, node
// descriptor and store capacity.
type StoreDescriptor struct {
	StoreID  StoreID        `protobuf:"varint,1,opt,name=store_id,json=storeId,casttype=StoreID" json:"store_id"`
	Attrs    Attributes     `protobuf:"bytes,2,opt,name=attrs" json:"attrs"`
	Node     NodeDescriptor `protobuf:"bytes,3,opt,name=node" json:"node"`
	Capacity StoreCapacity  `protobuf:"bytes,4,opt,name=capacity" json:"capacity"`
}

func (m *StoreDescriptor) Reset()         { *m = StoreDescriptor{} }
func (m *StoreDescriptor) String() string { return proto.CompactTextString(m) }
func (*StoreDescriptor) ProtoMessage()    {}
func (*StoreDescriptor) Descriptor() ([]byte, []int) {
	return fileDescriptor_metadata_4d08fb4df4010e8b, []int{9}
}
func (m *StoreDescriptor) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StoreDescriptor) 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 *StoreDescriptor) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StoreDescriptor.Merge(dst, src)
}
func (m *StoreDescriptor) XXX_Size() int {
	return m.Size()
}
func (m *StoreDescriptor) XXX_DiscardUnknown() {
	xxx_messageInfo_StoreDescriptor.DiscardUnknown(m)
}

var xxx_messageInfo_StoreDescriptor proto.InternalMessageInfo

// StoreDeadReplicas holds a storeID and a list of dead replicas on that store.
// Used to let the range lease holder know about corrupted or otherwise
// destroyed replicas that should be transferred to a different store.
type StoreDeadReplicas struct {
	StoreID  StoreID        `protobuf:"varint,1,opt,name=store_id,json=storeId,casttype=StoreID" json:"store_id"`
	Replicas []ReplicaIdent `protobuf:"bytes,2,rep,name=replicas" json:"replicas"`
}

func (m *StoreDeadReplicas) Reset()         { *m = StoreDeadReplicas{} }
func (m *StoreDeadReplicas) String() string { return proto.CompactTextString(m) }
func (*StoreDeadReplicas) ProtoMessage()    {}
func (*StoreDeadReplicas) Descriptor() ([]byte, []int) {
	return fileDescriptor_metadata_4d08fb4df4010e8b, []int{10}
}
func (m *StoreDeadReplicas) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StoreDeadReplicas) 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 *StoreDeadReplicas) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StoreDeadReplicas.Merge(dst, src)
}
func (m *StoreDeadReplicas) XXX_Size() int {
	return m.Size()
}
func (m *StoreDeadReplicas) XXX_DiscardUnknown() {
	xxx_messageInfo_StoreDeadReplicas.DiscardUnknown(m)
}

var xxx_messageInfo_StoreDeadReplicas proto.InternalMessageInfo

// Locality is an ordered set of key value Tiers that describe a node's
// location. The tier keys should be the same across all nodes.
type Locality struct {
	Tiers []Tier `protobuf:"bytes,1,rep,name=tiers" json:"tiers"`
}

func (m *Locality) Reset()      { *m = Locality{} }
func (*Locality) ProtoMessage() {}
func (*Locality) Descriptor() ([]byte, []int) {
	return fileDescriptor_metadata_4d08fb4df4010e8b, []int{11}
}
func (m *Locality) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Locality) 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 *Locality) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Locality.Merge(dst, src)
}
func (m *Locality) XXX_Size() int {
	return m.Size()
}
func (m *Locality) XXX_DiscardUnknown() {
	xxx_messageInfo_Locality.DiscardUnknown(m)
}

var xxx_messageInfo_Locality proto.InternalMessageInfo

// Tier represents one level of the locality hierarchy.
type Tier struct {
	// Key is the name of tier and should match all other nodes.
	Key string `protobuf:"bytes,1,opt,name=key" json:"key"`
	// Value is node specific value corresponding to the key.
	Value string `protobuf:"bytes,2,opt,name=value" json:"value"`
}

func (m *Tier) Reset()      { *m = Tier{} }
func (*Tier) ProtoMessage() {}
func (*Tier) Descriptor() ([]byte, []int) {
	return fileDescriptor_metadata_4d08fb4df4010e8b, []int{12}
}
func (m *Tier) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Tier) 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 *Tier) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Tier.Merge(dst, src)
}
func (m *Tier) XXX_Size() int {
	return m.Size()
}
func (m *Tier) XXX_DiscardUnknown() {
	xxx_messageInfo_Tier.DiscardUnknown(m)
}

var xxx_messageInfo_Tier proto.InternalMessageInfo

type Version struct {
	Major int32 `protobuf:"varint,1,opt,name=major_val,json=majorVal" json:"major_val"`
	Minor int32 `protobuf:"varint,2,opt,name=minor_val,json=minorVal" json:"minor_val"`
	// Note that patch is a placeholder and will always be zero.
	Patch int32 `protobuf:"varint,3,opt,name=patch" json:"patch"`
	// The unstable version is used to migrate during development.
	// Users of stable, public releases will only use binaries
	// with unstable set to 0.
	Unstable int32 `protobuf:"varint,4,opt,name=unstable" json:"unstable"`
}

func (m *Version) Reset()      { *m = Version{} }
func (*Version) ProtoMessage() {}
func (*Version) Descriptor() ([]byte, []int) {
	return fileDescriptor_metadata_4d08fb4df4010e8b, []int{13}
}
func (m *Version) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Version) 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 *Version) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Version.Merge(dst, src)
}
func (m *Version) XXX_Size() int {
	return m.Size()
}
func (m *Version) XXX_DiscardUnknown() {
	xxx_messageInfo_Version.DiscardUnknown(m)
}

var xxx_messageInfo_Version proto.InternalMessageInfo

func init() {
	proto.RegisterType((*Attributes)(nil), "cockroach.roachpb.Attributes")
	proto.RegisterType((*ReplicationTarget)(nil), "cockroach.roachpb.ReplicationTarget")
	proto.RegisterType((*ReplicaDescriptor)(nil), "cockroach.roachpb.ReplicaDescriptor")
	proto.RegisterType((*ReplicaIdent)(nil), "cockroach.roachpb.ReplicaIdent")
	proto.RegisterType((*RangeDescriptor)(nil), "cockroach.roachpb.RangeDescriptor")
	proto.RegisterType((*Percentiles)(nil), "cockroach.roachpb.Percentiles")
	proto.RegisterType((*StoreCapacity)(nil), "cockroach.roachpb.StoreCapacity")
	proto.RegisterType((*NodeDescriptor)(nil), "cockroach.roachpb.NodeDescriptor")
	proto.RegisterType((*LocalityAddress)(nil), "cockroach.roachpb.LocalityAddress")
	proto.RegisterType((*StoreDescriptor)(nil), "cockroach.roachpb.StoreDescriptor")
	proto.RegisterType((*StoreDeadReplicas)(nil), "cockroach.roachpb.StoreDeadReplicas")
	proto.RegisterType((*Locality)(nil), "cockroach.roachpb.Locality")
	proto.RegisterType((*Tier)(nil), "cockroach.roachpb.Tier")
	proto.RegisterType((*Version)(nil), "cockroach.roachpb.Version")
	proto.RegisterEnum("cockroach.roachpb.ReplicaType", ReplicaType_name, ReplicaType_value)
}
func (this *ReplicationTarget) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ReplicationTarget)
	if !ok {
		that2, ok := that.(ReplicationTarget)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.NodeID != that1.NodeID {
		return false
	}
	if this.StoreID != that1.StoreID {
		return false
	}
	return true
}
func (this *ReplicaDescriptor) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ReplicaDescriptor)
	if !ok {
		that2, ok := that.(ReplicaDescriptor)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.NodeID != that1.NodeID {
		return false
	}
	if this.StoreID != that1.StoreID {
		return false
	}
	if this.ReplicaID != that1.ReplicaID {
		return false
	}
	if this.Type != nil && that1.Type != nil {
		if *this.Type != *that1.Type {
			return false
		}
	} else if this.Type != nil {
		return false
	} else if that1.Type != nil {
		return false
	}
	return true
}
func (this *RangeDescriptor) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RangeDescriptor)
	if !ok {
		that2, ok := that.(RangeDescriptor)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.RangeID != that1.RangeID {
		return false
	}
	if !bytes.Equal(this.StartKey, that1.StartKey) {
		return false
	}
	if !bytes.Equal(this.EndKey, that1.EndKey) {
		return false
	}
	if len(this.InternalReplicas) != len(that1.InternalReplicas) {
		return false
	}
	for i := range this.InternalReplicas {
		if !this.InternalReplicas[i].Equal(&that1.InternalReplicas[i]) {
			return false
		}
	}
	if this.NextReplicaID != that1.NextReplicaID {
		return false
	}
	if this.Generation != that1.Generation {
		return false
	}
	if !this.StickyBit.Equal(that1.StickyBit) {
		return false
	}
	return true
}
func (m *Attributes) 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 *Attributes) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Attrs) > 0 {
		for _, s := range m.Attrs {
			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 *ReplicationTarget) 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 *ReplicationTarget) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.NodeID))
	dAtA[i] = 0x10
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.StoreID))
	return i, nil
}

func (m *ReplicaDescriptor) 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 *ReplicaDescriptor) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.NodeID))
	dAtA[i] = 0x10
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.StoreID))
	dAtA[i] = 0x18
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.ReplicaID))
	if m.Type != nil {
		dAtA[i] = 0x20
		i++
		i = encodeVarintMetadata(dAtA, i, uint64(*m.Type))
	}
	return i, nil
}

func (m *ReplicaIdent) 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 *ReplicaIdent) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.RangeID))
	dAtA[i] = 0x12
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.Replica.Size()))
	n1, err := m.Replica.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n1
	return i, nil
}

func (m *RangeDescriptor) 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 *RangeDescriptor) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.RangeID))
	if m.StartKey != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.StartKey)))
		i += copy(dAtA[i:], m.StartKey)
	}
	if m.EndKey != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.EndKey)))
		i += copy(dAtA[i:], m.EndKey)
	}
	if len(m.InternalReplicas) > 0 {
		for _, msg := range m.InternalReplicas {
			dAtA[i] = 0x22
			i++
			i = encodeVarintMetadata(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	dAtA[i] = 0x28
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.NextReplicaID))
	dAtA[i] = 0x30
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.Generation))
	if m.StickyBit != nil {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintMetadata(dAtA, i, uint64(m.StickyBit.Size()))
		n2, err := m.StickyBit.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	return i, nil
}

func (m *Percentiles) 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 *Percentiles) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x9
	i++
	encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.P10))))
	i += 8
	dAtA[i] = 0x11
	i++
	encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.P25))))
	i += 8
	dAtA[i] = 0x19
	i++
	encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.P50))))
	i += 8
	dAtA[i] = 0x21
	i++
	encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.P75))))
	i += 8
	dAtA[i] = 0x29
	i++
	encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.P90))))
	i += 8
	dAtA[i] = 0x31
	i++
	encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.PMax))))
	i += 8
	return i, nil
}

func (m *StoreCapacity) 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 *StoreCapacity) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.Capacity))
	dAtA[i] = 0x10
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.Available))
	dAtA[i] = 0x18
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.RangeCount))
	dAtA[i] = 0x20
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.LeaseCount))
	dAtA[i] = 0x29
	i++
	encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.WritesPerSecond))))
	i += 8
	dAtA[i] = 0x32
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.BytesPerReplica.Size()))
	n3, err := m.BytesPerReplica.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n3
	dAtA[i] = 0x3a
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.WritesPerReplica.Size()))
	n4, err := m.WritesPerReplica.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n4
	dAtA[i] = 0x40
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.Used))
	dAtA[i] = 0x48
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.LogicalBytes))
	dAtA[i] = 0x51
	i++
	encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.QueriesPerSecond))))
	i += 8
	return i, nil
}

func (m *NodeDescriptor) 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 *NodeDescriptor) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.NodeID))
	dAtA[i] = 0x12
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.Address.Size()))
	n5, err := m.Address.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n5
	dAtA[i] = 0x1a
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.Attrs.Size()))
	n6, err := m.Attrs.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n6
	dAtA[i] = 0x22
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.Locality.Size()))
	n7, err := m.Locality.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n7
	dAtA[i] = 0x2a
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.ServerVersion.Size()))
	n8, err := m.ServerVersion.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n8
	dAtA[i] = 0x32
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(len(m.BuildTag)))
	i += copy(dAtA[i:], m.BuildTag)
	dAtA[i] = 0x38
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.StartedAt))
	if len(m.LocalityAddress) > 0 {
		for _, msg := range m.LocalityAddress {
			dAtA[i] = 0x42
			i++
			i = encodeVarintMetadata(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	dAtA[i] = 0x4a
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(len(m.ClusterName)))
	i += copy(dAtA[i:], m.ClusterName)
	dAtA[i] = 0x52
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.SQLAddress.Size()))
	n9, err := m.SQLAddress.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n9
	return i, nil
}

func (m *LocalityAddress) 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 *LocalityAddress) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.Address.Size()))
	n10, err := m.Address.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n10
	dAtA[i] = 0x12
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.LocalityTier.Size()))
	n11, err := m.LocalityTier.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n11
	return i, nil
}

func (m *StoreDescriptor) 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 *StoreDescriptor) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.StoreID))
	dAtA[i] = 0x12
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.Attrs.Size()))
	n12, err := m.Attrs.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n12
	dAtA[i] = 0x1a
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.Node.Size()))
	n13, err := m.Node.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n13
	dAtA[i] = 0x22
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.Capacity.Size()))
	n14, err := m.Capacity.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n14
	return i, nil
}

func (m *StoreDeadReplicas) 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 *StoreDeadReplicas) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.StoreID))
	if len(m.Replicas) > 0 {
		for _, msg := range m.Replicas {
			dAtA[i] = 0x12
			i++
			i = encodeVarintMetadata(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func (m *Locality) 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 *Locality) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Tiers) > 0 {
		for _, msg := range m.Tiers {
			dAtA[i] = 0xa
			i++
			i = encodeVarintMetadata(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func (m *Tier) 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 *Tier) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(len(m.Key)))
	i += copy(dAtA[i:], m.Key)
	dAtA[i] = 0x12
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(len(m.Value)))
	i += copy(dAtA[i:], m.Value)
	return i, nil
}

func (m *Version) 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 *Version) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.Major))
	dAtA[i] = 0x10
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.Minor))
	dAtA[i] = 0x18
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.Patch))
	dAtA[i] = 0x20
	i++
	i = encodeVarintMetadata(dAtA, i, uint64(m.Unstable))
	return i, nil
}

func encodeVarintMetadata(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func NewPopulatedReplicaDescriptor(r randyMetadata, easy bool) *ReplicaDescriptor {
	this := &ReplicaDescriptor{}
	this.NodeID = NodeID(r.Int31())
	if r.Intn(2) == 0 {
		this.NodeID *= -1
	}
	this.StoreID = StoreID(r.Int31())
	if r.Intn(2) == 0 {
		this.StoreID *= -1
	}
	this.ReplicaID = ReplicaID(r.Int31())
	if r.Intn(2) == 0 {
		this.ReplicaID *= -1
	}
	if r.Intn(10) != 0 {
		v1 := ReplicaType([]int32{0, 2, 3, 4, 1}[r.Intn(5)])
		this.Type = &v1
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedRangeDescriptor(r randyMetadata, easy bool) *RangeDescriptor {
	this := &RangeDescriptor{}
	this.RangeID = RangeID(r.Int63())
	if r.Intn(2) == 0 {
		this.RangeID *= -1
	}
	if r.Intn(10) != 0 {
		v2 := r.Intn(100)
		this.StartKey = make(RKey, v2)
		for i := 0; i < v2; i++ {
			this.StartKey[i] = byte(r.Intn(256))
		}
	}
	if r.Intn(10) != 0 {
		v3 := r.Intn(100)
		this.EndKey = make(RKey, v3)
		for i := 0; i < v3; i++ {
			this.EndKey[i] = byte(r.Intn(256))
		}
	}
	if r.Intn(10) != 0 {
		v4 := r.Intn(5)
		this.InternalReplicas = make([]ReplicaDescriptor, v4)
		for i := 0; i < v4; i++ {
			v5 := NewPopulatedReplicaDescriptor(r, easy)
			this.InternalReplicas[i] = *v5
		}
	}
	this.NextReplicaID = ReplicaID(r.Int31())
	if r.Intn(2) == 0 {
		this.NextReplicaID *= -1
	}
	this.Generation = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.Generation *= -1
	}
	if r.Intn(10) != 0 {
		this.StickyBit = hlc.NewPopulatedTimestamp(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

type randyMetadata interface {
	Float32() float32
	Float64() float64
	Int63() int64
	Int31() int32
	Uint32() uint32
	Intn(n int) int
}

func randUTF8RuneMetadata(r randyMetadata) rune {
	ru := r.Intn(62)
	if ru < 10 {
		return rune(ru + 48)
	} else if ru < 36 {
		return rune(ru + 55)
	}
	return rune(ru + 61)
}
func randStringMetadata(r randyMetadata) string {
	v6 := r.Intn(100)
	tmps := make([]rune, v6)
	for i := 0; i < v6; i++ {
		tmps[i] = randUTF8RuneMetadata(r)
	}
	return string(tmps)
}
func randUnrecognizedMetadata(r randyMetadata, maxFieldNumber int) (dAtA []byte) {
	l := r.Intn(5)
	for i := 0; i < l; i++ {
		wire := r.Intn(4)
		if wire == 3 {
			wire = 5
		}
		fieldNumber := maxFieldNumber + r.Intn(100)
		dAtA = randFieldMetadata(dAtA, r, fieldNumber, wire)
	}
	return dAtA
}
func randFieldMetadata(dAtA []byte, r randyMetadata, fieldNumber int, wire int) []byte {
	key := uint32(fieldNumber)<<3 | uint32(wire)
	switch wire {
	case 0:
		dAtA = encodeVarintPopulateMetadata(dAtA, uint64(key))
		v7 := r.Int63()
		if r.Intn(2) == 0 {
			v7 *= -1
		}
		dAtA = encodeVarintPopulateMetadata(dAtA, uint64(v7))
	case 1:
		dAtA = encodeVarintPopulateMetadata(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	case 2:
		dAtA = encodeVarintPopulateMetadata(dAtA, uint64(key))
		ll := r.Intn(100)
		dAtA = encodeVarintPopulateMetadata(dAtA, uint64(ll))
		for j := 0; j < ll; j++ {
			dAtA = append(dAtA, byte(r.Intn(256)))
		}
	default:
		dAtA = encodeVarintPopulateMetadata(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	}
	return dAtA
}
func encodeVarintPopulateMetadata(dAtA []byte, v uint64) []byte {
	for v >= 1<<7 {
		dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
		v >>= 7
	}
	dAtA = append(dAtA, uint8(v))
	return dAtA
}
func (m *Attributes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Attrs) > 0 {
		for _, s := range m.Attrs {
			l = len(s)
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	return n
}

func (m *ReplicationTarget) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovMetadata(uint64(m.NodeID))
	n += 1 + sovMetadata(uint64(m.StoreID))
	return n
}

func (m *ReplicaDescriptor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovMetadata(uint64(m.NodeID))
	n += 1 + sovMetadata(uint64(m.StoreID))
	n += 1 + sovMetadata(uint64(m.ReplicaID))
	if m.Type != nil {
		n += 1 + sovMetadata(uint64(*m.Type))
	}
	return n
}

func (m *ReplicaIdent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovMetadata(uint64(m.RangeID))
	l = m.Replica.Size()
	n += 1 + l + sovMetadata(uint64(l))
	return n
}

func (m *RangeDescriptor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovMetadata(uint64(m.RangeID))
	if m.StartKey != nil {
		l = len(m.StartKey)
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.EndKey != nil {
		l = len(m.EndKey)
		n += 1 + l + sovMetadata(uint64(l))
	}
	if len(m.InternalReplicas) > 0 {
		for _, e := range m.InternalReplicas {
			l = e.Size()
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	n += 1 + sovMetadata(uint64(m.NextReplicaID))
	n += 1 + sovMetadata(uint64(m.Generation))
	if m.StickyBit != nil {
		l = m.StickyBit.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}

func (m *Percentiles) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 9
	n += 9
	n += 9
	n += 9
	n += 9
	n += 9
	return n
}

func (m *StoreCapacity) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovMetadata(uint64(m.Capacity))
	n += 1 + sovMetadata(uint64(m.Available))
	n += 1 + sovMetadata(uint64(m.RangeCount))
	n += 1 + sovMetadata(uint64(m.LeaseCount))
	n += 9
	l = m.BytesPerReplica.Size()
	n += 1 + l + sovMetadata(uint64(l))
	l = m.WritesPerReplica.Size()
	n += 1 + l + sovMetadata(uint64(l))
	n += 1 + sovMetadata(uint64(m.Used))
	n += 1 + sovMetadata(uint64(m.LogicalBytes))
	n += 9
	return n
}

func (m *NodeDescriptor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovMetadata(uint64(m.NodeID))
	l = m.Address.Size()
	n += 1 + l + sovMetadata(uint64(l))
	l = m.Attrs.Size()
	n += 1 + l + sovMetadata(uint64(l))
	l = m.Locality.Size()
	n += 1 + l + sovMetadata(uint64(l))
	l = m.ServerVersion.Size()
	n += 1 + l + sovMetadata(uint64(l))
	l = len(m.BuildTag)
	n += 1 + l + sovMetadata(uint64(l))
	n += 1 + sovMetadata(uint64(m.StartedAt))
	if len(m.LocalityAddress) > 0 {
		for _, e := range m.LocalityAddress {
			l = e.Size()
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	l = len(m.ClusterName)
	n += 1 + l + sovMetadata(uint64(l))
	l = m.SQLAddress.Size()
	n += 1 + l + sovMetadata(uint64(l))
	return n
}

func (m *LocalityAddress) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Address.Size()
	n += 1 + l + sovMetadata(uint64(l))
	l = m.LocalityTier.Size()
	n += 1 + l + sovMetadata(uint64(l))
	return n
}

func (m *StoreDescriptor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovMetadata(uint64(m.StoreID))
	l = m.Attrs.Size()
	n += 1 + l + sovMetadata(uint64(l))
	l = m.Node.Size()
	n += 1 + l + sovMetadata(uint64(l))
	l = m.Capacity.Size()
	n += 1 + l + sovMetadata(uint64(l))
	return n
}

func (m *StoreDeadReplicas) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovMetadata(uint64(m.StoreID))
	if len(m.Replicas) > 0 {
		for _, e := range m.Replicas {
			l = e.Size()
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	return n
}

func (m *Locality) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Tiers) > 0 {
		for _, e := range m.Tiers {
			l = e.Size()
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	return n
}

func (m *Tier) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	n += 1 + l + sovMetadata(uint64(l))
	l = len(m.Value)
	n += 1 + l + sovMetadata(uint64(l))
	return n
}

func (m *Version) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovMetadata(uint64(m.Major))
	n += 1 + sovMetadata(uint64(m.Minor))
	n += 1 + sovMetadata(uint64(m.Patch))
	n += 1 + sovMetadata(uint64(m.Unstable))
	return n
}

func sovMetadata(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozMetadata(x uint64) (n int) {
	return sovMetadata(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Attributes) 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 ErrIntOverflowMetadata
			}
			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: Attributes: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Attributes: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Attrs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				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 ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Attrs = append(m.Attrs, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ReplicationTarget) 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 ErrIntOverflowMetadata
			}
			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: ReplicationTarget: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReplicationTarget: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeID", wireType)
			}
			m.NodeID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NodeID |= (NodeID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StoreID", wireType)
			}
			m.StoreID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StoreID |= (StoreID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ReplicaDescriptor) 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 ErrIntOverflowMetadata
			}
			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: ReplicaDescriptor: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReplicaDescriptor: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeID", wireType)
			}
			m.NodeID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NodeID |= (NodeID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StoreID", wireType)
			}
			m.StoreID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StoreID |= (StoreID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReplicaID", wireType)
			}
			m.ReplicaID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ReplicaID |= (ReplicaID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var v ReplicaType
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (ReplicaType(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Type = &v
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ReplicaIdent) 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 ErrIntOverflowMetadata
			}
			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: ReplicaIdent: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReplicaIdent: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RangeID", wireType)
			}
			m.RangeID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RangeID |= (RangeID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Replica", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Replica.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RangeDescriptor) 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 ErrIntOverflowMetadata
			}
			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: RangeDescriptor: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RangeDescriptor: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RangeID", wireType)
			}
			m.RangeID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RangeID |= (RangeID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...)
			if m.StartKey == nil {
				m.StartKey = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...)
			if m.EndKey == nil {
				m.EndKey = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InternalReplicas", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InternalReplicas = append(m.InternalReplicas, ReplicaDescriptor{})
			if err := m.InternalReplicas[len(m.InternalReplicas)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NextReplicaID", wireType)
			}
			m.NextReplicaID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NextReplicaID |= (ReplicaID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Generation", wireType)
			}
			m.Generation = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Generation |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StickyBit", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StickyBit == nil {
				m.StickyBit = &hlc.Timestamp{}
			}
			if err := m.StickyBit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Percentiles) 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 ErrIntOverflowMetadata
			}
			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: Percentiles: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Percentiles: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field P10", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.P10 = float64(math.Float64frombits(v))
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field P25", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.P25 = float64(math.Float64frombits(v))
		case 3:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field P50", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.P50 = float64(math.Float64frombits(v))
		case 4:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field P75", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.P75 = float64(math.Float64frombits(v))
		case 5:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field P90", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.P90 = float64(math.Float64frombits(v))
		case 6:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field PMax", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.PMax = float64(math.Float64frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StoreCapacity) 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 ErrIntOverflowMetadata
			}
			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: StoreCapacity: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StoreCapacity: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Capacity", wireType)
			}
			m.Capacity = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Capacity |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Available", wireType)
			}
			m.Available = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Available |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RangeCount", wireType)
			}
			m.RangeCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RangeCount |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LeaseCount", wireType)
			}
			m.LeaseCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LeaseCount |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field WritesPerSecond", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.WritesPerSecond = float64(math.Float64frombits(v))
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BytesPerReplica", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.BytesPerReplica.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WritesPerReplica", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.WritesPerReplica.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Used", wireType)
			}
			m.Used = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Used |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LogicalBytes", wireType)
			}
			m.LogicalBytes = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LogicalBytes |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueriesPerSecond", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.QueriesPerSecond = float64(math.Float64frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NodeDescriptor) 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 ErrIntOverflowMetadata
			}
			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: NodeDescriptor: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NodeDescriptor: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeID", wireType)
			}
			m.NodeID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NodeID |= (NodeID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Attrs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Attrs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Locality", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Locality.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServerVersion", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ServerVersion.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BuildTag", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				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 ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BuildTag = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartedAt", wireType)
			}
			m.StartedAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartedAt |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LocalityAddress", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LocalityAddress = append(m.LocalityAddress, LocalityAddress{})
			if err := m.LocalityAddress[len(m.LocalityAddress)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				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 ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ClusterName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SQLAddress", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.SQLAddress.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LocalityAddress) 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 ErrIntOverflowMetadata
			}
			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: LocalityAddress: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LocalityAddress: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LocalityTier", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.LocalityTier.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StoreDescriptor) 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 ErrIntOverflowMetadata
			}
			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: StoreDescriptor: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StoreDescriptor: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StoreID", wireType)
			}
			m.StoreID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StoreID |= (StoreID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Attrs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Attrs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Node", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Node.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Capacity", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Capacity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StoreDeadReplicas) 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 ErrIntOverflowMetadata
			}
			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: StoreDeadReplicas: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StoreDeadReplicas: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StoreID", wireType)
			}
			m.StoreID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StoreID |= (StoreID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Replicas = append(m.Replicas, ReplicaIdent{})
			if err := m.Replicas[len(m.Replicas)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Locality) 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 ErrIntOverflowMetadata
			}
			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: Locality: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Locality: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tiers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tiers = append(m.Tiers, Tier{})
			if err := m.Tiers[len(m.Tiers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Tier) 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 ErrIntOverflowMetadata
			}
			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: Tier: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Tier: 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 ErrIntOverflowMetadata
				}
				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 ErrInvalidLengthMetadata
			}
			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 Value", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				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 ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Version) 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 ErrIntOverflowMetadata
			}
			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: Version: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Version: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Major", wireType)
			}
			m.Major = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Major |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Minor", wireType)
			}
			m.Minor = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Minor |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Patch", wireType)
			}
			m.Patch = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Patch |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Unstable", wireType)
			}
			m.Unstable = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Unstable |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipMetadata(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			iNdEx += length
			if length < 0 {
				return 0, ErrInvalidLengthMetadata
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowMetadata
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipMetadata(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthMetadata = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowMetadata   = fmt.Errorf("proto: integer overflow")
)

func init() { proto.RegisterFile("roachpb/metadata.proto", fileDescriptor_metadata_4d08fb4df4010e8b) }

var fileDescriptor_metadata_4d08fb4df4010e8b = []byte{
	// 1385 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x56, 0xcf, 0x6f, 0x1b, 0x45,
	0x14, 0xf6, 0xc6, 0xeb, 0x78, 0xfd, 0x9c, 0x1f, 0xf6, 0x08, 0x8a, 0x65, 0x84, 0x9d, 0x2e, 0xad,
	0x68, 0x0b, 0x4a, 0xd2, 0xa0, 0xa8, 0x6a, 0xa0, 0x40, 0xdc, 0xa4, 0x95, 0xdb, 0xfc, 0x62, 0xe3,
	0x16, 0x89, 0xcb, 0x6a, 0xb2, 0x3b, 0x38, 0x4b, 0xd7, 0xbb, 0xee, 0xec, 0x38, 0xad, 0xef, 0x48,
	0x20, 0x21, 0x24, 0x2e, 0x48, 0x1c, 0x2b, 0xa1, 0x9e, 0xb9, 0xf2, 0x27, 0xf4, 0xd8, 0x63, 0x4f,
	0x51, 0x49, 0x2f, 0x9c, 0x39, 0xf6, 0x80, 0xd0, 0xcc, 0xce, 0xec, 0xae, 0x53, 0x17, 0xda, 0x20,
	0x71, 0x9b, 0xfd, 0xde, 0xf7, 0xbd, 0x7d, 0xf3, 0xe6, 0xcd, 0x7b, 0x03, 0xa7, 0x68, 0x88, 0x9d,
	0xfd, 0xfe, 0xde, 0x42, 0x8f, 0x30, 0xec, 0x62, 0x86, 0xe7, 0xfb, 0x34, 0x64, 0x21, 0xaa, 0x3a,
	0xa1, 0x73, 0x47, 0xd8, 0xe6, 0x25, 0xa3, 0x5e, 0x1f, 0x30, 0xcf, 0x5f, 0x18, 0x04, 0x94, 0x44,
	0xa1, 0x7f, 0x40, 0x5c, 0x1b, 0xbb, 0x2e, 0x8d, 0xe9, 0xf5, 0x9a, 0xb0, 0xed, 0xfb, 0xce, 0x02,
	0xf3, 0x7a, 0x24, 0x62, 0xb8, 0xd7, 0x97, 0x96, 0x37, 0xba, 0x61, 0x37, 0x14, 0xcb, 0x05, 0xbe,
	0x8a, 0x51, 0xf3, 0x53, 0x80, 0x55, 0xc6, 0xa8, 0xb7, 0x37, 0x60, 0x24, 0x42, 0xef, 0x43, 0x01,
	0x33, 0x46, 0xa3, 0x9a, 0x36, 0x97, 0x3f, 0x57, 0x6a, 0xbd, 0xf9, 0xe7, 0x61, 0xb3, 0x3a, 0xc4,
	0x3d, 0x7f, 0xc5, 0x14, 0xf0, 0x07, 0x5f, 0xf9, 0xe1, 0x3d, 0xd3, 0x8a, 0x39, 0x2b, 0xfa, 0xcf,
	0x0f, 0x9a, 0x39, 0xf3, 0x5b, 0x0d, 0xaa, 0x16, 0xe9, 0xfb, 0x9e, 0x83, 0x99, 0x17, 0x06, 0x1d,
	0x4c, 0xbb, 0x84, 0xa1, 0x8b, 0x50, 0x0c, 0x42, 0x97, 0xd8, 0x9e, 0x5b, 0xd3, 0xe6, 0xb4, 0x73,
	0x85, 0x56, 0xed, 0xd1, 0x61, 0x33, 0x77, 0x74, 0xd8, 0x9c, 0xdc, 0x0a, 0x5d, 0xd2, 0x5e, 0x7b,
	0x9e, 0xac, 0xac, 0x49, 0x4e, 0x6c, 0xbb, 0x68, 0x19, 0x8c, 0x88, 0x85, 0x54, 0x68, 0x26, 0x84,
	0xa6, 0x2e, 0x35, 0xc5, 0x5d, 0x8e, 0x0b, 0x91, 0x5a, 0x5a, 0x45, 0xc1, 0x6d, 0xbb, 0x2b, 0x06,
	0x8f, 0xe2, 0x8f, 0x07, 0x4d, 0xcd, 0xfc, 0x2b, 0x8d, 0x64, 0x8d, 0x44, 0x0e, 0xf5, 0xfa, 0x2c,
	0xa4, 0xff, 0x5f, 0x24, 0xe8, 0x0a, 0x00, 0x8d, 0x7f, 0xcf, 0x85, 0x79, 0x21, 0x6c, 0x48, 0x61,
	0x49, 0x06, 0x26, 0xa4, 0xe9, 0x87, 0x55, 0x92, 0x8a, 0xb6, 0x8b, 0x96, 0x40, 0x67, 0xc3, 0x3e,
	0xa9, 0xe9, 0x73, 0xda, 0xb9, 0x99, 0xa5, 0xc6, 0xfc, 0x0b, 0xe7, 0x3e, 0x2f, 0x65, 0x9d, 0x61,
	0x9f, 0x58, 0x82, 0xbb, 0x32, 0xc5, 0x37, 0xff, 0xdb, 0x83, 0xa6, 0x26, 0x12, 0xf0, 0xbd, 0x06,
	0x53, 0xca, 0xb5, 0x4b, 0x02, 0xc6, 0x37, 0x42, 0x71, 0xd0, 0x4d, 0x36, 0x9f, 0x4f, 0x37, 0x62,
	0x71, 0x3c, 0xde, 0x88, 0x5c, 0x5a, 0x45, 0xc1, 0x6d, 0xbb, 0x68, 0x0d, 0x8a, 0x32, 0x2c, 0xb1,
	0xfd, 0xf2, 0xd2, 0x99, 0x97, 0x07, 0x93, 0x66, 0xba, 0xa5, 0x73, 0xdf, 0x96, 0x92, 0x9a, 0xbf,
	0xe6, 0x61, 0x56, 0xb8, 0xce, 0x1c, 0xc6, 0x09, 0x03, 0x3a, 0x0b, 0xa5, 0x88, 0x61, 0xca, 0xec,
	0x3b, 0x64, 0x28, 0x42, 0x9a, 0x6a, 0x19, 0xcf, 0x0f, 0x9b, 0xba, 0x75, 0x93, 0x0c, 0x2d, 0x43,
	0x98, 0x6e, 0x92, 0x21, 0x3a, 0x0d, 0x45, 0x12, 0xb8, 0x82, 0x94, 0x3f, 0x46, 0x9a, 0x24, 0x81,
	0xcb, 0x29, 0x5f, 0x40, 0xd5, 0x0b, 0x18, 0xa1, 0x01, 0xf6, 0x6d, 0x19, 0x68, 0x54, 0xd3, 0xe7,
	0xf2, 0xaf, 0xb9, 0xc9, 0x8a, 0x72, 0x22, 0x09, 0x11, 0xba, 0x01, 0xb3, 0x01, 0xb9, 0xcf, 0xec,
	0x4c, 0x05, 0x14, 0x44, 0x05, 0x98, 0x72, 0x83, 0xd3, 0x5b, 0xe4, 0x3e, 0x7b, 0x49, 0x15, 0x4c,
	0x07, 0x19, 0x9b, 0x8b, 0xce, 0x00, 0x74, 0x49, 0x40, 0xa8, 0xb8, 0x50, 0xb5, 0x49, 0x91, 0xa7,
	0xf8, 0xbf, 0x19, 0x1c, 0x7d, 0x0c, 0x10, 0x31, 0xcf, 0xb9, 0x33, 0xb4, 0xf7, 0x3c, 0x56, 0x2b,
	0x8a, 0x83, 0x7a, 0x27, 0xb3, 0x07, 0xde, 0x08, 0xe6, 0xf7, 0x7d, 0x67, 0xbe, 0xa3, 0x1a, 0x81,
	0x55, 0x8a, 0x05, 0x2d, 0x8f, 0x8d, 0x56, 0xce, 0x0d, 0xdd, 0x30, 0x2a, 0x25, 0xf3, 0xa1, 0x06,
	0xe5, 0x1d, 0x42, 0x1d, 0x12, 0x30, 0xcf, 0x27, 0x11, 0x3a, 0x05, 0xf9, 0xfe, 0xc5, 0x45, 0x71,
	0x50, 0x9a, 0x0c, 0x80, 0x03, 0x02, 0x5f, 0x5a, 0x16, 0x07, 0x91, 0xe2, 0x4b, 0xcb, 0x02, 0x5f,
	0x5e, 0x14, 0xb9, 0x4f, 0xf1, 0xe5, 0x98, 0x7f, 0x69, 0x59, 0x14, 0x76, 0x8a, 0x5f, 0x8a, 0xf9,
	0x97, 0x17, 0x45, 0x9e, 0x52, 0xfc, 0xf2, 0x22, 0xaa, 0x81, 0xde, 0xdf, 0xc4, 0xf7, 0xc5, 0xce,
	0x95, 0x41, 0x20, 0xb2, 0xe5, 0x3c, 0xcf, 0xc3, 0xb4, 0xb8, 0x7d, 0x57, 0x71, 0x1f, 0x3b, 0x1e,
	0x1b, 0xa2, 0x39, 0x30, 0x1c, 0xb9, 0x96, 0x75, 0x15, 0xab, 0x12, 0x14, 0x99, 0x50, 0xc2, 0x07,
	0xd8, 0xf3, 0xf1, 0x9e, 0x4f, 0x44, 0xe4, 0x8a, 0x92, 0xc2, 0xe8, 0x2c, 0x94, 0xe3, 0xea, 0x74,
	0xc2, 0x41, 0xc0, 0xe4, 0x0d, 0x96, 0x89, 0x17, 0x86, 0xab, 0x1c, 0xe7, 0x34, 0x9f, 0xe0, 0x48,
	0xd1, 0xf4, 0x2c, 0x4d, 0x18, 0x62, 0xda, 0x22, 0x54, 0xef, 0x51, 0x8f, 0x91, 0xc8, 0xee, 0x13,
	0x6a, 0x47, 0xc4, 0x09, 0x03, 0x77, 0x64, 0xaf, 0xb3, 0xb1, 0x79, 0x87, 0xd0, 0x5d, 0x61, 0x44,
	0x3b, 0x50, 0xdd, 0x1b, 0x2a, 0x81, 0xba, 0x81, 0x93, 0xe2, 0x60, 0xc7, 0xb5, 0x83, 0xcc, 0x51,
	0x29, 0x8f, 0x42, 0xbe, 0x43, 0xa8, 0xac, 0x25, 0x64, 0x01, 0xca, 0xc4, 0xa0, 0x5c, 0x16, 0x5f,
	0xc3, 0x65, 0x25, 0x09, 0x52, 0xf9, 0xac, 0x81, 0x3e, 0x88, 0x88, 0x5b, 0x33, 0x32, 0x49, 0x14,
	0x08, 0x3a, 0x0f, 0xd3, 0x7e, 0xd8, 0xf5, 0x1c, 0xec, 0xdb, 0x22, 0x90, 0x5a, 0x29, 0x43, 0x99,
	0x92, 0xa6, 0x16, 0xb7, 0xa0, 0x25, 0x40, 0x77, 0x07, 0x84, 0x7a, 0xa3, 0xd9, 0x81, 0x4c, 0x76,
	0x2a, 0xd2, 0x9e, 0xa4, 0x47, 0x1e, 0xfe, 0x53, 0x1d, 0x66, 0x78, 0xbf, 0xfe, 0x6f, 0x2d, 0xfe,
	0x13, 0x28, 0xf2, 0xa1, 0x49, 0xa2, 0x48, 0xb6, 0xb8, 0xc6, 0xf1, 0x9b, 0x73, 0x2b, 0x19, 0xaf,
	0xab, 0xae, 0x9b, 0x34, 0x37, 0x29, 0x42, 0x97, 0xd5, 0xa0, 0xcc, 0xbf, 0x70, 0xef, 0x54, 0x2e,
	0xd3, 0xb1, 0x2a, 0xc5, 0xb1, 0x02, 0x5d, 0x01, 0xc3, 0x0f, 0x1d, 0xec, 0xf3, 0x5a, 0xd5, 0x85,
	0xfa, 0xed, 0x31, 0xea, 0x0d, 0x49, 0x51, 0x85, 0xac, 0x24, 0xe8, 0x1a, 0x4c, 0xef, 0x12, 0x7a,
	0x40, 0xe8, 0x6d, 0x42, 0x23, 0xde, 0x1f, 0x0a, 0xc2, 0x47, 0x7d, 0x8c, 0x0f, 0xc9, 0x90, 0x2e,
	0x46, 0x65, 0xe8, 0x34, 0x94, 0xf6, 0x06, 0x9e, 0xef, 0xda, 0x0c, 0x77, 0x45, 0x91, 0x95, 0xd4,
	0xaf, 0x04, 0xdc, 0xc1, 0x5d, 0xf4, 0x2e, 0xef, 0x30, 0x98, 0x32, 0xfe, 0xc2, 0x88, 0x3b, 0x4c,
	0x72, 0x69, 0x24, 0xbe, 0xca, 0xd0, 0x2e, 0x54, 0x54, 0x6c, 0xb6, 0x4a, 0xa9, 0x21, 0x1a, 0xaa,
	0xf9, 0x0f, 0xdb, 0x5a, 0x8d, 0x99, 0xaa, 0x6e, 0xfd, 0x51, 0x18, 0xbd, 0x07, 0x53, 0x8e, 0x3f,
	0x88, 0x18, 0xa1, 0x76, 0x80, 0x7b, 0x44, 0x14, 0x92, 0x8a, 0xaf, 0x2c, 0x2d, 0x5b, 0xb8, 0x47,
	0xd0, 0x2e, 0x94, 0xa3, 0xbb, 0x7e, 0xf2, 0x63, 0x78, 0xa5, 0xb3, 0x44, 0xb2, 0x3c, 0x60, 0xf7,
	0xf3, 0x0d, 0xf9, 0x47, 0x0b, 0xa2, 0xbb, 0xbe, 0x5c, 0x9b, 0x3f, 0x69, 0x30, 0x7b, 0x2c, 0xd0,
	0x6c, 0xc1, 0x68, 0x27, 0x29, 0x98, 0x16, 0xbf, 0x1b, 0x32, 0x4d, 0xcc, 0x23, 0x54, 0x96, 0xdd,
	0x5b, 0x63, 0x72, 0xd4, 0xf1, 0x08, 0x4d, 0x2f, 0x4d, 0xac, 0xe1, 0x98, 0xf9, 0xcd, 0x04, 0xcc,
	0x8a, 0xbe, 0x37, 0x3a, 0x51, 0x93, 0xb7, 0x8a, 0xf6, 0xea, 0x6f, 0x95, 0xa4, 0x7e, 0x27, 0x5e,
	0xbb, 0x7e, 0x3f, 0x02, 0x9d, 0x5f, 0x22, 0x59, 0xf9, 0xa7, 0xc7, 0x28, 0x47, 0xaf, 0xa7, 0x6a,
	0x11, 0x5c, 0x84, 0x5a, 0x99, 0x46, 0x1d, 0x17, 0xff, 0xdc, 0x18, 0x07, 0x23, 0xcd, 0xfd, 0x78,
	0x2b, 0x37, 0x7f, 0xd0, 0xa0, 0x2a, 0xd3, 0x80, 0xdd, 0x64, 0x00, 0x9f, 0x30, 0x11, 0xab, 0x60,
	0x24, 0xef, 0x80, 0x09, 0x51, 0xb6, 0xcd, 0x97, 0xbf, 0x03, 0xc4, 0xab, 0x4a, 0xc5, 0xa3, 0x64,
	0xe6, 0x3a, 0x18, 0xaa, 0x5a, 0xd0, 0x87, 0x50, 0xe0, 0xa7, 0x1b, 0x3f, 0xa0, 0xff, 0xf5, 0x78,
	0x63, 0xae, 0x6c, 0x6c, 0x9f, 0x81, 0xce, 0x4d, 0x7c, 0x2a, 0xf2, 0x17, 0x8c, 0x96, 0x29, 0x79,
	0x0e, 0xa0, 0x3a, 0x14, 0x0e, 0xb0, 0x3f, 0x88, 0xa7, 0x97, 0xb2, 0xc4, 0x90, 0xf4, 0xf0, 0x50,
	0x83, 0xa2, 0xba, 0xde, 0x17, 0xa0, 0xd4, 0xc3, 0x5f, 0x87, 0xd4, 0x3e, 0xc0, 0xbe, 0xcc, 0xc7,
	0xb4, 0xcc, 0x47, 0x61, 0x93, 0x1b, 0x2c, 0x43, 0xd8, 0x6f, 0x63, 0x5f, 0x70, 0xbd, 0x40, 0x72,
	0x27, 0x8e, 0x71, 0xb9, 0xc1, 0x32, 0x84, 0x9d, 0x73, 0xeb, 0x50, 0xe8, 0x63, 0xe6, 0xec, 0x8f,
	0x4c, 0xc7, 0x18, 0xe2, 0x53, 0x78, 0x10, 0x44, 0x4c, 0x8c, 0xd8, 0xec, 0x54, 0x4c, 0xd0, 0x38,
	0xce, 0x0b, 0x3e, 0x94, 0x33, 0x4f, 0x59, 0x34, 0x03, 0x70, 0x7b, 0xbb, 0xb3, 0x6e, 0xd9, 0xd7,
	0x6e, 0x6d, 0x6c, 0x54, 0x72, 0x08, 0xc1, 0x4c, 0xfc, 0xdd, 0xde, 0xba, 0xba, 0xbd, 0xd9, 0xde,
	0xba, 0x5e, 0x99, 0x48, 0xb1, 0xed, 0x5b, 0x9d, 0xeb, 0xdb, 0x1c, 0xcb, 0xa7, 0xd8, 0xda, 0xfa,
	0xe6, 0x76, 0x87, 0x63, 0x3a, 0x2a, 0x43, 0x71, 0x63, 0x7d, 0xd5, 0xda, 0x5a, 0xb7, 0x2a, 0x5a,
	0x5d, 0xff, 0xee, 0x97, 0x46, 0xae, 0x75, 0xfe, 0xd1, 0xef, 0x8d, 0xdc, 0xa3, 0xa3, 0x86, 0xf6,
	0xf8, 0xa8, 0xa1, 0x3d, 0x39, 0x6a, 0x68, 0x4f, 0x8f, 0x1a, 0xda, 0x8f, 0xcf, 0x1a, 0xb9, 0xc7,
	0xcf, 0x1a, 0xb9, 0x27, 0xcf, 0x1a, 0xb9, 0x2f, 0x8b, 0xf2, 0x68, 0xfe, 0x0e, 0x00, 0x00, 0xff,
	0xff, 0x6e, 0xce, 0xc8, 0xc3, 0x84, 0x0d, 0x00, 0x00,
}