Integrate public as bindata optionally (#293)

* Dropped unused codekit config

* Integrated dynamic and static bindata for public

* Ignore public bindata

* Add a general generate make task

* Integrated flexible public assets into web command

* Updated vendoring, added all missiong govendor deps

* Made the linter happy with the bindata and dynamic code

* Moved public bindata definition to modules directory

* Ignoring the new bindata path now

* Updated to the new public modules import path

* Updated public bindata command and drop the new prefix

vendor/github.com/pingcap/go-hbase/proto/AccessControl.pb.go

@@ -0,0 +1,451 @@
+// Code generated by protoc-gen-go.
+// source: AccessControl.proto
+// DO NOT EDIT!
+
+/*
+Package proto is a generated protocol buffer package.
+
+It is generated from these files:
+	AccessControl.proto
+	Admin.proto
+	Aggregate.proto
+	Authentication.proto
+	Cell.proto
+	Client.proto
+	ClusterId.proto
+	ClusterStatus.proto
+	Comparator.proto
+	Encryption.proto
+	ErrorHandling.proto
+	FS.proto
+	Filter.proto
+	HBase.proto
+	HFile.proto
+	LoadBalancer.proto
+	MapReduce.proto
+	Master.proto
+	MultiRowMutation.proto
+	RPC.proto
+	RegionServerStatus.proto
+	RowProcessor.proto
+	SecureBulkLoad.proto
+	Snapshot.proto
+	Themis.proto
+	Tracing.proto
+	VisibilityLabels.proto
+	WAL.proto
+	ZooKeeper.proto
+
+It has these top-level messages:
+	Permission
+	TablePermission
+	NamespacePermission
+	GlobalPermission
+	UserPermission
+	UsersAndPermissions
+	GrantRequest
+	GrantResponse
+	RevokeRequest
+	RevokeResponse
+	GetUserPermissionsRequest
+	GetUserPermissionsResponse
+	CheckPermissionsRequest
+	CheckPermissionsResponse
+*/
+package proto
+
+import proto1 "github.com/golang/protobuf/proto"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto1.Marshal
+var _ = math.Inf
+
+type Permission_Action int32
+
+const (
+	Permission_READ   Permission_Action = 0
+	Permission_WRITE  Permission_Action = 1
+	Permission_EXEC   Permission_Action = 2
+	Permission_CREATE Permission_Action = 3
+	Permission_ADMIN  Permission_Action = 4
+)
+
+var Permission_Action_name = map[int32]string{
+	0: "READ",
+	1: "WRITE",
+	2: "EXEC",
+	3: "CREATE",
+	4: "ADMIN",
+}
+var Permission_Action_value = map[string]int32{
+	"READ":   0,
+	"WRITE":  1,
+	"EXEC":   2,
+	"CREATE": 3,
+	"ADMIN":  4,
+}
+
+func (x Permission_Action) Enum() *Permission_Action {
+	p := new(Permission_Action)
+	*p = x
+	return p
+}
+func (x Permission_Action) String() string {
+	return proto1.EnumName(Permission_Action_name, int32(x))
+}
+func (x *Permission_Action) UnmarshalJSON(data []byte) error {
+	value, err := proto1.UnmarshalJSONEnum(Permission_Action_value, data, "Permission_Action")
+	if err != nil {
+		return err
+	}
+	*x = Permission_Action(value)
+	return nil
+}
+
+type Permission_Type int32
+
+const (
+	Permission_Global    Permission_Type = 1
+	Permission_Namespace Permission_Type = 2
+	Permission_Table     Permission_Type = 3
+)
+
+var Permission_Type_name = map[int32]string{
+	1: "Global",
+	2: "Namespace",
+	3: "Table",
+}
+var Permission_Type_value = map[string]int32{
+	"Global":    1,
+	"Namespace": 2,
+	"Table":     3,
+}
+
+func (x Permission_Type) Enum() *Permission_Type {
+	p := new(Permission_Type)
+	*p = x
+	return p
+}
+func (x Permission_Type) String() string {
+	return proto1.EnumName(Permission_Type_name, int32(x))
+}
+func (x *Permission_Type) UnmarshalJSON(data []byte) error {
+	value, err := proto1.UnmarshalJSONEnum(Permission_Type_value, data, "Permission_Type")
+	if err != nil {
+		return err
+	}
+	*x = Permission_Type(value)
+	return nil
+}
+
+type Permission struct {
+	Type                *Permission_Type     `protobuf:"varint,1,req,name=type,enum=proto.Permission_Type" json:"type,omitempty"`
+	GlobalPermission    *GlobalPermission    `protobuf:"bytes,2,opt,name=global_permission" json:"global_permission,omitempty"`
+	NamespacePermission *NamespacePermission `protobuf:"bytes,3,opt,name=namespace_permission" json:"namespace_permission,omitempty"`
+	TablePermission     *TablePermission     `protobuf:"bytes,4,opt,name=table_permission" json:"table_permission,omitempty"`
+	XXX_unrecognized    []byte               `json:"-"`
+}
+
+func (m *Permission) Reset()         { *m = Permission{} }
+func (m *Permission) String() string { return proto1.CompactTextString(m) }
+func (*Permission) ProtoMessage()    {}
+
+func (m *Permission) GetType() Permission_Type {
+	if m != nil && m.Type != nil {
+		return *m.Type
+	}
+	return Permission_Global
+}
+
+func (m *Permission) GetGlobalPermission() *GlobalPermission {
+	if m != nil {
+		return m.GlobalPermission
+	}
+	return nil
+}
+
+func (m *Permission) GetNamespacePermission() *NamespacePermission {
+	if m != nil {
+		return m.NamespacePermission
+	}
+	return nil
+}
+
+func (m *Permission) GetTablePermission() *TablePermission {
+	if m != nil {
+		return m.TablePermission
+	}
+	return nil
+}
+
+type TablePermission struct {
+	TableName        *TableName          `protobuf:"bytes,1,opt,name=table_name" json:"table_name,omitempty"`
+	Family           []byte              `protobuf:"bytes,2,opt,name=family" json:"family,omitempty"`
+	Qualifier        []byte              `protobuf:"bytes,3,opt,name=qualifier" json:"qualifier,omitempty"`
+	Action           []Permission_Action `protobuf:"varint,4,rep,name=action,enum=proto.Permission_Action" json:"action,omitempty"`
+	XXX_unrecognized []byte              `json:"-"`
+}
+
+func (m *TablePermission) Reset()         { *m = TablePermission{} }
+func (m *TablePermission) String() string { return proto1.CompactTextString(m) }
+func (*TablePermission) ProtoMessage()    {}
+
+func (m *TablePermission) GetTableName() *TableName {
+	if m != nil {
+		return m.TableName
+	}
+	return nil
+}
+
+func (m *TablePermission) GetFamily() []byte {
+	if m != nil {
+		return m.Family
+	}
+	return nil
+}
+
+func (m *TablePermission) GetQualifier() []byte {
+	if m != nil {
+		return m.Qualifier
+	}
+	return nil
+}
+
+func (m *TablePermission) GetAction() []Permission_Action {
+	if m != nil {
+		return m.Action
+	}
+	return nil
+}
+
+type NamespacePermission struct {
+	NamespaceName    []byte              `protobuf:"bytes,1,opt,name=namespace_name" json:"namespace_name,omitempty"`
+	Action           []Permission_Action `protobuf:"varint,2,rep,name=action,enum=proto.Permission_Action" json:"action,omitempty"`
+	XXX_unrecognized []byte              `json:"-"`
+}
+
+func (m *NamespacePermission) Reset()         { *m = NamespacePermission{} }
+func (m *NamespacePermission) String() string { return proto1.CompactTextString(m) }
+func (*NamespacePermission) ProtoMessage()    {}
+
+func (m *NamespacePermission) GetNamespaceName() []byte {
+	if m != nil {
+		return m.NamespaceName
+	}
+	return nil
+}
+
+func (m *NamespacePermission) GetAction() []Permission_Action {
+	if m != nil {
+		return m.Action
+	}
+	return nil
+}
+
+type GlobalPermission struct {
+	Action           []Permission_Action `protobuf:"varint,1,rep,name=action,enum=proto.Permission_Action" json:"action,omitempty"`
+	XXX_unrecognized []byte              `json:"-"`
+}
+
+func (m *GlobalPermission) Reset()         { *m = GlobalPermission{} }
+func (m *GlobalPermission) String() string { return proto1.CompactTextString(m) }
+func (*GlobalPermission) ProtoMessage()    {}
+
+func (m *GlobalPermission) GetAction() []Permission_Action {
+	if m != nil {
+		return m.Action
+	}
+	return nil
+}
+
+type UserPermission struct {
+	User             []byte      `protobuf:"bytes,1,req,name=user" json:"user,omitempty"`
+	Permission       *Permission `protobuf:"bytes,3,req,name=permission" json:"permission,omitempty"`
+	XXX_unrecognized []byte      `json:"-"`
+}
+
+func (m *UserPermission) Reset()         { *m = UserPermission{} }
+func (m *UserPermission) String() string { return proto1.CompactTextString(m) }
+func (*UserPermission) ProtoMessage()    {}
+
+func (m *UserPermission) GetUser() []byte {
+	if m != nil {
+		return m.User
+	}
+	return nil
+}
+
+func (m *UserPermission) GetPermission() *Permission {
+	if m != nil {
+		return m.Permission
+	}
+	return nil
+}
+
+// *
+// Content of the /hbase/acl/<table or namespace> znode.
+type UsersAndPermissions struct {
+	UserPermissions  []*UsersAndPermissions_UserPermissions `protobuf:"bytes,1,rep,name=user_permissions" json:"user_permissions,omitempty"`
+	XXX_unrecognized []byte                                 `json:"-"`
+}
+
+func (m *UsersAndPermissions) Reset()         { *m = UsersAndPermissions{} }
+func (m *UsersAndPermissions) String() string { return proto1.CompactTextString(m) }
+func (*UsersAndPermissions) ProtoMessage()    {}
+
+func (m *UsersAndPermissions) GetUserPermissions() []*UsersAndPermissions_UserPermissions {
+	if m != nil {
+		return m.UserPermissions
+	}
+	return nil
+}
+
+type UsersAndPermissions_UserPermissions struct {
+	User             []byte        `protobuf:"bytes,1,req,name=user" json:"user,omitempty"`
+	Permissions      []*Permission `protobuf:"bytes,2,rep,name=permissions" json:"permissions,omitempty"`
+	XXX_unrecognized []byte        `json:"-"`
+}
+
+func (m *UsersAndPermissions_UserPermissions) Reset()         { *m = UsersAndPermissions_UserPermissions{} }
+func (m *UsersAndPermissions_UserPermissions) String() string { return proto1.CompactTextString(m) }
+func (*UsersAndPermissions_UserPermissions) ProtoMessage()    {}
+
+func (m *UsersAndPermissions_UserPermissions) GetUser() []byte {
+	if m != nil {
+		return m.User
+	}
+	return nil
+}
+
+func (m *UsersAndPermissions_UserPermissions) GetPermissions() []*Permission {
+	if m != nil {
+		return m.Permissions
+	}
+	return nil
+}
+
+type GrantRequest struct {
+	UserPermission   *UserPermission `protobuf:"bytes,1,req,name=user_permission" json:"user_permission,omitempty"`
+	XXX_unrecognized []byte          `json:"-"`
+}
+
+func (m *GrantRequest) Reset()         { *m = GrantRequest{} }
+func (m *GrantRequest) String() string { return proto1.CompactTextString(m) }
+func (*GrantRequest) ProtoMessage()    {}
+
+func (m *GrantRequest) GetUserPermission() *UserPermission {
+	if m != nil {
+		return m.UserPermission
+	}
+	return nil
+}
+
+type GrantResponse struct {
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *GrantResponse) Reset()         { *m = GrantResponse{} }
+func (m *GrantResponse) String() string { return proto1.CompactTextString(m) }
+func (*GrantResponse) ProtoMessage()    {}
+
+type RevokeRequest struct {
+	UserPermission   *UserPermission `protobuf:"bytes,1,req,name=user_permission" json:"user_permission,omitempty"`
+	XXX_unrecognized []byte          `json:"-"`
+}
+
+func (m *RevokeRequest) Reset()         { *m = RevokeRequest{} }
+func (m *RevokeRequest) String() string { return proto1.CompactTextString(m) }
+func (*RevokeRequest) ProtoMessage()    {}
+
+func (m *RevokeRequest) GetUserPermission() *UserPermission {
+	if m != nil {
+		return m.UserPermission
+	}
+	return nil
+}
+
+type RevokeResponse struct {
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *RevokeResponse) Reset()         { *m = RevokeResponse{} }
+func (m *RevokeResponse) String() string { return proto1.CompactTextString(m) }
+func (*RevokeResponse) ProtoMessage()    {}
+
+type GetUserPermissionsRequest struct {
+	Type             *Permission_Type `protobuf:"varint,1,opt,name=type,enum=proto.Permission_Type" json:"type,omitempty"`
+	TableName        *TableName       `protobuf:"bytes,2,opt,name=table_name" json:"table_name,omitempty"`
+	NamespaceName    []byte           `protobuf:"bytes,3,opt,name=namespace_name" json:"namespace_name,omitempty"`
+	XXX_unrecognized []byte           `json:"-"`
+}
+
+func (m *GetUserPermissionsRequest) Reset()         { *m = GetUserPermissionsRequest{} }
+func (m *GetUserPermissionsRequest) String() string { return proto1.CompactTextString(m) }
+func (*GetUserPermissionsRequest) ProtoMessage()    {}
+
+func (m *GetUserPermissionsRequest) GetType() Permission_Type {
+	if m != nil && m.Type != nil {
+		return *m.Type
+	}
+	return Permission_Global
+}
+
+func (m *GetUserPermissionsRequest) GetTableName() *TableName {
+	if m != nil {
+		return m.TableName
+	}
+	return nil
+}
+
+func (m *GetUserPermissionsRequest) GetNamespaceName() []byte {
+	if m != nil {
+		return m.NamespaceName
+	}
+	return nil
+}
+
+type GetUserPermissionsResponse struct {
+	UserPermission   []*UserPermission `protobuf:"bytes,1,rep,name=user_permission" json:"user_permission,omitempty"`
+	XXX_unrecognized []byte            `json:"-"`
+}
+
+func (m *GetUserPermissionsResponse) Reset()         { *m = GetUserPermissionsResponse{} }
+func (m *GetUserPermissionsResponse) String() string { return proto1.CompactTextString(m) }
+func (*GetUserPermissionsResponse) ProtoMessage()    {}
+
+func (m *GetUserPermissionsResponse) GetUserPermission() []*UserPermission {
+	if m != nil {
+		return m.UserPermission
+	}
+	return nil
+}
+
+type CheckPermissionsRequest struct {
+	Permission       []*Permission `protobuf:"bytes,1,rep,name=permission" json:"permission,omitempty"`
+	XXX_unrecognized []byte        `json:"-"`
+}
+
+func (m *CheckPermissionsRequest) Reset()         { *m = CheckPermissionsRequest{} }
+func (m *CheckPermissionsRequest) String() string { return proto1.CompactTextString(m) }
+func (*CheckPermissionsRequest) ProtoMessage()    {}
+
+func (m *CheckPermissionsRequest) GetPermission() []*Permission {
+	if m != nil {
+		return m.Permission
+	}
+	return nil
+}
+
+type CheckPermissionsResponse struct {
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *CheckPermissionsResponse) Reset()         { *m = CheckPermissionsResponse{} }
+func (m *CheckPermissionsResponse) String() string { return proto1.CompactTextString(m) }
+func (*CheckPermissionsResponse) ProtoMessage()    {}
+
+func init() {
+	proto1.RegisterEnum("proto.Permission_Action", Permission_Action_name, Permission_Action_value)
+	proto1.RegisterEnum("proto.Permission_Type", Permission_Type_name, Permission_Type_value)
+}

vendor/github.com/pingcap/go-hbase/proto/Admin.pb.go

@@ -0,0 +1,769 @@
+// Code generated by protoc-gen-go.
+// source: Admin.proto
+// DO NOT EDIT!
+
+package proto
+
+import proto1 "github.com/golang/protobuf/proto"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto1.Marshal
+var _ = math.Inf
+
+type GetRegionInfoResponse_CompactionState int32
+
+const (
+	GetRegionInfoResponse_NONE            GetRegionInfoResponse_CompactionState = 0
+	GetRegionInfoResponse_MINOR           GetRegionInfoResponse_CompactionState = 1
+	GetRegionInfoResponse_MAJOR           GetRegionInfoResponse_CompactionState = 2
+	GetRegionInfoResponse_MAJOR_AND_MINOR GetRegionInfoResponse_CompactionState = 3
+)
+
+var GetRegionInfoResponse_CompactionState_name = map[int32]string{
+	0: "NONE",
+	1: "MINOR",
+	2: "MAJOR",
+	3: "MAJOR_AND_MINOR",
+}
+var GetRegionInfoResponse_CompactionState_value = map[string]int32{
+	"NONE":            0,
+	"MINOR":           1,
+	"MAJOR":           2,
+	"MAJOR_AND_MINOR": 3,
+}
+
+func (x GetRegionInfoResponse_CompactionState) Enum() *GetRegionInfoResponse_CompactionState {
+	p := new(GetRegionInfoResponse_CompactionState)
+	*p = x
+	return p
+}
+func (x GetRegionInfoResponse_CompactionState) String() string {
+	return proto1.EnumName(GetRegionInfoResponse_CompactionState_name, int32(x))
+}
+func (x *GetRegionInfoResponse_CompactionState) UnmarshalJSON(data []byte) error {
+	value, err := proto1.UnmarshalJSONEnum(GetRegionInfoResponse_CompactionState_value, data, "GetRegionInfoResponse_CompactionState")
+	if err != nil {
+		return err
+	}
+	*x = GetRegionInfoResponse_CompactionState(value)
+	return nil
+}
+
+type OpenRegionResponse_RegionOpeningState int32
+
+const (
+	OpenRegionResponse_OPENED         OpenRegionResponse_RegionOpeningState = 0
+	OpenRegionResponse_ALREADY_OPENED OpenRegionResponse_RegionOpeningState = 1
+	OpenRegionResponse_FAILED_OPENING OpenRegionResponse_RegionOpeningState = 2
+)
+
+var OpenRegionResponse_RegionOpeningState_name = map[int32]string{
+	0: "OPENED",
+	1: "ALREADY_OPENED",
+	2: "FAILED_OPENING",
+}
+var OpenRegionResponse_RegionOpeningState_value = map[string]int32{
+	"OPENED":         0,
+	"ALREADY_OPENED": 1,
+	"FAILED_OPENING": 2,
+}
+
+func (x OpenRegionResponse_RegionOpeningState) Enum() *OpenRegionResponse_RegionOpeningState {
+	p := new(OpenRegionResponse_RegionOpeningState)
+	*p = x
+	return p
+}
+func (x OpenRegionResponse_RegionOpeningState) String() string {
+	return proto1.EnumName(OpenRegionResponse_RegionOpeningState_name, int32(x))
+}
+func (x *OpenRegionResponse_RegionOpeningState) UnmarshalJSON(data []byte) error {
+	value, err := proto1.UnmarshalJSONEnum(OpenRegionResponse_RegionOpeningState_value, data, "OpenRegionResponse_RegionOpeningState")
+	if err != nil {
+		return err
+	}
+	*x = OpenRegionResponse_RegionOpeningState(value)
+	return nil
+}
+
+type GetRegionInfoRequest struct {
+	Region           *RegionSpecifier `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
+	CompactionState  *bool            `protobuf:"varint,2,opt,name=compaction_state" json:"compaction_state,omitempty"`
+	XXX_unrecognized []byte           `json:"-"`
+}
+
+func (m *GetRegionInfoRequest) Reset()         { *m = GetRegionInfoRequest{} }
+func (m *GetRegionInfoRequest) String() string { return proto1.CompactTextString(m) }
+func (*GetRegionInfoRequest) ProtoMessage()    {}
+
+func (m *GetRegionInfoRequest) GetRegion() *RegionSpecifier {
+	if m != nil {
+		return m.Region
+	}
+	return nil
+}
+
+func (m *GetRegionInfoRequest) GetCompactionState() bool {
+	if m != nil && m.CompactionState != nil {
+		return *m.CompactionState
+	}
+	return false
+}
+
+type GetRegionInfoResponse struct {
+	RegionInfo       *RegionInfo                            `protobuf:"bytes,1,req,name=region_info" json:"region_info,omitempty"`
+	CompactionState  *GetRegionInfoResponse_CompactionState `protobuf:"varint,2,opt,name=compaction_state,enum=proto.GetRegionInfoResponse_CompactionState" json:"compaction_state,omitempty"`
+	IsRecovering     *bool                                  `protobuf:"varint,3,opt,name=isRecovering" json:"isRecovering,omitempty"`
+	XXX_unrecognized []byte                                 `json:"-"`
+}
+
+func (m *GetRegionInfoResponse) Reset()         { *m = GetRegionInfoResponse{} }
+func (m *GetRegionInfoResponse) String() string { return proto1.CompactTextString(m) }
+func (*GetRegionInfoResponse) ProtoMessage()    {}
+
+func (m *GetRegionInfoResponse) GetRegionInfo() *RegionInfo {
+	if m != nil {
+		return m.RegionInfo
+	}
+	return nil
+}
+
+func (m *GetRegionInfoResponse) GetCompactionState() GetRegionInfoResponse_CompactionState {
+	if m != nil && m.CompactionState != nil {
+		return *m.CompactionState
+	}
+	return GetRegionInfoResponse_NONE
+}
+
+func (m *GetRegionInfoResponse) GetIsRecovering() bool {
+	if m != nil && m.IsRecovering != nil {
+		return *m.IsRecovering
+	}
+	return false
+}
+
+// *
+// 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.
+type GetStoreFileRequest struct {
+	Region           *RegionSpecifier `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
+	Family           [][]byte         `protobuf:"bytes,2,rep,name=family" json:"family,omitempty"`
+	XXX_unrecognized []byte           `json:"-"`
+}
+
+func (m *GetStoreFileRequest) Reset()         { *m = GetStoreFileRequest{} }
+func (m *GetStoreFileRequest) String() string { return proto1.CompactTextString(m) }
+func (*GetStoreFileRequest) ProtoMessage()    {}
+
+func (m *GetStoreFileRequest) GetRegion() *RegionSpecifier {
+	if m != nil {
+		return m.Region
+	}
+	return nil
+}
+
+func (m *GetStoreFileRequest) GetFamily() [][]byte {
+	if m != nil {
+		return m.Family
+	}
+	return nil
+}
+
+type GetStoreFileResponse struct {
+	StoreFile        []string `protobuf:"bytes,1,rep,name=store_file" json:"store_file,omitempty"`
+	XXX_unrecognized []byte   `json:"-"`
+}
+
+func (m *GetStoreFileResponse) Reset()         { *m = GetStoreFileResponse{} }
+func (m *GetStoreFileResponse) String() string { return proto1.CompactTextString(m) }
+func (*GetStoreFileResponse) ProtoMessage()    {}
+
+func (m *GetStoreFileResponse) GetStoreFile() []string {
+	if m != nil {
+		return m.StoreFile
+	}
+	return nil
+}
+
+type GetOnlineRegionRequest struct {
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *GetOnlineRegionRequest) Reset()         { *m = GetOnlineRegionRequest{} }
+func (m *GetOnlineRegionRequest) String() string { return proto1.CompactTextString(m) }
+func (*GetOnlineRegionRequest) ProtoMessage()    {}
+
+type GetOnlineRegionResponse struct {
+	RegionInfo       []*RegionInfo `protobuf:"bytes,1,rep,name=region_info" json:"region_info,omitempty"`
+	XXX_unrecognized []byte        `json:"-"`
+}
+
+func (m *GetOnlineRegionResponse) Reset()         { *m = GetOnlineRegionResponse{} }
+func (m *GetOnlineRegionResponse) String() string { return proto1.CompactTextString(m) }
+func (*GetOnlineRegionResponse) ProtoMessage()    {}
+
+func (m *GetOnlineRegionResponse) GetRegionInfo() []*RegionInfo {
+	if m != nil {
+		return m.RegionInfo
+	}
+	return nil
+}
+
+type OpenRegionRequest struct {
+	OpenInfo []*OpenRegionRequest_RegionOpenInfo `protobuf:"bytes,1,rep,name=open_info" json:"open_info,omitempty"`
+	// the intended server for this RPC.
+	ServerStartCode  *uint64 `protobuf:"varint,2,opt,name=serverStartCode" json:"serverStartCode,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *OpenRegionRequest) Reset()         { *m = OpenRegionRequest{} }
+func (m *OpenRegionRequest) String() string { return proto1.CompactTextString(m) }
+func (*OpenRegionRequest) ProtoMessage()    {}
+
+func (m *OpenRegionRequest) GetOpenInfo() []*OpenRegionRequest_RegionOpenInfo {
+	if m != nil {
+		return m.OpenInfo
+	}
+	return nil
+}
+
+func (m *OpenRegionRequest) GetServerStartCode() uint64 {
+	if m != nil && m.ServerStartCode != nil {
+		return *m.ServerStartCode
+	}
+	return 0
+}
+
+type OpenRegionRequest_RegionOpenInfo struct {
+	Region               *RegionInfo   `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
+	VersionOfOfflineNode *uint32       `protobuf:"varint,2,opt,name=version_of_offline_node" json:"version_of_offline_node,omitempty"`
+	FavoredNodes         []*ServerName `protobuf:"bytes,3,rep,name=favored_nodes" json:"favored_nodes,omitempty"`
+	// open region for distributedLogReplay
+	OpenForDistributedLogReplay *bool  `protobuf:"varint,4,opt,name=openForDistributedLogReplay" json:"openForDistributedLogReplay,omitempty"`
+	XXX_unrecognized            []byte `json:"-"`
+}
+
+func (m *OpenRegionRequest_RegionOpenInfo) Reset()         { *m = OpenRegionRequest_RegionOpenInfo{} }
+func (m *OpenRegionRequest_RegionOpenInfo) String() string { return proto1.CompactTextString(m) }
+func (*OpenRegionRequest_RegionOpenInfo) ProtoMessage()    {}
+
+func (m *OpenRegionRequest_RegionOpenInfo) GetRegion() *RegionInfo {
+	if m != nil {
+		return m.Region
+	}
+	return nil
+}
+
+func (m *OpenRegionRequest_RegionOpenInfo) GetVersionOfOfflineNode() uint32 {
+	if m != nil && m.VersionOfOfflineNode != nil {
+		return *m.VersionOfOfflineNode
+	}
+	return 0
+}
+
+func (m *OpenRegionRequest_RegionOpenInfo) GetFavoredNodes() []*ServerName {
+	if m != nil {
+		return m.FavoredNodes
+	}
+	return nil
+}
+
+func (m *OpenRegionRequest_RegionOpenInfo) GetOpenForDistributedLogReplay() bool {
+	if m != nil && m.OpenForDistributedLogReplay != nil {
+		return *m.OpenForDistributedLogReplay
+	}
+	return false
+}
+
+type OpenRegionResponse struct {
+	OpeningState     []OpenRegionResponse_RegionOpeningState `protobuf:"varint,1,rep,name=opening_state,enum=proto.OpenRegionResponse_RegionOpeningState" json:"opening_state,omitempty"`
+	XXX_unrecognized []byte                                  `json:"-"`
+}
+
+func (m *OpenRegionResponse) Reset()         { *m = OpenRegionResponse{} }
+func (m *OpenRegionResponse) String() string { return proto1.CompactTextString(m) }
+func (*OpenRegionResponse) ProtoMessage()    {}
+
+func (m *OpenRegionResponse) GetOpeningState() []OpenRegionResponse_RegionOpeningState {
+	if m != nil {
+		return m.OpeningState
+	}
+	return nil
+}
+
+// *
+// Closes the specified region and will use or not use ZK during the close
+// according to the specified flag.
+type CloseRegionRequest struct {
+	Region               *RegionSpecifier `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
+	VersionOfClosingNode *uint32          `protobuf:"varint,2,opt,name=version_of_closing_node" json:"version_of_closing_node,omitempty"`
+	TransitionIn_ZK      *bool            `protobuf:"varint,3,opt,name=transition_in_ZK,def=1" json:"transition_in_ZK,omitempty"`
+	DestinationServer    *ServerName      `protobuf:"bytes,4,opt,name=destination_server" json:"destination_server,omitempty"`
+	// the intended server for this RPC.
+	ServerStartCode  *uint64 `protobuf:"varint,5,opt,name=serverStartCode" json:"serverStartCode,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *CloseRegionRequest) Reset()         { *m = CloseRegionRequest{} }
+func (m *CloseRegionRequest) String() string { return proto1.CompactTextString(m) }
+func (*CloseRegionRequest) ProtoMessage()    {}
+
+const Default_CloseRegionRequest_TransitionIn_ZK bool = true
+
+func (m *CloseRegionRequest) GetRegion() *RegionSpecifier {
+	if m != nil {
+		return m.Region
+	}
+	return nil
+}
+
+func (m *CloseRegionRequest) GetVersionOfClosingNode() uint32 {
+	if m != nil && m.VersionOfClosingNode != nil {
+		return *m.VersionOfClosingNode
+	}
+	return 0
+}
+
+func (m *CloseRegionRequest) GetTransitionIn_ZK() bool {
+	if m != nil && m.TransitionIn_ZK != nil {
+		return *m.TransitionIn_ZK
+	}
+	return Default_CloseRegionRequest_TransitionIn_ZK
+}
+
+func (m *CloseRegionRequest) GetDestinationServer() *ServerName {
+	if m != nil {
+		return m.DestinationServer
+	}
+	return nil
+}
+
+func (m *CloseRegionRequest) GetServerStartCode() uint64 {
+	if m != nil && m.ServerStartCode != nil {
+		return *m.ServerStartCode
+	}
+	return 0
+}
+
+type CloseRegionResponse struct {
+	Closed           *bool  `protobuf:"varint,1,req,name=closed" json:"closed,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *CloseRegionResponse) Reset()         { *m = CloseRegionResponse{} }
+func (m *CloseRegionResponse) String() string { return proto1.CompactTextString(m) }
+func (*CloseRegionResponse) ProtoMessage()    {}
+
+func (m *CloseRegionResponse) GetClosed() bool {
+	if m != nil && m.Closed != nil {
+		return *m.Closed
+	}
+	return false
+}
+
+// *
+// Flushes the MemStore of the specified region.
+// <p>
+// This method is synchronous.
+type FlushRegionRequest struct {
+	Region           *RegionSpecifier `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
+	IfOlderThanTs    *uint64          `protobuf:"varint,2,opt,name=if_older_than_ts" json:"if_older_than_ts,omitempty"`
+	XXX_unrecognized []byte           `json:"-"`
+}
+
+func (m *FlushRegionRequest) Reset()         { *m = FlushRegionRequest{} }
+func (m *FlushRegionRequest) String() string { return proto1.CompactTextString(m) }
+func (*FlushRegionRequest) ProtoMessage()    {}
+
+func (m *FlushRegionRequest) GetRegion() *RegionSpecifier {
+	if m != nil {
+		return m.Region
+	}
+	return nil
+}
+
+func (m *FlushRegionRequest) GetIfOlderThanTs() uint64 {
+	if m != nil && m.IfOlderThanTs != nil {
+		return *m.IfOlderThanTs
+	}
+	return 0
+}
+
+type FlushRegionResponse struct {
+	LastFlushTime    *uint64 `protobuf:"varint,1,req,name=last_flush_time" json:"last_flush_time,omitempty"`
+	Flushed          *bool   `protobuf:"varint,2,opt,name=flushed" json:"flushed,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *FlushRegionResponse) Reset()         { *m = FlushRegionResponse{} }
+func (m *FlushRegionResponse) String() string { return proto1.CompactTextString(m) }
+func (*FlushRegionResponse) ProtoMessage()    {}
+
+func (m *FlushRegionResponse) GetLastFlushTime() uint64 {
+	if m != nil && m.LastFlushTime != nil {
+		return *m.LastFlushTime
+	}
+	return 0
+}
+
+func (m *FlushRegionResponse) GetFlushed() bool {
+	if m != nil && m.Flushed != nil {
+		return *m.Flushed
+	}
+	return false
+}
+
+// *
+// 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.
+type SplitRegionRequest struct {
+	Region           *RegionSpecifier `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
+	SplitPoint       []byte           `protobuf:"bytes,2,opt,name=split_point" json:"split_point,omitempty"`
+	XXX_unrecognized []byte           `json:"-"`
+}
+
+func (m *SplitRegionRequest) Reset()         { *m = SplitRegionRequest{} }
+func (m *SplitRegionRequest) String() string { return proto1.CompactTextString(m) }
+func (*SplitRegionRequest) ProtoMessage()    {}
+
+func (m *SplitRegionRequest) GetRegion() *RegionSpecifier {
+	if m != nil {
+		return m.Region
+	}
+	return nil
+}
+
+func (m *SplitRegionRequest) GetSplitPoint() []byte {
+	if m != nil {
+		return m.SplitPoint
+	}
+	return nil
+}
+
+type SplitRegionResponse struct {
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *SplitRegionResponse) Reset()         { *m = SplitRegionResponse{} }
+func (m *SplitRegionResponse) String() string { return proto1.CompactTextString(m) }
+func (*SplitRegionResponse) ProtoMessage()    {}
+
+// *
+// Compacts the specified region.  Performs a major compaction if specified.
+// <p>
+// This method is asynchronous.
+type CompactRegionRequest struct {
+	Region           *RegionSpecifier `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
+	Major            *bool            `protobuf:"varint,2,opt,name=major" json:"major,omitempty"`
+	Family           []byte           `protobuf:"bytes,3,opt,name=family" json:"family,omitempty"`
+	XXX_unrecognized []byte           `json:"-"`
+}
+
+func (m *CompactRegionRequest) Reset()         { *m = CompactRegionRequest{} }
+func (m *CompactRegionRequest) String() string { return proto1.CompactTextString(m) }
+func (*CompactRegionRequest) ProtoMessage()    {}
+
+func (m *CompactRegionRequest) GetRegion() *RegionSpecifier {
+	if m != nil {
+		return m.Region
+	}
+	return nil
+}
+
+func (m *CompactRegionRequest) GetMajor() bool {
+	if m != nil && m.Major != nil {
+		return *m.Major
+	}
+	return false
+}
+
+func (m *CompactRegionRequest) GetFamily() []byte {
+	if m != nil {
+		return m.Family
+	}
+	return nil
+}
+
+type CompactRegionResponse struct {
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *CompactRegionResponse) Reset()         { *m = CompactRegionResponse{} }
+func (m *CompactRegionResponse) String() string { return proto1.CompactTextString(m) }
+func (*CompactRegionResponse) ProtoMessage()    {}
+
+type UpdateFavoredNodesRequest struct {
+	UpdateInfo       []*UpdateFavoredNodesRequest_RegionUpdateInfo `protobuf:"bytes,1,rep,name=update_info" json:"update_info,omitempty"`
+	XXX_unrecognized []byte                                        `json:"-"`
+}
+
+func (m *UpdateFavoredNodesRequest) Reset()         { *m = UpdateFavoredNodesRequest{} }
+func (m *UpdateFavoredNodesRequest) String() string { return proto1.CompactTextString(m) }
+func (*UpdateFavoredNodesRequest) ProtoMessage()    {}
+
+func (m *UpdateFavoredNodesRequest) GetUpdateInfo() []*UpdateFavoredNodesRequest_RegionUpdateInfo {
+	if m != nil {
+		return m.UpdateInfo
+	}
+	return nil
+}
+
+type UpdateFavoredNodesRequest_RegionUpdateInfo struct {
+	Region           *RegionInfo   `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
+	FavoredNodes     []*ServerName `protobuf:"bytes,2,rep,name=favored_nodes" json:"favored_nodes,omitempty"`
+	XXX_unrecognized []byte        `json:"-"`
+}
+
+func (m *UpdateFavoredNodesRequest_RegionUpdateInfo) Reset() {
+	*m = UpdateFavoredNodesRequest_RegionUpdateInfo{}
+}
+func (m *UpdateFavoredNodesRequest_RegionUpdateInfo) String() string {
+	return proto1.CompactTextString(m)
+}
+func (*UpdateFavoredNodesRequest_RegionUpdateInfo) ProtoMessage() {}
+
+func (m *UpdateFavoredNodesRequest_RegionUpdateInfo) GetRegion() *RegionInfo {
+	if m != nil {
+		return m.Region
+	}
+	return nil
+}
+
+func (m *UpdateFavoredNodesRequest_RegionUpdateInfo) GetFavoredNodes() []*ServerName {
+	if m != nil {
+		return m.FavoredNodes
+	}
+	return nil
+}
+
+type UpdateFavoredNodesResponse struct {
+	Response         *uint32 `protobuf:"varint,1,opt,name=response" json:"response,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *UpdateFavoredNodesResponse) Reset()         { *m = UpdateFavoredNodesResponse{} }
+func (m *UpdateFavoredNodesResponse) String() string { return proto1.CompactTextString(m) }
+func (*UpdateFavoredNodesResponse) ProtoMessage()    {}
+
+func (m *UpdateFavoredNodesResponse) GetResponse() uint32 {
+	if m != nil && m.Response != nil {
+		return *m.Response
+	}
+	return 0
+}
+
+// *
+// Merges the specified regions.
+// <p>
+// This method currently closes the regions and then merges them
+type MergeRegionsRequest struct {
+	RegionA          *RegionSpecifier `protobuf:"bytes,1,req,name=region_a" json:"region_a,omitempty"`
+	RegionB          *RegionSpecifier `protobuf:"bytes,2,req,name=region_b" json:"region_b,omitempty"`
+	Forcible         *bool            `protobuf:"varint,3,opt,name=forcible,def=0" json:"forcible,omitempty"`
+	XXX_unrecognized []byte           `json:"-"`
+}
+
+func (m *MergeRegionsRequest) Reset()         { *m = MergeRegionsRequest{} }
+func (m *MergeRegionsRequest) String() string { return proto1.CompactTextString(m) }
+func (*MergeRegionsRequest) ProtoMessage()    {}
+
+const Default_MergeRegionsRequest_Forcible bool = false
+
+func (m *MergeRegionsRequest) GetRegionA() *RegionSpecifier {
+	if m != nil {
+		return m.RegionA
+	}
+	return nil
+}
+
+func (m *MergeRegionsRequest) GetRegionB() *RegionSpecifier {
+	if m != nil {
+		return m.RegionB
+	}
+	return nil
+}
+
+func (m *MergeRegionsRequest) GetForcible() bool {
+	if m != nil && m.Forcible != nil {
+		return *m.Forcible
+	}
+	return Default_MergeRegionsRequest_Forcible
+}
+
+type MergeRegionsResponse struct {
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *MergeRegionsResponse) Reset()         { *m = MergeRegionsResponse{} }
+func (m *MergeRegionsResponse) String() string { return proto1.CompactTextString(m) }
+func (*MergeRegionsResponse) ProtoMessage()    {}
+
+// Protocol buffer version of WAL for replication
+type WALEntry struct {
+	Key *WALKey `protobuf:"bytes,1,req,name=key" json:"key,omitempty"`
+	// 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
+	KeyValueBytes [][]byte `protobuf:"bytes,2,rep,name=key_value_bytes" json:"key_value_bytes,omitempty"`
+	// If Cell data is carried alongside in a cellblock, this is count of Cells in the cellblock.
+	AssociatedCellCount *int32 `protobuf:"varint,3,opt,name=associated_cell_count" json:"associated_cell_count,omitempty"`
+	XXX_unrecognized    []byte `json:"-"`
+}
+
+func (m *WALEntry) Reset()         { *m = WALEntry{} }
+func (m *WALEntry) String() string { return proto1.CompactTextString(m) }
+func (*WALEntry) ProtoMessage()    {}
+
+func (m *WALEntry) GetKey() *WALKey {
+	if m != nil {
+		return m.Key
+	}
+	return nil
+}
+
+func (m *WALEntry) GetKeyValueBytes() [][]byte {
+	if m != nil {
+		return m.KeyValueBytes
+	}
+	return nil
+}
+
+func (m *WALEntry) GetAssociatedCellCount() int32 {
+	if m != nil && m.AssociatedCellCount != nil {
+		return *m.AssociatedCellCount
+	}
+	return 0
+}
+
+// *
+// 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.
+type ReplicateWALEntryRequest struct {
+	Entry            []*WALEntry `protobuf:"bytes,1,rep,name=entry" json:"entry,omitempty"`
+	XXX_unrecognized []byte      `json:"-"`
+}
+
+func (m *ReplicateWALEntryRequest) Reset()         { *m = ReplicateWALEntryRequest{} }
+func (m *ReplicateWALEntryRequest) String() string { return proto1.CompactTextString(m) }
+func (*ReplicateWALEntryRequest) ProtoMessage()    {}
+
+func (m *ReplicateWALEntryRequest) GetEntry() []*WALEntry {
+	if m != nil {
+		return m.Entry
+	}
+	return nil
+}
+
+type ReplicateWALEntryResponse struct {
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *ReplicateWALEntryResponse) Reset()         { *m = ReplicateWALEntryResponse{} }
+func (m *ReplicateWALEntryResponse) String() string { return proto1.CompactTextString(m) }
+func (*ReplicateWALEntryResponse) ProtoMessage()    {}
+
+type RollWALWriterRequest struct {
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *RollWALWriterRequest) Reset()         { *m = RollWALWriterRequest{} }
+func (m *RollWALWriterRequest) String() string { return proto1.CompactTextString(m) }
+func (*RollWALWriterRequest) ProtoMessage()    {}
+
+type RollWALWriterResponse struct {
+	// A list of encoded name of regions to flush
+	RegionToFlush    [][]byte `protobuf:"bytes,1,rep,name=region_to_flush" json:"region_to_flush,omitempty"`
+	XXX_unrecognized []byte   `json:"-"`
+}
+
+func (m *RollWALWriterResponse) Reset()         { *m = RollWALWriterResponse{} }
+func (m *RollWALWriterResponse) String() string { return proto1.CompactTextString(m) }
+func (*RollWALWriterResponse) ProtoMessage()    {}
+
+func (m *RollWALWriterResponse) GetRegionToFlush() [][]byte {
+	if m != nil {
+		return m.RegionToFlush
+	}
+	return nil
+}
+
+type StopServerRequest struct {
+	Reason           *string `protobuf:"bytes,1,req,name=reason" json:"reason,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *StopServerRequest) Reset()         { *m = StopServerRequest{} }
+func (m *StopServerRequest) String() string { return proto1.CompactTextString(m) }
+func (*StopServerRequest) ProtoMessage()    {}
+
+func (m *StopServerRequest) GetReason() string {
+	if m != nil && m.Reason != nil {
+		return *m.Reason
+	}
+	return ""
+}
+
+type StopServerResponse struct {
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *StopServerResponse) Reset()         { *m = StopServerResponse{} }
+func (m *StopServerResponse) String() string { return proto1.CompactTextString(m) }
+func (*StopServerResponse) ProtoMessage()    {}
+
+type GetServerInfoRequest struct {
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *GetServerInfoRequest) Reset()         { *m = GetServerInfoRequest{} }
+func (m *GetServerInfoRequest) String() string { return proto1.CompactTextString(m) }
+func (*GetServerInfoRequest) ProtoMessage()    {}
+
+type ServerInfo struct {
+	ServerName       *ServerName `protobuf:"bytes,1,req,name=server_name" json:"server_name,omitempty"`
+	WebuiPort        *uint32     `protobuf:"varint,2,opt,name=webui_port" json:"webui_port,omitempty"`
+	XXX_unrecognized []byte      `json:"-"`
+}
+
+func (m *ServerInfo) Reset()         { *m = ServerInfo{} }
+func (m *ServerInfo) String() string { return proto1.CompactTextString(m) }
+func (*ServerInfo) ProtoMessage()    {}
+
+func (m *ServerInfo) GetServerName() *ServerName {
+	if m != nil {
+		return m.ServerName
+	}
+	return nil
+}
+
+func (m *ServerInfo) GetWebuiPort() uint32 {
+	if m != nil && m.WebuiPort != nil {
+		return *m.WebuiPort
+	}
+	return 0
+}
+
+type GetServerInfoResponse struct {
+	ServerInfo       *ServerInfo `protobuf:"bytes,1,req,name=server_info" json:"server_info,omitempty"`
+	XXX_unrecognized []byte      `json:"-"`
+}
+
+func (m *GetServerInfoResponse) Reset()         { *m = GetServerInfoResponse{} }
+func (m *GetServerInfoResponse) String() string { return proto1.CompactTextString(m) }
+func (*GetServerInfoResponse) ProtoMessage()    {}
+
+func (m *GetServerInfoResponse) GetServerInfo() *ServerInfo {
+	if m != nil {
+		return m.ServerInfo
+	}
+	return nil
+}
+
+func init() {
+	proto1.RegisterEnum("proto.GetRegionInfoResponse_CompactionState", GetRegionInfoResponse_CompactionState_name, GetRegionInfoResponse_CompactionState_value)
+	proto1.RegisterEnum("proto.OpenRegionResponse_RegionOpeningState", OpenRegionResponse_RegionOpeningState_name, OpenRegionResponse_RegionOpeningState_value)
+}

vendor/github.com/pingcap/go-hbase/proto/Aggregate.pb.go

@@ -0,0 +1,82 @@
+// Code generated by protoc-gen-go.
+// source: Aggregate.proto
+// DO NOT EDIT!
+
+package proto
+
+import proto1 "github.com/golang/protobuf/proto"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto1.Marshal
+var _ = math.Inf
+
+type AggregateRequest struct {
+	// * The request passed to the AggregateService consists of three parts
+	//  (1) the (canonical) classname of the ColumnInterpreter implementation
+	//  (2) the Scan query
+	//  (3) any bytes required to construct the ColumnInterpreter object
+	//      properly
+	InterpreterClassName     *string `protobuf:"bytes,1,req,name=interpreter_class_name" json:"interpreter_class_name,omitempty"`
+	Scan                     *Scan   `protobuf:"bytes,2,req,name=scan" json:"scan,omitempty"`
+	InterpreterSpecificBytes []byte  `protobuf:"bytes,3,opt,name=interpreter_specific_bytes" json:"interpreter_specific_bytes,omitempty"`
+	XXX_unrecognized         []byte  `json:"-"`
+}
+
+func (m *AggregateRequest) Reset()         { *m = AggregateRequest{} }
+func (m *AggregateRequest) String() string { return proto1.CompactTextString(m) }
+func (*AggregateRequest) ProtoMessage()    {}
+
+func (m *AggregateRequest) GetInterpreterClassName() string {
+	if m != nil && m.InterpreterClassName != nil {
+		return *m.InterpreterClassName
+	}
+	return ""
+}
+
+func (m *AggregateRequest) GetScan() *Scan {
+	if m != nil {
+		return m.Scan
+	}
+	return nil
+}
+
+func (m *AggregateRequest) GetInterpreterSpecificBytes() []byte {
+	if m != nil {
+		return m.InterpreterSpecificBytes
+	}
+	return nil
+}
+
+type AggregateResponse struct {
+	// *
+	// The AggregateService methods all have a response that either is a Pair
+	// or a simple object. When it is a Pair both first_part and second_part
+	// have defined values (and the second_part is not present in the response
+	// when the response is not a pair). Refer to the AggregateImplementation
+	// class for an overview of the AggregateResponse object constructions.
+	FirstPart        [][]byte `protobuf:"bytes,1,rep,name=first_part" json:"first_part,omitempty"`
+	SecondPart       []byte   `protobuf:"bytes,2,opt,name=second_part" json:"second_part,omitempty"`
+	XXX_unrecognized []byte   `json:"-"`
+}
+
+func (m *AggregateResponse) Reset()         { *m = AggregateResponse{} }
+func (m *AggregateResponse) String() string { return proto1.CompactTextString(m) }
+func (*AggregateResponse) ProtoMessage()    {}
+
+func (m *AggregateResponse) GetFirstPart() [][]byte {
+	if m != nil {
+		return m.FirstPart
+	}
+	return nil
+}
+
+func (m *AggregateResponse) GetSecondPart() []byte {
+	if m != nil {
+		return m.SecondPart
+	}
+	return nil
+}
+
+func init() {
+}

vendor/github.com/pingcap/go-hbase/proto/Authentication.pb.go

@@ -0,0 +1,228 @@
+// Code generated by protoc-gen-go.
+// source: Authentication.proto
+// DO NOT EDIT!
+
+package proto
+
+import proto1 "github.com/golang/protobuf/proto"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto1.Marshal
+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 proto1.EnumName(TokenIdentifier_Kind_name, int32(x))
+}
+func (x *TokenIdentifier_Kind) UnmarshalJSON(data []byte) error {
+	value, err := proto1.UnmarshalJSONEnum(TokenIdentifier_Kind_value, data, "TokenIdentifier_Kind")
+	if err != nil {
+		return err
+	}
+	*x = TokenIdentifier_Kind(value)
+	return nil
+}
+
+type AuthenticationKey struct {
+	Id               *int32 `protobuf:"varint,1,req,name=id" json:"id,omitempty"`
+	ExpirationDate   *int64 `protobuf:"varint,2,req,name=expiration_date" 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 proto1.CompactTextString(m) }
+func (*AuthenticationKey) ProtoMessage()    {}
+
+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=proto.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:"key_id,omitempty"`
+	IssueDate        *int64                `protobuf:"varint,4,opt,name=issue_date" json:"issue_date,omitempty"`
+	ExpirationDate   *int64                `protobuf:"varint,5,opt,name=expiration_date" json:"expiration_date,omitempty"`
+	SequenceNumber   *int64                `protobuf:"varint,6,opt,name=sequence_number" json:"sequence_number,omitempty"`
+	XXX_unrecognized []byte                `json:"-"`
+}
+
+func (m *TokenIdentifier) Reset()         { *m = TokenIdentifier{} }
+func (m *TokenIdentifier) String() string { return proto1.CompactTextString(m) }
+func (*TokenIdentifier) ProtoMessage()    {}
+
+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 proto1.CompactTextString(m) }
+func (*Token) ProtoMessage()    {}
+
+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 proto1.CompactTextString(m) }
+func (*GetAuthenticationTokenRequest) ProtoMessage()    {}
+
+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 proto1.CompactTextString(m) }
+func (*GetAuthenticationTokenResponse) ProtoMessage()    {}
+
+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 proto1.CompactTextString(m) }
+func (*WhoAmIRequest) ProtoMessage()    {}
+
+type WhoAmIResponse struct {
+	Username         *string `protobuf:"bytes,1,opt,name=username" json:"username,omitempty"`
+	AuthMethod       *string `protobuf:"bytes,2,opt,name=auth_method" json:"auth_method,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *WhoAmIResponse) Reset()         { *m = WhoAmIResponse{} }
+func (m *WhoAmIResponse) String() string { return proto1.CompactTextString(m) }
+func (*WhoAmIResponse) ProtoMessage()    {}
+
+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() {
+	proto1.RegisterEnum("proto.TokenIdentifier_Kind", TokenIdentifier_Kind_name, TokenIdentifier_Kind_value)
+}

vendor/github.com/pingcap/go-hbase/proto/Cell.pb.go

@@ -0,0 +1,197 @@
+// Code generated by protoc-gen-go.
+// source: Cell.proto
+// DO NOT EDIT!
+
+package proto
+
+import proto1 "github.com/golang/protobuf/proto"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto1.Marshal
+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 proto1.EnumName(CellType_name, int32(x))
+}
+func (x *CellType) UnmarshalJSON(data []byte) error {
+	value, err := proto1.UnmarshalJSONEnum(CellType_value, data, "CellType")
+	if err != nil {
+		return err
+	}
+	*x = CellType(value)
+	return nil
+}
+
+// *
+// 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,enum=proto.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 proto1.CompactTextString(m) }
+func (*Cell) ProtoMessage()    {}
+
+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,enum=proto.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 proto1.CompactTextString(m) }
+func (*KeyValue) ProtoMessage()    {}
+
+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() {
+	proto1.RegisterEnum("proto.CellType", CellType_name, CellType_value)
+}

vendor/github.com/pingcap/go-hbase/proto/ClusterId.pb.go

@@ -0,0 +1,35 @@
+// Code generated by protoc-gen-go.
+// source: ClusterId.proto
+// DO NOT EDIT!
+
+package proto
+
+import proto1 "github.com/golang/protobuf/proto"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto1.Marshal
+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:"cluster_id,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *ClusterId) Reset()         { *m = ClusterId{} }
+func (m *ClusterId) String() string { return proto1.CompactTextString(m) }
+func (*ClusterId) ProtoMessage()    {}
+
+func (m *ClusterId) GetClusterId() string {
+	if m != nil && m.ClusterId != nil {
+		return *m.ClusterId
+	}
+	return ""
+}
+
+func init() {
+}

vendor/github.com/pingcap/go-hbase/proto/ClusterStatus.pb.go

@@ -0,0 +1,597 @@
+// Code generated by protoc-gen-go.
+// source: ClusterStatus.proto
+// DO NOT EDIT!
+
+package proto
+
+import proto1 "github.com/golang/protobuf/proto"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto1.Marshal
+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 proto1.EnumName(RegionState_State_name, int32(x))
+}
+func (x *RegionState_State) UnmarshalJSON(data []byte) error {
+	value, err := proto1.UnmarshalJSONEnum(RegionState_State_value, data, "RegionState_State")
+	if err != nil {
+		return err
+	}
+	*x = RegionState_State(value)
+	return nil
+}
+
+type RegionState struct {
+	RegionInfo       *RegionInfo        `protobuf:"bytes,1,req,name=region_info" json:"region_info,omitempty"`
+	State            *RegionState_State `protobuf:"varint,2,req,name=state,enum=proto.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 proto1.CompactTextString(m) }
+func (*RegionState) ProtoMessage()    {}
+
+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:"region_state,omitempty"`
+	XXX_unrecognized []byte           `json:"-"`
+}
+
+func (m *RegionInTransition) Reset()         { *m = RegionInTransition{} }
+func (m *RegionInTransition) String() string { return proto1.CompactTextString(m) }
+func (*RegionInTransition) ProtoMessage()    {}
+
+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
+}
+
+type RegionLoad struct {
+	// * the region specifier
+	RegionSpecifier *RegionSpecifier `protobuf:"bytes,1,req,name=region_specifier" 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:"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:"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:"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:"storefile_index_size_MB,omitempty"`
+	// * the current total read requests made to region
+	ReadRequestsCount *uint64 `protobuf:"varint,8,opt,name=read_requests_count" json:"read_requests_count,omitempty"`
+	// * the current total write requests made to region
+	WriteRequestsCount *uint64 `protobuf:"varint,9,opt,name=write_requests_count" 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:"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:"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:"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:"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:"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:"complete_sequence_id,omitempty"`
+	// * The current data locality for region in the regionserver
+	DataLocality     *float32 `protobuf:"fixed32,16,opt,name=data_locality" json:"data_locality,omitempty"`
+	XXX_unrecognized []byte   `json:"-"`
+}
+
+func (m *RegionLoad) Reset()         { *m = RegionLoad{} }
+func (m *RegionLoad) String() string { return proto1.CompactTextString(m) }
+func (*RegionLoad) ProtoMessage()    {}
+
+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
+}
+
+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 proto1.CompactTextString(m) }
+func (*ReplicationLoadSink) ProtoMessage()    {}
+
+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 proto1.CompactTextString(m) }
+func (*ReplicationLoadSource) ProtoMessage()    {}
+
+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 *uint32 `protobuf:"varint,1,opt,name=number_of_requests" json:"number_of_requests,omitempty"`
+	// * Total Number of requests from the start of the region server.
+	TotalNumberOfRequests *uint32 `protobuf:"varint,2,opt,name=total_number_of_requests" 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:"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:"max_heap_MB,omitempty"`
+	// * Information on the load of individual regions.
+	RegionLoads []*RegionLoad `protobuf:"bytes,5,rep,name=region_loads" 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:"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:"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:"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 proto1.CompactTextString(m) }
+func (*ServerLoad) ProtoMessage()    {}
+
+func (m *ServerLoad) GetNumberOfRequests() uint32 {
+	if m != nil && m.NumberOfRequests != nil {
+		return *m.NumberOfRequests
+	}
+	return 0
+}
+
+func (m *ServerLoad) GetTotalNumberOfRequests() uint32 {
+	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:"server_load,omitempty"`
+	XXX_unrecognized []byte      `json:"-"`
+}
+
+func (m *LiveServerInfo) Reset()         { *m = LiveServerInfo{} }
+func (m *LiveServerInfo) String() string { return proto1.CompactTextString(m) }
+func (*LiveServerInfo) ProtoMessage()    {}
+
+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:"hbase_version,omitempty"`
+	LiveServers         []*LiveServerInfo        `protobuf:"bytes,2,rep,name=live_servers" json:"live_servers,omitempty"`
+	DeadServers         []*ServerName            `protobuf:"bytes,3,rep,name=dead_servers" json:"dead_servers,omitempty"`
+	RegionsInTransition []*RegionInTransition    `protobuf:"bytes,4,rep,name=regions_in_transition" json:"regions_in_transition,omitempty"`
+	ClusterId           *ClusterId               `protobuf:"bytes,5,opt,name=cluster_id" json:"cluster_id,omitempty"`
+	MasterCoprocessors  []*Coprocessor           `protobuf:"bytes,6,rep,name=master_coprocessors" 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:"backup_masters,omitempty"`
+	BalancerOn          *bool                    `protobuf:"varint,9,opt,name=balancer_on" json:"balancer_on,omitempty"`
+	XXX_unrecognized    []byte                   `json:"-"`
+}
+
+func (m *ClusterStatus) Reset()         { *m = ClusterStatus{} }
+func (m *ClusterStatus) String() string { return proto1.CompactTextString(m) }
+func (*ClusterStatus) ProtoMessage()    {}
+
+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() {
+	proto1.RegisterEnum("proto.RegionState_State", RegionState_State_name, RegionState_State_value)
+}

vendor/github.com/pingcap/go-hbase/proto/Comparator.pb.go

@@ -0,0 +1,228 @@
+// Code generated by protoc-gen-go.
+// source: Comparator.proto
+// DO NOT EDIT!
+
+package proto
+
+import proto1 "github.com/golang/protobuf/proto"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto1.Marshal
+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 proto1.EnumName(BitComparator_BitwiseOp_name, int32(x))
+}
+func (x *BitComparator_BitwiseOp) UnmarshalJSON(data []byte) error {
+	value, err := proto1.UnmarshalJSONEnum(BitComparator_BitwiseOp_value, data, "BitComparator_BitwiseOp")
+	if err != nil {
+		return err
+	}
+	*x = BitComparator_BitwiseOp(value)
+	return nil
+}
+
+type Comparator struct {
+	Name                 *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
+	SerializedComparator []byte  `protobuf:"bytes,2,opt,name=serialized_comparator" json:"serialized_comparator,omitempty"`
+	XXX_unrecognized     []byte  `json:"-"`
+}
+
+func (m *Comparator) Reset()         { *m = Comparator{} }
+func (m *Comparator) String() string { return proto1.CompactTextString(m) }
+func (*Comparator) ProtoMessage()    {}
+
+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 proto1.CompactTextString(m) }
+func (*ByteArrayComparable) ProtoMessage()    {}
+
+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 proto1.CompactTextString(m) }
+func (*BinaryComparator) ProtoMessage()    {}
+
+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 proto1.CompactTextString(m) }
+func (*LongComparator) ProtoMessage()    {}
+
+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 proto1.CompactTextString(m) }
+func (*BinaryPrefixComparator) ProtoMessage()    {}
+
+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,enum=proto.BitComparator_BitwiseOp" json:"bitwise_op,omitempty"`
+	XXX_unrecognized []byte                   `json:"-"`
+}
+
+func (m *BitComparator) Reset()         { *m = BitComparator{} }
+func (m *BitComparator) String() string { return proto1.CompactTextString(m) }
+func (*BitComparator) ProtoMessage()    {}
+
+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 proto1.CompactTextString(m) }
+func (*NullComparator) ProtoMessage()    {}
+
+type RegexStringComparator struct {
+	Pattern          *string `protobuf:"bytes,1,req,name=pattern" json:"pattern,omitempty"`
+	PatternFlags     *int32  `protobuf:"varint,2,req,name=pattern_flags" 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 proto1.CompactTextString(m) }
+func (*RegexStringComparator) ProtoMessage()    {}
+
+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 proto1.CompactTextString(m) }
+func (*SubstringComparator) ProtoMessage()    {}
+
+func (m *SubstringComparator) GetSubstr() string {
+	if m != nil && m.Substr != nil {
+		return *m.Substr
+	}
+	return ""
+}
+
+func init() {
+	proto1.RegisterEnum("proto.BitComparator_BitwiseOp", BitComparator_BitwiseOp_name, BitComparator_BitwiseOp_value)
+}

vendor/github.com/pingcap/go-hbase/proto/Encryption.pb.go

@@ -0,0 +1,63 @@
+// Code generated by protoc-gen-go.
+// source: Encryption.proto
+// DO NOT EDIT!
+
+package proto
+
+import proto1 "github.com/golang/protobuf/proto"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto1.Marshal
+var _ = math.Inf
+
+type WrappedKey struct {
+	Algorithm        *string `protobuf:"bytes,1,req,name=algorithm" json:"algorithm,omitempty"`
+	Length           *uint32 `protobuf:"varint,2,req,name=length" json:"length,omitempty"`
+	Data             []byte  `protobuf:"bytes,3,req,name=data" json:"data,omitempty"`
+	Iv               []byte  `protobuf:"bytes,4,opt,name=iv" json:"iv,omitempty"`
+	Hash             []byte  `protobuf:"bytes,5,opt,name=hash" json:"hash,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *WrappedKey) Reset()         { *m = WrappedKey{} }
+func (m *WrappedKey) String() string { return proto1.CompactTextString(m) }
+func (*WrappedKey) ProtoMessage()    {}
+
+func (m *WrappedKey) GetAlgorithm() string {
+	if m != nil && m.Algorithm != nil {
+		return *m.Algorithm
+	}
+	return ""
+}
+
+func (m *WrappedKey) GetLength() uint32 {
+	if m != nil && m.Length != nil {
+		return *m.Length
+	}
+	return 0
+}
+
+func (m *WrappedKey) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+func (m *WrappedKey) GetIv() []byte {
+	if m != nil {
+		return m.Iv
+	}
+	return nil
+}
+
+func (m *WrappedKey) GetHash() []byte {
+	if m != nil {
+		return m.Hash
+	}
+	return nil
+}
+
+func init() {
+}

vendor/github.com/pingcap/go-hbase/proto/ErrorHandling.pb.go

@@ -0,0 +1,130 @@
+// Code generated by protoc-gen-go.
+// source: ErrorHandling.proto
+// DO NOT EDIT!
+
+package proto
+
+import proto1 "github.com/golang/protobuf/proto"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto1.Marshal
+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:"declaring_class,omitempty"`
+	MethodName       *string `protobuf:"bytes,2,opt,name=method_name" json:"method_name,omitempty"`
+	FileName         *string `protobuf:"bytes,3,opt,name=file_name" json:"file_name,omitempty"`
+	LineNumber       *int32  `protobuf:"varint,4,opt,name=line_number" json:"line_number,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *StackTraceElementMessage) Reset()         { *m = StackTraceElementMessage{} }
+func (m *StackTraceElementMessage) String() string { return proto1.CompactTextString(m) }
+func (*StackTraceElementMessage) ProtoMessage()    {}
+
+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:"class_name,omitempty"`
+	Message          *string                     `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
+	ErrorInfo        []byte                      `protobuf:"bytes,3,opt,name=error_info" 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 proto1.CompactTextString(m) }
+func (*GenericExceptionMessage) ProtoMessage()    {}
+
+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:"generic_exception,omitempty"`
+	XXX_unrecognized []byte                   `json:"-"`
+}
+
+func (m *ForeignExceptionMessage) Reset()         { *m = ForeignExceptionMessage{} }
+func (m *ForeignExceptionMessage) String() string { return proto1.CompactTextString(m) }
+func (*ForeignExceptionMessage) ProtoMessage()    {}
+
+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() {
+}

vendor/github.com/pingcap/go-hbase/proto/FS.pb.go

@@ -0,0 +1,93 @@
+// Code generated by protoc-gen-go.
+// source: FS.proto
+// DO NOT EDIT!
+
+package proto
+
+import proto1 "github.com/golang/protobuf/proto"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto1.Marshal
+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 proto1.EnumName(Reference_Range_name, int32(x))
+}
+func (x *Reference_Range) UnmarshalJSON(data []byte) error {
+	value, err := proto1.UnmarshalJSONEnum(Reference_Range_value, data, "Reference_Range")
+	if err != nil {
+		return err
+	}
+	*x = Reference_Range(value)
+	return nil
+}
+
+// *
+// 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 proto1.CompactTextString(m) }
+func (*HBaseVersionFileContent) ProtoMessage()    {}
+
+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=proto.Reference_Range" json:"range,omitempty"`
+	XXX_unrecognized []byte           `json:"-"`
+}
+
+func (m *Reference) Reset()         { *m = Reference{} }
+func (m *Reference) String() string { return proto1.CompactTextString(m) }
+func (*Reference) ProtoMessage()    {}
+
+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() {
+	proto1.RegisterEnum("proto.Reference_Range", Reference_Range_name, Reference_Range_value)
+}

vendor/github.com/pingcap/go-hbase/proto/Filter.pb.go

@@ -0,0 +1,609 @@
+// Code generated by protoc-gen-go.
+// source: Filter.proto
+// DO NOT EDIT!
+
+package proto
+
+import proto1 "github.com/golang/protobuf/proto"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto1.Marshal
+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 proto1.EnumName(FilterList_Operator_name, int32(x))
+}
+func (x *FilterList_Operator) UnmarshalJSON(data []byte) error {
+	value, err := proto1.UnmarshalJSONEnum(FilterList_Operator_value, data, "FilterList_Operator")
+	if err != nil {
+		return err
+	}
+	*x = FilterList_Operator(value)
+	return nil
+}
+
+type Filter struct {
+	Name             *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
+	SerializedFilter []byte  `protobuf:"bytes,2,opt,name=serialized_filter" json:"serialized_filter,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *Filter) Reset()         { *m = Filter{} }
+func (m *Filter) String() string { return proto1.CompactTextString(m) }
+func (*Filter) ProtoMessage()    {}
+
+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 proto1.CompactTextString(m) }
+func (*ColumnCountGetFilter) ProtoMessage()    {}
+
+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:"column_offset,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *ColumnPaginationFilter) Reset()         { *m = ColumnPaginationFilter{} }
+func (m *ColumnPaginationFilter) String() string { return proto1.CompactTextString(m) }
+func (*ColumnPaginationFilter) ProtoMessage()    {}
+
+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 proto1.CompactTextString(m) }
+func (*ColumnPrefixFilter) ProtoMessage()    {}
+
+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:"min_column,omitempty"`
+	MinColumnInclusive *bool  `protobuf:"varint,2,opt,name=min_column_inclusive" json:"min_column_inclusive,omitempty"`
+	MaxColumn          []byte `protobuf:"bytes,3,opt,name=max_column" json:"max_column,omitempty"`
+	MaxColumnInclusive *bool  `protobuf:"varint,4,opt,name=max_column_inclusive" json:"max_column_inclusive,omitempty"`
+	XXX_unrecognized   []byte `json:"-"`
+}
+
+func (m *ColumnRangeFilter) Reset()         { *m = ColumnRangeFilter{} }
+func (m *ColumnRangeFilter) String() string { return proto1.CompactTextString(m) }
+func (*ColumnRangeFilter) ProtoMessage()    {}
+
+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,enum=proto.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 proto1.CompactTextString(m) }
+func (*CompareFilter) ProtoMessage()    {}
+
+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:"compare_filter,omitempty"`
+	ColumnFamily        []byte         `protobuf:"bytes,2,opt,name=column_family" json:"column_family,omitempty"`
+	ColumnQualifier     []byte         `protobuf:"bytes,3,opt,name=column_qualifier" json:"column_qualifier,omitempty"`
+	DropDependentColumn *bool          `protobuf:"varint,4,opt,name=drop_dependent_column" json:"drop_dependent_column,omitempty"`
+	XXX_unrecognized    []byte         `json:"-"`
+}
+
+func (m *DependentColumnFilter) Reset()         { *m = DependentColumnFilter{} }
+func (m *DependentColumnFilter) String() string { return proto1.CompactTextString(m) }
+func (*DependentColumnFilter) ProtoMessage()    {}
+
+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:"compare_filter,omitempty"`
+	XXX_unrecognized []byte         `json:"-"`
+}
+
+func (m *FamilyFilter) Reset()         { *m = FamilyFilter{} }
+func (m *FamilyFilter) String() string { return proto1.CompactTextString(m) }
+func (*FamilyFilter) ProtoMessage()    {}
+
+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=proto.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 proto1.CompactTextString(m) }
+func (*FilterList) ProtoMessage()    {}
+
+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 proto1.CompactTextString(m) }
+func (*FilterWrapper) ProtoMessage()    {}
+
+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 proto1.CompactTextString(m) }
+func (*FirstKeyOnlyFilter) ProtoMessage()    {}
+
+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 proto1.CompactTextString(m) }
+func (*FirstKeyValueMatchingQualifiersFilter) ProtoMessage()    {}
+
+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:"fuzzy_keys_data,omitempty"`
+	XXX_unrecognized []byte            `json:"-"`
+}
+
+func (m *FuzzyRowFilter) Reset()         { *m = FuzzyRowFilter{} }
+func (m *FuzzyRowFilter) String() string { return proto1.CompactTextString(m) }
+func (*FuzzyRowFilter) ProtoMessage()    {}
+
+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:"stop_row_key,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *InclusiveStopFilter) Reset()         { *m = InclusiveStopFilter{} }
+func (m *InclusiveStopFilter) String() string { return proto1.CompactTextString(m) }
+func (*InclusiveStopFilter) ProtoMessage()    {}
+
+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:"len_as_val,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *KeyOnlyFilter) Reset()         { *m = KeyOnlyFilter{} }
+func (m *KeyOnlyFilter) String() string { return proto1.CompactTextString(m) }
+func (*KeyOnlyFilter) ProtoMessage()    {}
+
+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:"sorted_prefixes,omitempty"`
+	XXX_unrecognized []byte   `json:"-"`
+}
+
+func (m *MultipleColumnPrefixFilter) Reset()         { *m = MultipleColumnPrefixFilter{} }
+func (m *MultipleColumnPrefixFilter) String() string { return proto1.CompactTextString(m) }
+func (*MultipleColumnPrefixFilter) ProtoMessage()    {}
+
+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:"page_size,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *PageFilter) Reset()         { *m = PageFilter{} }
+func (m *PageFilter) String() string { return proto1.CompactTextString(m) }
+func (*PageFilter) ProtoMessage()    {}
+
+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 proto1.CompactTextString(m) }
+func (*PrefixFilter) ProtoMessage()    {}
+
+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:"compare_filter,omitempty"`
+	XXX_unrecognized []byte         `json:"-"`
+}
+
+func (m *QualifierFilter) Reset()         { *m = QualifierFilter{} }
+func (m *QualifierFilter) String() string { return proto1.CompactTextString(m) }
+func (*QualifierFilter) ProtoMessage()    {}
+
+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 proto1.CompactTextString(m) }
+func (*RandomRowFilter) ProtoMessage()    {}
+
+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:"compare_filter,omitempty"`
+	XXX_unrecognized []byte         `json:"-"`
+}
+
+func (m *RowFilter) Reset()         { *m = RowFilter{} }
+func (m *RowFilter) String() string { return proto1.CompactTextString(m) }
+func (*RowFilter) ProtoMessage()    {}
+
+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:"single_column_value_filter,omitempty"`
+	XXX_unrecognized        []byte                   `json:"-"`
+}
+
+func (m *SingleColumnValueExcludeFilter) Reset()         { *m = SingleColumnValueExcludeFilter{} }
+func (m *SingleColumnValueExcludeFilter) String() string { return proto1.CompactTextString(m) }
+func (*SingleColumnValueExcludeFilter) ProtoMessage()    {}
+
+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:"column_family,omitempty"`
+	ColumnQualifier   []byte       `protobuf:"bytes,2,opt,name=column_qualifier" json:"column_qualifier,omitempty"`
+	CompareOp         *CompareType `protobuf:"varint,3,req,name=compare_op,enum=proto.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:"filter_if_missing,omitempty"`
+	LatestVersionOnly *bool        `protobuf:"varint,6,opt,name=latest_version_only" json:"latest_version_only,omitempty"`
+	XXX_unrecognized  []byte       `json:"-"`
+}
+
+func (m *SingleColumnValueFilter) Reset()         { *m = SingleColumnValueFilter{} }
+func (m *SingleColumnValueFilter) String() string { return proto1.CompactTextString(m) }
+func (*SingleColumnValueFilter) ProtoMessage()    {}
+
+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 proto1.CompactTextString(m) }
+func (*SkipFilter) ProtoMessage()    {}
+
+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"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *TimestampsFilter) Reset()         { *m = TimestampsFilter{} }
+func (m *TimestampsFilter) String() string { return proto1.CompactTextString(m) }
+func (*TimestampsFilter) ProtoMessage()    {}
+
+func (m *TimestampsFilter) GetTimestamps() []int64 {
+	if m != nil {
+		return m.Timestamps
+	}
+	return nil
+}
+
+type ValueFilter struct {
+	CompareFilter    *CompareFilter `protobuf:"bytes,1,req,name=compare_filter" json:"compare_filter,omitempty"`
+	XXX_unrecognized []byte         `json:"-"`
+}
+
+func (m *ValueFilter) Reset()         { *m = ValueFilter{} }
+func (m *ValueFilter) String() string { return proto1.CompactTextString(m) }
+func (*ValueFilter) ProtoMessage()    {}
+
+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 proto1.CompactTextString(m) }
+func (*WhileMatchFilter) ProtoMessage()    {}
+
+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 proto1.CompactTextString(m) }
+func (*FilterAllFilter) ProtoMessage()    {}
+
+func init() {
+	proto1.RegisterEnum("proto.FilterList_Operator", FilterList_Operator_name, FilterList_Operator_value)
+}

vendor/github.com/pingcap/go-hbase/proto/HBase.pb.go

@@ -0,0 +1,741 @@
+// Code generated by protoc-gen-go.
+// source: HBase.proto
+// DO NOT EDIT!
+
+package proto
+
+import proto1 "github.com/golang/protobuf/proto"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto1.Marshal
+var _ = math.Inf
+
+// Comparison operators
+type CompareType int32
+
+const (
+	CompareType_LESS             CompareType = 0
+	CompareType_LESS_OR_EQUAL    CompareType = 1
+	CompareType_EQUAL            CompareType = 2
+	CompareType_NOT_EQUAL        CompareType = 3
+	CompareType_GREATER_OR_EQUAL CompareType = 4
+	CompareType_GREATER          CompareType = 5
+	CompareType_NO_OP            CompareType = 6
+)
+
+var CompareType_name = map[int32]string{
+	0: "LESS",
+	1: "LESS_OR_EQUAL",
+	2: "EQUAL",
+	3: "NOT_EQUAL",
+	4: "GREATER_OR_EQUAL",
+	5: "GREATER",
+	6: "NO_OP",
+}
+var CompareType_value = map[string]int32{
+	"LESS":             0,
+	"LESS_OR_EQUAL":    1,
+	"EQUAL":            2,
+	"NOT_EQUAL":        3,
+	"GREATER_OR_EQUAL": 4,
+	"GREATER":          5,
+	"NO_OP":            6,
+}
+
+func (x CompareType) Enum() *CompareType {
+	p := new(CompareType)
+	*p = x
+	return p
+}
+func (x CompareType) String() string {
+	return proto1.EnumName(CompareType_name, int32(x))
+}
+func (x *CompareType) UnmarshalJSON(data []byte) error {
+	value, err := proto1.UnmarshalJSONEnum(CompareType_value, data, "CompareType")
+	if err != nil {
+		return err
+	}
+	*x = CompareType(value)
+	return nil
+}
+
+type RegionSpecifier_RegionSpecifierType int32
+
+const (
+	// <tablename>,<startkey>,<regionId>.<encodedName>
+	RegionSpecifier_REGION_NAME RegionSpecifier_RegionSpecifierType = 1
+	// hash of <tablename>,<startkey>,<regionId>
+	RegionSpecifier_ENCODED_REGION_NAME RegionSpecifier_RegionSpecifierType = 2
+)
+
+var RegionSpecifier_RegionSpecifierType_name = map[int32]string{
+	1: "REGION_NAME",
+	2: "ENCODED_REGION_NAME",
+}
+var RegionSpecifier_RegionSpecifierType_value = map[string]int32{
+	"REGION_NAME":         1,
+	"ENCODED_REGION_NAME": 2,
+}
+
+func (x RegionSpecifier_RegionSpecifierType) Enum() *RegionSpecifier_RegionSpecifierType {
+	p := new(RegionSpecifier_RegionSpecifierType)
+	*p = x
+	return p
+}
+func (x RegionSpecifier_RegionSpecifierType) String() string {
+	return proto1.EnumName(RegionSpecifier_RegionSpecifierType_name, int32(x))
+}
+func (x *RegionSpecifier_RegionSpecifierType) UnmarshalJSON(data []byte) error {
+	value, err := proto1.UnmarshalJSONEnum(RegionSpecifier_RegionSpecifierType_value, data, "RegionSpecifier_RegionSpecifierType")
+	if err != nil {
+		return err
+	}
+	*x = RegionSpecifier_RegionSpecifierType(value)
+	return nil
+}
+
+type SnapshotDescription_Type int32
+
+const (
+	SnapshotDescription_DISABLED  SnapshotDescription_Type = 0
+	SnapshotDescription_FLUSH     SnapshotDescription_Type = 1
+	SnapshotDescription_SKIPFLUSH SnapshotDescription_Type = 2
+)
+
+var SnapshotDescription_Type_name = map[int32]string{
+	0: "DISABLED",
+	1: "FLUSH",
+	2: "SKIPFLUSH",
+}
+var SnapshotDescription_Type_value = map[string]int32{
+	"DISABLED":  0,
+	"FLUSH":     1,
+	"SKIPFLUSH": 2,
+}
+
+func (x SnapshotDescription_Type) Enum() *SnapshotDescription_Type {
+	p := new(SnapshotDescription_Type)
+	*p = x
+	return p
+}
+func (x SnapshotDescription_Type) String() string {
+	return proto1.EnumName(SnapshotDescription_Type_name, int32(x))
+}
+func (x *SnapshotDescription_Type) UnmarshalJSON(data []byte) error {
+	value, err := proto1.UnmarshalJSONEnum(SnapshotDescription_Type_value, data, "SnapshotDescription_Type")
+	if err != nil {
+		return err
+	}
+	*x = SnapshotDescription_Type(value)
+	return nil
+}
+
+// *
+// Table Name
+type TableName struct {
+	Namespace        []byte `protobuf:"bytes,1,req,name=namespace" json:"namespace,omitempty"`
+	Qualifier        []byte `protobuf:"bytes,2,req,name=qualifier" json:"qualifier,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *TableName) Reset()         { *m = TableName{} }
+func (m *TableName) String() string { return proto1.CompactTextString(m) }
+func (*TableName) ProtoMessage()    {}
+
+func (m *TableName) GetNamespace() []byte {
+	if m != nil {
+		return m.Namespace
+	}
+	return nil
+}
+
+func (m *TableName) GetQualifier() []byte {
+	if m != nil {
+		return m.Qualifier
+	}
+	return nil
+}
+
+// *
+// Table Schema
+// Inspired by the rest TableSchema
+type TableSchema struct {
+	TableName        *TableName            `protobuf:"bytes,1,opt,name=table_name" json:"table_name,omitempty"`
+	Attributes       []*BytesBytesPair     `protobuf:"bytes,2,rep,name=attributes" json:"attributes,omitempty"`
+	ColumnFamilies   []*ColumnFamilySchema `protobuf:"bytes,3,rep,name=column_families" json:"column_families,omitempty"`
+	Configuration    []*NameStringPair     `protobuf:"bytes,4,rep,name=configuration" json:"configuration,omitempty"`
+	XXX_unrecognized []byte                `json:"-"`
+}
+
+func (m *TableSchema) Reset()         { *m = TableSchema{} }
+func (m *TableSchema) String() string { return proto1.CompactTextString(m) }
+func (*TableSchema) ProtoMessage()    {}
+
+func (m *TableSchema) GetTableName() *TableName {
+	if m != nil {
+		return m.TableName
+	}
+	return nil
+}
+
+func (m *TableSchema) GetAttributes() []*BytesBytesPair {
+	if m != nil {
+		return m.Attributes
+	}
+	return nil
+}
+
+func (m *TableSchema) GetColumnFamilies() []*ColumnFamilySchema {
+	if m != nil {
+		return m.ColumnFamilies
+	}
+	return nil
+}
+
+func (m *TableSchema) GetConfiguration() []*NameStringPair {
+	if m != nil {
+		return m.Configuration
+	}
+	return nil
+}
+
+// *
+// Column Family Schema
+// Inspired by the rest ColumSchemaMessage
+type ColumnFamilySchema struct {
+	Name             []byte            `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
+	Attributes       []*BytesBytesPair `protobuf:"bytes,2,rep,name=attributes" json:"attributes,omitempty"`
+	Configuration    []*NameStringPair `protobuf:"bytes,3,rep,name=configuration" json:"configuration,omitempty"`
+	XXX_unrecognized []byte            `json:"-"`
+}
+
+func (m *ColumnFamilySchema) Reset()         { *m = ColumnFamilySchema{} }
+func (m *ColumnFamilySchema) String() string { return proto1.CompactTextString(m) }
+func (*ColumnFamilySchema) ProtoMessage()    {}
+
+func (m *ColumnFamilySchema) GetName() []byte {
+	if m != nil {
+		return m.Name
+	}
+	return nil
+}
+
+func (m *ColumnFamilySchema) GetAttributes() []*BytesBytesPair {
+	if m != nil {
+		return m.Attributes
+	}
+	return nil
+}
+
+func (m *ColumnFamilySchema) GetConfiguration() []*NameStringPair {
+	if m != nil {
+		return m.Configuration
+	}
+	return nil
+}
+
+// *
+// Protocol buffer version of HRegionInfo.
+type RegionInfo struct {
+	RegionId         *uint64    `protobuf:"varint,1,req,name=region_id" json:"region_id,omitempty"`
+	TableName        *TableName `protobuf:"bytes,2,req,name=table_name" json:"table_name,omitempty"`
+	StartKey         []byte     `protobuf:"bytes,3,opt,name=start_key" json:"start_key,omitempty"`
+	EndKey           []byte     `protobuf:"bytes,4,opt,name=end_key" json:"end_key,omitempty"`
+	Offline          *bool      `protobuf:"varint,5,opt,name=offline" json:"offline,omitempty"`
+	Split            *bool      `protobuf:"varint,6,opt,name=split" json:"split,omitempty"`
+	XXX_unrecognized []byte     `json:"-"`
+}
+
+func (m *RegionInfo) Reset()         { *m = RegionInfo{} }
+func (m *RegionInfo) String() string { return proto1.CompactTextString(m) }
+func (*RegionInfo) ProtoMessage()    {}
+
+func (m *RegionInfo) GetRegionId() uint64 {
+	if m != nil && m.RegionId != nil {
+		return *m.RegionId
+	}
+	return 0
+}
+
+func (m *RegionInfo) GetTableName() *TableName {
+	if m != nil {
+		return m.TableName
+	}
+	return nil
+}
+
+func (m *RegionInfo) GetStartKey() []byte {
+	if m != nil {
+		return m.StartKey
+	}
+	return nil
+}
+
+func (m *RegionInfo) GetEndKey() []byte {
+	if m != nil {
+		return m.EndKey
+	}
+	return nil
+}
+
+func (m *RegionInfo) GetOffline() bool {
+	if m != nil && m.Offline != nil {
+		return *m.Offline
+	}
+	return false
+}
+
+func (m *RegionInfo) GetSplit() bool {
+	if m != nil && m.Split != nil {
+		return *m.Split
+	}
+	return false
+}
+
+// *
+// Protocol buffer for favored nodes
+type FavoredNodes struct {
+	FavoredNode      []*ServerName `protobuf:"bytes,1,rep,name=favored_node" json:"favored_node,omitempty"`
+	XXX_unrecognized []byte        `json:"-"`
+}
+
+func (m *FavoredNodes) Reset()         { *m = FavoredNodes{} }
+func (m *FavoredNodes) String() string { return proto1.CompactTextString(m) }
+func (*FavoredNodes) ProtoMessage()    {}
+
+func (m *FavoredNodes) GetFavoredNode() []*ServerName {
+	if m != nil {
+		return m.FavoredNode
+	}
+	return nil
+}
+
+// *
+// 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.
+type RegionSpecifier struct {
+	Type             *RegionSpecifier_RegionSpecifierType `protobuf:"varint,1,req,name=type,enum=proto.RegionSpecifier_RegionSpecifierType" json:"type,omitempty"`
+	Value            []byte                               `protobuf:"bytes,2,req,name=value" json:"value,omitempty"`
+	XXX_unrecognized []byte                               `json:"-"`
+}
+
+func (m *RegionSpecifier) Reset()         { *m = RegionSpecifier{} }
+func (m *RegionSpecifier) String() string { return proto1.CompactTextString(m) }
+func (*RegionSpecifier) ProtoMessage()    {}
+
+func (m *RegionSpecifier) GetType() RegionSpecifier_RegionSpecifierType {
+	if m != nil && m.Type != nil {
+		return *m.Type
+	}
+	return RegionSpecifier_REGION_NAME
+}
+
+func (m *RegionSpecifier) GetValue() []byte {
+	if m != nil {
+		return m.Value
+	}
+	return nil
+}
+
+// *
+// 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
+type TimeRange struct {
+	From             *uint64 `protobuf:"varint,1,opt,name=from" json:"from,omitempty"`
+	To               *uint64 `protobuf:"varint,2,opt,name=to" json:"to,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *TimeRange) Reset()         { *m = TimeRange{} }
+func (m *TimeRange) String() string { return proto1.CompactTextString(m) }
+func (*TimeRange) ProtoMessage()    {}
+
+func (m *TimeRange) GetFrom() uint64 {
+	if m != nil && m.From != nil {
+		return *m.From
+	}
+	return 0
+}
+
+func (m *TimeRange) GetTo() uint64 {
+	if m != nil && m.To != nil {
+		return *m.To
+	}
+	return 0
+}
+
+// *
+// Protocol buffer version of ServerName
+type ServerName struct {
+	HostName         *string `protobuf:"bytes,1,req,name=host_name" json:"host_name,omitempty"`
+	Port             *uint32 `protobuf:"varint,2,opt,name=port" json:"port,omitempty"`
+	StartCode        *uint64 `protobuf:"varint,3,opt,name=start_code" json:"start_code,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *ServerName) Reset()         { *m = ServerName{} }
+func (m *ServerName) String() string { return proto1.CompactTextString(m) }
+func (*ServerName) ProtoMessage()    {}
+
+func (m *ServerName) GetHostName() string {
+	if m != nil && m.HostName != nil {
+		return *m.HostName
+	}
+	return ""
+}
+
+func (m *ServerName) GetPort() uint32 {
+	if m != nil && m.Port != nil {
+		return *m.Port
+	}
+	return 0
+}
+
+func (m *ServerName) GetStartCode() uint64 {
+	if m != nil && m.StartCode != nil {
+		return *m.StartCode
+	}
+	return 0
+}
+
+type Coprocessor struct {
+	Name             *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *Coprocessor) Reset()         { *m = Coprocessor{} }
+func (m *Coprocessor) String() string { return proto1.CompactTextString(m) }
+func (*Coprocessor) ProtoMessage()    {}
+
+func (m *Coprocessor) GetName() string {
+	if m != nil && m.Name != nil {
+		return *m.Name
+	}
+	return ""
+}
+
+type NameStringPair struct {
+	Name             *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
+	Value            *string `protobuf:"bytes,2,req,name=value" json:"value,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *NameStringPair) Reset()         { *m = NameStringPair{} }
+func (m *NameStringPair) String() string { return proto1.CompactTextString(m) }
+func (*NameStringPair) ProtoMessage()    {}
+
+func (m *NameStringPair) GetName() string {
+	if m != nil && m.Name != nil {
+		return *m.Name
+	}
+	return ""
+}
+
+func (m *NameStringPair) GetValue() string {
+	if m != nil && m.Value != nil {
+		return *m.Value
+	}
+	return ""
+}
+
+type NameBytesPair struct {
+	Name             *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
+	Value            []byte  `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *NameBytesPair) Reset()         { *m = NameBytesPair{} }
+func (m *NameBytesPair) String() string { return proto1.CompactTextString(m) }
+func (*NameBytesPair) ProtoMessage()    {}
+
+func (m *NameBytesPair) GetName() string {
+	if m != nil && m.Name != nil {
+		return *m.Name
+	}
+	return ""
+}
+
+func (m *NameBytesPair) GetValue() []byte {
+	if m != nil {
+		return m.Value
+	}
+	return nil
+}
+
+type BytesBytesPair struct {
+	First            []byte `protobuf:"bytes,1,req,name=first" json:"first,omitempty"`
+	Second           []byte `protobuf:"bytes,2,req,name=second" json:"second,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *BytesBytesPair) Reset()         { *m = BytesBytesPair{} }
+func (m *BytesBytesPair) String() string { return proto1.CompactTextString(m) }
+func (*BytesBytesPair) ProtoMessage()    {}
+
+func (m *BytesBytesPair) GetFirst() []byte {
+	if m != nil {
+		return m.First
+	}
+	return nil
+}
+
+func (m *BytesBytesPair) GetSecond() []byte {
+	if m != nil {
+		return m.Second
+	}
+	return nil
+}
+
+type NameInt64Pair struct {
+	Name             *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+	Value            *int64  `protobuf:"varint,2,opt,name=value" json:"value,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *NameInt64Pair) Reset()         { *m = NameInt64Pair{} }
+func (m *NameInt64Pair) String() string { return proto1.CompactTextString(m) }
+func (*NameInt64Pair) ProtoMessage()    {}
+
+func (m *NameInt64Pair) GetName() string {
+	if m != nil && m.Name != nil {
+		return *m.Name
+	}
+	return ""
+}
+
+func (m *NameInt64Pair) GetValue() int64 {
+	if m != nil && m.Value != nil {
+		return *m.Value
+	}
+	return 0
+}
+
+// *
+// Description of the snapshot to take
+type SnapshotDescription struct {
+	Name             *string                   `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
+	Table            *string                   `protobuf:"bytes,2,opt,name=table" json:"table,omitempty"`
+	CreationTime     *int64                    `protobuf:"varint,3,opt,name=creation_time,def=0" json:"creation_time,omitempty"`
+	Type             *SnapshotDescription_Type `protobuf:"varint,4,opt,name=type,enum=proto.SnapshotDescription_Type,def=1" json:"type,omitempty"`
+	Version          *int32                    `protobuf:"varint,5,opt,name=version" json:"version,omitempty"`
+	XXX_unrecognized []byte                    `json:"-"`
+}
+
+func (m *SnapshotDescription) Reset()         { *m = SnapshotDescription{} }
+func (m *SnapshotDescription) String() string { return proto1.CompactTextString(m) }
+func (*SnapshotDescription) ProtoMessage()    {}
+
+const Default_SnapshotDescription_CreationTime int64 = 0
+const Default_SnapshotDescription_Type SnapshotDescription_Type = SnapshotDescription_FLUSH
+
+func (m *SnapshotDescription) GetName() string {
+	if m != nil && m.Name != nil {
+		return *m.Name
+	}
+	return ""
+}
+
+func (m *SnapshotDescription) GetTable() string {
+	if m != nil && m.Table != nil {
+		return *m.Table
+	}
+	return ""
+}
+
+func (m *SnapshotDescription) GetCreationTime() int64 {
+	if m != nil && m.CreationTime != nil {
+		return *m.CreationTime
+	}
+	return Default_SnapshotDescription_CreationTime
+}
+
+func (m *SnapshotDescription) GetType() SnapshotDescription_Type {
+	if m != nil && m.Type != nil {
+		return *m.Type
+	}
+	return Default_SnapshotDescription_Type
+}
+
+func (m *SnapshotDescription) GetVersion() int32 {
+	if m != nil && m.Version != nil {
+		return *m.Version
+	}
+	return 0
+}
+
+// *
+// Description of the distributed procedure to take
+type ProcedureDescription struct {
+	Signature        *string           `protobuf:"bytes,1,req,name=signature" json:"signature,omitempty"`
+	Instance         *string           `protobuf:"bytes,2,opt,name=instance" json:"instance,omitempty"`
+	CreationTime     *int64            `protobuf:"varint,3,opt,name=creation_time,def=0" json:"creation_time,omitempty"`
+	Configuration    []*NameStringPair `protobuf:"bytes,4,rep,name=configuration" json:"configuration,omitempty"`
+	XXX_unrecognized []byte            `json:"-"`
+}
+
+func (m *ProcedureDescription) Reset()         { *m = ProcedureDescription{} }
+func (m *ProcedureDescription) String() string { return proto1.CompactTextString(m) }
+func (*ProcedureDescription) ProtoMessage()    {}
+
+const Default_ProcedureDescription_CreationTime int64 = 0
+
+func (m *ProcedureDescription) GetSignature() string {
+	if m != nil && m.Signature != nil {
+		return *m.Signature
+	}
+	return ""
+}
+
+func (m *ProcedureDescription) GetInstance() string {
+	if m != nil && m.Instance != nil {
+		return *m.Instance
+	}
+	return ""
+}
+
+func (m *ProcedureDescription) GetCreationTime() int64 {
+	if m != nil && m.CreationTime != nil {
+		return *m.CreationTime
+	}
+	return Default_ProcedureDescription_CreationTime
+}
+
+func (m *ProcedureDescription) GetConfiguration() []*NameStringPair {
+	if m != nil {
+		return m.Configuration
+	}
+	return nil
+}
+
+type EmptyMsg struct {
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *EmptyMsg) Reset()         { *m = EmptyMsg{} }
+func (m *EmptyMsg) String() string { return proto1.CompactTextString(m) }
+func (*EmptyMsg) ProtoMessage()    {}
+
+type LongMsg struct {
+	LongMsg          *int64 `protobuf:"varint,1,req,name=long_msg" json:"long_msg,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *LongMsg) Reset()         { *m = LongMsg{} }
+func (m *LongMsg) String() string { return proto1.CompactTextString(m) }
+func (*LongMsg) ProtoMessage()    {}
+
+func (m *LongMsg) GetLongMsg() int64 {
+	if m != nil && m.LongMsg != nil {
+		return *m.LongMsg
+	}
+	return 0
+}
+
+type DoubleMsg struct {
+	DoubleMsg        *float64 `protobuf:"fixed64,1,req,name=double_msg" json:"double_msg,omitempty"`
+	XXX_unrecognized []byte   `json:"-"`
+}
+
+func (m *DoubleMsg) Reset()         { *m = DoubleMsg{} }
+func (m *DoubleMsg) String() string { return proto1.CompactTextString(m) }
+func (*DoubleMsg) ProtoMessage()    {}
+
+func (m *DoubleMsg) GetDoubleMsg() float64 {
+	if m != nil && m.DoubleMsg != nil {
+		return *m.DoubleMsg
+	}
+	return 0
+}
+
+type BigDecimalMsg struct {
+	BigdecimalMsg    []byte `protobuf:"bytes,1,req,name=bigdecimal_msg" json:"bigdecimal_msg,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *BigDecimalMsg) Reset()         { *m = BigDecimalMsg{} }
+func (m *BigDecimalMsg) String() string { return proto1.CompactTextString(m) }
+func (*BigDecimalMsg) ProtoMessage()    {}
+
+func (m *BigDecimalMsg) GetBigdecimalMsg() []byte {
+	if m != nil {
+		return m.BigdecimalMsg
+	}
+	return nil
+}
+
+type UUID struct {
+	LeastSigBits     *uint64 `protobuf:"varint,1,req,name=least_sig_bits" json:"least_sig_bits,omitempty"`
+	MostSigBits      *uint64 `protobuf:"varint,2,req,name=most_sig_bits" json:"most_sig_bits,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *UUID) Reset()         { *m = UUID{} }
+func (m *UUID) String() string { return proto1.CompactTextString(m) }
+func (*UUID) ProtoMessage()    {}
+
+func (m *UUID) GetLeastSigBits() uint64 {
+	if m != nil && m.LeastSigBits != nil {
+		return *m.LeastSigBits
+	}
+	return 0
+}
+
+func (m *UUID) GetMostSigBits() uint64 {
+	if m != nil && m.MostSigBits != nil {
+		return *m.MostSigBits
+	}
+	return 0
+}
+
+type NamespaceDescriptor struct {
+	Name             []byte            `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
+	Configuration    []*NameStringPair `protobuf:"bytes,2,rep,name=configuration" json:"configuration,omitempty"`
+	XXX_unrecognized []byte            `json:"-"`
+}
+
+func (m *NamespaceDescriptor) Reset()         { *m = NamespaceDescriptor{} }
+func (m *NamespaceDescriptor) String() string { return proto1.CompactTextString(m) }
+func (*NamespaceDescriptor) ProtoMessage()    {}
+
+func (m *NamespaceDescriptor) GetName() []byte {
+	if m != nil {
+		return m.Name
+	}
+	return nil
+}
+
+func (m *NamespaceDescriptor) GetConfiguration() []*NameStringPair {
+	if m != nil {
+		return m.Configuration
+	}
+	return nil
+}
+
+// *
+// Description of the region server info
+type RegionServerInfo struct {
+	InfoPort         *int32 `protobuf:"varint,1,opt,name=infoPort" json:"infoPort,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *RegionServerInfo) Reset()         { *m = RegionServerInfo{} }
+func (m *RegionServerInfo) String() string { return proto1.CompactTextString(m) }
+func (*RegionServerInfo) ProtoMessage()    {}
+
+func (m *RegionServerInfo) GetInfoPort() int32 {
+	if m != nil && m.InfoPort != nil {
+		return *m.InfoPort
+	}
+	return 0
+}
+
+func init() {
+	proto1.RegisterEnum("proto.CompareType", CompareType_name, CompareType_value)
+	proto1.RegisterEnum("proto.RegionSpecifier_RegionSpecifierType", RegionSpecifier_RegionSpecifierType_name, RegionSpecifier_RegionSpecifierType_value)
+	proto1.RegisterEnum("proto.SnapshotDescription_Type", SnapshotDescription_Type_name, SnapshotDescription_Type_value)
+}

vendor/github.com/pingcap/go-hbase/proto/HFile.pb.go

@@ -0,0 +1,145 @@
+// Code generated by protoc-gen-go.
+// source: HFile.proto
+// DO NOT EDIT!
+
+package proto
+
+import proto1 "github.com/golang/protobuf/proto"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto1.Marshal
+var _ = math.Inf
+
+// Map of name/values
+type FileInfoProto struct {
+	MapEntry         []*BytesBytesPair `protobuf:"bytes,1,rep,name=map_entry" json:"map_entry,omitempty"`
+	XXX_unrecognized []byte            `json:"-"`
+}
+
+func (m *FileInfoProto) Reset()         { *m = FileInfoProto{} }
+func (m *FileInfoProto) String() string { return proto1.CompactTextString(m) }
+func (*FileInfoProto) ProtoMessage()    {}
+
+func (m *FileInfoProto) GetMapEntry() []*BytesBytesPair {
+	if m != nil {
+		return m.MapEntry
+	}
+	return nil
+}
+
+// HFile file trailer
+type FileTrailerProto struct {
+	FileInfoOffset            *uint64 `protobuf:"varint,1,opt,name=file_info_offset" json:"file_info_offset,omitempty"`
+	LoadOnOpenDataOffset      *uint64 `protobuf:"varint,2,opt,name=load_on_open_data_offset" json:"load_on_open_data_offset,omitempty"`
+	UncompressedDataIndexSize *uint64 `protobuf:"varint,3,opt,name=uncompressed_data_index_size" json:"uncompressed_data_index_size,omitempty"`
+	TotalUncompressedBytes    *uint64 `protobuf:"varint,4,opt,name=total_uncompressed_bytes" json:"total_uncompressed_bytes,omitempty"`
+	DataIndexCount            *uint32 `protobuf:"varint,5,opt,name=data_index_count" json:"data_index_count,omitempty"`
+	MetaIndexCount            *uint32 `protobuf:"varint,6,opt,name=meta_index_count" json:"meta_index_count,omitempty"`
+	EntryCount                *uint64 `protobuf:"varint,7,opt,name=entry_count" json:"entry_count,omitempty"`
+	NumDataIndexLevels        *uint32 `protobuf:"varint,8,opt,name=num_data_index_levels" json:"num_data_index_levels,omitempty"`
+	FirstDataBlockOffset      *uint64 `protobuf:"varint,9,opt,name=first_data_block_offset" json:"first_data_block_offset,omitempty"`
+	LastDataBlockOffset       *uint64 `protobuf:"varint,10,opt,name=last_data_block_offset" json:"last_data_block_offset,omitempty"`
+	ComparatorClassName       *string `protobuf:"bytes,11,opt,name=comparator_class_name" json:"comparator_class_name,omitempty"`
+	CompressionCodec          *uint32 `protobuf:"varint,12,opt,name=compression_codec" json:"compression_codec,omitempty"`
+	EncryptionKey             []byte  `protobuf:"bytes,13,opt,name=encryption_key" json:"encryption_key,omitempty"`
+	XXX_unrecognized          []byte  `json:"-"`
+}
+
+func (m *FileTrailerProto) Reset()         { *m = FileTrailerProto{} }
+func (m *FileTrailerProto) String() string { return proto1.CompactTextString(m) }
+func (*FileTrailerProto) ProtoMessage()    {}
+
+func (m *FileTrailerProto) GetFileInfoOffset() uint64 {
+	if m != nil && m.FileInfoOffset != nil {
+		return *m.FileInfoOffset
+	}
+	return 0
+}
+
+func (m *FileTrailerProto) GetLoadOnOpenDataOffset() uint64 {
+	if m != nil && m.LoadOnOpenDataOffset != nil {
+		return *m.LoadOnOpenDataOffset
+	}
+	return 0
+}
+
+func (m *FileTrailerProto) GetUncompressedDataIndexSize() uint64 {
+	if m != nil && m.UncompressedDataIndexSize != nil {
+		return *m.UncompressedDataIndexSize
+	}
+	return 0
+}
+
+func (m *FileTrailerProto) GetTotalUncompressedBytes() uint64 {
+	if m != nil && m.TotalUncompressedBytes != nil {
+		return *m.TotalUncompressedBytes
+	}
+	return 0
+}
+
+func (m *FileTrailerProto) GetDataIndexCount() uint32 {
+	if m != nil && m.DataIndexCount != nil {
+		return *m.DataIndexCount
+	}
+	return 0
+}
+
+func (m *FileTrailerProto) GetMetaIndexCount() uint32 {
+	if m != nil && m.MetaIndexCount != nil {
+		return *m.MetaIndexCount
+	}
+	return 0
+}
+
+func (m *FileTrailerProto) GetEntryCount() uint64 {
+	if m != nil && m.EntryCount != nil {
+		return *m.EntryCount
+	}
+	return 0
+}
+
+func (m *FileTrailerProto) GetNumDataIndexLevels() uint32 {
+	if m != nil && m.NumDataIndexLevels != nil {
+		return *m.NumDataIndexLevels
+	}
+	return 0
+}
+
+func (m *FileTrailerProto) GetFirstDataBlockOffset() uint64 {
+	if m != nil && m.FirstDataBlockOffset != nil {
+		return *m.FirstDataBlockOffset
+	}
+	return 0
+}
+
+func (m *FileTrailerProto) GetLastDataBlockOffset() uint64 {
+	if m != nil && m.LastDataBlockOffset != nil {
+		return *m.LastDataBlockOffset
+	}
+	return 0
+}
+
+func (m *FileTrailerProto) GetComparatorClassName() string {
+	if m != nil && m.ComparatorClassName != nil {
+		return *m.ComparatorClassName
+	}
+	return ""
+}
+
+func (m *FileTrailerProto) GetCompressionCodec() uint32 {
+	if m != nil && m.CompressionCodec != nil {
+		return *m.CompressionCodec
+	}
+	return 0
+}
+
+func (m *FileTrailerProto) GetEncryptionKey() []byte {
+	if m != nil {
+		return m.EncryptionKey
+	}
+	return nil
+}
+
+func init() {
+}

vendor/github.com/pingcap/go-hbase/proto/LoadBalancer.pb.go

@@ -0,0 +1,31 @@
+// Code generated by protoc-gen-go.
+// source: LoadBalancer.proto
+// DO NOT EDIT!
+
+package proto
+
+import proto1 "github.com/golang/protobuf/proto"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto1.Marshal
+var _ = math.Inf
+
+type LoadBalancerState struct {
+	BalancerOn       *bool  `protobuf:"varint,1,opt,name=balancer_on" json:"balancer_on,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *LoadBalancerState) Reset()         { *m = LoadBalancerState{} }
+func (m *LoadBalancerState) String() string { return proto1.CompactTextString(m) }
+func (*LoadBalancerState) ProtoMessage()    {}
+
+func (m *LoadBalancerState) GetBalancerOn() bool {
+	if m != nil && m.BalancerOn != nil {
+		return *m.BalancerOn
+	}
+	return false
+}
+
+func init() {
+}

vendor/github.com/pingcap/go-hbase/proto/MapReduce.pb.go

@@ -0,0 +1,63 @@
+// Code generated by protoc-gen-go.
+// source: MapReduce.proto
+// DO NOT EDIT!
+
+package proto
+
+import proto1 "github.com/golang/protobuf/proto"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto1.Marshal
+var _ = math.Inf
+
+type ScanMetrics struct {
+	Metrics          []*NameInt64Pair `protobuf:"bytes,1,rep,name=metrics" json:"metrics,omitempty"`
+	XXX_unrecognized []byte           `json:"-"`
+}
+
+func (m *ScanMetrics) Reset()         { *m = ScanMetrics{} }
+func (m *ScanMetrics) String() string { return proto1.CompactTextString(m) }
+func (*ScanMetrics) ProtoMessage()    {}
+
+func (m *ScanMetrics) GetMetrics() []*NameInt64Pair {
+	if m != nil {
+		return m.Metrics
+	}
+	return nil
+}
+
+type TableSnapshotRegionSplit struct {
+	Locations        []string     `protobuf:"bytes,2,rep,name=locations" json:"locations,omitempty"`
+	Table            *TableSchema `protobuf:"bytes,3,opt,name=table" json:"table,omitempty"`
+	Region           *RegionInfo  `protobuf:"bytes,4,opt,name=region" json:"region,omitempty"`
+	XXX_unrecognized []byte       `json:"-"`
+}
+
+func (m *TableSnapshotRegionSplit) Reset()         { *m = TableSnapshotRegionSplit{} }
+func (m *TableSnapshotRegionSplit) String() string { return proto1.CompactTextString(m) }
+func (*TableSnapshotRegionSplit) ProtoMessage()    {}
+
+func (m *TableSnapshotRegionSplit) GetLocations() []string {
+	if m != nil {
+		return m.Locations
+	}
+	return nil
+}
+
+func (m *TableSnapshotRegionSplit) GetTable() *TableSchema {
+	if m != nil {
+		return m.Table
+	}
+	return nil
+}
+
+func (m *TableSnapshotRegionSplit) GetRegion() *RegionInfo {
+	if m != nil {
+		return m.Region
+	}
+	return nil
+}
+
+func init() {
+}

vendor/github.com/pingcap/go-hbase/proto/MultiRowMutation.pb.go

@@ -0,0 +1,71 @@
+// Code generated by protoc-gen-go.
+// source: MultiRowMutation.proto
+// DO NOT EDIT!
+
+package proto
+
+import proto1 "github.com/golang/protobuf/proto"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto1.Marshal
+var _ = math.Inf
+
+type MultiRowMutationProcessorRequest struct {
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *MultiRowMutationProcessorRequest) Reset()         { *m = MultiRowMutationProcessorRequest{} }
+func (m *MultiRowMutationProcessorRequest) String() string { return proto1.CompactTextString(m) }
+func (*MultiRowMutationProcessorRequest) ProtoMessage()    {}
+
+type MultiRowMutationProcessorResponse struct {
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *MultiRowMutationProcessorResponse) Reset()         { *m = MultiRowMutationProcessorResponse{} }
+func (m *MultiRowMutationProcessorResponse) String() string { return proto1.CompactTextString(m) }
+func (*MultiRowMutationProcessorResponse) ProtoMessage()    {}
+
+type MutateRowsRequest struct {
+	MutationRequest  []*MutationProto `protobuf:"bytes,1,rep,name=mutation_request" json:"mutation_request,omitempty"`
+	NonceGroup       *uint64          `protobuf:"varint,2,opt,name=nonce_group" 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 proto1.CompactTextString(m) }
+func (*MutateRowsRequest) ProtoMessage()    {}
+
+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 proto1.CompactTextString(m) }
+func (*MutateRowsResponse) ProtoMessage()    {}
+
+func init() {
+}

vendor/github.com/pingcap/go-hbase/proto/RPC.pb.go

@@ -0,0 +1,319 @@
+// Code generated by protoc-gen-go.
+// source: RPC.proto
+// DO NOT EDIT!
+
+package proto
+
+import proto1 "github.com/golang/protobuf/proto"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto1.Marshal
+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:"effective_user,omitempty"`
+	RealUser         *string `protobuf:"bytes,2,opt,name=real_user" json:"real_user,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *UserInformation) Reset()         { *m = UserInformation{} }
+func (m *UserInformation) String() string { return proto1.CompactTextString(m) }
+func (*UserInformation) ProtoMessage()    {}
+
+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 ""
+}
+
+// Rpc client version info proto. Included in ConnectionHeader on connection setup
+type VersionInfo struct {
+	Version          *string `protobuf:"bytes,1,req,name=version" json:"version,omitempty"`
+	Url              *string `protobuf:"bytes,2,req,name=url" json:"url,omitempty"`
+	Revision         *string `protobuf:"bytes,3,req,name=revision" json:"revision,omitempty"`
+	User             *string `protobuf:"bytes,4,req,name=user" json:"user,omitempty"`
+	Date             *string `protobuf:"bytes,5,req,name=date" json:"date,omitempty"`
+	SrcChecksum      *string `protobuf:"bytes,6,req,name=src_checksum" json:"src_checksum,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *VersionInfo) Reset()         { *m = VersionInfo{} }
+func (m *VersionInfo) String() string { return proto1.CompactTextString(m) }
+func (*VersionInfo) ProtoMessage()    {}
+
+func (m *VersionInfo) GetVersion() string {
+	if m != nil && m.Version != nil {
+		return *m.Version
+	}
+	return ""
+}
+
+func (m *VersionInfo) GetUrl() string {
+	if m != nil && m.Url != nil {
+		return *m.Url
+	}
+	return ""
+}
+
+func (m *VersionInfo) GetRevision() string {
+	if m != nil && m.Revision != nil {
+		return *m.Revision
+	}
+	return ""
+}
+
+func (m *VersionInfo) GetUser() string {
+	if m != nil && m.User != nil {
+		return *m.User
+	}
+	return ""
+}
+
+func (m *VersionInfo) GetDate() string {
+	if m != nil && m.Date != nil {
+		return *m.Date
+	}
+	return ""
+}
+
+func (m *VersionInfo) GetSrcChecksum() string {
+	if m != nil && m.SrcChecksum != nil {
+		return *m.SrcChecksum
+	}
+	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:"user_info,omitempty"`
+	ServiceName *string          `protobuf:"bytes,2,opt,name=service_name" 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:"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:"cell_block_compressor_class,omitempty"`
+	VersionInfo              *VersionInfo `protobuf:"bytes,5,opt,name=version_info" json:"version_info,omitempty"`
+	XXX_unrecognized         []byte       `json:"-"`
+}
+
+func (m *ConnectionHeader) Reset()         { *m = ConnectionHeader{} }
+func (m *ConnectionHeader) String() string { return proto1.CompactTextString(m) }
+func (*ConnectionHeader) ProtoMessage()    {}
+
+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 proto1.CompactTextString(m) }
+func (*CellBlockMeta) ProtoMessage()    {}
+
+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:"exception_class_name,omitempty"`
+	// Exception stack trace from the server side
+	StackTrace *string `protobuf:"bytes,2,opt,name=stack_trace" 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:"do_not_retry,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *ExceptionResponse) Reset()         { *m = ExceptionResponse{} }
+func (m *ExceptionResponse) String() string { return proto1.CompactTextString(m) }
+func (*ExceptionResponse) ProtoMessage()    {}
+
+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:"call_id,omitempty"`
+	TraceInfo  *RPCTInfo `protobuf:"bytes,2,opt,name=trace_info" json:"trace_info,omitempty"`
+	MethodName *string   `protobuf:"bytes,3,opt,name=method_name" json:"method_name,omitempty"`
+	// If true, then a pb Message param follows.
+	RequestParam *bool `protobuf:"varint,4,opt,name=request_param" json:"request_param,omitempty"`
+	// If present, then an encoded data block follows.
+	CellBlockMeta *CellBlockMeta `protobuf:"bytes,5,opt,name=cell_block_meta" json:"cell_block_meta,omitempty"`
+	// 0 is NORMAL priority.  100 is HIGH.  If no priority, treat it as NORMAL.
+	// See HConstants.
+	Priority         *uint32 `protobuf:"varint,6,opt,name=priority" json:"priority,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *RequestHeader) Reset()         { *m = RequestHeader{} }
+func (m *RequestHeader) String() string { return proto1.CompactTextString(m) }
+func (*RequestHeader) ProtoMessage()    {}
+
+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
+}
+
+type ResponseHeader struct {
+	CallId *uint32 `protobuf:"varint,1,opt,name=call_id" 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:"cell_block_meta,omitempty"`
+	XXX_unrecognized []byte         `json:"-"`
+}
+
+func (m *ResponseHeader) Reset()         { *m = ResponseHeader{} }
+func (m *ResponseHeader) String() string { return proto1.CompactTextString(m) }
+func (*ResponseHeader) ProtoMessage()    {}
+
+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() {
+}

vendor/github.com/pingcap/go-hbase/proto/RegionServerStatus.pb.go

@@ -0,0 +1,310 @@
+// Code generated by protoc-gen-go.
+// source: RegionServerStatus.proto
+// DO NOT EDIT!
+
+package proto
+
+import proto1 "github.com/golang/protobuf/proto"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto1.Marshal
+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 proto1.EnumName(RegionStateTransition_TransitionCode_name, int32(x))
+}
+func (x *RegionStateTransition_TransitionCode) UnmarshalJSON(data []byte) error {
+	value, err := proto1.UnmarshalJSONEnum(RegionStateTransition_TransitionCode_value, data, "RegionStateTransition_TransitionCode")
+	if err != nil {
+		return err
+	}
+	*x = RegionStateTransition_TransitionCode(value)
+	return nil
+}
+
+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:"server_start_code,omitempty"`
+	// * Current time of the region server in ms
+	ServerCurrentTime *uint64 `protobuf:"varint,3,req,name=server_current_time" json:"server_current_time,omitempty"`
+	XXX_unrecognized  []byte  `json:"-"`
+}
+
+func (m *RegionServerStartupRequest) Reset()         { *m = RegionServerStartupRequest{} }
+func (m *RegionServerStartupRequest) String() string { return proto1.CompactTextString(m) }
+func (*RegionServerStartupRequest) ProtoMessage()    {}
+
+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
+}
+
+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:"map_entries,omitempty"`
+	XXX_unrecognized []byte            `json:"-"`
+}
+
+func (m *RegionServerStartupResponse) Reset()         { *m = RegionServerStartupResponse{} }
+func (m *RegionServerStartupResponse) String() string { return proto1.CompactTextString(m) }
+func (*RegionServerStartupResponse) ProtoMessage()    {}
+
+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 proto1.CompactTextString(m) }
+func (*RegionServerReportRequest) ProtoMessage()    {}
+
+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 proto1.CompactTextString(m) }
+func (*RegionServerReportResponse) ProtoMessage()    {}
+
+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:"error_message,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *ReportRSFatalErrorRequest) Reset()         { *m = ReportRSFatalErrorRequest{} }
+func (m *ReportRSFatalErrorRequest) String() string { return proto1.CompactTextString(m) }
+func (*ReportRSFatalErrorRequest) ProtoMessage()    {}
+
+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 proto1.CompactTextString(m) }
+func (*ReportRSFatalErrorResponse) ProtoMessage()    {}
+
+type GetLastFlushedSequenceIdRequest struct {
+	// * region name
+	RegionName       []byte `protobuf:"bytes,1,req,name=region_name" json:"region_name,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *GetLastFlushedSequenceIdRequest) Reset()         { *m = GetLastFlushedSequenceIdRequest{} }
+func (m *GetLastFlushedSequenceIdRequest) String() string { return proto1.CompactTextString(m) }
+func (*GetLastFlushedSequenceIdRequest) ProtoMessage()    {}
+
+func (m *GetLastFlushedSequenceIdRequest) GetRegionName() []byte {
+	if m != nil {
+		return m.RegionName
+	}
+	return nil
+}
+
+type GetLastFlushedSequenceIdResponse struct {
+	// * the last HLog sequence id flushed from MemStore to HFile for the region
+	LastFlushedSequenceId *uint64 `protobuf:"varint,1,req,name=last_flushed_sequence_id" json:"last_flushed_sequence_id,omitempty"`
+	XXX_unrecognized      []byte  `json:"-"`
+}
+
+func (m *GetLastFlushedSequenceIdResponse) Reset()         { *m = GetLastFlushedSequenceIdResponse{} }
+func (m *GetLastFlushedSequenceIdResponse) String() string { return proto1.CompactTextString(m) }
+func (*GetLastFlushedSequenceIdResponse) ProtoMessage()    {}
+
+func (m *GetLastFlushedSequenceIdResponse) GetLastFlushedSequenceId() uint64 {
+	if m != nil && m.LastFlushedSequenceId != nil {
+		return *m.LastFlushedSequenceId
+	}
+	return 0
+}
+
+type RegionStateTransition struct {
+	TransitionCode *RegionStateTransition_TransitionCode `protobuf:"varint,1,req,name=transition_code,enum=proto.RegionStateTransition_TransitionCode" json:"transition_code,omitempty"`
+	// * Mutliple regions are involved during merging/splitting
+	RegionInfo []*RegionInfo `protobuf:"bytes,2,rep,name=region_info" 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:"open_seq_num,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *RegionStateTransition) Reset()         { *m = RegionStateTransition{} }
+func (m *RegionStateTransition) String() string { return proto1.CompactTextString(m) }
+func (*RegionStateTransition) ProtoMessage()    {}
+
+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 proto1.CompactTextString(m) }
+func (*ReportRegionStateTransitionRequest) ProtoMessage()    {}
+
+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:"error_message,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *ReportRegionStateTransitionResponse) Reset()         { *m = ReportRegionStateTransitionResponse{} }
+func (m *ReportRegionStateTransitionResponse) String() string { return proto1.CompactTextString(m) }
+func (*ReportRegionStateTransitionResponse) ProtoMessage()    {}
+
+func (m *ReportRegionStateTransitionResponse) GetErrorMessage() string {
+	if m != nil && m.ErrorMessage != nil {
+		return *m.ErrorMessage
+	}
+	return ""
+}
+
+func init() {
+	proto1.RegisterEnum("proto.RegionStateTransition_TransitionCode", RegionStateTransition_TransitionCode_name, RegionStateTransition_TransitionCode_value)
+}

vendor/github.com/pingcap/go-hbase/proto/RowProcessor.pb.go

@@ -0,0 +1,79 @@
+// Code generated by protoc-gen-go.
+// source: RowProcessor.proto
+// DO NOT EDIT!
+
+package proto
+
+import proto1 "github.com/golang/protobuf/proto"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto1.Marshal
+var _ = math.Inf
+
+type ProcessRequest struct {
+	RowProcessorClassName              *string `protobuf:"bytes,1,req,name=row_processor_class_name" json:"row_processor_class_name,omitempty"`
+	RowProcessorInitializerMessageName *string `protobuf:"bytes,2,opt,name=row_processor_initializer_message_name" json:"row_processor_initializer_message_name,omitempty"`
+	RowProcessorInitializerMessage     []byte  `protobuf:"bytes,3,opt,name=row_processor_initializer_message" json:"row_processor_initializer_message,omitempty"`
+	NonceGroup                         *uint64 `protobuf:"varint,4,opt,name=nonce_group" json:"nonce_group,omitempty"`
+	Nonce                              *uint64 `protobuf:"varint,5,opt,name=nonce" json:"nonce,omitempty"`
+	XXX_unrecognized                   []byte  `json:"-"`
+}
+
+func (m *ProcessRequest) Reset()         { *m = ProcessRequest{} }
+func (m *ProcessRequest) String() string { return proto1.CompactTextString(m) }
+func (*ProcessRequest) ProtoMessage()    {}
+
+func (m *ProcessRequest) GetRowProcessorClassName() string {
+	if m != nil && m.RowProcessorClassName != nil {
+		return *m.RowProcessorClassName
+	}
+	return ""
+}
+
+func (m *ProcessRequest) GetRowProcessorInitializerMessageName() string {
+	if m != nil && m.RowProcessorInitializerMessageName != nil {
+		return *m.RowProcessorInitializerMessageName
+	}
+	return ""
+}
+
+func (m *ProcessRequest) GetRowProcessorInitializerMessage() []byte {
+	if m != nil {
+		return m.RowProcessorInitializerMessage
+	}
+	return nil
+}
+
+func (m *ProcessRequest) GetNonceGroup() uint64 {
+	if m != nil && m.NonceGroup != nil {
+		return *m.NonceGroup
+	}
+	return 0
+}
+
+func (m *ProcessRequest) GetNonce() uint64 {
+	if m != nil && m.Nonce != nil {
+		return *m.Nonce
+	}
+	return 0
+}
+
+type ProcessResponse struct {
+	RowProcessorResult []byte `protobuf:"bytes,1,req,name=row_processor_result" json:"row_processor_result,omitempty"`
+	XXX_unrecognized   []byte `json:"-"`
+}
+
+func (m *ProcessResponse) Reset()         { *m = ProcessResponse{} }
+func (m *ProcessResponse) String() string { return proto1.CompactTextString(m) }
+func (*ProcessResponse) ProtoMessage()    {}
+
+func (m *ProcessResponse) GetRowProcessorResult() []byte {
+	if m != nil {
+		return m.RowProcessorResult
+	}
+	return nil
+}
+
+func init() {
+}

vendor/github.com/pingcap/go-hbase/proto/SecureBulkLoad.pb.go

@@ -0,0 +1,167 @@
+// Code generated by protoc-gen-go.
+// source: SecureBulkLoad.proto
+// DO NOT EDIT!
+
+package proto
+
+import proto1 "github.com/golang/protobuf/proto"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto1.Marshal
+var _ = math.Inf
+
+type SecureBulkLoadHFilesRequest struct {
+	FamilyPath       []*BulkLoadHFileRequest_FamilyPath `protobuf:"bytes,1,rep,name=family_path" json:"family_path,omitempty"`
+	AssignSeqNum     *bool                              `protobuf:"varint,2,opt,name=assign_seq_num" json:"assign_seq_num,omitempty"`
+	FsToken          *DelegationToken                   `protobuf:"bytes,3,req,name=fs_token" json:"fs_token,omitempty"`
+	BulkToken        *string                            `protobuf:"bytes,4,req,name=bulk_token" json:"bulk_token,omitempty"`
+	XXX_unrecognized []byte                             `json:"-"`
+}
+
+func (m *SecureBulkLoadHFilesRequest) Reset()         { *m = SecureBulkLoadHFilesRequest{} }
+func (m *SecureBulkLoadHFilesRequest) String() string { return proto1.CompactTextString(m) }
+func (*SecureBulkLoadHFilesRequest) ProtoMessage()    {}
+
+func (m *SecureBulkLoadHFilesRequest) GetFamilyPath() []*BulkLoadHFileRequest_FamilyPath {
+	if m != nil {
+		return m.FamilyPath
+	}
+	return nil
+}
+
+func (m *SecureBulkLoadHFilesRequest) GetAssignSeqNum() bool {
+	if m != nil && m.AssignSeqNum != nil {
+		return *m.AssignSeqNum
+	}
+	return false
+}
+
+func (m *SecureBulkLoadHFilesRequest) GetFsToken() *DelegationToken {
+	if m != nil {
+		return m.FsToken
+	}
+	return nil
+}
+
+func (m *SecureBulkLoadHFilesRequest) GetBulkToken() string {
+	if m != nil && m.BulkToken != nil {
+		return *m.BulkToken
+	}
+	return ""
+}
+
+type SecureBulkLoadHFilesResponse struct {
+	Loaded           *bool  `protobuf:"varint,1,req,name=loaded" json:"loaded,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *SecureBulkLoadHFilesResponse) Reset()         { *m = SecureBulkLoadHFilesResponse{} }
+func (m *SecureBulkLoadHFilesResponse) String() string { return proto1.CompactTextString(m) }
+func (*SecureBulkLoadHFilesResponse) ProtoMessage()    {}
+
+func (m *SecureBulkLoadHFilesResponse) GetLoaded() bool {
+	if m != nil && m.Loaded != nil {
+		return *m.Loaded
+	}
+	return false
+}
+
+type DelegationToken struct {
+	Identifier       []byte  `protobuf:"bytes,1,opt,name=identifier" json:"identifier,omitempty"`
+	Password         []byte  `protobuf:"bytes,2,opt,name=password" json:"password,omitempty"`
+	Kind             *string `protobuf:"bytes,3,opt,name=kind" json:"kind,omitempty"`
+	Service          *string `protobuf:"bytes,4,opt,name=service" json:"service,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *DelegationToken) Reset()         { *m = DelegationToken{} }
+func (m *DelegationToken) String() string { return proto1.CompactTextString(m) }
+func (*DelegationToken) ProtoMessage()    {}
+
+func (m *DelegationToken) GetIdentifier() []byte {
+	if m != nil {
+		return m.Identifier
+	}
+	return nil
+}
+
+func (m *DelegationToken) GetPassword() []byte {
+	if m != nil {
+		return m.Password
+	}
+	return nil
+}
+
+func (m *DelegationToken) GetKind() string {
+	if m != nil && m.Kind != nil {
+		return *m.Kind
+	}
+	return ""
+}
+
+func (m *DelegationToken) GetService() string {
+	if m != nil && m.Service != nil {
+		return *m.Service
+	}
+	return ""
+}
+
+type PrepareBulkLoadRequest struct {
+	TableName        *TableName `protobuf:"bytes,1,req,name=table_name" json:"table_name,omitempty"`
+	XXX_unrecognized []byte     `json:"-"`
+}
+
+func (m *PrepareBulkLoadRequest) Reset()         { *m = PrepareBulkLoadRequest{} }
+func (m *PrepareBulkLoadRequest) String() string { return proto1.CompactTextString(m) }
+func (*PrepareBulkLoadRequest) ProtoMessage()    {}
+
+func (m *PrepareBulkLoadRequest) GetTableName() *TableName {
+	if m != nil {
+		return m.TableName
+	}
+	return nil
+}
+
+type PrepareBulkLoadResponse struct {
+	BulkToken        *string `protobuf:"bytes,1,req,name=bulk_token" json:"bulk_token,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *PrepareBulkLoadResponse) Reset()         { *m = PrepareBulkLoadResponse{} }
+func (m *PrepareBulkLoadResponse) String() string { return proto1.CompactTextString(m) }
+func (*PrepareBulkLoadResponse) ProtoMessage()    {}
+
+func (m *PrepareBulkLoadResponse) GetBulkToken() string {
+	if m != nil && m.BulkToken != nil {
+		return *m.BulkToken
+	}
+	return ""
+}
+
+type CleanupBulkLoadRequest struct {
+	BulkToken        *string `protobuf:"bytes,1,req,name=bulk_token" json:"bulk_token,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *CleanupBulkLoadRequest) Reset()         { *m = CleanupBulkLoadRequest{} }
+func (m *CleanupBulkLoadRequest) String() string { return proto1.CompactTextString(m) }
+func (*CleanupBulkLoadRequest) ProtoMessage()    {}
+
+func (m *CleanupBulkLoadRequest) GetBulkToken() string {
+	if m != nil && m.BulkToken != nil {
+		return *m.BulkToken
+	}
+	return ""
+}
+
+type CleanupBulkLoadResponse struct {
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *CleanupBulkLoadResponse) Reset()         { *m = CleanupBulkLoadResponse{} }
+func (m *CleanupBulkLoadResponse) String() string { return proto1.CompactTextString(m) }
+func (*CleanupBulkLoadResponse) ProtoMessage()    {}
+
+func init() {
+}

vendor/github.com/pingcap/go-hbase/proto/Snapshot.pb.go

@@ -0,0 +1,202 @@
+// Code generated by protoc-gen-go.
+// source: Snapshot.proto
+// DO NOT EDIT!
+
+package proto
+
+import proto1 "github.com/golang/protobuf/proto"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto1.Marshal
+var _ = math.Inf
+
+type SnapshotFileInfo_Type int32
+
+const (
+	SnapshotFileInfo_HFILE SnapshotFileInfo_Type = 1
+	SnapshotFileInfo_WAL   SnapshotFileInfo_Type = 2
+)
+
+var SnapshotFileInfo_Type_name = map[int32]string{
+	1: "HFILE",
+	2: "WAL",
+}
+var SnapshotFileInfo_Type_value = map[string]int32{
+	"HFILE": 1,
+	"WAL":   2,
+}
+
+func (x SnapshotFileInfo_Type) Enum() *SnapshotFileInfo_Type {
+	p := new(SnapshotFileInfo_Type)
+	*p = x
+	return p
+}
+func (x SnapshotFileInfo_Type) String() string {
+	return proto1.EnumName(SnapshotFileInfo_Type_name, int32(x))
+}
+func (x *SnapshotFileInfo_Type) UnmarshalJSON(data []byte) error {
+	value, err := proto1.UnmarshalJSONEnum(SnapshotFileInfo_Type_value, data, "SnapshotFileInfo_Type")
+	if err != nil {
+		return err
+	}
+	*x = SnapshotFileInfo_Type(value)
+	return nil
+}
+
+type SnapshotFileInfo struct {
+	Type             *SnapshotFileInfo_Type `protobuf:"varint,1,req,name=type,enum=proto.SnapshotFileInfo_Type" json:"type,omitempty"`
+	Hfile            *string                `protobuf:"bytes,3,opt,name=hfile" json:"hfile,omitempty"`
+	WalServer        *string                `protobuf:"bytes,4,opt,name=wal_server" json:"wal_server,omitempty"`
+	WalName          *string                `protobuf:"bytes,5,opt,name=wal_name" json:"wal_name,omitempty"`
+	XXX_unrecognized []byte                 `json:"-"`
+}
+
+func (m *SnapshotFileInfo) Reset()         { *m = SnapshotFileInfo{} }
+func (m *SnapshotFileInfo) String() string { return proto1.CompactTextString(m) }
+func (*SnapshotFileInfo) ProtoMessage()    {}
+
+func (m *SnapshotFileInfo) GetType() SnapshotFileInfo_Type {
+	if m != nil && m.Type != nil {
+		return *m.Type
+	}
+	return SnapshotFileInfo_HFILE
+}
+
+func (m *SnapshotFileInfo) GetHfile() string {
+	if m != nil && m.Hfile != nil {
+		return *m.Hfile
+	}
+	return ""
+}
+
+func (m *SnapshotFileInfo) GetWalServer() string {
+	if m != nil && m.WalServer != nil {
+		return *m.WalServer
+	}
+	return ""
+}
+
+func (m *SnapshotFileInfo) GetWalName() string {
+	if m != nil && m.WalName != nil {
+		return *m.WalName
+	}
+	return ""
+}
+
+type SnapshotRegionManifest struct {
+	Version          *int32                                `protobuf:"varint,1,opt,name=version" json:"version,omitempty"`
+	RegionInfo       *RegionInfo                           `protobuf:"bytes,2,req,name=region_info" json:"region_info,omitempty"`
+	FamilyFiles      []*SnapshotRegionManifest_FamilyFiles `protobuf:"bytes,3,rep,name=family_files" json:"family_files,omitempty"`
+	XXX_unrecognized []byte                                `json:"-"`
+}
+
+func (m *SnapshotRegionManifest) Reset()         { *m = SnapshotRegionManifest{} }
+func (m *SnapshotRegionManifest) String() string { return proto1.CompactTextString(m) }
+func (*SnapshotRegionManifest) ProtoMessage()    {}
+
+func (m *SnapshotRegionManifest) GetVersion() int32 {
+	if m != nil && m.Version != nil {
+		return *m.Version
+	}
+	return 0
+}
+
+func (m *SnapshotRegionManifest) GetRegionInfo() *RegionInfo {
+	if m != nil {
+		return m.RegionInfo
+	}
+	return nil
+}
+
+func (m *SnapshotRegionManifest) GetFamilyFiles() []*SnapshotRegionManifest_FamilyFiles {
+	if m != nil {
+		return m.FamilyFiles
+	}
+	return nil
+}
+
+type SnapshotRegionManifest_StoreFile struct {
+	Name      *string    `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
+	Reference *Reference `protobuf:"bytes,2,opt,name=reference" json:"reference,omitempty"`
+	// TODO: Add checksums or other fields to verify the file
+	FileSize         *uint64 `protobuf:"varint,3,opt,name=file_size" json:"file_size,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *SnapshotRegionManifest_StoreFile) Reset()         { *m = SnapshotRegionManifest_StoreFile{} }
+func (m *SnapshotRegionManifest_StoreFile) String() string { return proto1.CompactTextString(m) }
+func (*SnapshotRegionManifest_StoreFile) ProtoMessage()    {}
+
+func (m *SnapshotRegionManifest_StoreFile) GetName() string {
+	if m != nil && m.Name != nil {
+		return *m.Name
+	}
+	return ""
+}
+
+func (m *SnapshotRegionManifest_StoreFile) GetReference() *Reference {
+	if m != nil {
+		return m.Reference
+	}
+	return nil
+}
+
+func (m *SnapshotRegionManifest_StoreFile) GetFileSize() uint64 {
+	if m != nil && m.FileSize != nil {
+		return *m.FileSize
+	}
+	return 0
+}
+
+type SnapshotRegionManifest_FamilyFiles struct {
+	FamilyName       []byte                              `protobuf:"bytes,1,req,name=family_name" json:"family_name,omitempty"`
+	StoreFiles       []*SnapshotRegionManifest_StoreFile `protobuf:"bytes,2,rep,name=store_files" json:"store_files,omitempty"`
+	XXX_unrecognized []byte                              `json:"-"`
+}
+
+func (m *SnapshotRegionManifest_FamilyFiles) Reset()         { *m = SnapshotRegionManifest_FamilyFiles{} }
+func (m *SnapshotRegionManifest_FamilyFiles) String() string { return proto1.CompactTextString(m) }
+func (*SnapshotRegionManifest_FamilyFiles) ProtoMessage()    {}
+
+func (m *SnapshotRegionManifest_FamilyFiles) GetFamilyName() []byte {
+	if m != nil {
+		return m.FamilyName
+	}
+	return nil
+}
+
+func (m *SnapshotRegionManifest_FamilyFiles) GetStoreFiles() []*SnapshotRegionManifest_StoreFile {
+	if m != nil {
+		return m.StoreFiles
+	}
+	return nil
+}
+
+type SnapshotDataManifest struct {
+	TableSchema      *TableSchema              `protobuf:"bytes,1,req,name=table_schema" json:"table_schema,omitempty"`
+	RegionManifests  []*SnapshotRegionManifest `protobuf:"bytes,2,rep,name=region_manifests" json:"region_manifests,omitempty"`
+	XXX_unrecognized []byte                    `json:"-"`
+}
+
+func (m *SnapshotDataManifest) Reset()         { *m = SnapshotDataManifest{} }
+func (m *SnapshotDataManifest) String() string { return proto1.CompactTextString(m) }
+func (*SnapshotDataManifest) ProtoMessage()    {}
+
+func (m *SnapshotDataManifest) GetTableSchema() *TableSchema {
+	if m != nil {
+		return m.TableSchema
+	}
+	return nil
+}
+
+func (m *SnapshotDataManifest) GetRegionManifests() []*SnapshotRegionManifest {
+	if m != nil {
+		return m.RegionManifests
+	}
+	return nil
+}
+
+func init() {
+	proto1.RegisterEnum("proto.SnapshotFileInfo_Type", SnapshotFileInfo_Type_name, SnapshotFileInfo_Type_value)
+}

vendor/github.com/pingcap/go-hbase/proto/Tracing.pb.go

@@ -0,0 +1,44 @@
+// Code generated by protoc-gen-go.
+// source: Tracing.proto
+// DO NOT EDIT!
+
+package proto
+
+import proto1 "github.com/golang/protobuf/proto"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto1.Marshal
+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:"trace_id,omitempty"`
+	ParentId         *int64 `protobuf:"varint,2,opt,name=parent_id" json:"parent_id,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *RPCTInfo) Reset()         { *m = RPCTInfo{} }
+func (m *RPCTInfo) String() string { return proto1.CompactTextString(m) }
+func (*RPCTInfo) ProtoMessage()    {}
+
+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() {
+}

vendor/github.com/pingcap/go-hbase/proto/VisibilityLabels.pb.go

@@ -0,0 +1,207 @@
+// Code generated by protoc-gen-go.
+// source: VisibilityLabels.proto
+// DO NOT EDIT!
+
+package proto
+
+import proto1 "github.com/golang/protobuf/proto"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto1.Marshal
+var _ = math.Inf
+
+type VisibilityLabelsRequest struct {
+	VisLabel         []*VisibilityLabel `protobuf:"bytes,1,rep,name=visLabel" json:"visLabel,omitempty"`
+	XXX_unrecognized []byte             `json:"-"`
+}
+
+func (m *VisibilityLabelsRequest) Reset()         { *m = VisibilityLabelsRequest{} }
+func (m *VisibilityLabelsRequest) String() string { return proto1.CompactTextString(m) }
+func (*VisibilityLabelsRequest) ProtoMessage()    {}
+
+func (m *VisibilityLabelsRequest) GetVisLabel() []*VisibilityLabel {
+	if m != nil {
+		return m.VisLabel
+	}
+	return nil
+}
+
+type VisibilityLabel struct {
+	Label            []byte  `protobuf:"bytes,1,req,name=label" json:"label,omitempty"`
+	Ordinal          *uint32 `protobuf:"varint,2,opt,name=ordinal" json:"ordinal,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *VisibilityLabel) Reset()         { *m = VisibilityLabel{} }
+func (m *VisibilityLabel) String() string { return proto1.CompactTextString(m) }
+func (*VisibilityLabel) ProtoMessage()    {}
+
+func (m *VisibilityLabel) GetLabel() []byte {
+	if m != nil {
+		return m.Label
+	}
+	return nil
+}
+
+func (m *VisibilityLabel) GetOrdinal() uint32 {
+	if m != nil && m.Ordinal != nil {
+		return *m.Ordinal
+	}
+	return 0
+}
+
+type VisibilityLabelsResponse struct {
+	Result           []*RegionActionResult `protobuf:"bytes,1,rep,name=result" json:"result,omitempty"`
+	XXX_unrecognized []byte                `json:"-"`
+}
+
+func (m *VisibilityLabelsResponse) Reset()         { *m = VisibilityLabelsResponse{} }
+func (m *VisibilityLabelsResponse) String() string { return proto1.CompactTextString(m) }
+func (*VisibilityLabelsResponse) ProtoMessage()    {}
+
+func (m *VisibilityLabelsResponse) GetResult() []*RegionActionResult {
+	if m != nil {
+		return m.Result
+	}
+	return nil
+}
+
+type SetAuthsRequest struct {
+	User             []byte   `protobuf:"bytes,1,req,name=user" json:"user,omitempty"`
+	Auth             [][]byte `protobuf:"bytes,2,rep,name=auth" json:"auth,omitempty"`
+	XXX_unrecognized []byte   `json:"-"`
+}
+
+func (m *SetAuthsRequest) Reset()         { *m = SetAuthsRequest{} }
+func (m *SetAuthsRequest) String() string { return proto1.CompactTextString(m) }
+func (*SetAuthsRequest) ProtoMessage()    {}
+
+func (m *SetAuthsRequest) GetUser() []byte {
+	if m != nil {
+		return m.User
+	}
+	return nil
+}
+
+func (m *SetAuthsRequest) GetAuth() [][]byte {
+	if m != nil {
+		return m.Auth
+	}
+	return nil
+}
+
+type UserAuthorizations struct {
+	User             []byte   `protobuf:"bytes,1,req,name=user" json:"user,omitempty"`
+	Auth             []uint32 `protobuf:"varint,2,rep,name=auth" json:"auth,omitempty"`
+	XXX_unrecognized []byte   `json:"-"`
+}
+
+func (m *UserAuthorizations) Reset()         { *m = UserAuthorizations{} }
+func (m *UserAuthorizations) String() string { return proto1.CompactTextString(m) }
+func (*UserAuthorizations) ProtoMessage()    {}
+
+func (m *UserAuthorizations) GetUser() []byte {
+	if m != nil {
+		return m.User
+	}
+	return nil
+}
+
+func (m *UserAuthorizations) GetAuth() []uint32 {
+	if m != nil {
+		return m.Auth
+	}
+	return nil
+}
+
+type MultiUserAuthorizations struct {
+	UserAuths        []*UserAuthorizations `protobuf:"bytes,1,rep,name=userAuths" json:"userAuths,omitempty"`
+	XXX_unrecognized []byte                `json:"-"`
+}
+
+func (m *MultiUserAuthorizations) Reset()         { *m = MultiUserAuthorizations{} }
+func (m *MultiUserAuthorizations) String() string { return proto1.CompactTextString(m) }
+func (*MultiUserAuthorizations) ProtoMessage()    {}
+
+func (m *MultiUserAuthorizations) GetUserAuths() []*UserAuthorizations {
+	if m != nil {
+		return m.UserAuths
+	}
+	return nil
+}
+
+type GetAuthsRequest struct {
+	User             []byte `protobuf:"bytes,1,req,name=user" json:"user,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *GetAuthsRequest) Reset()         { *m = GetAuthsRequest{} }
+func (m *GetAuthsRequest) String() string { return proto1.CompactTextString(m) }
+func (*GetAuthsRequest) ProtoMessage()    {}
+
+func (m *GetAuthsRequest) GetUser() []byte {
+	if m != nil {
+		return m.User
+	}
+	return nil
+}
+
+type GetAuthsResponse struct {
+	User             []byte   `protobuf:"bytes,1,req,name=user" json:"user,omitempty"`
+	Auth             [][]byte `protobuf:"bytes,2,rep,name=auth" json:"auth,omitempty"`
+	XXX_unrecognized []byte   `json:"-"`
+}
+
+func (m *GetAuthsResponse) Reset()         { *m = GetAuthsResponse{} }
+func (m *GetAuthsResponse) String() string { return proto1.CompactTextString(m) }
+func (*GetAuthsResponse) ProtoMessage()    {}
+
+func (m *GetAuthsResponse) GetUser() []byte {
+	if m != nil {
+		return m.User
+	}
+	return nil
+}
+
+func (m *GetAuthsResponse) GetAuth() [][]byte {
+	if m != nil {
+		return m.Auth
+	}
+	return nil
+}
+
+type ListLabelsRequest struct {
+	Regex            *string `protobuf:"bytes,1,opt,name=regex" json:"regex,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *ListLabelsRequest) Reset()         { *m = ListLabelsRequest{} }
+func (m *ListLabelsRequest) String() string { return proto1.CompactTextString(m) }
+func (*ListLabelsRequest) ProtoMessage()    {}
+
+func (m *ListLabelsRequest) GetRegex() string {
+	if m != nil && m.Regex != nil {
+		return *m.Regex
+	}
+	return ""
+}
+
+type ListLabelsResponse struct {
+	Label            [][]byte `protobuf:"bytes,1,rep,name=label" json:"label,omitempty"`
+	XXX_unrecognized []byte   `json:"-"`
+}
+
+func (m *ListLabelsResponse) Reset()         { *m = ListLabelsResponse{} }
+func (m *ListLabelsResponse) String() string { return proto1.CompactTextString(m) }
+func (*ListLabelsResponse) ProtoMessage()    {}
+
+func (m *ListLabelsResponse) GetLabel() [][]byte {
+	if m != nil {
+		return m.Label
+	}
+	return nil
+}
+
+func init() {
+}

vendor/github.com/pingcap/go-hbase/proto/WAL.pb.go

@@ -0,0 +1,298 @@
+// Code generated by protoc-gen-go.
+// source: WAL.proto
+// DO NOT EDIT!
+
+package proto
+
+import proto1 "github.com/golang/protobuf/proto"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto1.Marshal
+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 proto1.EnumName(ScopeType_name, int32(x))
+}
+func (x *ScopeType) UnmarshalJSON(data []byte) error {
+	value, err := proto1.UnmarshalJSONEnum(ScopeType_value, data, "ScopeType")
+	if err != nil {
+		return err
+	}
+	*x = ScopeType(value)
+	return nil
+}
+
+type WALHeader struct {
+	HasCompression    *bool   `protobuf:"varint,1,opt,name=has_compression" json:"has_compression,omitempty"`
+	EncryptionKey     []byte  `protobuf:"bytes,2,opt,name=encryption_key" json:"encryption_key,omitempty"`
+	HasTagCompression *bool   `protobuf:"varint,3,opt,name=has_tag_compression" json:"has_tag_compression,omitempty"`
+	WriterClsName     *string `protobuf:"bytes,4,opt,name=writer_cls_name" json:"writer_cls_name,omitempty"`
+	CellCodecClsName  *string `protobuf:"bytes,5,opt,name=cell_codec_cls_name" json:"cell_codec_cls_name,omitempty"`
+	XXX_unrecognized  []byte  `json:"-"`
+}
+
+func (m *WALHeader) Reset()         { *m = WALHeader{} }
+func (m *WALHeader) String() string { return proto1.CompactTextString(m) }
+func (*WALHeader) ProtoMessage()    {}
+
+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 HLogKey; see HLogKey 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:"encoded_region_name,omitempty"`
+	TableName         []byte  `protobuf:"bytes,2,req,name=table_name" json:"table_name,omitempty"`
+	LogSequenceNumber *uint64 `protobuf:"varint,3,req,name=log_sequence_number" json:"log_sequence_number,omitempty"`
+	WriteTime         *uint64 `protobuf:"varint,4,req,name=write_time" 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:"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:"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:"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"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *WALKey) Reset()         { *m = WALKey{} }
+func (m *WALKey) String() string { return proto1.CompactTextString(m) }
+func (*WALKey) ProtoMessage()    {}
+
+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
+}
+
+type FamilyScope struct {
+	Family           []byte     `protobuf:"bytes,1,req,name=family" json:"family,omitempty"`
+	ScopeType        *ScopeType `protobuf:"varint,2,req,name=scope_type,enum=proto.ScopeType" json:"scope_type,omitempty"`
+	XXX_unrecognized []byte     `json:"-"`
+}
+
+func (m *FamilyScope) Reset()         { *m = FamilyScope{} }
+func (m *FamilyScope) String() string { return proto1.CompactTextString(m) }
+func (*FamilyScope) ProtoMessage()    {}
+
+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:"table_name,omitempty"`
+	EncodedRegionName []byte   `protobuf:"bytes,2,req,name=encoded_region_name" json:"encoded_region_name,omitempty"`
+	FamilyName        []byte   `protobuf:"bytes,3,req,name=family_name" json:"family_name,omitempty"`
+	CompactionInput   []string `protobuf:"bytes,4,rep,name=compaction_input" json:"compaction_input,omitempty"`
+	CompactionOutput  []string `protobuf:"bytes,5,rep,name=compaction_output" json:"compaction_output,omitempty"`
+	StoreHomeDir      *string  `protobuf:"bytes,6,req,name=store_home_dir" json:"store_home_dir,omitempty"`
+	RegionName        []byte   `protobuf:"bytes,7,opt,name=region_name" json:"region_name,omitempty"`
+	XXX_unrecognized  []byte   `json:"-"`
+}
+
+func (m *CompactionDescriptor) Reset()         { *m = CompactionDescriptor{} }
+func (m *CompactionDescriptor) String() string { return proto1.CompactTextString(m) }
+func (*CompactionDescriptor) ProtoMessage()    {}
+
+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
+}
+
+// *
+// A trailer that is appended to the end of a properly closed HLog WAL file.
+// If missing, this is either a legacy or a corrupted WAL file.
+type WALTrailer struct {
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *WALTrailer) Reset()         { *m = WALTrailer{} }
+func (m *WALTrailer) String() string { return proto1.CompactTextString(m) }
+func (*WALTrailer) ProtoMessage()    {}
+
+func init() {
+	proto1.RegisterEnum("proto.ScopeType", ScopeType_name, ScopeType_value)
+}

vendor/github.com/pingcap/go-hbase/proto/ZooKeeper.pb.go

@@ -0,0 +1,580 @@
+// Code generated by protoc-gen-go.
+// source: ZooKeeper.proto
+// DO NOT EDIT!
+
+package proto
+
+import proto1 "github.com/golang/protobuf/proto"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto1.Marshal
+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 proto1.EnumName(SplitLogTask_State_name, int32(x))
+}
+func (x *SplitLogTask_State) UnmarshalJSON(data []byte) error {
+	value, err := proto1.UnmarshalJSONEnum(SplitLogTask_State_value, data, "SplitLogTask_State")
+	if err != nil {
+		return err
+	}
+	*x = SplitLogTask_State(value)
+	return nil
+}
+
+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 proto1.EnumName(SplitLogTask_RecoveryMode_name, int32(x))
+}
+func (x *SplitLogTask_RecoveryMode) UnmarshalJSON(data []byte) error {
+	value, err := proto1.UnmarshalJSONEnum(SplitLogTask_RecoveryMode_value, data, "SplitLogTask_RecoveryMode")
+	if err != nil {
+		return err
+	}
+	*x = SplitLogTask_RecoveryMode(value)
+	return nil
+}
+
+// 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 proto1.EnumName(Table_State_name, int32(x))
+}
+func (x *Table_State) UnmarshalJSON(data []byte) error {
+	value, err := proto1.UnmarshalJSONEnum(Table_State_value, data, "Table_State")
+	if err != nil {
+		return err
+	}
+	*x = Table_State(value)
+	return nil
+}
+
+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 proto1.EnumName(ReplicationState_State_name, int32(x))
+}
+func (x *ReplicationState_State) UnmarshalJSON(data []byte) error {
+	value, err := proto1.UnmarshalJSONEnum(ReplicationState_State_value, data, "ReplicationState_State")
+	if err != nil {
+		return err
+	}
+	*x = ReplicationState_State(value)
+	return nil
+}
+
+// *
+// Content of the meta-region-server znode.
+type MetaRegionServer struct {
+	// The ServerName hosting the meta region currently.
+	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:"rpc_version,omitempty"`
+	// State of the region transition. OPEN means fully operational 'hbase:meta'
+	State            *RegionState_State `protobuf:"varint,3,opt,name=state,enum=proto.RegionState_State" json:"state,omitempty"`
+	XXX_unrecognized []byte             `json:"-"`
+}
+
+func (m *MetaRegionServer) Reset()         { *m = MetaRegionServer{} }
+func (m *MetaRegionServer) String() string { return proto1.CompactTextString(m) }
+func (*MetaRegionServer) ProtoMessage()    {}
+
+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:"rpc_version,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *Master) Reset()         { *m = Master{} }
+func (m *Master) String() string { return proto1.CompactTextString(m) }
+func (*Master) ProtoMessage()    {}
+
+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
+}
+
+// *
+// 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:"start_date,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *ClusterUp) Reset()         { *m = ClusterUp{} }
+func (m *ClusterUp) String() string { return proto1.CompactTextString(m) }
+func (*ClusterUp) ProtoMessage()    {}
+
+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:"event_type_code,omitempty"`
+	// Full regionname in bytes
+	RegionName []byte  `protobuf:"bytes,2,req,name=region_name" json:"region_name,omitempty"`
+	CreateTime *uint64 `protobuf:"varint,3,req,name=create_time" 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:"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 proto1.CompactTextString(m) }
+func (*RegionTransition) ProtoMessage()    {}
+
+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=proto.SplitLogTask_State" json:"state,omitempty"`
+	ServerName       *ServerName                `protobuf:"bytes,2,req,name=server_name" json:"server_name,omitempty"`
+	Mode             *SplitLogTask_RecoveryMode `protobuf:"varint,3,opt,name=mode,enum=proto.SplitLogTask_RecoveryMode,def=0" json:"mode,omitempty"`
+	XXX_unrecognized []byte                     `json:"-"`
+}
+
+func (m *SplitLogTask) Reset()         { *m = SplitLogTask{} }
+func (m *SplitLogTask) String() string { return proto1.CompactTextString(m) }
+func (*SplitLogTask) ProtoMessage()    {}
+
+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=proto.Table_State,def=0" json:"state,omitempty"`
+	XXX_unrecognized []byte       `json:"-"`
+}
+
+func (m *Table) Reset()         { *m = Table{} }
+func (m *Table) String() string { return proto1.CompactTextString(m) }
+func (*Table) ProtoMessage()    {}
+
+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 proto1.CompactTextString(m) }
+func (*ReplicationPeer) ProtoMessage()    {}
+
+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=proto.ReplicationState_State" json:"state,omitempty"`
+	XXX_unrecognized []byte                  `json:"-"`
+}
+
+func (m *ReplicationState) Reset()         { *m = ReplicationState{} }
+func (m *ReplicationState) String() string { return proto1.CompactTextString(m) }
+func (*ReplicationState) ProtoMessage()    {}
+
+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 HLog 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 proto1.CompactTextString(m) }
+func (*ReplicationHLogPosition) ProtoMessage()    {}
+
+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:"lock_owner,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *ReplicationLock) Reset()         { *m = ReplicationLock{} }
+func (m *ReplicationLock) String() string { return proto1.CompactTextString(m) }
+func (*ReplicationLock) ProtoMessage()    {}
+
+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:"table_name,omitempty"`
+	LockOwner        *ServerName `protobuf:"bytes,2,opt,name=lock_owner" json:"lock_owner,omitempty"`
+	ThreadId         *int64      `protobuf:"varint,3,opt,name=thread_id" json:"thread_id,omitempty"`
+	IsShared         *bool       `protobuf:"varint,4,opt,name=is_shared" 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:"create_time,omitempty"`
+	XXX_unrecognized []byte      `json:"-"`
+}
+
+func (m *TableLock) Reset()         { *m = TableLock{} }
+func (m *TableLock) String() string { return proto1.CompactTextString(m) }
+func (*TableLock) ProtoMessage()    {}
+
+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
+}
+
+// *
+// sequence Id of a store
+type StoreSequenceId struct {
+	FamilyName       []byte  `protobuf:"bytes,1,req,name=family_name" json:"family_name,omitempty"`
+	SequenceId       *uint64 `protobuf:"varint,2,req,name=sequence_id" json:"sequence_id,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *StoreSequenceId) Reset()         { *m = StoreSequenceId{} }
+func (m *StoreSequenceId) String() string { return proto1.CompactTextString(m) }
+func (*StoreSequenceId) ProtoMessage()    {}
+
+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 sequence ids of the region's stores
+type RegionStoreSequenceIds struct {
+	LastFlushedSequenceId *uint64            `protobuf:"varint,1,req,name=last_flushed_sequence_id" json:"last_flushed_sequence_id,omitempty"`
+	StoreSequenceId       []*StoreSequenceId `protobuf:"bytes,2,rep,name=store_sequence_id" json:"store_sequence_id,omitempty"`
+	XXX_unrecognized      []byte             `json:"-"`
+}
+
+func (m *RegionStoreSequenceIds) Reset()         { *m = RegionStoreSequenceIds{} }
+func (m *RegionStoreSequenceIds) String() string { return proto1.CompactTextString(m) }
+func (*RegionStoreSequenceIds) ProtoMessage()    {}
+
+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
+}
+
+func init() {
+	proto1.RegisterEnum("proto.SplitLogTask_State", SplitLogTask_State_name, SplitLogTask_State_value)
+	proto1.RegisterEnum("proto.SplitLogTask_RecoveryMode", SplitLogTask_RecoveryMode_name, SplitLogTask_RecoveryMode_value)
+	proto1.RegisterEnum("proto.Table_State", Table_State_name, Table_State_value)
+	proto1.RegisterEnum("proto.ReplicationState_State", ReplicationState_State_name, ReplicationState_State_value)
+}