Initial commit

vendor/github.com/tsuna/gohbase/pb/Admin.proto

@@ -0,0 +1,310 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// This file contains protocol buffers that are used for Admin service.
+package pb;
+
+option java_package = "org.apache.hadoop.hbase.protobuf.generated";
+option java_outer_classname = "AdminProtos";
+option java_generic_services = true;
+option java_generate_equals_and_hash = true;
+option optimize_for = SPEED;
+
+//import "Client.proto";
+import "HBase.proto";
+import "WAL.proto";
+
+message GetRegionInfoRequest {
+  required RegionSpecifier region = 1;
+  optional bool compaction_state = 2;
+}
+
+message GetRegionInfoResponse {
+  required RegionInfo region_info = 1;
+  optional CompactionState compaction_state = 2;
+  optional bool isRecovering = 3;
+
+  enum CompactionState {
+    NONE = 0;
+    MINOR = 1;
+    MAJOR = 2;
+    MAJOR_AND_MINOR = 3;
+  }
+}
+
+/**
+ * Get a list of store files for a set of column families in a particular region.
+ * If no column family is specified, get the store files for all column families.
+ */
+message GetStoreFileRequest {
+  required RegionSpecifier region = 1;
+  repeated bytes family = 2;
+}
+
+message GetStoreFileResponse {
+  repeated string store_file = 1;
+}
+
+message GetOnlineRegionRequest {
+}
+
+message GetOnlineRegionResponse {
+  repeated RegionInfo region_info = 1;
+}
+
+message OpenRegionRequest {
+  repeated RegionOpenInfo open_info = 1;
+  // the intended server for this RPC.
+  optional uint64 serverStartCode = 2;
+  // wall clock time from master
+  optional uint64 master_system_time = 5;
+
+  message RegionOpenInfo {
+    required RegionInfo region = 1;
+    optional uint32 version_of_offline_node = 2;
+    repeated ServerName favored_nodes = 3;
+    // open region for distributedLogReplay
+    optional bool openForDistributedLogReplay = 4;
+  }
+}
+
+message OpenRegionResponse {
+  repeated RegionOpeningState opening_state = 1;
+
+  enum RegionOpeningState {
+    OPENED = 0;
+    ALREADY_OPENED = 1;
+    FAILED_OPENING = 2;
+  }
+}
+
+message WarmupRegionRequest {
+
+    required RegionInfo regionInfo = 1;
+}
+
+message WarmupRegionResponse {
+}
+
+/**
+ * Closes the specified region and will use or not use ZK during the close
+ * according to the specified flag.
+ */
+message CloseRegionRequest {
+  required RegionSpecifier region = 1;
+  optional uint32 version_of_closing_node = 2;
+  optional bool transition_in_ZK = 3 [default = true];
+  optional ServerName destination_server = 4;
+  // the intended server for this RPC.
+  optional uint64 serverStartCode = 5;
+}
+
+message CloseRegionResponse {
+  required bool closed = 1;
+}
+
+/**
+ * Flushes the MemStore of the specified region.
+ * <p>
+ * This method is synchronous.
+ */
+message FlushRegionRequest {
+  required RegionSpecifier region = 1;
+  optional uint64 if_older_than_ts = 2;
+  optional bool write_flush_wal_marker = 3; // whether to write a marker to WAL even if not flushed
+}
+
+message FlushRegionResponse {
+  required uint64 last_flush_time = 1;
+  optional bool flushed = 2;
+  optional bool wrote_flush_wal_marker = 3;
+}
+
+/**
+ * Splits the specified region.
+ * <p>
+ * This method currently flushes the region and then forces a compaction which
+ * will then trigger a split.  The flush is done synchronously but the
+ * compaction is asynchronous.
+ */
+message SplitRegionRequest {
+  required RegionSpecifier region = 1;
+  optional bytes split_point = 2;
+}
+
+message SplitRegionResponse {
+}
+
+/**
+ * Compacts the specified region.  Performs a major compaction if specified.
+ * <p>
+ * This method is asynchronous.
+ */
+message CompactRegionRequest {
+  required RegionSpecifier region = 1;
+  optional bool major = 2;
+  optional bytes family = 3;
+}
+
+message CompactRegionResponse {
+}
+
+message UpdateFavoredNodesRequest {
+  repeated RegionUpdateInfo update_info = 1;
+
+  message RegionUpdateInfo {
+    required RegionInfo region = 1;
+    repeated ServerName favored_nodes = 2;
+  }
+}
+
+message UpdateFavoredNodesResponse {
+  optional uint32 response = 1;
+}
+
+/**
+ * Merges the specified regions.
+ * <p>
+ * This method currently closes the regions and then merges them
+ */
+message MergeRegionsRequest {
+  required RegionSpecifier region_a = 1;
+  required RegionSpecifier region_b = 2;
+  optional bool forcible = 3 [default = false];
+  // wall clock time from master
+  optional uint64 master_system_time = 4;
+}
+
+message MergeRegionsResponse {
+}
+
+// Protocol buffer version of WAL for replication
+message WALEntry {
+  required WALKey key = 1;
+  // Following may be null if the KVs/Cells are carried along the side in a cellblock (See
+  // RPC for more on cellblocks). If Cells/KVs are in a cellblock, this next field is null
+  // and associated_cell_count has count of Cells associated w/ this WALEntry
+  repeated bytes key_value_bytes = 2;
+  // If Cell data is carried alongside in a cellblock, this is count of Cells in the cellblock.
+  optional int32 associated_cell_count = 3;
+}
+
+/**
+ * Replicates the given entries. The guarantee is that the given entries
+ * will be durable on the slave cluster if this method returns without
+ * any exception.  hbase.replication has to be set to true for this to work.
+ */
+message ReplicateWALEntryRequest {
+  repeated WALEntry entry = 1;
+  optional string replicationClusterId = 2;
+  optional string sourceBaseNamespaceDirPath = 3;
+  optional string sourceHFileArchiveDirPath = 4;
+}
+
+message ReplicateWALEntryResponse {
+}
+
+message RollWALWriterRequest {
+}
+
+/*
+ * Roll request responses no longer include regions to flush
+ * this list will always be empty when talking to a 1.0 server
+ */
+message RollWALWriterResponse {
+  // A list of encoded name of regions to flush
+  repeated bytes region_to_flush = 1;
+}
+
+message StopServerRequest {
+  required string reason = 1;
+}
+
+message StopServerResponse {
+}
+
+message GetServerInfoRequest {
+}
+
+message ServerInfo {
+  required ServerName server_name = 1;
+  optional uint32 webui_port = 2;
+}
+
+message GetServerInfoResponse {
+  required ServerInfo server_info = 1;
+}
+
+message UpdateConfigurationRequest {
+}
+
+message UpdateConfigurationResponse {
+}
+
+service AdminService {
+  rpc GetRegionInfo(GetRegionInfoRequest)
+    returns(GetRegionInfoResponse);
+
+  rpc GetStoreFile(GetStoreFileRequest)
+    returns(GetStoreFileResponse);
+
+  rpc GetOnlineRegion(GetOnlineRegionRequest)
+    returns(GetOnlineRegionResponse);
+
+  rpc OpenRegion(OpenRegionRequest)
+    returns(OpenRegionResponse);
+
+  rpc WarmupRegion(WarmupRegionRequest)
+    returns(WarmupRegionResponse);
+
+  rpc CloseRegion(CloseRegionRequest)
+    returns(CloseRegionResponse);
+
+  rpc FlushRegion(FlushRegionRequest)
+    returns(FlushRegionResponse);
+
+  rpc SplitRegion(SplitRegionRequest)
+    returns(SplitRegionResponse);
+
+  rpc CompactRegion(CompactRegionRequest)
+    returns(CompactRegionResponse);
+
+  rpc MergeRegions(MergeRegionsRequest)
+    returns(MergeRegionsResponse);
+
+  rpc ReplicateWALEntry(ReplicateWALEntryRequest)
+    returns(ReplicateWALEntryResponse);
+
+  rpc Replay(ReplicateWALEntryRequest)
+    returns(ReplicateWALEntryResponse);
+
+  rpc RollWALWriter(RollWALWriterRequest)
+    returns(RollWALWriterResponse);
+
+  rpc GetServerInfo(GetServerInfoRequest)
+    returns(GetServerInfoResponse);
+
+  rpc StopServer(StopServerRequest)
+    returns(StopServerResponse);
+
+  rpc UpdateFavoredNodes(UpdateFavoredNodesRequest)
+    returns(UpdateFavoredNodesResponse);
+
+  rpc UpdateConfiguration(UpdateConfigurationRequest)
+    returns(UpdateConfigurationResponse);
+}

vendor/github.com/tsuna/gohbase/pb/Authentication.pb.go

@@ -0,0 +1,282 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: Authentication.proto
+
+package pb
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+type TokenIdentifier_Kind int32
+
+const (
+	TokenIdentifier_HBASE_AUTH_TOKEN TokenIdentifier_Kind = 0
+)
+
+var TokenIdentifier_Kind_name = map[int32]string{
+	0: "HBASE_AUTH_TOKEN",
+}
+var TokenIdentifier_Kind_value = map[string]int32{
+	"HBASE_AUTH_TOKEN": 0,
+}
+
+func (x TokenIdentifier_Kind) Enum() *TokenIdentifier_Kind {
+	p := new(TokenIdentifier_Kind)
+	*p = x
+	return p
+}
+func (x TokenIdentifier_Kind) String() string {
+	return proto.EnumName(TokenIdentifier_Kind_name, int32(x))
+}
+func (x *TokenIdentifier_Kind) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(TokenIdentifier_Kind_value, data, "TokenIdentifier_Kind")
+	if err != nil {
+		return err
+	}
+	*x = TokenIdentifier_Kind(value)
+	return nil
+}
+func (TokenIdentifier_Kind) EnumDescriptor() ([]byte, []int) { return fileDescriptor1, []int{1, 0} }
+
+type AuthenticationKey struct {
+	Id               *int32 `protobuf:"varint,1,req,name=id" json:"id,omitempty"`
+	ExpirationDate   *int64 `protobuf:"varint,2,req,name=expiration_date,json=expirationDate" json:"expiration_date,omitempty"`
+	Key              []byte `protobuf:"bytes,3,req,name=key" json:"key,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *AuthenticationKey) Reset()                    { *m = AuthenticationKey{} }
+func (m *AuthenticationKey) String() string            { return proto.CompactTextString(m) }
+func (*AuthenticationKey) ProtoMessage()               {}
+func (*AuthenticationKey) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} }
+
+func (m *AuthenticationKey) GetId() int32 {
+	if m != nil && m.Id != nil {
+		return *m.Id
+	}
+	return 0
+}
+
+func (m *AuthenticationKey) GetExpirationDate() int64 {
+	if m != nil && m.ExpirationDate != nil {
+		return *m.ExpirationDate
+	}
+	return 0
+}
+
+func (m *AuthenticationKey) GetKey() []byte {
+	if m != nil {
+		return m.Key
+	}
+	return nil
+}
+
+type TokenIdentifier struct {
+	Kind             *TokenIdentifier_Kind `protobuf:"varint,1,req,name=kind,enum=pb.TokenIdentifier_Kind" json:"kind,omitempty"`
+	Username         []byte                `protobuf:"bytes,2,req,name=username" json:"username,omitempty"`
+	KeyId            *int32                `protobuf:"varint,3,req,name=key_id,json=keyId" json:"key_id,omitempty"`
+	IssueDate        *int64                `protobuf:"varint,4,opt,name=issue_date,json=issueDate" json:"issue_date,omitempty"`
+	ExpirationDate   *int64                `protobuf:"varint,5,opt,name=expiration_date,json=expirationDate" json:"expiration_date,omitempty"`
+	SequenceNumber   *int64                `protobuf:"varint,6,opt,name=sequence_number,json=sequenceNumber" json:"sequence_number,omitempty"`
+	XXX_unrecognized []byte                `json:"-"`
+}
+
+func (m *TokenIdentifier) Reset()                    { *m = TokenIdentifier{} }
+func (m *TokenIdentifier) String() string            { return proto.CompactTextString(m) }
+func (*TokenIdentifier) ProtoMessage()               {}
+func (*TokenIdentifier) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{1} }
+
+func (m *TokenIdentifier) GetKind() TokenIdentifier_Kind {
+	if m != nil && m.Kind != nil {
+		return *m.Kind
+	}
+	return TokenIdentifier_HBASE_AUTH_TOKEN
+}
+
+func (m *TokenIdentifier) GetUsername() []byte {
+	if m != nil {
+		return m.Username
+	}
+	return nil
+}
+
+func (m *TokenIdentifier) GetKeyId() int32 {
+	if m != nil && m.KeyId != nil {
+		return *m.KeyId
+	}
+	return 0
+}
+
+func (m *TokenIdentifier) GetIssueDate() int64 {
+	if m != nil && m.IssueDate != nil {
+		return *m.IssueDate
+	}
+	return 0
+}
+
+func (m *TokenIdentifier) GetExpirationDate() int64 {
+	if m != nil && m.ExpirationDate != nil {
+		return *m.ExpirationDate
+	}
+	return 0
+}
+
+func (m *TokenIdentifier) GetSequenceNumber() int64 {
+	if m != nil && m.SequenceNumber != nil {
+		return *m.SequenceNumber
+	}
+	return 0
+}
+
+// Serialization of the org.apache.hadoop.security.token.Token class
+// Note that this is a Hadoop class, so fields may change!
+type Token struct {
+	// the TokenIdentifier in serialized form
+	// Note: we can't use the protobuf directly because the Hadoop Token class
+	// only stores the serialized bytes
+	Identifier       []byte `protobuf:"bytes,1,opt,name=identifier" json:"identifier,omitempty"`
+	Password         []byte `protobuf:"bytes,2,opt,name=password" json:"password,omitempty"`
+	Service          []byte `protobuf:"bytes,3,opt,name=service" json:"service,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *Token) Reset()                    { *m = Token{} }
+func (m *Token) String() string            { return proto.CompactTextString(m) }
+func (*Token) ProtoMessage()               {}
+func (*Token) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{2} }
+
+func (m *Token) GetIdentifier() []byte {
+	if m != nil {
+		return m.Identifier
+	}
+	return nil
+}
+
+func (m *Token) GetPassword() []byte {
+	if m != nil {
+		return m.Password
+	}
+	return nil
+}
+
+func (m *Token) GetService() []byte {
+	if m != nil {
+		return m.Service
+	}
+	return nil
+}
+
+// RPC request & response messages
+type GetAuthenticationTokenRequest struct {
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *GetAuthenticationTokenRequest) Reset()                    { *m = GetAuthenticationTokenRequest{} }
+func (m *GetAuthenticationTokenRequest) String() string            { return proto.CompactTextString(m) }
+func (*GetAuthenticationTokenRequest) ProtoMessage()               {}
+func (*GetAuthenticationTokenRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{3} }
+
+type GetAuthenticationTokenResponse struct {
+	Token            *Token `protobuf:"bytes,1,opt,name=token" json:"token,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *GetAuthenticationTokenResponse) Reset()                    { *m = GetAuthenticationTokenResponse{} }
+func (m *GetAuthenticationTokenResponse) String() string            { return proto.CompactTextString(m) }
+func (*GetAuthenticationTokenResponse) ProtoMessage()               {}
+func (*GetAuthenticationTokenResponse) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{4} }
+
+func (m *GetAuthenticationTokenResponse) GetToken() *Token {
+	if m != nil {
+		return m.Token
+	}
+	return nil
+}
+
+type WhoAmIRequest struct {
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *WhoAmIRequest) Reset()                    { *m = WhoAmIRequest{} }
+func (m *WhoAmIRequest) String() string            { return proto.CompactTextString(m) }
+func (*WhoAmIRequest) ProtoMessage()               {}
+func (*WhoAmIRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{5} }
+
+type WhoAmIResponse struct {
+	Username         *string `protobuf:"bytes,1,opt,name=username" json:"username,omitempty"`
+	AuthMethod       *string `protobuf:"bytes,2,opt,name=auth_method,json=authMethod" json:"auth_method,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *WhoAmIResponse) Reset()                    { *m = WhoAmIResponse{} }
+func (m *WhoAmIResponse) String() string            { return proto.CompactTextString(m) }
+func (*WhoAmIResponse) ProtoMessage()               {}
+func (*WhoAmIResponse) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{6} }
+
+func (m *WhoAmIResponse) GetUsername() string {
+	if m != nil && m.Username != nil {
+		return *m.Username
+	}
+	return ""
+}
+
+func (m *WhoAmIResponse) GetAuthMethod() string {
+	if m != nil && m.AuthMethod != nil {
+		return *m.AuthMethod
+	}
+	return ""
+}
+
+func init() {
+	proto.RegisterType((*AuthenticationKey)(nil), "pb.AuthenticationKey")
+	proto.RegisterType((*TokenIdentifier)(nil), "pb.TokenIdentifier")
+	proto.RegisterType((*Token)(nil), "pb.Token")
+	proto.RegisterType((*GetAuthenticationTokenRequest)(nil), "pb.GetAuthenticationTokenRequest")
+	proto.RegisterType((*GetAuthenticationTokenResponse)(nil), "pb.GetAuthenticationTokenResponse")
+	proto.RegisterType((*WhoAmIRequest)(nil), "pb.WhoAmIRequest")
+	proto.RegisterType((*WhoAmIResponse)(nil), "pb.WhoAmIResponse")
+	proto.RegisterEnum("pb.TokenIdentifier_Kind", TokenIdentifier_Kind_name, TokenIdentifier_Kind_value)
+}
+
+func init() { proto.RegisterFile("Authentication.proto", fileDescriptor1) }
+
+var fileDescriptor1 = []byte{
+	// 497 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x93, 0x51, 0x6f, 0x12, 0x41,
+	0x10, 0xc7, 0xbd, 0xa3, 0x87, 0x32, 0x45, 0xa0, 0x9b, 0xd6, 0x5c, 0x88, 0x2d, 0x78, 0x2f, 0x25,
+	0xc6, 0x9c, 0x09, 0xdf, 0x00, 0x62, 0x23, 0x48, 0x5a, 0xcd, 0x16, 0xe3, 0x93, 0x5e, 0x16, 0x6e,
+	0xda, 0xdb, 0x10, 0x76, 0xcf, 0xdb, 0x3d, 0x95, 0x47, 0xdf, 0xfc, 0x18, 0xbe, 0xfa, 0x2d, 0xcd,
+	0xee, 0x16, 0x04, 0x52, 0xfb, 0x76, 0xf3, 0x9b, 0xff, 0xcd, 0xfc, 0xff, 0x99, 0x2c, 0x1c, 0x0f,
+	0x4a, 0x9d, 0xa1, 0xd0, 0x7c, 0xce, 0x34, 0x97, 0x22, 0xce, 0x0b, 0xa9, 0x25, 0xf1, 0xf3, 0x59,
+	0xf4, 0x05, 0x8e, 0x76, 0x7b, 0x13, 0x5c, 0x91, 0x06, 0xf8, 0x3c, 0x0d, 0xbd, 0xae, 0xdf, 0x0b,
+	0xa8, 0xcf, 0x53, 0x72, 0x0e, 0x4d, 0xfc, 0x91, 0xf3, 0xc2, 0x0a, 0x92, 0x94, 0x69, 0x0c, 0xfd,
+	0xae, 0xdf, 0xab, 0xd0, 0xc6, 0x3f, 0xfc, 0x86, 0x69, 0x24, 0x2d, 0xa8, 0x2c, 0x70, 0x15, 0x56,
+	0xba, 0x7e, 0xaf, 0x4e, 0xcd, 0x67, 0xf4, 0xd3, 0x87, 0xe6, 0x54, 0x2e, 0x50, 0x8c, 0x53, 0xb3,
+	0xe3, 0x86, 0x63, 0x41, 0x5e, 0xc1, 0xc1, 0x82, 0x0b, 0xb7, 0xa0, 0xd1, 0x0f, 0xe3, 0x7c, 0x16,
+	0xef, 0x49, 0xe2, 0x09, 0x17, 0x29, 0xb5, 0x2a, 0xd2, 0x86, 0x27, 0xa5, 0xc2, 0x42, 0xb0, 0xa5,
+	0xdb, 0x5a, 0xa7, 0x9b, 0x9a, 0x9c, 0x40, 0x75, 0x81, 0xab, 0x84, 0xa7, 0x76, 0x65, 0x40, 0x83,
+	0x05, 0xae, 0xc6, 0x29, 0x39, 0x05, 0xe0, 0x4a, 0x95, 0xe8, 0xac, 0x1e, 0x74, 0xbd, 0x5e, 0x85,
+	0xd6, 0x2c, 0xb1, 0x2e, 0xef, 0x89, 0x13, 0x58, 0xcd, 0x7e, 0x9c, 0x73, 0x68, 0x2a, 0xfc, 0x5a,
+	0xa2, 0x98, 0x63, 0x22, 0xca, 0xe5, 0x0c, 0x8b, 0xb0, 0xea, 0x84, 0x6b, 0x7c, 0x65, 0x69, 0xf4,
+	0x1c, 0x0e, 0x8c, 0x63, 0x72, 0x0c, 0xad, 0xd1, 0x70, 0x70, 0x7d, 0x91, 0x0c, 0x3e, 0x4e, 0x47,
+	0xc9, 0xf4, 0xfd, 0xe4, 0xe2, 0xaa, 0xf5, 0x28, 0xfa, 0x0c, 0x81, 0xcd, 0x47, 0xce, 0x00, 0xf8,
+	0x26, 0x63, 0xe8, 0x75, 0xbd, 0x5e, 0x9d, 0x6e, 0x11, 0x13, 0x35, 0x67, 0x4a, 0x7d, 0x97, 0x45,
+	0x1a, 0xfa, 0xb6, 0xbb, 0xa9, 0x49, 0x08, 0x8f, 0x15, 0x16, 0xdf, 0xf8, 0x1c, 0xc3, 0x8a, 0x6d,
+	0xad, 0xcb, 0xa8, 0x03, 0xa7, 0x6f, 0x51, 0xef, 0x5e, 0xd1, 0xee, 0xa3, 0xc6, 0xa4, 0xd2, 0xd1,
+	0x00, 0xce, 0xfe, 0x27, 0x50, 0xb9, 0x14, 0x0a, 0x49, 0x07, 0x02, 0x6d, 0x80, 0xf5, 0x74, 0xd8,
+	0xaf, 0x6d, 0x4e, 0x42, 0x1d, 0x8f, 0x9a, 0xf0, 0xf4, 0x53, 0x26, 0x07, 0xcb, 0xf1, 0x7a, 0xe6,
+	0x25, 0x34, 0xd6, 0xe0, 0x6e, 0xc6, 0xf6, 0x9d, 0xcc, 0x98, 0xda, 0xd6, 0x9d, 0x3a, 0x70, 0xc8,
+	0x4a, 0x9d, 0x25, 0x4b, 0xd4, 0x99, 0x74, 0xd9, 0x6a, 0x14, 0x0c, 0xba, 0xb4, 0xa4, 0xff, 0xc7,
+	0x83, 0x93, 0x5d, 0x83, 0xd7, 0x2e, 0x1d, 0x49, 0xe0, 0xd9, 0xfd, 0xe6, 0xc9, 0x0b, 0xe3, 0xf2,
+	0xc1, 0xe4, 0xed, 0xe8, 0x21, 0xc9, 0x9d, 0xef, 0xd7, 0x50, 0x75, 0x49, 0xc8, 0x91, 0x51, 0xef,
+	0xc4, 0x6c, 0x93, 0x6d, 0xe4, 0x7e, 0x18, 0xbe, 0x83, 0x97, 0xb2, 0xb8, 0x8d, 0x59, 0xce, 0xe6,
+	0x19, 0xc6, 0x19, 0x4b, 0xa5, 0xcc, 0xe3, 0x6c, 0xc6, 0x14, 0xba, 0x77, 0x35, 0x2b, 0x6f, 0xe2,
+	0x5b, 0x14, 0x58, 0x30, 0x8d, 0xe9, 0x70, 0xef, 0xe9, 0x7d, 0x30, 0x0a, 0x35, 0xf2, 0x7e, 0x79,
+	0xde, 0x6f, 0xcf, 0xfb, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x0e, 0xa0, 0x34, 0x67, 0x99, 0x03, 0x00,
+	0x00,
+}

vendor/github.com/tsuna/gohbase/pb/Authentication.proto

@@ -0,0 +1,82 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package pb;
+
+option java_package = "org.apache.hadoop.hbase.protobuf.generated";
+option java_outer_classname = "AuthenticationProtos";
+option java_generic_services = true;
+option java_generate_equals_and_hash = true;
+option optimize_for = SPEED;
+
+message AuthenticationKey {
+    required int32 id = 1;
+    required int64 expiration_date = 2;
+    required bytes key = 3;
+}
+
+
+message TokenIdentifier {
+    enum Kind {
+        HBASE_AUTH_TOKEN = 0;
+    }
+    required Kind kind = 1;
+    required bytes username = 2;
+    required int32 key_id = 3;
+    optional int64 issue_date = 4;
+    optional int64 expiration_date = 5;
+    optional int64 sequence_number = 6;
+}
+
+
+// Serialization of the org.apache.hadoop.security.token.Token class
+// Note that this is a Hadoop class, so fields may change!
+message Token {
+    // the TokenIdentifier in serialized form
+    // Note: we can't use the protobuf directly because the Hadoop Token class
+    // only stores the serialized bytes
+    optional bytes identifier = 1;
+    optional bytes password = 2;
+    optional bytes service = 3;
+}
+
+
+// RPC request & response messages
+message GetAuthenticationTokenRequest {
+}
+
+message GetAuthenticationTokenResponse {
+    optional Token token = 1;
+}
+
+message WhoAmIRequest {
+}
+
+message WhoAmIResponse {
+    optional string username = 1;
+    optional string auth_method = 2;
+}
+
+
+// RPC service
+service AuthenticationService {
+    rpc GetAuthenticationToken(GetAuthenticationTokenRequest)
+        returns (GetAuthenticationTokenResponse);
+
+    rpc WhoAmI(WhoAmIRequest)
+        returns (WhoAmIResponse);
+}

vendor/github.com/tsuna/gohbase/pb/BUILD.bazel

@@ -0,0 +1,52 @@
+load(
+    "@io_bazel_rules_go//proto:def.bzl",
+    "go_proto_library",
+)
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "Admin.pb.go",
+        "Authentication.pb.go",
+        "Cell.pb.go",
+        "Client.pb.go",
+        "ClusterId.pb.go",
+        "ClusterStatus.pb.go",
+        "Comparator.pb.go",
+        "ErrorHandling.pb.go",
+        "FS.pb.go",
+        "Filter.pb.go",
+        "HBase.pb.go",
+        "Master.pb.go",
+        "MultiRowMutation.pb.go",
+        "Procedure.pb.go",
+        "Quota.pb.go",
+        "RPC.pb.go",
+        "RegionServerStatus.pb.go",
+        "Tracing.pb.go",
+        "WAL.pb.go",
+        "ZooKeeper.pb.go",
+        "generate.go",
+        "marshal.go",
+    ],
+    importmap = "go-common/vendor/github.com/tsuna/gohbase/pb",
+    importpath = "github.com/tsuna/gohbase/pb",
+    tags = ["manual"],
+    visibility = ["//visibility:public"],
+    deps = ["@com_github_golang_protobuf//proto:go_default_library"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

vendor/github.com/tsuna/gohbase/pb/Cell.pb.go

@@ -0,0 +1,231 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: Cell.proto
+
+package pb
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// *
+// The type of the key in a Cell
+type CellType int32
+
+const (
+	CellType_MINIMUM       CellType = 0
+	CellType_PUT           CellType = 4
+	CellType_DELETE        CellType = 8
+	CellType_DELETE_COLUMN CellType = 12
+	CellType_DELETE_FAMILY CellType = 14
+	// MAXIMUM is used when searching; you look from maximum on down.
+	CellType_MAXIMUM CellType = 255
+)
+
+var CellType_name = map[int32]string{
+	0:   "MINIMUM",
+	4:   "PUT",
+	8:   "DELETE",
+	12:  "DELETE_COLUMN",
+	14:  "DELETE_FAMILY",
+	255: "MAXIMUM",
+}
+var CellType_value = map[string]int32{
+	"MINIMUM":       0,
+	"PUT":           4,
+	"DELETE":        8,
+	"DELETE_COLUMN": 12,
+	"DELETE_FAMILY": 14,
+	"MAXIMUM":       255,
+}
+
+func (x CellType) Enum() *CellType {
+	p := new(CellType)
+	*p = x
+	return p
+}
+func (x CellType) String() string {
+	return proto.EnumName(CellType_name, int32(x))
+}
+func (x *CellType) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(CellType_value, data, "CellType")
+	if err != nil {
+		return err
+	}
+	*x = CellType(value)
+	return nil
+}
+func (CellType) EnumDescriptor() ([]byte, []int) { return fileDescriptor2, []int{0} }
+
+// *
+// Protocol buffer version of Cell.
+type Cell struct {
+	Row              []byte    `protobuf:"bytes,1,opt,name=row" json:"row,omitempty"`
+	Family           []byte    `protobuf:"bytes,2,opt,name=family" json:"family,omitempty"`
+	Qualifier        []byte    `protobuf:"bytes,3,opt,name=qualifier" json:"qualifier,omitempty"`
+	Timestamp        *uint64   `protobuf:"varint,4,opt,name=timestamp" json:"timestamp,omitempty"`
+	CellType         *CellType `protobuf:"varint,5,opt,name=cell_type,json=cellType,enum=pb.CellType" json:"cell_type,omitempty"`
+	Value            []byte    `protobuf:"bytes,6,opt,name=value" json:"value,omitempty"`
+	Tags             []byte    `protobuf:"bytes,7,opt,name=tags" json:"tags,omitempty"`
+	XXX_unrecognized []byte    `json:"-"`
+}
+
+func (m *Cell) Reset()                    { *m = Cell{} }
+func (m *Cell) String() string            { return proto.CompactTextString(m) }
+func (*Cell) ProtoMessage()               {}
+func (*Cell) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} }
+
+func (m *Cell) GetRow() []byte {
+	if m != nil {
+		return m.Row
+	}
+	return nil
+}
+
+func (m *Cell) GetFamily() []byte {
+	if m != nil {
+		return m.Family
+	}
+	return nil
+}
+
+func (m *Cell) GetQualifier() []byte {
+	if m != nil {
+		return m.Qualifier
+	}
+	return nil
+}
+
+func (m *Cell) GetTimestamp() uint64 {
+	if m != nil && m.Timestamp != nil {
+		return *m.Timestamp
+	}
+	return 0
+}
+
+func (m *Cell) GetCellType() CellType {
+	if m != nil && m.CellType != nil {
+		return *m.CellType
+	}
+	return CellType_MINIMUM
+}
+
+func (m *Cell) GetValue() []byte {
+	if m != nil {
+		return m.Value
+	}
+	return nil
+}
+
+func (m *Cell) GetTags() []byte {
+	if m != nil {
+		return m.Tags
+	}
+	return nil
+}
+
+// *
+// Protocol buffer version of KeyValue.
+// It doesn't have those transient parameters
+type KeyValue struct {
+	Row              []byte    `protobuf:"bytes,1,req,name=row" json:"row,omitempty"`
+	Family           []byte    `protobuf:"bytes,2,req,name=family" json:"family,omitempty"`
+	Qualifier        []byte    `protobuf:"bytes,3,req,name=qualifier" json:"qualifier,omitempty"`
+	Timestamp        *uint64   `protobuf:"varint,4,opt,name=timestamp" json:"timestamp,omitempty"`
+	KeyType          *CellType `protobuf:"varint,5,opt,name=key_type,json=keyType,enum=pb.CellType" json:"key_type,omitempty"`
+	Value            []byte    `protobuf:"bytes,6,opt,name=value" json:"value,omitempty"`
+	Tags             []byte    `protobuf:"bytes,7,opt,name=tags" json:"tags,omitempty"`
+	XXX_unrecognized []byte    `json:"-"`
+}
+
+func (m *KeyValue) Reset()                    { *m = KeyValue{} }
+func (m *KeyValue) String() string            { return proto.CompactTextString(m) }
+func (*KeyValue) ProtoMessage()               {}
+func (*KeyValue) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{1} }
+
+func (m *KeyValue) GetRow() []byte {
+	if m != nil {
+		return m.Row
+	}
+	return nil
+}
+
+func (m *KeyValue) GetFamily() []byte {
+	if m != nil {
+		return m.Family
+	}
+	return nil
+}
+
+func (m *KeyValue) GetQualifier() []byte {
+	if m != nil {
+		return m.Qualifier
+	}
+	return nil
+}
+
+func (m *KeyValue) GetTimestamp() uint64 {
+	if m != nil && m.Timestamp != nil {
+		return *m.Timestamp
+	}
+	return 0
+}
+
+func (m *KeyValue) GetKeyType() CellType {
+	if m != nil && m.KeyType != nil {
+		return *m.KeyType
+	}
+	return CellType_MINIMUM
+}
+
+func (m *KeyValue) GetValue() []byte {
+	if m != nil {
+		return m.Value
+	}
+	return nil
+}
+
+func (m *KeyValue) GetTags() []byte {
+	if m != nil {
+		return m.Tags
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*Cell)(nil), "pb.Cell")
+	proto.RegisterType((*KeyValue)(nil), "pb.KeyValue")
+	proto.RegisterEnum("pb.CellType", CellType_name, CellType_value)
+}
+
+func init() { proto.RegisterFile("Cell.proto", fileDescriptor2) }
+
+var fileDescriptor2 = []byte{
+	// 338 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x92, 0x4f, 0x4f, 0xf2, 0x40,
+	0x10, 0x87, 0xdf, 0x2d, 0x85, 0x96, 0x79, 0x2b, 0xa9, 0x1b, 0x63, 0xf6, 0xe0, 0x81, 0x70, 0x11,
+	0x39, 0xec, 0xc1, 0xbb, 0x07, 0x40, 0x8c, 0x44, 0x8a, 0x84, 0x80, 0xd1, 0x13, 0x6e, 0x61, 0x80,
+	0x86, 0xc5, 0xae, 0x6d, 0xd1, 0xf4, 0xdb, 0xf8, 0x55, 0x8c, 0x1f, 0x4c, 0xd3, 0x05, 0xc5, 0x83,
+	0x1c, 0xb8, 0xfd, 0xe6, 0x99, 0xfd, 0x33, 0x4f, 0x32, 0x00, 0x4d, 0x94, 0x92, 0xab, 0x28, 0x4c,
+	0x42, 0x6a, 0x28, 0xbf, 0xf2, 0x4e, 0xc0, 0xcc, 0x10, 0x75, 0x21, 0x17, 0x85, 0xaf, 0x8c, 0x94,
+	0x49, 0xd5, 0xe9, 0x67, 0x91, 0x1e, 0x43, 0x61, 0x2a, 0x96, 0x81, 0x4c, 0x99, 0xa1, 0xe1, 0xa6,
+	0xa2, 0x27, 0x50, 0x7c, 0x5e, 0x09, 0x19, 0x4c, 0x03, 0x8c, 0x58, 0x4e, 0xb7, 0xb6, 0x20, 0xeb,
+	0x26, 0xc1, 0x12, 0xe3, 0x44, 0x2c, 0x15, 0x33, 0xcb, 0xa4, 0x6a, 0xf6, 0xb7, 0x80, 0x9e, 0x41,
+	0x71, 0x8c, 0x52, 0x8e, 0x92, 0x54, 0x21, 0xcb, 0x97, 0x49, 0xb5, 0x74, 0xee, 0x70, 0xe5, 0xf3,
+	0x6c, 0x84, 0x41, 0xaa, 0xb0, 0x6f, 0x8f, 0x37, 0x89, 0x1e, 0x41, 0xfe, 0x45, 0xc8, 0x15, 0xb2,
+	0x82, 0xfe, 0x62, 0x5d, 0x50, 0x0a, 0x66, 0x22, 0x66, 0x31, 0xb3, 0x34, 0xd4, 0xb9, 0xf2, 0x41,
+	0xc0, 0xbe, 0xc1, 0xf4, 0x4e, 0x1f, 0xf8, 0xf1, 0x30, 0xfe, 0xf2, 0x30, 0x76, 0x7b, 0x18, 0xfb,
+	0x78, 0x9c, 0x82, 0xbd, 0xc0, 0x74, 0xb7, 0x86, 0xb5, 0xc0, 0x74, 0x3f, 0x8b, 0xda, 0x23, 0xd8,
+	0xdf, 0xd7, 0xe9, 0x7f, 0xb0, 0xbc, 0x76, 0xb7, 0xed, 0x0d, 0x3d, 0xf7, 0x1f, 0xb5, 0x20, 0xd7,
+	0x1b, 0x0e, 0x5c, 0x93, 0x02, 0x14, 0x2e, 0x5b, 0x9d, 0xd6, 0xa0, 0xe5, 0xda, 0xf4, 0x10, 0x0e,
+	0xd6, 0x79, 0xd4, 0xbc, 0xed, 0x0c, 0xbd, 0xae, 0xeb, 0xfc, 0x42, 0x57, 0x75, 0xaf, 0xdd, 0x79,
+	0x70, 0x4b, 0xd4, 0x01, 0xcb, 0xab, 0xdf, 0xeb, 0x77, 0x3e, 0x49, 0xe3, 0x02, 0x6a, 0x61, 0x34,
+	0xe3, 0x42, 0x89, 0xf1, 0x1c, 0xf9, 0x5c, 0x4c, 0xc2, 0x50, 0xf1, 0xb9, 0x2f, 0x62, 0x5c, 0x2f,
+	0x84, 0xbf, 0x9a, 0xf2, 0x19, 0x3e, 0x61, 0x24, 0x12, 0x9c, 0x34, 0xf4, 0xa6, 0xf4, 0x32, 0x1e,
+	0x5f, 0x93, 0x37, 0x42, 0xbe, 0x02, 0x00, 0x00, 0xff, 0xff, 0x5f, 0xa7, 0x5d, 0xd4, 0x3b, 0x02,
+	0x00, 0x00,
+}

vendor/github.com/tsuna/gohbase/pb/Cell.proto

@@ -0,0 +1,67 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Cell and KeyValue protos
+package pb;
+
+option java_package = "org.apache.hadoop.hbase.protobuf.generated";
+option java_outer_classname = "CellProtos";
+option java_generate_equals_and_hash = true;
+option optimize_for = SPEED;
+
+/**
+ * The type of the key in a Cell
+ */
+enum CellType {
+    MINIMUM = 0;
+    PUT = 4;
+
+    DELETE = 8;
+    DELETE_COLUMN = 12;
+    DELETE_FAMILY = 14;
+
+    // MAXIMUM is used when searching; you look from maximum on down.
+    MAXIMUM = 255;
+}
+
+/**
+ * Protocol buffer version of Cell.
+ */
+message Cell {
+  optional bytes row = 1;
+  optional bytes family = 2;
+  optional bytes qualifier = 3;
+  optional uint64 timestamp = 4;
+  optional CellType cell_type = 5;
+  optional bytes value = 6;
+  optional bytes tags = 7;
+}
+
+/**
+ * Protocol buffer version of KeyValue.
+ * It doesn't have those transient parameters
+ */
+message KeyValue {
+  required bytes row = 1;
+  required bytes family = 2;
+  required bytes qualifier = 3;
+  optional uint64 timestamp = 4;
+  optional CellType key_type = 5;
+  optional bytes value = 6;
+  optional bytes tags = 7;
+}

vendor/github.com/tsuna/gohbase/pb/Client.proto

@@ -0,0 +1,483 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// This file contains protocol buffers that are used for Client service.
+package pb;
+
+option java_package = "org.apache.hadoop.hbase.protobuf.generated";
+option java_outer_classname = "ClientProtos";
+option java_generic_services = true;
+option java_generate_equals_and_hash = true;
+option optimize_for = SPEED;
+
+import "HBase.proto";
+import "Filter.proto";
+import "Cell.proto";
+import "Comparator.proto";
+//import "MapReduce.proto";
+
+/**
+ * The protocol buffer version of Authorizations.
+ */
+message Authorizations {
+  repeated string label = 1;
+}
+
+/**
+ * The protocol buffer version of CellVisibility.
+ */
+message CellVisibility {
+  required string expression = 1;
+}
+
+/**
+ * Container for a list of column qualifier names of a family.
+ */
+message Column {
+  required bytes family = 1;
+  repeated bytes qualifier = 2;
+}
+
+/**
+ * Consistency defines the expected consistency level for an operation.
+ */
+enum Consistency {
+  STRONG   = 0;
+  TIMELINE = 1;
+}
+
+/**
+ * The protocol buffer version of Get.
+ * Unless existence_only is specified, return all the requested data
+ * for the row that matches exactly, or the one that immediately
+ * precedes it if closest_row_before is specified.
+ */
+message Get {
+  required bytes row = 1;
+  repeated Column column = 2;
+  repeated NameBytesPair attribute = 3;
+  optional Filter filter = 4;
+  optional TimeRange time_range = 5;
+  optional uint32 max_versions = 6 [default = 1];
+  optional bool cache_blocks = 7 [default = true];
+  optional uint32 store_limit = 8;
+  optional uint32 store_offset = 9;
+
+  // The result isn't asked for, just check for
+  // the existence.
+  optional bool existence_only = 10 [default = false];
+
+  // If the row to get doesn't exist, return the
+  // closest row before.
+  optional bool closest_row_before = 11 [default = false];
+
+  optional Consistency consistency = 12 [default = STRONG];
+  repeated ColumnFamilyTimeRange cf_time_range = 13;
+}
+
+message Result {
+  // Result includes the Cells or else it just has a count of Cells
+  // that are carried otherwise.
+  repeated Cell cell = 1;
+  // The below count is set when the associated cells are
+  // not part of this protobuf message; they are passed alongside
+  // and then this Message is just a placeholder with metadata.
+  // The count is needed to know how many to peel off the block of Cells as
+  // ours.  NOTE: This is different from the pb managed cell_count of the
+  // 'cell' field above which is non-null when the cells are pb'd.
+  optional int32 associated_cell_count = 2;
+
+  // used for Get to check existence only. Not set if existence_only was not set to true
+  //  in the query.
+  optional bool exists = 3;
+
+  // Whether or not the results are coming from possibly stale data 
+  optional bool stale = 4 [default = false];
+
+  // Whether or not the entire result could be returned. Results will be split when
+  // the RPC chunk size limit is reached. Partial results contain only a subset of the
+  // cells for a row and must be combined with a result containing the remaining cells
+  // to form a complete result
+  optional bool partial = 5 [default = false];
+}
+
+/**
+ * The get request. Perform a single Get operation.
+ */
+message GetRequest {
+  required RegionSpecifier region = 1;
+  required Get get = 2;
+}
+
+message GetResponse {
+  optional Result result = 1;
+}
+
+/**
+ * Condition to check if the value of a given cell (row,
+ * family, qualifier) matches a value via a given comparator.
+ *
+ * Condition is used in check and mutate operations.
+ */
+message Condition {
+  required bytes row = 1;
+  required bytes family = 2;
+  required bytes qualifier = 3;
+  required CompareType compare_type = 4;
+  required Comparator comparator = 5;
+}
+
+
+/**
+ * A specific mutation inside a mutate request.
+ * It can be an append, increment, put or delete based
+ * on the mutation type.  It can be fully filled in or
+ * only metadata present because data is being carried
+ * elsewhere outside of pb.
+ */
+message MutationProto {
+  optional bytes row = 1;
+  optional MutationType mutate_type = 2;
+  repeated ColumnValue column_value = 3;
+  optional uint64 timestamp = 4;
+  repeated NameBytesPair attribute = 5;
+  optional Durability durability = 6 [default = USE_DEFAULT];
+
+  // For some mutations, a result may be returned, in which case,
+  // time range can be specified for potential performance gain
+  optional TimeRange time_range = 7;
+  // The below count is set when the associated cells are NOT
+  // part of this protobuf message; they are passed alongside
+  // and then this Message is a placeholder with metadata.  The
+  // count is needed to know how many to peel off the block of Cells as
+  // ours.  NOTE: This is different from the pb managed cell_count of the
+  // 'cell' field above which is non-null when the cells are pb'd.
+  optional int32 associated_cell_count = 8;
+
+  optional uint64 nonce = 9;
+
+  enum Durability {
+    USE_DEFAULT  = 0;
+    SKIP_WAL     = 1;
+    ASYNC_WAL    = 2;
+    SYNC_WAL     = 3;
+    FSYNC_WAL    = 4;
+  }
+
+  enum MutationType {
+    APPEND = 0;
+    INCREMENT = 1;
+    PUT = 2;
+    DELETE = 3;
+  }
+
+  enum DeleteType {
+    DELETE_ONE_VERSION = 0;
+    DELETE_MULTIPLE_VERSIONS = 1;
+    DELETE_FAMILY = 2;
+    DELETE_FAMILY_VERSION = 3;
+  }
+
+  message ColumnValue {
+    required bytes family = 1;
+    repeated QualifierValue qualifier_value = 2;
+
+    message QualifierValue {
+      optional bytes qualifier = 1;
+      optional bytes value = 2;
+      optional uint64 timestamp = 3;
+      optional DeleteType delete_type = 4;
+      optional bytes tags = 5;
+    }
+  }
+}
+
+/**
+ * The mutate request. Perform a single Mutate operation.
+ *
+ * Optionally, you can specify a condition. The mutate
+ * will take place only if the condition is met.  Otherwise,
+ * the mutate will be ignored.  In the response result,
+ * parameter processed is used to indicate if the mutate
+ * actually happened.
+ */
+message MutateRequest {
+  required RegionSpecifier region = 1;
+  required MutationProto mutation = 2;
+  optional Condition condition = 3;
+  optional uint64 nonce_group = 4;
+}
+
+message MutateResponse {
+  optional Result result = 1;
+
+  // used for mutate to indicate processed only
+  optional bool processed = 2;
+}
+
+/**
+ * Instead of get from a table, you can scan it with optional filters.
+ * You can specify the row key range, time range, the columns/families
+ * to scan and so on.
+ *
+ * This scan is used the first time in a scan request. The response of
+ * the initial scan will return a scanner id, which should be used to
+ * fetch result batches later on before it is closed.
+ */
+message Scan {
+  repeated Column column = 1;
+  repeated NameBytesPair attribute = 2;
+  optional bytes start_row = 3;
+  optional bytes stop_row = 4;
+  optional Filter filter = 5;
+  optional TimeRange time_range = 6;
+  optional uint32 max_versions = 7 [default = 1];
+  optional bool cache_blocks = 8 [default = true];
+  optional uint32 batch_size = 9;
+  optional uint64 max_result_size = 10;
+  optional uint32 store_limit = 11;
+  optional uint32 store_offset = 12;
+  optional bool load_column_families_on_demand = 13; /* DO NOT add defaults to load_column_families_on_demand. */
+  optional bool small = 14;
+  optional bool reversed = 15 [default = false];
+  optional Consistency consistency = 16 [default = STRONG];
+  optional uint32 caching = 17;
+  optional bool allow_partial_results = 18;
+  repeated ColumnFamilyTimeRange cf_time_range = 19;
+}
+
+/**
+ * A scan request. Initially, it should specify a scan. Later on, you
+ * can use the scanner id returned to fetch result batches with a different
+ * scan request.
+ *
+ * The scanner will remain open if there are more results, and it's not
+ * asked to be closed explicitly.
+ *
+ * You can fetch the results and ask the scanner to be closed to save
+ * a trip if you are not interested in remaining results.
+ */
+message ScanRequest {
+  optional RegionSpecifier region = 1;
+  optional Scan scan = 2;
+  optional uint64 scanner_id = 3;
+  optional uint32 number_of_rows = 4;
+  optional bool close_scanner = 5;
+  optional uint64 next_call_seq = 6;
+  optional bool client_handles_partials = 7;
+  optional bool client_handles_heartbeats = 8;
+  optional bool track_scan_metrics = 9;
+  optional bool renew = 10 [default = false];
+}
+
+/**
+ * The scan response. If there are no more results, more_results will
+ * be false.  If it is not specified, it means there are more.
+ */
+message ScanResponse {
+  // This field is filled in if we are doing cellblocks.  A cellblock is made up
+  // of all Cells serialized out as one cellblock BUT responses from a server
+  // have their Cells grouped by Result.  So we can reconstitute the
+  // Results on the client-side, this field is a list of counts of Cells
+  // in each Result that makes up the response.  For example, if this field
+  // has 3, 3, 3 in it, then we know that on the client, we are to make
+  // three Results each of three Cells each.
+  repeated uint32 cells_per_result = 1;
+
+  optional uint64 scanner_id = 2;
+  optional bool more_results = 3;
+  optional uint32 ttl = 4;
+  // If cells are not carried in an accompanying cellblock, then they are pb'd here.
+  // This field is mutually exclusive with cells_per_result (since the Cells will
+  // be inside the pb'd Result)
+  repeated Result results = 5;
+  optional bool stale = 6;
+
+  // This field is filled in if we are doing cellblocks. In the event that a row
+  // could not fit all of its cells into a single RPC chunk, the results will be
+  // returned as partials, and reconstructed into a complete result on the client
+  // side. This field is a list of flags indicating whether or not the result
+  // that the cells belong to is a partial result. For example, if this field
+  // has false, false, true in it, then we know that on the client side, we need to
+  // make another RPC request since the last result was only a partial.
+  repeated bool partial_flag_per_result = 7;
+
+  // A server may choose to limit the number of results returned to the client for
+  // reasons such as the size in bytes or quantity of results accumulated. This field
+  // will true when more results exist in the current region.
+  optional bool more_results_in_region = 8;
+  
+  // This field is filled in if the server is sending back a heartbeat message.
+  // Heartbeat messages are sent back to the client to prevent the scanner from
+  // timing out. Seeing a heartbeat message communicates to the Client that the
+  // server would have continued to scan had the time limit not been reached.
+  optional bool heartbeat_message = 9;
+  
+  // This field is filled in if the client has requested that scan metrics be tracked.
+  // The metrics tracked here are sent back to the client to be tracked together with 
+  // the existing client side metrics.
+  //optional ScanMetrics scan_metrics = 10; // not in gohbase
+}
+
+/**
+ * Atomically bulk load multiple HFiles (say from different column families)
+ * into an open region.
+ */
+message BulkLoadHFileRequest {
+  required RegionSpecifier region = 1;
+  repeated FamilyPath family_path = 2;
+  optional bool assign_seq_num = 3;
+
+  message FamilyPath {
+    required bytes family = 1;
+    required string path = 2;
+  }
+}
+
+message BulkLoadHFileResponse {
+  required bool loaded = 1;
+}
+
+message CoprocessorServiceCall {
+  required bytes row = 1;
+  required string service_name = 2;
+  required string method_name = 3;
+  required bytes request = 4;
+}
+
+message CoprocessorServiceResult {
+  optional NameBytesPair value = 1;
+}
+
+message CoprocessorServiceRequest {
+  required RegionSpecifier region = 1;
+  required CoprocessorServiceCall call = 2;
+}
+
+message CoprocessorServiceResponse {
+  required RegionSpecifier region = 1;
+  required NameBytesPair value = 2;
+}
+
+// Either a Get or a Mutation
+message Action {
+  // If part of a multi action, useful aligning
+  // result with what was originally submitted.
+  optional uint32 index = 1;
+  optional MutationProto mutation = 2;
+  optional Get get = 3;
+  optional CoprocessorServiceCall service_call = 4;
+}
+
+/**
+ * Actions to run against a Region.
+ */
+message RegionAction {
+  required RegionSpecifier region = 1;
+  // When set, run mutations as atomic unit.
+  optional bool atomic = 2;
+  repeated Action action = 3;
+}
+
+/*
+* Statistics about the current load on the region
+*/
+message RegionLoadStats {
+  // Percent load on the memstore. Guaranteed to be positive, between 0 and 100.
+  optional int32 memstoreLoad = 1 [default = 0];
+  // Percent JVM heap occupancy. Guaranteed to be positive, between 0 and 100.
+  // We can move this to "ServerLoadStats" should we develop them.
+  optional int32 heapOccupancy = 2 [default = 0];
+  // Compaction pressure. Guaranteed to be positive, between 0 and 100.
+  optional int32 compactionPressure = 3 [default = 0];
+}
+
+message MultiRegionLoadStats{
+  repeated RegionSpecifier region = 1;
+  repeated RegionLoadStats stat = 2;
+}
+
+/**
+ * Either a Result or an Exception NameBytesPair (keyed by
+ * exception name whose value is the exception stringified)
+ * or maybe empty if no result and no exception.
+ */
+message ResultOrException {
+  // If part of a multi call, save original index of the list of all
+  // passed so can align this response w/ original request.
+  optional uint32 index = 1;
+  optional Result result = 2;
+  optional NameBytesPair exception = 3;
+  // result if this was a coprocessor service call
+  optional CoprocessorServiceResult service_result = 4;
+  // current load on the region
+  optional RegionLoadStats loadStats = 5 [deprecated=true];
+}
+
+/**
+ * The result of a RegionAction.
+ */
+message RegionActionResult {
+  repeated ResultOrException resultOrException = 1;
+  // If the operation failed globally for this region, this exception is set
+  optional NameBytesPair exception = 2;
+}
+
+/**
+ * Execute a list of actions on a given region in order.
+ * Nothing prevents a request to contains a set of RegionAction on the same region.
+ * For this reason, the matching between the MultiRequest and the MultiResponse is not
+ *  done by the region specifier but by keeping the order of the RegionActionResult vs.
+ *  the order of the RegionAction.
+ */
+message MultiRequest {
+  repeated RegionAction regionAction = 1;
+  optional uint64 nonceGroup = 2;
+  optional Condition condition = 3;
+}
+
+message MultiResponse {
+  repeated RegionActionResult regionActionResult = 1;
+  // used for mutate to indicate processed only
+  optional bool processed = 2;
+  optional MultiRegionLoadStats regionStatistics = 3;
+}
+
+
+service ClientService {
+  rpc Get(GetRequest)
+    returns(GetResponse);
+
+  rpc Mutate(MutateRequest)
+    returns(MutateResponse);
+
+  rpc Scan(ScanRequest)
+    returns(ScanResponse);
+
+  rpc BulkLoadHFile(BulkLoadHFileRequest)
+    returns(BulkLoadHFileResponse);
+
+  rpc ExecService(CoprocessorServiceRequest)
+    returns(CoprocessorServiceResponse);
+    
+  rpc ExecRegionServerService(CoprocessorServiceRequest)
+    returns(CoprocessorServiceResponse);
+
+  rpc Multi(MultiRequest)
+    returns(MultiResponse);
+}

vendor/github.com/tsuna/gohbase/pb/ClusterId.pb.go

@@ -0,0 +1,52 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: ClusterId.proto
+
+package pb
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// *
+// Content of the '/hbase/hbaseid', cluster id, znode.
+// Also cluster of the ${HBASE_ROOTDIR}/hbase.id file.
+type ClusterId struct {
+	// This is the cluster id, a uuid as a String
+	ClusterId        *string `protobuf:"bytes,1,req,name=cluster_id,json=clusterId" json:"cluster_id,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *ClusterId) Reset()                    { *m = ClusterId{} }
+func (m *ClusterId) String() string            { return proto.CompactTextString(m) }
+func (*ClusterId) ProtoMessage()               {}
+func (*ClusterId) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{0} }
+
+func (m *ClusterId) GetClusterId() string {
+	if m != nil && m.ClusterId != nil {
+		return *m.ClusterId
+	}
+	return ""
+}
+
+func init() {
+	proto.RegisterType((*ClusterId)(nil), "pb.ClusterId")
+}
+
+func init() { proto.RegisterFile("ClusterId.proto", fileDescriptor4) }
+
+var fileDescriptor4 = []byte{
+	// 126 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x77, 0xce, 0x29, 0x2d,
+	0x2e, 0x49, 0x2d, 0xf2, 0x4c, 0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x2a, 0x48, 0x52,
+	0xd2, 0xe2, 0xe2, 0x84, 0x0b, 0x0b, 0xc9, 0x72, 0x71, 0x25, 0x43, 0x38, 0xf1, 0x99, 0x29, 0x12,
+	0x8c, 0x0a, 0x4c, 0x1a, 0x9c, 0x41, 0x9c, 0xc9, 0x30, 0x69, 0x27, 0x27, 0x2e, 0xad, 0xfc, 0xa2,
+	0x74, 0xbd, 0xc4, 0x82, 0xc4, 0xe4, 0x8c, 0x54, 0xbd, 0x8c, 0xc4, 0x94, 0xfc, 0xfc, 0x02, 0xbd,
+	0x8c, 0xa4, 0xc4, 0xe2, 0x54, 0x88, 0x81, 0x49, 0xa5, 0x69, 0x7a, 0xe9, 0xa9, 0x79, 0xa9, 0x45,
+	0x89, 0x25, 0xa9, 0x29, 0x4e, 0x08, 0xeb, 0x02, 0x40, 0x92, 0xc5, 0x1e, 0x8c, 0x0b, 0x18, 0x19,
+	0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0x3d, 0x70, 0xa4, 0x7a, 0x85, 0x00, 0x00, 0x00,
+}

vendor/github.com/tsuna/gohbase/pb/ClusterId.proto

@@ -0,0 +1,34 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// This file contains protocol buffers that are shared throughout HBase
+package pb;
+
+option java_package = "org.apache.hadoop.hbase.protobuf.generated";
+option java_outer_classname = "ClusterIdProtos";
+option java_generate_equals_and_hash = true;
+option optimize_for = SPEED;
+
+/**
+ * Content of the '/hbase/hbaseid', cluster id, znode.
+ * Also cluster of the ${HBASE_ROOTDIR}/hbase.id file.
+ */
+message ClusterId {
+  // This is the cluster id, a uuid as a String
+  required string cluster_id = 1;
+}

vendor/github.com/tsuna/gohbase/pb/ClusterStatus.pb.go

@@ -0,0 +1,789 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: ClusterStatus.proto
+
+package pb
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+type RegionState_State int32
+
+const (
+	RegionState_OFFLINE       RegionState_State = 0
+	RegionState_PENDING_OPEN  RegionState_State = 1
+	RegionState_OPENING       RegionState_State = 2
+	RegionState_OPEN          RegionState_State = 3
+	RegionState_PENDING_CLOSE RegionState_State = 4
+	RegionState_CLOSING       RegionState_State = 5
+	RegionState_CLOSED        RegionState_State = 6
+	RegionState_SPLITTING     RegionState_State = 7
+	RegionState_SPLIT         RegionState_State = 8
+	RegionState_FAILED_OPEN   RegionState_State = 9
+	RegionState_FAILED_CLOSE  RegionState_State = 10
+	RegionState_MERGING       RegionState_State = 11
+	RegionState_MERGED        RegionState_State = 12
+	RegionState_SPLITTING_NEW RegionState_State = 13
+	// region but hasn't be created yet, or master doesn't
+	// know it's already created
+	RegionState_MERGING_NEW RegionState_State = 14
+)
+
+var RegionState_State_name = map[int32]string{
+	0:  "OFFLINE",
+	1:  "PENDING_OPEN",
+	2:  "OPENING",
+	3:  "OPEN",
+	4:  "PENDING_CLOSE",
+	5:  "CLOSING",
+	6:  "CLOSED",
+	7:  "SPLITTING",
+	8:  "SPLIT",
+	9:  "FAILED_OPEN",
+	10: "FAILED_CLOSE",
+	11: "MERGING",
+	12: "MERGED",
+	13: "SPLITTING_NEW",
+	14: "MERGING_NEW",
+}
+var RegionState_State_value = map[string]int32{
+	"OFFLINE":       0,
+	"PENDING_OPEN":  1,
+	"OPENING":       2,
+	"OPEN":          3,
+	"PENDING_CLOSE": 4,
+	"CLOSING":       5,
+	"CLOSED":        6,
+	"SPLITTING":     7,
+	"SPLIT":         8,
+	"FAILED_OPEN":   9,
+	"FAILED_CLOSE":  10,
+	"MERGING":       11,
+	"MERGED":        12,
+	"SPLITTING_NEW": 13,
+	"MERGING_NEW":   14,
+}
+
+func (x RegionState_State) Enum() *RegionState_State {
+	p := new(RegionState_State)
+	*p = x
+	return p
+}
+func (x RegionState_State) String() string {
+	return proto.EnumName(RegionState_State_name, int32(x))
+}
+func (x *RegionState_State) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(RegionState_State_value, data, "RegionState_State")
+	if err != nil {
+		return err
+	}
+	*x = RegionState_State(value)
+	return nil
+}
+func (RegionState_State) EnumDescriptor() ([]byte, []int) { return fileDescriptor5, []int{0, 0} }
+
+type RegionState struct {
+	RegionInfo       *RegionInfo        `protobuf:"bytes,1,req,name=region_info,json=regionInfo" json:"region_info,omitempty"`
+	State            *RegionState_State `protobuf:"varint,2,req,name=state,enum=pb.RegionState_State" json:"state,omitempty"`
+	Stamp            *uint64            `protobuf:"varint,3,opt,name=stamp" json:"stamp,omitempty"`
+	XXX_unrecognized []byte             `json:"-"`
+}
+
+func (m *RegionState) Reset()                    { *m = RegionState{} }
+func (m *RegionState) String() string            { return proto.CompactTextString(m) }
+func (*RegionState) ProtoMessage()               {}
+func (*RegionState) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{0} }
+
+func (m *RegionState) GetRegionInfo() *RegionInfo {
+	if m != nil {
+		return m.RegionInfo
+	}
+	return nil
+}
+
+func (m *RegionState) GetState() RegionState_State {
+	if m != nil && m.State != nil {
+		return *m.State
+	}
+	return RegionState_OFFLINE
+}
+
+func (m *RegionState) GetStamp() uint64 {
+	if m != nil && m.Stamp != nil {
+		return *m.Stamp
+	}
+	return 0
+}
+
+type RegionInTransition struct {
+	Spec             *RegionSpecifier `protobuf:"bytes,1,req,name=spec" json:"spec,omitempty"`
+	RegionState      *RegionState     `protobuf:"bytes,2,req,name=region_state,json=regionState" json:"region_state,omitempty"`
+	XXX_unrecognized []byte           `json:"-"`
+}
+
+func (m *RegionInTransition) Reset()                    { *m = RegionInTransition{} }
+func (m *RegionInTransition) String() string            { return proto.CompactTextString(m) }
+func (*RegionInTransition) ProtoMessage()               {}
+func (*RegionInTransition) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{1} }
+
+func (m *RegionInTransition) GetSpec() *RegionSpecifier {
+	if m != nil {
+		return m.Spec
+	}
+	return nil
+}
+
+func (m *RegionInTransition) GetRegionState() *RegionState {
+	if m != nil {
+		return m.RegionState
+	}
+	return nil
+}
+
+// *
+// sequence Id of a store
+type StoreSequenceId struct {
+	FamilyName       []byte  `protobuf:"bytes,1,req,name=family_name,json=familyName" json:"family_name,omitempty"`
+	SequenceId       *uint64 `protobuf:"varint,2,req,name=sequence_id,json=sequenceId" json:"sequence_id,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *StoreSequenceId) Reset()                    { *m = StoreSequenceId{} }
+func (m *StoreSequenceId) String() string            { return proto.CompactTextString(m) }
+func (*StoreSequenceId) ProtoMessage()               {}
+func (*StoreSequenceId) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{2} }
+
+func (m *StoreSequenceId) GetFamilyName() []byte {
+	if m != nil {
+		return m.FamilyName
+	}
+	return nil
+}
+
+func (m *StoreSequenceId) GetSequenceId() uint64 {
+	if m != nil && m.SequenceId != nil {
+		return *m.SequenceId
+	}
+	return 0
+}
+
+// *
+// contains a sequence id of a region which should be the minimum of its store sequence ids and
+// list of sequence ids of the region's stores
+type RegionStoreSequenceIds struct {
+	LastFlushedSequenceId *uint64            `protobuf:"varint,1,req,name=last_flushed_sequence_id,json=lastFlushedSequenceId" json:"last_flushed_sequence_id,omitempty"`
+	StoreSequenceId       []*StoreSequenceId `protobuf:"bytes,2,rep,name=store_sequence_id,json=storeSequenceId" json:"store_sequence_id,omitempty"`
+	XXX_unrecognized      []byte             `json:"-"`
+}
+
+func (m *RegionStoreSequenceIds) Reset()                    { *m = RegionStoreSequenceIds{} }
+func (m *RegionStoreSequenceIds) String() string            { return proto.CompactTextString(m) }
+func (*RegionStoreSequenceIds) ProtoMessage()               {}
+func (*RegionStoreSequenceIds) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{3} }
+
+func (m *RegionStoreSequenceIds) GetLastFlushedSequenceId() uint64 {
+	if m != nil && m.LastFlushedSequenceId != nil {
+		return *m.LastFlushedSequenceId
+	}
+	return 0
+}
+
+func (m *RegionStoreSequenceIds) GetStoreSequenceId() []*StoreSequenceId {
+	if m != nil {
+		return m.StoreSequenceId
+	}
+	return nil
+}
+
+type RegionLoad struct {
+	// * the region specifier
+	RegionSpecifier *RegionSpecifier `protobuf:"bytes,1,req,name=region_specifier,json=regionSpecifier" json:"region_specifier,omitempty"`
+	// * the number of stores for the region
+	Stores *uint32 `protobuf:"varint,2,opt,name=stores" json:"stores,omitempty"`
+	// * the number of storefiles for the region
+	Storefiles *uint32 `protobuf:"varint,3,opt,name=storefiles" json:"storefiles,omitempty"`
+	// * the total size of the store files for the region, uncompressed, in MB
+	StoreUncompressedSize_MB *uint32 `protobuf:"varint,4,opt,name=store_uncompressed_size_MB,json=storeUncompressedSizeMB" json:"store_uncompressed_size_MB,omitempty"`
+	// * the current total size of the store files for the region, in MB
+	StorefileSize_MB *uint32 `protobuf:"varint,5,opt,name=storefile_size_MB,json=storefileSizeMB" json:"storefile_size_MB,omitempty"`
+	// * the current size of the memstore for the region, in MB
+	MemstoreSize_MB *uint32 `protobuf:"varint,6,opt,name=memstore_size_MB,json=memstoreSizeMB" json:"memstore_size_MB,omitempty"`
+	// *
+	// The current total size of root-level store file indexes for the region,
+	// in MB. The same as {@link #rootIndexSizeKB} but in MB.
+	StorefileIndexSize_MB *uint32 `protobuf:"varint,7,opt,name=storefile_index_size_MB,json=storefileIndexSizeMB" json:"storefile_index_size_MB,omitempty"`
+	// * the current total read requests made to region
+	ReadRequestsCount *uint64 `protobuf:"varint,8,opt,name=read_requests_count,json=readRequestsCount" json:"read_requests_count,omitempty"`
+	// * the current total write requests made to region
+	WriteRequestsCount *uint64 `protobuf:"varint,9,opt,name=write_requests_count,json=writeRequestsCount" json:"write_requests_count,omitempty"`
+	// * the total compacting key values in currently running compaction
+	TotalCompacting_KVs *uint64 `protobuf:"varint,10,opt,name=total_compacting_KVs,json=totalCompactingKVs" json:"total_compacting_KVs,omitempty"`
+	// * the completed count of key values in currently running compaction
+	CurrentCompacted_KVs *uint64 `protobuf:"varint,11,opt,name=current_compacted_KVs,json=currentCompactedKVs" json:"current_compacted_KVs,omitempty"`
+	// * The current total size of root-level indexes for the region, in KB.
+	RootIndexSize_KB *uint32 `protobuf:"varint,12,opt,name=root_index_size_KB,json=rootIndexSizeKB" json:"root_index_size_KB,omitempty"`
+	// * The total size of all index blocks, not just the root level, in KB.
+	TotalStaticIndexSize_KB *uint32 `protobuf:"varint,13,opt,name=total_static_index_size_KB,json=totalStaticIndexSizeKB" json:"total_static_index_size_KB,omitempty"`
+	// *
+	// The total size of all Bloom filter blocks, not just loaded into the
+	// block cache, in KB.
+	TotalStaticBloomSize_KB *uint32 `protobuf:"varint,14,opt,name=total_static_bloom_size_KB,json=totalStaticBloomSizeKB" json:"total_static_bloom_size_KB,omitempty"`
+	// * the most recent sequence Id from cache flush
+	CompleteSequenceId *uint64 `protobuf:"varint,15,opt,name=complete_sequence_id,json=completeSequenceId" json:"complete_sequence_id,omitempty"`
+	// * The current data locality for region in the regionserver
+	DataLocality          *float32 `protobuf:"fixed32,16,opt,name=data_locality,json=dataLocality" json:"data_locality,omitempty"`
+	LastMajorCompactionTs *uint64  `protobuf:"varint,17,opt,name=last_major_compaction_ts,json=lastMajorCompactionTs,def=0" json:"last_major_compaction_ts,omitempty"`
+	// * the most recent sequence Id of store from cache flush
+	StoreCompleteSequenceId []*StoreSequenceId `protobuf:"bytes,18,rep,name=store_complete_sequence_id,json=storeCompleteSequenceId" json:"store_complete_sequence_id,omitempty"`
+	XXX_unrecognized        []byte             `json:"-"`
+}
+
+func (m *RegionLoad) Reset()                    { *m = RegionLoad{} }
+func (m *RegionLoad) String() string            { return proto.CompactTextString(m) }
+func (*RegionLoad) ProtoMessage()               {}
+func (*RegionLoad) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{4} }
+
+const Default_RegionLoad_LastMajorCompactionTs uint64 = 0
+
+func (m *RegionLoad) GetRegionSpecifier() *RegionSpecifier {
+	if m != nil {
+		return m.RegionSpecifier
+	}
+	return nil
+}
+
+func (m *RegionLoad) GetStores() uint32 {
+	if m != nil && m.Stores != nil {
+		return *m.Stores
+	}
+	return 0
+}
+
+func (m *RegionLoad) GetStorefiles() uint32 {
+	if m != nil && m.Storefiles != nil {
+		return *m.Storefiles
+	}
+	return 0
+}
+
+func (m *RegionLoad) GetStoreUncompressedSize_MB() uint32 {
+	if m != nil && m.StoreUncompressedSize_MB != nil {
+		return *m.StoreUncompressedSize_MB
+	}
+	return 0
+}
+
+func (m *RegionLoad) GetStorefileSize_MB() uint32 {
+	if m != nil && m.StorefileSize_MB != nil {
+		return *m.StorefileSize_MB
+	}
+	return 0
+}
+
+func (m *RegionLoad) GetMemstoreSize_MB() uint32 {
+	if m != nil && m.MemstoreSize_MB != nil {
+		return *m.MemstoreSize_MB
+	}
+	return 0
+}
+
+func (m *RegionLoad) GetStorefileIndexSize_MB() uint32 {
+	if m != nil && m.StorefileIndexSize_MB != nil {
+		return *m.StorefileIndexSize_MB
+	}
+	return 0
+}
+
+func (m *RegionLoad) GetReadRequestsCount() uint64 {
+	if m != nil && m.ReadRequestsCount != nil {
+		return *m.ReadRequestsCount
+	}
+	return 0
+}
+
+func (m *RegionLoad) GetWriteRequestsCount() uint64 {
+	if m != nil && m.WriteRequestsCount != nil {
+		return *m.WriteRequestsCount
+	}
+	return 0
+}
+
+func (m *RegionLoad) GetTotalCompacting_KVs() uint64 {
+	if m != nil && m.TotalCompacting_KVs != nil {
+		return *m.TotalCompacting_KVs
+	}
+	return 0
+}
+
+func (m *RegionLoad) GetCurrentCompacted_KVs() uint64 {
+	if m != nil && m.CurrentCompacted_KVs != nil {
+		return *m.CurrentCompacted_KVs
+	}
+	return 0
+}
+
+func (m *RegionLoad) GetRootIndexSize_KB() uint32 {
+	if m != nil && m.RootIndexSize_KB != nil {
+		return *m.RootIndexSize_KB
+	}
+	return 0
+}
+
+func (m *RegionLoad) GetTotalStaticIndexSize_KB() uint32 {
+	if m != nil && m.TotalStaticIndexSize_KB != nil {
+		return *m.TotalStaticIndexSize_KB
+	}
+	return 0
+}
+
+func (m *RegionLoad) GetTotalStaticBloomSize_KB() uint32 {
+	if m != nil && m.TotalStaticBloomSize_KB != nil {
+		return *m.TotalStaticBloomSize_KB
+	}
+	return 0
+}
+
+func (m *RegionLoad) GetCompleteSequenceId() uint64 {
+	if m != nil && m.CompleteSequenceId != nil {
+		return *m.CompleteSequenceId
+	}
+	return 0
+}
+
+func (m *RegionLoad) GetDataLocality() float32 {
+	if m != nil && m.DataLocality != nil {
+		return *m.DataLocality
+	}
+	return 0
+}
+
+func (m *RegionLoad) GetLastMajorCompactionTs() uint64 {
+	if m != nil && m.LastMajorCompactionTs != nil {
+		return *m.LastMajorCompactionTs
+	}
+	return Default_RegionLoad_LastMajorCompactionTs
+}
+
+func (m *RegionLoad) GetStoreCompleteSequenceId() []*StoreSequenceId {
+	if m != nil {
+		return m.StoreCompleteSequenceId
+	}
+	return nil
+}
+
+type ReplicationLoadSink struct {
+	AgeOfLastAppliedOp        *uint64 `protobuf:"varint,1,req,name=ageOfLastAppliedOp" json:"ageOfLastAppliedOp,omitempty"`
+	TimeStampsOfLastAppliedOp *uint64 `protobuf:"varint,2,req,name=timeStampsOfLastAppliedOp" json:"timeStampsOfLastAppliedOp,omitempty"`
+	XXX_unrecognized          []byte  `json:"-"`
+}
+
+func (m *ReplicationLoadSink) Reset()                    { *m = ReplicationLoadSink{} }
+func (m *ReplicationLoadSink) String() string            { return proto.CompactTextString(m) }
+func (*ReplicationLoadSink) ProtoMessage()               {}
+func (*ReplicationLoadSink) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{5} }
+
+func (m *ReplicationLoadSink) GetAgeOfLastAppliedOp() uint64 {
+	if m != nil && m.AgeOfLastAppliedOp != nil {
+		return *m.AgeOfLastAppliedOp
+	}
+	return 0
+}
+
+func (m *ReplicationLoadSink) GetTimeStampsOfLastAppliedOp() uint64 {
+	if m != nil && m.TimeStampsOfLastAppliedOp != nil {
+		return *m.TimeStampsOfLastAppliedOp
+	}
+	return 0
+}
+
+type ReplicationLoadSource struct {
+	PeerID                   *string `protobuf:"bytes,1,req,name=peerID" json:"peerID,omitempty"`
+	AgeOfLastShippedOp       *uint64 `protobuf:"varint,2,req,name=ageOfLastShippedOp" json:"ageOfLastShippedOp,omitempty"`
+	SizeOfLogQueue           *uint32 `protobuf:"varint,3,req,name=sizeOfLogQueue" json:"sizeOfLogQueue,omitempty"`
+	TimeStampOfLastShippedOp *uint64 `protobuf:"varint,4,req,name=timeStampOfLastShippedOp" json:"timeStampOfLastShippedOp,omitempty"`
+	ReplicationLag           *uint64 `protobuf:"varint,5,req,name=replicationLag" json:"replicationLag,omitempty"`
+	XXX_unrecognized         []byte  `json:"-"`
+}
+
+func (m *ReplicationLoadSource) Reset()                    { *m = ReplicationLoadSource{} }
+func (m *ReplicationLoadSource) String() string            { return proto.CompactTextString(m) }
+func (*ReplicationLoadSource) ProtoMessage()               {}
+func (*ReplicationLoadSource) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{6} }
+
+func (m *ReplicationLoadSource) GetPeerID() string {
+	if m != nil && m.PeerID != nil {
+		return *m.PeerID
+	}
+	return ""
+}
+
+func (m *ReplicationLoadSource) GetAgeOfLastShippedOp() uint64 {
+	if m != nil && m.AgeOfLastShippedOp != nil {
+		return *m.AgeOfLastShippedOp
+	}
+	return 0
+}
+
+func (m *ReplicationLoadSource) GetSizeOfLogQueue() uint32 {
+	if m != nil && m.SizeOfLogQueue != nil {
+		return *m.SizeOfLogQueue
+	}
+	return 0
+}
+
+func (m *ReplicationLoadSource) GetTimeStampOfLastShippedOp() uint64 {
+	if m != nil && m.TimeStampOfLastShippedOp != nil {
+		return *m.TimeStampOfLastShippedOp
+	}
+	return 0
+}
+
+func (m *ReplicationLoadSource) GetReplicationLag() uint64 {
+	if m != nil && m.ReplicationLag != nil {
+		return *m.ReplicationLag
+	}
+	return 0
+}
+
+type ServerLoad struct {
+	// * Number of requests since last report.
+	NumberOfRequests *uint64 `protobuf:"varint,1,opt,name=number_of_requests,json=numberOfRequests" json:"number_of_requests,omitempty"`
+	// * Total Number of requests from the start of the region server.
+	TotalNumberOfRequests *uint64 `protobuf:"varint,2,opt,name=total_number_of_requests,json=totalNumberOfRequests" json:"total_number_of_requests,omitempty"`
+	// * the amount of used heap, in MB.
+	UsedHeap_MB *uint32 `protobuf:"varint,3,opt,name=used_heap_MB,json=usedHeapMB" json:"used_heap_MB,omitempty"`
+	// * the maximum allowable size of the heap, in MB.
+	MaxHeap_MB *uint32 `protobuf:"varint,4,opt,name=max_heap_MB,json=maxHeapMB" json:"max_heap_MB,omitempty"`
+	// * Information on the load of individual regions.
+	RegionLoads []*RegionLoad `protobuf:"bytes,5,rep,name=region_loads,json=regionLoads" json:"region_loads,omitempty"`
+	// *
+	// Regionserver-level coprocessors, e.g., WALObserver implementations.
+	// Region-level coprocessors, on the other hand, are stored inside RegionLoad
+	// objects.
+	Coprocessors []*Coprocessor `protobuf:"bytes,6,rep,name=coprocessors" json:"coprocessors,omitempty"`
+	// *
+	// Time when incremental (non-total) counts began being calculated (e.g. number_of_requests)
+	// time is measured as the difference, measured in milliseconds, between the current time
+	// and midnight, January 1, 1970 UTC.
+	ReportStartTime *uint64 `protobuf:"varint,7,opt,name=report_start_time,json=reportStartTime" json:"report_start_time,omitempty"`
+	// *
+	// Time when report was generated.
+	// time is measured as the difference, measured in milliseconds, between the current time
+	// and midnight, January 1, 1970 UTC.
+	ReportEndTime *uint64 `protobuf:"varint,8,opt,name=report_end_time,json=reportEndTime" json:"report_end_time,omitempty"`
+	// *
+	// The port number that this region server is hosing an info server on.
+	InfoServerPort *uint32 `protobuf:"varint,9,opt,name=info_server_port,json=infoServerPort" json:"info_server_port,omitempty"`
+	// *
+	// The replicationLoadSource for the replication Source status of this region server.
+	ReplLoadSource []*ReplicationLoadSource `protobuf:"bytes,10,rep,name=replLoadSource" json:"replLoadSource,omitempty"`
+	// *
+	// The replicationLoadSink for the replication Sink status of this region server.
+	ReplLoadSink     *ReplicationLoadSink `protobuf:"bytes,11,opt,name=replLoadSink" json:"replLoadSink,omitempty"`
+	XXX_unrecognized []byte               `json:"-"`
+}
+
+func (m *ServerLoad) Reset()                    { *m = ServerLoad{} }
+func (m *ServerLoad) String() string            { return proto.CompactTextString(m) }
+func (*ServerLoad) ProtoMessage()               {}
+func (*ServerLoad) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{7} }
+
+func (m *ServerLoad) GetNumberOfRequests() uint64 {
+	if m != nil && m.NumberOfRequests != nil {
+		return *m.NumberOfRequests
+	}
+	return 0
+}
+
+func (m *ServerLoad) GetTotalNumberOfRequests() uint64 {
+	if m != nil && m.TotalNumberOfRequests != nil {
+		return *m.TotalNumberOfRequests
+	}
+	return 0
+}
+
+func (m *ServerLoad) GetUsedHeap_MB() uint32 {
+	if m != nil && m.UsedHeap_MB != nil {
+		return *m.UsedHeap_MB
+	}
+	return 0
+}
+
+func (m *ServerLoad) GetMaxHeap_MB() uint32 {
+	if m != nil && m.MaxHeap_MB != nil {
+		return *m.MaxHeap_MB
+	}
+	return 0
+}
+
+func (m *ServerLoad) GetRegionLoads() []*RegionLoad {
+	if m != nil {
+		return m.RegionLoads
+	}
+	return nil
+}
+
+func (m *ServerLoad) GetCoprocessors() []*Coprocessor {
+	if m != nil {
+		return m.Coprocessors
+	}
+	return nil
+}
+
+func (m *ServerLoad) GetReportStartTime() uint64 {
+	if m != nil && m.ReportStartTime != nil {
+		return *m.ReportStartTime
+	}
+	return 0
+}
+
+func (m *ServerLoad) GetReportEndTime() uint64 {
+	if m != nil && m.ReportEndTime != nil {
+		return *m.ReportEndTime
+	}
+	return 0
+}
+
+func (m *ServerLoad) GetInfoServerPort() uint32 {
+	if m != nil && m.InfoServerPort != nil {
+		return *m.InfoServerPort
+	}
+	return 0
+}
+
+func (m *ServerLoad) GetReplLoadSource() []*ReplicationLoadSource {
+	if m != nil {
+		return m.ReplLoadSource
+	}
+	return nil
+}
+
+func (m *ServerLoad) GetReplLoadSink() *ReplicationLoadSink {
+	if m != nil {
+		return m.ReplLoadSink
+	}
+	return nil
+}
+
+type LiveServerInfo struct {
+	Server           *ServerName `protobuf:"bytes,1,req,name=server" json:"server,omitempty"`
+	ServerLoad       *ServerLoad `protobuf:"bytes,2,req,name=server_load,json=serverLoad" json:"server_load,omitempty"`
+	XXX_unrecognized []byte      `json:"-"`
+}
+
+func (m *LiveServerInfo) Reset()                    { *m = LiveServerInfo{} }
+func (m *LiveServerInfo) String() string            { return proto.CompactTextString(m) }
+func (*LiveServerInfo) ProtoMessage()               {}
+func (*LiveServerInfo) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{8} }
+
+func (m *LiveServerInfo) GetServer() *ServerName {
+	if m != nil {
+		return m.Server
+	}
+	return nil
+}
+
+func (m *LiveServerInfo) GetServerLoad() *ServerLoad {
+	if m != nil {
+		return m.ServerLoad
+	}
+	return nil
+}
+
+type ClusterStatus struct {
+	HbaseVersion        *HBaseVersionFileContent `protobuf:"bytes,1,opt,name=hbase_version,json=hbaseVersion" json:"hbase_version,omitempty"`
+	LiveServers         []*LiveServerInfo        `protobuf:"bytes,2,rep,name=live_servers,json=liveServers" json:"live_servers,omitempty"`
+	DeadServers         []*ServerName            `protobuf:"bytes,3,rep,name=dead_servers,json=deadServers" json:"dead_servers,omitempty"`
+	RegionsInTransition []*RegionInTransition    `protobuf:"bytes,4,rep,name=regions_in_transition,json=regionsInTransition" json:"regions_in_transition,omitempty"`
+	ClusterId           *ClusterId               `protobuf:"bytes,5,opt,name=cluster_id,json=clusterId" json:"cluster_id,omitempty"`
+	MasterCoprocessors  []*Coprocessor           `protobuf:"bytes,6,rep,name=master_coprocessors,json=masterCoprocessors" json:"master_coprocessors,omitempty"`
+	Master              *ServerName              `protobuf:"bytes,7,opt,name=master" json:"master,omitempty"`
+	BackupMasters       []*ServerName            `protobuf:"bytes,8,rep,name=backup_masters,json=backupMasters" json:"backup_masters,omitempty"`
+	BalancerOn          *bool                    `protobuf:"varint,9,opt,name=balancer_on,json=balancerOn" json:"balancer_on,omitempty"`
+	XXX_unrecognized    []byte                   `json:"-"`
+}
+
+func (m *ClusterStatus) Reset()                    { *m = ClusterStatus{} }
+func (m *ClusterStatus) String() string            { return proto.CompactTextString(m) }
+func (*ClusterStatus) ProtoMessage()               {}
+func (*ClusterStatus) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{9} }
+
+func (m *ClusterStatus) GetHbaseVersion() *HBaseVersionFileContent {
+	if m != nil {
+		return m.HbaseVersion
+	}
+	return nil
+}
+
+func (m *ClusterStatus) GetLiveServers() []*LiveServerInfo {
+	if m != nil {
+		return m.LiveServers
+	}
+	return nil
+}
+
+func (m *ClusterStatus) GetDeadServers() []*ServerName {
+	if m != nil {
+		return m.DeadServers
+	}
+	return nil
+}
+
+func (m *ClusterStatus) GetRegionsInTransition() []*RegionInTransition {
+	if m != nil {
+		return m.RegionsInTransition
+	}
+	return nil
+}
+
+func (m *ClusterStatus) GetClusterId() *ClusterId {
+	if m != nil {
+		return m.ClusterId
+	}
+	return nil
+}
+
+func (m *ClusterStatus) GetMasterCoprocessors() []*Coprocessor {
+	if m != nil {
+		return m.MasterCoprocessors
+	}
+	return nil
+}
+
+func (m *ClusterStatus) GetMaster() *ServerName {
+	if m != nil {
+		return m.Master
+	}
+	return nil
+}
+
+func (m *ClusterStatus) GetBackupMasters() []*ServerName {
+	if m != nil {
+		return m.BackupMasters
+	}
+	return nil
+}
+
+func (m *ClusterStatus) GetBalancerOn() bool {
+	if m != nil && m.BalancerOn != nil {
+		return *m.BalancerOn
+	}
+	return false
+}
+
+func init() {
+	proto.RegisterType((*RegionState)(nil), "pb.RegionState")
+	proto.RegisterType((*RegionInTransition)(nil), "pb.RegionInTransition")
+	proto.RegisterType((*StoreSequenceId)(nil), "pb.StoreSequenceId")
+	proto.RegisterType((*RegionStoreSequenceIds)(nil), "pb.RegionStoreSequenceIds")
+	proto.RegisterType((*RegionLoad)(nil), "pb.RegionLoad")
+	proto.RegisterType((*ReplicationLoadSink)(nil), "pb.ReplicationLoadSink")
+	proto.RegisterType((*ReplicationLoadSource)(nil), "pb.ReplicationLoadSource")
+	proto.RegisterType((*ServerLoad)(nil), "pb.ServerLoad")
+	proto.RegisterType((*LiveServerInfo)(nil), "pb.LiveServerInfo")
+	proto.RegisterType((*ClusterStatus)(nil), "pb.ClusterStatus")
+	proto.RegisterEnum("pb.RegionState_State", RegionState_State_name, RegionState_State_value)
+}
+
+func init() { proto.RegisterFile("ClusterStatus.proto", fileDescriptor5) }
+
+var fileDescriptor5 = []byte{
+	// 1468 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x57, 0x4d, 0x6f, 0x1b, 0x37,
+	0x13, 0x7e, 0x25, 0x4b, 0xfe, 0x18, 0x7d, 0x9a, 0xfe, 0xc8, 0xc6, 0x2f, 0x90, 0x1a, 0x2a, 0xe0,
+	0x1a, 0x49, 0xa0, 0xa6, 0x2e, 0x82, 0x02, 0x49, 0xd1, 0x26, 0x92, 0xe5, 0x44, 0xb5, 0x2c, 0xb9,
+	0x2b, 0x37, 0x3d, 0x2e, 0xa8, 0x5d, 0xca, 0x66, 0xbd, 0x5a, 0x6e, 0xc8, 0x95, 0x9b, 0xe4, 0xda,
+	0x7f, 0xd0, 0x6b, 0x2f, 0xf9, 0x6f, 0x3d, 0xf4, 0xd0, 0x1f, 0xd0, 0x6b, 0x31, 0x24, 0x77, 0x2d,
+	0x29, 0x4a, 0xd0, 0x8b, 0x40, 0xce, 0xf3, 0x3c, 0x43, 0x72, 0x38, 0x9c, 0x1d, 0xc1, 0x56, 0x3b,
+	0x9c, 0xaa, 0x84, 0xc9, 0x61, 0x42, 0x93, 0xa9, 0x6a, 0xc6, 0x52, 0x24, 0x82, 0xe4, 0xe3, 0xd1,
+	0x5e, 0xe9, 0x65, 0x8b, 0x2a, 0x66, 0x0c, 0x7b, 0x35, 0xcb, 0xea, 0x06, 0xd6, 0xb0, 0x7e, 0x32,
+	0x34, 0xa3, 0xc6, 0x5f, 0x79, 0x28, 0xb9, 0xec, 0x92, 0x8b, 0x08, 0x5d, 0x30, 0xf2, 0x25, 0x94,
+	0xa4, 0x9e, 0x7a, 0x3c, 0x1a, 0x0b, 0x27, 0xb7, 0x9f, 0x3f, 0x2c, 0x1d, 0x55, 0x9b, 0xf1, 0xa8,
+	0x69, 0x58, 0xdd, 0x68, 0x2c, 0x5c, 0x90, 0xd9, 0x98, 0x3c, 0x80, 0xa2, 0x42, 0xa5, 0x93, 0xdf,
+	0xcf, 0x1f, 0x56, 0x8f, 0x76, 0x6e, 0xa9, 0xda, 0x61, 0x53, 0xff, 0xba, 0x86, 0x43, 0xb6, 0x35,
+	0x79, 0x12, 0x3b, 0x2b, 0xfb, 0xb9, 0xc3, 0x82, 0x6b, 0x26, 0x8d, 0x3f, 0x73, 0x50, 0x34, 0xab,
+	0x97, 0x60, 0x6d, 0x70, 0x72, 0xd2, 0xeb, 0xf6, 0x3b, 0xf5, 0xff, 0x91, 0x3a, 0x94, 0xcf, 0x3b,
+	0xfd, 0xe3, 0x6e, 0xff, 0x85, 0x37, 0x38, 0xef, 0xf4, 0xeb, 0x39, 0x0d, 0x9f, 0x77, 0xfa, 0xdd,
+	0xfe, 0x8b, 0x7a, 0x9e, 0xac, 0x43, 0x41, 0x9b, 0x57, 0xc8, 0x26, 0x54, 0x52, 0x62, 0xbb, 0x37,
+	0x18, 0x76, 0xea, 0x05, 0x64, 0xe2, 0x10, 0x99, 0x45, 0x02, 0xb0, 0xaa, 0xed, 0xc7, 0xf5, 0x55,
+	0x52, 0x81, 0x8d, 0xe1, 0x79, 0xaf, 0x7b, 0x71, 0x81, 0xd0, 0x1a, 0xd9, 0x80, 0xa2, 0x9e, 0xd6,
+	0xd7, 0x49, 0x0d, 0x4a, 0x27, 0xcf, 0xbb, 0xbd, 0xce, 0xb1, 0x59, 0x6d, 0x03, 0xd7, 0xb7, 0x06,
+	0xe3, 0x15, 0xd0, 0xeb, 0x59, 0xc7, 0x7d, 0x81, 0xd2, 0x12, 0x7a, 0xc5, 0x49, 0xe7, 0xb8, 0x5e,
+	0xc6, 0x1d, 0x64, 0x5e, 0xbd, 0x7e, 0xe7, 0xe7, 0x7a, 0x05, 0xdd, 0x59, 0xae, 0x36, 0x54, 0x1b,
+	0xaf, 0x81, 0xa4, 0x21, 0xbc, 0x90, 0x34, 0x52, 0x3c, 0xe1, 0x22, 0x22, 0x5f, 0x40, 0x41, 0xc5,
+	0xcc, 0xb7, 0x81, 0xde, 0x9a, 0x89, 0x5e, 0xcc, 0x7c, 0x3e, 0xe6, 0x4c, 0xba, 0x9a, 0x40, 0x8e,
+	0xa0, 0x6c, 0x2f, 0xe6, 0x36, 0xdc, 0xa5, 0xa3, 0xda, 0x42, 0xb8, 0x5d, 0x7b, 0x7b, 0x7a, 0xd2,
+	0x18, 0x42, 0x6d, 0x98, 0x08, 0xc9, 0x86, 0xec, 0xf5, 0x94, 0x45, 0x3e, 0xeb, 0x06, 0xe4, 0x33,
+	0x28, 0x8d, 0xe9, 0x84, 0x87, 0x6f, 0xbd, 0x88, 0x4e, 0x98, 0x5e, 0xb6, 0xec, 0x82, 0x31, 0xf5,
+	0xe9, 0x84, 0x21, 0x41, 0x59, 0xba, 0xc7, 0x03, 0xbd, 0x4c, 0xc1, 0x05, 0x95, 0x79, 0x68, 0xfc,
+	0x9e, 0x83, 0xdd, 0x74, 0xc5, 0x39, 0xdf, 0x8a, 0x7c, 0x03, 0x4e, 0x48, 0x55, 0xe2, 0x8d, 0xc3,
+	0xa9, 0xba, 0x62, 0x81, 0x37, 0xeb, 0x28, 0xa7, 0x1d, 0xed, 0x20, 0x7e, 0x62, 0xe0, 0x99, 0x5d,
+	0x7d, 0x0f, 0x9b, 0x0a, 0x9d, 0x79, 0xf3, 0x4b, 0xaf, 0xa4, 0x21, 0x59, 0x58, 0xc9, 0xad, 0xa9,
+	0x79, 0x43, 0xe3, 0xfd, 0x1a, 0x80, 0xd9, 0x54, 0x4f, 0xd0, 0x80, 0x7c, 0x07, 0xf5, 0x34, 0x58,
+	0x69, 0x18, 0x3f, 0x15, 0xe1, 0x9a, 0x9c, 0x37, 0x90, 0x5d, 0x58, 0xd5, 0x2b, 0x28, 0x27, 0xbf,
+	0x9f, 0x3b, 0xac, 0xb8, 0x76, 0x46, 0xee, 0x01, 0xe8, 0xd1, 0x98, 0x87, 0x4c, 0xe9, 0x24, 0xae,
+	0xb8, 0x33, 0x16, 0xf2, 0x14, 0xf6, 0xcc, 0x39, 0xa6, 0x91, 0x2f, 0x26, 0xb1, 0x64, 0x4a, 0x61,
+	0x18, 0xf8, 0x3b, 0xe6, 0x9d, 0xb5, 0x9c, 0x82, 0xe6, 0xdf, 0xd1, 0x8c, 0x9f, 0x66, 0x08, 0x43,
+	0xfe, 0x8e, 0x9d, 0xb5, 0xc8, 0x7d, 0x1b, 0x04, 0x74, 0x95, 0x69, 0x8a, 0x5a, 0x53, 0xcb, 0x00,
+	0xcb, 0x3d, 0x84, 0xfa, 0x84, 0x4d, 0x6c, 0xcc, 0x2c, 0x75, 0x55, 0x53, 0xab, 0xa9, 0xdd, 0x32,
+	0x1f, 0xc3, 0x9d, 0x5b, 0xaf, 0x3c, 0x0a, 0xd8, 0x9b, 0x4c, 0xb0, 0xa6, 0x05, 0xdb, 0x19, 0xdc,
+	0x45, 0xd4, 0xca, 0x9a, 0xb0, 0x25, 0x19, 0x0d, 0x3c, 0x89, 0x31, 0x56, 0x89, 0xf2, 0x7c, 0x31,
+	0x8d, 0x12, 0x67, 0x5d, 0xbf, 0xdb, 0x4d, 0x84, 0x5c, 0x8b, 0xb4, 0x11, 0x20, 0x8f, 0x60, 0xfb,
+	0x57, 0xc9, 0x13, 0xb6, 0x28, 0xd8, 0xd0, 0x02, 0xa2, 0xb1, 0x0f, 0x14, 0x89, 0x48, 0x68, 0xe8,
+	0x61, 0x20, 0xa8, 0x9f, 0xf0, 0xe8, 0xd2, 0x3b, 0x7d, 0xa5, 0x1c, 0x30, 0x0a, 0x8d, 0xb5, 0x33,
+	0xe8, 0xf4, 0x95, 0x22, 0x47, 0xb0, 0xe3, 0x4f, 0xa5, 0x64, 0x51, 0x92, 0x6a, 0x58, 0xa0, 0x25,
+	0x25, 0x2d, 0xd9, 0xb2, 0x60, 0x3b, 0xc5, 0x50, 0xf3, 0x00, 0x88, 0x14, 0x22, 0x99, 0x3d, 0xf9,
+	0x69, 0xcb, 0x29, 0x9b, 0xa8, 0x22, 0x92, 0x1d, 0xfa, 0xb4, 0x45, 0x9e, 0xc0, 0x9e, 0xd9, 0x12,
+	0x3e, 0x31, 0xee, 0x2f, 0x88, 0x2a, 0x5a, 0xb4, 0xab, 0x19, 0x43, 0x4d, 0xf8, 0x94, 0x76, 0x14,
+	0x0a, 0x31, 0xc9, 0xb4, 0xd5, 0x0f, 0xb4, 0x2d, 0xc4, 0xad, 0xf6, 0x11, 0x6c, 0xe3, 0x81, 0x42,
+	0x96, 0xcc, 0xbf, 0x80, 0x9a, 0x09, 0x45, 0x8a, 0xcd, 0x3c, 0x98, 0xcf, 0xa1, 0x12, 0xd0, 0x84,
+	0x7a, 0xa1, 0xf0, 0x69, 0xc8, 0x93, 0xb7, 0x4e, 0x7d, 0x3f, 0x77, 0x98, 0x77, 0xcb, 0x68, 0xec,
+	0x59, 0x1b, 0x79, 0x62, 0x9f, 0xe3, 0x84, 0xfe, 0x22, 0x64, 0x16, 0x66, 0x11, 0x79, 0x89, 0x72,
+	0x36, 0xd1, 0xf5, 0x93, 0xdc, 0x23, 0xf3, 0x22, 0xcf, 0x90, 0xd1, 0xce, 0x08, 0x17, 0x8a, 0x9c,
+	0xa7, 0x99, 0xbc, 0x74, 0x63, 0xe4, 0xe3, 0x4f, 0xd3, 0x64, 0x5b, 0xfb, 0x83, 0x2d, 0x37, 0x7e,
+	0xcb, 0xc1, 0x96, 0xcb, 0xe2, 0x90, 0xfb, 0x34, 0xb1, 0xef, 0x74, 0xc8, 0xa3, 0x6b, 0xd2, 0x04,
+	0x42, 0x2f, 0xd9, 0x60, 0xdc, 0xa3, 0x2a, 0x79, 0x1e, 0xc7, 0x21, 0x67, 0xc1, 0x20, 0xb6, 0xe5,
+	0x62, 0x09, 0x42, 0xbe, 0x85, 0xbb, 0x09, 0x9f, 0xb0, 0x21, 0x7e, 0x3a, 0xd4, 0xa2, 0xcc, 0x94,
+	0xab, 0x8f, 0x13, 0x1a, 0x7f, 0xe7, 0x60, 0x67, 0x71, 0x17, 0x62, 0x2a, 0x7d, 0x86, 0x6f, 0x3e,
+	0x66, 0x4c, 0x76, 0x8f, 0xf5, 0xda, 0x1b, 0xae, 0x9d, 0xcd, 0xed, 0x6f, 0x78, 0xc5, 0xe3, 0x78,
+	0x66, 0xa1, 0x25, 0x08, 0x39, 0x80, 0x2a, 0xde, 0xfa, 0x60, 0xdc, 0x13, 0x97, 0x3f, 0x4e, 0xd9,
+	0x94, 0x39, 0x2b, 0xfb, 0x79, 0x7c, 0x98, 0xf3, 0x56, 0xbc, 0x9d, 0x6c, 0x9b, 0x8b, 0xde, 0x0b,
+	0xda, 0xfb, 0x47, 0x71, 0x5c, 0x43, 0xce, 0x1c, 0x82, 0x5e, 0x3a, 0x45, 0xad, 0x58, 0xb0, 0x36,
+	0xfe, 0x28, 0x00, 0x0c, 0x99, 0xbc, 0x61, 0x52, 0x97, 0xc5, 0x87, 0x40, 0xa2, 0xe9, 0x64, 0xc4,
+	0xa4, 0x27, 0xc6, 0xd9, 0x43, 0x75, 0x72, 0x3a, 0xcb, 0xea, 0x06, 0x19, 0x8c, 0xd3, 0x57, 0x8a,
+	0xd5, 0xdc, 0x64, 0xf4, 0x12, 0x4d, 0x5e, 0x6b, 0x76, 0x34, 0xde, 0x5f, 0x14, 0xee, 0x43, 0x79,
+	0x8a, 0x75, 0xef, 0x8a, 0xd1, 0x18, 0xeb, 0x8c, 0xad, 0x93, 0x68, 0x7b, 0xc9, 0x68, 0x7c, 0xd6,
+	0x22, 0xf7, 0xa0, 0x34, 0xa1, 0x6f, 0x32, 0x82, 0x29, 0x8c, 0x1b, 0x13, 0xfa, 0xc6, 0xe2, 0x5f,
+	0x65, 0x1f, 0xbb, 0x50, 0xd0, 0x40, 0x39, 0x45, 0x9d, 0x6f, 0x33, 0x6d, 0x08, 0x1e, 0x27, 0xfd,
+	0xd6, 0xe1, 0x58, 0x91, 0xaf, 0xa1, 0xec, 0x8b, 0x58, 0x0a, 0x9f, 0x29, 0x25, 0xa4, 0x72, 0x56,
+	0xb5, 0x44, 0x7f, 0x1f, 0xdb, 0xb7, 0x76, 0x77, 0x8e, 0x84, 0x25, 0x57, 0xb2, 0x58, 0xc8, 0x04,
+	0x5f, 0xad, 0x4c, 0x3c, 0x0c, 0xb8, 0x2e, 0x8b, 0x05, 0xfc, 0x26, 0x20, 0x30, 0x44, 0xfb, 0x05,
+	0x9f, 0x30, 0x72, 0x00, 0xd6, 0xe4, 0xb1, 0x28, 0x30, 0x4c, 0x53, 0x0d, 0x2b, 0xc6, 0xdc, 0x89,
+	0x02, 0xcd, 0x3b, 0x84, 0x3a, 0xb6, 0x4e, 0x9e, 0xd2, 0x71, 0xf7, 0x10, 0xd2, 0x55, 0xb0, 0xe2,
+	0x56, 0xd1, 0x6e, 0xae, 0xe3, 0x5c, 0xc8, 0x84, 0x3c, 0x37, 0xb7, 0x78, 0x9b, 0x83, 0x0e, 0xe8,
+	0x4d, 0xdf, 0x35, 0xe7, 0x5c, 0x92, 0xa4, 0xee, 0x82, 0x80, 0x3c, 0xc5, 0x40, 0x59, 0x0b, 0x8f,
+	0xae, 0x75, 0x25, 0x2c, 0x1d, 0xdd, 0x59, 0xe6, 0x80, 0x47, 0xd7, 0xee, 0x1c, 0xb9, 0xc1, 0xa1,
+	0xda, 0xe3, 0x37, 0xcc, 0xec, 0x48, 0x37, 0x73, 0x07, 0xb0, 0x6a, 0xb6, 0x3d, 0xdb, 0xf8, 0x19,
+	0x1c, 0x9b, 0x03, 0xd7, 0xa2, 0xd8, 0x25, 0xda, 0xe3, 0xe1, 0xfd, 0xd8, 0x5e, 0x64, 0x86, 0xac,
+	0xaf, 0x07, 0x54, 0x36, 0x6e, 0xfc, 0xb3, 0x02, 0x95, 0xb9, 0x56, 0x95, 0x3c, 0x83, 0xca, 0xd5,
+	0x88, 0x2a, 0xe6, 0xdd, 0x30, 0xa9, 0xb8, 0x88, 0x74, 0x1a, 0x96, 0x8e, 0xfe, 0x8f, 0x4e, 0x74,
+	0xef, 0xfa, 0xca, 0xd8, 0x4f, 0x78, 0xc8, 0xda, 0x22, 0x4a, 0x58, 0x94, 0xb8, 0x65, 0xad, 0xb0,
+	0x00, 0x79, 0x0c, 0xe5, 0x90, 0xdf, 0x30, 0x1b, 0x68, 0x65, 0xfb, 0x05, 0x82, 0x0e, 0xe6, 0x8f,
+	0xe5, 0x96, 0xc2, 0x6c, 0xae, 0x30, 0xb7, 0x02, 0xfc, 0xb2, 0xa5, 0xb2, 0x95, 0xdb, 0xdc, 0x9a,
+	0x39, 0x69, 0x09, 0x39, 0xa9, 0xe4, 0x07, 0xd8, 0x31, 0xa9, 0xa6, 0x3c, 0x1e, 0x79, 0x49, 0xd6,
+	0xbd, 0x39, 0x05, 0xad, 0xdd, 0x9d, 0x6d, 0x8f, 0x6f, 0x7b, 0x3b, 0x77, 0xcb, 0x8a, 0xe6, 0x1a,
+	0xbe, 0x87, 0x00, 0xbe, 0x09, 0x04, 0x16, 0xd2, 0xa2, 0x3e, 0x74, 0x45, 0x67, 0x69, 0xda, 0xa3,
+	0xbb, 0x1b, 0x7e, 0x3a, 0x24, 0xcf, 0x60, 0x6b, 0x42, 0x35, 0xf9, 0xbf, 0x24, 0x37, 0x31, 0xdc,
+	0xf6, 0x6c, 0x8a, 0x1f, 0xc0, 0xaa, 0xb1, 0xea, 0xbc, 0x5e, 0x72, 0xa5, 0x06, 0x25, 0x8f, 0xa1,
+	0x3a, 0xa2, 0xfe, 0xf5, 0x34, 0xf6, 0x8c, 0x41, 0x39, 0xeb, 0x4b, 0x03, 0x53, 0x31, 0xac, 0x33,
+	0x43, 0xc2, 0x76, 0x71, 0x44, 0x43, 0x1a, 0xf9, 0x58, 0x20, 0x22, 0x9d, 0xe8, 0xeb, 0x2e, 0xa4,
+	0xa6, 0x41, 0xd4, 0x3a, 0x81, 0xfb, 0x42, 0x5e, 0x36, 0x69, 0x4c, 0xfd, 0x2b, 0xd6, 0xbc, 0xa2,
+	0x81, 0x10, 0x71, 0x53, 0xdf, 0xa3, 0xf9, 0x07, 0x32, 0x9a, 0x8e, 0x9b, 0x97, 0x2c, 0x62, 0x92,
+	0x26, 0x2c, 0x68, 0xcd, 0xff, 0x9f, 0x39, 0x47, 0x82, 0x7a, 0x99, 0x7b, 0x9f, 0xcb, 0xfd, 0x1b,
+	0x00, 0x00, 0xff, 0xff, 0x04, 0x73, 0x7c, 0x28, 0xea, 0x0c, 0x00, 0x00,
+}

vendor/github.com/tsuna/gohbase/pb/ClusterStatus.proto

@@ -0,0 +1,224 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// This file contains protocol buffers that are used for ClustStatus
+package pb;
+
+option java_package = "org.apache.hadoop.hbase.protobuf.generated";
+option java_outer_classname = "ClusterStatusProtos";
+option java_generate_equals_and_hash = true;
+option optimize_for = SPEED;
+
+import "HBase.proto";
+import "ClusterId.proto";
+import "FS.proto";
+
+message RegionState {
+  required RegionInfo region_info = 1;
+  required State state = 2;
+  optional uint64 stamp = 3;
+  enum State {
+    OFFLINE = 0;       // region is in an offline state
+    PENDING_OPEN = 1;  // sent rpc to server to open but has not begun
+    OPENING = 2;       // server has begun to open but not yet done
+    OPEN = 3;          // server opened region and updated meta
+    PENDING_CLOSE = 4; // sent rpc to server to close but has not begun
+    CLOSING = 5;       // server has begun to close but not yet done
+    CLOSED = 6;        // server closed region and updated meta
+    SPLITTING = 7;     // server started split of a region
+    SPLIT = 8;         // server completed split of a region
+    FAILED_OPEN = 9;   // failed to open, and won't retry any more
+    FAILED_CLOSE = 10; // failed to close, and won't retry any more
+    MERGING = 11;      // server started merge a region
+    MERGED = 12;       // server completed merge of a region
+    SPLITTING_NEW = 13;  // new region to be created when RS splits a parent
+                       // region but hasn't be created yet, or master doesn't
+                       // know it's already created
+    MERGING_NEW = 14;  // new region to be created when RS merges two
+                       // daughter regions but hasn't be created yet, or
+                       // master doesn't know it's already created
+  }
+}
+
+message RegionInTransition {
+  required RegionSpecifier spec = 1;
+  required RegionState region_state = 2;
+}
+
+/**
+ * sequence Id of a store
+ */
+message StoreSequenceId {
+  required bytes family_name = 1;
+  required uint64 sequence_id = 2;
+}
+
+/**
+ * contains a sequence id of a region which should be the minimum of its store sequence ids and
+ * list of sequence ids of the region's stores
+ */
+message RegionStoreSequenceIds {
+  required uint64 last_flushed_sequence_id = 1;
+  repeated StoreSequenceId store_sequence_id = 2;
+}
+
+message RegionLoad {
+  /** the region specifier */
+  required RegionSpecifier region_specifier = 1;
+
+  /** the number of stores for the region */
+  optional uint32 stores = 2;
+
+  /** the number of storefiles for the region */
+  optional uint32 storefiles = 3;
+
+  /** the total size of the store files for the region, uncompressed, in MB */
+  optional uint32 store_uncompressed_size_MB = 4;
+
+  /** the current total size of the store files for the region, in MB */
+  optional uint32 storefile_size_MB = 5;
+
+  /** the current size of the memstore for the region, in MB */
+  optional uint32 memstore_size_MB = 6;
+
+  /**
+   * The current total size of root-level store file indexes for the region,
+   * in MB. The same as {@link #rootIndexSizeKB} but in MB.
+   */
+  optional uint32 storefile_index_size_MB = 7;
+
+  /** the current total read requests made to region */
+  optional uint64 read_requests_count = 8;
+
+  /** the current total write requests made to region */
+  optional uint64 write_requests_count = 9;
+
+  /** the total compacting key values in currently running compaction */
+  optional uint64 total_compacting_KVs = 10;
+
+  /** the completed count of key values in currently running compaction */
+  optional uint64 current_compacted_KVs = 11;
+
+   /** The current total size of root-level indexes for the region, in KB. */
+  optional uint32 root_index_size_KB = 12;
+
+  /** The total size of all index blocks, not just the root level, in KB. */
+  optional uint32 total_static_index_size_KB = 13;
+
+  /**
+   * The total size of all Bloom filter blocks, not just loaded into the
+   * block cache, in KB.
+   */
+  optional uint32 total_static_bloom_size_KB = 14;
+
+  /** the most recent sequence Id from cache flush */
+  optional uint64 complete_sequence_id = 15;
+
+  /** The current data locality for region in the regionserver */
+  optional float data_locality = 16;
+
+  optional uint64 last_major_compaction_ts = 17 [default = 0];
+
+  /** the most recent sequence Id of store from cache flush */
+  repeated StoreSequenceId store_complete_sequence_id = 18;
+}
+
+/* Server-level protobufs */
+
+message ReplicationLoadSink {
+  required uint64 ageOfLastAppliedOp = 1;
+  required uint64 timeStampsOfLastAppliedOp = 2;
+}
+
+message ReplicationLoadSource {
+  required string peerID = 1;
+  required uint64 ageOfLastShippedOp = 2;
+  required uint32 sizeOfLogQueue = 3;
+  required uint64 timeStampOfLastShippedOp = 4;
+  required uint64 replicationLag = 5;
+}
+
+message ServerLoad {
+  /** Number of requests since last report. */
+  optional uint64 number_of_requests = 1;
+
+  /** Total Number of requests from the start of the region server. */
+  optional uint64 total_number_of_requests = 2;
+
+  /** the amount of used heap, in MB. */
+  optional uint32 used_heap_MB = 3;
+
+  /** the maximum allowable size of the heap, in MB. */
+  optional uint32 max_heap_MB = 4;
+
+  /** Information on the load of individual regions. */
+  repeated RegionLoad region_loads = 5;
+
+  /**
+   * Regionserver-level coprocessors, e.g., WALObserver implementations.
+   * Region-level coprocessors, on the other hand, are stored inside RegionLoad
+   * objects.
+   */
+  repeated Coprocessor coprocessors = 6;
+
+  /**
+   * Time when incremental (non-total) counts began being calculated (e.g. number_of_requests)
+   * time is measured as the difference, measured in milliseconds, between the current time
+   * and midnight, January 1, 1970 UTC.
+   */
+  optional uint64 report_start_time = 7;
+
+  /**
+   * Time when report was generated.
+   * time is measured as the difference, measured in milliseconds, between the current time
+   * and midnight, January 1, 1970 UTC.
+   */
+  optional uint64 report_end_time = 8;
+
+  /**
+   * The port number that this region server is hosing an info server on.
+   */
+  optional uint32 info_server_port = 9;
+
+  /**
+   * The replicationLoadSource for the replication Source status of this region server.
+   */
+  repeated ReplicationLoadSource replLoadSource = 10;
+
+  /**
+   * The replicationLoadSink for the replication Sink status of this region server.
+   */
+  optional ReplicationLoadSink replLoadSink = 11;
+}
+
+message LiveServerInfo {
+  required ServerName server = 1;
+  required ServerLoad server_load = 2;
+}
+
+message ClusterStatus {
+  optional HBaseVersionFileContent hbase_version = 1;
+  repeated LiveServerInfo live_servers = 2;
+  repeated ServerName dead_servers = 3;
+  repeated RegionInTransition regions_in_transition = 4;
+  optional ClusterId cluster_id = 5;
+  repeated Coprocessor master_coprocessors = 6;
+  optional ServerName master = 7;
+  repeated ServerName backup_masters = 8;
+  optional bool balancer_on = 9;
+}

vendor/github.com/tsuna/gohbase/pb/Comparator.pb.go

@@ -0,0 +1,280 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: Comparator.proto
+
+package pb
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+type BitComparator_BitwiseOp int32
+
+const (
+	BitComparator_AND BitComparator_BitwiseOp = 1
+	BitComparator_OR  BitComparator_BitwiseOp = 2
+	BitComparator_XOR BitComparator_BitwiseOp = 3
+)
+
+var BitComparator_BitwiseOp_name = map[int32]string{
+	1: "AND",
+	2: "OR",
+	3: "XOR",
+}
+var BitComparator_BitwiseOp_value = map[string]int32{
+	"AND": 1,
+	"OR":  2,
+	"XOR": 3,
+}
+
+func (x BitComparator_BitwiseOp) Enum() *BitComparator_BitwiseOp {
+	p := new(BitComparator_BitwiseOp)
+	*p = x
+	return p
+}
+func (x BitComparator_BitwiseOp) String() string {
+	return proto.EnumName(BitComparator_BitwiseOp_name, int32(x))
+}
+func (x *BitComparator_BitwiseOp) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(BitComparator_BitwiseOp_value, data, "BitComparator_BitwiseOp")
+	if err != nil {
+		return err
+	}
+	*x = BitComparator_BitwiseOp(value)
+	return nil
+}
+func (BitComparator_BitwiseOp) EnumDescriptor() ([]byte, []int) { return fileDescriptor6, []int{5, 0} }
+
+type Comparator struct {
+	Name                 *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
+	SerializedComparator []byte  `protobuf:"bytes,2,opt,name=serialized_comparator,json=serializedComparator" json:"serialized_comparator,omitempty"`
+	XXX_unrecognized     []byte  `json:"-"`
+}
+
+func (m *Comparator) Reset()                    { *m = Comparator{} }
+func (m *Comparator) String() string            { return proto.CompactTextString(m) }
+func (*Comparator) ProtoMessage()               {}
+func (*Comparator) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{0} }
+
+func (m *Comparator) GetName() string {
+	if m != nil && m.Name != nil {
+		return *m.Name
+	}
+	return ""
+}
+
+func (m *Comparator) GetSerializedComparator() []byte {
+	if m != nil {
+		return m.SerializedComparator
+	}
+	return nil
+}
+
+type ByteArrayComparable struct {
+	Value            []byte `protobuf:"bytes,1,opt,name=value" json:"value,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *ByteArrayComparable) Reset()                    { *m = ByteArrayComparable{} }
+func (m *ByteArrayComparable) String() string            { return proto.CompactTextString(m) }
+func (*ByteArrayComparable) ProtoMessage()               {}
+func (*ByteArrayComparable) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{1} }
+
+func (m *ByteArrayComparable) GetValue() []byte {
+	if m != nil {
+		return m.Value
+	}
+	return nil
+}
+
+type BinaryComparator struct {
+	Comparable       *ByteArrayComparable `protobuf:"bytes,1,req,name=comparable" json:"comparable,omitempty"`
+	XXX_unrecognized []byte               `json:"-"`
+}
+
+func (m *BinaryComparator) Reset()                    { *m = BinaryComparator{} }
+func (m *BinaryComparator) String() string            { return proto.CompactTextString(m) }
+func (*BinaryComparator) ProtoMessage()               {}
+func (*BinaryComparator) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{2} }
+
+func (m *BinaryComparator) GetComparable() *ByteArrayComparable {
+	if m != nil {
+		return m.Comparable
+	}
+	return nil
+}
+
+type LongComparator struct {
+	Comparable       *ByteArrayComparable `protobuf:"bytes,1,req,name=comparable" json:"comparable,omitempty"`
+	XXX_unrecognized []byte               `json:"-"`
+}
+
+func (m *LongComparator) Reset()                    { *m = LongComparator{} }
+func (m *LongComparator) String() string            { return proto.CompactTextString(m) }
+func (*LongComparator) ProtoMessage()               {}
+func (*LongComparator) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{3} }
+
+func (m *LongComparator) GetComparable() *ByteArrayComparable {
+	if m != nil {
+		return m.Comparable
+	}
+	return nil
+}
+
+type BinaryPrefixComparator struct {
+	Comparable       *ByteArrayComparable `protobuf:"bytes,1,req,name=comparable" json:"comparable,omitempty"`
+	XXX_unrecognized []byte               `json:"-"`
+}
+
+func (m *BinaryPrefixComparator) Reset()                    { *m = BinaryPrefixComparator{} }
+func (m *BinaryPrefixComparator) String() string            { return proto.CompactTextString(m) }
+func (*BinaryPrefixComparator) ProtoMessage()               {}
+func (*BinaryPrefixComparator) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{4} }
+
+func (m *BinaryPrefixComparator) GetComparable() *ByteArrayComparable {
+	if m != nil {
+		return m.Comparable
+	}
+	return nil
+}
+
+type BitComparator struct {
+	Comparable       *ByteArrayComparable     `protobuf:"bytes,1,req,name=comparable" json:"comparable,omitempty"`
+	BitwiseOp        *BitComparator_BitwiseOp `protobuf:"varint,2,req,name=bitwise_op,json=bitwiseOp,enum=pb.BitComparator_BitwiseOp" json:"bitwise_op,omitempty"`
+	XXX_unrecognized []byte                   `json:"-"`
+}
+
+func (m *BitComparator) Reset()                    { *m = BitComparator{} }
+func (m *BitComparator) String() string            { return proto.CompactTextString(m) }
+func (*BitComparator) ProtoMessage()               {}
+func (*BitComparator) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{5} }
+
+func (m *BitComparator) GetComparable() *ByteArrayComparable {
+	if m != nil {
+		return m.Comparable
+	}
+	return nil
+}
+
+func (m *BitComparator) GetBitwiseOp() BitComparator_BitwiseOp {
+	if m != nil && m.BitwiseOp != nil {
+		return *m.BitwiseOp
+	}
+	return BitComparator_AND
+}
+
+type NullComparator struct {
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *NullComparator) Reset()                    { *m = NullComparator{} }
+func (m *NullComparator) String() string            { return proto.CompactTextString(m) }
+func (*NullComparator) ProtoMessage()               {}
+func (*NullComparator) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{6} }
+
+type RegexStringComparator struct {
+	Pattern          *string `protobuf:"bytes,1,req,name=pattern" json:"pattern,omitempty"`
+	PatternFlags     *int32  `protobuf:"varint,2,req,name=pattern_flags,json=patternFlags" json:"pattern_flags,omitempty"`
+	Charset          *string `protobuf:"bytes,3,req,name=charset" json:"charset,omitempty"`
+	Engine           *string `protobuf:"bytes,4,opt,name=engine" json:"engine,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *RegexStringComparator) Reset()                    { *m = RegexStringComparator{} }
+func (m *RegexStringComparator) String() string            { return proto.CompactTextString(m) }
+func (*RegexStringComparator) ProtoMessage()               {}
+func (*RegexStringComparator) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{7} }
+
+func (m *RegexStringComparator) GetPattern() string {
+	if m != nil && m.Pattern != nil {
+		return *m.Pattern
+	}
+	return ""
+}
+
+func (m *RegexStringComparator) GetPatternFlags() int32 {
+	if m != nil && m.PatternFlags != nil {
+		return *m.PatternFlags
+	}
+	return 0
+}
+
+func (m *RegexStringComparator) GetCharset() string {
+	if m != nil && m.Charset != nil {
+		return *m.Charset
+	}
+	return ""
+}
+
+func (m *RegexStringComparator) GetEngine() string {
+	if m != nil && m.Engine != nil {
+		return *m.Engine
+	}
+	return ""
+}
+
+type SubstringComparator struct {
+	Substr           *string `protobuf:"bytes,1,req,name=substr" json:"substr,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *SubstringComparator) Reset()                    { *m = SubstringComparator{} }
+func (m *SubstringComparator) String() string            { return proto.CompactTextString(m) }
+func (*SubstringComparator) ProtoMessage()               {}
+func (*SubstringComparator) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{8} }
+
+func (m *SubstringComparator) GetSubstr() string {
+	if m != nil && m.Substr != nil {
+		return *m.Substr
+	}
+	return ""
+}
+
+func init() {
+	proto.RegisterType((*Comparator)(nil), "pb.Comparator")
+	proto.RegisterType((*ByteArrayComparable)(nil), "pb.ByteArrayComparable")
+	proto.RegisterType((*BinaryComparator)(nil), "pb.BinaryComparator")
+	proto.RegisterType((*LongComparator)(nil), "pb.LongComparator")
+	proto.RegisterType((*BinaryPrefixComparator)(nil), "pb.BinaryPrefixComparator")
+	proto.RegisterType((*BitComparator)(nil), "pb.BitComparator")
+	proto.RegisterType((*NullComparator)(nil), "pb.NullComparator")
+	proto.RegisterType((*RegexStringComparator)(nil), "pb.RegexStringComparator")
+	proto.RegisterType((*SubstringComparator)(nil), "pb.SubstringComparator")
+	proto.RegisterEnum("pb.BitComparator_BitwiseOp", BitComparator_BitwiseOp_name, BitComparator_BitwiseOp_value)
+}
+
+func init() { proto.RegisterFile("Comparator.proto", fileDescriptor6) }
+
+var fileDescriptor6 = []byte{
+	// 411 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x53, 0xc1, 0x6e, 0x13, 0x31,
+	0x10, 0x95, 0x37, 0x6d, 0xaa, 0x0c, 0x6d, 0xb4, 0x72, 0xdb, 0xb0, 0x12, 0x97, 0x68, 0x11, 0x52,
+	0x04, 0x62, 0x0f, 0xe5, 0x80, 0xc4, 0xad, 0x0b, 0xaa, 0x40, 0xa0, 0xa6, 0xb8, 0x42, 0xe2, 0x16,
+	0xd9, 0xc9, 0x64, 0x63, 0x69, 0xbb, 0xb6, 0x6c, 0x2f, 0x34, 0x7c, 0x41, 0x3f, 0x83, 0x3b, 0x3f,
+	0x89, 0xbc, 0xeb, 0x24, 0x0b, 0xea, 0x31, 0xb7, 0x79, 0x6f, 0xe6, 0x3d, 0x3f, 0xd9, 0x1e, 0x88,
+	0xdf, 0xab, 0x3b, 0xcd, 0x0d, 0x77, 0xca, 0x64, 0xda, 0x28, 0xa7, 0x68, 0xa4, 0x45, 0xfa, 0x0d,
+	0x60, 0xc7, 0x53, 0x0a, 0x07, 0x15, 0xbf, 0xc3, 0x84, 0x8c, 0xa3, 0xc9, 0x80, 0x35, 0x35, 0x7d,
+	0x03, 0xe7, 0x16, 0x8d, 0xe4, 0xa5, 0xfc, 0x85, 0x8b, 0xd9, 0x7c, 0x3b, 0x9c, 0x44, 0x63, 0x32,
+	0x39, 0x66, 0x67, 0xbb, 0xe6, 0xce, 0x28, 0x7d, 0x05, 0xa7, 0xf9, 0xda, 0xe1, 0xa5, 0x31, 0x7c,
+	0x1d, 0x68, 0x51, 0x22, 0x3d, 0x83, 0xc3, 0x1f, 0xbc, 0xac, 0xfd, 0x01, 0x5e, 0xdb, 0x82, 0xf4,
+	0x33, 0xc4, 0xb9, 0xac, 0xb8, 0x59, 0x77, 0x92, 0xbc, 0x05, 0x98, 0x6f, 0x75, 0x4d, 0x9e, 0x27,
+	0x17, 0x4f, 0x33, 0x2d, 0xb2, 0x47, 0x6c, 0x59, 0x67, 0x34, 0xfd, 0x04, 0xc3, 0x2f, 0xaa, 0x2a,
+	0xf6, 0x61, 0xf5, 0x15, 0x46, 0x6d, 0xae, 0x1b, 0x83, 0x4b, 0x79, 0xbf, 0x0f, 0xcb, 0x3f, 0x04,
+	0x4e, 0x72, 0xe9, 0xf6, 0x60, 0x45, 0xdf, 0x01, 0x08, 0xe9, 0x7e, 0x4a, 0x8b, 0x33, 0xa5, 0x93,
+	0x68, 0x1c, 0x4d, 0x86, 0x17, 0xcf, 0x1a, 0x61, 0xd7, 0xdf, 0x23, 0x3f, 0x33, 0xd5, 0x6c, 0x20,
+	0x36, 0x65, 0xfa, 0x02, 0x06, 0x5b, 0x9e, 0x1e, 0x41, 0xef, 0xf2, 0xfa, 0x43, 0x4c, 0x68, 0x1f,
+	0xa2, 0x29, 0x8b, 0x23, 0x4f, 0x7c, 0x9f, 0xb2, 0xb8, 0x97, 0xc6, 0x30, 0xbc, 0xae, 0xcb, 0xb2,
+	0xf3, 0xae, 0x0f, 0x04, 0xce, 0x19, 0x16, 0x78, 0x7f, 0xeb, 0x8c, 0xfc, 0xe7, 0x96, 0x13, 0x38,
+	0xd2, 0xdc, 0x39, 0x34, 0x55, 0xf8, 0x3d, 0x1b, 0x48, 0x9f, 0xc3, 0x49, 0x28, 0x67, 0xcb, 0x92,
+	0x17, 0xb6, 0xc9, 0x7a, 0xc8, 0x8e, 0x03, 0x79, 0xe5, 0x39, 0x2f, 0x9f, 0xaf, 0xb8, 0xb1, 0xe8,
+	0x92, 0x5e, 0x2b, 0x0f, 0x90, 0x8e, 0xa0, 0x8f, 0x55, 0x21, 0x2b, 0x4c, 0x0e, 0xc6, 0x64, 0x32,
+	0x60, 0x01, 0xa5, 0xaf, 0xe1, 0xf4, 0xb6, 0x16, 0xf6, 0xff, 0x1c, 0x23, 0xe8, 0xdb, 0x86, 0x0e,
+	0x31, 0x02, 0xca, 0xaf, 0xe0, 0xa5, 0x32, 0x45, 0xc6, 0x35, 0x9f, 0xaf, 0x30, 0x5b, 0xf1, 0x85,
+	0x52, 0x3a, 0x5b, 0x09, 0x6e, 0xb1, 0xdd, 0x06, 0x51, 0x2f, 0xb3, 0x02, 0x2b, 0x34, 0xdc, 0xe1,
+	0x22, 0xef, 0x2c, 0xcb, 0x8d, 0xef, 0xda, 0x8f, 0xe4, 0x81, 0x90, 0xdf, 0x84, 0xfc, 0x0d, 0x00,
+	0x00, 0xff, 0xff, 0xff, 0x76, 0x5f, 0x6f, 0x47, 0x03, 0x00, 0x00,
+}

vendor/github.com/tsuna/gohbase/pb/Comparator.proto

@@ -0,0 +1,74 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// This file contains protocol buffers that are used for filters
+package pb;
+
+option java_package = "org.apache.hadoop.hbase.protobuf.generated";
+option java_outer_classname = "ComparatorProtos";
+option java_generic_services = true;
+option java_generate_equals_and_hash = true;
+option optimize_for = SPEED;
+
+// This file contains protocol buffers that are used for comparators (e.g. in filters)
+
+message Comparator {
+  required string name = 1;
+  optional bytes serialized_comparator = 2;
+}
+
+message ByteArrayComparable {
+  optional bytes value = 1;
+}
+
+message BinaryComparator {
+  required ByteArrayComparable comparable = 1;
+}
+
+message LongComparator {
+  required ByteArrayComparable comparable = 1;
+}
+
+message BinaryPrefixComparator {
+  required ByteArrayComparable comparable = 1;
+}
+
+message BitComparator {
+  required ByteArrayComparable comparable = 1;
+  required BitwiseOp bitwise_op = 2;
+
+  enum BitwiseOp {
+    AND = 1;
+    OR = 2;
+    XOR = 3;
+  }
+}
+
+message NullComparator {
+}
+
+message RegexStringComparator {
+  required string pattern = 1;
+  required int32 pattern_flags = 2;
+  required string charset = 3;
+  optional string engine = 4;
+}
+
+message SubstringComparator {
+  required string substr = 1;
+}

vendor/github.com/tsuna/gohbase/pb/ErrorHandling.pb.go

@@ -0,0 +1,165 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: ErrorHandling.proto
+
+package pb
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// *
+// Protobuf version of a java.lang.StackTraceElement
+// so we can serialize exceptions.
+type StackTraceElementMessage struct {
+	DeclaringClass   *string `protobuf:"bytes,1,opt,name=declaring_class,json=declaringClass" json:"declaring_class,omitempty"`
+	MethodName       *string `protobuf:"bytes,2,opt,name=method_name,json=methodName" json:"method_name,omitempty"`
+	FileName         *string `protobuf:"bytes,3,opt,name=file_name,json=fileName" json:"file_name,omitempty"`
+	LineNumber       *int32  `protobuf:"varint,4,opt,name=line_number,json=lineNumber" json:"line_number,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *StackTraceElementMessage) Reset()                    { *m = StackTraceElementMessage{} }
+func (m *StackTraceElementMessage) String() string            { return proto.CompactTextString(m) }
+func (*StackTraceElementMessage) ProtoMessage()               {}
+func (*StackTraceElementMessage) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{0} }
+
+func (m *StackTraceElementMessage) GetDeclaringClass() string {
+	if m != nil && m.DeclaringClass != nil {
+		return *m.DeclaringClass
+	}
+	return ""
+}
+
+func (m *StackTraceElementMessage) GetMethodName() string {
+	if m != nil && m.MethodName != nil {
+		return *m.MethodName
+	}
+	return ""
+}
+
+func (m *StackTraceElementMessage) GetFileName() string {
+	if m != nil && m.FileName != nil {
+		return *m.FileName
+	}
+	return ""
+}
+
+func (m *StackTraceElementMessage) GetLineNumber() int32 {
+	if m != nil && m.LineNumber != nil {
+		return *m.LineNumber
+	}
+	return 0
+}
+
+// *
+// Cause of a remote failure for a generic exception. Contains
+// all the information for a generic exception as well as
+// optional info about the error for generic info passing
+// (which should be another protobuffed class).
+type GenericExceptionMessage struct {
+	ClassName        *string                     `protobuf:"bytes,1,opt,name=class_name,json=className" json:"class_name,omitempty"`
+	Message          *string                     `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
+	ErrorInfo        []byte                      `protobuf:"bytes,3,opt,name=error_info,json=errorInfo" json:"error_info,omitempty"`
+	Trace            []*StackTraceElementMessage `protobuf:"bytes,4,rep,name=trace" json:"trace,omitempty"`
+	XXX_unrecognized []byte                      `json:"-"`
+}
+
+func (m *GenericExceptionMessage) Reset()                    { *m = GenericExceptionMessage{} }
+func (m *GenericExceptionMessage) String() string            { return proto.CompactTextString(m) }
+func (*GenericExceptionMessage) ProtoMessage()               {}
+func (*GenericExceptionMessage) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{1} }
+
+func (m *GenericExceptionMessage) GetClassName() string {
+	if m != nil && m.ClassName != nil {
+		return *m.ClassName
+	}
+	return ""
+}
+
+func (m *GenericExceptionMessage) GetMessage() string {
+	if m != nil && m.Message != nil {
+		return *m.Message
+	}
+	return ""
+}
+
+func (m *GenericExceptionMessage) GetErrorInfo() []byte {
+	if m != nil {
+		return m.ErrorInfo
+	}
+	return nil
+}
+
+func (m *GenericExceptionMessage) GetTrace() []*StackTraceElementMessage {
+	if m != nil {
+		return m.Trace
+	}
+	return nil
+}
+
+// *
+// Exception sent across the wire when a remote task needs
+// to notify other tasks that it failed and why
+type ForeignExceptionMessage struct {
+	Source           *string                  `protobuf:"bytes,1,opt,name=source" json:"source,omitempty"`
+	GenericException *GenericExceptionMessage `protobuf:"bytes,2,opt,name=generic_exception,json=genericException" json:"generic_exception,omitempty"`
+	XXX_unrecognized []byte                   `json:"-"`
+}
+
+func (m *ForeignExceptionMessage) Reset()                    { *m = ForeignExceptionMessage{} }
+func (m *ForeignExceptionMessage) String() string            { return proto.CompactTextString(m) }
+func (*ForeignExceptionMessage) ProtoMessage()               {}
+func (*ForeignExceptionMessage) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{2} }
+
+func (m *ForeignExceptionMessage) GetSource() string {
+	if m != nil && m.Source != nil {
+		return *m.Source
+	}
+	return ""
+}
+
+func (m *ForeignExceptionMessage) GetGenericException() *GenericExceptionMessage {
+	if m != nil {
+		return m.GenericException
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*StackTraceElementMessage)(nil), "pb.StackTraceElementMessage")
+	proto.RegisterType((*GenericExceptionMessage)(nil), "pb.GenericExceptionMessage")
+	proto.RegisterType((*ForeignExceptionMessage)(nil), "pb.ForeignExceptionMessage")
+}
+
+func init() { proto.RegisterFile("ErrorHandling.proto", fileDescriptor7) }
+
+var fileDescriptor7 = []byte{
+	// 349 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x92, 0x5d, 0x4b, 0xf3, 0x30,
+	0x14, 0xc7, 0xc9, 0x5e, 0x9e, 0xe7, 0xe9, 0xe9, 0x83, 0x2f, 0x15, 0x5c, 0x61, 0xca, 0xc6, 0x6e,
+	0x1c, 0x5e, 0xf4, 0x62, 0x1f, 0x61, 0xb2, 0x39, 0x2f, 0x1c, 0x52, 0xbd, 0x2f, 0x69, 0x7a, 0xda,
+	0x06, 0xdb, 0xa4, 0xa4, 0x19, 0x08, 0x7e, 0x19, 0x11, 0xfc, 0x9e, 0x92, 0x64, 0x15, 0x54, 0x76,
+	0x99, 0xdf, 0xf9, 0x9f, 0xf4, 0x77, 0x4e, 0x03, 0x67, 0x2b, 0xa5, 0xa4, 0xda, 0x50, 0x91, 0x55,
+	0x5c, 0x14, 0x51, 0xa3, 0xa4, 0x96, 0x41, 0xaf, 0x49, 0x67, 0xef, 0x04, 0xc2, 0x47, 0x4d, 0xd9,
+	0xf3, 0x93, 0xa2, 0x0c, 0x57, 0x15, 0xd6, 0x28, 0xf4, 0x3d, 0xb6, 0x2d, 0x2d, 0x30, 0xb8, 0x82,
+	0xe3, 0x0c, 0x59, 0x45, 0x15, 0x17, 0x45, 0xc2, 0x2a, 0xda, 0xb6, 0x21, 0x99, 0x92, 0xb9, 0x17,
+	0x1f, 0x7d, 0xe1, 0x1b, 0x43, 0x83, 0x09, 0xf8, 0x35, 0xea, 0x52, 0x66, 0x89, 0xa0, 0x35, 0x86,
+	0x3d, 0x1b, 0x02, 0x87, 0xb6, 0xb4, 0xc6, 0x60, 0x0c, 0x5e, 0xce, 0x2b, 0x74, 0xe5, 0xbe, 0x2d,
+	0xff, 0x33, 0xc0, 0x16, 0x27, 0xe0, 0x57, 0x5c, 0x60, 0x22, 0x76, 0x75, 0x8a, 0x2a, 0x1c, 0x4c,
+	0xc9, 0x7c, 0x18, 0x83, 0x41, 0x5b, 0x4b, 0x66, 0x1f, 0x04, 0x46, 0xb7, 0x28, 0x50, 0x71, 0xb6,
+	0x7a, 0x61, 0xd8, 0x68, 0x2e, 0x45, 0xe7, 0x78, 0x09, 0x60, 0xcd, 0xdc, 0xd5, 0x4e, 0xcf, 0xb3,
+	0xc4, 0xde, 0x1d, 0xc2, 0xdf, 0xda, 0x25, 0xf7, 0x56, 0xdd, 0xd1, 0x34, 0xa2, 0x59, 0x4a, 0xc2,
+	0x45, 0x2e, 0xad, 0xd3, 0xff, 0xd8, 0xb3, 0xe4, 0x4e, 0xe4, 0x32, 0x58, 0xc0, 0x50, 0x9b, 0x95,
+	0x84, 0x83, 0x69, 0x7f, 0xee, 0x2f, 0x2e, 0xa2, 0x26, 0x8d, 0x0e, 0x2d, 0x2a, 0x76, 0xd1, 0xd9,
+	0x2b, 0x8c, 0xd6, 0x52, 0x21, 0x2f, 0xc4, 0x2f, 0xcd, 0x73, 0xf8, 0xd3, 0xca, 0x9d, 0x62, 0x9d,
+	0xe2, 0xfe, 0x14, 0x6c, 0xe0, 0xb4, 0x70, 0x93, 0x25, 0xd8, 0xf5, 0x58, 0x53, 0x7f, 0x31, 0x36,
+	0x9f, 0x3c, 0x30, 0x76, 0x7c, 0x52, 0xfc, 0x28, 0x2c, 0xd7, 0x70, 0x2d, 0x55, 0x11, 0xd1, 0x86,
+	0xb2, 0x12, 0xa3, 0x92, 0x66, 0x52, 0x36, 0x51, 0x99, 0xd2, 0x16, 0xdd, 0xef, 0x4e, 0x77, 0x79,
+	0x64, 0x9b, 0xa8, 0xc6, 0x6c, 0xf9, 0xfd, 0x41, 0x3c, 0x98, 0x40, 0xbb, 0x21, 0x6f, 0x84, 0x7c,
+	0x06, 0x00, 0x00, 0xff, 0xff, 0x59, 0x62, 0x7e, 0xbe, 0x2b, 0x02, 0x00, 0x00,
+}

vendor/github.com/tsuna/gohbase/pb/ErrorHandling.proto

@@ -0,0 +1,58 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// This file contains protocol buffers that are used for error handling
+package pb;
+
+option java_package = "org.apache.hadoop.hbase.protobuf.generated";
+option java_outer_classname = "ErrorHandlingProtos";
+option java_generate_equals_and_hash = true;
+option optimize_for = SPEED;
+
+/**
+ * Protobuf version of a java.lang.StackTraceElement
+ * so we can serialize exceptions.
+ */
+message StackTraceElementMessage {
+  optional string declaring_class = 1;
+  optional string method_name = 2;
+  optional string file_name = 3;
+  optional int32 line_number = 4;
+}
+
+/**
+ * Cause of a remote failure for a generic exception. Contains
+ * all the information for a generic exception as well as
+ * optional info about the error for generic info passing
+ * (which should be another protobuffed class).
+ */
+message GenericExceptionMessage {
+  optional string class_name = 1;
+  optional string message = 2;
+  optional bytes error_info = 3;
+  repeated StackTraceElementMessage trace = 4;
+}
+
+/**
+ * Exception sent across the wire when a remote task needs
+ * to notify other tasks that it failed and why
+ */
+message ForeignExceptionMessage {
+  optional string source = 1;
+  optional GenericExceptionMessage generic_exception = 2;
+}

vendor/github.com/tsuna/gohbase/pb/FS.pb.go

@@ -0,0 +1,119 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: FS.proto
+
+package pb
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+type Reference_Range int32
+
+const (
+	Reference_TOP    Reference_Range = 0
+	Reference_BOTTOM Reference_Range = 1
+)
+
+var Reference_Range_name = map[int32]string{
+	0: "TOP",
+	1: "BOTTOM",
+}
+var Reference_Range_value = map[string]int32{
+	"TOP":    0,
+	"BOTTOM": 1,
+}
+
+func (x Reference_Range) Enum() *Reference_Range {
+	p := new(Reference_Range)
+	*p = x
+	return p
+}
+func (x Reference_Range) String() string {
+	return proto.EnumName(Reference_Range_name, int32(x))
+}
+func (x *Reference_Range) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(Reference_Range_value, data, "Reference_Range")
+	if err != nil {
+		return err
+	}
+	*x = Reference_Range(value)
+	return nil
+}
+func (Reference_Range) EnumDescriptor() ([]byte, []int) { return fileDescriptor8, []int{1, 0} }
+
+// *
+// The ${HBASE_ROOTDIR}/hbase.version file content
+type HBaseVersionFileContent struct {
+	Version          *string `protobuf:"bytes,1,req,name=version" json:"version,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *HBaseVersionFileContent) Reset()                    { *m = HBaseVersionFileContent{} }
+func (m *HBaseVersionFileContent) String() string            { return proto.CompactTextString(m) }
+func (*HBaseVersionFileContent) ProtoMessage()               {}
+func (*HBaseVersionFileContent) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{0} }
+
+func (m *HBaseVersionFileContent) GetVersion() string {
+	if m != nil && m.Version != nil {
+		return *m.Version
+	}
+	return ""
+}
+
+// *
+// Reference file content used when we split an hfile under a region.
+type Reference struct {
+	Splitkey         []byte           `protobuf:"bytes,1,req,name=splitkey" json:"splitkey,omitempty"`
+	Range            *Reference_Range `protobuf:"varint,2,req,name=range,enum=pb.Reference_Range" json:"range,omitempty"`
+	XXX_unrecognized []byte           `json:"-"`
+}
+
+func (m *Reference) Reset()                    { *m = Reference{} }
+func (m *Reference) String() string            { return proto.CompactTextString(m) }
+func (*Reference) ProtoMessage()               {}
+func (*Reference) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{1} }
+
+func (m *Reference) GetSplitkey() []byte {
+	if m != nil {
+		return m.Splitkey
+	}
+	return nil
+}
+
+func (m *Reference) GetRange() Reference_Range {
+	if m != nil && m.Range != nil {
+		return *m.Range
+	}
+	return Reference_TOP
+}
+
+func init() {
+	proto.RegisterType((*HBaseVersionFileContent)(nil), "pb.HBaseVersionFileContent")
+	proto.RegisterType((*Reference)(nil), "pb.Reference")
+	proto.RegisterEnum("pb.Reference_Range", Reference_Range_name, Reference_Range_value)
+}
+
+func init() { proto.RegisterFile("FS.proto", fileDescriptor8) }
+
+var fileDescriptor8 = []byte{
+	// 218 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x3c, 0x8f, 0x31, 0x4f, 0xc3, 0x30,
+	0x10, 0x46, 0xb1, 0x51, 0x69, 0x7a, 0x42, 0xa8, 0x32, 0x03, 0x11, 0x62, 0xa8, 0x32, 0x15, 0x86,
+	0x1b, 0x60, 0x64, 0x33, 0x52, 0xd4, 0x05, 0xa5, 0x72, 0x23, 0x76, 0xbb, 0xbd, 0x26, 0x11, 0x91,
+	0x6d, 0xd9, 0x06, 0x89, 0x7f, 0xc3, 0x4f, 0x45, 0x49, 0x44, 0xc6, 0xf7, 0xee, 0xdd, 0xf0, 0x41,
+	0x56, 0x1e, 0xd0, 0x07, 0x97, 0x9c, 0xe0, 0xde, 0x14, 0x2f, 0x70, 0xb7, 0x93, 0x3a, 0xd2, 0x07,
+	0x85, 0xd8, 0x39, 0x5b, 0x76, 0x3d, 0xbd, 0x39, 0x9b, 0xc8, 0x26, 0x91, 0xc3, 0xf2, 0x7b, 0xb2,
+	0x39, 0xdb, 0xf0, 0xed, 0x4a, 0xfd, 0x63, 0xe1, 0x61, 0xa5, 0xe8, 0x4c, 0x81, 0xec, 0x91, 0xc4,
+	0x3d, 0x64, 0xd1, 0xf7, 0x5d, 0xfa, 0xa4, 0x9f, 0xb1, 0xbb, 0x56, 0x33, 0x8b, 0x47, 0x58, 0x04,
+	0x6d, 0x1b, 0xca, 0xf9, 0x86, 0x6f, 0x6f, 0x9e, 0x6f, 0xd1, 0x1b, 0x9c, 0x3f, 0x51, 0x0d, 0x27,
+	0x35, 0x15, 0xc5, 0x03, 0x2c, 0x46, 0x16, 0x4b, 0xb8, 0xac, 0xab, 0xfd, 0xfa, 0x42, 0x00, 0x5c,
+	0xc9, 0xaa, 0xae, 0xab, 0xf7, 0x35, 0x93, 0xaf, 0xf0, 0xe4, 0x42, 0x83, 0xda, 0xeb, 0x63, 0x4b,
+	0xd8, 0xea, 0x93, 0x73, 0x1e, 0x5b, 0xa3, 0x23, 0x4d, 0x5b, 0xcc, 0xd7, 0x19, 0x1b, 0xb2, 0x14,
+	0x74, 0xa2, 0x93, 0xcc, 0xca, 0xc3, 0x7e, 0xb0, 0x71, 0xc7, 0x7e, 0x19, 0xfb, 0x0b, 0x00, 0x00,
+	0xff, 0xff, 0x80, 0x03, 0xac, 0x94, 0xf2, 0x00, 0x00, 0x00,
+}

vendor/github.com/tsuna/gohbase/pb/FS.proto

@@ -0,0 +1,45 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// This file contains protocol buffers that are written into the filesystem
+package pb;
+
+option java_package = "org.apache.hadoop.hbase.protobuf.generated";
+option java_outer_classname = "FSProtos";
+option java_generate_equals_and_hash = true;
+option optimize_for = SPEED;
+
+/**
+ * The ${HBASE_ROOTDIR}/hbase.version file content
+ */
+message HBaseVersionFileContent {
+  required string version = 1;
+}
+
+/**
+ * Reference file content used when we split an hfile under a region.
+ */
+message Reference {
+  required bytes splitkey = 1;
+  enum Range {
+    TOP = 0;
+    BOTTOM = 1;
+  }
+  required Range range = 2;
+}
+

vendor/github.com/tsuna/gohbase/pb/Filter.pb.go

@@ -0,0 +1,814 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: Filter.proto
+
+package pb
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+type FilterList_Operator int32
+
+const (
+	FilterList_MUST_PASS_ALL FilterList_Operator = 1
+	FilterList_MUST_PASS_ONE FilterList_Operator = 2
+)
+
+var FilterList_Operator_name = map[int32]string{
+	1: "MUST_PASS_ALL",
+	2: "MUST_PASS_ONE",
+}
+var FilterList_Operator_value = map[string]int32{
+	"MUST_PASS_ALL": 1,
+	"MUST_PASS_ONE": 2,
+}
+
+func (x FilterList_Operator) Enum() *FilterList_Operator {
+	p := new(FilterList_Operator)
+	*p = x
+	return p
+}
+func (x FilterList_Operator) String() string {
+	return proto.EnumName(FilterList_Operator_name, int32(x))
+}
+func (x *FilterList_Operator) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(FilterList_Operator_value, data, "FilterList_Operator")
+	if err != nil {
+		return err
+	}
+	*x = FilterList_Operator(value)
+	return nil
+}
+func (FilterList_Operator) EnumDescriptor() ([]byte, []int) { return fileDescriptor9, []int{8, 0} }
+
+type Filter struct {
+	Name             *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
+	SerializedFilter []byte  `protobuf:"bytes,2,opt,name=serialized_filter,json=serializedFilter" json:"serialized_filter,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *Filter) Reset()                    { *m = Filter{} }
+func (m *Filter) String() string            { return proto.CompactTextString(m) }
+func (*Filter) ProtoMessage()               {}
+func (*Filter) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{0} }
+
+func (m *Filter) GetName() string {
+	if m != nil && m.Name != nil {
+		return *m.Name
+	}
+	return ""
+}
+
+func (m *Filter) GetSerializedFilter() []byte {
+	if m != nil {
+		return m.SerializedFilter
+	}
+	return nil
+}
+
+type ColumnCountGetFilter struct {
+	Limit            *int32 `protobuf:"varint,1,req,name=limit" json:"limit,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *ColumnCountGetFilter) Reset()                    { *m = ColumnCountGetFilter{} }
+func (m *ColumnCountGetFilter) String() string            { return proto.CompactTextString(m) }
+func (*ColumnCountGetFilter) ProtoMessage()               {}
+func (*ColumnCountGetFilter) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{1} }
+
+func (m *ColumnCountGetFilter) GetLimit() int32 {
+	if m != nil && m.Limit != nil {
+		return *m.Limit
+	}
+	return 0
+}
+
+type ColumnPaginationFilter struct {
+	Limit            *int32 `protobuf:"varint,1,req,name=limit" json:"limit,omitempty"`
+	Offset           *int32 `protobuf:"varint,2,opt,name=offset" json:"offset,omitempty"`
+	ColumnOffset     []byte `protobuf:"bytes,3,opt,name=column_offset,json=columnOffset" json:"column_offset,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *ColumnPaginationFilter) Reset()                    { *m = ColumnPaginationFilter{} }
+func (m *ColumnPaginationFilter) String() string            { return proto.CompactTextString(m) }
+func (*ColumnPaginationFilter) ProtoMessage()               {}
+func (*ColumnPaginationFilter) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{2} }
+
+func (m *ColumnPaginationFilter) GetLimit() int32 {
+	if m != nil && m.Limit != nil {
+		return *m.Limit
+	}
+	return 0
+}
+
+func (m *ColumnPaginationFilter) GetOffset() int32 {
+	if m != nil && m.Offset != nil {
+		return *m.Offset
+	}
+	return 0
+}
+
+func (m *ColumnPaginationFilter) GetColumnOffset() []byte {
+	if m != nil {
+		return m.ColumnOffset
+	}
+	return nil
+}
+
+type ColumnPrefixFilter struct {
+	Prefix           []byte `protobuf:"bytes,1,req,name=prefix" json:"prefix,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *ColumnPrefixFilter) Reset()                    { *m = ColumnPrefixFilter{} }
+func (m *ColumnPrefixFilter) String() string            { return proto.CompactTextString(m) }
+func (*ColumnPrefixFilter) ProtoMessage()               {}
+func (*ColumnPrefixFilter) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{3} }
+
+func (m *ColumnPrefixFilter) GetPrefix() []byte {
+	if m != nil {
+		return m.Prefix
+	}
+	return nil
+}
+
+type ColumnRangeFilter struct {
+	MinColumn          []byte `protobuf:"bytes,1,opt,name=min_column,json=minColumn" json:"min_column,omitempty"`
+	MinColumnInclusive *bool  `protobuf:"varint,2,opt,name=min_column_inclusive,json=minColumnInclusive" json:"min_column_inclusive,omitempty"`
+	MaxColumn          []byte `protobuf:"bytes,3,opt,name=max_column,json=maxColumn" json:"max_column,omitempty"`
+	MaxColumnInclusive *bool  `protobuf:"varint,4,opt,name=max_column_inclusive,json=maxColumnInclusive" json:"max_column_inclusive,omitempty"`
+	XXX_unrecognized   []byte `json:"-"`
+}
+
+func (m *ColumnRangeFilter) Reset()                    { *m = ColumnRangeFilter{} }
+func (m *ColumnRangeFilter) String() string            { return proto.CompactTextString(m) }
+func (*ColumnRangeFilter) ProtoMessage()               {}
+func (*ColumnRangeFilter) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{4} }
+
+func (m *ColumnRangeFilter) GetMinColumn() []byte {
+	if m != nil {
+		return m.MinColumn
+	}
+	return nil
+}
+
+func (m *ColumnRangeFilter) GetMinColumnInclusive() bool {
+	if m != nil && m.MinColumnInclusive != nil {
+		return *m.MinColumnInclusive
+	}
+	return false
+}
+
+func (m *ColumnRangeFilter) GetMaxColumn() []byte {
+	if m != nil {
+		return m.MaxColumn
+	}
+	return nil
+}
+
+func (m *ColumnRangeFilter) GetMaxColumnInclusive() bool {
+	if m != nil && m.MaxColumnInclusive != nil {
+		return *m.MaxColumnInclusive
+	}
+	return false
+}
+
+type CompareFilter struct {
+	CompareOp        *CompareType `protobuf:"varint,1,req,name=compare_op,json=compareOp,enum=pb.CompareType" json:"compare_op,omitempty"`
+	Comparator       *Comparator  `protobuf:"bytes,2,opt,name=comparator" json:"comparator,omitempty"`
+	XXX_unrecognized []byte       `json:"-"`
+}
+
+func (m *CompareFilter) Reset()                    { *m = CompareFilter{} }
+func (m *CompareFilter) String() string            { return proto.CompactTextString(m) }
+func (*CompareFilter) ProtoMessage()               {}
+func (*CompareFilter) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{5} }
+
+func (m *CompareFilter) GetCompareOp() CompareType {
+	if m != nil && m.CompareOp != nil {
+		return *m.CompareOp
+	}
+	return CompareType_LESS
+}
+
+func (m *CompareFilter) GetComparator() *Comparator {
+	if m != nil {
+		return m.Comparator
+	}
+	return nil
+}
+
+type DependentColumnFilter struct {
+	CompareFilter       *CompareFilter `protobuf:"bytes,1,req,name=compare_filter,json=compareFilter" json:"compare_filter,omitempty"`
+	ColumnFamily        []byte         `protobuf:"bytes,2,opt,name=column_family,json=columnFamily" json:"column_family,omitempty"`
+	ColumnQualifier     []byte         `protobuf:"bytes,3,opt,name=column_qualifier,json=columnQualifier" json:"column_qualifier,omitempty"`
+	DropDependentColumn *bool          `protobuf:"varint,4,opt,name=drop_dependent_column,json=dropDependentColumn" json:"drop_dependent_column,omitempty"`
+	XXX_unrecognized    []byte         `json:"-"`
+}
+
+func (m *DependentColumnFilter) Reset()                    { *m = DependentColumnFilter{} }
+func (m *DependentColumnFilter) String() string            { return proto.CompactTextString(m) }
+func (*DependentColumnFilter) ProtoMessage()               {}
+func (*DependentColumnFilter) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{6} }
+
+func (m *DependentColumnFilter) GetCompareFilter() *CompareFilter {
+	if m != nil {
+		return m.CompareFilter
+	}
+	return nil
+}
+
+func (m *DependentColumnFilter) GetColumnFamily() []byte {
+	if m != nil {
+		return m.ColumnFamily
+	}
+	return nil
+}
+
+func (m *DependentColumnFilter) GetColumnQualifier() []byte {
+	if m != nil {
+		return m.ColumnQualifier
+	}
+	return nil
+}
+
+func (m *DependentColumnFilter) GetDropDependentColumn() bool {
+	if m != nil && m.DropDependentColumn != nil {
+		return *m.DropDependentColumn
+	}
+	return false
+}
+
+type FamilyFilter struct {
+	CompareFilter    *CompareFilter `protobuf:"bytes,1,req,name=compare_filter,json=compareFilter" json:"compare_filter,omitempty"`
+	XXX_unrecognized []byte         `json:"-"`
+}
+
+func (m *FamilyFilter) Reset()                    { *m = FamilyFilter{} }
+func (m *FamilyFilter) String() string            { return proto.CompactTextString(m) }
+func (*FamilyFilter) ProtoMessage()               {}
+func (*FamilyFilter) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{7} }
+
+func (m *FamilyFilter) GetCompareFilter() *CompareFilter {
+	if m != nil {
+		return m.CompareFilter
+	}
+	return nil
+}
+
+type FilterList struct {
+	Operator         *FilterList_Operator `protobuf:"varint,1,req,name=operator,enum=pb.FilterList_Operator" json:"operator,omitempty"`
+	Filters          []*Filter            `protobuf:"bytes,2,rep,name=filters" json:"filters,omitempty"`
+	XXX_unrecognized []byte               `json:"-"`
+}
+
+func (m *FilterList) Reset()                    { *m = FilterList{} }
+func (m *FilterList) String() string            { return proto.CompactTextString(m) }
+func (*FilterList) ProtoMessage()               {}
+func (*FilterList) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{8} }
+
+func (m *FilterList) GetOperator() FilterList_Operator {
+	if m != nil && m.Operator != nil {
+		return *m.Operator
+	}
+	return FilterList_MUST_PASS_ALL
+}
+
+func (m *FilterList) GetFilters() []*Filter {
+	if m != nil {
+		return m.Filters
+	}
+	return nil
+}
+
+type FilterWrapper struct {
+	Filter           *Filter `protobuf:"bytes,1,req,name=filter" json:"filter,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *FilterWrapper) Reset()                    { *m = FilterWrapper{} }
+func (m *FilterWrapper) String() string            { return proto.CompactTextString(m) }
+func (*FilterWrapper) ProtoMessage()               {}
+func (*FilterWrapper) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{9} }
+
+func (m *FilterWrapper) GetFilter() *Filter {
+	if m != nil {
+		return m.Filter
+	}
+	return nil
+}
+
+type FirstKeyOnlyFilter struct {
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *FirstKeyOnlyFilter) Reset()                    { *m = FirstKeyOnlyFilter{} }
+func (m *FirstKeyOnlyFilter) String() string            { return proto.CompactTextString(m) }
+func (*FirstKeyOnlyFilter) ProtoMessage()               {}
+func (*FirstKeyOnlyFilter) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{10} }
+
+type FirstKeyValueMatchingQualifiersFilter struct {
+	Qualifiers       [][]byte `protobuf:"bytes,1,rep,name=qualifiers" json:"qualifiers,omitempty"`
+	XXX_unrecognized []byte   `json:"-"`
+}
+
+func (m *FirstKeyValueMatchingQualifiersFilter) Reset()         { *m = FirstKeyValueMatchingQualifiersFilter{} }
+func (m *FirstKeyValueMatchingQualifiersFilter) String() string { return proto.CompactTextString(m) }
+func (*FirstKeyValueMatchingQualifiersFilter) ProtoMessage()    {}
+func (*FirstKeyValueMatchingQualifiersFilter) Descriptor() ([]byte, []int) {
+	return fileDescriptor9, []int{11}
+}
+
+func (m *FirstKeyValueMatchingQualifiersFilter) GetQualifiers() [][]byte {
+	if m != nil {
+		return m.Qualifiers
+	}
+	return nil
+}
+
+type FuzzyRowFilter struct {
+	FuzzyKeysData    []*BytesBytesPair `protobuf:"bytes,1,rep,name=fuzzy_keys_data,json=fuzzyKeysData" json:"fuzzy_keys_data,omitempty"`
+	XXX_unrecognized []byte            `json:"-"`
+}
+
+func (m *FuzzyRowFilter) Reset()                    { *m = FuzzyRowFilter{} }
+func (m *FuzzyRowFilter) String() string            { return proto.CompactTextString(m) }
+func (*FuzzyRowFilter) ProtoMessage()               {}
+func (*FuzzyRowFilter) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{12} }
+
+func (m *FuzzyRowFilter) GetFuzzyKeysData() []*BytesBytesPair {
+	if m != nil {
+		return m.FuzzyKeysData
+	}
+	return nil
+}
+
+type InclusiveStopFilter struct {
+	StopRowKey       []byte `protobuf:"bytes,1,opt,name=stop_row_key,json=stopRowKey" json:"stop_row_key,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *InclusiveStopFilter) Reset()                    { *m = InclusiveStopFilter{} }
+func (m *InclusiveStopFilter) String() string            { return proto.CompactTextString(m) }
+func (*InclusiveStopFilter) ProtoMessage()               {}
+func (*InclusiveStopFilter) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{13} }
+
+func (m *InclusiveStopFilter) GetStopRowKey() []byte {
+	if m != nil {
+		return m.StopRowKey
+	}
+	return nil
+}
+
+type KeyOnlyFilter struct {
+	LenAsVal         *bool  `protobuf:"varint,1,req,name=len_as_val,json=lenAsVal" json:"len_as_val,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *KeyOnlyFilter) Reset()                    { *m = KeyOnlyFilter{} }
+func (m *KeyOnlyFilter) String() string            { return proto.CompactTextString(m) }
+func (*KeyOnlyFilter) ProtoMessage()               {}
+func (*KeyOnlyFilter) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{14} }
+
+func (m *KeyOnlyFilter) GetLenAsVal() bool {
+	if m != nil && m.LenAsVal != nil {
+		return *m.LenAsVal
+	}
+	return false
+}
+
+type MultipleColumnPrefixFilter struct {
+	SortedPrefixes   [][]byte `protobuf:"bytes,1,rep,name=sorted_prefixes,json=sortedPrefixes" json:"sorted_prefixes,omitempty"`
+	XXX_unrecognized []byte   `json:"-"`
+}
+
+func (m *MultipleColumnPrefixFilter) Reset()                    { *m = MultipleColumnPrefixFilter{} }
+func (m *MultipleColumnPrefixFilter) String() string            { return proto.CompactTextString(m) }
+func (*MultipleColumnPrefixFilter) ProtoMessage()               {}
+func (*MultipleColumnPrefixFilter) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{15} }
+
+func (m *MultipleColumnPrefixFilter) GetSortedPrefixes() [][]byte {
+	if m != nil {
+		return m.SortedPrefixes
+	}
+	return nil
+}
+
+type PageFilter struct {
+	PageSize         *int64 `protobuf:"varint,1,req,name=page_size,json=pageSize" json:"page_size,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *PageFilter) Reset()                    { *m = PageFilter{} }
+func (m *PageFilter) String() string            { return proto.CompactTextString(m) }
+func (*PageFilter) ProtoMessage()               {}
+func (*PageFilter) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{16} }
+
+func (m *PageFilter) GetPageSize() int64 {
+	if m != nil && m.PageSize != nil {
+		return *m.PageSize
+	}
+	return 0
+}
+
+type PrefixFilter struct {
+	Prefix           []byte `protobuf:"bytes,1,opt,name=prefix" json:"prefix,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *PrefixFilter) Reset()                    { *m = PrefixFilter{} }
+func (m *PrefixFilter) String() string            { return proto.CompactTextString(m) }
+func (*PrefixFilter) ProtoMessage()               {}
+func (*PrefixFilter) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{17} }
+
+func (m *PrefixFilter) GetPrefix() []byte {
+	if m != nil {
+		return m.Prefix
+	}
+	return nil
+}
+
+type QualifierFilter struct {
+	CompareFilter    *CompareFilter `protobuf:"bytes,1,req,name=compare_filter,json=compareFilter" json:"compare_filter,omitempty"`
+	XXX_unrecognized []byte         `json:"-"`
+}
+
+func (m *QualifierFilter) Reset()                    { *m = QualifierFilter{} }
+func (m *QualifierFilter) String() string            { return proto.CompactTextString(m) }
+func (*QualifierFilter) ProtoMessage()               {}
+func (*QualifierFilter) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{18} }
+
+func (m *QualifierFilter) GetCompareFilter() *CompareFilter {
+	if m != nil {
+		return m.CompareFilter
+	}
+	return nil
+}
+
+type RandomRowFilter struct {
+	Chance           *float32 `protobuf:"fixed32,1,req,name=chance" json:"chance,omitempty"`
+	XXX_unrecognized []byte   `json:"-"`
+}
+
+func (m *RandomRowFilter) Reset()                    { *m = RandomRowFilter{} }
+func (m *RandomRowFilter) String() string            { return proto.CompactTextString(m) }
+func (*RandomRowFilter) ProtoMessage()               {}
+func (*RandomRowFilter) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{19} }
+
+func (m *RandomRowFilter) GetChance() float32 {
+	if m != nil && m.Chance != nil {
+		return *m.Chance
+	}
+	return 0
+}
+
+type RowFilter struct {
+	CompareFilter    *CompareFilter `protobuf:"bytes,1,req,name=compare_filter,json=compareFilter" json:"compare_filter,omitempty"`
+	XXX_unrecognized []byte         `json:"-"`
+}
+
+func (m *RowFilter) Reset()                    { *m = RowFilter{} }
+func (m *RowFilter) String() string            { return proto.CompactTextString(m) }
+func (*RowFilter) ProtoMessage()               {}
+func (*RowFilter) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{20} }
+
+func (m *RowFilter) GetCompareFilter() *CompareFilter {
+	if m != nil {
+		return m.CompareFilter
+	}
+	return nil
+}
+
+type SingleColumnValueExcludeFilter struct {
+	SingleColumnValueFilter *SingleColumnValueFilter `protobuf:"bytes,1,req,name=single_column_value_filter,json=singleColumnValueFilter" json:"single_column_value_filter,omitempty"`
+	XXX_unrecognized        []byte                   `json:"-"`
+}
+
+func (m *SingleColumnValueExcludeFilter) Reset()                    { *m = SingleColumnValueExcludeFilter{} }
+func (m *SingleColumnValueExcludeFilter) String() string            { return proto.CompactTextString(m) }
+func (*SingleColumnValueExcludeFilter) ProtoMessage()               {}
+func (*SingleColumnValueExcludeFilter) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{21} }
+
+func (m *SingleColumnValueExcludeFilter) GetSingleColumnValueFilter() *SingleColumnValueFilter {
+	if m != nil {
+		return m.SingleColumnValueFilter
+	}
+	return nil
+}
+
+type SingleColumnValueFilter struct {
+	ColumnFamily      []byte       `protobuf:"bytes,1,opt,name=column_family,json=columnFamily" json:"column_family,omitempty"`
+	ColumnQualifier   []byte       `protobuf:"bytes,2,opt,name=column_qualifier,json=columnQualifier" json:"column_qualifier,omitempty"`
+	CompareOp         *CompareType `protobuf:"varint,3,req,name=compare_op,json=compareOp,enum=pb.CompareType" json:"compare_op,omitempty"`
+	Comparator        *Comparator  `protobuf:"bytes,4,req,name=comparator" json:"comparator,omitempty"`
+	FilterIfMissing   *bool        `protobuf:"varint,5,opt,name=filter_if_missing,json=filterIfMissing" json:"filter_if_missing,omitempty"`
+	LatestVersionOnly *bool        `protobuf:"varint,6,opt,name=latest_version_only,json=latestVersionOnly" json:"latest_version_only,omitempty"`
+	XXX_unrecognized  []byte       `json:"-"`
+}
+
+func (m *SingleColumnValueFilter) Reset()                    { *m = SingleColumnValueFilter{} }
+func (m *SingleColumnValueFilter) String() string            { return proto.CompactTextString(m) }
+func (*SingleColumnValueFilter) ProtoMessage()               {}
+func (*SingleColumnValueFilter) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{22} }
+
+func (m *SingleColumnValueFilter) GetColumnFamily() []byte {
+	if m != nil {
+		return m.ColumnFamily
+	}
+	return nil
+}
+
+func (m *SingleColumnValueFilter) GetColumnQualifier() []byte {
+	if m != nil {
+		return m.ColumnQualifier
+	}
+	return nil
+}
+
+func (m *SingleColumnValueFilter) GetCompareOp() CompareType {
+	if m != nil && m.CompareOp != nil {
+		return *m.CompareOp
+	}
+	return CompareType_LESS
+}
+
+func (m *SingleColumnValueFilter) GetComparator() *Comparator {
+	if m != nil {
+		return m.Comparator
+	}
+	return nil
+}
+
+func (m *SingleColumnValueFilter) GetFilterIfMissing() bool {
+	if m != nil && m.FilterIfMissing != nil {
+		return *m.FilterIfMissing
+	}
+	return false
+}
+
+func (m *SingleColumnValueFilter) GetLatestVersionOnly() bool {
+	if m != nil && m.LatestVersionOnly != nil {
+		return *m.LatestVersionOnly
+	}
+	return false
+}
+
+type SkipFilter struct {
+	Filter           *Filter `protobuf:"bytes,1,req,name=filter" json:"filter,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *SkipFilter) Reset()                    { *m = SkipFilter{} }
+func (m *SkipFilter) String() string            { return proto.CompactTextString(m) }
+func (*SkipFilter) ProtoMessage()               {}
+func (*SkipFilter) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{23} }
+
+func (m *SkipFilter) GetFilter() *Filter {
+	if m != nil {
+		return m.Filter
+	}
+	return nil
+}
+
+type TimestampsFilter struct {
+	Timestamps       []int64 `protobuf:"varint,1,rep,packed,name=timestamps" json:"timestamps,omitempty"`
+	CanHint          *bool   `protobuf:"varint,2,opt,name=can_hint,json=canHint" json:"can_hint,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *TimestampsFilter) Reset()                    { *m = TimestampsFilter{} }
+func (m *TimestampsFilter) String() string            { return proto.CompactTextString(m) }
+func (*TimestampsFilter) ProtoMessage()               {}
+func (*TimestampsFilter) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{24} }
+
+func (m *TimestampsFilter) GetTimestamps() []int64 {
+	if m != nil {
+		return m.Timestamps
+	}
+	return nil
+}
+
+func (m *TimestampsFilter) GetCanHint() bool {
+	if m != nil && m.CanHint != nil {
+		return *m.CanHint
+	}
+	return false
+}
+
+type ValueFilter struct {
+	CompareFilter    *CompareFilter `protobuf:"bytes,1,req,name=compare_filter,json=compareFilter" json:"compare_filter,omitempty"`
+	XXX_unrecognized []byte         `json:"-"`
+}
+
+func (m *ValueFilter) Reset()                    { *m = ValueFilter{} }
+func (m *ValueFilter) String() string            { return proto.CompactTextString(m) }
+func (*ValueFilter) ProtoMessage()               {}
+func (*ValueFilter) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{25} }
+
+func (m *ValueFilter) GetCompareFilter() *CompareFilter {
+	if m != nil {
+		return m.CompareFilter
+	}
+	return nil
+}
+
+type WhileMatchFilter struct {
+	Filter           *Filter `protobuf:"bytes,1,req,name=filter" json:"filter,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *WhileMatchFilter) Reset()                    { *m = WhileMatchFilter{} }
+func (m *WhileMatchFilter) String() string            { return proto.CompactTextString(m) }
+func (*WhileMatchFilter) ProtoMessage()               {}
+func (*WhileMatchFilter) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{26} }
+
+func (m *WhileMatchFilter) GetFilter() *Filter {
+	if m != nil {
+		return m.Filter
+	}
+	return nil
+}
+
+type FilterAllFilter struct {
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *FilterAllFilter) Reset()                    { *m = FilterAllFilter{} }
+func (m *FilterAllFilter) String() string            { return proto.CompactTextString(m) }
+func (*FilterAllFilter) ProtoMessage()               {}
+func (*FilterAllFilter) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{27} }
+
+type RowRange struct {
+	StartRow          []byte `protobuf:"bytes,1,opt,name=start_row,json=startRow" json:"start_row,omitempty"`
+	StartRowInclusive *bool  `protobuf:"varint,2,opt,name=start_row_inclusive,json=startRowInclusive" json:"start_row_inclusive,omitempty"`
+	StopRow           []byte `protobuf:"bytes,3,opt,name=stop_row,json=stopRow" json:"stop_row,omitempty"`
+	StopRowInclusive  *bool  `protobuf:"varint,4,opt,name=stop_row_inclusive,json=stopRowInclusive" json:"stop_row_inclusive,omitempty"`
+	XXX_unrecognized  []byte `json:"-"`
+}
+
+func (m *RowRange) Reset()                    { *m = RowRange{} }
+func (m *RowRange) String() string            { return proto.CompactTextString(m) }
+func (*RowRange) ProtoMessage()               {}
+func (*RowRange) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{28} }
+
+func (m *RowRange) GetStartRow() []byte {
+	if m != nil {
+		return m.StartRow
+	}
+	return nil
+}
+
+func (m *RowRange) GetStartRowInclusive() bool {
+	if m != nil && m.StartRowInclusive != nil {
+		return *m.StartRowInclusive
+	}
+	return false
+}
+
+func (m *RowRange) GetStopRow() []byte {
+	if m != nil {
+		return m.StopRow
+	}
+	return nil
+}
+
+func (m *RowRange) GetStopRowInclusive() bool {
+	if m != nil && m.StopRowInclusive != nil {
+		return *m.StopRowInclusive
+	}
+	return false
+}
+
+type MultiRowRangeFilter struct {
+	RowRangeList     []*RowRange `protobuf:"bytes,1,rep,name=row_range_list,json=rowRangeList" json:"row_range_list,omitempty"`
+	XXX_unrecognized []byte      `json:"-"`
+}
+
+func (m *MultiRowRangeFilter) Reset()                    { *m = MultiRowRangeFilter{} }
+func (m *MultiRowRangeFilter) String() string            { return proto.CompactTextString(m) }
+func (*MultiRowRangeFilter) ProtoMessage()               {}
+func (*MultiRowRangeFilter) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{29} }
+
+func (m *MultiRowRangeFilter) GetRowRangeList() []*RowRange {
+	if m != nil {
+		return m.RowRangeList
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*Filter)(nil), "pb.Filter")
+	proto.RegisterType((*ColumnCountGetFilter)(nil), "pb.ColumnCountGetFilter")
+	proto.RegisterType((*ColumnPaginationFilter)(nil), "pb.ColumnPaginationFilter")
+	proto.RegisterType((*ColumnPrefixFilter)(nil), "pb.ColumnPrefixFilter")
+	proto.RegisterType((*ColumnRangeFilter)(nil), "pb.ColumnRangeFilter")
+	proto.RegisterType((*CompareFilter)(nil), "pb.CompareFilter")
+	proto.RegisterType((*DependentColumnFilter)(nil), "pb.DependentColumnFilter")
+	proto.RegisterType((*FamilyFilter)(nil), "pb.FamilyFilter")
+	proto.RegisterType((*FilterList)(nil), "pb.FilterList")
+	proto.RegisterType((*FilterWrapper)(nil), "pb.FilterWrapper")
+	proto.RegisterType((*FirstKeyOnlyFilter)(nil), "pb.FirstKeyOnlyFilter")
+	proto.RegisterType((*FirstKeyValueMatchingQualifiersFilter)(nil), "pb.FirstKeyValueMatchingQualifiersFilter")
+	proto.RegisterType((*FuzzyRowFilter)(nil), "pb.FuzzyRowFilter")
+	proto.RegisterType((*InclusiveStopFilter)(nil), "pb.InclusiveStopFilter")
+	proto.RegisterType((*KeyOnlyFilter)(nil), "pb.KeyOnlyFilter")
+	proto.RegisterType((*MultipleColumnPrefixFilter)(nil), "pb.MultipleColumnPrefixFilter")
+	proto.RegisterType((*PageFilter)(nil), "pb.PageFilter")
+	proto.RegisterType((*PrefixFilter)(nil), "pb.PrefixFilter")
+	proto.RegisterType((*QualifierFilter)(nil), "pb.QualifierFilter")
+	proto.RegisterType((*RandomRowFilter)(nil), "pb.RandomRowFilter")
+	proto.RegisterType((*RowFilter)(nil), "pb.RowFilter")
+	proto.RegisterType((*SingleColumnValueExcludeFilter)(nil), "pb.SingleColumnValueExcludeFilter")
+	proto.RegisterType((*SingleColumnValueFilter)(nil), "pb.SingleColumnValueFilter")
+	proto.RegisterType((*SkipFilter)(nil), "pb.SkipFilter")
+	proto.RegisterType((*TimestampsFilter)(nil), "pb.TimestampsFilter")
+	proto.RegisterType((*ValueFilter)(nil), "pb.ValueFilter")
+	proto.RegisterType((*WhileMatchFilter)(nil), "pb.WhileMatchFilter")
+	proto.RegisterType((*FilterAllFilter)(nil), "pb.FilterAllFilter")
+	proto.RegisterType((*RowRange)(nil), "pb.RowRange")
+	proto.RegisterType((*MultiRowRangeFilter)(nil), "pb.MultiRowRangeFilter")
+	proto.RegisterEnum("pb.FilterList_Operator", FilterList_Operator_name, FilterList_Operator_value)
+}
+
+func init() { proto.RegisterFile("Filter.proto", fileDescriptor9) }
+
+var fileDescriptor9 = []byte{
+	// 1134 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0xd9, 0x6e, 0x1b, 0x37,
+	0x17, 0xc6, 0x48, 0xb1, 0x22, 0x1f, 0xed, 0x63, 0xc7, 0x51, 0x9c, 0xff, 0x0f, 0x0c, 0x76, 0x73,
+	0x52, 0x57, 0x30, 0x14, 0xa0, 0x2d, 0x7a, 0x67, 0x39, 0xde, 0x60, 0xbb, 0x56, 0x28, 0xd7, 0xe9,
+	0xdd, 0x80, 0x96, 0x28, 0x89, 0xf0, 0x88, 0x9c, 0x0e, 0x29, 0xdb, 0xd2, 0x13, 0xf4, 0x15, 0x7a,
+	0x97, 0x9b, 0x3e, 0x42, 0x1f, 0xa5, 0xef, 0x53, 0x70, 0x99, 0x91, 0x14, 0x3b, 0x41, 0x96, 0x1b,
+	0x41, 0xfc, 0xce, 0xc7, 0xb3, 0x92, 0xdf, 0x10, 0x8a, 0xfb, 0x2c, 0x54, 0x34, 0x6e, 0x44, 0xb1,
+	0x50, 0xc2, 0xcf, 0x44, 0x97, 0xeb, 0x85, 0xc3, 0x16, 0x91, 0xd4, 0x02, 0xeb, 0xd5, 0x5d, 0x31,
+	0x8a, 0x48, 0x4c, 0x94, 0x70, 0x14, 0x74, 0x04, 0x39, 0xbb, 0xc5, 0xf7, 0xe1, 0x01, 0x27, 0x23,
+	0x5a, 0xf7, 0x36, 0x32, 0x9b, 0xcb, 0xd8, 0xfc, 0xf7, 0xbf, 0x87, 0x9a, 0xa4, 0x31, 0x23, 0x21,
+	0x9b, 0xd2, 0x5e, 0xd0, 0x37, 0xc4, 0x7a, 0x66, 0xc3, 0xdb, 0x2c, 0xe2, 0xea, 0xcc, 0x60, 0x1d,
+	0xa0, 0x2d, 0x58, 0xdd, 0x15, 0xe1, 0x78, 0xc4, 0x77, 0xc5, 0x98, 0xab, 0x03, 0xaa, 0x9c, 0xe3,
+	0x55, 0x58, 0x0a, 0xd9, 0x88, 0x29, 0xe3, 0x79, 0x09, 0xdb, 0x05, 0xba, 0x82, 0x35, 0xcb, 0x6e,
+	0x93, 0x01, 0xe3, 0x44, 0x31, 0xc1, 0x3f, 0xc4, 0xf7, 0xd7, 0x20, 0x27, 0xfa, 0x7d, 0x49, 0x95,
+	0x89, 0xbf, 0x84, 0xdd, 0xca, 0xff, 0x0a, 0x4a, 0x5d, 0xe3, 0x27, 0x70, 0xe6, 0xac, 0x49, 0xaf,
+	0x68, 0xc1, 0x33, 0x83, 0xa1, 0x2d, 0xf0, 0x5d, 0xb0, 0x98, 0xf6, 0xd9, 0xad, 0x0b, 0xb4, 0x06,
+	0xb9, 0xc8, 0xac, 0x4d, 0xa4, 0x22, 0x76, 0x2b, 0xf4, 0x8f, 0x07, 0x35, 0x4b, 0xc7, 0x84, 0x0f,
+	0xa8, 0x63, 0xff, 0x1f, 0x60, 0xc4, 0x78, 0x60, 0xfd, 0xd6, 0x3d, 0x13, 0x65, 0x79, 0xc4, 0xb8,
+	0x65, 0xfa, 0xdb, 0xb0, 0x3a, 0x33, 0x07, 0x8c, 0x77, 0xc3, 0xb1, 0x64, 0xd7, 0xd4, 0x64, 0x9b,
+	0xc7, 0x7e, 0x4a, 0x3c, 0x4a, 0x2c, 0xc6, 0x21, 0xb9, 0x4d, 0x1c, 0x66, 0x9d, 0x43, 0x72, 0x3b,
+	0xe7, 0x30, 0x35, 0xcf, 0x39, 0x7c, 0xe0, 0x1c, 0x26, 0xc4, 0xd4, 0x21, 0x12, 0x50, 0xb2, 0xf3,
+	0x4d, 0x52, 0x6e, 0x00, 0x74, 0x2d, 0x10, 0x88, 0xc8, 0x14, 0x59, 0x6e, 0x56, 0x1a, 0xd1, 0x65,
+	0xc3, 0xd1, 0xce, 0x27, 0x11, 0xc5, 0xcb, 0x8e, 0x72, 0x16, 0xcd, 0xf8, 0xfa, 0x80, 0x98, 0xcc,
+	0x0b, 0xcd, 0xf2, 0x8c, 0xaf, 0x51, 0x3c, 0xc7, 0x40, 0xff, 0x7a, 0xf0, 0xe8, 0x15, 0x8d, 0x28,
+	0xef, 0x51, 0xae, 0x6c, 0x36, 0x2e, 0xf2, 0xcf, 0x50, 0x4e, 0x22, 0xbb, 0x53, 0xa3, 0xa3, 0x17,
+	0x9a, 0xb5, 0xb9, 0xe8, 0x96, 0x8a, 0x4b, 0xdd, 0x85, 0x9c, 0x67, 0xf3, 0xec, 0x93, 0x11, 0x0b,
+	0x27, 0xee, 0xb8, 0xb9, 0x79, 0xee, 0x1b, 0xcc, 0x7f, 0x0e, 0x55, 0x47, 0xfa, 0x63, 0x4c, 0x42,
+	0xd6, 0x67, 0x34, 0x76, 0x0d, 0xac, 0x58, 0xfc, 0x75, 0x02, 0xfb, 0x4d, 0x78, 0xd4, 0x8b, 0x45,
+	0x14, 0xf4, 0x92, 0x3c, 0x93, 0x86, 0xdb, 0x3e, 0xae, 0x68, 0xe3, 0x3b, 0x35, 0xa0, 0x43, 0x28,
+	0xda, 0x40, 0x5f, 0x5a, 0x0d, 0xfa, 0xcb, 0x03, 0xb0, 0x7f, 0x4f, 0x98, 0x54, 0xfe, 0x4b, 0xc8,
+	0x8b, 0x88, 0xda, 0xf6, 0xda, 0x71, 0x3c, 0xd6, 0x2e, 0x66, 0x8c, 0xc6, 0x99, 0x33, 0xe3, 0x94,
+	0xe8, 0x7f, 0x0d, 0x0f, 0x6d, 0x54, 0x59, 0xcf, 0x6c, 0x64, 0x37, 0x0b, 0x4d, 0x98, 0xed, 0xc1,
+	0x89, 0x09, 0x6d, 0x43, 0x3e, 0xd9, 0xeb, 0xd7, 0xa0, 0x74, 0xfa, 0x5b, 0xe7, 0x3c, 0x68, 0xef,
+	0x74, 0x3a, 0xc1, 0xce, 0xc9, 0x49, 0xd5, 0x5b, 0x84, 0xce, 0x7e, 0xdd, 0xab, 0x66, 0xd0, 0x4b,
+	0x28, 0x59, 0x27, 0x6f, 0x62, 0x12, 0x45, 0x34, 0xf6, 0x11, 0xe4, 0x16, 0xca, 0x9b, 0x8f, 0xe3,
+	0x2c, 0x68, 0x15, 0xfc, 0x7d, 0x16, 0x4b, 0x75, 0x4c, 0x27, 0x67, 0x3c, 0x69, 0x10, 0x3a, 0x80,
+	0x6f, 0x12, 0xf4, 0x82, 0x84, 0x63, 0x7a, 0x4a, 0x54, 0x77, 0xc8, 0xf8, 0x20, 0x1d, 0x83, 0x74,
+	0x9d, 0x7c, 0x06, 0x90, 0x4e, 0x4c, 0xd6, 0xbd, 0x8d, 0xec, 0x66, 0x11, 0xcf, 0x21, 0xe8, 0x04,
+	0xca, 0xfb, 0xe3, 0xe9, 0x74, 0x82, 0xc5, 0x8d, 0xdb, 0xf1, 0x0b, 0x54, 0xfa, 0x1a, 0x09, 0xae,
+	0xe8, 0x44, 0x06, 0x3d, 0xa2, 0x88, 0xd9, 0x56, 0x68, 0xfa, 0x3a, 0xbb, 0xd6, 0x44, 0x51, 0x69,
+	0x7e, 0xda, 0x84, 0xc5, 0xb8, 0x64, 0xa8, 0xc7, 0x74, 0x22, 0x5f, 0x11, 0x45, 0xd0, 0x4f, 0xb0,
+	0x92, 0xde, 0x8e, 0x8e, 0x12, 0x91, 0x73, 0xb9, 0x01, 0x45, 0xa9, 0x44, 0x14, 0xc4, 0xe2, 0x46,
+	0x7b, 0x75, 0x77, 0x19, 0x34, 0x86, 0xc5, 0xcd, 0x31, 0x9d, 0xa0, 0x1f, 0xa0, 0xb4, 0x50, 0xa0,
+	0xff, 0x3f, 0x80, 0x90, 0xf2, 0x80, 0xc8, 0xe0, 0x9a, 0x84, 0xa6, 0x3d, 0x79, 0x9c, 0x0f, 0x29,
+	0xdf, 0x91, 0x17, 0x24, 0x44, 0x7b, 0xb0, 0x7e, 0x3a, 0x0e, 0x15, 0x8b, 0x42, 0x7a, 0x8f, 0xcc,
+	0x7c, 0x07, 0x15, 0x29, 0x62, 0x45, 0x7b, 0x81, 0xd5, 0x17, 0x9a, 0x14, 0x5e, 0xb6, 0x70, 0xdb,
+	0xa1, 0xe8, 0x39, 0x40, 0x9b, 0xa4, 0x7a, 0xf3, 0x14, 0x96, 0x23, 0x32, 0xa0, 0x81, 0x64, 0x53,
+	0x2b, 0xca, 0x59, 0x9c, 0xd7, 0x40, 0x87, 0x4d, 0x29, 0xfa, 0x16, 0x8a, 0xef, 0x95, 0x32, 0x6f,
+	0x4e, 0xca, 0x8e, 0xa1, 0x92, 0xce, 0xe0, 0x8b, 0x0f, 0xf3, 0x73, 0xa8, 0x60, 0xc2, 0x7b, 0x62,
+	0x34, 0x9b, 0xce, 0x1a, 0xe4, 0xba, 0x43, 0xc2, 0xbb, 0x36, 0xc3, 0x0c, 0x76, 0x2b, 0xb4, 0x07,
+	0xcb, 0x33, 0xd2, 0xe7, 0x47, 0x9c, 0xc2, 0xb3, 0x0e, 0xe3, 0x83, 0xa4, 0xad, 0xe6, 0x6c, 0xed,
+	0xdd, 0x76, 0xc3, 0x71, 0x2f, 0xe9, 0xd2, 0xef, 0xb0, 0x2e, 0x0d, 0x23, 0x11, 0xca, 0x6b, 0xcd,
+	0x59, 0x8c, 0xf3, 0x54, 0xc7, 0xb9, 0xe3, 0xc7, 0x45, 0x7c, 0x2c, 0xef, 0x37, 0xa0, 0xbf, 0x33,
+	0xf0, 0xf8, 0x3d, 0x9b, 0xee, 0x8a, 0x94, 0xf7, 0x91, 0x22, 0x95, 0xb9, 0x5f, 0xa4, 0x16, 0x85,
+	0x3a, 0xfb, 0x89, 0x42, 0xfd, 0xc0, 0x54, 0xf9, 0x01, 0xa1, 0xf6, 0x5f, 0x40, 0xcd, 0x76, 0x24,
+	0x60, 0xfd, 0x60, 0xc4, 0xa4, 0xae, 0xb9, 0xbe, 0x64, 0x04, 0xb0, 0x62, 0x0d, 0x47, 0xfd, 0x53,
+	0x0b, 0xfb, 0x0d, 0x58, 0x09, 0x89, 0xa2, 0x52, 0x05, 0xd7, 0x34, 0x96, 0x4c, 0xf0, 0x40, 0xf0,
+	0x70, 0x52, 0xcf, 0x19, 0x76, 0xcd, 0x9a, 0x2e, 0xac, 0x45, 0x5f, 0x10, 0xb4, 0x0d, 0xd0, 0xb9,
+	0x62, 0xc9, 0xdd, 0xfa, 0x18, 0x0d, 0x79, 0x0d, 0xd5, 0x73, 0x36, 0xa2, 0x52, 0x91, 0x51, 0x24,
+	0xd3, 0x7d, 0xa0, 0x52, 0xcc, 0xdc, 0x8f, 0x6c, 0x2b, 0x53, 0xf5, 0xf0, 0x1c, 0xea, 0x3f, 0x81,
+	0x7c, 0x97, 0xf0, 0x60, 0xc8, 0xb8, 0x72, 0x9f, 0xd5, 0x87, 0x5d, 0xc2, 0x0f, 0x19, 0x57, 0xe8,
+	0x00, 0x0a, 0xf3, 0xf3, 0xf9, 0xfc, 0x13, 0xf7, 0x23, 0x54, 0xdf, 0x0c, 0x59, 0x68, 0x15, 0xec,
+	0x13, 0x6a, 0xaa, 0x41, 0xc5, 0x22, 0x3b, 0x61, 0xe8, 0x5c, 0xbd, 0xf5, 0x20, 0x8f, 0xc5, 0x8d,
+	0x79, 0x43, 0xe8, 0xdb, 0x2c, 0x15, 0x89, 0x95, 0x16, 0x1d, 0x77, 0x5a, 0xf2, 0x06, 0xc0, 0xe2,
+	0x46, 0xb7, 0x3c, 0x35, 0xde, 0x79, 0x3a, 0xd4, 0x12, 0xda, 0xec, 0xe5, 0xf0, 0x04, 0xf2, 0x89,
+	0x80, 0xb9, 0xcf, 0xde, 0x43, 0x27, 0x5e, 0xfe, 0x16, 0xf8, 0xa9, 0xb6, 0xbd, 0xfb, 0x66, 0xa8,
+	0x3a, 0xd2, 0xec, 0xc5, 0x70, 0x04, 0x2b, 0x46, 0xb8, 0x92, 0x34, 0x5d, 0xc1, 0x4d, 0x28, 0xeb,
+	0xfd, 0xb1, 0x86, 0x82, 0x90, 0x49, 0xe5, 0x24, 0xb7, 0xa8, 0x0b, 0x4f, 0xb8, 0xb8, 0x18, 0xbb,
+	0x7f, 0xfa, 0xc3, 0xd5, 0x6a, 0xc1, 0x0b, 0x11, 0x0f, 0x1a, 0x24, 0x22, 0xdd, 0x21, 0x6d, 0x0c,
+	0x49, 0x4f, 0x88, 0xa8, 0x31, 0xbc, 0x4c, 0xdf, 0x9e, 0x97, 0xe3, 0x7e, 0x63, 0x40, 0xb9, 0xfe,
+	0x42, 0xd1, 0x5e, 0xcb, 0xbd, 0x53, 0xdb, 0xda, 0x22, 0x0f, 0xbd, 0x3f, 0x3d, 0xef, 0xad, 0xe7,
+	0xfd, 0x17, 0x00, 0x00, 0xff, 0xff, 0xce, 0xd0, 0xd7, 0x26, 0xbe, 0x0a, 0x00, 0x00,
+}

vendor/github.com/tsuna/gohbase/pb/Filter.proto

@@ -0,0 +1,171 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// This file contains protocol buffers that are used for filters
+package pb;
+
+option java_package = "org.apache.hadoop.hbase.protobuf.generated";
+option java_outer_classname = "FilterProtos";
+option java_generic_services = true;
+option java_generate_equals_and_hash = true;
+option optimize_for = SPEED;
+
+import "HBase.proto";
+import "Comparator.proto";
+
+message Filter {
+  required string name = 1;
+  optional bytes serialized_filter = 2;
+}
+
+message ColumnCountGetFilter {
+  required int32 limit = 1;
+}
+
+message ColumnPaginationFilter {
+  required int32 limit = 1;
+  optional int32 offset = 2;
+  optional bytes column_offset = 3;
+}
+
+message ColumnPrefixFilter {
+  required bytes prefix = 1;
+}
+
+message ColumnRangeFilter {
+  optional bytes min_column = 1;
+  optional bool min_column_inclusive = 2;
+  optional bytes max_column = 3;
+  optional bool max_column_inclusive = 4;
+}
+
+message CompareFilter {
+  required CompareType compare_op = 1;
+  optional Comparator comparator = 2;
+}
+
+message DependentColumnFilter {
+  required CompareFilter compare_filter = 1;
+  optional bytes column_family = 2;
+  optional bytes column_qualifier = 3;
+  optional bool drop_dependent_column = 4;
+}
+
+message FamilyFilter {
+  required CompareFilter compare_filter = 1;
+}
+
+message FilterList {
+  required Operator operator = 1;
+  repeated Filter filters = 2;
+
+  enum Operator {
+    MUST_PASS_ALL = 1;
+    MUST_PASS_ONE = 2;
+  }
+}
+
+message FilterWrapper {
+  required Filter filter = 1;
+}
+
+message FirstKeyOnlyFilter {
+}
+
+message FirstKeyValueMatchingQualifiersFilter {
+  repeated bytes qualifiers = 1;
+}
+
+message FuzzyRowFilter {
+  repeated BytesBytesPair fuzzy_keys_data = 1;
+}
+
+message InclusiveStopFilter {
+  optional bytes stop_row_key = 1;
+}
+
+message KeyOnlyFilter {
+  required bool len_as_val = 1;
+}
+
+message MultipleColumnPrefixFilter {
+  repeated bytes sorted_prefixes = 1;
+}
+
+message PageFilter {
+  required int64 page_size = 1;
+}
+
+message PrefixFilter {
+  optional bytes prefix = 1;
+}
+
+message QualifierFilter {
+  required CompareFilter compare_filter = 1;
+}
+
+message RandomRowFilter {
+  required float chance = 1;
+}
+
+message RowFilter {
+  required CompareFilter compare_filter = 1;
+}
+
+message SingleColumnValueExcludeFilter {
+  required SingleColumnValueFilter single_column_value_filter = 1;
+}
+
+message SingleColumnValueFilter {
+  optional bytes column_family = 1;
+  optional bytes column_qualifier = 2;
+  required CompareType compare_op = 3;
+  required Comparator comparator = 4;
+  optional bool filter_if_missing = 5;
+  optional bool latest_version_only = 6;
+}
+
+message SkipFilter {
+  required Filter filter = 1;
+}
+
+message TimestampsFilter {
+  repeated int64 timestamps = 1 [packed=true];
+  optional bool can_hint = 2;
+}
+
+message ValueFilter {
+  required CompareFilter compare_filter = 1;
+}
+
+message WhileMatchFilter {
+  required Filter filter = 1;
+}
+message FilterAllFilter {
+}
+
+message RowRange {
+  optional bytes start_row = 1;
+  optional bool start_row_inclusive = 2;
+  optional bytes stop_row = 3;
+  optional bool stop_row_inclusive =4;
+}
+
+message MultiRowRangeFilter {
+  repeated RowRange row_range_list = 1;
+}

vendor/github.com/tsuna/gohbase/pb/HBase.proto

@@ -0,0 +1,240 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// This file contains protocol buffers that are shared throughout HBase
+package pb;
+
+option java_package = "org.apache.hadoop.hbase.protobuf.generated";
+option java_outer_classname = "HBaseProtos";
+option java_generate_equals_and_hash = true;
+option optimize_for = SPEED;
+
+import "Cell.proto";
+
+/**
+ * Table Name
+ */
+message TableName {
+  required bytes namespace = 1;
+  required bytes qualifier = 2;
+}
+
+/**
+ * Table Schema
+ * Inspired by the rest TableSchema
+ */
+message TableSchema {
+  optional TableName table_name = 1;
+  repeated BytesBytesPair attributes = 2;
+  repeated ColumnFamilySchema column_families = 3;
+  repeated NameStringPair configuration = 4;
+}
+
+/**
+ * Column Family Schema
+ * Inspired by the rest ColumSchemaMessage
+ */
+message ColumnFamilySchema {
+  required bytes name = 1;
+  repeated BytesBytesPair attributes = 2;
+  repeated NameStringPair configuration = 3;
+}
+
+/**
+ * Protocol buffer version of HRegionInfo.
+ */
+message RegionInfo {
+  required uint64 region_id = 1;
+  required TableName table_name = 2;
+  optional bytes start_key = 3;
+  optional bytes end_key = 4;
+  optional bool offline = 5;
+  optional bool split = 6;
+  optional int32 replica_id = 7 [default = 0];
+}
+
+/**
+ * Protocol buffer for favored nodes
+ */
+message FavoredNodes {
+  repeated ServerName favored_node = 1;
+}
+
+/**
+ * Container protocol buffer to specify a region.
+ * You can specify region by region name, or the hash
+ * of the region name, which is known as encoded
+ * region name.
+ */
+message RegionSpecifier {
+  required RegionSpecifierType type = 1;
+  required bytes value = 2;
+
+  enum RegionSpecifierType {
+    // <tablename>,<startkey>,<regionId>.<encodedName>
+    REGION_NAME = 1;
+
+    // hash of <tablename>,<startkey>,<regionId>
+    ENCODED_REGION_NAME = 2;
+  }
+}
+
+/**
+ * A range of time. Both from and to are Java time
+ * stamp in milliseconds. If you don't specify a time
+ * range, it means all time.  By default, if not
+ * specified, from = 0, and to = Long.MAX_VALUE
+ */
+message TimeRange {
+  optional uint64 from = 1;
+  optional uint64 to = 2;
+}
+
+/* ColumnFamily Specific TimeRange */
+message ColumnFamilyTimeRange {
+  required bytes column_family = 1;
+  required TimeRange time_range = 2;
+}
+
+/* Comparison operators */
+enum CompareType {
+  LESS = 0;
+  LESS_OR_EQUAL = 1;
+  EQUAL = 2;
+  NOT_EQUAL = 3;
+  GREATER_OR_EQUAL = 4;
+  GREATER = 5;
+  NO_OP = 6;
+}
+
+/**
+ * Protocol buffer version of ServerName
+ */
+message ServerName {
+  required string host_name = 1;
+  optional uint32 port = 2;
+  optional uint64 start_code = 3;
+}
+
+// Comment data structures
+
+message Coprocessor {
+  required string name = 1;
+}
+
+message NameStringPair {
+  required string name = 1;
+  required string value = 2;
+}
+
+message NameBytesPair {
+  required string name = 1;
+  optional bytes value = 2;
+}
+
+message BytesBytesPair {
+  required bytes first = 1;
+  required bytes second = 2;
+}
+
+message NameInt64Pair {
+  optional string name = 1;
+  optional int64 value = 2;
+}
+
+/**
+ * Description of the snapshot to take
+ */
+message SnapshotDescription {
+  required string name = 1;
+  optional string table = 2; // not needed for delete, but checked for in taking snapshot
+  optional int64 creation_time = 3 [default = 0];
+  enum Type {
+    DISABLED = 0;
+    FLUSH = 1;
+    SKIPFLUSH = 2;
+  }
+  optional Type type = 4 [default = FLUSH];
+  optional int32 version = 5;
+  optional string owner = 6;
+}
+
+/**
+ * Description of the distributed procedure to take
+ */
+message ProcedureDescription {
+  required string signature = 1; // the unique signature of the procedure
+  optional string instance = 2; // the procedure instance name
+  optional int64 creation_time = 3 [default = 0];
+  repeated NameStringPair configuration = 4;
+}
+
+message EmptyMsg {
+}
+
+enum TimeUnit {
+  NANOSECONDS = 1;
+  MICROSECONDS = 2;
+  MILLISECONDS = 3;
+  SECONDS = 4;
+  MINUTES = 5;
+  HOURS = 6;
+  DAYS = 7;
+}
+
+message LongMsg {
+  required int64 long_msg = 1;
+}
+
+message DoubleMsg {
+  required double double_msg = 1;
+}
+
+message BigDecimalMsg {
+  required bytes bigdecimal_msg = 1;
+}
+
+message UUID {
+  required uint64 least_sig_bits = 1;
+  required uint64 most_sig_bits = 2;
+}
+
+message NamespaceDescriptor {
+  required bytes name = 1;
+  repeated NameStringPair configuration = 2;
+}
+
+// Rpc client version info proto. Included in ConnectionHeader on connection setup
+message VersionInfo {
+  required string version = 1;
+  required string url = 2;
+  required string revision = 3;
+  required string user = 4;
+  required string date = 5;
+  required string src_checksum = 6;
+  optional uint32 version_major = 7;
+  optional uint32 version_minor = 8;
+}
+
+/**
+ * Description of the region server info
+ */
+message RegionServerInfo {
+  optional int32 infoPort = 1;
+  optional VersionInfo version_info = 2;
+}

vendor/github.com/tsuna/gohbase/pb/Master.proto

@@ -0,0 +1,797 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// All to do with the Master.  Includes schema management since these
+// changes are run by the Master process.
+package pb;
+
+option java_package = "org.apache.hadoop.hbase.protobuf.generated";
+option java_outer_classname = "MasterProtos";
+option java_generic_services = true;
+option java_generate_equals_and_hash = true;
+option optimize_for = SPEED;
+
+import "HBase.proto";
+import "Client.proto";
+import "ClusterStatus.proto";
+import "ErrorHandling.proto";
+import "Procedure.proto";
+import "Quota.proto";
+
+/* Column-level protobufs */
+
+message AddColumnRequest {
+  required TableName table_name = 1;
+  required ColumnFamilySchema column_families = 2;
+  optional uint64 nonce_group = 3 [default = 0];
+  optional uint64 nonce = 4 [default = 0];
+}
+
+message AddColumnResponse {
+}
+
+message DeleteColumnRequest {
+  required TableName table_name = 1;
+  required bytes column_name = 2;
+  optional uint64 nonce_group = 3 [default = 0];
+  optional uint64 nonce = 4 [default = 0];
+}
+
+message DeleteColumnResponse {
+}
+
+message ModifyColumnRequest {
+  required TableName table_name = 1;
+  required ColumnFamilySchema column_families = 2;
+  optional uint64 nonce_group = 3 [default = 0];
+  optional uint64 nonce = 4 [default = 0];
+}
+
+message ModifyColumnResponse {
+}
+
+/* Region-level Protos */
+
+message MoveRegionRequest {
+  required RegionSpecifier region = 1;
+  optional ServerName dest_server_name = 2;
+}
+
+message MoveRegionResponse {
+}
+
+/**
+ * Dispatch merging the specified regions.
+ */
+message DispatchMergingRegionsRequest {
+  required RegionSpecifier region_a = 1;
+  required RegionSpecifier region_b = 2;
+  optional bool forcible = 3 [default = false];
+}
+
+message DispatchMergingRegionsResponse {
+}
+
+message AssignRegionRequest {
+  required RegionSpecifier region = 1;
+}
+
+message AssignRegionResponse {
+}
+
+message UnassignRegionRequest {
+  required RegionSpecifier region = 1;
+  optional bool force = 2 [default = false];
+}
+
+message UnassignRegionResponse {
+}
+
+message OfflineRegionRequest {
+  required RegionSpecifier region = 1;
+}
+
+message OfflineRegionResponse {
+}
+
+/* Table-level protobufs */
+
+message CreateTableRequest {
+  required TableSchema table_schema = 1;
+  repeated bytes split_keys = 2;
+  optional uint64 nonce_group = 3 [default = 0];
+  optional uint64 nonce = 4 [default = 0];
+}
+
+message CreateTableResponse {
+  optional uint64 proc_id = 1;
+}
+
+message DeleteTableRequest {
+  required TableName table_name = 1;
+  optional uint64 nonce_group = 2 [default = 0];
+  optional uint64 nonce = 3 [default = 0];
+}
+
+message DeleteTableResponse {
+  optional uint64 proc_id = 1;
+}
+
+message TruncateTableRequest {
+  required TableName tableName = 1;
+  optional bool preserveSplits = 2 [default = false];
+  optional uint64 nonce_group = 3 [default = 0];
+  optional uint64 nonce = 4 [default = 0];
+}
+
+message TruncateTableResponse {
+}
+
+message EnableTableRequest {
+  required TableName table_name = 1;
+  optional uint64 nonce_group = 2 [default = 0];
+  optional uint64 nonce = 3 [default = 0];
+}
+
+message EnableTableResponse {
+  optional uint64 proc_id = 1;
+}
+
+message DisableTableRequest {
+  required TableName table_name = 1;
+  optional uint64 nonce_group = 2 [default = 0];
+  optional uint64 nonce = 3 [default = 0];
+}
+
+message DisableTableResponse {
+  optional uint64 proc_id = 1;
+}
+
+message ModifyTableRequest {
+  required TableName table_name = 1;
+  required TableSchema table_schema = 2;
+  optional uint64 nonce_group = 3 [default = 0];
+  optional uint64 nonce = 4 [default = 0];
+}
+
+message ModifyTableResponse {
+}
+
+/* Namespace-level protobufs */
+
+message CreateNamespaceRequest {
+  required NamespaceDescriptor namespaceDescriptor = 1;
+  optional uint64 nonce_group = 2 [default = 0];
+  optional uint64 nonce = 3 [default = 0];
+}
+
+message CreateNamespaceResponse {
+}
+
+message DeleteNamespaceRequest {
+  required string namespaceName = 1;
+  optional uint64 nonce_group = 2 [default = 0];
+  optional uint64 nonce = 3 [default = 0];
+}
+
+message DeleteNamespaceResponse {
+}
+
+message ModifyNamespaceRequest {
+  required NamespaceDescriptor namespaceDescriptor = 1;
+  optional uint64 nonce_group = 2 [default = 0];
+  optional uint64 nonce = 3 [default = 0];
+}
+
+message ModifyNamespaceResponse {
+}
+
+message GetNamespaceDescriptorRequest {
+  required string namespaceName = 1;
+}
+
+message GetNamespaceDescriptorResponse {
+  required NamespaceDescriptor namespaceDescriptor = 1;
+}
+
+message ListNamespaceDescriptorsRequest {
+}
+
+message ListNamespaceDescriptorsResponse {
+  repeated NamespaceDescriptor namespaceDescriptor = 1;
+}
+
+message ListTableDescriptorsByNamespaceRequest {
+  required string namespaceName = 1;
+}
+
+message ListTableDescriptorsByNamespaceResponse {
+  repeated TableSchema tableSchema = 1;
+}
+
+message ListTableNamesByNamespaceRequest {
+  required string namespaceName = 1;
+}
+
+message ListTableNamesByNamespaceResponse {
+  repeated TableName tableName = 1;
+}
+
+/* Cluster-level protobufs */
+
+
+message ShutdownRequest {
+}
+
+message ShutdownResponse {
+}
+
+message StopMasterRequest {
+}
+
+message StopMasterResponse {
+}
+
+message BalanceRequest {
+  optional bool force = 1;
+}
+
+message BalanceResponse {
+  required bool balancer_ran = 1;
+}
+
+message SetBalancerRunningRequest {
+  required bool on = 1;
+  optional bool synchronous = 2;
+}
+
+message SetBalancerRunningResponse {
+  optional bool prev_balance_value = 1;
+}
+
+message IsBalancerEnabledRequest {
+}
+
+message IsBalancerEnabledResponse {
+  required bool enabled = 1;
+}
+
+enum MasterSwitchType {
+  SPLIT = 0;
+  MERGE = 1;
+}
+
+message SetSplitOrMergeEnabledRequest {
+  required bool enabled = 1;
+  optional bool synchronous = 2;
+  repeated MasterSwitchType switch_types = 3;
+}
+
+message SetSplitOrMergeEnabledResponse {
+  repeated bool prev_value = 1;
+}
+
+message IsSplitOrMergeEnabledRequest {
+  required MasterSwitchType switch_type = 1;
+}
+
+message IsSplitOrMergeEnabledResponse {
+  required bool enabled = 1;
+}
+
+message NormalizeRequest {
+}
+
+message NormalizeResponse {
+  required bool normalizer_ran = 1;
+}
+
+message SetNormalizerRunningRequest {
+  required bool on = 1;
+}
+
+message SetNormalizerRunningResponse {
+  optional bool prev_normalizer_value = 1;
+}
+
+message IsNormalizerEnabledRequest {
+}
+
+message IsNormalizerEnabledResponse {
+  required bool enabled = 1;
+}
+
+message RunCatalogScanRequest {
+}
+
+message RunCatalogScanResponse {
+  optional int32 scan_result = 1;
+}
+
+message EnableCatalogJanitorRequest {
+  required bool enable = 1;
+}
+
+message EnableCatalogJanitorResponse {
+  optional bool prev_value = 1;
+}
+
+message IsCatalogJanitorEnabledRequest {
+}
+
+message IsCatalogJanitorEnabledResponse {
+  required bool value = 1;
+}
+
+message SnapshotRequest {
+	required SnapshotDescription snapshot = 1;
+}
+
+message SnapshotResponse {
+	required int64 expected_timeout = 1;
+}
+
+message GetCompletedSnapshotsRequest {
+}
+
+message GetCompletedSnapshotsResponse {
+	repeated SnapshotDescription snapshots = 1;
+}
+
+message DeleteSnapshotRequest {
+	required SnapshotDescription snapshot = 1;
+}
+
+message DeleteSnapshotResponse {
+}
+
+message RestoreSnapshotRequest {
+  required SnapshotDescription snapshot = 1;
+}
+
+message RestoreSnapshotResponse {
+}
+
+/* if you don't send the snapshot, then you will get it back
+ * in the response (if the snapshot is done) so you can check the snapshot
+ */
+message IsSnapshotDoneRequest {
+	optional SnapshotDescription snapshot = 1;
+}
+
+message IsSnapshotDoneResponse {
+	optional bool done = 1 [default = false];
+	optional SnapshotDescription snapshot = 2;
+}
+
+message IsRestoreSnapshotDoneRequest {
+  optional SnapshotDescription snapshot = 1;
+}
+
+message IsRestoreSnapshotDoneResponse {
+  optional bool done = 1 [default = false];
+}
+
+message GetSchemaAlterStatusRequest {
+  required TableName table_name = 1;
+}
+
+message GetSchemaAlterStatusResponse {
+  optional uint32 yet_to_update_regions = 1;
+  optional uint32 total_regions = 2;
+}
+
+message GetTableDescriptorsRequest {
+  repeated TableName table_names = 1;
+  optional string regex = 2;
+  optional bool include_sys_tables = 3 [default=false];
+  optional string namespace = 4;
+}
+
+message GetTableDescriptorsResponse {
+  repeated TableSchema table_schema = 1;
+}
+
+message GetTableNamesRequest {
+  optional string regex = 1;
+  optional bool include_sys_tables = 2 [default=false];
+  optional string namespace = 3;
+}
+
+message GetTableNamesResponse {
+  repeated TableName table_names = 1;
+}
+
+message GetClusterStatusRequest {
+}
+
+message GetClusterStatusResponse {
+  required ClusterStatus cluster_status = 1;
+}
+
+message IsMasterRunningRequest {
+}
+
+message IsMasterRunningResponse {
+  required bool is_master_running = 1;
+}
+
+message ExecProcedureRequest {
+  required ProcedureDescription procedure = 1;
+}
+
+message ExecProcedureResponse {
+  optional int64 expected_timeout = 1;
+  optional bytes return_data = 2;
+}
+
+message IsProcedureDoneRequest {
+  optional ProcedureDescription procedure = 1;
+}
+
+message IsProcedureDoneResponse {
+  optional bool done = 1 [default = false];
+  optional ProcedureDescription snapshot = 2;
+}
+
+message GetProcedureResultRequest {
+  required uint64 proc_id = 1;
+}
+
+message GetProcedureResultResponse {
+  enum State {
+    NOT_FOUND = 0;
+    RUNNING = 1;
+    FINISHED = 2;
+  }
+
+  required State state = 1;
+  optional uint64 start_time = 2;
+  optional uint64 last_update = 3;
+  optional bytes result = 4;
+  optional ForeignExceptionMessage exception = 5;
+}
+
+message AbortProcedureRequest {
+  required uint64 proc_id = 1;
+  optional bool mayInterruptIfRunning = 2 [default = true];
+}
+
+message AbortProcedureResponse {
+  required bool is_procedure_aborted = 1;
+}
+
+message ListProceduresRequest {
+}
+
+message ListProceduresResponse {
+  repeated Procedure procedure = 1;
+}
+
+message SetQuotaRequest {
+  optional string user_name = 1;
+  optional string user_group = 2;
+  optional string namespace = 3;
+  optional TableName table_name = 4;
+
+  optional bool remove_all = 5;
+  optional bool bypass_globals = 6;
+  optional ThrottleRequest throttle = 7;
+}
+
+message SetQuotaResponse {
+}
+
+message MajorCompactionTimestampRequest {
+  required TableName table_name = 1;
+}
+
+message MajorCompactionTimestampForRegionRequest {
+  required RegionSpecifier region = 1;
+}
+
+message MajorCompactionTimestampResponse {
+  required int64 compaction_timestamp = 1;
+}
+
+message SecurityCapabilitiesRequest {
+}
+
+message SecurityCapabilitiesResponse {
+  enum Capability {
+    SIMPLE_AUTHENTICATION = 0;
+    SECURE_AUTHENTICATION = 1;
+    AUTHORIZATION = 2;
+    CELL_AUTHORIZATION = 3;
+    CELL_VISIBILITY = 4;
+  }
+
+  repeated Capability capabilities = 1;
+}
+
+service MasterService {
+  /** Used by the client to get the number of regions that have received the updated schema */
+  rpc GetSchemaAlterStatus(GetSchemaAlterStatusRequest)
+    returns(GetSchemaAlterStatusResponse);
+
+  /** Get list of TableDescriptors for requested tables. */
+  rpc GetTableDescriptors(GetTableDescriptorsRequest)
+    returns(GetTableDescriptorsResponse);
+
+  /** Get the list of table names. */
+  rpc GetTableNames(GetTableNamesRequest)
+    returns(GetTableNamesResponse);
+
+  /** Return cluster status. */
+  rpc GetClusterStatus(GetClusterStatusRequest)
+    returns(GetClusterStatusResponse);
+
+  /** return true if master is available */
+  rpc IsMasterRunning(IsMasterRunningRequest) returns(IsMasterRunningResponse);
+
+  /** Adds a column to the specified table. */
+  rpc AddColumn(AddColumnRequest)
+    returns(AddColumnResponse);
+
+  /** Deletes a column from the specified table. Table must be disabled. */
+  rpc DeleteColumn(DeleteColumnRequest)
+    returns(DeleteColumnResponse);
+
+  /** Modifies an existing column on the specified table. */
+  rpc ModifyColumn(ModifyColumnRequest)
+    returns(ModifyColumnResponse);
+
+  /** Move the region region to the destination server. */
+  rpc MoveRegion(MoveRegionRequest)
+    returns(MoveRegionResponse);
+
+ /** Master dispatch merging the regions */
+  rpc DispatchMergingRegions(DispatchMergingRegionsRequest)
+    returns(DispatchMergingRegionsResponse);
+
+  /** Assign a region to a server chosen at random. */
+  rpc AssignRegion(AssignRegionRequest)
+    returns(AssignRegionResponse);
+
+  /**
+   * Unassign a region from current hosting regionserver.  Region will then be
+   * assigned to a regionserver chosen at random.  Region could be reassigned
+   * back to the same server.  Use MoveRegion if you want
+   * to control the region movement.
+   */
+  rpc UnassignRegion(UnassignRegionRequest)
+    returns(UnassignRegionResponse);
+
+  /**
+   * Offline a region from the assignment manager's in-memory state.  The
+   * region should be in a closed state and there will be no attempt to
+   * automatically reassign the region as in unassign.   This is a special
+   * method, and should only be used by experts or hbck.
+   */
+  rpc OfflineRegion(OfflineRegionRequest)
+    returns(OfflineRegionResponse);
+
+  /** Deletes a table */
+  rpc DeleteTable(DeleteTableRequest)
+    returns(DeleteTableResponse);
+
+  /** Truncate a table */
+  rpc truncateTable(TruncateTableRequest)
+    returns(TruncateTableResponse);
+
+  /** Puts the table on-line (only needed if table has been previously taken offline) */
+  rpc EnableTable(EnableTableRequest)
+    returns(EnableTableResponse);
+
+  /** Take table offline */
+  rpc DisableTable(DisableTableRequest)
+    returns(DisableTableResponse);
+
+  /** Modify a table's metadata */
+  rpc ModifyTable(ModifyTableRequest)
+    returns(ModifyTableResponse);
+
+  /** Creates a new table asynchronously */
+  rpc CreateTable(CreateTableRequest)
+    returns(CreateTableResponse);
+
+    /** Shutdown an HBase cluster. */
+  rpc Shutdown(ShutdownRequest)
+    returns(ShutdownResponse);
+
+  /** Stop HBase Master only.  Does not shutdown the cluster. */
+  rpc StopMaster(StopMasterRequest)
+    returns(StopMasterResponse);
+
+  /**
+   * Run the balancer.  Will run the balancer and if regions to move, it will
+   * go ahead and do the reassignments.  Can NOT run for various reasons.
+   * Check logs.
+   */
+  rpc Balance(BalanceRequest)
+    returns(BalanceResponse);
+
+  /**
+   * Turn the load balancer on or off.
+   * If synchronous is true, it waits until current balance() call, if outstanding, to return.
+   */
+  rpc SetBalancerRunning(SetBalancerRunningRequest)
+    returns(SetBalancerRunningResponse);
+
+  /**
+   * Query whether the Region Balancer is running.
+   */
+  rpc IsBalancerEnabled(IsBalancerEnabledRequest)
+    returns(IsBalancerEnabledResponse);
+
+  /**
+   * Turn the split or merge switch on or off.
+   * If synchronous is true, it waits until current operation call, if outstanding, to return.
+   */
+  rpc SetSplitOrMergeEnabled(SetSplitOrMergeEnabledRequest)
+    returns(SetSplitOrMergeEnabledResponse);
+
+  /**
+   * Query whether the split or merge switch is on/off.
+   */
+  rpc IsSplitOrMergeEnabled(IsSplitOrMergeEnabledRequest)
+    returns(IsSplitOrMergeEnabledResponse);
+
+  /**
+   * Run region normalizer. Can NOT run for various reasons. Check logs.
+   */
+  rpc Normalize(NormalizeRequest)
+  returns(NormalizeResponse);
+
+  /**
+   * Turn region normalizer on or off.
+   */
+  rpc SetNormalizerRunning(SetNormalizerRunningRequest)
+  returns(SetNormalizerRunningResponse);
+
+  /**
+   * Query whether region normalizer is enabled.
+   */
+  rpc IsNormalizerEnabled(IsNormalizerEnabledRequest)
+  returns(IsNormalizerEnabledResponse);
+
+  /** Get a run of the catalog janitor */
+  rpc RunCatalogScan(RunCatalogScanRequest)
+     returns(RunCatalogScanResponse);
+
+  /**
+   * Enable the catalog janitor on or off.
+   */
+  rpc EnableCatalogJanitor(EnableCatalogJanitorRequest)
+     returns(EnableCatalogJanitorResponse);
+
+  /**
+   * Query whether the catalog janitor is enabled.
+   */
+  rpc IsCatalogJanitorEnabled(IsCatalogJanitorEnabledRequest)
+     returns(IsCatalogJanitorEnabledResponse);
+
+  /**
+   * Call a master coprocessor endpoint
+   */
+  rpc ExecMasterService(CoprocessorServiceRequest)
+    returns(CoprocessorServiceResponse);
+
+  /**
+   * Create a snapshot for the given table.
+   */
+  rpc Snapshot(SnapshotRequest) returns(SnapshotResponse);
+
+  /**
+   * Get completed snapshots.
+   * Returns a list of snapshot descriptors for completed snapshots
+   */
+  rpc GetCompletedSnapshots(GetCompletedSnapshotsRequest) returns(GetCompletedSnapshotsResponse);
+
+  /**
+   * Delete an existing snapshot. This method can also be used to clean up an aborted snapshot.
+   */
+  rpc DeleteSnapshot(DeleteSnapshotRequest) returns(DeleteSnapshotResponse);
+
+  /**
+   * Determine if the snapshot is done yet.
+   */
+  rpc IsSnapshotDone(IsSnapshotDoneRequest) returns(IsSnapshotDoneResponse);
+
+  /**
+   * Restore a snapshot
+   */
+  rpc RestoreSnapshot(RestoreSnapshotRequest) returns(RestoreSnapshotResponse);
+
+  /**
+   * Determine if the snapshot restore is done yet.
+   */
+  rpc IsRestoreSnapshotDone(IsRestoreSnapshotDoneRequest) returns(IsRestoreSnapshotDoneResponse);
+
+  /**
+   * Execute a distributed procedure.
+   */
+  rpc ExecProcedure(ExecProcedureRequest) returns(ExecProcedureResponse);
+
+  /**
+   * Execute a distributed procedure with return data.
+   */
+  rpc ExecProcedureWithRet(ExecProcedureRequest) returns(ExecProcedureResponse);
+
+  /**
+   * Determine if the procedure is done yet.
+   */
+  rpc IsProcedureDone(IsProcedureDoneRequest) returns(IsProcedureDoneResponse);
+
+  /** return true if master is available */
+  /** rpc IsMasterRunning(IsMasterRunningRequest) returns(IsMasterRunningResponse); */
+
+  /** Modify a namespace's metadata */
+  rpc ModifyNamespace(ModifyNamespaceRequest)
+    returns(ModifyNamespaceResponse);
+
+  /** Creates a new namespace synchronously */
+  rpc CreateNamespace(CreateNamespaceRequest)
+    returns(CreateNamespaceResponse);
+
+  /** Deletes namespace synchronously */
+  rpc DeleteNamespace(DeleteNamespaceRequest)
+    returns(DeleteNamespaceResponse);
+
+  /** Get a namespace descriptor by name */
+  rpc GetNamespaceDescriptor(GetNamespaceDescriptorRequest)
+    returns(GetNamespaceDescriptorResponse);
+
+  /** returns a list of namespaces */
+  rpc ListNamespaceDescriptors(ListNamespaceDescriptorsRequest)
+    returns(ListNamespaceDescriptorsResponse);
+
+  /** returns a list of tables for a given namespace*/
+  rpc ListTableDescriptorsByNamespace(ListTableDescriptorsByNamespaceRequest)
+    returns(ListTableDescriptorsByNamespaceResponse);
+
+  /** returns a list of tables for a given namespace*/
+  rpc ListTableNamesByNamespace(ListTableNamesByNamespaceRequest)
+    returns(ListTableNamesByNamespaceResponse);
+
+  /** Apply the new quota settings */
+  rpc SetQuota(SetQuotaRequest) returns(SetQuotaResponse);
+
+  /** Returns the timestamp of the last major compaction */
+  rpc getLastMajorCompactionTimestamp(MajorCompactionTimestampRequest)
+    returns(MajorCompactionTimestampResponse);
+
+  /** Returns the timestamp of the last major compaction */
+  rpc getLastMajorCompactionTimestampForRegion(MajorCompactionTimestampForRegionRequest)
+    returns(MajorCompactionTimestampResponse);
+
+  rpc getProcedureResult(GetProcedureResultRequest)
+    returns(GetProcedureResultResponse);
+
+  /** Returns the security capabilities in effect on the cluster */
+  rpc getSecurityCapabilities(SecurityCapabilitiesRequest)
+    returns(SecurityCapabilitiesResponse);
+
+  /** Abort a procedure */
+  rpc AbortProcedure(AbortProcedureRequest)
+    returns(AbortProcedureResponse);
+
+  /** returns a list of procedures */
+  rpc ListProcedures(ListProceduresRequest)
+    returns(ListProceduresResponse);
+}

vendor/github.com/tsuna/gohbase/pb/MultiRowMutation.pb.go

@@ -0,0 +1,107 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: MultiRowMutation.proto
+
+package pb
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+type MultiRowMutationProcessorRequest struct {
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *MultiRowMutationProcessorRequest) Reset()         { *m = MultiRowMutationProcessorRequest{} }
+func (m *MultiRowMutationProcessorRequest) String() string { return proto.CompactTextString(m) }
+func (*MultiRowMutationProcessorRequest) ProtoMessage()    {}
+func (*MultiRowMutationProcessorRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor12, []int{0}
+}
+
+type MultiRowMutationProcessorResponse struct {
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *MultiRowMutationProcessorResponse) Reset()         { *m = MultiRowMutationProcessorResponse{} }
+func (m *MultiRowMutationProcessorResponse) String() string { return proto.CompactTextString(m) }
+func (*MultiRowMutationProcessorResponse) ProtoMessage()    {}
+func (*MultiRowMutationProcessorResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor12, []int{1}
+}
+
+type MutateRowsRequest struct {
+	MutationRequest  []*MutationProto `protobuf:"bytes,1,rep,name=mutation_request,json=mutationRequest" json:"mutation_request,omitempty"`
+	NonceGroup       *uint64          `protobuf:"varint,2,opt,name=nonce_group,json=nonceGroup" json:"nonce_group,omitempty"`
+	Nonce            *uint64          `protobuf:"varint,3,opt,name=nonce" json:"nonce,omitempty"`
+	XXX_unrecognized []byte           `json:"-"`
+}
+
+func (m *MutateRowsRequest) Reset()                    { *m = MutateRowsRequest{} }
+func (m *MutateRowsRequest) String() string            { return proto.CompactTextString(m) }
+func (*MutateRowsRequest) ProtoMessage()               {}
+func (*MutateRowsRequest) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{2} }
+
+func (m *MutateRowsRequest) GetMutationRequest() []*MutationProto {
+	if m != nil {
+		return m.MutationRequest
+	}
+	return nil
+}
+
+func (m *MutateRowsRequest) GetNonceGroup() uint64 {
+	if m != nil && m.NonceGroup != nil {
+		return *m.NonceGroup
+	}
+	return 0
+}
+
+func (m *MutateRowsRequest) GetNonce() uint64 {
+	if m != nil && m.Nonce != nil {
+		return *m.Nonce
+	}
+	return 0
+}
+
+type MutateRowsResponse struct {
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *MutateRowsResponse) Reset()                    { *m = MutateRowsResponse{} }
+func (m *MutateRowsResponse) String() string            { return proto.CompactTextString(m) }
+func (*MutateRowsResponse) ProtoMessage()               {}
+func (*MutateRowsResponse) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{3} }
+
+func init() {
+	proto.RegisterType((*MultiRowMutationProcessorRequest)(nil), "pb.MultiRowMutationProcessorRequest")
+	proto.RegisterType((*MultiRowMutationProcessorResponse)(nil), "pb.MultiRowMutationProcessorResponse")
+	proto.RegisterType((*MutateRowsRequest)(nil), "pb.MutateRowsRequest")
+	proto.RegisterType((*MutateRowsResponse)(nil), "pb.MutateRowsResponse")
+}
+
+func init() { proto.RegisterFile("MultiRowMutation.proto", fileDescriptor12) }
+
+var fileDescriptor12 = []byte{
+	// 271 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x90, 0xbf, 0x4e, 0xf3, 0x40,
+	0x10, 0xc4, 0x75, 0xc9, 0xf7, 0x35, 0x1b, 0x24, 0xc8, 0x29, 0x18, 0x2b, 0x0d, 0xc6, 0x34, 0x11,
+	0xc5, 0x15, 0x69, 0xa1, 0x0a, 0x05, 0x14, 0x44, 0x42, 0x87, 0x44, 0x1b, 0x9d, 0x9d, 0xc5, 0xb6,
+	0x14, 0x6e, 0x8f, 0xfb, 0x43, 0x5e, 0x21, 0x8f, 0xc1, 0xa3, 0x22, 0x7c, 0x09, 0x58, 0x16, 0xa2,
+	0xdc, 0xdf, 0xce, 0xac, 0x66, 0x07, 0x92, 0x65, 0xd8, 0xf8, 0x46, 0xd2, 0x76, 0x19, 0xbc, 0xf2,
+	0x0d, 0x69, 0x61, 0x2c, 0x79, 0xe2, 0x03, 0x53, 0x4c, 0x8f, 0x6e, 0x37, 0x0d, 0x6a, 0x1f, 0x49,
+	0x9e, 0x43, 0xd6, 0xd7, 0x3e, 0x5a, 0x2a, 0xd1, 0x39, 0xb2, 0x12, 0xdf, 0x02, 0x3a, 0x9f, 0x5f,
+	0xc2, 0xc5, 0x1f, 0x1a, 0x67, 0x48, 0x3b, 0xcc, 0x77, 0x0c, 0xc6, 0xed, 0x16, 0x25, 0x6d, 0xdd,
+	0xde, 0xca, 0x6f, 0xe0, 0xe4, 0x75, 0x6f, 0x59, 0xd9, 0xc8, 0x52, 0x96, 0x0d, 0x67, 0xa3, 0xf9,
+	0x58, 0x98, 0x42, 0x74, 0xce, 0x79, 0x92, 0xc7, 0x07, 0xe9, 0xc1, 0x7d, 0x0e, 0x23, 0x4d, 0xba,
+	0xc4, 0x55, 0x65, 0x29, 0x98, 0x74, 0x90, 0xb1, 0xd9, 0x3f, 0x09, 0x2d, 0xba, 0xfb, 0x22, 0x7c,
+	0x02, 0xff, 0xdb, 0x29, 0x1d, 0xb6, 0xab, 0x38, 0xe4, 0x13, 0xe0, 0xdd, 0x24, 0x31, 0xe0, 0xfc,
+	0x19, 0xce, 0xfa, 0x5f, 0x3c, 0xa1, 0x7d, 0x6f, 0x4a, 0xe4, 0xd7, 0x00, 0x3f, 0x06, 0x7e, 0xfa,
+	0x9d, 0xac, 0xfb, 0xca, 0x34, 0xe9, 0xe3, 0x78, 0x77, 0xf1, 0x00, 0x57, 0x64, 0x2b, 0xa1, 0x8c,
+	0x2a, 0x6b, 0x14, 0xb5, 0x5a, 0x13, 0x19, 0x51, 0x17, 0xca, 0x61, 0xac, 0xb8, 0x08, 0x2f, 0xa2,
+	0x42, 0x8d, 0x56, 0x79, 0x5c, 0x2f, 0x92, 0x5f, 0x9a, 0xf4, 0xe4, 0xee, 0xd9, 0x8e, 0xb1, 0x0f,
+	0xc6, 0x3e, 0x03, 0x00, 0x00, 0xff, 0xff, 0x1d, 0xcf, 0x5a, 0xf8, 0xba, 0x01, 0x00, 0x00,
+}

vendor/github.com/tsuna/gohbase/pb/MultiRowMutation.proto

@@ -0,0 +1,45 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package pb;
+
+import "Client.proto";
+option java_package = "org.apache.hadoop.hbase.protobuf.generated";
+option java_outer_classname = "MultiRowMutationProtos";
+option java_generate_equals_and_hash = true;
+option java_generic_services = true;
+option optimize_for = SPEED;
+
+message MultiRowMutationProcessorRequest{
+}
+
+message MultiRowMutationProcessorResponse{
+}
+
+message MutateRowsRequest {
+  repeated MutationProto mutation_request = 1;
+  optional uint64 nonce_group = 2;
+  optional uint64 nonce = 3;
+}
+
+message MutateRowsResponse {
+}
+
+service MultiRowMutationService {
+  rpc MutateRows(MutateRowsRequest)
+      returns(MutateRowsResponse);
+}

vendor/github.com/tsuna/gohbase/pb/Procedure.pb.go

@@ -0,0 +1,500 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: Procedure.proto
+
+package pb
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+type ProcedureState int32
+
+const (
+	ProcedureState_INITIALIZING    ProcedureState = 1
+	ProcedureState_RUNNABLE        ProcedureState = 2
+	ProcedureState_WAITING         ProcedureState = 3
+	ProcedureState_WAITING_TIMEOUT ProcedureState = 4
+	ProcedureState_ROLLEDBACK      ProcedureState = 5
+	ProcedureState_FINISHED        ProcedureState = 6
+)
+
+var ProcedureState_name = map[int32]string{
+	1: "INITIALIZING",
+	2: "RUNNABLE",
+	3: "WAITING",
+	4: "WAITING_TIMEOUT",
+	5: "ROLLEDBACK",
+	6: "FINISHED",
+}
+var ProcedureState_value = map[string]int32{
+	"INITIALIZING":    1,
+	"RUNNABLE":        2,
+	"WAITING":         3,
+	"WAITING_TIMEOUT": 4,
+	"ROLLEDBACK":      5,
+	"FINISHED":        6,
+}
+
+func (x ProcedureState) Enum() *ProcedureState {
+	p := new(ProcedureState)
+	*p = x
+	return p
+}
+func (x ProcedureState) String() string {
+	return proto.EnumName(ProcedureState_name, int32(x))
+}
+func (x *ProcedureState) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(ProcedureState_value, data, "ProcedureState")
+	if err != nil {
+		return err
+	}
+	*x = ProcedureState(value)
+	return nil
+}
+func (ProcedureState) EnumDescriptor() ([]byte, []int) { return fileDescriptor13, []int{0} }
+
+type ProcedureWALEntry_Type int32
+
+const (
+	ProcedureWALEntry_PROCEDURE_WAL_EOF     ProcedureWALEntry_Type = 1
+	ProcedureWALEntry_PROCEDURE_WAL_INIT    ProcedureWALEntry_Type = 2
+	ProcedureWALEntry_PROCEDURE_WAL_INSERT  ProcedureWALEntry_Type = 3
+	ProcedureWALEntry_PROCEDURE_WAL_UPDATE  ProcedureWALEntry_Type = 4
+	ProcedureWALEntry_PROCEDURE_WAL_DELETE  ProcedureWALEntry_Type = 5
+	ProcedureWALEntry_PROCEDURE_WAL_COMPACT ProcedureWALEntry_Type = 6
+)
+
+var ProcedureWALEntry_Type_name = map[int32]string{
+	1: "PROCEDURE_WAL_EOF",
+	2: "PROCEDURE_WAL_INIT",
+	3: "PROCEDURE_WAL_INSERT",
+	4: "PROCEDURE_WAL_UPDATE",
+	5: "PROCEDURE_WAL_DELETE",
+	6: "PROCEDURE_WAL_COMPACT",
+}
+var ProcedureWALEntry_Type_value = map[string]int32{
+	"PROCEDURE_WAL_EOF":     1,
+	"PROCEDURE_WAL_INIT":    2,
+	"PROCEDURE_WAL_INSERT":  3,
+	"PROCEDURE_WAL_UPDATE":  4,
+	"PROCEDURE_WAL_DELETE":  5,
+	"PROCEDURE_WAL_COMPACT": 6,
+}
+
+func (x ProcedureWALEntry_Type) Enum() *ProcedureWALEntry_Type {
+	p := new(ProcedureWALEntry_Type)
+	*p = x
+	return p
+}
+func (x ProcedureWALEntry_Type) String() string {
+	return proto.EnumName(ProcedureWALEntry_Type_name, int32(x))
+}
+func (x *ProcedureWALEntry_Type) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(ProcedureWALEntry_Type_value, data, "ProcedureWALEntry_Type")
+	if err != nil {
+		return err
+	}
+	*x = ProcedureWALEntry_Type(value)
+	return nil
+}
+func (ProcedureWALEntry_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptor13, []int{6, 0} }
+
+// *
+// Procedure metadata, serialized by the ProcedureStore to be able to recover the old state.
+type Procedure struct {
+	// internal "static" state
+	ClassName *string `protobuf:"bytes,1,req,name=class_name,json=className" json:"class_name,omitempty"`
+	ParentId  *uint64 `protobuf:"varint,2,opt,name=parent_id,json=parentId" json:"parent_id,omitempty"`
+	ProcId    *uint64 `protobuf:"varint,3,req,name=proc_id,json=procId" json:"proc_id,omitempty"`
+	StartTime *uint64 `protobuf:"varint,4,req,name=start_time,json=startTime" json:"start_time,omitempty"`
+	Owner     *string `protobuf:"bytes,5,opt,name=owner" json:"owner,omitempty"`
+	// internal "runtime" state
+	State      *ProcedureState `protobuf:"varint,6,req,name=state,enum=pb.ProcedureState" json:"state,omitempty"`
+	StackId    []uint32        `protobuf:"varint,7,rep,name=stack_id,json=stackId" json:"stack_id,omitempty"`
+	LastUpdate *uint64         `protobuf:"varint,8,req,name=last_update,json=lastUpdate" json:"last_update,omitempty"`
+	Timeout    *uint32         `protobuf:"varint,9,opt,name=timeout" json:"timeout,omitempty"`
+	// user state/results
+	Exception *ForeignExceptionMessage `protobuf:"bytes,10,opt,name=exception" json:"exception,omitempty"`
+	Result    []byte                   `protobuf:"bytes,11,opt,name=result" json:"result,omitempty"`
+	StateData []byte                   `protobuf:"bytes,12,opt,name=state_data,json=stateData" json:"state_data,omitempty"`
+	// Nonce to prevent same procedure submit by multiple times
+	NonceGroup       *uint64 `protobuf:"varint,13,opt,name=nonce_group,json=nonceGroup,def=0" json:"nonce_group,omitempty"`
+	Nonce            *uint64 `protobuf:"varint,14,opt,name=nonce,def=0" json:"nonce,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *Procedure) Reset()                    { *m = Procedure{} }
+func (m *Procedure) String() string            { return proto.CompactTextString(m) }
+func (*Procedure) ProtoMessage()               {}
+func (*Procedure) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{0} }
+
+const Default_Procedure_NonceGroup uint64 = 0
+const Default_Procedure_Nonce uint64 = 0
+
+func (m *Procedure) GetClassName() string {
+	if m != nil && m.ClassName != nil {
+		return *m.ClassName
+	}
+	return ""
+}
+
+func (m *Procedure) GetParentId() uint64 {
+	if m != nil && m.ParentId != nil {
+		return *m.ParentId
+	}
+	return 0
+}
+
+func (m *Procedure) GetProcId() uint64 {
+	if m != nil && m.ProcId != nil {
+		return *m.ProcId
+	}
+	return 0
+}
+
+func (m *Procedure) GetStartTime() uint64 {
+	if m != nil && m.StartTime != nil {
+		return *m.StartTime
+	}
+	return 0
+}
+
+func (m *Procedure) GetOwner() string {
+	if m != nil && m.Owner != nil {
+		return *m.Owner
+	}
+	return ""
+}
+
+func (m *Procedure) GetState() ProcedureState {
+	if m != nil && m.State != nil {
+		return *m.State
+	}
+	return ProcedureState_INITIALIZING
+}
+
+func (m *Procedure) GetStackId() []uint32 {
+	if m != nil {
+		return m.StackId
+	}
+	return nil
+}
+
+func (m *Procedure) GetLastUpdate() uint64 {
+	if m != nil && m.LastUpdate != nil {
+		return *m.LastUpdate
+	}
+	return 0
+}
+
+func (m *Procedure) GetTimeout() uint32 {
+	if m != nil && m.Timeout != nil {
+		return *m.Timeout
+	}
+	return 0
+}
+
+func (m *Procedure) GetException() *ForeignExceptionMessage {
+	if m != nil {
+		return m.Exception
+	}
+	return nil
+}
+
+func (m *Procedure) GetResult() []byte {
+	if m != nil {
+		return m.Result
+	}
+	return nil
+}
+
+func (m *Procedure) GetStateData() []byte {
+	if m != nil {
+		return m.StateData
+	}
+	return nil
+}
+
+func (m *Procedure) GetNonceGroup() uint64 {
+	if m != nil && m.NonceGroup != nil {
+		return *m.NonceGroup
+	}
+	return Default_Procedure_NonceGroup
+}
+
+func (m *Procedure) GetNonce() uint64 {
+	if m != nil && m.Nonce != nil {
+		return *m.Nonce
+	}
+	return Default_Procedure_Nonce
+}
+
+// *
+// SequentialProcedure data
+type SequentialProcedureData struct {
+	Executed         *bool  `protobuf:"varint,1,req,name=executed" json:"executed,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *SequentialProcedureData) Reset()                    { *m = SequentialProcedureData{} }
+func (m *SequentialProcedureData) String() string            { return proto.CompactTextString(m) }
+func (*SequentialProcedureData) ProtoMessage()               {}
+func (*SequentialProcedureData) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{1} }
+
+func (m *SequentialProcedureData) GetExecuted() bool {
+	if m != nil && m.Executed != nil {
+		return *m.Executed
+	}
+	return false
+}
+
+// *
+// StateMachineProcedure data
+type StateMachineProcedureData struct {
+	State            []uint32 `protobuf:"varint,1,rep,name=state" json:"state,omitempty"`
+	XXX_unrecognized []byte   `json:"-"`
+}
+
+func (m *StateMachineProcedureData) Reset()                    { *m = StateMachineProcedureData{} }
+func (m *StateMachineProcedureData) String() string            { return proto.CompactTextString(m) }
+func (*StateMachineProcedureData) ProtoMessage()               {}
+func (*StateMachineProcedureData) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{2} }
+
+func (m *StateMachineProcedureData) GetState() []uint32 {
+	if m != nil {
+		return m.State
+	}
+	return nil
+}
+
+// *
+// Procedure WAL header
+type ProcedureWALHeader struct {
+	Version          *uint32 `protobuf:"varint,1,req,name=version" json:"version,omitempty"`
+	Type             *uint32 `protobuf:"varint,2,req,name=type" json:"type,omitempty"`
+	LogId            *uint64 `protobuf:"varint,3,req,name=log_id,json=logId" json:"log_id,omitempty"`
+	MinProcId        *uint64 `protobuf:"varint,4,req,name=min_proc_id,json=minProcId" json:"min_proc_id,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *ProcedureWALHeader) Reset()                    { *m = ProcedureWALHeader{} }
+func (m *ProcedureWALHeader) String() string            { return proto.CompactTextString(m) }
+func (*ProcedureWALHeader) ProtoMessage()               {}
+func (*ProcedureWALHeader) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{3} }
+
+func (m *ProcedureWALHeader) GetVersion() uint32 {
+	if m != nil && m.Version != nil {
+		return *m.Version
+	}
+	return 0
+}
+
+func (m *ProcedureWALHeader) GetType() uint32 {
+	if m != nil && m.Type != nil {
+		return *m.Type
+	}
+	return 0
+}
+
+func (m *ProcedureWALHeader) GetLogId() uint64 {
+	if m != nil && m.LogId != nil {
+		return *m.LogId
+	}
+	return 0
+}
+
+func (m *ProcedureWALHeader) GetMinProcId() uint64 {
+	if m != nil && m.MinProcId != nil {
+		return *m.MinProcId
+	}
+	return 0
+}
+
+// *
+// Procedure WAL trailer
+type ProcedureWALTrailer struct {
+	Version          *uint32 `protobuf:"varint,1,req,name=version" json:"version,omitempty"`
+	TrackerPos       *uint64 `protobuf:"varint,2,req,name=tracker_pos,json=trackerPos" json:"tracker_pos,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *ProcedureWALTrailer) Reset()                    { *m = ProcedureWALTrailer{} }
+func (m *ProcedureWALTrailer) String() string            { return proto.CompactTextString(m) }
+func (*ProcedureWALTrailer) ProtoMessage()               {}
+func (*ProcedureWALTrailer) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{4} }
+
+func (m *ProcedureWALTrailer) GetVersion() uint32 {
+	if m != nil && m.Version != nil {
+		return *m.Version
+	}
+	return 0
+}
+
+func (m *ProcedureWALTrailer) GetTrackerPos() uint64 {
+	if m != nil && m.TrackerPos != nil {
+		return *m.TrackerPos
+	}
+	return 0
+}
+
+type ProcedureStoreTracker struct {
+	Node             []*ProcedureStoreTracker_TrackerNode `protobuf:"bytes,1,rep,name=node" json:"node,omitempty"`
+	XXX_unrecognized []byte                               `json:"-"`
+}
+
+func (m *ProcedureStoreTracker) Reset()                    { *m = ProcedureStoreTracker{} }
+func (m *ProcedureStoreTracker) String() string            { return proto.CompactTextString(m) }
+func (*ProcedureStoreTracker) ProtoMessage()               {}
+func (*ProcedureStoreTracker) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{5} }
+
+func (m *ProcedureStoreTracker) GetNode() []*ProcedureStoreTracker_TrackerNode {
+	if m != nil {
+		return m.Node
+	}
+	return nil
+}
+
+type ProcedureStoreTracker_TrackerNode struct {
+	StartId          *uint64  `protobuf:"varint,1,req,name=start_id,json=startId" json:"start_id,omitempty"`
+	Updated          []uint64 `protobuf:"varint,2,rep,name=updated" json:"updated,omitempty"`
+	Deleted          []uint64 `protobuf:"varint,3,rep,name=deleted" json:"deleted,omitempty"`
+	XXX_unrecognized []byte   `json:"-"`
+}
+
+func (m *ProcedureStoreTracker_TrackerNode) Reset()         { *m = ProcedureStoreTracker_TrackerNode{} }
+func (m *ProcedureStoreTracker_TrackerNode) String() string { return proto.CompactTextString(m) }
+func (*ProcedureStoreTracker_TrackerNode) ProtoMessage()    {}
+func (*ProcedureStoreTracker_TrackerNode) Descriptor() ([]byte, []int) {
+	return fileDescriptor13, []int{5, 0}
+}
+
+func (m *ProcedureStoreTracker_TrackerNode) GetStartId() uint64 {
+	if m != nil && m.StartId != nil {
+		return *m.StartId
+	}
+	return 0
+}
+
+func (m *ProcedureStoreTracker_TrackerNode) GetUpdated() []uint64 {
+	if m != nil {
+		return m.Updated
+	}
+	return nil
+}
+
+func (m *ProcedureStoreTracker_TrackerNode) GetDeleted() []uint64 {
+	if m != nil {
+		return m.Deleted
+	}
+	return nil
+}
+
+type ProcedureWALEntry struct {
+	Type             *ProcedureWALEntry_Type `protobuf:"varint,1,req,name=type,enum=pb.ProcedureWALEntry_Type" json:"type,omitempty"`
+	Procedure        []*Procedure            `protobuf:"bytes,2,rep,name=procedure" json:"procedure,omitempty"`
+	ProcId           *uint64                 `protobuf:"varint,3,opt,name=proc_id,json=procId" json:"proc_id,omitempty"`
+	XXX_unrecognized []byte                  `json:"-"`
+}
+
+func (m *ProcedureWALEntry) Reset()                    { *m = ProcedureWALEntry{} }
+func (m *ProcedureWALEntry) String() string            { return proto.CompactTextString(m) }
+func (*ProcedureWALEntry) ProtoMessage()               {}
+func (*ProcedureWALEntry) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{6} }
+
+func (m *ProcedureWALEntry) GetType() ProcedureWALEntry_Type {
+	if m != nil && m.Type != nil {
+		return *m.Type
+	}
+	return ProcedureWALEntry_PROCEDURE_WAL_EOF
+}
+
+func (m *ProcedureWALEntry) GetProcedure() []*Procedure {
+	if m != nil {
+		return m.Procedure
+	}
+	return nil
+}
+
+func (m *ProcedureWALEntry) GetProcId() uint64 {
+	if m != nil && m.ProcId != nil {
+		return *m.ProcId
+	}
+	return 0
+}
+
+func init() {
+	proto.RegisterType((*Procedure)(nil), "pb.Procedure")
+	proto.RegisterType((*SequentialProcedureData)(nil), "pb.SequentialProcedureData")
+	proto.RegisterType((*StateMachineProcedureData)(nil), "pb.StateMachineProcedureData")
+	proto.RegisterType((*ProcedureWALHeader)(nil), "pb.ProcedureWALHeader")
+	proto.RegisterType((*ProcedureWALTrailer)(nil), "pb.ProcedureWALTrailer")
+	proto.RegisterType((*ProcedureStoreTracker)(nil), "pb.ProcedureStoreTracker")
+	proto.RegisterType((*ProcedureStoreTracker_TrackerNode)(nil), "pb.ProcedureStoreTracker.TrackerNode")
+	proto.RegisterType((*ProcedureWALEntry)(nil), "pb.ProcedureWALEntry")
+	proto.RegisterEnum("pb.ProcedureState", ProcedureState_name, ProcedureState_value)
+	proto.RegisterEnum("pb.ProcedureWALEntry_Type", ProcedureWALEntry_Type_name, ProcedureWALEntry_Type_value)
+}
+
+func init() { proto.RegisterFile("Procedure.proto", fileDescriptor13) }
+
+var fileDescriptor13 = []byte{
+	// 834 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x94, 0xdf, 0x6a, 0xe3, 0x46,
+	0x14, 0xc6, 0x19, 0xff, 0xd7, 0x51, 0x92, 0xd5, 0x4e, 0x92, 0x8d, 0x92, 0xa5, 0x5d, 0x63, 0x28,
+	0x98, 0x2d, 0x88, 0x36, 0xd0, 0x8b, 0xed, 0x9d, 0x13, 0x2b, 0x1b, 0x51, 0xc7, 0x31, 0x13, 0x99,
+	0x40, 0x29, 0x88, 0x89, 0x74, 0xea, 0x88, 0x95, 0x35, 0xea, 0x68, 0xdc, 0x6e, 0xde, 0xa0, 0x4f,
+	0x51, 0x7a, 0xdd, 0xab, 0x3e, 0x44, 0x1f, 0xac, 0xcc, 0x48, 0xb6, 0xe3, 0x5d, 0xd8, 0x2b, 0xfb,
+	0xfb, 0x7e, 0x67, 0xe6, 0x1c, 0x9d, 0x39, 0x33, 0xf0, 0x62, 0x26, 0x45, 0x8c, 0xc9, 0x4a, 0xa2,
+	0x57, 0x48, 0xa1, 0x04, 0x6d, 0x14, 0x0f, 0x67, 0x87, 0xbe, 0x94, 0x42, 0x5e, 0xf3, 0x3c, 0xc9,
+	0xd2, 0x7c, 0x51, 0x81, 0xc1, 0x7f, 0x4d, 0xb0, 0x36, 0xc1, 0xf4, 0x2b, 0x80, 0x38, 0xe3, 0x65,
+	0x19, 0xe5, 0x7c, 0x89, 0x2e, 0xe9, 0x37, 0x86, 0x16, 0xb3, 0x8c, 0x33, 0xe5, 0x4b, 0xa4, 0xaf,
+	0xc1, 0x2a, 0xb8, 0xc4, 0x5c, 0x45, 0x69, 0xe2, 0x36, 0xfa, 0x64, 0xd8, 0x62, 0xbd, 0xca, 0x08,
+	0x12, 0x7a, 0x02, 0xdd, 0x42, 0x8a, 0x58, 0xa3, 0x66, 0xbf, 0x31, 0x6c, 0xb1, 0x8e, 0x96, 0x41,
+	0xa2, 0x37, 0x2d, 0x15, 0x97, 0x2a, 0x52, 0xe9, 0x12, 0xdd, 0x96, 0x61, 0x96, 0x71, 0xc2, 0x74,
+	0x89, 0xf4, 0x08, 0xda, 0xe2, 0x8f, 0x1c, 0xa5, 0xdb, 0xee, 0x93, 0xa1, 0xc5, 0x2a, 0x41, 0x87,
+	0xd0, 0x2e, 0x15, 0x57, 0xe8, 0x76, 0xfa, 0x8d, 0xe1, 0xc1, 0x39, 0xf5, 0x8a, 0x07, 0x6f, 0x53,
+	0xe7, 0x9d, 0x26, 0xac, 0x0a, 0xa0, 0xa7, 0xd0, 0x2b, 0x15, 0x8f, 0x3f, 0xe8, 0xc4, 0xdd, 0x7e,
+	0x73, 0xb8, 0xcf, 0xba, 0x46, 0x07, 0x09, 0x7d, 0x03, 0x76, 0xc6, 0x4b, 0x15, 0xad, 0x8a, 0x44,
+	0x6f, 0xd5, 0x33, 0xa9, 0x41, 0x5b, 0x73, 0xe3, 0x50, 0x17, 0xba, 0xba, 0x28, 0xb1, 0x52, 0xae,
+	0xd5, 0x27, 0x7a, 0x69, 0x2d, 0xe9, 0x3b, 0xb0, 0xf0, 0x63, 0x8c, 0x85, 0x4a, 0x45, 0xee, 0x42,
+	0x9f, 0x0c, 0xed, 0xf3, 0xd7, 0xba, 0x86, 0x2b, 0x21, 0x31, 0x5d, 0xe4, 0xfe, 0x9a, 0xdd, 0x60,
+	0x59, 0xf2, 0x05, 0xb2, 0x6d, 0x34, 0x7d, 0x05, 0x1d, 0x89, 0xe5, 0x2a, 0x53, 0xae, 0xdd, 0x27,
+	0xc3, 0x3d, 0x56, 0xab, 0xba, 0x0f, 0x0a, 0xa3, 0x84, 0x2b, 0xee, 0xee, 0x19, 0x66, 0x19, 0x67,
+	0xcc, 0x15, 0xa7, 0x03, 0xb0, 0x73, 0x91, 0xc7, 0x18, 0x2d, 0xa4, 0x58, 0x15, 0xee, 0xbe, 0x6e,
+	0xef, 0x8f, 0xe4, 0x3b, 0x06, 0xc6, 0x7d, 0xaf, 0x4d, 0x7a, 0x02, 0x6d, 0xa3, 0xdc, 0x83, 0x35,
+	0xad, 0xf4, 0xe0, 0x07, 0x38, 0xb9, 0xc3, 0xdf, 0x56, 0x98, 0xab, 0x94, 0x67, 0x9b, 0x3e, 0x99,
+	0x7d, 0xcf, 0xa0, 0x87, 0x1f, 0x31, 0x5e, 0x29, 0x4c, 0xcc, 0x89, 0xf6, 0xd8, 0x46, 0x0f, 0xbe,
+	0x87, 0x53, 0xd3, 0xcb, 0x1b, 0x1e, 0x3f, 0xa6, 0x39, 0xee, 0x2e, 0x3c, 0x5a, 0x1f, 0x01, 0x31,
+	0x5d, 0xad, 0xc4, 0xe0, 0x09, 0xe8, 0x26, 0xec, 0x7e, 0x34, 0xb9, 0x46, 0x9e, 0xa0, 0xd4, 0x8d,
+	0xfc, 0x1d, 0x65, 0xa9, 0x9b, 0xa5, 0x73, 0xec, 0xb3, 0xb5, 0xa4, 0x14, 0x5a, 0xea, 0xa9, 0x40,
+	0xb7, 0x61, 0x6c, 0xf3, 0x9f, 0x1e, 0x43, 0x27, 0x13, 0x8b, 0xed, 0xa4, 0xb4, 0x33, 0xb1, 0x08,
+	0x12, 0xfa, 0x35, 0xd8, 0xcb, 0x34, 0x8f, 0xd6, 0x53, 0x54, 0x4f, 0xca, 0x32, 0xcd, 0x67, 0x66,
+	0x90, 0x06, 0x33, 0x38, 0x7c, 0x9e, 0x3a, 0x94, 0x3c, 0xcd, 0xbe, 0x98, 0xfb, 0x0d, 0xd8, 0x4a,
+	0xf2, 0xf8, 0x03, 0xca, 0xa8, 0x10, 0xa5, 0x29, 0xa1, 0xc5, 0xa0, 0xb6, 0x66, 0xa2, 0x1c, 0xfc,
+	0x4b, 0xe0, 0xf8, 0xd9, 0x54, 0x09, 0x89, 0x61, 0x05, 0xe9, 0x3b, 0x68, 0xe5, 0x22, 0xa9, 0xbe,
+	0xdd, 0x3e, 0xff, 0xe6, 0x93, 0xf1, 0xdb, 0x06, 0x7a, 0xf5, 0xef, 0x54, 0x24, 0xc8, 0xcc, 0x92,
+	0xb3, 0x5f, 0xc0, 0x7e, 0x66, 0xd6, 0xf3, 0x29, 0xcd, 0x9d, 0x21, 0xa6, 0x82, 0xae, 0xd1, 0x41,
+	0xa2, 0x2b, 0xaf, 0x46, 0x53, 0xdf, 0xa6, 0xa6, 0x26, 0xb5, 0xd4, 0x24, 0xc1, 0x0c, 0x35, 0x69,
+	0x56, 0xa4, 0x96, 0x83, 0x7f, 0x1a, 0xf0, 0xf2, 0x79, 0x17, 0xfc, 0x5c, 0xc9, 0x27, 0xea, 0xd5,
+	0x5d, 0x26, 0xe6, 0xb6, 0x9c, 0xed, 0x94, 0xbb, 0x0e, 0xf2, 0xc2, 0xa7, 0x02, 0xeb, 0x13, 0xf8,
+	0x16, 0xac, 0x62, 0xcd, 0x4d, 0x6e, 0xfb, 0x7c, 0x7f, 0x67, 0x11, 0xdb, 0xf2, 0xdd, 0x9b, 0x4d,
+	0xb6, 0x37, 0x7b, 0xf0, 0x17, 0x81, 0x56, 0x58, 0x1d, 0xe8, 0xcb, 0x19, 0xbb, 0xbd, 0xf4, 0xc7,
+	0x73, 0xe6, 0x47, 0xf7, 0xa3, 0x49, 0xe4, 0xdf, 0x5e, 0x39, 0x84, 0xbe, 0x02, 0xba, 0x6b, 0x07,
+	0xd3, 0x20, 0x74, 0x1a, 0xd4, 0x85, 0xa3, 0x4f, 0xfd, 0x3b, 0x9f, 0x85, 0x4e, 0xf3, 0x73, 0x32,
+	0x9f, 0x8d, 0x47, 0xa1, 0xef, 0xb4, 0x3e, 0x27, 0x63, 0x7f, 0xe2, 0x87, 0xbe, 0xd3, 0xa6, 0xa7,
+	0x70, 0xbc, 0x4b, 0x2e, 0x6f, 0x6f, 0x66, 0xa3, 0xcb, 0xd0, 0xe9, 0xbc, 0x2d, 0xe0, 0x60, 0xf7,
+	0xd1, 0xa0, 0x0e, 0xec, 0xe9, 0x22, 0x82, 0xd1, 0x24, 0xf8, 0x39, 0x98, 0xbe, 0x77, 0x08, 0xdd,
+	0x83, 0x1e, 0x9b, 0x4f, 0xa7, 0xa3, 0x8b, 0x89, 0xef, 0x34, 0xa8, 0x0d, 0xdd, 0xfb, 0x51, 0x10,
+	0x6a, 0xd4, 0xa4, 0x87, 0xf0, 0xa2, 0x16, 0x51, 0x18, 0xdc, 0xf8, 0xb7, 0xf3, 0xd0, 0x69, 0xd1,
+	0x03, 0x00, 0x76, 0x3b, 0x99, 0xf8, 0xe3, 0x8b, 0xd1, 0xe5, 0x4f, 0x4e, 0x5b, 0xaf, 0xbf, 0x0a,
+	0xa6, 0xc1, 0xdd, 0xb5, 0x3f, 0x76, 0x3a, 0x17, 0x3e, 0xbc, 0x15, 0x72, 0xe1, 0xf1, 0x82, 0xc7,
+	0x8f, 0xe8, 0x3d, 0xf2, 0x44, 0x88, 0xc2, 0x7b, 0x7c, 0xe0, 0x65, 0xfd, 0x12, 0x3f, 0xac, 0x7e,
+	0xf5, 0x16, 0x98, 0xa3, 0xd4, 0xc7, 0x7c, 0xb1, 0x7d, 0xa7, 0x67, 0x1a, 0x96, 0xd7, 0xe4, 0x4f,
+	0x42, 0xfe, 0x26, 0xe4, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xa8, 0xe2, 0x27, 0x16, 0xc1, 0x05,
+	0x00, 0x00,
+}

vendor/github.com/tsuna/gohbase/pb/Procedure.proto

@@ -0,0 +1,119 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package pb;
+
+option java_package = "org.apache.hadoop.hbase.protobuf.generated";
+option java_outer_classname = "ProcedureProtos";
+option java_generic_services = true;
+option java_generate_equals_and_hash = true;
+option optimize_for = SPEED;
+
+import "ErrorHandling.proto";
+
+enum ProcedureState {
+  INITIALIZING = 1;         // Procedure in construction, not yet added to the executor
+  RUNNABLE = 2;             // Procedure added to the executor, and ready to be executed
+  WAITING = 3;              // The procedure is waiting on children to be completed
+  WAITING_TIMEOUT = 4;      // The procedure is waiting a timout or an external event
+  ROLLEDBACK = 5;           // The procedure failed and was rolledback
+  FINISHED = 6;             // The procedure execution is completed. may need a rollback if failed.
+}
+
+/**
+ * Procedure metadata, serialized by the ProcedureStore to be able to recover the old state.
+ */
+message Procedure {
+  // internal "static" state
+  required string class_name = 1;        // full classname to be able to instantiate the procedure
+  optional uint64 parent_id = 2;         // parent if not a root-procedure otherwise not set
+  required uint64 proc_id = 3;
+  required uint64 start_time = 4;
+  optional string owner = 5;
+
+  // internal "runtime" state
+  required ProcedureState state = 6;
+  repeated uint32 stack_id = 7;          // stack indices in case the procedure was running
+  required uint64 last_update = 8;
+  optional uint32 timeout = 9;
+
+  // user state/results
+  optional ForeignExceptionMessage exception = 10;
+  optional bytes result = 11;           // opaque (user) result structure
+  optional bytes state_data = 12;       // opaque (user) procedure internal-state
+
+  // Nonce to prevent same procedure submit by multiple times
+  optional uint64 nonce_group = 13 [default = 0];
+  optional uint64 nonce = 14 [default = 0];
+}
+
+/**
+ * SequentialProcedure data
+ */
+message SequentialProcedureData {
+  required bool executed = 1;
+}
+
+/**
+ * StateMachineProcedure data
+ */
+message StateMachineProcedureData {
+  repeated uint32 state = 1;
+}
+
+/**
+ * Procedure WAL header
+ */
+message ProcedureWALHeader {
+  required uint32 version = 1;
+  required uint32 type = 2;
+  required uint64 log_id = 3;
+  required uint64 min_proc_id = 4;
+}
+
+/**
+ * Procedure WAL trailer
+ */
+message ProcedureWALTrailer {
+  required uint32 version = 1;
+  required uint64 tracker_pos = 2;
+}
+
+message ProcedureStoreTracker {
+  message TrackerNode {
+    required uint64 start_id = 1;
+    repeated uint64 updated = 2;
+    repeated uint64 deleted = 3;
+  }
+
+  repeated TrackerNode node = 1;
+}
+
+message ProcedureWALEntry {
+  enum Type {
+    PROCEDURE_WAL_EOF     = 1;
+    PROCEDURE_WAL_INIT    = 2;
+    PROCEDURE_WAL_INSERT  = 3;
+    PROCEDURE_WAL_UPDATE  = 4;
+    PROCEDURE_WAL_DELETE  = 5;
+    PROCEDURE_WAL_COMPACT = 6;
+  }
+
+  required Type type = 1;
+  repeated Procedure procedure = 2;
+  optional uint64 proc_id = 3;
+}

vendor/github.com/tsuna/gohbase/pb/Quota.pb.go

@@ -0,0 +1,337 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: Quota.proto
+
+package pb
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+type QuotaScope int32
+
+const (
+	QuotaScope_CLUSTER QuotaScope = 1
+	QuotaScope_MACHINE QuotaScope = 2
+)
+
+var QuotaScope_name = map[int32]string{
+	1: "CLUSTER",
+	2: "MACHINE",
+}
+var QuotaScope_value = map[string]int32{
+	"CLUSTER": 1,
+	"MACHINE": 2,
+}
+
+func (x QuotaScope) Enum() *QuotaScope {
+	p := new(QuotaScope)
+	*p = x
+	return p
+}
+func (x QuotaScope) String() string {
+	return proto.EnumName(QuotaScope_name, int32(x))
+}
+func (x *QuotaScope) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(QuotaScope_value, data, "QuotaScope")
+	if err != nil {
+		return err
+	}
+	*x = QuotaScope(value)
+	return nil
+}
+func (QuotaScope) EnumDescriptor() ([]byte, []int) { return fileDescriptor14, []int{0} }
+
+type ThrottleType int32
+
+const (
+	ThrottleType_REQUEST_NUMBER ThrottleType = 1
+	ThrottleType_REQUEST_SIZE   ThrottleType = 2
+	ThrottleType_WRITE_NUMBER   ThrottleType = 3
+	ThrottleType_WRITE_SIZE     ThrottleType = 4
+	ThrottleType_READ_NUMBER    ThrottleType = 5
+	ThrottleType_READ_SIZE      ThrottleType = 6
+)
+
+var ThrottleType_name = map[int32]string{
+	1: "REQUEST_NUMBER",
+	2: "REQUEST_SIZE",
+	3: "WRITE_NUMBER",
+	4: "WRITE_SIZE",
+	5: "READ_NUMBER",
+	6: "READ_SIZE",
+}
+var ThrottleType_value = map[string]int32{
+	"REQUEST_NUMBER": 1,
+	"REQUEST_SIZE":   2,
+	"WRITE_NUMBER":   3,
+	"WRITE_SIZE":     4,
+	"READ_NUMBER":    5,
+	"READ_SIZE":      6,
+}
+
+func (x ThrottleType) Enum() *ThrottleType {
+	p := new(ThrottleType)
+	*p = x
+	return p
+}
+func (x ThrottleType) String() string {
+	return proto.EnumName(ThrottleType_name, int32(x))
+}
+func (x *ThrottleType) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(ThrottleType_value, data, "ThrottleType")
+	if err != nil {
+		return err
+	}
+	*x = ThrottleType(value)
+	return nil
+}
+func (ThrottleType) EnumDescriptor() ([]byte, []int) { return fileDescriptor14, []int{1} }
+
+type QuotaType int32
+
+const (
+	QuotaType_THROTTLE QuotaType = 1
+)
+
+var QuotaType_name = map[int32]string{
+	1: "THROTTLE",
+}
+var QuotaType_value = map[string]int32{
+	"THROTTLE": 1,
+}
+
+func (x QuotaType) Enum() *QuotaType {
+	p := new(QuotaType)
+	*p = x
+	return p
+}
+func (x QuotaType) String() string {
+	return proto.EnumName(QuotaType_name, int32(x))
+}
+func (x *QuotaType) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(QuotaType_value, data, "QuotaType")
+	if err != nil {
+		return err
+	}
+	*x = QuotaType(value)
+	return nil
+}
+func (QuotaType) EnumDescriptor() ([]byte, []int) { return fileDescriptor14, []int{2} }
+
+type TimedQuota struct {
+	TimeUnit         *TimeUnit   `protobuf:"varint,1,req,name=time_unit,json=timeUnit,enum=pb.TimeUnit" json:"time_unit,omitempty"`
+	SoftLimit        *uint64     `protobuf:"varint,2,opt,name=soft_limit,json=softLimit" json:"soft_limit,omitempty"`
+	Share            *float32    `protobuf:"fixed32,3,opt,name=share" json:"share,omitempty"`
+	Scope            *QuotaScope `protobuf:"varint,4,opt,name=scope,enum=pb.QuotaScope,def=2" json:"scope,omitempty"`
+	XXX_unrecognized []byte      `json:"-"`
+}
+
+func (m *TimedQuota) Reset()                    { *m = TimedQuota{} }
+func (m *TimedQuota) String() string            { return proto.CompactTextString(m) }
+func (*TimedQuota) ProtoMessage()               {}
+func (*TimedQuota) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{0} }
+
+const Default_TimedQuota_Scope QuotaScope = QuotaScope_MACHINE
+
+func (m *TimedQuota) GetTimeUnit() TimeUnit {
+	if m != nil && m.TimeUnit != nil {
+		return *m.TimeUnit
+	}
+	return TimeUnit_NANOSECONDS
+}
+
+func (m *TimedQuota) GetSoftLimit() uint64 {
+	if m != nil && m.SoftLimit != nil {
+		return *m.SoftLimit
+	}
+	return 0
+}
+
+func (m *TimedQuota) GetShare() float32 {
+	if m != nil && m.Share != nil {
+		return *m.Share
+	}
+	return 0
+}
+
+func (m *TimedQuota) GetScope() QuotaScope {
+	if m != nil && m.Scope != nil {
+		return *m.Scope
+	}
+	return Default_TimedQuota_Scope
+}
+
+type Throttle struct {
+	ReqNum           *TimedQuota `protobuf:"bytes,1,opt,name=req_num,json=reqNum" json:"req_num,omitempty"`
+	ReqSize          *TimedQuota `protobuf:"bytes,2,opt,name=req_size,json=reqSize" json:"req_size,omitempty"`
+	WriteNum         *TimedQuota `protobuf:"bytes,3,opt,name=write_num,json=writeNum" json:"write_num,omitempty"`
+	WriteSize        *TimedQuota `protobuf:"bytes,4,opt,name=write_size,json=writeSize" json:"write_size,omitempty"`
+	ReadNum          *TimedQuota `protobuf:"bytes,5,opt,name=read_num,json=readNum" json:"read_num,omitempty"`
+	ReadSize         *TimedQuota `protobuf:"bytes,6,opt,name=read_size,json=readSize" json:"read_size,omitempty"`
+	XXX_unrecognized []byte      `json:"-"`
+}
+
+func (m *Throttle) Reset()                    { *m = Throttle{} }
+func (m *Throttle) String() string            { return proto.CompactTextString(m) }
+func (*Throttle) ProtoMessage()               {}
+func (*Throttle) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{1} }
+
+func (m *Throttle) GetReqNum() *TimedQuota {
+	if m != nil {
+		return m.ReqNum
+	}
+	return nil
+}
+
+func (m *Throttle) GetReqSize() *TimedQuota {
+	if m != nil {
+		return m.ReqSize
+	}
+	return nil
+}
+
+func (m *Throttle) GetWriteNum() *TimedQuota {
+	if m != nil {
+		return m.WriteNum
+	}
+	return nil
+}
+
+func (m *Throttle) GetWriteSize() *TimedQuota {
+	if m != nil {
+		return m.WriteSize
+	}
+	return nil
+}
+
+func (m *Throttle) GetReadNum() *TimedQuota {
+	if m != nil {
+		return m.ReadNum
+	}
+	return nil
+}
+
+func (m *Throttle) GetReadSize() *TimedQuota {
+	if m != nil {
+		return m.ReadSize
+	}
+	return nil
+}
+
+type ThrottleRequest struct {
+	Type             *ThrottleType `protobuf:"varint,1,opt,name=type,enum=pb.ThrottleType" json:"type,omitempty"`
+	TimedQuota       *TimedQuota   `protobuf:"bytes,2,opt,name=timed_quota,json=timedQuota" json:"timed_quota,omitempty"`
+	XXX_unrecognized []byte        `json:"-"`
+}
+
+func (m *ThrottleRequest) Reset()                    { *m = ThrottleRequest{} }
+func (m *ThrottleRequest) String() string            { return proto.CompactTextString(m) }
+func (*ThrottleRequest) ProtoMessage()               {}
+func (*ThrottleRequest) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{2} }
+
+func (m *ThrottleRequest) GetType() ThrottleType {
+	if m != nil && m.Type != nil {
+		return *m.Type
+	}
+	return ThrottleType_REQUEST_NUMBER
+}
+
+func (m *ThrottleRequest) GetTimedQuota() *TimedQuota {
+	if m != nil {
+		return m.TimedQuota
+	}
+	return nil
+}
+
+type Quotas struct {
+	BypassGlobals    *bool     `protobuf:"varint,1,opt,name=bypass_globals,json=bypassGlobals,def=0" json:"bypass_globals,omitempty"`
+	Throttle         *Throttle `protobuf:"bytes,2,opt,name=throttle" json:"throttle,omitempty"`
+	XXX_unrecognized []byte    `json:"-"`
+}
+
+func (m *Quotas) Reset()                    { *m = Quotas{} }
+func (m *Quotas) String() string            { return proto.CompactTextString(m) }
+func (*Quotas) ProtoMessage()               {}
+func (*Quotas) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{3} }
+
+const Default_Quotas_BypassGlobals bool = false
+
+func (m *Quotas) GetBypassGlobals() bool {
+	if m != nil && m.BypassGlobals != nil {
+		return *m.BypassGlobals
+	}
+	return Default_Quotas_BypassGlobals
+}
+
+func (m *Quotas) GetThrottle() *Throttle {
+	if m != nil {
+		return m.Throttle
+	}
+	return nil
+}
+
+type QuotaUsage struct {
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *QuotaUsage) Reset()                    { *m = QuotaUsage{} }
+func (m *QuotaUsage) String() string            { return proto.CompactTextString(m) }
+func (*QuotaUsage) ProtoMessage()               {}
+func (*QuotaUsage) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{4} }
+
+func init() {
+	proto.RegisterType((*TimedQuota)(nil), "pb.TimedQuota")
+	proto.RegisterType((*Throttle)(nil), "pb.Throttle")
+	proto.RegisterType((*ThrottleRequest)(nil), "pb.ThrottleRequest")
+	proto.RegisterType((*Quotas)(nil), "pb.Quotas")
+	proto.RegisterType((*QuotaUsage)(nil), "pb.QuotaUsage")
+	proto.RegisterEnum("pb.QuotaScope", QuotaScope_name, QuotaScope_value)
+	proto.RegisterEnum("pb.ThrottleType", ThrottleType_name, ThrottleType_value)
+	proto.RegisterEnum("pb.QuotaType", QuotaType_name, QuotaType_value)
+}
+
+func init() { proto.RegisterFile("Quota.proto", fileDescriptor14) }
+
+var fileDescriptor14 = []byte{
+	// 546 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x93, 0xc1, 0x6f, 0x9b, 0x3e,
+	0x14, 0xc7, 0x65, 0x9a, 0xa4, 0xf0, 0xa0, 0x14, 0x59, 0xbf, 0x43, 0x7e, 0x93, 0x26, 0x45, 0xd1,
+	0xb4, 0xd1, 0x74, 0x65, 0x52, 0x8f, 0xbd, 0x35, 0x1d, 0x5a, 0x2a, 0xb5, 0xdd, 0xea, 0x10, 0x4d,
+	0xda, 0x85, 0x99, 0xe2, 0x06, 0xa4, 0x24, 0x10, 0x6c, 0x36, 0xb5, 0x7f, 0xc1, 0xce, 0xbb, 0xee,
+	0xb2, 0x3f, 0x75, 0xf2, 0x83, 0x64, 0x95, 0x96, 0xde, 0xec, 0xef, 0xfb, 0xf8, 0xfb, 0xbe, 0x3c,
+	0x6c, 0xb0, 0x6f, 0xeb, 0x42, 0xf1, 0xa0, 0xac, 0x0a, 0x55, 0x50, 0xa3, 0x4c, 0x5e, 0xd8, 0x93,
+	0x31, 0x97, 0xa2, 0x11, 0x86, 0xbf, 0x08, 0x40, 0x94, 0x2f, 0x45, 0x8a, 0x14, 0x3d, 0x02, 0x4b,
+	0xe5, 0x4b, 0x11, 0xd7, 0xab, 0x5c, 0xf5, 0xc9, 0xc0, 0xf0, 0xdd, 0x53, 0x27, 0x28, 0x93, 0x40,
+	0x23, 0xb3, 0x55, 0xae, 0x98, 0xa9, 0xda, 0x15, 0x7d, 0x09, 0x20, 0x8b, 0x7b, 0x15, 0x2f, 0xf2,
+	0x65, 0xae, 0xfa, 0xc6, 0x80, 0xf8, 0x1d, 0x66, 0x69, 0xe5, 0x4a, 0x0b, 0xf4, 0x3f, 0xe8, 0xca,
+	0x8c, 0x57, 0xa2, 0xbf, 0x37, 0x20, 0xbe, 0xc1, 0x9a, 0x0d, 0x3d, 0x81, 0xae, 0xbc, 0x2b, 0x4a,
+	0xd1, 0xef, 0x0c, 0x88, 0xef, 0x9e, 0xba, 0xda, 0x1b, 0x3b, 0x4f, 0xb5, 0x7a, 0xb6, 0x7f, 0x7d,
+	0x7e, 0x31, 0xb9, 0xbc, 0x09, 0x59, 0x43, 0x0d, 0x7f, 0x1a, 0x60, 0x46, 0x59, 0x55, 0x28, 0xb5,
+	0x10, 0xf4, 0x0d, 0xec, 0x57, 0x62, 0x1d, 0xaf, 0xea, 0x65, 0x9f, 0x0c, 0x88, 0x6f, 0x37, 0xa7,
+	0xff, 0x86, 0x67, 0xbd, 0x4a, 0xac, 0x6f, 0xea, 0x25, 0x3d, 0x02, 0x53, 0x83, 0x32, 0x7f, 0x14,
+	0x98, 0xeb, 0x5f, 0x52, 0x1b, 0x4d, 0xf3, 0x47, 0x41, 0x8f, 0xc1, 0xfa, 0x5e, 0xe5, 0x4a, 0xa0,
+	0xeb, 0xde, 0x4e, 0xd6, 0x44, 0x40, 0xfb, 0x9e, 0x00, 0x34, 0x30, 0x3a, 0x77, 0x76, 0xd2, 0x8d,
+	0x1d, 0x7a, 0x63, 0x0c, 0x9e, 0xa2, 0x75, 0xf7, 0xb9, 0x18, 0x3c, 0xd5, 0xce, 0xc7, 0x60, 0x21,
+	0x8a, 0xc6, 0xbd, 0xdd, 0x31, 0x34, 0xa0, 0x7d, 0x87, 0x19, 0x1c, 0x6e, 0x66, 0xc2, 0xc4, 0xba,
+	0x16, 0x52, 0xd1, 0x57, 0xd0, 0x51, 0x0f, 0xa5, 0xc0, 0xb9, 0xb8, 0xa7, 0x1e, 0x1e, 0x6d, 0x91,
+	0xe8, 0xa1, 0x14, 0x0c, 0xab, 0xf4, 0x1d, 0xd8, 0xfa, 0xef, 0xa5, 0xf1, 0x5a, 0x3b, 0x3e, 0x33,
+	0x1a, 0x50, 0xdb, 0xf5, 0xf0, 0x2b, 0xf4, 0x70, 0x21, 0xe9, 0x5b, 0x70, 0x93, 0x87, 0x92, 0x4b,
+	0x19, 0xcf, 0x17, 0x45, 0xc2, 0x17, 0x12, 0x5b, 0x99, 0x67, 0xdd, 0x7b, 0xbe, 0x90, 0x82, 0x1d,
+	0x34, 0xc5, 0x0f, 0x4d, 0x8d, 0xfa, 0x60, 0xaa, 0xb6, 0x7d, 0xdb, 0xc5, 0x79, 0x1a, 0x89, 0x6d,
+	0xab, 0x43, 0x07, 0x00, 0x3b, 0xcc, 0x24, 0x9f, 0x8b, 0xd1, 0xeb, 0x76, 0x87, 0x97, 0x81, 0xda,
+	0xb0, 0x7f, 0x71, 0x35, 0x9b, 0x46, 0x21, 0xf3, 0x88, 0xde, 0xb4, 0x77, 0xc3, 0x33, 0x46, 0xdf,
+	0xc0, 0x79, 0xfa, 0x79, 0x94, 0x82, 0xcb, 0xc2, 0xdb, 0x59, 0x38, 0x8d, 0xe2, 0x9b, 0xd9, 0xf5,
+	0x18, 0x0f, 0x78, 0xe0, 0x6c, 0xb4, 0xe9, 0xe5, 0x97, 0xd0, 0x33, 0xb4, 0xf2, 0x99, 0x5d, 0x46,
+	0xe1, 0x86, 0xd9, 0xa3, 0x2e, 0x40, 0xa3, 0x20, 0xd1, 0xa1, 0x87, 0x60, 0xb3, 0xf0, 0xfc, 0xfd,
+	0x06, 0xe8, 0xd2, 0x03, 0xb0, 0x50, 0xc0, 0x7a, 0x6f, 0xf4, 0x3f, 0x58, 0x98, 0x0f, 0x9b, 0x3a,
+	0x60, 0x46, 0x13, 0xf6, 0x31, 0x8a, 0xae, 0x42, 0x8f, 0x8c, 0xcf, 0x61, 0x54, 0x54, 0xf3, 0x80,
+	0x97, 0xfc, 0x2e, 0x13, 0x41, 0xc6, 0xd3, 0xa2, 0x28, 0x83, 0x2c, 0xd9, 0x3e, 0xb4, 0xa4, 0xbe,
+	0x0f, 0xe6, 0x62, 0x25, 0x2a, 0xae, 0x44, 0x3a, 0x6e, 0xde, 0xe4, 0x27, 0x5d, 0x90, 0x13, 0xf2,
+	0x83, 0x90, 0xdf, 0x84, 0xfc, 0x09, 0x00, 0x00, 0xff, 0xff, 0x31, 0x6b, 0x5c, 0x31, 0xa9, 0x03,
+	0x00, 0x00,
+}

vendor/github.com/tsuna/gohbase/pb/Quota.proto

@@ -0,0 +1,76 @@
+ /**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package pb;
+
+option java_package = "org.apache.hadoop.hbase.protobuf.generated";
+option java_outer_classname = "QuotaProtos";
+option java_generic_services = true;
+option java_generate_equals_and_hash = true;
+option optimize_for = SPEED;
+
+import "HBase.proto";
+
+enum QuotaScope {
+  CLUSTER = 1;
+  MACHINE = 2;
+}
+
+message TimedQuota {
+  required TimeUnit time_unit = 1;
+  optional uint64 soft_limit  = 2;
+  optional float share = 3;
+  optional QuotaScope scope  = 4 [default = MACHINE];
+}
+
+enum ThrottleType {
+  REQUEST_NUMBER = 1;
+  REQUEST_SIZE   = 2;
+  WRITE_NUMBER   = 3;
+  WRITE_SIZE     = 4;
+  READ_NUMBER    = 5;
+  READ_SIZE      = 6;
+}
+
+message Throttle {
+  optional TimedQuota req_num  = 1;
+  optional TimedQuota req_size = 2;
+
+  optional TimedQuota write_num  = 3;
+  optional TimedQuota write_size = 4;
+
+  optional TimedQuota read_num  = 5;
+  optional TimedQuota read_size = 6;
+}
+
+message ThrottleRequest {
+  optional ThrottleType type = 1;
+  optional TimedQuota timed_quota = 2;
+}
+
+enum QuotaType {
+  THROTTLE = 1;
+}
+
+message Quotas {
+  optional bool bypass_globals = 1 [default = false];
+  optional Throttle throttle = 2;
+}
+
+message QuotaUsage {
+}

vendor/github.com/tsuna/gohbase/pb/README.txt

@@ -0,0 +1,11 @@
+These are the protobuf definition files used by GoHBase.
+They were copied from HBase (see under hbase-protocol/src/main/protobuf).
+
+Currently using .proto files from HBase branch-1.3, with unnecessary .proto
+files removed.
+
+The following changes were made to those files:
+  - the package name was changed to "pb". (`sed -i 's/hbase.pb/pb/g' ./*`)
+
+The files in this directory are also subject to the Apache License 2.0 and
+are copyright of the Apache Software Foundation.

vendor/github.com/tsuna/gohbase/pb/RPC.pb.go

@@ -0,0 +1,327 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: RPC.proto
+
+package pb
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// User Information proto.  Included in ConnectionHeader on connection setup
+type UserInformation struct {
+	EffectiveUser    *string `protobuf:"bytes,1,req,name=effective_user,json=effectiveUser" json:"effective_user,omitempty"`
+	RealUser         *string `protobuf:"bytes,2,opt,name=real_user,json=realUser" json:"real_user,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *UserInformation) Reset()                    { *m = UserInformation{} }
+func (m *UserInformation) String() string            { return proto.CompactTextString(m) }
+func (*UserInformation) ProtoMessage()               {}
+func (*UserInformation) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{0} }
+
+func (m *UserInformation) GetEffectiveUser() string {
+	if m != nil && m.EffectiveUser != nil {
+		return *m.EffectiveUser
+	}
+	return ""
+}
+
+func (m *UserInformation) GetRealUser() string {
+	if m != nil && m.RealUser != nil {
+		return *m.RealUser
+	}
+	return ""
+}
+
+// This is sent on connection setup after the connection preamble is sent.
+type ConnectionHeader struct {
+	UserInfo    *UserInformation `protobuf:"bytes,1,opt,name=user_info,json=userInfo" json:"user_info,omitempty"`
+	ServiceName *string          `protobuf:"bytes,2,opt,name=service_name,json=serviceName" json:"service_name,omitempty"`
+	// Cell block codec we will use sending over optional cell blocks.  Server throws exception
+	// if cannot deal.  Null means no codec'ing going on so we are pb all the time (SLOW!!!)
+	CellBlockCodecClass *string `protobuf:"bytes,3,opt,name=cell_block_codec_class,json=cellBlockCodecClass" json:"cell_block_codec_class,omitempty"`
+	// Compressor we will use if cell block is compressed.  Server will throw exception if not supported.
+	// Class must implement hadoop's CompressionCodec Interface.  Can't compress if no codec.
+	CellBlockCompressorClass *string      `protobuf:"bytes,4,opt,name=cell_block_compressor_class,json=cellBlockCompressorClass" json:"cell_block_compressor_class,omitempty"`
+	VersionInfo              *VersionInfo `protobuf:"bytes,5,opt,name=version_info,json=versionInfo" json:"version_info,omitempty"`
+	XXX_unrecognized         []byte       `json:"-"`
+}
+
+func (m *ConnectionHeader) Reset()                    { *m = ConnectionHeader{} }
+func (m *ConnectionHeader) String() string            { return proto.CompactTextString(m) }
+func (*ConnectionHeader) ProtoMessage()               {}
+func (*ConnectionHeader) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{1} }
+
+func (m *ConnectionHeader) GetUserInfo() *UserInformation {
+	if m != nil {
+		return m.UserInfo
+	}
+	return nil
+}
+
+func (m *ConnectionHeader) GetServiceName() string {
+	if m != nil && m.ServiceName != nil {
+		return *m.ServiceName
+	}
+	return ""
+}
+
+func (m *ConnectionHeader) GetCellBlockCodecClass() string {
+	if m != nil && m.CellBlockCodecClass != nil {
+		return *m.CellBlockCodecClass
+	}
+	return ""
+}
+
+func (m *ConnectionHeader) GetCellBlockCompressorClass() string {
+	if m != nil && m.CellBlockCompressorClass != nil {
+		return *m.CellBlockCompressorClass
+	}
+	return ""
+}
+
+func (m *ConnectionHeader) GetVersionInfo() *VersionInfo {
+	if m != nil {
+		return m.VersionInfo
+	}
+	return nil
+}
+
+// Optional Cell block Message.  Included in client RequestHeader
+type CellBlockMeta struct {
+	// Length of the following cell block.  Could calculate it but convenient having it too hand.
+	Length           *uint32 `protobuf:"varint,1,opt,name=length" json:"length,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *CellBlockMeta) Reset()                    { *m = CellBlockMeta{} }
+func (m *CellBlockMeta) String() string            { return proto.CompactTextString(m) }
+func (*CellBlockMeta) ProtoMessage()               {}
+func (*CellBlockMeta) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{2} }
+
+func (m *CellBlockMeta) GetLength() uint32 {
+	if m != nil && m.Length != nil {
+		return *m.Length
+	}
+	return 0
+}
+
+// At the RPC layer, this message is used to carry
+// the server side exception to the RPC client.
+type ExceptionResponse struct {
+	// Class name of the exception thrown from the server
+	ExceptionClassName *string `protobuf:"bytes,1,opt,name=exception_class_name,json=exceptionClassName" json:"exception_class_name,omitempty"`
+	// Exception stack trace from the server side
+	StackTrace *string `protobuf:"bytes,2,opt,name=stack_trace,json=stackTrace" json:"stack_trace,omitempty"`
+	// Optional hostname.  Filled in for some exceptions such as region moved
+	// where exception gives clue on where the region may have moved.
+	Hostname *string `protobuf:"bytes,3,opt,name=hostname" json:"hostname,omitempty"`
+	Port     *int32  `protobuf:"varint,4,opt,name=port" json:"port,omitempty"`
+	// Set if we are NOT to retry on receipt of this exception
+	DoNotRetry       *bool  `protobuf:"varint,5,opt,name=do_not_retry,json=doNotRetry" json:"do_not_retry,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *ExceptionResponse) Reset()                    { *m = ExceptionResponse{} }
+func (m *ExceptionResponse) String() string            { return proto.CompactTextString(m) }
+func (*ExceptionResponse) ProtoMessage()               {}
+func (*ExceptionResponse) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{3} }
+
+func (m *ExceptionResponse) GetExceptionClassName() string {
+	if m != nil && m.ExceptionClassName != nil {
+		return *m.ExceptionClassName
+	}
+	return ""
+}
+
+func (m *ExceptionResponse) GetStackTrace() string {
+	if m != nil && m.StackTrace != nil {
+		return *m.StackTrace
+	}
+	return ""
+}
+
+func (m *ExceptionResponse) GetHostname() string {
+	if m != nil && m.Hostname != nil {
+		return *m.Hostname
+	}
+	return ""
+}
+
+func (m *ExceptionResponse) GetPort() int32 {
+	if m != nil && m.Port != nil {
+		return *m.Port
+	}
+	return 0
+}
+
+func (m *ExceptionResponse) GetDoNotRetry() bool {
+	if m != nil && m.DoNotRetry != nil {
+		return *m.DoNotRetry
+	}
+	return false
+}
+
+// Header sent making a request.
+type RequestHeader struct {
+	// Monotonically increasing call_id to keep track of RPC requests and their response
+	CallId     *uint32   `protobuf:"varint,1,opt,name=call_id,json=callId" json:"call_id,omitempty"`
+	TraceInfo  *RPCTInfo `protobuf:"bytes,2,opt,name=trace_info,json=traceInfo" json:"trace_info,omitempty"`
+	MethodName *string   `protobuf:"bytes,3,opt,name=method_name,json=methodName" json:"method_name,omitempty"`
+	// If true, then a pb Message param follows.
+	RequestParam *bool `protobuf:"varint,4,opt,name=request_param,json=requestParam" json:"request_param,omitempty"`
+	// If present, then an encoded data block follows.
+	CellBlockMeta *CellBlockMeta `protobuf:"bytes,5,opt,name=cell_block_meta,json=cellBlockMeta" json:"cell_block_meta,omitempty"`
+	// 0 is NORMAL priority.  200 is HIGH.  If no priority, treat it as NORMAL.
+	// See HConstants.
+	Priority         *uint32 `protobuf:"varint,6,opt,name=priority" json:"priority,omitempty"`
+	Timeout          *uint32 `protobuf:"varint,7,opt,name=timeout" json:"timeout,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *RequestHeader) Reset()                    { *m = RequestHeader{} }
+func (m *RequestHeader) String() string            { return proto.CompactTextString(m) }
+func (*RequestHeader) ProtoMessage()               {}
+func (*RequestHeader) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{4} }
+
+func (m *RequestHeader) GetCallId() uint32 {
+	if m != nil && m.CallId != nil {
+		return *m.CallId
+	}
+	return 0
+}
+
+func (m *RequestHeader) GetTraceInfo() *RPCTInfo {
+	if m != nil {
+		return m.TraceInfo
+	}
+	return nil
+}
+
+func (m *RequestHeader) GetMethodName() string {
+	if m != nil && m.MethodName != nil {
+		return *m.MethodName
+	}
+	return ""
+}
+
+func (m *RequestHeader) GetRequestParam() bool {
+	if m != nil && m.RequestParam != nil {
+		return *m.RequestParam
+	}
+	return false
+}
+
+func (m *RequestHeader) GetCellBlockMeta() *CellBlockMeta {
+	if m != nil {
+		return m.CellBlockMeta
+	}
+	return nil
+}
+
+func (m *RequestHeader) GetPriority() uint32 {
+	if m != nil && m.Priority != nil {
+		return *m.Priority
+	}
+	return 0
+}
+
+func (m *RequestHeader) GetTimeout() uint32 {
+	if m != nil && m.Timeout != nil {
+		return *m.Timeout
+	}
+	return 0
+}
+
+type ResponseHeader struct {
+	CallId *uint32 `protobuf:"varint,1,opt,name=call_id,json=callId" json:"call_id,omitempty"`
+	// If present, then request threw an exception and no response message (else we presume one)
+	Exception *ExceptionResponse `protobuf:"bytes,2,opt,name=exception" json:"exception,omitempty"`
+	// If present, then an encoded data block follows.
+	CellBlockMeta    *CellBlockMeta `protobuf:"bytes,3,opt,name=cell_block_meta,json=cellBlockMeta" json:"cell_block_meta,omitempty"`
+	XXX_unrecognized []byte         `json:"-"`
+}
+
+func (m *ResponseHeader) Reset()                    { *m = ResponseHeader{} }
+func (m *ResponseHeader) String() string            { return proto.CompactTextString(m) }
+func (*ResponseHeader) ProtoMessage()               {}
+func (*ResponseHeader) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{5} }
+
+func (m *ResponseHeader) GetCallId() uint32 {
+	if m != nil && m.CallId != nil {
+		return *m.CallId
+	}
+	return 0
+}
+
+func (m *ResponseHeader) GetException() *ExceptionResponse {
+	if m != nil {
+		return m.Exception
+	}
+	return nil
+}
+
+func (m *ResponseHeader) GetCellBlockMeta() *CellBlockMeta {
+	if m != nil {
+		return m.CellBlockMeta
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*UserInformation)(nil), "pb.UserInformation")
+	proto.RegisterType((*ConnectionHeader)(nil), "pb.ConnectionHeader")
+	proto.RegisterType((*CellBlockMeta)(nil), "pb.CellBlockMeta")
+	proto.RegisterType((*ExceptionResponse)(nil), "pb.ExceptionResponse")
+	proto.RegisterType((*RequestHeader)(nil), "pb.RequestHeader")
+	proto.RegisterType((*ResponseHeader)(nil), "pb.ResponseHeader")
+}
+
+func init() { proto.RegisterFile("RPC.proto", fileDescriptor15) }
+
+var fileDescriptor15 = []byte{
+	// 606 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x54, 0x5f, 0x6f, 0xd3, 0x3e,
+	0x14, 0x55, 0xba, 0x7f, 0xcd, 0x6d, 0xb3, 0xfd, 0xe6, 0xfd, 0x18, 0x51, 0xf7, 0xb0, 0x52, 0x84,
+	0x98, 0x40, 0x8a, 0xa6, 0xed, 0x09, 0x09, 0x5e, 0x5a, 0x21, 0x6d, 0x0f, 0x4c, 0x95, 0xb5, 0xf1,
+	0x1a, 0xb9, 0xce, 0x6d, 0x1b, 0x2d, 0xb1, 0x83, 0xed, 0x56, 0xec, 0x3b, 0x20, 0xf1, 0xcc, 0x1b,
+	0x1f, 0x83, 0x8f, 0x87, 0x6c, 0x27, 0xd9, 0x06, 0x48, 0xf0, 0x96, 0x7b, 0xce, 0xbd, 0xf1, 0x39,
+	0xe7, 0x5a, 0x86, 0x90, 0x4e, 0x27, 0x49, 0xa5, 0xa4, 0x91, 0xa4, 0x53, 0xcd, 0x06, 0xd1, 0xb5,
+	0x62, 0x3c, 0x17, 0x0b, 0x0f, 0x0d, 0x7a, 0x17, 0x63, 0xa6, 0xd1, 0x17, 0xa3, 0x1b, 0xd8, 0xbb,
+	0xd1, 0xa8, 0x2e, 0xc5, 0x5c, 0xaa, 0x92, 0x99, 0x5c, 0x0a, 0xf2, 0x02, 0x76, 0x71, 0x3e, 0x47,
+	0x6e, 0xf2, 0x35, 0xa6, 0x2b, 0x8d, 0x2a, 0x0e, 0x86, 0x9d, 0x93, 0x90, 0x46, 0x2d, 0x6a, 0x27,
+	0xc8, 0x11, 0x84, 0x0a, 0x59, 0xe1, 0x3b, 0x3a, 0xc3, 0xe0, 0x24, 0xa4, 0x5d, 0x0b, 0x58, 0x72,
+	0xf4, 0xb5, 0x03, 0xff, 0x4d, 0xa4, 0x10, 0xb6, 0x5f, 0x8a, 0x0b, 0x64, 0x19, 0x2a, 0x72, 0x0a,
+	0xa1, 0x6d, 0x4e, 0x73, 0x31, 0x97, 0x71, 0x30, 0x0c, 0x4e, 0x7a, 0x67, 0x07, 0x49, 0x35, 0x4b,
+	0x7e, 0x11, 0x40, 0xbb, 0xab, 0x1a, 0x20, 0xcf, 0xa0, 0xaf, 0x51, 0xad, 0x73, 0x8e, 0xa9, 0x60,
+	0x25, 0xd6, 0xc7, 0xf4, 0x6a, 0xec, 0x8a, 0x95, 0x48, 0xce, 0xe1, 0x90, 0x63, 0x51, 0xa4, 0xb3,
+	0x42, 0xf2, 0xdb, 0x94, 0xcb, 0x0c, 0x79, 0xca, 0x0b, 0xa6, 0x75, 0xbc, 0xe1, 0x9a, 0x0f, 0x2c,
+	0x3b, 0xb6, 0xe4, 0xc4, 0x72, 0x13, 0x4b, 0x91, 0x77, 0x70, 0xf4, 0x68, 0xa8, 0xac, 0x14, 0x6a,
+	0x2d, 0x55, 0x3d, 0xb9, 0xe9, 0x26, 0xe3, 0x07, 0x93, 0x4d, 0x83, 0x1f, 0x3f, 0x83, 0xfe, 0x1a,
+	0x95, 0xce, 0xa5, 0xf0, 0x5e, 0xb6, 0x9c, 0x97, 0x3d, 0xeb, 0xe5, 0xa3, 0xc7, 0xad, 0x7a, 0xda,
+	0x5b, 0xdf, 0x17, 0xa3, 0x97, 0x10, 0x4d, 0x9a, 0xff, 0x7d, 0x40, 0xc3, 0xc8, 0x21, 0x6c, 0x17,
+	0x28, 0x16, 0x66, 0xe9, 0xa2, 0x88, 0x68, 0x5d, 0x8d, 0x7e, 0x04, 0xb0, 0xff, 0xfe, 0x33, 0xc7,
+	0xca, 0x65, 0x81, 0xba, 0x92, 0x42, 0x23, 0x39, 0x85, 0xff, 0xb1, 0x01, 0xbd, 0x4a, 0x9f, 0x48,
+	0xe0, 0xa4, 0x92, 0x96, 0x73, 0x02, 0x5d, 0x30, 0xc7, 0xd0, 0xd3, 0x86, 0xf1, 0xdb, 0xd4, 0x28,
+	0xc6, 0x9b, 0xe8, 0xc0, 0x41, 0xf6, 0x3e, 0x20, 0x19, 0x40, 0x77, 0x29, 0xb5, 0x71, 0xbf, 0xf1,
+	0x59, 0xb5, 0x35, 0x21, 0xb0, 0x59, 0x49, 0x65, 0x5c, 0x12, 0x5b, 0xd4, 0x7d, 0x93, 0x21, 0xf4,
+	0x33, 0x99, 0x0a, 0x69, 0x52, 0x85, 0x46, 0xdd, 0x39, 0xd7, 0x5d, 0x0a, 0x99, 0xbc, 0x92, 0x86,
+	0x5a, 0x64, 0xf4, 0xa5, 0x03, 0x11, 0xc5, 0x4f, 0x2b, 0xd4, 0xa6, 0x5e, 0xf9, 0x53, 0xd8, 0xe1,
+	0xac, 0x28, 0xd2, 0x3c, 0x6b, 0x5c, 0xda, 0xf2, 0x32, 0x23, 0xaf, 0x01, 0x9c, 0x2e, 0x1f, 0x60,
+	0xc7, 0x05, 0xd8, 0xb7, 0x01, 0xd2, 0xe9, 0xe4, 0xda, 0xa5, 0x17, 0x3a, 0xde, 0x5d, 0x83, 0x63,
+	0xe8, 0x95, 0x68, 0x96, 0x32, 0x4b, 0x1f, 0x88, 0x05, 0x0f, 0x39, 0xaf, 0xcf, 0x21, 0x52, 0xfe,
+	0xdc, 0xb4, 0x62, 0x8a, 0x95, 0x4e, 0x77, 0x97, 0xf6, 0x6b, 0x70, 0x6a, 0x31, 0xf2, 0x06, 0xf6,
+	0x1e, 0x2c, 0xbd, 0x44, 0xc3, 0xea, 0xc5, 0xed, 0xdb, 0x73, 0x1f, 0x2d, 0x87, 0x46, 0xfc, 0xd1,
+	0xae, 0x06, 0xd0, 0xad, 0x54, 0x2e, 0x55, 0x6e, 0xee, 0xe2, 0x6d, 0xe7, 0xa3, 0xad, 0x49, 0x0c,
+	0x3b, 0x26, 0x2f, 0x51, 0xae, 0x4c, 0xbc, 0xe3, 0xa8, 0xa6, 0x1c, 0x7d, 0x0b, 0x60, 0xb7, 0x59,
+	0xe0, 0xdf, 0xf2, 0x38, 0x87, 0xb0, 0xdd, 0x61, 0x1d, 0xc7, 0x13, 0x2b, 0xeb, 0xb7, 0x9b, 0x40,
+	0xef, 0xfb, 0xfe, 0xe4, 0x68, 0xe3, 0xdf, 0x1c, 0x8d, 0xdf, 0xc2, 0x2b, 0xa9, 0x16, 0x09, 0xab,
+	0x18, 0x5f, 0x62, 0xb2, 0x64, 0x99, 0x94, 0x55, 0xb2, 0x9c, 0xb5, 0x0f, 0xc3, 0x6c, 0x35, 0x4f,
+	0x16, 0x28, 0x50, 0x31, 0x83, 0xd9, 0xd8, 0x3e, 0x28, 0x53, 0x0b, 0xeb, 0x8b, 0xe0, 0x7b, 0x10,
+	0xfc, 0x0c, 0x00, 0x00, 0xff, 0xff, 0xde, 0x56, 0xde, 0xc7, 0x61, 0x04, 0x00, 0x00,
+}

vendor/github.com/tsuna/gohbase/pb/RPC.proto

@@ -0,0 +1,137 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package pb;
+
+import "Tracing.proto"; 
+import "HBase.proto";
+
+option java_package = "org.apache.hadoop.hbase.protobuf.generated";
+option java_outer_classname = "RPCProtos";
+option java_generate_equals_and_hash = true;
+option optimize_for = SPEED;
+
+// See https://issues.apache.org/jira/browse/HBASE-7898 for high-level
+// description of RPC specification.
+//
+// On connection setup, the client sends six bytes of preamble -- a four
+// byte magic, a byte of version, and a byte of authentication type.
+//
+// We then send a "ConnectionHeader" protobuf of user information and the
+// 'protocol' or 'service' that is to be run over this connection as well as
+// info such as codecs and compression to use when we send cell blocks(see below).
+// This connection header protobuf is prefaced by an int that holds the length
+// of this connection header (this is NOT a varint).  The pb connection header
+// is sent with Message#writeTo.  The server throws an exception if it doesn't
+// like what it was sent noting what it is objecting too.  Otherwise, the server
+// says nothing and is open for business.
+//
+// Hereafter the client makes requests and the server returns responses.
+//
+// Requests look like this:
+//
+// <An int with the total length of the request>
+// <RequestHeader Message written out using Message#writeDelimitedTo>
+// <Optionally a Request Parameter Message written out using Message#writeDelimitedTo>
+// <Optionally a Cell block>
+//
+// ...where the Request Parameter Message is whatever the method name stipulated
+// in the RequestHeader expects; e.g. if the method is a scan, then the pb
+// Request Message is a GetRequest, or a ScanRequest.  A block of Cells
+// optionally follows.  The presence of a Request param Message and/or a
+// block of Cells will be noted in the RequestHeader.
+//
+// Response is the mirror of the request:
+//
+// <An int with the total length of the response>
+// <ResponseHeader Message written out using Message#writeDelimitedTo>
+// <Optionally a Response Result Message written out using Message#writeDelimitedTo>
+// <Optionally a Cell block>
+//
+// ...where the Response Message is the response type that goes with the
+// method specified when making the request and the follow on Cell blocks may
+// or may not be there -- read the response header to find out if one following.
+// If an exception, it will be included inside the Response Header.
+//
+// Any time we write a pb, we do it with Message#writeDelimitedTo EXCEPT when
+// the connection header is sent; this is prefaced by an int with its length
+// and the pb connection header is then written with Message#writeTo.
+//
+
+// User Information proto.  Included in ConnectionHeader on connection setup
+message UserInformation {
+  required string effective_user = 1;
+  optional string real_user = 2;
+}
+
+// This is sent on connection setup after the connection preamble is sent.
+message ConnectionHeader {
+  optional UserInformation user_info = 1;
+  optional string service_name = 2;
+  // Cell block codec we will use sending over optional cell blocks.  Server throws exception
+  // if cannot deal.  Null means no codec'ing going on so we are pb all the time (SLOW!!!)
+  optional string cell_block_codec_class = 3;
+  // Compressor we will use if cell block is compressed.  Server will throw exception if not supported.
+  // Class must implement hadoop's CompressionCodec Interface.  Can't compress if no codec.
+  optional string cell_block_compressor_class = 4;
+  optional VersionInfo version_info = 5;
+}
+
+// Optional Cell block Message.  Included in client RequestHeader
+message CellBlockMeta {
+  // Length of the following cell block.  Could calculate it but convenient having it too hand.
+  optional uint32 length = 1;
+}
+
+// At the RPC layer, this message is used to carry
+// the server side exception to the RPC client.
+message ExceptionResponse {
+  // Class name of the exception thrown from the server
+  optional string exception_class_name = 1;
+  // Exception stack trace from the server side
+  optional string stack_trace = 2;
+  // Optional hostname.  Filled in for some exceptions such as region moved
+  // where exception gives clue on where the region may have moved.
+  optional string hostname = 3;
+  optional int32 port = 4;
+  // Set if we are NOT to retry on receipt of this exception
+  optional bool do_not_retry = 5;
+}
+
+// Header sent making a request.
+message RequestHeader {
+  // Monotonically increasing call_id to keep track of RPC requests and their response
+  optional uint32 call_id = 1;
+  optional RPCTInfo trace_info = 2;
+  optional string method_name = 3;
+  // If true, then a pb Message param follows.
+  optional bool request_param = 4;
+  // If present, then an encoded data block follows.
+  optional CellBlockMeta cell_block_meta = 5;
+  // 0 is NORMAL priority.  200 is HIGH.  If no priority, treat it as NORMAL.
+  // See HConstants.
+  optional uint32 priority = 6;
+  optional uint32 timeout = 7;
+}
+
+message ResponseHeader {
+  optional uint32 call_id = 1;
+  // If present, then request threw an exception and no response message (else we presume one)
+  optional ExceptionResponse exception = 2;
+  // If present, then an encoded data block follows.
+  optional CellBlockMeta cell_block_meta = 3;
+}

vendor/github.com/tsuna/gohbase/pb/RegionServerStatus.pb.go

@@ -0,0 +1,421 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: RegionServerStatus.proto
+
+package pb
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+type RegionStateTransition_TransitionCode int32
+
+const (
+	RegionStateTransition_OPENED      RegionStateTransition_TransitionCode = 0
+	RegionStateTransition_FAILED_OPEN RegionStateTransition_TransitionCode = 1
+	// * No failed_close, in which case region server will abort
+	RegionStateTransition_CLOSED RegionStateTransition_TransitionCode = 2
+	// * Ask master for ok to split/merge region(s)
+	RegionStateTransition_READY_TO_SPLIT RegionStateTransition_TransitionCode = 3
+	RegionStateTransition_READY_TO_MERGE RegionStateTransition_TransitionCode = 4
+	RegionStateTransition_SPLIT_PONR     RegionStateTransition_TransitionCode = 5
+	RegionStateTransition_MERGE_PONR     RegionStateTransition_TransitionCode = 6
+	RegionStateTransition_SPLIT          RegionStateTransition_TransitionCode = 7
+	RegionStateTransition_MERGED         RegionStateTransition_TransitionCode = 8
+	RegionStateTransition_SPLIT_REVERTED RegionStateTransition_TransitionCode = 9
+	RegionStateTransition_MERGE_REVERTED RegionStateTransition_TransitionCode = 10
+)
+
+var RegionStateTransition_TransitionCode_name = map[int32]string{
+	0:  "OPENED",
+	1:  "FAILED_OPEN",
+	2:  "CLOSED",
+	3:  "READY_TO_SPLIT",
+	4:  "READY_TO_MERGE",
+	5:  "SPLIT_PONR",
+	6:  "MERGE_PONR",
+	7:  "SPLIT",
+	8:  "MERGED",
+	9:  "SPLIT_REVERTED",
+	10: "MERGE_REVERTED",
+}
+var RegionStateTransition_TransitionCode_value = map[string]int32{
+	"OPENED":         0,
+	"FAILED_OPEN":    1,
+	"CLOSED":         2,
+	"READY_TO_SPLIT": 3,
+	"READY_TO_MERGE": 4,
+	"SPLIT_PONR":     5,
+	"MERGE_PONR":     6,
+	"SPLIT":          7,
+	"MERGED":         8,
+	"SPLIT_REVERTED": 9,
+	"MERGE_REVERTED": 10,
+}
+
+func (x RegionStateTransition_TransitionCode) Enum() *RegionStateTransition_TransitionCode {
+	p := new(RegionStateTransition_TransitionCode)
+	*p = x
+	return p
+}
+func (x RegionStateTransition_TransitionCode) String() string {
+	return proto.EnumName(RegionStateTransition_TransitionCode_name, int32(x))
+}
+func (x *RegionStateTransition_TransitionCode) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(RegionStateTransition_TransitionCode_value, data, "RegionStateTransition_TransitionCode")
+	if err != nil {
+		return err
+	}
+	*x = RegionStateTransition_TransitionCode(value)
+	return nil
+}
+func (RegionStateTransition_TransitionCode) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor16, []int{8, 0}
+}
+
+type RegionServerStartupRequest struct {
+	// * Port number this regionserver is up on
+	Port *uint32 `protobuf:"varint,1,req,name=port" json:"port,omitempty"`
+	// * This servers' startcode
+	ServerStartCode *uint64 `protobuf:"varint,2,req,name=server_start_code,json=serverStartCode" json:"server_start_code,omitempty"`
+	// * Current time of the region server in ms
+	ServerCurrentTime *uint64 `protobuf:"varint,3,req,name=server_current_time,json=serverCurrentTime" json:"server_current_time,omitempty"`
+	// * hostname for region server, optional
+	UseThisHostnameInstead *string `protobuf:"bytes,4,opt,name=use_this_hostname_instead,json=useThisHostnameInstead" json:"use_this_hostname_instead,omitempty"`
+	XXX_unrecognized       []byte  `json:"-"`
+}
+
+func (m *RegionServerStartupRequest) Reset()                    { *m = RegionServerStartupRequest{} }
+func (m *RegionServerStartupRequest) String() string            { return proto.CompactTextString(m) }
+func (*RegionServerStartupRequest) ProtoMessage()               {}
+func (*RegionServerStartupRequest) Descriptor() ([]byte, []int) { return fileDescriptor16, []int{0} }
+
+func (m *RegionServerStartupRequest) GetPort() uint32 {
+	if m != nil && m.Port != nil {
+		return *m.Port
+	}
+	return 0
+}
+
+func (m *RegionServerStartupRequest) GetServerStartCode() uint64 {
+	if m != nil && m.ServerStartCode != nil {
+		return *m.ServerStartCode
+	}
+	return 0
+}
+
+func (m *RegionServerStartupRequest) GetServerCurrentTime() uint64 {
+	if m != nil && m.ServerCurrentTime != nil {
+		return *m.ServerCurrentTime
+	}
+	return 0
+}
+
+func (m *RegionServerStartupRequest) GetUseThisHostnameInstead() string {
+	if m != nil && m.UseThisHostnameInstead != nil {
+		return *m.UseThisHostnameInstead
+	}
+	return ""
+}
+
+type RegionServerStartupResponse struct {
+	// *
+	// Configuration for the regionserver to use: e.g. filesystem,
+	// hbase rootdir, the hostname to use creating the RegionServer ServerName,
+	// etc
+	MapEntries       []*NameStringPair `protobuf:"bytes,1,rep,name=map_entries,json=mapEntries" json:"map_entries,omitempty"`
+	XXX_unrecognized []byte            `json:"-"`
+}
+
+func (m *RegionServerStartupResponse) Reset()                    { *m = RegionServerStartupResponse{} }
+func (m *RegionServerStartupResponse) String() string            { return proto.CompactTextString(m) }
+func (*RegionServerStartupResponse) ProtoMessage()               {}
+func (*RegionServerStartupResponse) Descriptor() ([]byte, []int) { return fileDescriptor16, []int{1} }
+
+func (m *RegionServerStartupResponse) GetMapEntries() []*NameStringPair {
+	if m != nil {
+		return m.MapEntries
+	}
+	return nil
+}
+
+type RegionServerReportRequest struct {
+	Server *ServerName `protobuf:"bytes,1,req,name=server" json:"server,omitempty"`
+	// * load the server is under
+	Load             *ServerLoad `protobuf:"bytes,2,opt,name=load" json:"load,omitempty"`
+	XXX_unrecognized []byte      `json:"-"`
+}
+
+func (m *RegionServerReportRequest) Reset()                    { *m = RegionServerReportRequest{} }
+func (m *RegionServerReportRequest) String() string            { return proto.CompactTextString(m) }
+func (*RegionServerReportRequest) ProtoMessage()               {}
+func (*RegionServerReportRequest) Descriptor() ([]byte, []int) { return fileDescriptor16, []int{2} }
+
+func (m *RegionServerReportRequest) GetServer() *ServerName {
+	if m != nil {
+		return m.Server
+	}
+	return nil
+}
+
+func (m *RegionServerReportRequest) GetLoad() *ServerLoad {
+	if m != nil {
+		return m.Load
+	}
+	return nil
+}
+
+type RegionServerReportResponse struct {
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *RegionServerReportResponse) Reset()                    { *m = RegionServerReportResponse{} }
+func (m *RegionServerReportResponse) String() string            { return proto.CompactTextString(m) }
+func (*RegionServerReportResponse) ProtoMessage()               {}
+func (*RegionServerReportResponse) Descriptor() ([]byte, []int) { return fileDescriptor16, []int{3} }
+
+type ReportRSFatalErrorRequest struct {
+	// * name of the server experiencing the error
+	Server *ServerName `protobuf:"bytes,1,req,name=server" json:"server,omitempty"`
+	// * informative text to expose in the master logs and UI
+	ErrorMessage     *string `protobuf:"bytes,2,req,name=error_message,json=errorMessage" json:"error_message,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *ReportRSFatalErrorRequest) Reset()                    { *m = ReportRSFatalErrorRequest{} }
+func (m *ReportRSFatalErrorRequest) String() string            { return proto.CompactTextString(m) }
+func (*ReportRSFatalErrorRequest) ProtoMessage()               {}
+func (*ReportRSFatalErrorRequest) Descriptor() ([]byte, []int) { return fileDescriptor16, []int{4} }
+
+func (m *ReportRSFatalErrorRequest) GetServer() *ServerName {
+	if m != nil {
+		return m.Server
+	}
+	return nil
+}
+
+func (m *ReportRSFatalErrorRequest) GetErrorMessage() string {
+	if m != nil && m.ErrorMessage != nil {
+		return *m.ErrorMessage
+	}
+	return ""
+}
+
+type ReportRSFatalErrorResponse struct {
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *ReportRSFatalErrorResponse) Reset()                    { *m = ReportRSFatalErrorResponse{} }
+func (m *ReportRSFatalErrorResponse) String() string            { return proto.CompactTextString(m) }
+func (*ReportRSFatalErrorResponse) ProtoMessage()               {}
+func (*ReportRSFatalErrorResponse) Descriptor() ([]byte, []int) { return fileDescriptor16, []int{5} }
+
+type GetLastFlushedSequenceIdRequest struct {
+	// * region name
+	RegionName       []byte `protobuf:"bytes,1,req,name=region_name,json=regionName" json:"region_name,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *GetLastFlushedSequenceIdRequest) Reset()         { *m = GetLastFlushedSequenceIdRequest{} }
+func (m *GetLastFlushedSequenceIdRequest) String() string { return proto.CompactTextString(m) }
+func (*GetLastFlushedSequenceIdRequest) ProtoMessage()    {}
+func (*GetLastFlushedSequenceIdRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor16, []int{6}
+}
+
+func (m *GetLastFlushedSequenceIdRequest) GetRegionName() []byte {
+	if m != nil {
+		return m.RegionName
+	}
+	return nil
+}
+
+type GetLastFlushedSequenceIdResponse struct {
+	// * the last WAL sequence id flushed from MemStore to HFile for the region
+	LastFlushedSequenceId *uint64 `protobuf:"varint,1,req,name=last_flushed_sequence_id,json=lastFlushedSequenceId" json:"last_flushed_sequence_id,omitempty"`
+	// * the last WAL sequence id flushed from MemStore to HFile for stores of the region
+	StoreLastFlushedSequenceId []*StoreSequenceId `protobuf:"bytes,2,rep,name=store_last_flushed_sequence_id,json=storeLastFlushedSequenceId" json:"store_last_flushed_sequence_id,omitempty"`
+	XXX_unrecognized           []byte             `json:"-"`
+}
+
+func (m *GetLastFlushedSequenceIdResponse) Reset()         { *m = GetLastFlushedSequenceIdResponse{} }
+func (m *GetLastFlushedSequenceIdResponse) String() string { return proto.CompactTextString(m) }
+func (*GetLastFlushedSequenceIdResponse) ProtoMessage()    {}
+func (*GetLastFlushedSequenceIdResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor16, []int{7}
+}
+
+func (m *GetLastFlushedSequenceIdResponse) GetLastFlushedSequenceId() uint64 {
+	if m != nil && m.LastFlushedSequenceId != nil {
+		return *m.LastFlushedSequenceId
+	}
+	return 0
+}
+
+func (m *GetLastFlushedSequenceIdResponse) GetStoreLastFlushedSequenceId() []*StoreSequenceId {
+	if m != nil {
+		return m.StoreLastFlushedSequenceId
+	}
+	return nil
+}
+
+type RegionStateTransition struct {
+	TransitionCode *RegionStateTransition_TransitionCode `protobuf:"varint,1,req,name=transition_code,json=transitionCode,enum=pb.RegionStateTransition_TransitionCode" json:"transition_code,omitempty"`
+	// * Mutliple regions are involved during merging/splitting
+	RegionInfo []*RegionInfo `protobuf:"bytes,2,rep,name=region_info,json=regionInfo" json:"region_info,omitempty"`
+	// * For newly opened region, the open seq num is needed
+	OpenSeqNum       *uint64 `protobuf:"varint,3,opt,name=open_seq_num,json=openSeqNum" json:"open_seq_num,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *RegionStateTransition) Reset()                    { *m = RegionStateTransition{} }
+func (m *RegionStateTransition) String() string            { return proto.CompactTextString(m) }
+func (*RegionStateTransition) ProtoMessage()               {}
+func (*RegionStateTransition) Descriptor() ([]byte, []int) { return fileDescriptor16, []int{8} }
+
+func (m *RegionStateTransition) GetTransitionCode() RegionStateTransition_TransitionCode {
+	if m != nil && m.TransitionCode != nil {
+		return *m.TransitionCode
+	}
+	return RegionStateTransition_OPENED
+}
+
+func (m *RegionStateTransition) GetRegionInfo() []*RegionInfo {
+	if m != nil {
+		return m.RegionInfo
+	}
+	return nil
+}
+
+func (m *RegionStateTransition) GetOpenSeqNum() uint64 {
+	if m != nil && m.OpenSeqNum != nil {
+		return *m.OpenSeqNum
+	}
+	return 0
+}
+
+type ReportRegionStateTransitionRequest struct {
+	// * This region server's server name
+	Server           *ServerName              `protobuf:"bytes,1,req,name=server" json:"server,omitempty"`
+	Transition       []*RegionStateTransition `protobuf:"bytes,2,rep,name=transition" json:"transition,omitempty"`
+	XXX_unrecognized []byte                   `json:"-"`
+}
+
+func (m *ReportRegionStateTransitionRequest) Reset()         { *m = ReportRegionStateTransitionRequest{} }
+func (m *ReportRegionStateTransitionRequest) String() string { return proto.CompactTextString(m) }
+func (*ReportRegionStateTransitionRequest) ProtoMessage()    {}
+func (*ReportRegionStateTransitionRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor16, []int{9}
+}
+
+func (m *ReportRegionStateTransitionRequest) GetServer() *ServerName {
+	if m != nil {
+		return m.Server
+	}
+	return nil
+}
+
+func (m *ReportRegionStateTransitionRequest) GetTransition() []*RegionStateTransition {
+	if m != nil {
+		return m.Transition
+	}
+	return nil
+}
+
+type ReportRegionStateTransitionResponse struct {
+	// * Error message if failed to update the region state
+	ErrorMessage     *string `protobuf:"bytes,1,opt,name=error_message,json=errorMessage" json:"error_message,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *ReportRegionStateTransitionResponse) Reset()         { *m = ReportRegionStateTransitionResponse{} }
+func (m *ReportRegionStateTransitionResponse) String() string { return proto.CompactTextString(m) }
+func (*ReportRegionStateTransitionResponse) ProtoMessage()    {}
+func (*ReportRegionStateTransitionResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor16, []int{10}
+}
+
+func (m *ReportRegionStateTransitionResponse) GetErrorMessage() string {
+	if m != nil && m.ErrorMessage != nil {
+		return *m.ErrorMessage
+	}
+	return ""
+}
+
+func init() {
+	proto.RegisterType((*RegionServerStartupRequest)(nil), "pb.RegionServerStartupRequest")
+	proto.RegisterType((*RegionServerStartupResponse)(nil), "pb.RegionServerStartupResponse")
+	proto.RegisterType((*RegionServerReportRequest)(nil), "pb.RegionServerReportRequest")
+	proto.RegisterType((*RegionServerReportResponse)(nil), "pb.RegionServerReportResponse")
+	proto.RegisterType((*ReportRSFatalErrorRequest)(nil), "pb.ReportRSFatalErrorRequest")
+	proto.RegisterType((*ReportRSFatalErrorResponse)(nil), "pb.ReportRSFatalErrorResponse")
+	proto.RegisterType((*GetLastFlushedSequenceIdRequest)(nil), "pb.GetLastFlushedSequenceIdRequest")
+	proto.RegisterType((*GetLastFlushedSequenceIdResponse)(nil), "pb.GetLastFlushedSequenceIdResponse")
+	proto.RegisterType((*RegionStateTransition)(nil), "pb.RegionStateTransition")
+	proto.RegisterType((*ReportRegionStateTransitionRequest)(nil), "pb.ReportRegionStateTransitionRequest")
+	proto.RegisterType((*ReportRegionStateTransitionResponse)(nil), "pb.ReportRegionStateTransitionResponse")
+	proto.RegisterEnum("pb.RegionStateTransition_TransitionCode", RegionStateTransition_TransitionCode_name, RegionStateTransition_TransitionCode_value)
+}
+
+func init() { proto.RegisterFile("RegionServerStatus.proto", fileDescriptor16) }
+
+var fileDescriptor16 = []byte{
+	// 842 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x55, 0xc1, 0x6e, 0xdb, 0x46,
+	0x10, 0x2d, 0x25, 0xc5, 0xad, 0x47, 0x8e, 0xac, 0xae, 0x91, 0x82, 0x56, 0x5b, 0x5b, 0xa0, 0x8b,
+	0x54, 0xc8, 0x81, 0x05, 0xdc, 0x43, 0x91, 0x63, 0x6c, 0xd1, 0xb1, 0x0a, 0x45, 0x56, 0x97, 0x42,
+	0x8a, 0x9e, 0x16, 0x6b, 0x71, 0x2c, 0x11, 0x10, 0xb9, 0xcc, 0xee, 0xb2, 0xe7, 0xde, 0xda, 0xcf,
+	0xe8, 0x47, 0xf4, 0x03, 0x7a, 0xeb, 0x0f, 0xf5, 0x03, 0x82, 0xe5, 0x52, 0xb6, 0x68, 0x8b, 0x0e,
+	0x7c, 0xdb, 0x9d, 0x79, 0xf3, 0xe6, 0xed, 0x0c, 0x67, 0x08, 0x2e, 0xc5, 0x45, 0x2c, 0xd2, 0x10,
+	0xe5, 0xef, 0x28, 0x43, 0xcd, 0x75, 0xae, 0xfc, 0x4c, 0x0a, 0x2d, 0x48, 0x23, 0xbb, 0xee, 0xb5,
+	0x2f, 0xcf, 0xb8, 0x42, 0x6b, 0xe8, 0x1d, 0x9c, 0xaf, 0x72, 0xa5, 0xab, 0x28, 0xef, 0x3f, 0x07,
+	0x7a, 0xf7, 0x28, 0xa4, 0xce, 0x33, 0x8a, 0x1f, 0x72, 0x54, 0x9a, 0x10, 0x68, 0x65, 0x42, 0x6a,
+	0xd7, 0xe9, 0x37, 0x06, 0xcf, 0x69, 0x71, 0x26, 0xaf, 0xe0, 0x4b, 0x55, 0x60, 0x99, 0x32, 0x60,
+	0x36, 0x17, 0x11, 0xba, 0x8d, 0x7e, 0x63, 0xd0, 0xa2, 0xfb, 0xea, 0x8e, 0xe4, 0x5c, 0x44, 0x48,
+	0x7c, 0x38, 0x28, 0xb1, 0xf3, 0x5c, 0x4a, 0x4c, 0x35, 0xd3, 0x71, 0x82, 0x6e, 0xb3, 0x40, 0x97,
+	0x34, 0xe7, 0xd6, 0x33, 0x8b, 0x13, 0x24, 0xaf, 0xe1, 0x30, 0x57, 0xc8, 0xf4, 0x32, 0x56, 0x6c,
+	0x29, 0x94, 0x4e, 0x79, 0x82, 0x2c, 0x4e, 0x95, 0x46, 0x1e, 0xb9, 0xad, 0xbe, 0x33, 0xd8, 0xa5,
+	0x5f, 0xe5, 0x0a, 0x67, 0xcb, 0x58, 0x5d, 0x96, 0xee, 0x91, 0xf5, 0x7a, 0x14, 0xbe, 0xde, 0xfa,
+	0x10, 0x95, 0x89, 0x54, 0x21, 0xf9, 0x11, 0xda, 0x09, 0xcf, 0x18, 0xa6, 0x5a, 0xc6, 0xa8, 0x5c,
+	0xa7, 0xdf, 0x1c, 0xb4, 0x4f, 0x89, 0x9f, 0x5d, 0xfb, 0x13, 0x9e, 0x60, 0xa8, 0x65, 0x9c, 0x2e,
+	0xa6, 0x3c, 0x96, 0x14, 0x12, 0x9e, 0x05, 0x16, 0xe5, 0x2d, 0xe0, 0x70, 0x93, 0x93, 0xa2, 0x29,
+	0xc0, 0xba, 0x36, 0x2f, 0x61, 0xc7, 0x3e, 0xa0, 0xa8, 0x4e, 0xfb, 0xb4, 0x63, 0xc8, 0x2c, 0xd0,
+	0x50, 0xd2, 0xd2, 0x4b, 0x3c, 0x68, 0xad, 0x04, 0x8f, 0xdc, 0x46, 0xdf, 0xa9, 0xa2, 0xc6, 0x82,
+	0x47, 0xb4, 0xf0, 0x79, 0xdf, 0x54, 0xbb, 0xb0, 0x4e, 0x64, 0xb5, 0x7b, 0x4b, 0x23, 0xa3, 0xb0,
+	0x84, 0x17, 0x5c, 0xf3, 0x55, 0x20, 0xa5, 0x90, 0x4f, 0x95, 0x71, 0x02, 0xcf, 0xd1, 0xc4, 0xb1,
+	0x04, 0x95, 0xe2, 0x0b, 0xdb, 0xb2, 0x5d, 0xba, 0x57, 0x18, 0xdf, 0x59, 0x9b, 0xd5, 0xf1, 0x30,
+	0x53, 0xa9, 0xe3, 0x0c, 0x8e, 0xdf, 0xa2, 0x1e, 0x73, 0xa5, 0x2f, 0x56, 0xb9, 0x5a, 0x62, 0x14,
+	0x1a, 0x0d, 0xe9, 0x1c, 0x47, 0xd1, 0x5a, 0xcd, 0x31, 0xb4, 0x65, 0xf1, 0x10, 0x66, 0x7a, 0x53,
+	0x48, 0xda, 0xa3, 0x60, 0x4d, 0x46, 0x8e, 0xf7, 0x8f, 0x03, 0xfd, 0x7a, 0x92, 0xb2, 0x59, 0x3f,
+	0x81, 0xbb, 0xe2, 0x4a, 0xb3, 0x1b, 0x8b, 0x60, 0xaa, 0x84, 0xb0, 0x38, 0x2a, 0x28, 0x5b, 0xf4,
+	0xc5, 0x6a, 0x1b, 0x01, 0xf9, 0x15, 0x8e, 0x94, 0x16, 0x12, 0x59, 0x6d, 0x78, 0xa3, 0x68, 0xfc,
+	0x41, 0x51, 0x24, 0x83, 0xdc, 0xc8, 0xde, 0x2b, 0x42, 0xb7, 0x2a, 0xf3, 0xfe, 0x68, 0xc2, 0x8b,
+	0xb2, 0x43, 0x9a, 0x6b, 0x9c, 0x49, 0x9e, 0xaa, 0x58, 0xc7, 0x22, 0x25, 0xbf, 0xc0, 0xbe, 0xbe,
+	0xbd, 0xd9, 0x61, 0x30, 0x12, 0x3b, 0xa7, 0x03, 0x93, 0x63, 0x6b, 0x8c, 0x7f, 0x77, 0x34, 0x53,
+	0x42, 0x3b, 0xba, 0x72, 0x27, 0x3f, 0xdc, 0x16, 0x31, 0x4e, 0x6f, 0x44, 0x29, 0xb9, 0x73, 0x47,
+	0x37, 0x4a, 0x6f, 0xc4, 0xba, 0xa8, 0xe6, 0x4c, 0xfa, 0xb0, 0x27, 0x32, 0x4c, 0xcd, 0x43, 0x59,
+	0x9a, 0x27, 0x6e, 0xb3, 0xef, 0x0c, 0x5a, 0x14, 0x8c, 0x2d, 0xc4, 0x0f, 0x93, 0x3c, 0xf1, 0xfe,
+	0x75, 0xa0, 0x53, 0xcd, 0x4a, 0x00, 0x76, 0xae, 0xa6, 0xc1, 0x24, 0x18, 0x76, 0x3f, 0x23, 0xfb,
+	0xd0, 0xbe, 0x78, 0x33, 0x1a, 0x07, 0x43, 0x66, 0x4c, 0x5d, 0xc7, 0x38, 0xcf, 0xc7, 0x57, 0x61,
+	0x30, 0xec, 0x36, 0x08, 0x81, 0x0e, 0x0d, 0xde, 0x0c, 0x7f, 0x63, 0xb3, 0x2b, 0x16, 0x4e, 0xc7,
+	0xa3, 0x59, 0xb7, 0x59, 0xb1, 0xbd, 0x0b, 0xe8, 0xdb, 0xa0, 0xdb, 0x22, 0x1d, 0x80, 0xc2, 0xcd,
+	0xa6, 0x57, 0x13, 0xda, 0x7d, 0x66, 0xee, 0x85, 0xcb, 0xde, 0x77, 0xc8, 0x2e, 0x3c, 0xb3, 0xe1,
+	0x9f, 0x1b, 0xfa, 0xc2, 0x35, 0xec, 0x7e, 0x61, 0xa8, 0x6c, 0x18, 0x0d, 0xde, 0x07, 0x74, 0x16,
+	0x0c, 0xbb, 0xbb, 0xc6, 0x66, 0x43, 0x6f, 0x6d, 0xe0, 0xfd, 0xe9, 0x80, 0xb7, 0x1e, 0x8c, 0x2d,
+	0x45, 0x7d, 0xea, 0x3c, 0xbc, 0x06, 0xb8, 0x2b, 0x7b, 0x59, 0xe3, 0xc3, 0xda, 0x96, 0xd1, 0x0d,
+	0xb0, 0xf7, 0x33, 0x9c, 0x3c, 0x2a, 0xa4, 0xfc, 0x8a, 0x1f, 0x4c, 0x9c, 0x53, 0x2c, 0xb0, 0xca,
+	0xc4, 0x9d, 0xfe, 0xdf, 0xac, 0xee, 0x18, 0xbb, 0x9d, 0xcd, 0x39, 0x9e, 0x23, 0x79, 0x0f, 0x07,
+	0x5b, 0x96, 0x1a, 0x39, 0xda, 0xd0, 0xb9, 0x65, 0x6d, 0xf7, 0x8e, 0x6b, 0xfd, 0xa5, 0xb4, 0x10,
+	0xc8, 0xc3, 0x7d, 0x43, 0xbe, 0xbd, 0x1f, 0x56, 0x59, 0x78, 0xbd, 0xa3, 0x3a, 0xf7, 0x26, 0xe9,
+	0xfd, 0xe5, 0xb1, 0x26, 0xad, 0x59, 0x5f, 0x6b, 0xd2, 0xba, 0x9d, 0x43, 0x10, 0xdc, 0xba, 0x75,
+	0x41, 0x4e, 0x4c, 0xec, 0x27, 0x36, 0x52, 0xef, 0xbb, 0xc7, 0x41, 0x65, 0x9a, 0xd4, 0xfc, 0x3d,
+	0x6a, 0x5b, 0x4a, 0x5e, 0x6e, 0xa8, 0x7c, 0xe4, 0xe3, 0xeb, 0x7d, 0xff, 0x49, 0x9c, 0xcd, 0x77,
+	0x36, 0x81, 0x57, 0x42, 0x2e, 0x7c, 0x9e, 0xf1, 0xf9, 0x12, 0xfd, 0x25, 0x8f, 0x84, 0xc8, 0xfc,
+	0xe5, 0xf5, 0xed, 0xdf, 0xfa, 0x3a, 0xbf, 0xf1, 0x17, 0x98, 0xa2, 0xe4, 0x1a, 0xa3, 0xb3, 0x2d,
+	0x7f, 0xf9, 0xa9, 0x41, 0xa9, 0x4b, 0xe7, 0x2f, 0xc7, 0xf9, 0xdb, 0x71, 0x3e, 0x06, 0x00, 0x00,
+	0xff, 0xff, 0x12, 0x1f, 0xbe, 0x69, 0x08, 0x08, 0x00, 0x00,
+}

vendor/github.com/tsuna/gohbase/pb/RegionServerStatus.proto

@@ -0,0 +1,158 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// This file contains protocol buffers that are used for RegionServerStatusProtocol.
+package pb;
+
+option java_package = "org.apache.hadoop.hbase.protobuf.generated";
+option java_outer_classname = "RegionServerStatusProtos";
+option java_generic_services = true;
+option java_generate_equals_and_hash = true;
+option optimize_for = SPEED;
+
+import "HBase.proto";
+import "ClusterStatus.proto";
+
+message RegionServerStartupRequest {
+  /** Port number this regionserver is up on */
+  required uint32 port = 1;
+
+  /** This servers' startcode */
+  required uint64 server_start_code = 2;
+
+  /** Current time of the region server in ms */
+  required uint64 server_current_time = 3;
+
+  /** hostname for region server, optional */
+  optional string use_this_hostname_instead = 4;
+}
+
+message RegionServerStartupResponse {
+  /**
+   * Configuration for the regionserver to use: e.g. filesystem,
+   * hbase rootdir, the hostname to use creating the RegionServer ServerName,
+   * etc
+   */
+  repeated NameStringPair map_entries = 1;
+}
+
+message RegionServerReportRequest {
+  required ServerName server = 1;
+
+  /** load the server is under */
+  optional ServerLoad load = 2;
+}
+
+message RegionServerReportResponse {
+}
+
+message ReportRSFatalErrorRequest {
+  /** name of the server experiencing the error */
+  required ServerName server = 1;
+
+  /** informative text to expose in the master logs and UI */
+  required string error_message = 2;
+}
+
+message ReportRSFatalErrorResponse {
+}
+
+message GetLastFlushedSequenceIdRequest {
+  /** region name */
+  required bytes region_name = 1;
+}
+
+message GetLastFlushedSequenceIdResponse {
+  /** the last WAL sequence id flushed from MemStore to HFile for the region */
+  required uint64 last_flushed_sequence_id = 1;
+
+  /** the last WAL sequence id flushed from MemStore to HFile for stores of the region */
+  repeated StoreSequenceId store_last_flushed_sequence_id = 2;
+}
+
+message RegionStateTransition {
+  required TransitionCode transition_code = 1;
+
+  /** Mutliple regions are involved during merging/splitting */
+  repeated RegionInfo region_info = 2;
+
+  /** For newly opened region, the open seq num is needed */
+  optional uint64 open_seq_num = 3;
+
+  enum TransitionCode {
+    OPENED = 0;
+    FAILED_OPEN = 1;
+    /** No failed_close, in which case region server will abort */
+    CLOSED = 2;
+
+    /** Ask master for ok to split/merge region(s) */
+    READY_TO_SPLIT = 3;
+    READY_TO_MERGE = 4;
+
+    SPLIT_PONR = 5;
+    MERGE_PONR = 6;
+
+    SPLIT = 7;
+    MERGED = 8;
+    SPLIT_REVERTED = 9;
+    MERGE_REVERTED = 10;
+  }
+}
+
+message ReportRegionStateTransitionRequest {
+  /** This region server's server name */
+  required ServerName server = 1;
+
+  repeated RegionStateTransition transition = 2;
+}
+
+message ReportRegionStateTransitionResponse {
+  /** Error message if failed to update the region state */
+  optional string error_message = 1;
+}
+
+service RegionServerStatusService {
+  /** Called when a region server first starts. */
+  rpc RegionServerStartup(RegionServerStartupRequest)
+    returns(RegionServerStartupResponse);
+
+  /** Called to report the load the RegionServer is under. */
+  rpc RegionServerReport(RegionServerReportRequest)
+    returns(RegionServerReportResponse);
+
+  /**
+   * Called by a region server to report a fatal error that is causing it to
+   * abort.
+   */
+  rpc ReportRSFatalError(ReportRSFatalErrorRequest)
+    returns(ReportRSFatalErrorResponse);
+
+  /** Called to get the sequence id of the last MemStore entry flushed to an
+   * HFile for a specified region. Used by the region server to speed up
+   * log splitting. */
+  rpc GetLastFlushedSequenceId(GetLastFlushedSequenceIdRequest)
+    returns(GetLastFlushedSequenceIdResponse);
+
+  /**
+   * Called by a region server to report the progress of a region
+   * transition. If the request fails, the transition should
+   * be aborted.
+   */
+  rpc ReportRegionStateTransition(ReportRegionStateTransitionRequest)
+    returns(ReportRegionStateTransitionResponse);
+}

vendor/github.com/tsuna/gohbase/pb/Tracing.pb.go

@@ -0,0 +1,63 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: Tracing.proto
+
+package pb
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// Used to pass through the information necessary to continue
+// a trace after an RPC is made. All we need is the traceid
+// (so we know the overarching trace this message is a part of), and
+// the id of the current span when this message was sent, so we know
+// what span caused the new span we will create when this message is received.
+type RPCTInfo struct {
+	TraceId          *int64 `protobuf:"varint,1,opt,name=trace_id,json=traceId" json:"trace_id,omitempty"`
+	ParentId         *int64 `protobuf:"varint,2,opt,name=parent_id,json=parentId" json:"parent_id,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *RPCTInfo) Reset()                    { *m = RPCTInfo{} }
+func (m *RPCTInfo) String() string            { return proto.CompactTextString(m) }
+func (*RPCTInfo) ProtoMessage()               {}
+func (*RPCTInfo) Descriptor() ([]byte, []int) { return fileDescriptor17, []int{0} }
+
+func (m *RPCTInfo) GetTraceId() int64 {
+	if m != nil && m.TraceId != nil {
+		return *m.TraceId
+	}
+	return 0
+}
+
+func (m *RPCTInfo) GetParentId() int64 {
+	if m != nil && m.ParentId != nil {
+		return *m.ParentId
+	}
+	return 0
+}
+
+func init() {
+	proto.RegisterType((*RPCTInfo)(nil), "pb.RPCTInfo")
+}
+
+func init() { proto.RegisterFile("Tracing.proto", fileDescriptor17) }
+
+var fileDescriptor17 = []byte{
+	// 153 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x0d, 0x29, 0x4a, 0x4c,
+	0xce, 0xcc, 0x4b, 0xd7, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x2a, 0x48, 0x52, 0x72, 0xe2,
+	0xe2, 0x08, 0x0a, 0x70, 0x0e, 0xf1, 0xcc, 0x4b, 0xcb, 0x17, 0x92, 0xe4, 0xe2, 0x28, 0x29, 0x4a,
+	0x4c, 0x4e, 0x8d, 0xcf, 0x4c, 0x91, 0x60, 0x54, 0x60, 0xd4, 0x60, 0x0e, 0x62, 0x07, 0xf3, 0x3d,
+	0x53, 0x84, 0xa4, 0xb9, 0x38, 0x0b, 0x12, 0x8b, 0x52, 0xf3, 0x4a, 0x40, 0x72, 0x4c, 0x60, 0x39,
+	0x0e, 0x88, 0x80, 0x67, 0x8a, 0x93, 0x03, 0x97, 0x56, 0x7e, 0x51, 0xba, 0x5e, 0x62, 0x41, 0x62,
+	0x72, 0x46, 0xaa, 0x5e, 0x46, 0x62, 0x4a, 0x7e, 0x7e, 0x81, 0x5e, 0x46, 0x52, 0x62, 0x71, 0x2a,
+	0xc4, 0xa2, 0xa4, 0xd2, 0x34, 0xbd, 0xf4, 0xd4, 0xbc, 0xd4, 0xa2, 0xc4, 0x92, 0xd4, 0x14, 0x27,
+	0x98, 0x23, 0x02, 0x40, 0x52, 0xc5, 0x1e, 0x8c, 0x0b, 0x18, 0x19, 0x01, 0x01, 0x00, 0x00, 0xff,
+	0xff, 0x4f, 0x30, 0xae, 0x8e, 0x99, 0x00, 0x00, 0x00,
+}

vendor/github.com/tsuna/gohbase/pb/Tracing.proto

@@ -0,0 +1,33 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package pb;
+
+option java_package = "org.apache.hadoop.hbase.protobuf.generated";
+option java_outer_classname = "TracingProtos";
+option java_generate_equals_and_hash = true;
+option optimize_for = SPEED;
+
+//Used to pass through the information necessary to continue
+//a trace after an RPC is made. All we need is the traceid 
+//(so we know the overarching trace this message is a part of), and
+//the id of the current span when this message was sent, so we know 
+//what span caused the new span we will create when this message is received.
+message RPCTInfo {
+  optional int64 trace_id = 1;
+  optional int64 parent_id = 2;
+}

vendor/github.com/tsuna/gohbase/pb/WAL.pb.go

@@ -0,0 +1,727 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: WAL.proto
+
+package pb
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+type ScopeType int32
+
+const (
+	ScopeType_REPLICATION_SCOPE_LOCAL  ScopeType = 0
+	ScopeType_REPLICATION_SCOPE_GLOBAL ScopeType = 1
+)
+
+var ScopeType_name = map[int32]string{
+	0: "REPLICATION_SCOPE_LOCAL",
+	1: "REPLICATION_SCOPE_GLOBAL",
+}
+var ScopeType_value = map[string]int32{
+	"REPLICATION_SCOPE_LOCAL":  0,
+	"REPLICATION_SCOPE_GLOBAL": 1,
+}
+
+func (x ScopeType) Enum() *ScopeType {
+	p := new(ScopeType)
+	*p = x
+	return p
+}
+func (x ScopeType) String() string {
+	return proto.EnumName(ScopeType_name, int32(x))
+}
+func (x *ScopeType) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(ScopeType_value, data, "ScopeType")
+	if err != nil {
+		return err
+	}
+	*x = ScopeType(value)
+	return nil
+}
+func (ScopeType) EnumDescriptor() ([]byte, []int) { return fileDescriptor18, []int{0} }
+
+type FlushDescriptor_FlushAction int32
+
+const (
+	FlushDescriptor_START_FLUSH  FlushDescriptor_FlushAction = 0
+	FlushDescriptor_COMMIT_FLUSH FlushDescriptor_FlushAction = 1
+	FlushDescriptor_ABORT_FLUSH  FlushDescriptor_FlushAction = 2
+	FlushDescriptor_CANNOT_FLUSH FlushDescriptor_FlushAction = 3
+)
+
+var FlushDescriptor_FlushAction_name = map[int32]string{
+	0: "START_FLUSH",
+	1: "COMMIT_FLUSH",
+	2: "ABORT_FLUSH",
+	3: "CANNOT_FLUSH",
+}
+var FlushDescriptor_FlushAction_value = map[string]int32{
+	"START_FLUSH":  0,
+	"COMMIT_FLUSH": 1,
+	"ABORT_FLUSH":  2,
+	"CANNOT_FLUSH": 3,
+}
+
+func (x FlushDescriptor_FlushAction) Enum() *FlushDescriptor_FlushAction {
+	p := new(FlushDescriptor_FlushAction)
+	*p = x
+	return p
+}
+func (x FlushDescriptor_FlushAction) String() string {
+	return proto.EnumName(FlushDescriptor_FlushAction_name, int32(x))
+}
+func (x *FlushDescriptor_FlushAction) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(FlushDescriptor_FlushAction_value, data, "FlushDescriptor_FlushAction")
+	if err != nil {
+		return err
+	}
+	*x = FlushDescriptor_FlushAction(value)
+	return nil
+}
+func (FlushDescriptor_FlushAction) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor18, []int{4, 0}
+}
+
+type RegionEventDescriptor_EventType int32
+
+const (
+	RegionEventDescriptor_REGION_OPEN  RegionEventDescriptor_EventType = 0
+	RegionEventDescriptor_REGION_CLOSE RegionEventDescriptor_EventType = 1
+)
+
+var RegionEventDescriptor_EventType_name = map[int32]string{
+	0: "REGION_OPEN",
+	1: "REGION_CLOSE",
+}
+var RegionEventDescriptor_EventType_value = map[string]int32{
+	"REGION_OPEN":  0,
+	"REGION_CLOSE": 1,
+}
+
+func (x RegionEventDescriptor_EventType) Enum() *RegionEventDescriptor_EventType {
+	p := new(RegionEventDescriptor_EventType)
+	*p = x
+	return p
+}
+func (x RegionEventDescriptor_EventType) String() string {
+	return proto.EnumName(RegionEventDescriptor_EventType_name, int32(x))
+}
+func (x *RegionEventDescriptor_EventType) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(RegionEventDescriptor_EventType_value, data, "RegionEventDescriptor_EventType")
+	if err != nil {
+		return err
+	}
+	*x = RegionEventDescriptor_EventType(value)
+	return nil
+}
+func (RegionEventDescriptor_EventType) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor18, []int{7, 0}
+}
+
+type WALHeader struct {
+	HasCompression    *bool   `protobuf:"varint,1,opt,name=has_compression,json=hasCompression" json:"has_compression,omitempty"`
+	EncryptionKey     []byte  `protobuf:"bytes,2,opt,name=encryption_key,json=encryptionKey" json:"encryption_key,omitempty"`
+	HasTagCompression *bool   `protobuf:"varint,3,opt,name=has_tag_compression,json=hasTagCompression" json:"has_tag_compression,omitempty"`
+	WriterClsName     *string `protobuf:"bytes,4,opt,name=writer_cls_name,json=writerClsName" json:"writer_cls_name,omitempty"`
+	CellCodecClsName  *string `protobuf:"bytes,5,opt,name=cell_codec_cls_name,json=cellCodecClsName" json:"cell_codec_cls_name,omitempty"`
+	XXX_unrecognized  []byte  `json:"-"`
+}
+
+func (m *WALHeader) Reset()                    { *m = WALHeader{} }
+func (m *WALHeader) String() string            { return proto.CompactTextString(m) }
+func (*WALHeader) ProtoMessage()               {}
+func (*WALHeader) Descriptor() ([]byte, []int) { return fileDescriptor18, []int{0} }
+
+func (m *WALHeader) GetHasCompression() bool {
+	if m != nil && m.HasCompression != nil {
+		return *m.HasCompression
+	}
+	return false
+}
+
+func (m *WALHeader) GetEncryptionKey() []byte {
+	if m != nil {
+		return m.EncryptionKey
+	}
+	return nil
+}
+
+func (m *WALHeader) GetHasTagCompression() bool {
+	if m != nil && m.HasTagCompression != nil {
+		return *m.HasTagCompression
+	}
+	return false
+}
+
+func (m *WALHeader) GetWriterClsName() string {
+	if m != nil && m.WriterClsName != nil {
+		return *m.WriterClsName
+	}
+	return ""
+}
+
+func (m *WALHeader) GetCellCodecClsName() string {
+	if m != nil && m.CellCodecClsName != nil {
+		return *m.CellCodecClsName
+	}
+	return ""
+}
+
+//
+// Protocol buffer version of WALKey; see WALKey comment, not really a key but WALEdit header
+// for some KVs
+type WALKey struct {
+	EncodedRegionName []byte  `protobuf:"bytes,1,req,name=encoded_region_name,json=encodedRegionName" json:"encoded_region_name,omitempty"`
+	TableName         []byte  `protobuf:"bytes,2,req,name=table_name,json=tableName" json:"table_name,omitempty"`
+	LogSequenceNumber *uint64 `protobuf:"varint,3,req,name=log_sequence_number,json=logSequenceNumber" json:"log_sequence_number,omitempty"`
+	WriteTime         *uint64 `protobuf:"varint,4,req,name=write_time,json=writeTime" json:"write_time,omitempty"`
+	//
+	// This parameter is deprecated in favor of clusters which
+	// contains the list of clusters that have consumed the change.
+	// It is retained so that the log created by earlier releases (0.94)
+	// can be read by the newer releases.
+	ClusterId        *UUID          `protobuf:"bytes,5,opt,name=cluster_id,json=clusterId" json:"cluster_id,omitempty"`
+	Scopes           []*FamilyScope `protobuf:"bytes,6,rep,name=scopes" json:"scopes,omitempty"`
+	FollowingKvCount *uint32        `protobuf:"varint,7,opt,name=following_kv_count,json=followingKvCount" json:"following_kv_count,omitempty"`
+	//
+	// This field contains the list of clusters that have
+	// consumed the change
+	ClusterIds         []*UUID `protobuf:"bytes,8,rep,name=cluster_ids,json=clusterIds" json:"cluster_ids,omitempty"`
+	NonceGroup         *uint64 `protobuf:"varint,9,opt,name=nonceGroup" json:"nonceGroup,omitempty"`
+	Nonce              *uint64 `protobuf:"varint,10,opt,name=nonce" json:"nonce,omitempty"`
+	OrigSequenceNumber *uint64 `protobuf:"varint,11,opt,name=orig_sequence_number,json=origSequenceNumber" json:"orig_sequence_number,omitempty"`
+	XXX_unrecognized   []byte  `json:"-"`
+}
+
+func (m *WALKey) Reset()                    { *m = WALKey{} }
+func (m *WALKey) String() string            { return proto.CompactTextString(m) }
+func (*WALKey) ProtoMessage()               {}
+func (*WALKey) Descriptor() ([]byte, []int) { return fileDescriptor18, []int{1} }
+
+func (m *WALKey) GetEncodedRegionName() []byte {
+	if m != nil {
+		return m.EncodedRegionName
+	}
+	return nil
+}
+
+func (m *WALKey) GetTableName() []byte {
+	if m != nil {
+		return m.TableName
+	}
+	return nil
+}
+
+func (m *WALKey) GetLogSequenceNumber() uint64 {
+	if m != nil && m.LogSequenceNumber != nil {
+		return *m.LogSequenceNumber
+	}
+	return 0
+}
+
+func (m *WALKey) GetWriteTime() uint64 {
+	if m != nil && m.WriteTime != nil {
+		return *m.WriteTime
+	}
+	return 0
+}
+
+func (m *WALKey) GetClusterId() *UUID {
+	if m != nil {
+		return m.ClusterId
+	}
+	return nil
+}
+
+func (m *WALKey) GetScopes() []*FamilyScope {
+	if m != nil {
+		return m.Scopes
+	}
+	return nil
+}
+
+func (m *WALKey) GetFollowingKvCount() uint32 {
+	if m != nil && m.FollowingKvCount != nil {
+		return *m.FollowingKvCount
+	}
+	return 0
+}
+
+func (m *WALKey) GetClusterIds() []*UUID {
+	if m != nil {
+		return m.ClusterIds
+	}
+	return nil
+}
+
+func (m *WALKey) GetNonceGroup() uint64 {
+	if m != nil && m.NonceGroup != nil {
+		return *m.NonceGroup
+	}
+	return 0
+}
+
+func (m *WALKey) GetNonce() uint64 {
+	if m != nil && m.Nonce != nil {
+		return *m.Nonce
+	}
+	return 0
+}
+
+func (m *WALKey) GetOrigSequenceNumber() uint64 {
+	if m != nil && m.OrigSequenceNumber != nil {
+		return *m.OrigSequenceNumber
+	}
+	return 0
+}
+
+type FamilyScope struct {
+	Family           []byte     `protobuf:"bytes,1,req,name=family" json:"family,omitempty"`
+	ScopeType        *ScopeType `protobuf:"varint,2,req,name=scope_type,json=scopeType,enum=pb.ScopeType" json:"scope_type,omitempty"`
+	XXX_unrecognized []byte     `json:"-"`
+}
+
+func (m *FamilyScope) Reset()                    { *m = FamilyScope{} }
+func (m *FamilyScope) String() string            { return proto.CompactTextString(m) }
+func (*FamilyScope) ProtoMessage()               {}
+func (*FamilyScope) Descriptor() ([]byte, []int) { return fileDescriptor18, []int{2} }
+
+func (m *FamilyScope) GetFamily() []byte {
+	if m != nil {
+		return m.Family
+	}
+	return nil
+}
+
+func (m *FamilyScope) GetScopeType() ScopeType {
+	if m != nil && m.ScopeType != nil {
+		return *m.ScopeType
+	}
+	return ScopeType_REPLICATION_SCOPE_LOCAL
+}
+
+// *
+// Special WAL entry to hold all related to a compaction.
+// Written to WAL before completing compaction.  There is
+// sufficient info in the below message to complete later
+// the * compaction should we fail the WAL write.
+type CompactionDescriptor struct {
+	TableName         []byte   `protobuf:"bytes,1,req,name=table_name,json=tableName" json:"table_name,omitempty"`
+	EncodedRegionName []byte   `protobuf:"bytes,2,req,name=encoded_region_name,json=encodedRegionName" json:"encoded_region_name,omitempty"`
+	FamilyName        []byte   `protobuf:"bytes,3,req,name=family_name,json=familyName" json:"family_name,omitempty"`
+	CompactionInput   []string `protobuf:"bytes,4,rep,name=compaction_input,json=compactionInput" json:"compaction_input,omitempty"`
+	CompactionOutput  []string `protobuf:"bytes,5,rep,name=compaction_output,json=compactionOutput" json:"compaction_output,omitempty"`
+	StoreHomeDir      *string  `protobuf:"bytes,6,req,name=store_home_dir,json=storeHomeDir" json:"store_home_dir,omitempty"`
+	RegionName        []byte   `protobuf:"bytes,7,opt,name=region_name,json=regionName" json:"region_name,omitempty"`
+	XXX_unrecognized  []byte   `json:"-"`
+}
+
+func (m *CompactionDescriptor) Reset()                    { *m = CompactionDescriptor{} }
+func (m *CompactionDescriptor) String() string            { return proto.CompactTextString(m) }
+func (*CompactionDescriptor) ProtoMessage()               {}
+func (*CompactionDescriptor) Descriptor() ([]byte, []int) { return fileDescriptor18, []int{3} }
+
+func (m *CompactionDescriptor) GetTableName() []byte {
+	if m != nil {
+		return m.TableName
+	}
+	return nil
+}
+
+func (m *CompactionDescriptor) GetEncodedRegionName() []byte {
+	if m != nil {
+		return m.EncodedRegionName
+	}
+	return nil
+}
+
+func (m *CompactionDescriptor) GetFamilyName() []byte {
+	if m != nil {
+		return m.FamilyName
+	}
+	return nil
+}
+
+func (m *CompactionDescriptor) GetCompactionInput() []string {
+	if m != nil {
+		return m.CompactionInput
+	}
+	return nil
+}
+
+func (m *CompactionDescriptor) GetCompactionOutput() []string {
+	if m != nil {
+		return m.CompactionOutput
+	}
+	return nil
+}
+
+func (m *CompactionDescriptor) GetStoreHomeDir() string {
+	if m != nil && m.StoreHomeDir != nil {
+		return *m.StoreHomeDir
+	}
+	return ""
+}
+
+func (m *CompactionDescriptor) GetRegionName() []byte {
+	if m != nil {
+		return m.RegionName
+	}
+	return nil
+}
+
+// *
+// Special WAL entry to hold all related to a flush.
+type FlushDescriptor struct {
+	Action              *FlushDescriptor_FlushAction            `protobuf:"varint,1,req,name=action,enum=pb.FlushDescriptor_FlushAction" json:"action,omitempty"`
+	TableName           []byte                                  `protobuf:"bytes,2,req,name=table_name,json=tableName" json:"table_name,omitempty"`
+	EncodedRegionName   []byte                                  `protobuf:"bytes,3,req,name=encoded_region_name,json=encodedRegionName" json:"encoded_region_name,omitempty"`
+	FlushSequenceNumber *uint64                                 `protobuf:"varint,4,opt,name=flush_sequence_number,json=flushSequenceNumber" json:"flush_sequence_number,omitempty"`
+	StoreFlushes        []*FlushDescriptor_StoreFlushDescriptor `protobuf:"bytes,5,rep,name=store_flushes,json=storeFlushes" json:"store_flushes,omitempty"`
+	RegionName          []byte                                  `protobuf:"bytes,6,opt,name=region_name,json=regionName" json:"region_name,omitempty"`
+	XXX_unrecognized    []byte                                  `json:"-"`
+}
+
+func (m *FlushDescriptor) Reset()                    { *m = FlushDescriptor{} }
+func (m *FlushDescriptor) String() string            { return proto.CompactTextString(m) }
+func (*FlushDescriptor) ProtoMessage()               {}
+func (*FlushDescriptor) Descriptor() ([]byte, []int) { return fileDescriptor18, []int{4} }
+
+func (m *FlushDescriptor) GetAction() FlushDescriptor_FlushAction {
+	if m != nil && m.Action != nil {
+		return *m.Action
+	}
+	return FlushDescriptor_START_FLUSH
+}
+
+func (m *FlushDescriptor) GetTableName() []byte {
+	if m != nil {
+		return m.TableName
+	}
+	return nil
+}
+
+func (m *FlushDescriptor) GetEncodedRegionName() []byte {
+	if m != nil {
+		return m.EncodedRegionName
+	}
+	return nil
+}
+
+func (m *FlushDescriptor) GetFlushSequenceNumber() uint64 {
+	if m != nil && m.FlushSequenceNumber != nil {
+		return *m.FlushSequenceNumber
+	}
+	return 0
+}
+
+func (m *FlushDescriptor) GetStoreFlushes() []*FlushDescriptor_StoreFlushDescriptor {
+	if m != nil {
+		return m.StoreFlushes
+	}
+	return nil
+}
+
+func (m *FlushDescriptor) GetRegionName() []byte {
+	if m != nil {
+		return m.RegionName
+	}
+	return nil
+}
+
+type FlushDescriptor_StoreFlushDescriptor struct {
+	FamilyName       []byte   `protobuf:"bytes,1,req,name=family_name,json=familyName" json:"family_name,omitempty"`
+	StoreHomeDir     *string  `protobuf:"bytes,2,req,name=store_home_dir,json=storeHomeDir" json:"store_home_dir,omitempty"`
+	FlushOutput      []string `protobuf:"bytes,3,rep,name=flush_output,json=flushOutput" json:"flush_output,omitempty"`
+	XXX_unrecognized []byte   `json:"-"`
+}
+
+func (m *FlushDescriptor_StoreFlushDescriptor) Reset()         { *m = FlushDescriptor_StoreFlushDescriptor{} }
+func (m *FlushDescriptor_StoreFlushDescriptor) String() string { return proto.CompactTextString(m) }
+func (*FlushDescriptor_StoreFlushDescriptor) ProtoMessage()    {}
+func (*FlushDescriptor_StoreFlushDescriptor) Descriptor() ([]byte, []int) {
+	return fileDescriptor18, []int{4, 0}
+}
+
+func (m *FlushDescriptor_StoreFlushDescriptor) GetFamilyName() []byte {
+	if m != nil {
+		return m.FamilyName
+	}
+	return nil
+}
+
+func (m *FlushDescriptor_StoreFlushDescriptor) GetStoreHomeDir() string {
+	if m != nil && m.StoreHomeDir != nil {
+		return *m.StoreHomeDir
+	}
+	return ""
+}
+
+func (m *FlushDescriptor_StoreFlushDescriptor) GetFlushOutput() []string {
+	if m != nil {
+		return m.FlushOutput
+	}
+	return nil
+}
+
+type StoreDescriptor struct {
+	FamilyName         []byte   `protobuf:"bytes,1,req,name=family_name,json=familyName" json:"family_name,omitempty"`
+	StoreHomeDir       *string  `protobuf:"bytes,2,req,name=store_home_dir,json=storeHomeDir" json:"store_home_dir,omitempty"`
+	StoreFile          []string `protobuf:"bytes,3,rep,name=store_file,json=storeFile" json:"store_file,omitempty"`
+	StoreFileSizeBytes *uint64  `protobuf:"varint,4,opt,name=store_file_size_bytes,json=storeFileSizeBytes" json:"store_file_size_bytes,omitempty"`
+	XXX_unrecognized   []byte   `json:"-"`
+}
+
+func (m *StoreDescriptor) Reset()                    { *m = StoreDescriptor{} }
+func (m *StoreDescriptor) String() string            { return proto.CompactTextString(m) }
+func (*StoreDescriptor) ProtoMessage()               {}
+func (*StoreDescriptor) Descriptor() ([]byte, []int) { return fileDescriptor18, []int{5} }
+
+func (m *StoreDescriptor) GetFamilyName() []byte {
+	if m != nil {
+		return m.FamilyName
+	}
+	return nil
+}
+
+func (m *StoreDescriptor) GetStoreHomeDir() string {
+	if m != nil && m.StoreHomeDir != nil {
+		return *m.StoreHomeDir
+	}
+	return ""
+}
+
+func (m *StoreDescriptor) GetStoreFile() []string {
+	if m != nil {
+		return m.StoreFile
+	}
+	return nil
+}
+
+func (m *StoreDescriptor) GetStoreFileSizeBytes() uint64 {
+	if m != nil && m.StoreFileSizeBytes != nil {
+		return *m.StoreFileSizeBytes
+	}
+	return 0
+}
+
+// *
+// Special WAL entry used for writing bulk load events to WAL
+type BulkLoadDescriptor struct {
+	TableName         *TableName         `protobuf:"bytes,1,req,name=table_name,json=tableName" json:"table_name,omitempty"`
+	EncodedRegionName []byte             `protobuf:"bytes,2,req,name=encoded_region_name,json=encodedRegionName" json:"encoded_region_name,omitempty"`
+	Stores            []*StoreDescriptor `protobuf:"bytes,3,rep,name=stores" json:"stores,omitempty"`
+	BulkloadSeqNum    *int64             `protobuf:"varint,4,req,name=bulkload_seq_num,json=bulkloadSeqNum" json:"bulkload_seq_num,omitempty"`
+	XXX_unrecognized  []byte             `json:"-"`
+}
+
+func (m *BulkLoadDescriptor) Reset()                    { *m = BulkLoadDescriptor{} }
+func (m *BulkLoadDescriptor) String() string            { return proto.CompactTextString(m) }
+func (*BulkLoadDescriptor) ProtoMessage()               {}
+func (*BulkLoadDescriptor) Descriptor() ([]byte, []int) { return fileDescriptor18, []int{6} }
+
+func (m *BulkLoadDescriptor) GetTableName() *TableName {
+	if m != nil {
+		return m.TableName
+	}
+	return nil
+}
+
+func (m *BulkLoadDescriptor) GetEncodedRegionName() []byte {
+	if m != nil {
+		return m.EncodedRegionName
+	}
+	return nil
+}
+
+func (m *BulkLoadDescriptor) GetStores() []*StoreDescriptor {
+	if m != nil {
+		return m.Stores
+	}
+	return nil
+}
+
+func (m *BulkLoadDescriptor) GetBulkloadSeqNum() int64 {
+	if m != nil && m.BulkloadSeqNum != nil {
+		return *m.BulkloadSeqNum
+	}
+	return 0
+}
+
+// *
+// Special WAL entry to hold all related to a region event (open/close).
+type RegionEventDescriptor struct {
+	EventType         *RegionEventDescriptor_EventType `protobuf:"varint,1,req,name=event_type,json=eventType,enum=pb.RegionEventDescriptor_EventType" json:"event_type,omitempty"`
+	TableName         []byte                           `protobuf:"bytes,2,req,name=table_name,json=tableName" json:"table_name,omitempty"`
+	EncodedRegionName []byte                           `protobuf:"bytes,3,req,name=encoded_region_name,json=encodedRegionName" json:"encoded_region_name,omitempty"`
+	LogSequenceNumber *uint64                          `protobuf:"varint,4,opt,name=log_sequence_number,json=logSequenceNumber" json:"log_sequence_number,omitempty"`
+	Stores            []*StoreDescriptor               `protobuf:"bytes,5,rep,name=stores" json:"stores,omitempty"`
+	Server            *ServerName                      `protobuf:"bytes,6,opt,name=server" json:"server,omitempty"`
+	RegionName        []byte                           `protobuf:"bytes,7,opt,name=region_name,json=regionName" json:"region_name,omitempty"`
+	XXX_unrecognized  []byte                           `json:"-"`
+}
+
+func (m *RegionEventDescriptor) Reset()                    { *m = RegionEventDescriptor{} }
+func (m *RegionEventDescriptor) String() string            { return proto.CompactTextString(m) }
+func (*RegionEventDescriptor) ProtoMessage()               {}
+func (*RegionEventDescriptor) Descriptor() ([]byte, []int) { return fileDescriptor18, []int{7} }
+
+func (m *RegionEventDescriptor) GetEventType() RegionEventDescriptor_EventType {
+	if m != nil && m.EventType != nil {
+		return *m.EventType
+	}
+	return RegionEventDescriptor_REGION_OPEN
+}
+
+func (m *RegionEventDescriptor) GetTableName() []byte {
+	if m != nil {
+		return m.TableName
+	}
+	return nil
+}
+
+func (m *RegionEventDescriptor) GetEncodedRegionName() []byte {
+	if m != nil {
+		return m.EncodedRegionName
+	}
+	return nil
+}
+
+func (m *RegionEventDescriptor) GetLogSequenceNumber() uint64 {
+	if m != nil && m.LogSequenceNumber != nil {
+		return *m.LogSequenceNumber
+	}
+	return 0
+}
+
+func (m *RegionEventDescriptor) GetStores() []*StoreDescriptor {
+	if m != nil {
+		return m.Stores
+	}
+	return nil
+}
+
+func (m *RegionEventDescriptor) GetServer() *ServerName {
+	if m != nil {
+		return m.Server
+	}
+	return nil
+}
+
+func (m *RegionEventDescriptor) GetRegionName() []byte {
+	if m != nil {
+		return m.RegionName
+	}
+	return nil
+}
+
+// *
+// A trailer that is appended to the end of a properly closed WAL file.
+// If missing, this is either a legacy or a corrupted WAL file.
+// N.B. This trailer currently doesn't contain any information and we
+// purposefully don't expose it in the WAL APIs. It's for future growth.
+type WALTrailer struct {
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *WALTrailer) Reset()                    { *m = WALTrailer{} }
+func (m *WALTrailer) String() string            { return proto.CompactTextString(m) }
+func (*WALTrailer) ProtoMessage()               {}
+func (*WALTrailer) Descriptor() ([]byte, []int) { return fileDescriptor18, []int{8} }
+
+func init() {
+	proto.RegisterType((*WALHeader)(nil), "pb.WALHeader")
+	proto.RegisterType((*WALKey)(nil), "pb.WALKey")
+	proto.RegisterType((*FamilyScope)(nil), "pb.FamilyScope")
+	proto.RegisterType((*CompactionDescriptor)(nil), "pb.CompactionDescriptor")
+	proto.RegisterType((*FlushDescriptor)(nil), "pb.FlushDescriptor")
+	proto.RegisterType((*FlushDescriptor_StoreFlushDescriptor)(nil), "pb.FlushDescriptor.StoreFlushDescriptor")
+	proto.RegisterType((*StoreDescriptor)(nil), "pb.StoreDescriptor")
+	proto.RegisterType((*BulkLoadDescriptor)(nil), "pb.BulkLoadDescriptor")
+	proto.RegisterType((*RegionEventDescriptor)(nil), "pb.RegionEventDescriptor")
+	proto.RegisterType((*WALTrailer)(nil), "pb.WALTrailer")
+	proto.RegisterEnum("pb.ScopeType", ScopeType_name, ScopeType_value)
+	proto.RegisterEnum("pb.FlushDescriptor_FlushAction", FlushDescriptor_FlushAction_name, FlushDescriptor_FlushAction_value)
+	proto.RegisterEnum("pb.RegionEventDescriptor_EventType", RegionEventDescriptor_EventType_name, RegionEventDescriptor_EventType_value)
+}
+
+func init() { proto.RegisterFile("WAL.proto", fileDescriptor18) }
+
+var fileDescriptor18 = []byte{
+	// 1104 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xdf, 0x72, 0xda, 0xc6,
+	0x17, 0x8e, 0x00, 0x93, 0xe8, 0x08, 0x03, 0x5e, 0xdb, 0xbf, 0x9f, 0xc6, 0x6d, 0x1a, 0x4a, 0xdb,
+	0x44, 0x89, 0x5d, 0xa6, 0xe5, 0xa6, 0x97, 0x1d, 0xc0, 0xd8, 0x66, 0x22, 0x83, 0x47, 0xe0, 0xf1,
+	0xa5, 0x46, 0x88, 0x35, 0x68, 0x2c, 0xb4, 0x8a, 0x56, 0x72, 0x86, 0x5c, 0xe5, 0xb2, 0x2f, 0xd0,
+	0xfb, 0xde, 0xf4, 0xa6, 0xef, 0xd0, 0x07, 0xe8, 0x6b, 0xf4, 0x49, 0x3a, 0x7b, 0x56, 0xfc, 0x31,
+	0xe0, 0x49, 0x67, 0x9a, 0x3b, 0xf6, 0xfb, 0xbe, 0xdd, 0x3d, 0xe7, 0x3b, 0xe7, 0xac, 0x00, 0xf5,
+	0xa6, 0x61, 0xd6, 0xc2, 0x88, 0xc5, 0x8c, 0x64, 0xc2, 0xe1, 0x91, 0x76, 0xd1, 0x74, 0x38, 0x95,
+	0xc0, 0x51, 0xa1, 0xe5, 0x7b, 0x34, 0x88, 0xe5, 0xaa, 0xfa, 0xb7, 0x82, 0xe2, 0x0b, 0xea, 0x8c,
+	0x68, 0x44, 0x5e, 0x41, 0x69, 0xe2, 0x70, 0xdb, 0x65, 0xd3, 0x30, 0xa2, 0x9c, 0x7b, 0x2c, 0xd0,
+	0x95, 0x8a, 0x62, 0x3c, 0xb3, 0x8a, 0x13, 0x87, 0xb7, 0x96, 0x28, 0xf9, 0x0e, 0x8a, 0x34, 0x70,
+	0xa3, 0x59, 0x18, 0x7b, 0x2c, 0xb0, 0xef, 0xe8, 0x4c, 0xcf, 0x54, 0x14, 0xa3, 0x60, 0xed, 0x2e,
+	0xd1, 0xb7, 0x74, 0x46, 0x6a, 0xb0, 0x2f, 0xce, 0x8b, 0x9d, 0xf1, 0x83, 0x33, 0xb3, 0x78, 0xe6,
+	0xde, 0xc4, 0xe1, 0x03, 0x67, 0xbc, 0x7a, 0xec, 0x4b, 0x28, 0xbd, 0x8f, 0xbc, 0x98, 0x46, 0xb6,
+	0xeb, 0x73, 0x3b, 0x70, 0xa6, 0x54, 0xcf, 0x55, 0x14, 0x43, 0xb5, 0x76, 0x25, 0xdc, 0xf2, 0x79,
+	0xd7, 0x99, 0x52, 0xf2, 0x3d, 0xec, 0xbb, 0xd4, 0xf7, 0x6d, 0x97, 0x8d, 0xa8, 0xbb, 0xd4, 0xee,
+	0xa0, 0xb6, 0x2c, 0xa8, 0x96, 0x60, 0x52, 0x79, 0xf5, 0xcf, 0x2c, 0xe4, 0x6f, 0x1a, 0x66, 0x1a,
+	0x11, 0x0d, 0xc4, 0xb6, 0x91, 0x1d, 0xd1, 0xb1, 0x08, 0x1e, 0x77, 0x2a, 0x95, 0x8c, 0x51, 0xb0,
+	0xf6, 0x52, 0xca, 0x42, 0x06, 0x6f, 0x7a, 0x0e, 0x10, 0x3b, 0x43, 0x9f, 0x4a, 0x59, 0x06, 0x65,
+	0x2a, 0x22, 0x48, 0xd7, 0x60, 0xdf, 0x67, 0x63, 0x9b, 0xd3, 0x77, 0x09, 0x0d, 0x5c, 0x6a, 0x07,
+	0xc9, 0x74, 0x48, 0x23, 0x3d, 0x5b, 0xc9, 0x18, 0x39, 0x6b, 0xcf, 0x67, 0xe3, 0x7e, 0xca, 0x74,
+	0x91, 0x10, 0xc7, 0x61, 0x26, 0x76, 0xec, 0x61, 0x6e, 0x42, 0xa6, 0x22, 0x32, 0xf0, 0xa6, 0x94,
+	0x1c, 0x03, 0xb8, 0x7e, 0xc2, 0x85, 0x01, 0xde, 0x08, 0xd3, 0xd1, 0xea, 0xcf, 0x6a, 0xe1, 0xb0,
+	0x76, 0x7d, 0xdd, 0x39, 0x6d, 0x66, 0x74, 0xc5, 0x52, 0x53, 0xbe, 0x33, 0x22, 0xaf, 0x20, 0xcf,
+	0x5d, 0x16, 0x52, 0xae, 0xe7, 0x2b, 0x59, 0x43, 0xab, 0x97, 0x84, 0xf0, 0xcc, 0x99, 0x7a, 0xfe,
+	0xac, 0x2f, 0x70, 0x2b, 0xa5, 0xc9, 0x09, 0x90, 0x5b, 0xe6, 0xfb, 0xec, 0xbd, 0x17, 0x8c, 0xed,
+	0xbb, 0x7b, 0xdb, 0x65, 0x49, 0x10, 0xeb, 0x4f, 0x2b, 0x8a, 0xb1, 0x6b, 0x95, 0x17, 0xcc, 0xdb,
+	0xfb, 0x96, 0xc0, 0xc9, 0x6b, 0xd0, 0x96, 0x31, 0x70, 0xfd, 0x19, 0x9e, 0xbd, 0x08, 0xc2, 0x82,
+	0x45, 0x00, 0x9c, 0x7c, 0x05, 0x10, 0xb0, 0xc0, 0xa5, 0xe7, 0x11, 0x4b, 0x42, 0x5d, 0xad, 0x28,
+	0x46, 0xce, 0x5a, 0x41, 0xc8, 0x01, 0xec, 0xe0, 0x4a, 0x07, 0xa4, 0xe4, 0x82, 0xfc, 0x00, 0x07,
+	0x2c, 0xf2, 0x36, 0x4d, 0xd3, 0x50, 0x44, 0x04, 0xf7, 0xd0, 0xb5, 0x6a, 0x1f, 0xb4, 0x95, 0xbc,
+	0xc8, 0xff, 0x20, 0x7f, 0x8b, 0xcb, 0xb4, 0x6c, 0xe9, 0x8a, 0x9c, 0x00, 0x60, 0xc6, 0x76, 0x3c,
+	0x0b, 0x65, 0xad, 0x8a, 0xf5, 0x5d, 0x11, 0x38, 0x6e, 0x1b, 0xcc, 0x42, 0x6a, 0xa9, 0x7c, 0xfe,
+	0xb3, 0xfa, 0x7b, 0x06, 0x0e, 0x44, 0xef, 0x39, 0xae, 0xe8, 0xd6, 0x53, 0xca, 0xdd, 0xc8, 0x0b,
+	0x63, 0x16, 0xad, 0x95, 0x5c, 0xd9, 0x52, 0xf2, 0x6d, 0x1d, 0x94, 0x79, 0xac, 0x83, 0x5e, 0x80,
+	0x26, 0xe3, 0x93, 0xba, 0x2c, 0xea, 0x40, 0x42, 0x28, 0x78, 0x0d, 0x65, 0x77, 0x11, 0x87, 0xed,
+	0x05, 0x61, 0x12, 0xeb, 0xb9, 0x4a, 0xd6, 0x50, 0xad, 0xd2, 0x12, 0xef, 0x08, 0x98, 0x1c, 0xc3,
+	0xde, 0x8a, 0x94, 0x25, 0xb1, 0xd0, 0xee, 0xa0, 0x76, 0xe5, 0x8c, 0x1e, 0xe2, 0xe4, 0x5b, 0x28,
+	0xf2, 0x98, 0x45, 0xd4, 0x9e, 0xb0, 0x29, 0xb5, 0x47, 0x5e, 0xa4, 0xe7, 0x2b, 0x19, 0x43, 0xb5,
+	0x0a, 0x88, 0x5e, 0xb0, 0x29, 0x3d, 0xf5, 0x22, 0x11, 0xde, 0x6a, 0x1a, 0x4f, 0x71, 0x8c, 0x21,
+	0x5a, 0xc4, 0x5f, 0xfd, 0x35, 0x07, 0xa5, 0x33, 0x3f, 0xe1, 0x93, 0x15, 0x8b, 0x7e, 0x82, 0xbc,
+	0xbc, 0x0a, 0xed, 0x29, 0xd6, 0x5f, 0x60, 0xeb, 0x3d, 0x14, 0xc9, 0x75, 0x03, 0x65, 0x56, 0x2a,
+	0xff, 0x17, 0xe3, 0xb4, 0xcd, 0xdb, 0xec, 0x63, 0xde, 0xd6, 0xe1, 0xf0, 0x56, 0xdc, 0xb2, 0xd1,
+	0x4b, 0x39, 0xec, 0xa5, 0x7d, 0x24, 0xd7, 0x46, 0xf0, 0x12, 0x76, 0xa5, 0x2d, 0x48, 0x52, 0x8e,
+	0xfe, 0x69, 0x75, 0x63, 0x5b, 0x0a, 0x7d, 0x21, 0x5c, 0x03, 0x53, 0xff, 0xce, 0xe4, 0xee, 0x75,
+	0xff, 0xf2, 0xeb, 0xfe, 0x1d, 0x7d, 0x54, 0xe0, 0x60, 0xdb, 0x39, 0xeb, 0x8d, 0xa1, 0x6c, 0x34,
+	0xc6, 0x66, 0x01, 0x33, 0x5b, 0x0a, 0xf8, 0x35, 0x14, 0xa4, 0x07, 0x69, 0x3b, 0x64, 0xb1, 0x1d,
+	0x34, 0xc4, 0x64, 0x27, 0xe0, 0xfc, 0x2c, 0x8b, 0x41, 0x4a, 0xa0, 0xf5, 0x07, 0x0d, 0x6b, 0x60,
+	0x9f, 0x99, 0xd7, 0xfd, 0x8b, 0xf2, 0x13, 0x52, 0x86, 0x42, 0xab, 0x77, 0x79, 0xd9, 0x99, 0x23,
+	0x8a, 0x90, 0x34, 0x9a, 0xbd, 0x85, 0x24, 0x83, 0x92, 0x46, 0xb7, 0xdb, 0x9b, 0x23, 0xd9, 0xea,
+	0x1f, 0x0a, 0x94, 0x30, 0xaf, 0xcf, 0x9f, 0xd2, 0x73, 0x80, 0xb4, 0x44, 0x9e, 0x4f, 0xd3, 0x84,
+	0x54, 0xe9, 0xba, 0xe7, 0x53, 0xf2, 0x23, 0x1c, 0x2e, 0x69, 0x9b, 0x7b, 0x1f, 0xa8, 0x3d, 0x9c,
+	0xc5, 0x94, 0xa7, 0x55, 0x27, 0x0b, 0x65, 0xdf, 0xfb, 0x40, 0x9b, 0x82, 0xa9, 0xfe, 0xa5, 0x00,
+	0x69, 0x26, 0xfe, 0x9d, 0xc9, 0x9c, 0xd1, 0x4a, 0xbc, 0x27, 0x1b, 0xa3, 0xae, 0xc9, 0x17, 0x63,
+	0x30, 0x6f, 0xc9, 0xff, 0x32, 0xf9, 0xc7, 0x90, 0xc7, 0x50, 0x38, 0xa6, 0xa0, 0xd5, 0xf7, 0xf1,
+	0x2d, 0x7a, 0x68, 0x99, 0x95, 0x4a, 0x88, 0x01, 0xe5, 0x61, 0xe2, 0xdf, 0xf9, 0xcc, 0x19, 0x89,
+	0x6e, 0x16, 0x8d, 0x8c, 0xdf, 0x87, 0xac, 0x55, 0x9c, 0xe3, 0x7d, 0xfa, 0xae, 0x9b, 0x4c, 0xab,
+	0x1f, 0xb3, 0x70, 0x28, 0x6f, 0x69, 0xdf, 0xd3, 0x20, 0x5e, 0x49, 0xa7, 0x09, 0x40, 0x05, 0x24,
+	0x1f, 0x40, 0x39, 0x9a, 0xdf, 0x88, 0x4b, 0xb7, 0xca, 0x6b, 0xb8, 0x96, 0xcf, 0x22, 0x9d, 0xff,
+	0xfc, 0xdc, 0x13, 0xfa, 0xc8, 0x07, 0x52, 0x56, 0x6a, 0xcb, 0x07, 0x72, 0xe9, 0xd9, 0xce, 0xa7,
+	0x3d, 0x7b, 0x09, 0x79, 0x4e, 0xa3, 0x7b, 0x1a, 0xe1, 0xd8, 0x69, 0xf5, 0x22, 0x8a, 0x11, 0xc1,
+	0xda, 0xa5, 0xec, 0xa7, 0xdf, 0xb8, 0x1a, 0xa8, 0x0b, 0x33, 0x44, 0xef, 0x5b, 0xed, 0xf3, 0x4e,
+	0xaf, 0x6b, 0xf7, 0xae, 0xda, 0x5d, 0x39, 0x1e, 0x29, 0xd0, 0x32, 0x7b, 0xfd, 0x76, 0x59, 0xa9,
+	0x16, 0x00, 0x6e, 0x1a, 0xe6, 0x20, 0x72, 0x3c, 0x9f, 0x46, 0x6f, 0xce, 0x40, 0x5d, 0x7c, 0x61,
+	0xc8, 0x17, 0xf0, 0x7f, 0xab, 0x7d, 0x65, 0x76, 0x5a, 0x8d, 0x81, 0xd8, 0xd1, 0x6f, 0xf5, 0xae,
+	0xda, 0xb6, 0xd9, 0x6b, 0x35, 0xcc, 0xf2, 0x13, 0xf2, 0x25, 0xe8, 0x9b, 0xe4, 0xb9, 0xd9, 0x6b,
+	0x36, 0xcc, 0xb2, 0xd2, 0xfc, 0x19, 0xde, 0xb0, 0x68, 0x5c, 0x73, 0x42, 0xc7, 0x9d, 0xd0, 0xda,
+	0xc4, 0x19, 0x31, 0x16, 0xd6, 0x26, 0xc3, 0xc5, 0x5f, 0xb7, 0x61, 0x72, 0x5b, 0x1b, 0xd3, 0x80,
+	0x46, 0x4e, 0x4c, 0x47, 0x4d, 0xf1, 0xb7, 0xed, 0x4a, 0xc0, 0xfc, 0x42, 0xf9, 0x45, 0x79, 0xf2,
+	0x9b, 0xa2, 0xfc, 0x13, 0x00, 0x00, 0xff, 0xff, 0xed, 0x1e, 0xb6, 0x57, 0xf7, 0x09, 0x00, 0x00,
+}

vendor/github.com/tsuna/gohbase/pb/WAL.proto

@@ -0,0 +1,173 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package pb;
+
+option java_package = "org.apache.hadoop.hbase.protobuf.generated";
+option java_outer_classname = "WALProtos";
+option java_generic_services = false;
+option java_generate_equals_and_hash = true;
+option optimize_for = SPEED;
+
+import "HBase.proto";
+import "Client.proto";
+
+message WALHeader {
+  optional bool has_compression = 1;
+  optional bytes encryption_key = 2;
+  optional bool has_tag_compression = 3;
+  optional string writer_cls_name = 4;
+  optional string cell_codec_cls_name = 5;
+}
+
+/*
+ * Protocol buffer version of WALKey; see WALKey comment, not really a key but WALEdit header
+ * for some KVs
+ */
+message WALKey {
+  required bytes encoded_region_name = 1;
+  required bytes table_name = 2;
+  required uint64 log_sequence_number = 3;
+  required uint64 write_time = 4;
+  /*
+  This parameter is deprecated in favor of clusters which
+  contains the list of clusters that have consumed the change.
+  It is retained so that the log created by earlier releases (0.94)
+  can be read by the newer releases.
+  */
+  optional UUID cluster_id = 5 [deprecated=true];
+
+  repeated FamilyScope scopes = 6;
+  optional uint32 following_kv_count = 7;
+
+  /*
+  This field contains the list of clusters that have
+  consumed the change
+  */
+  repeated UUID cluster_ids = 8;
+
+  optional uint64 nonceGroup = 9;
+  optional uint64 nonce = 10;
+  optional uint64 orig_sequence_number = 11;
+
+/*
+  optional CustomEntryType custom_entry_type = 9;
+
+  enum CustomEntryType {
+    COMPACTION = 0;
+  }
+*/
+}
+
+enum ScopeType {
+  REPLICATION_SCOPE_LOCAL = 0;
+  REPLICATION_SCOPE_GLOBAL = 1;
+}
+
+message FamilyScope {
+  required bytes family = 1;
+  required ScopeType scope_type = 2;
+}
+
+/**
+ * Custom WAL entries
+ */
+
+/**
+ * Special WAL entry to hold all related to a compaction.
+ * Written to WAL before completing compaction.  There is
+ * sufficient info in the below message to complete later
+ * the * compaction should we fail the WAL write.
+ */
+message CompactionDescriptor {
+  required bytes table_name = 1; // TODO: WALKey already stores these, might remove
+  required bytes encoded_region_name = 2;
+  required bytes family_name = 3;
+  repeated string compaction_input = 4; // relative to store dir
+  repeated string compaction_output = 5;
+  required string store_home_dir = 6; // relative to region dir
+  optional bytes  region_name = 7; // full region name
+}
+
+/**
+ * Special WAL entry to hold all related to a flush.
+ */
+message FlushDescriptor {
+  enum FlushAction {
+    START_FLUSH = 0;
+    COMMIT_FLUSH = 1;
+    ABORT_FLUSH = 2;
+    CANNOT_FLUSH = 3; // marker for indicating that a flush has been requested but cannot complete
+  }
+
+  message StoreFlushDescriptor {
+    required bytes family_name = 1;
+    required string store_home_dir = 2; //relative to region dir
+    repeated string flush_output = 3; // relative to store dir (if this is a COMMIT_FLUSH)
+  }
+
+  required FlushAction action = 1;
+  required bytes table_name = 2;
+  required bytes encoded_region_name = 3;
+  optional uint64 flush_sequence_number = 4;
+  repeated StoreFlushDescriptor store_flushes = 5;
+  optional bytes  region_name = 6; // full region name
+}
+
+message StoreDescriptor {
+  required bytes family_name = 1;
+  required string store_home_dir = 2; //relative to region dir
+  repeated string store_file = 3; // relative to store dir
+  optional uint64 store_file_size_bytes = 4; // size of store file
+}
+
+/**
+ * Special WAL entry used for writing bulk load events to WAL
+ */
+message BulkLoadDescriptor {
+  required TableName table_name = 1;
+  required bytes encoded_region_name = 2;
+  repeated StoreDescriptor stores = 3;
+  required int64 bulkload_seq_num = 4;
+}
+
+/**
+ * Special WAL entry to hold all related to a region event (open/close).
+ */
+message RegionEventDescriptor {
+  enum EventType {
+    REGION_OPEN = 0;
+    REGION_CLOSE = 1;
+  }
+
+  required EventType event_type = 1;
+  required bytes table_name = 2;
+  required bytes encoded_region_name = 3;
+  optional uint64 log_sequence_number = 4;
+  repeated StoreDescriptor stores = 5;
+  optional ServerName server = 6;  // Server who opened the region
+  optional bytes  region_name = 7; // full region name
+}
+
+/**
+ * A trailer that is appended to the end of a properly closed WAL file.
+ * If missing, this is either a legacy or a corrupted WAL file.
+ * N.B. This trailer currently doesn't contain any information and we
+ * purposefully don't expose it in the WAL APIs. It's for future growth.
+ */
+message WALTrailer {
+}

vendor/github.com/tsuna/gohbase/pb/ZooKeeper.pb.go

@@ -0,0 +1,648 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: ZooKeeper.proto
+
+package pb
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+type SplitLogTask_State int32
+
+const (
+	SplitLogTask_UNASSIGNED SplitLogTask_State = 0
+	SplitLogTask_OWNED      SplitLogTask_State = 1
+	SplitLogTask_RESIGNED   SplitLogTask_State = 2
+	SplitLogTask_DONE       SplitLogTask_State = 3
+	SplitLogTask_ERR        SplitLogTask_State = 4
+)
+
+var SplitLogTask_State_name = map[int32]string{
+	0: "UNASSIGNED",
+	1: "OWNED",
+	2: "RESIGNED",
+	3: "DONE",
+	4: "ERR",
+}
+var SplitLogTask_State_value = map[string]int32{
+	"UNASSIGNED": 0,
+	"OWNED":      1,
+	"RESIGNED":   2,
+	"DONE":       3,
+	"ERR":        4,
+}
+
+func (x SplitLogTask_State) Enum() *SplitLogTask_State {
+	p := new(SplitLogTask_State)
+	*p = x
+	return p
+}
+func (x SplitLogTask_State) String() string {
+	return proto.EnumName(SplitLogTask_State_name, int32(x))
+}
+func (x *SplitLogTask_State) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(SplitLogTask_State_value, data, "SplitLogTask_State")
+	if err != nil {
+		return err
+	}
+	*x = SplitLogTask_State(value)
+	return nil
+}
+func (SplitLogTask_State) EnumDescriptor() ([]byte, []int) { return fileDescriptor19, []int{4, 0} }
+
+type SplitLogTask_RecoveryMode int32
+
+const (
+	SplitLogTask_UNKNOWN       SplitLogTask_RecoveryMode = 0
+	SplitLogTask_LOG_SPLITTING SplitLogTask_RecoveryMode = 1
+	SplitLogTask_LOG_REPLAY    SplitLogTask_RecoveryMode = 2
+)
+
+var SplitLogTask_RecoveryMode_name = map[int32]string{
+	0: "UNKNOWN",
+	1: "LOG_SPLITTING",
+	2: "LOG_REPLAY",
+}
+var SplitLogTask_RecoveryMode_value = map[string]int32{
+	"UNKNOWN":       0,
+	"LOG_SPLITTING": 1,
+	"LOG_REPLAY":    2,
+}
+
+func (x SplitLogTask_RecoveryMode) Enum() *SplitLogTask_RecoveryMode {
+	p := new(SplitLogTask_RecoveryMode)
+	*p = x
+	return p
+}
+func (x SplitLogTask_RecoveryMode) String() string {
+	return proto.EnumName(SplitLogTask_RecoveryMode_name, int32(x))
+}
+func (x *SplitLogTask_RecoveryMode) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(SplitLogTask_RecoveryMode_value, data, "SplitLogTask_RecoveryMode")
+	if err != nil {
+		return err
+	}
+	*x = SplitLogTask_RecoveryMode(value)
+	return nil
+}
+func (SplitLogTask_RecoveryMode) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor19, []int{4, 1}
+}
+
+// Table's current state
+type Table_State int32
+
+const (
+	Table_ENABLED   Table_State = 0
+	Table_DISABLED  Table_State = 1
+	Table_DISABLING Table_State = 2
+	Table_ENABLING  Table_State = 3
+)
+
+var Table_State_name = map[int32]string{
+	0: "ENABLED",
+	1: "DISABLED",
+	2: "DISABLING",
+	3: "ENABLING",
+}
+var Table_State_value = map[string]int32{
+	"ENABLED":   0,
+	"DISABLED":  1,
+	"DISABLING": 2,
+	"ENABLING":  3,
+}
+
+func (x Table_State) Enum() *Table_State {
+	p := new(Table_State)
+	*p = x
+	return p
+}
+func (x Table_State) String() string {
+	return proto.EnumName(Table_State_name, int32(x))
+}
+func (x *Table_State) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(Table_State_value, data, "Table_State")
+	if err != nil {
+		return err
+	}
+	*x = Table_State(value)
+	return nil
+}
+func (Table_State) EnumDescriptor() ([]byte, []int) { return fileDescriptor19, []int{5, 0} }
+
+type ReplicationState_State int32
+
+const (
+	ReplicationState_ENABLED  ReplicationState_State = 0
+	ReplicationState_DISABLED ReplicationState_State = 1
+)
+
+var ReplicationState_State_name = map[int32]string{
+	0: "ENABLED",
+	1: "DISABLED",
+}
+var ReplicationState_State_value = map[string]int32{
+	"ENABLED":  0,
+	"DISABLED": 1,
+}
+
+func (x ReplicationState_State) Enum() *ReplicationState_State {
+	p := new(ReplicationState_State)
+	*p = x
+	return p
+}
+func (x ReplicationState_State) String() string {
+	return proto.EnumName(ReplicationState_State_name, int32(x))
+}
+func (x *ReplicationState_State) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(ReplicationState_State_value, data, "ReplicationState_State")
+	if err != nil {
+		return err
+	}
+	*x = ReplicationState_State(value)
+	return nil
+}
+func (ReplicationState_State) EnumDescriptor() ([]byte, []int) { return fileDescriptor19, []int{7, 0} }
+
+// *
+// Content of the meta-region-server znode.
+type MetaRegionServer struct {
+	// The ServerName hosting the meta region currently, or destination server,
+	// if meta region is in transition.
+	Server *ServerName `protobuf:"bytes,1,req,name=server" json:"server,omitempty"`
+	// The major version of the rpc the server speaks.  This is used so that
+	// clients connecting to the cluster can have prior knowledge of what version
+	// to send to a RegionServer.  AsyncHBase will use this to detect versions.
+	RpcVersion *uint32 `protobuf:"varint,2,opt,name=rpc_version,json=rpcVersion" json:"rpc_version,omitempty"`
+	// State of the region transition. OPEN means fully operational 'hbase:meta'
+	State            *RegionState_State `protobuf:"varint,3,opt,name=state,enum=pb.RegionState_State" json:"state,omitempty"`
+	XXX_unrecognized []byte             `json:"-"`
+}
+
+func (m *MetaRegionServer) Reset()                    { *m = MetaRegionServer{} }
+func (m *MetaRegionServer) String() string            { return proto.CompactTextString(m) }
+func (*MetaRegionServer) ProtoMessage()               {}
+func (*MetaRegionServer) Descriptor() ([]byte, []int) { return fileDescriptor19, []int{0} }
+
+func (m *MetaRegionServer) GetServer() *ServerName {
+	if m != nil {
+		return m.Server
+	}
+	return nil
+}
+
+func (m *MetaRegionServer) GetRpcVersion() uint32 {
+	if m != nil && m.RpcVersion != nil {
+		return *m.RpcVersion
+	}
+	return 0
+}
+
+func (m *MetaRegionServer) GetState() RegionState_State {
+	if m != nil && m.State != nil {
+		return *m.State
+	}
+	return RegionState_OFFLINE
+}
+
+// *
+// Content of the master znode.
+type Master struct {
+	// The ServerName of the current Master
+	Master *ServerName `protobuf:"bytes,1,req,name=master" json:"master,omitempty"`
+	// Major RPC version so that clients can know what version the master can accept.
+	RpcVersion       *uint32 `protobuf:"varint,2,opt,name=rpc_version,json=rpcVersion" json:"rpc_version,omitempty"`
+	InfoPort         *uint32 `protobuf:"varint,3,opt,name=info_port,json=infoPort" json:"info_port,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *Master) Reset()                    { *m = Master{} }
+func (m *Master) String() string            { return proto.CompactTextString(m) }
+func (*Master) ProtoMessage()               {}
+func (*Master) Descriptor() ([]byte, []int) { return fileDescriptor19, []int{1} }
+
+func (m *Master) GetMaster() *ServerName {
+	if m != nil {
+		return m.Master
+	}
+	return nil
+}
+
+func (m *Master) GetRpcVersion() uint32 {
+	if m != nil && m.RpcVersion != nil {
+		return *m.RpcVersion
+	}
+	return 0
+}
+
+func (m *Master) GetInfoPort() uint32 {
+	if m != nil && m.InfoPort != nil {
+		return *m.InfoPort
+	}
+	return 0
+}
+
+// *
+// Content of the '/hbase/running', cluster state, znode.
+type ClusterUp struct {
+	// If this znode is present, cluster is up.  Currently
+	// the data is cluster start_date.
+	StartDate        *string `protobuf:"bytes,1,req,name=start_date,json=startDate" json:"start_date,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *ClusterUp) Reset()                    { *m = ClusterUp{} }
+func (m *ClusterUp) String() string            { return proto.CompactTextString(m) }
+func (*ClusterUp) ProtoMessage()               {}
+func (*ClusterUp) Descriptor() ([]byte, []int) { return fileDescriptor19, []int{2} }
+
+func (m *ClusterUp) GetStartDate() string {
+	if m != nil && m.StartDate != nil {
+		return *m.StartDate
+	}
+	return ""
+}
+
+// *
+// What we write under unassigned up in zookeeper as a region moves through
+// open/close, etc., regions.  Details a region in transition.
+type RegionTransition struct {
+	// Code for EventType gotten by doing o.a.h.h.EventHandler.EventType.getCode()
+	EventTypeCode *uint32 `protobuf:"varint,1,req,name=event_type_code,json=eventTypeCode" json:"event_type_code,omitempty"`
+	// Full regionname in bytes
+	RegionName []byte  `protobuf:"bytes,2,req,name=region_name,json=regionName" json:"region_name,omitempty"`
+	CreateTime *uint64 `protobuf:"varint,3,req,name=create_time,json=createTime" json:"create_time,omitempty"`
+	// The region server where the transition will happen or is happening
+	ServerName       *ServerName `protobuf:"bytes,4,req,name=server_name,json=serverName" json:"server_name,omitempty"`
+	Payload          []byte      `protobuf:"bytes,5,opt,name=payload" json:"payload,omitempty"`
+	XXX_unrecognized []byte      `json:"-"`
+}
+
+func (m *RegionTransition) Reset()                    { *m = RegionTransition{} }
+func (m *RegionTransition) String() string            { return proto.CompactTextString(m) }
+func (*RegionTransition) ProtoMessage()               {}
+func (*RegionTransition) Descriptor() ([]byte, []int) { return fileDescriptor19, []int{3} }
+
+func (m *RegionTransition) GetEventTypeCode() uint32 {
+	if m != nil && m.EventTypeCode != nil {
+		return *m.EventTypeCode
+	}
+	return 0
+}
+
+func (m *RegionTransition) GetRegionName() []byte {
+	if m != nil {
+		return m.RegionName
+	}
+	return nil
+}
+
+func (m *RegionTransition) GetCreateTime() uint64 {
+	if m != nil && m.CreateTime != nil {
+		return *m.CreateTime
+	}
+	return 0
+}
+
+func (m *RegionTransition) GetServerName() *ServerName {
+	if m != nil {
+		return m.ServerName
+	}
+	return nil
+}
+
+func (m *RegionTransition) GetPayload() []byte {
+	if m != nil {
+		return m.Payload
+	}
+	return nil
+}
+
+// *
+// WAL SplitLog directory znodes have this for content.  Used doing distributed
+// WAL splitting.  Holds current state and name of server that originated split.
+type SplitLogTask struct {
+	State            *SplitLogTask_State        `protobuf:"varint,1,req,name=state,enum=pb.SplitLogTask_State" json:"state,omitempty"`
+	ServerName       *ServerName                `protobuf:"bytes,2,req,name=server_name,json=serverName" json:"server_name,omitempty"`
+	Mode             *SplitLogTask_RecoveryMode `protobuf:"varint,3,opt,name=mode,enum=pb.SplitLogTask_RecoveryMode,def=0" json:"mode,omitempty"`
+	XXX_unrecognized []byte                     `json:"-"`
+}
+
+func (m *SplitLogTask) Reset()                    { *m = SplitLogTask{} }
+func (m *SplitLogTask) String() string            { return proto.CompactTextString(m) }
+func (*SplitLogTask) ProtoMessage()               {}
+func (*SplitLogTask) Descriptor() ([]byte, []int) { return fileDescriptor19, []int{4} }
+
+const Default_SplitLogTask_Mode SplitLogTask_RecoveryMode = SplitLogTask_UNKNOWN
+
+func (m *SplitLogTask) GetState() SplitLogTask_State {
+	if m != nil && m.State != nil {
+		return *m.State
+	}
+	return SplitLogTask_UNASSIGNED
+}
+
+func (m *SplitLogTask) GetServerName() *ServerName {
+	if m != nil {
+		return m.ServerName
+	}
+	return nil
+}
+
+func (m *SplitLogTask) GetMode() SplitLogTask_RecoveryMode {
+	if m != nil && m.Mode != nil {
+		return *m.Mode
+	}
+	return Default_SplitLogTask_Mode
+}
+
+// *
+// The znode that holds state of table.
+type Table struct {
+	// This is the table's state.  If no znode for a table,
+	// its state is presumed enabled.  See o.a.h.h.zookeeper.ZKTable class
+	// for more.
+	State            *Table_State `protobuf:"varint,1,req,name=state,enum=pb.Table_State,def=0" json:"state,omitempty"`
+	XXX_unrecognized []byte       `json:"-"`
+}
+
+func (m *Table) Reset()                    { *m = Table{} }
+func (m *Table) String() string            { return proto.CompactTextString(m) }
+func (*Table) ProtoMessage()               {}
+func (*Table) Descriptor() ([]byte, []int) { return fileDescriptor19, []int{5} }
+
+const Default_Table_State Table_State = Table_ENABLED
+
+func (m *Table) GetState() Table_State {
+	if m != nil && m.State != nil {
+		return *m.State
+	}
+	return Default_Table_State
+}
+
+// *
+// Used by replication. Holds a replication peer key.
+type ReplicationPeer struct {
+	// clusterkey is the concatenation of the slave cluster's
+	// hbase.zookeeper.quorum:hbase.zookeeper.property.clientPort:zookeeper.znode.parent
+	Clusterkey              *string           `protobuf:"bytes,1,req,name=clusterkey" json:"clusterkey,omitempty"`
+	ReplicationEndpointImpl *string           `protobuf:"bytes,2,opt,name=replicationEndpointImpl" json:"replicationEndpointImpl,omitempty"`
+	Data                    []*BytesBytesPair `protobuf:"bytes,3,rep,name=data" json:"data,omitempty"`
+	Configuration           []*NameStringPair `protobuf:"bytes,4,rep,name=configuration" json:"configuration,omitempty"`
+	XXX_unrecognized        []byte            `json:"-"`
+}
+
+func (m *ReplicationPeer) Reset()                    { *m = ReplicationPeer{} }
+func (m *ReplicationPeer) String() string            { return proto.CompactTextString(m) }
+func (*ReplicationPeer) ProtoMessage()               {}
+func (*ReplicationPeer) Descriptor() ([]byte, []int) { return fileDescriptor19, []int{6} }
+
+func (m *ReplicationPeer) GetClusterkey() string {
+	if m != nil && m.Clusterkey != nil {
+		return *m.Clusterkey
+	}
+	return ""
+}
+
+func (m *ReplicationPeer) GetReplicationEndpointImpl() string {
+	if m != nil && m.ReplicationEndpointImpl != nil {
+		return *m.ReplicationEndpointImpl
+	}
+	return ""
+}
+
+func (m *ReplicationPeer) GetData() []*BytesBytesPair {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+func (m *ReplicationPeer) GetConfiguration() []*NameStringPair {
+	if m != nil {
+		return m.Configuration
+	}
+	return nil
+}
+
+// *
+// Used by replication. Holds whether enabled or disabled
+type ReplicationState struct {
+	State            *ReplicationState_State `protobuf:"varint,1,req,name=state,enum=pb.ReplicationState_State" json:"state,omitempty"`
+	XXX_unrecognized []byte                  `json:"-"`
+}
+
+func (m *ReplicationState) Reset()                    { *m = ReplicationState{} }
+func (m *ReplicationState) String() string            { return proto.CompactTextString(m) }
+func (*ReplicationState) ProtoMessage()               {}
+func (*ReplicationState) Descriptor() ([]byte, []int) { return fileDescriptor19, []int{7} }
+
+func (m *ReplicationState) GetState() ReplicationState_State {
+	if m != nil && m.State != nil {
+		return *m.State
+	}
+	return ReplicationState_ENABLED
+}
+
+// *
+// Used by replication. Holds the current position in an WAL file.
+type ReplicationHLogPosition struct {
+	Position         *int64 `protobuf:"varint,1,req,name=position" json:"position,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *ReplicationHLogPosition) Reset()                    { *m = ReplicationHLogPosition{} }
+func (m *ReplicationHLogPosition) String() string            { return proto.CompactTextString(m) }
+func (*ReplicationHLogPosition) ProtoMessage()               {}
+func (*ReplicationHLogPosition) Descriptor() ([]byte, []int) { return fileDescriptor19, []int{8} }
+
+func (m *ReplicationHLogPosition) GetPosition() int64 {
+	if m != nil && m.Position != nil {
+		return *m.Position
+	}
+	return 0
+}
+
+// *
+// Used by replication. Used to lock a region server during failover.
+type ReplicationLock struct {
+	LockOwner        *string `protobuf:"bytes,1,req,name=lock_owner,json=lockOwner" json:"lock_owner,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *ReplicationLock) Reset()                    { *m = ReplicationLock{} }
+func (m *ReplicationLock) String() string            { return proto.CompactTextString(m) }
+func (*ReplicationLock) ProtoMessage()               {}
+func (*ReplicationLock) Descriptor() ([]byte, []int) { return fileDescriptor19, []int{9} }
+
+func (m *ReplicationLock) GetLockOwner() string {
+	if m != nil && m.LockOwner != nil {
+		return *m.LockOwner
+	}
+	return ""
+}
+
+// *
+// Metadata associated with a table lock in zookeeper
+type TableLock struct {
+	TableName        *TableName  `protobuf:"bytes,1,opt,name=table_name,json=tableName" json:"table_name,omitempty"`
+	LockOwner        *ServerName `protobuf:"bytes,2,opt,name=lock_owner,json=lockOwner" json:"lock_owner,omitempty"`
+	ThreadId         *int64      `protobuf:"varint,3,opt,name=thread_id,json=threadId" json:"thread_id,omitempty"`
+	IsShared         *bool       `protobuf:"varint,4,opt,name=is_shared,json=isShared" json:"is_shared,omitempty"`
+	Purpose          *string     `protobuf:"bytes,5,opt,name=purpose" json:"purpose,omitempty"`
+	CreateTime       *int64      `protobuf:"varint,6,opt,name=create_time,json=createTime" json:"create_time,omitempty"`
+	XXX_unrecognized []byte      `json:"-"`
+}
+
+func (m *TableLock) Reset()                    { *m = TableLock{} }
+func (m *TableLock) String() string            { return proto.CompactTextString(m) }
+func (*TableLock) ProtoMessage()               {}
+func (*TableLock) Descriptor() ([]byte, []int) { return fileDescriptor19, []int{10} }
+
+func (m *TableLock) GetTableName() *TableName {
+	if m != nil {
+		return m.TableName
+	}
+	return nil
+}
+
+func (m *TableLock) GetLockOwner() *ServerName {
+	if m != nil {
+		return m.LockOwner
+	}
+	return nil
+}
+
+func (m *TableLock) GetThreadId() int64 {
+	if m != nil && m.ThreadId != nil {
+		return *m.ThreadId
+	}
+	return 0
+}
+
+func (m *TableLock) GetIsShared() bool {
+	if m != nil && m.IsShared != nil {
+		return *m.IsShared
+	}
+	return false
+}
+
+func (m *TableLock) GetPurpose() string {
+	if m != nil && m.Purpose != nil {
+		return *m.Purpose
+	}
+	return ""
+}
+
+func (m *TableLock) GetCreateTime() int64 {
+	if m != nil && m.CreateTime != nil {
+		return *m.CreateTime
+	}
+	return 0
+}
+
+// *
+// State of the switch.
+type SwitchState struct {
+	Enabled          *bool  `protobuf:"varint,1,opt,name=enabled" json:"enabled,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *SwitchState) Reset()                    { *m = SwitchState{} }
+func (m *SwitchState) String() string            { return proto.CompactTextString(m) }
+func (*SwitchState) ProtoMessage()               {}
+func (*SwitchState) Descriptor() ([]byte, []int) { return fileDescriptor19, []int{11} }
+
+func (m *SwitchState) GetEnabled() bool {
+	if m != nil && m.Enabled != nil {
+		return *m.Enabled
+	}
+	return false
+}
+
+func init() {
+	proto.RegisterType((*MetaRegionServer)(nil), "pb.MetaRegionServer")
+	proto.RegisterType((*Master)(nil), "pb.Master")
+	proto.RegisterType((*ClusterUp)(nil), "pb.ClusterUp")
+	proto.RegisterType((*RegionTransition)(nil), "pb.RegionTransition")
+	proto.RegisterType((*SplitLogTask)(nil), "pb.SplitLogTask")
+	proto.RegisterType((*Table)(nil), "pb.Table")
+	proto.RegisterType((*ReplicationPeer)(nil), "pb.ReplicationPeer")
+	proto.RegisterType((*ReplicationState)(nil), "pb.ReplicationState")
+	proto.RegisterType((*ReplicationHLogPosition)(nil), "pb.ReplicationHLogPosition")
+	proto.RegisterType((*ReplicationLock)(nil), "pb.ReplicationLock")
+	proto.RegisterType((*TableLock)(nil), "pb.TableLock")
+	proto.RegisterType((*SwitchState)(nil), "pb.SwitchState")
+	proto.RegisterEnum("pb.SplitLogTask_State", SplitLogTask_State_name, SplitLogTask_State_value)
+	proto.RegisterEnum("pb.SplitLogTask_RecoveryMode", SplitLogTask_RecoveryMode_name, SplitLogTask_RecoveryMode_value)
+	proto.RegisterEnum("pb.Table_State", Table_State_name, Table_State_value)
+	proto.RegisterEnum("pb.ReplicationState_State", ReplicationState_State_name, ReplicationState_State_value)
+}
+
+func init() { proto.RegisterFile("ZooKeeper.proto", fileDescriptor19) }
+
+var fileDescriptor19 = []byte{
+	// 907 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x55, 0xef, 0x6e, 0xe2, 0x46,
+	0x10, 0x8f, 0x0d, 0x49, 0xf0, 0x10, 0x12, 0xba, 0x55, 0x7b, 0x56, 0xaa, 0x6b, 0x91, 0x3f, 0xa4,
+	0xe8, 0x7a, 0xa5, 0x27, 0xa4, 0x4a, 0xa7, 0x7c, 0x68, 0x15, 0x02, 0x4a, 0xd0, 0x11, 0x40, 0x6b,
+	0xd2, 0x53, 0xfb, 0xc5, 0x5a, 0xec, 0x09, 0x58, 0x01, 0xef, 0x6a, 0xbd, 0xe4, 0xca, 0x1b, 0xdc,
+	0x63, 0xf4, 0x09, 0xfa, 0x1a, 0xfd, 0xd4, 0x47, 0xe8, 0xbb, 0x54, 0xbb, 0x0b, 0x04, 0xd2, 0x9e,
+	0xf2, 0xc5, 0xda, 0xf9, 0xcd, 0x9f, 0xdf, 0xec, 0xec, 0xcc, 0x18, 0x4e, 0x7e, 0xe3, 0xfc, 0x1d,
+	0xa2, 0x40, 0xd9, 0x10, 0x92, 0x2b, 0x4e, 0x5c, 0x31, 0x3e, 0x2d, 0x5f, 0xb7, 0x58, 0x8e, 0x16,
+	0x38, 0xfd, 0xfc, 0x72, 0xb6, 0xc8, 0x15, 0xca, 0x50, 0x31, 0xb5, 0xc8, 0x2d, 0x18, 0x7c, 0x74,
+	0xa0, 0x7a, 0x83, 0x8a, 0x51, 0x9c, 0xa4, 0x3c, 0x0b, 0x51, 0x3e, 0xa0, 0x24, 0x67, 0x70, 0x90,
+	0x9b, 0x93, 0xef, 0xd4, 0xdc, 0x7a, 0xb9, 0x79, 0xdc, 0x10, 0xe3, 0x86, 0xd5, 0xf5, 0xd9, 0x1c,
+	0xe9, 0x4a, 0x4b, 0xbe, 0x81, 0xb2, 0x14, 0x71, 0xf4, 0x80, 0x32, 0x4f, 0x79, 0xe6, 0xbb, 0x35,
+	0xa7, 0x5e, 0xa1, 0x20, 0x45, 0xfc, 0x8b, 0x45, 0xc8, 0x77, 0xb0, 0x9f, 0x2b, 0xa6, 0xd0, 0x2f,
+	0xd4, 0x9c, 0xfa, 0x71, 0xf3, 0x0b, 0x1d, 0x67, 0xc5, 0xa4, 0xe1, 0x86, 0xf9, 0x52, 0x6b, 0x13,
+	0x64, 0x70, 0x70, 0xc3, 0x74, 0x82, 0x9a, 0x7f, 0x6e, 0x4e, 0x9f, 0xe2, 0xb7, 0xda, 0xe7, 0xf9,
+	0xbf, 0x02, 0x2f, 0xcd, 0xee, 0x78, 0x24, 0xb8, 0x54, 0x26, 0x87, 0x0a, 0x2d, 0x69, 0x60, 0xc8,
+	0xa5, 0x0a, 0x5e, 0x81, 0xb7, 0xaa, 0xc8, 0xad, 0x20, 0x2f, 0x01, 0x72, 0xc5, 0xa4, 0x8a, 0x12,
+	0x9d, 0xae, 0xa6, 0xf5, 0xa8, 0x67, 0x90, 0xb6, 0xce, 0xed, 0x2f, 0x07, 0xaa, 0x36, 0xf1, 0x91,
+	0x64, 0x59, 0x9e, 0x2a, 0x1d, 0xfd, 0x0c, 0x4e, 0xf0, 0x01, 0x33, 0x15, 0xa9, 0xa5, 0xc0, 0x28,
+	0xe6, 0x89, 0x75, 0xac, 0xd0, 0x8a, 0x81, 0x47, 0x4b, 0x81, 0x97, 0x3c, 0x41, 0x93, 0xa6, 0xf1,
+	0x8d, 0x32, 0x36, 0x47, 0xdf, 0xad, 0xb9, 0xf5, 0x23, 0x0a, 0x16, 0xd2, 0xf7, 0xd1, 0x06, 0xb1,
+	0x44, 0xa6, 0x30, 0x52, 0xe9, 0x5c, 0x17, 0xcb, 0xad, 0x17, 0x29, 0x58, 0x68, 0x94, 0xce, 0x91,
+	0xfc, 0x00, 0x65, 0x5b, 0x72, 0x1b, 0xa1, 0xf8, 0xbf, 0x55, 0x81, 0x7c, 0x73, 0x26, 0x3e, 0x1c,
+	0x0a, 0xb6, 0x9c, 0x71, 0x96, 0xf8, 0xfb, 0x35, 0xa7, 0x7e, 0x44, 0xd7, 0x62, 0xf0, 0xa7, 0x0b,
+	0x47, 0xa1, 0x98, 0xa5, 0xaa, 0xc7, 0x27, 0x23, 0x96, 0xdf, 0x93, 0xd7, 0xeb, 0x37, 0xd2, 0xb9,
+	0x1f, 0x37, 0xbf, 0x34, 0x51, 0xb7, 0x0c, 0x76, 0x1e, 0xe9, 0x69, 0x26, 0xee, 0xb3, 0x99, 0x9c,
+	0x43, 0x71, 0xae, 0x2b, 0x63, 0x3b, 0xe0, 0xe5, 0x7f, 0xa2, 0x53, 0x8c, 0xf9, 0x03, 0xca, 0xe5,
+	0x0d, 0x4f, 0xf0, 0xfc, 0xf0, 0xb6, 0xff, 0xae, 0x3f, 0x78, 0xdf, 0xa7, 0xc6, 0x27, 0xb8, 0x84,
+	0x7d, 0x43, 0x4e, 0x8e, 0x01, 0x6e, 0xfb, 0x17, 0x61, 0xd8, 0xbd, 0xea, 0x77, 0xda, 0xd5, 0x3d,
+	0xe2, 0xc1, 0xfe, 0xe0, 0xbd, 0x3e, 0x3a, 0xe4, 0x08, 0x4a, 0xb4, 0xb3, 0x52, 0xb8, 0xa4, 0x04,
+	0xc5, 0xf6, 0xa0, 0xdf, 0xa9, 0x16, 0xc8, 0x21, 0x14, 0x3a, 0x94, 0x56, 0x8b, 0xc1, 0x4f, 0x70,
+	0xb4, 0xcd, 0x41, 0xca, 0xb0, 0x66, 0xa9, 0xee, 0x91, 0xcf, 0xa0, 0xd2, 0x1b, 0x5c, 0x45, 0xe1,
+	0xb0, 0xd7, 0x1d, 0x8d, 0xba, 0xfd, 0xab, 0xaa, 0xa3, 0xb9, 0x34, 0x44, 0x3b, 0xc3, 0xde, 0xc5,
+	0xaf, 0x55, 0x37, 0xf8, 0x1d, 0xf6, 0x47, 0x6c, 0x3c, 0x43, 0xd2, 0xd8, 0x2d, 0xd4, 0x89, 0xbe,
+	0x8a, 0xd1, 0xd8, 0x0a, 0x9d, 0x1f, 0x76, 0xfa, 0x17, 0xad, 0x5e, 0xa7, 0xbd, 0xee, 0xe7, 0x9f,
+	0xd7, 0xd9, 0x97, 0x61, 0xad, 0xaa, 0xee, 0xe9, 0x7c, 0xdb, 0xdd, 0xd0, 0x4a, 0x0e, 0xa9, 0x80,
+	0x67, 0x25, 0xcd, 0xed, 0x6a, 0xa5, 0xb1, 0xd4, 0x52, 0x21, 0xf8, 0xdb, 0x81, 0x13, 0x8a, 0x62,
+	0x96, 0xc6, 0x4c, 0xf7, 0xdb, 0x10, 0x51, 0x92, 0xaf, 0x01, 0x62, 0xdb, 0xb4, 0xf7, 0xb8, 0x5c,
+	0xf5, 0xe9, 0x16, 0x42, 0xde, 0xc2, 0x0b, 0xf9, 0xe8, 0xd2, 0xc9, 0x12, 0xc1, 0xd3, 0x4c, 0x75,
+	0xe7, 0x62, 0x66, 0xc6, 0xc3, 0xa3, 0x9f, 0x52, 0x93, 0x33, 0x28, 0x26, 0x4c, 0x31, 0xbf, 0x50,
+	0x2b, 0xd4, 0xcb, 0x4d, 0xa2, 0x6f, 0xd7, 0x5a, 0x2a, 0xcc, 0xcd, 0x67, 0xc8, 0x52, 0x49, 0x8d,
+	0x9e, 0xbc, 0x85, 0x4a, 0xcc, 0xb3, 0xbb, 0x74, 0xb2, 0x90, 0x26, 0x88, 0x5f, 0x7c, 0x74, 0xd0,
+	0x2f, 0x1e, 0x2a, 0x99, 0x66, 0x13, 0xe3, 0xb0, 0x6b, 0x18, 0x4c, 0xf5, 0x0c, 0x6d, 0xc8, 0x6d,
+	0x6d, 0xde, 0xec, 0x16, 0xf5, 0xd4, 0x6e, 0x88, 0x5d, 0xa3, 0xdd, 0x35, 0x11, 0x3c, 0x5f, 0xd6,
+	0xe0, 0x47, 0x78, 0xb1, 0x15, 0xe4, 0xba, 0xc7, 0x27, 0x43, 0xbe, 0x1a, 0xda, 0x53, 0x28, 0x89,
+	0xd5, 0xd9, 0x70, 0x16, 0xe8, 0x46, 0x0e, 0xde, 0xec, 0xd4, 0xbb, 0xc7, 0xe3, 0x7b, 0xbd, 0x17,
+	0x66, 0x3c, 0xbe, 0x8f, 0xf8, 0x87, 0x6c, 0xb5, 0x8e, 0x3c, 0xea, 0x69, 0x64, 0xa0, 0x81, 0xe0,
+	0x1f, 0x07, 0x3c, 0xd3, 0x03, 0xc6, 0xf8, 0x35, 0x80, 0xd2, 0x82, 0x9d, 0x0d, 0xa7, 0xe6, 0xd4,
+	0xcb, 0xcd, 0xca, 0xa6, 0x4d, 0xcc, 0x68, 0x78, 0x6a, 0x7d, 0x24, 0xdf, 0xef, 0x84, 0x76, 0x8d,
+	0xf5, 0xd3, 0x49, 0x7a, 0xa4, 0xd2, 0xbb, 0x4c, 0x4d, 0x25, 0xb2, 0x24, 0x4a, 0x13, 0x33, 0x4d,
+	0x05, 0x5a, 0xb2, 0x40, 0x37, 0x31, 0x8b, 0x2e, 0x8f, 0xf2, 0x29, 0x93, 0x98, 0xf8, 0xc5, 0x9a,
+	0x53, 0x2f, 0xd1, 0x52, 0x9a, 0x87, 0x46, 0x36, 0xcb, 0x60, 0x21, 0x05, 0xcf, 0xd1, 0x2c, 0x03,
+	0x8f, 0xae, 0xc5, 0xa7, 0x8b, 0xe7, 0xc0, 0x44, 0xdd, 0x5a, 0x3c, 0xc1, 0xb7, 0x50, 0x0e, 0x3f,
+	0xa4, 0x2a, 0x9e, 0xda, 0x92, 0xfb, 0x70, 0x88, 0x99, 0xbe, 0x40, 0x62, 0x6e, 0x57, 0xa2, 0x6b,
+	0xb1, 0xd5, 0x81, 0x57, 0x5c, 0x4e, 0x1a, 0x4c, 0xb0, 0x78, 0x8a, 0x8d, 0x29, 0x4b, 0x38, 0x17,
+	0x8d, 0xe9, 0x78, 0xf3, 0xf7, 0x19, 0x2f, 0xee, 0x1a, 0x13, 0xcc, 0x50, 0x32, 0x85, 0x49, 0xeb,
+	0xf1, 0x67, 0x35, 0xd4, 0xca, 0xfc, 0xda, 0xf9, 0xe8, 0x38, 0x7f, 0x38, 0xce, 0xbf, 0x01, 0x00,
+	0x00, 0xff, 0xff, 0x48, 0xdb, 0x93, 0x4c, 0xc6, 0x06, 0x00, 0x00,
+}

vendor/github.com/tsuna/gohbase/pb/ZooKeeper.proto

@@ -0,0 +1,176 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ZNode data in hbase are serialized protobufs with a four byte
+// 'magic' 'PBUF' prefix.
+package pb;
+
+option java_package = "org.apache.hadoop.hbase.protobuf.generated";
+option java_outer_classname = "ZooKeeperProtos";
+option java_generic_services = true;
+option java_generate_equals_and_hash = true;
+option optimize_for = SPEED;
+
+import "HBase.proto";
+import "ClusterStatus.proto";
+
+/**
+ * Content of the meta-region-server znode.
+ */
+message MetaRegionServer {
+  // The ServerName hosting the meta region currently, or destination server,
+  // if meta region is in transition.
+  required ServerName server = 1;
+  // The major version of the rpc the server speaks.  This is used so that
+  // clients connecting to the cluster can have prior knowledge of what version
+  // to send to a RegionServer.  AsyncHBase will use this to detect versions.
+  optional uint32 rpc_version = 2;
+
+  // State of the region transition. OPEN means fully operational 'hbase:meta'
+  optional RegionState.State state = 3;
+}
+
+/**
+ * Content of the master znode.
+ */
+message Master {
+  // The ServerName of the current Master
+  required ServerName master = 1;
+  // Major RPC version so that clients can know what version the master can accept.
+  optional uint32 rpc_version = 2;
+  optional uint32 info_port = 3;
+}
+
+/**
+ * Content of the '/hbase/running', cluster state, znode.
+ */
+message ClusterUp {
+  // If this znode is present, cluster is up.  Currently
+  // the data is cluster start_date.
+  required string start_date = 1;
+}
+
+/**
+ * What we write under unassigned up in zookeeper as a region moves through
+ * open/close, etc., regions.  Details a region in transition.
+ */
+message RegionTransition {
+  // Code for EventType gotten by doing o.a.h.h.EventHandler.EventType.getCode()
+  required uint32 event_type_code = 1;
+  // Full regionname in bytes
+  required bytes region_name = 2;
+  required uint64 create_time = 3;
+  // The region server where the transition will happen or is happening
+  required ServerName server_name = 4;
+  optional bytes payload = 5;
+}
+
+/**
+ * WAL SplitLog directory znodes have this for content.  Used doing distributed
+ * WAL splitting.  Holds current state and name of server that originated split.
+ */
+message SplitLogTask {
+  enum State {
+    UNASSIGNED = 0;
+    OWNED = 1;
+    RESIGNED = 2;
+    DONE = 3;
+    ERR = 4;
+  }
+  enum RecoveryMode {
+    UNKNOWN = 0;
+    LOG_SPLITTING = 1;
+    LOG_REPLAY = 2;
+  }
+  required State state = 1;
+  required ServerName server_name = 2;
+  optional RecoveryMode mode = 3 [default = UNKNOWN];
+}
+
+/**
+ * The znode that holds state of table.
+ */
+message Table {
+  // Table's current state
+  enum State {
+    ENABLED = 0;
+    DISABLED = 1;
+    DISABLING = 2;
+    ENABLING = 3;
+  }
+  // This is the table's state.  If no znode for a table,
+  // its state is presumed enabled.  See o.a.h.h.zookeeper.ZKTable class
+  // for more.
+  required State state = 1 [default = ENABLED];
+}
+
+/**
+ * Used by replication. Holds a replication peer key.
+ */
+message ReplicationPeer {
+  // clusterkey is the concatenation of the slave cluster's
+  // hbase.zookeeper.quorum:hbase.zookeeper.property.clientPort:zookeeper.znode.parent
+  required string clusterkey = 1;
+  optional string replicationEndpointImpl = 2;
+  repeated BytesBytesPair data = 3;
+  repeated NameStringPair configuration = 4;
+}
+
+/**
+ * Used by replication. Holds whether enabled or disabled
+ */
+message ReplicationState {
+  enum State {
+    ENABLED = 0;
+    DISABLED = 1;
+  }
+  required State state = 1;
+}
+
+/**
+ * Used by replication. Holds the current position in an WAL file.
+ */
+message ReplicationHLogPosition {
+  required int64 position = 1;
+}
+
+/**
+ * Used by replication. Used to lock a region server during failover.
+ */
+message ReplicationLock {
+  required string lock_owner = 1;
+}
+
+/**
+ * Metadata associated with a table lock in zookeeper
+ */
+message TableLock {
+  optional TableName table_name = 1;
+  optional ServerName lock_owner = 2;
+  optional int64 thread_id = 3;
+  optional bool is_shared = 4;
+  optional string purpose = 5;
+  optional int64 create_time = 6;
+}
+
+/**
+ * State of the switch.
+ */
+message SwitchState {
+  optional bool enabled = 1;
+}

vendor/github.com/tsuna/gohbase/pb/generate.go

@@ -0,0 +1,8 @@
+// Copyright (C) 2015  The GoHBase Authors.  All rights reserved.
+// This file is part of GoHBase.
+// Use of this source code is governed by the Apache License 2.0
+// that can be found in the COPYING file.
+
+package pb
+
+//go:generate sh -c "protoc --go_out=. *.proto"

vendor/github.com/tsuna/gohbase/pb/marshal.go

@@ -0,0 +1,20 @@
+// Copyright (C) 2015  The GoHBase Authors.  All rights reserved.
+// This file is part of GoHBase.
+// Use of this source code is governed by the Apache License 2.0
+// that can be found in the COPYING file.
+
+package pb
+
+import (
+	"github.com/golang/protobuf/proto"
+)
+
+// MustMarshal is like proto.Marshal except it panic()'s if the protobuf
+// couldn't be serialized.
+func MustMarshal(pb proto.Message) []byte {
+	b, err := proto.Marshal(pb)
+	if err != nil {
+		panic(err)
+	}
+	return b
+}