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/LICENSE

@@ -0,0 +1,50 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 dongxu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+Copyright (c) 2014 Bryan Peterson. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/github.com/pingcap/go-hbase/README.md

@@ -0,0 +1,14 @@
+#go-hbase
+
+[![Build Status](https://travis-ci.org/pingcap/go-hbase.svg)](https://travis-ci.org/pingcap/go-hbase)
+
+Derived from [Lazyshot/go-hbase](https://github.com/Lazyshot/go-hbase). Add some new features and fix some bugs.
+
+## New Features
+
+1. Coprocessor EndPoint call.
+2. Goroutine-safe.
+3. Admin commands: Create/Disable/Drop table.
+4. Pipelined RPC.
+
+Support HBase >= 0.98.5

vendor/github.com/pingcap/go-hbase/action.go

@@ -0,0 +1,101 @@
+package hbase
+
+import (
+	pb "github.com/golang/protobuf/proto"
+	"github.com/juju/errors"
+	"github.com/ngaut/log"
+	"github.com/pingcap/go-hbase/proto"
+)
+
+type action interface {
+	ToProto() pb.Message
+}
+
+func (c *client) innerCall(table, row []byte, action action, useCache bool) (*call, error) {
+	region, err := c.LocateRegion(table, row, useCache)
+	if err != nil {
+		return nil, errors.Trace(err)
+	}
+
+	conn, err := c.getClientConn(region.Server)
+	if err != nil {
+		return nil, errors.Trace(err)
+	}
+
+	regionSpecifier := &proto.RegionSpecifier{
+		Type:  proto.RegionSpecifier_REGION_NAME.Enum(),
+		Value: []byte(region.Name),
+	}
+
+	var cl *call
+	switch a := action.(type) {
+	case *Get:
+		cl = newCall(&proto.GetRequest{
+			Region: regionSpecifier,
+			Get:    a.ToProto().(*proto.Get),
+		})
+	case *Put, *Delete:
+		cl = newCall(&proto.MutateRequest{
+			Region:   regionSpecifier,
+			Mutation: a.ToProto().(*proto.MutationProto),
+		})
+
+	case *CoprocessorServiceCall:
+		cl = newCall(&proto.CoprocessorServiceRequest{
+			Region: regionSpecifier,
+			Call:   a.ToProto().(*proto.CoprocessorServiceCall),
+		})
+	default:
+		return nil, errors.Errorf("Unknown action - %T - %v", action, action)
+	}
+
+	err = conn.call(cl)
+	if err != nil {
+		// If failed, remove bad server conn cache.
+		cachedKey := cachedConnKey(region.Server, ClientService)
+		delete(c.cachedConns, cachedKey)
+		return nil, errors.Trace(err)
+	}
+
+	return cl, nil
+}
+
+func (c *client) innerDo(table, row []byte, action action, useCache bool) (pb.Message, error) {
+	// Try to create and send a new resuqest call.
+	cl, err := c.innerCall(table, row, action, useCache)
+	if err != nil {
+		log.Warnf("inner call failed - %v", errors.ErrorStack(err))
+		return nil, errors.Trace(err)
+	}
+
+	// Wait and receive the result.
+	return <-cl.responseCh, nil
+}
+
+func (c *client) do(table, row []byte, action action, useCache bool) (pb.Message, error) {
+	var (
+		result pb.Message
+		err    error
+	)
+
+LOOP:
+	for i := 0; i < c.maxRetries; i++ {
+		result, err = c.innerDo(table, row, action, useCache)
+		if err == nil {
+			switch r := result.(type) {
+			case *exception:
+				err = errors.New(r.msg)
+				// If get an execption response, clean old region cache.
+				c.CleanRegionCache(table)
+			default:
+				break LOOP
+			}
+		}
+
+		useCache = false
+		log.Warnf("Retrying action for the %d time(s), error - %v", i+1, errors.ErrorStack(err))
+		retrySleep(i + 1)
+	}
+
+	return result, errors.Trace(err)
+}

vendor/github.com/pingcap/go-hbase/admin.go

@@ -0,0 +1,340 @@
+package hbase
+
+import (
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/juju/errors"
+	"github.com/ngaut/log"
+	"github.com/pingcap/go-hbase/proto"
+)
+
+const defaultNS = "default"
+
+type TableName struct {
+	namespace string
+	name      string
+}
+
+func newTableNameWithDefaultNS(tblName string) TableName {
+	return TableName{
+		namespace: defaultNS,
+		name:      tblName,
+	}
+}
+
+type TableDescriptor struct {
+	name  TableName
+	attrs map[string][]byte
+	cfs   []*ColumnFamilyDescriptor
+}
+
+func NewTableDesciptor(tblName string) *TableDescriptor {
+	ret := &TableDescriptor{
+		name:  newTableNameWithDefaultNS(tblName),
+		attrs: map[string][]byte{},
+	}
+	ret.AddAddr("IS_META", "false")
+	return ret
+}
+
+func (c *TableDescriptor) AddAddr(attrName string, val string) {
+	c.attrs[attrName] = []byte(val)
+}
+
+func (t *TableDescriptor) AddColumnDesc(cf *ColumnFamilyDescriptor) {
+	for _, c := range t.cfs {
+		if c.name == cf.name {
+			return
+		}
+	}
+	t.cfs = append(t.cfs, cf)
+}
+
+type ColumnFamilyDescriptor struct {
+	name  string
+	attrs map[string][]byte
+}
+
+func (c *ColumnFamilyDescriptor) AddAttr(attrName string, val string) {
+	c.attrs[attrName] = []byte(val)
+}
+
+// Themis will use VERSIONS=1 for some hook.
+func NewColumnFamilyDescriptor(name string) *ColumnFamilyDescriptor {
+	return newColumnFamilyDescriptor(name, 1)
+}
+
+func newColumnFamilyDescriptor(name string, versionsNum int) *ColumnFamilyDescriptor {
+	versions := strconv.Itoa(versionsNum)
+
+	ret := &ColumnFamilyDescriptor{
+		name:  name,
+		attrs: make(map[string][]byte),
+	}
+
+	// add default attrs
+	ret.AddAttr("DATA_BLOCK_ENCODING", "NONE")
+	ret.AddAttr("BLOOMFILTER", "ROW")
+	ret.AddAttr("REPLICATION_SCOPE", "0")
+	ret.AddAttr("COMPRESSION", "NONE")
+	ret.AddAttr("VERSIONS", versions)
+	ret.AddAttr("TTL", "2147483647") // 1 << 31
+	ret.AddAttr("MIN_VERSIONS", "0")
+	ret.AddAttr("KEEP_DELETED_CELLS", "false")
+	ret.AddAttr("BLOCKSIZE", "65536")
+	ret.AddAttr("IN_MEMORY", "false")
+	ret.AddAttr("BLOCKCACHE", "true")
+	return ret
+}
+
+func getPauseTime(retry int) int64 {
+	if retry >= len(retryPauseTime) {
+		retry = len(retryPauseTime) - 1
+	}
+	if retry < 0 {
+		retry = 0
+	}
+	return retryPauseTime[retry] * defaultRetryWaitMs
+}
+
+func (c *client) CreateTable(t *TableDescriptor, splits [][]byte) error {
+	req := &proto.CreateTableRequest{}
+	schema := &proto.TableSchema{}
+
+	sort.Sort(BytesSlice(splits))
+
+	schema.TableName = &proto.TableName{
+		Qualifier: []byte(t.name.name),
+		Namespace: []byte(t.name.namespace),
+	}
+
+	for k, v := range t.attrs {
+		schema.Attributes = append(schema.Attributes, &proto.BytesBytesPair{
+			First:  []byte(k),
+			Second: []byte(v),
+		})
+	}
+
+	for _, c := range t.cfs {
+		cf := &proto.ColumnFamilySchema{
+			Name: []byte(c.name),
+		}
+		for k, v := range c.attrs {
+			cf.Attributes = append(cf.Attributes, &proto.BytesBytesPair{
+				First:  []byte(k),
+				Second: []byte(v),
+			})
+		}
+		schema.ColumnFamilies = append(schema.ColumnFamilies, cf)
+	}
+
+	req.TableSchema = schema
+	req.SplitKeys = splits
+
+	ch, err := c.adminAction(req)
+	if err != nil {
+		return errors.Trace(err)
+	}
+
+	resp := <-ch
+	switch r := resp.(type) {
+	case *exception:
+		return errors.New(r.msg)
+	}
+
+	// wait and check
+	for retry := 0; retry < defaultMaxActionRetries*retryLongerMultiplier; retry++ {
+		regCnt := 0
+		numRegs := len(splits) + 1
+		err = c.metaScan(t.name.name, func(r *RegionInfo) (bool, error) {
+			if !(r.Offline || r.Split) && len(r.Server) > 0 && r.TableName == t.name.name {
+				regCnt++
+			}
+			return true, nil
+		})
+		if err != nil {
+			return errors.Trace(err)
+		}
+
+		if regCnt == numRegs {
+			return nil
+		}
+		log.Warnf("Retrying create table for the %d time(s)", retry+1)
+		time.Sleep(time.Duration(getPauseTime(retry)) * time.Millisecond)
+	}
+	return errors.New("create table timeout")
+}
+
+func (c *client) DisableTable(tblName string) error {
+	req := &proto.DisableTableRequest{
+		TableName: &proto.TableName{
+			Qualifier: []byte(tblName),
+			Namespace: []byte(defaultNS),
+		},
+	}
+
+	ch, err := c.adminAction(req)
+	if err != nil {
+		return errors.Trace(err)
+	}
+
+	resp := <-ch
+	switch r := resp.(type) {
+	case *exception:
+		return errors.New(r.msg)
+	}
+
+	return nil
+}
+
+func (c *client) EnableTable(tblName string) error {
+	req := &proto.EnableTableRequest{
+		TableName: &proto.TableName{
+			Qualifier: []byte(tblName),
+			Namespace: []byte(defaultNS),
+		},
+	}
+
+	ch, err := c.adminAction(req)
+	if err != nil {
+		return errors.Trace(err)
+	}
+
+	resp := <-ch
+	switch r := resp.(type) {
+	case *exception:
+		return errors.New(r.msg)
+	}
+
+	return nil
+}
+
+func (c *client) DropTable(tblName string) error {
+	req := &proto.DeleteTableRequest{
+		TableName: &proto.TableName{
+			Qualifier: []byte(tblName),
+			Namespace: []byte(defaultNS),
+		},
+	}
+
+	ch, err := c.adminAction(req)
+	if err != nil {
+		return errors.Trace(err)
+	}
+
+	resp := <-ch
+	switch r := resp.(type) {
+	case *exception:
+		return errors.New(r.msg)
+	}
+
+	return nil
+}
+
+func (c *client) metaScan(tbl string, fn func(r *RegionInfo) (bool, error)) error {
+	scan := NewScan(metaTableName, 0, c)
+	defer scan.Close()
+
+	scan.StartRow = []byte(tbl)
+	scan.StopRow = nextKey([]byte(tbl))
+
+	for {
+		r := scan.Next()
+		if r == nil || scan.Closed() {
+			break
+		}
+
+		region, err := c.parseRegion(r)
+		if err != nil {
+			return errors.Trace(err)
+		}
+
+		if more, err := fn(region); !more || err != nil {
+			return errors.Trace(err)
+		}
+	}
+
+	return nil
+}
+
+func (c *client) TableExists(tbl string) (bool, error) {
+	found := false
+	err := c.metaScan(tbl, func(region *RegionInfo) (bool, error) {
+		if region.TableName == tbl {
+			found = true
+			return false, nil
+		}
+		return true, nil
+	})
+	if err != nil {
+		return false, errors.Trace(err)
+	}
+
+	return found, nil
+}
+
+// Split splits region.
+// tblOrRegion table name or region(<tbl>,<endKey>,<timestamp>.<md5>).
+// splitPoint which is a key, leave "" if want to split each region automatically.
+func (c *client) Split(tblOrRegion, splitPoint string) error {
+	// Extract table name from supposing regionName.
+	tbls := strings.SplitN(tblOrRegion, ",", 2)
+	tbl := tbls[0]
+	found := false
+	var foundRegion *RegionInfo
+	err := c.metaScan(tbl, func(region *RegionInfo) (bool, error) {
+		if region != nil && region.Name == tblOrRegion {
+			found = true
+			foundRegion = region
+			return false, nil
+		}
+		return true, nil
+	})
+	if err != nil {
+		return errors.Trace(err)
+	}
+
+	// This is a region name, split it directly.
+	if found {
+		return c.split(foundRegion, []byte(splitPoint))
+	}
+
+	// This is a table name.
+	tbl = tblOrRegion
+	regions, err := c.GetRegions([]byte(tbl), false)
+	if err != nil {
+		return errors.Trace(err)
+	}
+	// Split each region.
+	for _, region := range regions {
+		err := c.split(region, []byte(splitPoint))
+		if err != nil {
+			return errors.Trace(err)
+		}
+	}
+	return nil
+}
+
+func (c *client) split(region *RegionInfo, splitPoint []byte) error {
+	// Not in this region, skip it.
+	if len(splitPoint) > 0 && !findKey(region, splitPoint) {
+		return nil
+	}
+	c.CleanRegionCache([]byte(region.TableName))
+	rs := NewRegionSpecifier(region.Name)
+	req := &proto.SplitRegionRequest{
+		Region: rs,
+	}
+	if len(splitPoint) > 0 {
+		req.SplitPoint = splitPoint
+	}
+	// Empty response.
+	_, err := c.regionAction(region.Server, req)
+	if err != nil {
+		return errors.Trace(err)
+	}
+	return nil
+}

vendor/github.com/pingcap/go-hbase/call.go

@@ -0,0 +1,100 @@
+package hbase
+
+import (
+	"strings"
+
+	pb "github.com/golang/protobuf/proto"
+	"github.com/pingcap/go-hbase/proto"
+)
+
+type call struct {
+	id             uint32
+	methodName     string
+	request        pb.Message
+	responseBuffer pb.Message
+	responseCh     chan pb.Message
+}
+
+type exception struct {
+	msg string
+}
+
+func isNotInRegionError(err error) bool {
+	return strings.Contains(err.Error(), "org.apache.hadoop.hbase.NotServingRegionException")
+}
+func isUnknownScannerError(err error) bool {
+	return strings.Contains(err.Error(), "org.apache.hadoop.hbase.UnknownScannerException")
+}
+
+func (m *exception) Reset()         { *m = exception{} }
+func (m *exception) String() string { return m.msg }
+func (m *exception) ProtoMessage()  {}
+
+func newCall(request pb.Message) *call {
+	var responseBuffer pb.Message
+	var methodName string
+
+	switch request.(type) {
+	case *proto.GetRequest:
+		responseBuffer = &proto.GetResponse{}
+		methodName = "Get"
+	case *proto.MutateRequest:
+		responseBuffer = &proto.MutateResponse{}
+		methodName = "Mutate"
+	case *proto.ScanRequest:
+		responseBuffer = &proto.ScanResponse{}
+		methodName = "Scan"
+	case *proto.GetTableDescriptorsRequest:
+		responseBuffer = &proto.GetTableDescriptorsResponse{}
+		methodName = "GetTableDescriptors"
+	case *proto.CoprocessorServiceRequest:
+		responseBuffer = &proto.CoprocessorServiceResponse{}
+		methodName = "ExecService"
+	case *proto.CreateTableRequest:
+		responseBuffer = &proto.CreateTableResponse{}
+		methodName = "CreateTable"
+	case *proto.DisableTableRequest:
+		responseBuffer = &proto.DisableTableResponse{}
+		methodName = "DisableTable"
+	case *proto.EnableTableRequest:
+		responseBuffer = &proto.EnableTableResponse{}
+		methodName = "EnableTable"
+	case *proto.DeleteTableRequest:
+		responseBuffer = &proto.DeleteTableResponse{}
+		methodName = "DeleteTable"
+	case *proto.MultiRequest:
+		responseBuffer = &proto.MultiResponse{}
+		methodName = "Multi"
+	case *proto.SplitRegionRequest:
+		responseBuffer = &proto.SplitRegionResponse{}
+		methodName = "SplitRegion"
+	}
+
+	return &call{
+		methodName:     methodName,
+		request:        request,
+		responseBuffer: responseBuffer,
+		responseCh:     make(chan pb.Message, 1),
+	}
+}
+
+func (c *call) complete(err error, response []byte) {
+	defer close(c.responseCh)
+
+	if err != nil {
+		c.responseCh <- &exception{
+			msg: err.Error(),
+		}
+		return
+	}
+
+	err = pb.Unmarshal(response, c.responseBuffer)
+	if err != nil {
+		c.responseCh <- &exception{
+			msg: err.Error(),
+		}
+		return
+	}
+
+	c.responseCh <- c.responseBuffer
+}

vendor/github.com/pingcap/go-hbase/client.go

@@ -0,0 +1,454 @@
+package hbase
+
+import (
+	"bytes"
+	"crypto/md5"
+	"encoding/binary"
+	"encoding/hex"
+	"fmt"
+	"sync"
+	"time"
+
+	pb "github.com/golang/protobuf/proto"
+	"github.com/juju/errors"
+	"github.com/ngaut/go-zookeeper/zk"
+	"github.com/ngaut/log"
+	"github.com/pingcap/go-hbase/proto"
+)
+
+const (
+	zkRootRegionPath = "/meta-region-server"
+	zkMasterAddrPath = "/master"
+
+	magicHeadByte           = 0xff
+	magicHeadSize           = 1
+	idLengthSize            = 4
+	md5HexSize              = 32
+	servernameSeparator     = ","
+	rpcTimeout              = 30000
+	pingTimeout             = 30000
+	callTimeout             = 5000
+	defaultMaxActionRetries = 3
+	// Some operations can take a long time such as disable of big table.
+	// numRetries is for 'normal' stuff... Multiply by this factor when
+	// want to wait a long time.
+	retryLongerMultiplier    = 31
+	socketDefaultRetryWaitMs = 200
+	defaultRetryWaitMs       = 100
+	// always >= any unix timestamp(hbase version)
+	beyondMaxTimestamp = "99999999999999"
+)
+
+var (
+	hbaseHeaderBytes []byte = []byte("HBas")
+	metaTableName    []byte = []byte("hbase:meta")
+	metaRegionName   []byte = []byte("hbase:meta,,1")
+)
+
+var retryPauseTime = []int64{1, 2, 3, 5, 10, 20, 40, 100, 100, 100, 100, 200, 200}
+
+type RegionInfo struct {
+	Server         string
+	StartKey       []byte
+	EndKey         []byte
+	Name           string
+	Ts             string
+	TableNamespace string
+	TableName      string
+	Offline        bool
+	Split          bool
+}
+
+type tableInfo struct {
+	tableName string
+	families  []string
+}
+
+// export client interface
+type HBaseClient interface {
+	Get(tbl string, g *Get) (*ResultRow, error)
+	Put(tbl string, p *Put) (bool, error)
+	Delete(tbl string, d *Delete) (bool, error)
+	TableExists(tbl string) (bool, error)
+	DropTable(t string) error
+	DisableTable(t string) error
+	EnableTable(t string) error
+	CreateTable(t *TableDescriptor, splits [][]byte) error
+	ServiceCall(table string, call *CoprocessorServiceCall) (*proto.CoprocessorServiceResponse, error)
+	LocateRegion(table, row []byte, useCache bool) (*RegionInfo, error)
+	GetRegions(table []byte, useCache bool) ([]*RegionInfo, error)
+	Split(tblOrRegion, splitPoint string) error
+	CleanRegionCache(table []byte)
+	CleanAllRegionCache()
+	Close() error
+}
+
+// hbase client implemetation
+var _ HBaseClient = (*client)(nil)
+
+type client struct {
+	mu               sync.RWMutex // for read/update region info
+	zkClient         *zk.Conn
+	zkHosts          []string
+	zkRoot           string
+	prefetched       map[string]bool
+	cachedConns      map[string]*connection
+	cachedRegionInfo map[string]map[string]*RegionInfo
+	maxRetries       int
+	rootServerName   *proto.ServerName
+	masterServerName *proto.ServerName
+}
+
+func serverNameToAddr(server *proto.ServerName) string {
+	return fmt.Sprintf("%s:%d", server.GetHostName(), server.GetPort())
+}
+
+func cachedConnKey(addr string, srvType ServiceType) string {
+	return fmt.Sprintf("%s|%d", addr, srvType)
+}
+
+func NewClient(zkHosts []string, zkRoot string) (HBaseClient, error) {
+	cl := &client{
+		zkHosts:          zkHosts,
+		zkRoot:           zkRoot,
+		cachedConns:      make(map[string]*connection),
+		cachedRegionInfo: make(map[string]map[string]*RegionInfo),
+		prefetched:       make(map[string]bool),
+		maxRetries:       defaultMaxActionRetries,
+	}
+
+	err := cl.init()
+	if err != nil {
+		return nil, errors.Trace(err)
+	}
+
+	return cl, nil
+}
+
+func (c *client) decodeMeta(data []byte) (*proto.ServerName, error) {
+	if data[0] != magicHeadByte {
+		return nil, errors.New("unknown packet")
+	}
+
+	var n int32
+	err := binary.Read(bytes.NewBuffer(data[1:]), binary.BigEndian, &n)
+	if err != nil {
+		return nil, errors.Trace(err)
+	}
+
+	dataOffset := magicHeadSize + idLengthSize + int(n)
+	data = data[(dataOffset + 4):]
+
+	var mrs proto.MetaRegionServer
+	err = pb.Unmarshal(data, &mrs)
+	if err != nil {
+		return nil, errors.Trace(err)
+	}
+
+	return mrs.GetServer(), nil
+}
+
+// init and get root region server addr and master addr
+func (c *client) init() error {
+	zkclient, _, err := zk.Connect(c.zkHosts, time.Second*30)
+	if err != nil {
+		return errors.Trace(err)
+	}
+	c.zkClient = zkclient
+
+	res, _, _, err := c.zkClient.GetW(c.zkRoot + zkRootRegionPath)
+	if err != nil {
+		return errors.Trace(err)
+	}
+
+	c.rootServerName, err = c.decodeMeta(res)
+	if err != nil {
+		return errors.Trace(err)
+	}
+
+	log.Debug("connect root region server...", c.rootServerName)
+	serverAddr := serverNameToAddr(c.rootServerName)
+	conn, err := newConnection(serverAddr, ClientService)
+	if err != nil {
+		return errors.Trace(err)
+	}
+
+	// Set buffered regionserver conn.
+	cachedKey := cachedConnKey(serverAddr, ClientService)
+	c.cachedConns[cachedKey] = conn
+
+	res, _, _, err = c.zkClient.GetW(c.zkRoot + zkMasterAddrPath)
+	if err != nil {
+		return errors.Trace(err)
+	}
+
+	c.masterServerName, err = c.decodeMeta(res)
+	if err != nil {
+		return errors.Trace(err)
+	}
+
+	return nil
+}
+
+// get connection
+func (c *client) getConn(addr string, srvType ServiceType) (*connection, error) {
+	connKey := cachedConnKey(addr, srvType)
+	c.mu.RLock()
+	conn, ok := c.cachedConns[connKey]
+	c.mu.RUnlock()
+
+	if ok {
+		return conn, nil
+	}
+
+	var err error
+	conn, err = newConnection(addr, srvType)
+	if err != nil {
+		return nil, errors.Errorf("create new connection failed - %v", errors.ErrorStack(err))
+	}
+	c.mu.Lock()
+	c.cachedConns[connKey] = conn
+	c.mu.Unlock()
+	return conn, nil
+}
+
+func (c *client) getAdminConn(addr string) (*connection, error) {
+	return c.getConn(addr, AdminService)
+}
+
+func (c *client) getClientConn(addr string) (*connection, error) {
+	return c.getConn(addr, ClientService)
+}
+
+func (c *client) getMasterConn() (*connection, error) {
+	return c.getConn(serverNameToAddr(c.masterServerName), MasterService)
+}
+
+func (c *client) doAction(conn *connection, req pb.Message) (chan pb.Message, error) {
+	cl := newCall(req)
+	err := conn.call(cl)
+	if err != nil {
+		return nil, errors.Trace(err)
+	}
+
+	return cl.responseCh, nil
+}
+
+func (c *client) adminAction(req pb.Message) (chan pb.Message, error) {
+	conn, err := c.getMasterConn()
+	if err != nil {
+		return nil, errors.Trace(err)
+	}
+	return c.doAction(conn, req)
+}
+
+func (c *client) regionAction(addr string, req pb.Message) (chan pb.Message, error) {
+	conn, err := c.getAdminConn(addr)
+	if err != nil {
+		return nil, errors.Trace(err)
+	}
+	return c.doAction(conn, req)
+}
+
+// http://stackoverflow.com/questions/27602013/correct-way-to-get-region-name-by-using-hbase-api
+func (c *client) createRegionName(table, startKey []byte, id string, newFormat bool) []byte {
+	if len(startKey) == 0 {
+		startKey = make([]byte, 1)
+	}
+
+	b := bytes.Join([][]byte{table, startKey, []byte(id)}, []byte{','})
+
+	if newFormat {
+		m := md5.Sum(b)
+		mhex := []byte(hex.EncodeToString(m[:]))
+		b = append(bytes.Join([][]byte{b, mhex}, []byte{'.'}), '.')
+	}
+
+	return b
+}
+
+func (c *client) parseRegion(rr *ResultRow) (*RegionInfo, error) {
+	regionInfoCol, ok := rr.Columns["info:regioninfo"]
+	if !ok {
+		return nil, errors.Errorf("Unable to parse region location (no regioninfo column): %#v", rr)
+	}
+
+	offset := bytes.Index(regionInfoCol.Value, []byte("PBUF")) + 4
+	regionInfoBytes := regionInfoCol.Value[offset:]
+
+	var info proto.RegionInfo
+	err := pb.Unmarshal(regionInfoBytes, &info)
+	if err != nil {
+		return nil, errors.Errorf("Unable to parse region location: %#v", err)
+	}
+
+	ri := &RegionInfo{
+		StartKey:       info.GetStartKey(),
+		EndKey:         info.GetEndKey(),
+		Name:           bytes.NewBuffer(rr.Row).String(),
+		TableNamespace: string(info.GetTableName().GetNamespace()),
+		TableName:      string(info.GetTableName().GetQualifier()),
+		Offline:        info.GetOffline(),
+		Split:          info.GetSplit(),
+	}
+
+	if v, ok := rr.Columns["info:server"]; ok {
+		ri.Server = string(v.Value)
+	}
+
+	return ri, nil
+}
+
+func (c *client) getMetaRegion() *RegionInfo {
+	return &RegionInfo{
+		StartKey: []byte{},
+		EndKey:   []byte{},
+		Name:     string(metaRegionName),
+		Server:   serverNameToAddr(c.rootServerName),
+	}
+}
+
+func (c *client) getCachedLocation(table, row []byte) *RegionInfo {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+
+	tableStr := string(table)
+	if regions, ok := c.cachedRegionInfo[tableStr]; ok {
+		for _, region := range regions {
+			if (len(region.EndKey) == 0 ||
+				bytes.Compare(row, region.EndKey) < 0) &&
+				(len(region.StartKey) == 0 ||
+					bytes.Compare(row, region.StartKey) >= 0) {
+				return region
+			}
+		}
+	}
+
+	return nil
+}
+
+func (c *client) updateRegionCache(table []byte, region *RegionInfo) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	tableStr := string(table)
+	if _, ok := c.cachedRegionInfo[tableStr]; !ok {
+		c.cachedRegionInfo[tableStr] = make(map[string]*RegionInfo)
+	}
+	c.cachedRegionInfo[tableStr][region.Name] = region
+}
+
+func (c *client) CleanRegionCache(table []byte) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	delete(c.cachedRegionInfo, string(table))
+}
+
+func (c *client) CleanAllRegionCache() {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	c.cachedRegionInfo = map[string]map[string]*RegionInfo{}
+}
+
+func (c *client) LocateRegion(table, row []byte, useCache bool) (*RegionInfo, error) {
+	// If user wants to locate metaregion, just return it.
+	if bytes.Equal(table, metaTableName) {
+		return c.getMetaRegion(), nil
+	}
+
+	// Try to get location from cache.
+	if useCache {
+		if r := c.getCachedLocation(table, row); r != nil {
+			return r, nil
+		}
+	}
+
+	// If cache missed or not using cache, try to get and update region info.
+	metaRegion := c.getMetaRegion()
+	conn, err := c.getClientConn(metaRegion.Server)
+	if err != nil {
+		return nil, errors.Trace(err)
+	}
+
+	regionRow := c.createRegionName(table, row, beyondMaxTimestamp, true)
+
+	call := newCall(&proto.GetRequest{
+		Region: &proto.RegionSpecifier{
+			Type:  proto.RegionSpecifier_REGION_NAME.Enum(),
+			Value: metaRegionName,
+		},
+		Get: &proto.Get{
+			Row: regionRow,
+			Column: []*proto.Column{&proto.Column{
+				Family: []byte("info"),
+			}},
+			ClosestRowBefore: pb.Bool(true),
+		},
+	})
+
+	err = conn.call(call)
+	if err != nil {
+		return nil, errors.Trace(err)
+	}
+
+	response := <-call.responseCh
+
+	switch r := response.(type) {
+	case *proto.GetResponse:
+		res := r.GetResult()
+		if res == nil {
+			return nil, errors.Errorf("Empty region: [table=%s] [row=%q] [region_row=%q]", table, row, regionRow)
+		}
+
+		rr := NewResultRow(res)
+		region, err := c.parseRegion(rr)
+		if err != nil {
+			return nil, errors.Trace(err)
+		}
+
+		c.updateRegionCache(table, region)
+		return region, nil
+	case *exception:
+		return nil, errors.New(r.msg)
+	default:
+		log.Warnf("Unknown response - %T - %v", r, r)
+	}
+
+	return nil, errors.Errorf("Couldn't find the region: [table=%s] [row=%q] [region_row=%q]", table, row, regionRow)
+}
+
+func (c *client) GetRegions(table []byte, useCache bool) ([]*RegionInfo, error) {
+	var regions []*RegionInfo
+	startKey := []byte("")
+	// Get first region.
+	region, err := c.LocateRegion(table, []byte(startKey), useCache)
+	if err != nil {
+		return nil, errors.Errorf("couldn't find any region: [table=%s] [useCache=%t]", table, useCache)
+	}
+	regions = append(regions, region)
+	startKey = region.EndKey
+	for len(startKey) > 0 {
+		region, err = c.LocateRegion(table, []byte(startKey), useCache)
+		if err != nil {
+			return nil, errors.Trace(err)
+		}
+		regions = append(regions, region)
+		startKey = region.EndKey
+	}
+	return regions, nil
+}
+
+func (c *client) Close() error {
+	if c.zkClient != nil {
+		c.zkClient.Close()
+	}
+
+	for _, conn := range c.cachedConns {
+		err := conn.close()
+		if err != nil {
+			return errors.Trace(err)
+		}
+	}
+
+	return nil
+}

vendor/github.com/pingcap/go-hbase/client_ops.go

@@ -0,0 +1,67 @@
+package hbase
+
+import (
+	"github.com/juju/errors"
+	"github.com/pingcap/go-hbase/proto"
+)
+
+func (c *client) Delete(table string, del *Delete) (bool, error) {
+	response, err := c.do([]byte(table), del.GetRow(), del, true)
+	if err != nil {
+		return false, errors.Trace(err)
+	}
+
+	switch r := response.(type) {
+	case *proto.MutateResponse:
+		return r.GetProcessed(), nil
+	}
+	return false, errors.Errorf("Invalid response seen [response: %#v]", response)
+}
+
+func (c *client) Get(table string, get *Get) (*ResultRow, error) {
+	response, err := c.do([]byte(table), get.GetRow(), get, true)
+	if err != nil {
+		return nil, errors.Trace(err)
+	}
+
+	switch r := response.(type) {
+	case *proto.GetResponse:
+		res := r.GetResult()
+		if res == nil {
+			return nil, errors.Errorf("Empty response: [table=%s] [row=%q]", table, get.GetRow())
+		}
+
+		return NewResultRow(res), nil
+	case *exception:
+		return nil, errors.New(r.msg)
+	}
+	return nil, errors.Errorf("Invalid response seen [response: %#v]", response)
+}
+
+func (c *client) Put(table string, put *Put) (bool, error) {
+	response, err := c.do([]byte(table), put.GetRow(), put, true)
+	if err != nil {
+		return false, errors.Trace(err)
+	}
+
+	switch r := response.(type) {
+	case *proto.MutateResponse:
+		return r.GetProcessed(), nil
+	}
+	return false, errors.Errorf("Invalid response seen [response: %#v]", response)
+}
+
+func (c *client) ServiceCall(table string, call *CoprocessorServiceCall) (*proto.CoprocessorServiceResponse, error) {
+	response, err := c.do([]byte(table), call.Row, call, true)
+	if err != nil {
+		return nil, errors.Trace(err)
+	}
+
+	switch r := response.(type) {
+	case *proto.CoprocessorServiceResponse:
+		return r, nil
+	case *exception:
+		return nil, errors.New(r.msg)
+	}
+	return nil, errors.Errorf("Invalid response seen [response: %#v]", response)
+}

vendor/github.com/pingcap/go-hbase/column.go

@@ -0,0 +1,177 @@
+package hbase
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+
+	"github.com/juju/errors"
+	"github.com/pingcap/go-hbase/iohelper"
+)
+
+type Column struct {
+	Family []byte
+	Qual   []byte
+}
+
+func NewColumn(family, qual []byte) *Column {
+	return &Column{
+		Family: family,
+		Qual:   qual,
+	}
+}
+
+func encode(parts ...[]byte) ([]byte, error) {
+	buf := &bytes.Buffer{}
+	for _, p := range parts {
+		err := iohelper.WriteVarBytes(buf, p)
+		if err != nil {
+			return nil, errors.Trace(err)
+		}
+	}
+	return buf.Bytes(), nil
+}
+
+func decode(encoded []byte) ([][]byte, error) {
+	var ret [][]byte
+	buf := bytes.NewBuffer(encoded)
+	for {
+		b, err := iohelper.ReadVarBytes(buf)
+		if len(b) == 0 || (err != nil && ErrorEqual(err, io.EOF)) {
+			break
+		}
+		ret = append(ret, b)
+	}
+	return ret, nil
+}
+
+func (c *Column) Write(w io.Writer) error {
+	err := iohelper.WriteVarBytes(w, c.Family)
+	if err != nil {
+		return errors.Trace(err)
+	}
+
+	err = iohelper.WriteVarBytes(w, c.Qual)
+	if err != nil {
+		return errors.Trace(err)
+	}
+
+	return nil
+}
+
+func (c *Column) String() string {
+	b, err := encode(c.Family, c.Qual)
+	if err != nil {
+		return fmt.Sprintf("invalid column - %v", err)
+	}
+	return string(b)
+}
+
+func (c *Column) ParseFromString(s string) error {
+	pairs, err := decode([]byte(s))
+	if err != nil {
+		return errors.Trace(err)
+	}
+
+	c.Family = pairs[0]
+	c.Qual = pairs[1]
+	return nil
+}
+
+type ColumnCoordinate struct {
+	Table []byte
+	Row   []byte
+	Column
+}
+
+func NewColumnCoordinate(table, row, family, qual []byte) *ColumnCoordinate {
+	return &ColumnCoordinate{
+		Table: table,
+		Row:   row,
+		Column: Column{
+			Family: family,
+			Qual:   qual,
+		},
+	}
+}
+
+func (c *ColumnCoordinate) Write(w io.Writer) error {
+	err := iohelper.WriteVarBytes(w, c.Table)
+	if err != nil {
+		return errors.Trace(err)
+	}
+
+	err = iohelper.WriteVarBytes(w, c.Row)
+	if err != nil {
+		return errors.Trace(err)
+	}
+
+	err = c.Column.Write(w)
+	if err != nil {
+		return errors.Trace(err)
+	}
+
+	return nil
+}
+
+func (c *ColumnCoordinate) Equal(a *ColumnCoordinate) bool {
+	return bytes.Compare(c.Table, a.Table) == 0 &&
+		bytes.Compare(c.Row, a.Row) == 0 &&
+		bytes.Compare(c.Family, a.Family) == 0 &&
+		bytes.Compare(c.Qual, a.Qual) == 0
+}
+
+func (c *ColumnCoordinate) String() string {
+	b, err := encode(c.Table, c.Row, c.Family, c.Qual)
+	if err != nil {
+		return fmt.Sprintf("invalid column coordinate - %v", err)
+	}
+	return string(b)
+}
+
+func (c *ColumnCoordinate) ParseFromString(s string) error {
+	pairs, err := decode([]byte(s))
+	if err != nil {
+		return errors.Trace(err)
+	}
+
+	c.Table = pairs[0]
+	c.Row = pairs[1]
+	c.Family = pairs[2]
+	c.Qual = pairs[3]
+	return nil
+}
+
+func (c *ColumnCoordinate) ParseField(b iohelper.ByteMultiReader) error {
+	table, err := iohelper.ReadVarBytes(b)
+	if err != nil {
+		return errors.Trace(err)
+	}
+	c.Table = table
+
+	row, err := iohelper.ReadVarBytes(b)
+	if err != nil {
+		return errors.Trace(err)
+	}
+	c.Row = row
+
+	family, err := iohelper.ReadVarBytes(b)
+	if err != nil {
+		return errors.Trace(err)
+	}
+	c.Family = family
+
+	qual, err := iohelper.ReadVarBytes(b)
+	if err != nil {
+		return errors.Trace(err)
+	}
+	c.Qual = qual
+	return nil
+}
+
+func (c *ColumnCoordinate) GetColumn() *Column {
+	return &Column{
+		Family: c.Family,
+		Qual:   c.Qual,
+	}
+}

vendor/github.com/pingcap/go-hbase/conn.go

@@ -0,0 +1,291 @@
+package hbase
+
+import (
+	"bufio"
+	"bytes"
+	"io"
+	"net"
+	"strings"
+	"sync"
+
+	pb "github.com/golang/protobuf/proto"
+	"github.com/juju/errors"
+	"github.com/ngaut/log"
+	"github.com/pingcap/go-hbase/iohelper"
+	"github.com/pingcap/go-hbase/proto"
+)
+
+type ServiceType byte
+
+const (
+	MasterMonitorService = iota + 1
+	MasterService
+	MasterAdminService
+	AdminService
+	ClientService
+	RegionServerStatusService
+)
+
+// convert above const to protobuf string
+var ServiceString = map[ServiceType]string{
+	MasterMonitorService:      "MasterMonitorService",
+	MasterService:             "MasterService",
+	MasterAdminService:        "MasterAdminService",
+	AdminService:              "AdminService",
+	ClientService:             "ClientService",
+	RegionServerStatusService: "RegionServerStatusService",
+}
+
+type idGenerator struct {
+	n  int
+	mu *sync.RWMutex
+}
+
+func newIdGenerator() *idGenerator {
+	return &idGenerator{
+		n:  0,
+		mu: &sync.RWMutex{},
+	}
+}
+
+func (a *idGenerator) get() int {
+	a.mu.RLock()
+	v := a.n
+	a.mu.RUnlock()
+	return v
+}
+
+func (a *idGenerator) incrAndGet() int {
+	a.mu.Lock()
+	a.n++
+	v := a.n
+	a.mu.Unlock()
+	return v
+}
+
+type connection struct {
+	mu           sync.Mutex
+	addr         string
+	conn         net.Conn
+	bw           *bufio.Writer
+	idGen        *idGenerator
+	serviceType  ServiceType
+	in           chan *iohelper.PbBuffer
+	ongoingCalls map[int]*call
+}
+
+func processMessage(msg []byte) ([][]byte, error) {
+	buf := pb.NewBuffer(msg)
+	payloads := make([][]byte, 0)
+
+	// Question: why can we ignore this error?
+	for {
+		hbytes, err := buf.DecodeRawBytes(true)
+		if err != nil {
+			// Check whether error is `unexpected EOF`.
+			if strings.Contains(err.Error(), "unexpected EOF") {
+				break
+			}
+
+			log.Errorf("Decode raw bytes error - %v", errors.ErrorStack(err))
+			return nil, errors.Trace(err)
+		}
+
+		payloads = append(payloads, hbytes)
+	}
+
+	return payloads, nil
+}
+
+func readPayloads(r io.Reader) ([][]byte, error) {
+	nBytesExpecting, err := iohelper.ReadInt32(r)
+	if err != nil {
+		return nil, errors.Trace(err)
+	}
+
+	if nBytesExpecting > 0 {
+		buf, err := iohelper.ReadN(r, nBytesExpecting)
+		// Question: why should we return error only when we get an io.EOF error?
+		if err != nil && ErrorEqual(err, io.EOF) {
+			return nil, errors.Trace(err)
+		}
+
+		payloads, err := processMessage(buf)
+		if err != nil {
+			return nil, errors.Trace(err)
+		}
+
+		if len(payloads) > 0 {
+			return payloads, nil
+		}
+	}
+	return nil, errors.New("unexpected payload")
+}
+
+func newConnection(addr string, srvType ServiceType) (*connection, error) {
+	conn, err := net.Dial("tcp", addr)
+	if err != nil {
+		return nil, errors.Trace(err)
+	}
+	if _, ok := ServiceString[srvType]; !ok {
+		return nil, errors.Errorf("unexpected service type [serviceType=%d]", srvType)
+	}
+	c := &connection{
+		addr:         addr,
+		bw:           bufio.NewWriter(conn),
+		conn:         conn,
+		in:           make(chan *iohelper.PbBuffer, 20),
+		serviceType:  srvType,
+		idGen:        newIdGenerator(),
+		ongoingCalls: map[int]*call{},
+	}
+
+	err = c.init()
+	if err != nil {
+		return nil, errors.Trace(err)
+	}
+
+	return c, nil
+}
+
+func (c *connection) init() error {
+	err := c.writeHead()
+	if err != nil {
+		return errors.Trace(err)
+	}
+
+	err = c.writeConnectionHeader()
+	if err != nil {
+		return errors.Trace(err)
+	}
+
+	go func() {
+		err := c.processMessages()
+		if err != nil {
+			log.Warnf("process messages failed - %v", errors.ErrorStack(err))
+			return
+		}
+	}()
+	go c.dispatch()
+	return nil
+}
+
+func (c *connection) processMessages() error {
+	for {
+		msgs, err := readPayloads(c.conn)
+		if err != nil {
+			return errors.Trace(err)
+		}
+
+		var rh proto.ResponseHeader
+		err = pb.Unmarshal(msgs[0], &rh)
+		if err != nil {
+			return errors.Trace(err)
+		}
+
+		callId := rh.GetCallId()
+		c.mu.Lock()
+		call, ok := c.ongoingCalls[int(callId)]
+		if !ok {
+			c.mu.Unlock()
+			return errors.Errorf("Invalid call id: %d", callId)
+		}
+		delete(c.ongoingCalls, int(callId))
+		c.mu.Unlock()
+
+		exception := rh.GetException()
+		if exception != nil {
+			call.complete(errors.Errorf("Exception returned: %s\n%s", exception.GetExceptionClassName(), exception.GetStackTrace()), nil)
+		} else if len(msgs) == 2 {
+			call.complete(nil, msgs[1])
+		}
+	}
+}
+
+func (c *connection) writeHead() error {
+	buf := bytes.NewBuffer(nil)
+	buf.Write(hbaseHeaderBytes)
+	buf.WriteByte(0)
+	buf.WriteByte(80)
+	_, err := c.conn.Write(buf.Bytes())
+	return errors.Trace(err)
+}
+
+func (c *connection) writeConnectionHeader() error {
+	buf := iohelper.NewPbBuffer()
+	service := pb.String(ServiceString[c.serviceType])
+
+	err := buf.WritePBMessage(&proto.ConnectionHeader{
+		UserInfo: &proto.UserInformation{
+			EffectiveUser: pb.String("pingcap"),
+		},
+		ServiceName: service,
+	})
+	if err != nil {
+		return errors.Trace(err)
+	}
+
+	err = buf.PrependSize()
+	if err != nil {
+		return errors.Trace(err)
+	}
+
+	_, err = c.conn.Write(buf.Bytes())
+	if err != nil {
+		return errors.Trace(err)
+	}
+
+	return nil
+}
+
+func (c *connection) dispatch() {
+	for {
+		select {
+		case buf := <-c.in:
+			// TODO: add error check.
+			c.bw.Write(buf.Bytes())
+			if len(c.in) == 0 {
+				c.bw.Flush()
+			}
+		}
+	}
+}
+
+func (c *connection) call(request *call) error {
+	id := c.idGen.incrAndGet()
+	rh := &proto.RequestHeader{
+		CallId:       pb.Uint32(uint32(id)),
+		MethodName:   pb.String(request.methodName),
+		RequestParam: pb.Bool(true),
+	}
+
+	request.id = uint32(id)
+
+	bfrh := iohelper.NewPbBuffer()
+	err := bfrh.WritePBMessage(rh)
+	if err != nil {
+		return errors.Trace(err)
+	}
+
+	bfr := iohelper.NewPbBuffer()
+	err = bfr.WritePBMessage(request.request)
+	if err != nil {
+		return errors.Trace(err)
+	}
+
+	// Buf =>
+	// | total size | pb1 size | pb1 | pb2 size | pb2 | ...
+	buf := iohelper.NewPbBuffer()
+	buf.WriteDelimitedBuffers(bfrh, bfr)
+
+	c.mu.Lock()
+	c.ongoingCalls[id] = request
+	c.in <- buf
+	c.mu.Unlock()
+
+	return nil
+}
+
+func (c *connection) close() error {
+	return c.conn.Close()
+}

vendor/github.com/pingcap/go-hbase/del.go

@@ -0,0 +1,113 @@
+package hbase
+
+import (
+	pb "github.com/golang/protobuf/proto"
+	"github.com/pingcap/go-hbase/proto"
+
+	"fmt"
+	"math"
+	"strings"
+)
+
+type Delete struct {
+	Row         []byte
+	Families    set
+	FamilyQuals map[string]set
+	Ts          map[string]uint64
+}
+
+func NewDelete(row []byte) *Delete {
+	return &Delete{
+		Row:         row,
+		Families:    newSet(),
+		FamilyQuals: make(map[string]set),
+		Ts:          make(map[string]uint64),
+	}
+}
+
+func (d *Delete) AddString(famqual string) error {
+	parts := strings.Split(famqual, ":")
+
+	if len(parts) > 2 {
+		return fmt.Errorf("Too many colons were found in the family:qualifier string. '%s'", famqual)
+	} else if len(parts) == 2 {
+		d.AddStringColumn(parts[0], parts[1])
+	} else {
+		d.AddStringFamily(famqual)
+	}
+
+	return nil
+}
+
+func (d *Delete) GetRow() []byte {
+	return d.Row
+}
+
+func (d *Delete) AddColumn(family, qual []byte) *Delete {
+	d.AddFamily(family)
+	d.FamilyQuals[string(family)].add(string(qual))
+	return d
+}
+
+func (d *Delete) AddStringColumn(family, qual string) *Delete {
+	return d.AddColumn([]byte(family), []byte(qual))
+}
+
+func (d *Delete) AddFamily(family []byte) *Delete {
+	d.Families.add(string(family))
+	if _, ok := d.FamilyQuals[string(family)]; !ok {
+		d.FamilyQuals[string(family)] = newSet()
+	}
+	return d
+}
+
+func (d *Delete) AddStringFamily(family string) *Delete {
+	return d.AddFamily([]byte(family))
+}
+
+func (d *Delete) AddColumnWithTimestamp(family, qual []byte, ts uint64) *Delete {
+	d.AddColumn(family, qual)
+	k := string(family) + ":" + string(qual)
+	d.Ts[k] = ts
+	return d
+}
+
+func (d *Delete) ToProto() pb.Message {
+	del := &proto.MutationProto{
+		Row:        d.Row,
+		MutateType: proto.MutationProto_DELETE.Enum(),
+	}
+
+	for family := range d.Families {
+		cv := &proto.MutationProto_ColumnValue{
+			Family:         []byte(family),
+			QualifierValue: make([]*proto.MutationProto_ColumnValue_QualifierValue, 0),
+		}
+
+		if len(d.FamilyQuals[family]) == 0 {
+			cv.QualifierValue = append(cv.QualifierValue, &proto.MutationProto_ColumnValue_QualifierValue{
+				Qualifier:  nil,
+				Timestamp:  pb.Uint64(uint64(math.MaxInt64)),
+				DeleteType: proto.MutationProto_DELETE_FAMILY.Enum(),
+			})
+		}
+
+		for qual := range d.FamilyQuals[family] {
+			v := &proto.MutationProto_ColumnValue_QualifierValue{
+				Qualifier:  []byte(qual),
+				Timestamp:  pb.Uint64(uint64(math.MaxInt64)),
+				DeleteType: proto.MutationProto_DELETE_MULTIPLE_VERSIONS.Enum(),
+			}
+			tsKey := string(family) + ":" + string(qual)
+			if ts, ok := d.Ts[tsKey]; ok {
+				v.Timestamp = pb.Uint64(ts)
+				v.DeleteType = proto.MutationProto_DELETE_ONE_VERSION.Enum()
+			}
+			cv.QualifierValue = append(cv.QualifierValue, v)
+		}
+
+		del.ColumnValue = append(del.ColumnValue, cv)
+	}
+
+	return del
+}

vendor/github.com/pingcap/go-hbase/get.go

@@ -0,0 +1,105 @@
+package hbase
+
+import (
+	"strings"
+
+	pb "github.com/golang/protobuf/proto"
+	"github.com/juju/errors"
+	"github.com/pingcap/go-hbase/proto"
+)
+
+type Get struct {
+	Row         []byte
+	Families    set
+	FamilyQuals map[string]set
+	Versions    int32
+	TsRangeFrom uint64
+	TsRangeTo   uint64
+}
+
+func NewGet(row []byte) *Get {
+	return &Get{
+		Row:         append([]byte(nil), row...),
+		Families:    newSet(),
+		FamilyQuals: make(map[string]set),
+		Versions:    1,
+	}
+}
+
+func (g *Get) GetRow() []byte {
+	return g.Row
+}
+
+func (g *Get) AddString(famqual string) error {
+	parts := strings.Split(famqual, ":")
+
+	if len(parts) > 2 {
+		return errors.Errorf("Too many colons were found in the family:qualifier string. '%s'", famqual)
+	} else if len(parts) == 2 {
+		g.AddStringColumn(parts[0], parts[1])
+	} else {
+		g.AddStringFamily(famqual)
+	}
+
+	return nil
+}
+
+func (g *Get) AddColumn(family, qual []byte) *Get {
+	g.AddFamily(family)
+	g.FamilyQuals[string(family)].add(string(qual))
+	return g
+}
+
+func (g *Get) AddStringColumn(family, qual string) *Get {
+	return g.AddColumn([]byte(family), []byte(qual))
+}
+
+func (g *Get) AddFamily(family []byte) *Get {
+	g.Families.add(string(family))
+	if _, ok := g.FamilyQuals[string(family)]; !ok {
+		g.FamilyQuals[string(family)] = newSet()
+	}
+	return g
+}
+
+func (g *Get) AddStringFamily(family string) *Get {
+	return g.AddFamily([]byte(family))
+}
+
+func (g *Get) AddTimeRange(from uint64, to uint64) *Get {
+	g.TsRangeFrom = from
+	g.TsRangeTo = to
+	return g
+}
+
+func (g *Get) SetMaxVersion(maxVersion int32) *Get {
+	g.Versions = maxVersion
+	return g
+}
+
+func (g *Get) ToProto() pb.Message {
+	get := &proto.Get{
+		Row: g.Row,
+	}
+
+	if g.TsRangeFrom != 0 && g.TsRangeTo != 0 && g.TsRangeFrom <= g.TsRangeTo {
+		get.TimeRange = &proto.TimeRange{
+			From: pb.Uint64(g.TsRangeFrom),
+			To:   pb.Uint64(g.TsRangeTo),
+		}
+	}
+
+	for v := range g.Families {
+		col := &proto.Column{
+			Family: []byte(v),
+		}
+		var quals [][]byte
+		for qual := range g.FamilyQuals[v] {
+			quals = append(quals, []byte(qual))
+		}
+		col.Qualifier = quals
+		get.Column = append(get.Column, col)
+	}
+	get.MaxVersions = pb.Uint32(uint32(g.Versions))
+	return get
+}

vendor/github.com/pingcap/go-hbase/iohelper/multireader.go

@@ -0,0 +1,8 @@
+package iohelper
+
+import "io"
+
+type ByteMultiReader interface {
+	io.ByteReader
+	io.Reader
+}

vendor/github.com/pingcap/go-hbase/iohelper/pbbuffer.go

@@ -0,0 +1,111 @@
+package iohelper
+
+import (
+	"encoding/binary"
+
+	pb "github.com/golang/protobuf/proto"
+	"github.com/juju/errors"
+)
+
+type PbBuffer struct {
+	b []byte
+}
+
+func NewPbBuffer() *PbBuffer {
+	b := []byte{}
+	return &PbBuffer{
+		b: b,
+	}
+}
+
+func (b *PbBuffer) Bytes() []byte {
+	return b.b
+}
+
+func (b *PbBuffer) Write(d []byte) (int, error) {
+	b.b = append(b.b, d...)
+	return len(d), nil
+}
+
+func (b *PbBuffer) WriteByte(d byte) error {
+	return binary.Write(b, binary.BigEndian, d)
+}
+
+func (b *PbBuffer) WriteString(d string) error {
+	return binary.Write(b, binary.BigEndian, d)
+}
+
+func (b *PbBuffer) WriteInt32(d int32) error {
+	return binary.Write(b, binary.BigEndian, d)
+}
+
+func (b *PbBuffer) WriteInt64(d int64) error {
+	return binary.Write(b, binary.BigEndian, d)
+}
+
+func (b *PbBuffer) WriteFloat32(d float32) error {
+	return binary.Write(b, binary.BigEndian, d)
+}
+
+func (b *PbBuffer) WriteFloat64(d float64) error {
+	return binary.Write(b, binary.BigEndian, d)
+}
+
+func (b *PbBuffer) WritePBMessage(d pb.Message) error {
+	buf, err := pb.Marshal(d)
+	if err != nil {
+		return errors.Trace(err)
+	}
+
+	_, err = b.Write(buf)
+	return errors.Trace(err)
+}
+
+func (b *PbBuffer) WriteDelimitedBuffers(bufs ...*PbBuffer) error {
+	totalLength := 0
+	lens := make([][]byte, len(bufs))
+	for i, v := range bufs {
+		n := len(v.Bytes())
+		lenb := pb.EncodeVarint(uint64(n))
+
+		totalLength += len(lenb) + n
+		lens[i] = lenb
+	}
+
+	err := b.WriteInt32(int32(totalLength))
+	if err != nil {
+		return errors.Trace(err)
+	}
+
+	for i, v := range bufs {
+		_, err = b.Write(lens[i])
+		if err != nil {
+			return errors.Trace(err)
+		}
+
+		_, err = b.Write(v.Bytes())
+		if err != nil {
+			return errors.Trace(err)
+		}
+	}
+
+	return nil
+}
+
+func (b *PbBuffer) PrependSize() error {
+	size := int32(len(b.b))
+	newBuf := NewPbBuffer()
+
+	err := newBuf.WriteInt32(size)
+	if err != nil {
+		return errors.Trace(err)
+	}
+
+	_, err = newBuf.Write(b.b)
+	if err != nil {
+		return errors.Trace(err)
+	}
+
+	*b = *newBuf
+	return nil
+}

vendor/github.com/pingcap/go-hbase/iohelper/utils.go

@@ -0,0 +1,177 @@
+package iohelper
+
+import (
+	"bytes"
+	"encoding/binary"
+	"io"
+
+	"github.com/juju/errors"
+)
+
+var (
+	cachedItob [][]byte
+)
+
+func init() {
+	cachedItob = make([][]byte, 1024)
+	for i := 0; i < len(cachedItob); i++ {
+		var b bytes.Buffer
+		writeVLong(&b, int64(i))
+		cachedItob[i] = b.Bytes()
+	}
+}
+
+func itob(i int) ([]byte, error) {
+	if i >= 0 && i < len(cachedItob) {
+		return cachedItob[i], nil
+	}
+
+	var b bytes.Buffer
+	err := binary.Write(&b, binary.BigEndian, i)
+	if err != nil {
+		return nil, errors.Trace(err)
+	}
+	return b.Bytes(), nil
+}
+
+func decodeVIntSize(value byte) int32 {
+	if int32(value) >= -112 {
+		return int32(1)
+	}
+
+	if int32(value) < -120 {
+		return -119 - int32(value)
+	}
+
+	return -111 - int32(value)
+}
+
+func isNegativeVInt(value byte) bool {
+	return int32(value) < -120 || int32(value) >= -112 && int32(value) < 0
+}
+
+func readVLong(r io.Reader) (int64, error) {
+	var firstByte byte
+	err := binary.Read(r, binary.BigEndian, &firstByte)
+	if err != nil {
+		return 0, errors.Trace(err)
+	}
+
+	l := decodeVIntSize(firstByte)
+	if l == 1 {
+		return int64(firstByte), nil
+	}
+
+	var (
+		i   int64
+		idx int32
+	)
+
+	for idx = 0; idx < l-1; idx++ {
+		var b byte
+		err = binary.Read(r, binary.BigEndian, &b)
+		if err != nil {
+			return 0, errors.Trace(err)
+		}
+
+		i <<= 8
+		i |= int64(b & 255)
+	}
+
+	if isNegativeVInt(firstByte) {
+		return ^i, nil
+	}
+
+	return i, nil
+}
+
+func writeVLong(w io.Writer, i int64) error {
+	var err error
+	if i >= -112 && i <= 127 {
+		err = binary.Write(w, binary.BigEndian, byte(i))
+		if err != nil {
+			return errors.Trace(err)
+		}
+	} else {
+		var l int32 = -112
+		if i < 0 {
+			i = ^i
+			l = -120
+		}
+		var tmp int64
+		for tmp = i; tmp != 0; l-- {
+			tmp >>= 8
+		}
+
+		err = binary.Write(w, binary.BigEndian, byte(l))
+		if err != nil {
+			return errors.Trace(err)
+		}
+
+		if l < -120 {
+			l = -(l + 120)
+		} else {
+			l = -(l + 112)
+		}
+
+		for idx := l; idx != 0; idx-- {
+			var mask int64
+			shiftbits := uint((idx - 1) * 8)
+			mask = int64(255) << shiftbits
+			err = binary.Write(w, binary.BigEndian, byte((i&mask)>>shiftbits))
+			if err != nil {
+				return errors.Trace(err)
+			}
+		}
+	}
+
+	return nil
+}
+
+func ReadVarBytes(r ByteMultiReader) ([]byte, error) {
+	sz, err := readVLong(r)
+	if err != nil {
+		return nil, errors.Trace(err)
+	}
+
+	b := make([]byte, sz)
+	_, err = r.Read(b)
+	if err != nil {
+		return nil, errors.Trace(err)
+	}
+
+	return b, nil
+}
+
+func WriteVarBytes(w io.Writer, b []byte) error {
+	lenb, err := itob(len(b))
+	if err != nil {
+		return errors.Trace(err)
+	}
+
+	_, err = w.Write(lenb)
+	if err != nil {
+		return errors.Trace(err)
+	}
+
+	_, err = w.Write(b)
+	return errors.Trace(err)
+}
+
+func ReadInt32(r io.Reader) (int32, error) {
+	var n int32
+	err := binary.Read(r, binary.BigEndian, &n)
+	return n, errors.Trace(err)
+}
+
+func ReadN(r io.Reader, n int32) ([]byte, error) {
+	b := make([]byte, n)
+	_, err := io.ReadFull(r, b)
+	return b, errors.Trace(err)
+}
+
+func ReadUint64(r io.Reader) (uint64, error) {
+	var n uint64
+	err := binary.Read(r, binary.BigEndian, &n)
+	return n, errors.Trace(err)
+}

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)
+}

vendor/github.com/pingcap/go-hbase/put.go

@@ -0,0 +1,92 @@
+package hbase
+
+import (
+	"bytes"
+	"math"
+
+	pb "github.com/golang/protobuf/proto"
+	"github.com/pingcap/go-hbase/proto"
+)
+
+type Put struct {
+	Row        []byte
+	Families   [][]byte
+	Qualifiers [][][]byte
+	Values     [][][]byte
+	Timestamp  uint64
+}
+
+func NewPut(row []byte) *Put {
+	return &Put{
+		Row:        row,
+		Families:   make([][]byte, 0),
+		Qualifiers: make([][][]byte, 0),
+		Values:     make([][][]byte, 0),
+	}
+}
+
+func (p *Put) GetRow() []byte {
+	return p.Row
+}
+
+func (p *Put) AddValue(family, qual, value []byte) *Put {
+	pos := p.posOfFamily(family)
+	if pos == -1 {
+		p.Families = append(p.Families, family)
+		p.Qualifiers = append(p.Qualifiers, make([][]byte, 0))
+		p.Values = append(p.Values, make([][]byte, 0))
+
+		pos = p.posOfFamily(family)
+	}
+
+	p.Qualifiers[pos] = append(p.Qualifiers[pos], qual)
+	p.Values[pos] = append(p.Values[pos], value)
+	return p
+}
+
+func (p *Put) AddStringValue(family, column, value string) *Put {
+	return p.AddValue([]byte(family), []byte(column), []byte(value))
+}
+
+func (p *Put) AddTimestamp(ts uint64) *Put {
+	if ts == 0 {
+		p.Timestamp = math.MaxInt64
+	} else {
+		p.Timestamp = ts
+	}
+	return p
+}
+
+func (p *Put) posOfFamily(family []byte) int {
+	for p, v := range p.Families {
+		if bytes.Equal(family, v) {
+			return p
+		}
+	}
+	return -1
+}
+
+func (p *Put) ToProto() pb.Message {
+	put := &proto.MutationProto{
+		Row:        p.Row,
+		MutateType: proto.MutationProto_PUT.Enum(),
+	}
+
+	for i, family := range p.Families {
+		cv := &proto.MutationProto_ColumnValue{
+			Family: family,
+		}
+
+		for j := range p.Qualifiers[i] {
+			cv.QualifierValue = append(cv.QualifierValue, &proto.MutationProto_ColumnValue_QualifierValue{
+				Qualifier: p.Qualifiers[i][j],
+				Value:     p.Values[i][j],
+				Timestamp: pb.Uint64(p.Timestamp),
+			})
+		}
+
+		put.ColumnValue = append(put.ColumnValue, cv)
+	}
+
+	return put
+}

vendor/github.com/pingcap/go-hbase/result.go

@@ -0,0 +1,76 @@
+package hbase
+
+import (
+	"fmt"
+
+	"github.com/pingcap/go-hbase/proto"
+)
+
+type Kv struct {
+	Row   []byte
+	Ts    uint64
+	Value []byte
+	// history results
+	Values map[uint64][]byte
+	Column
+}
+
+func (kv *Kv) String() string {
+	if kv == nil {
+		return "<nil>"
+	}
+	return fmt.Sprintf("Kv(%+v)", *kv)
+}
+
+type ResultRow struct {
+	Row           []byte
+	Columns       map[string]*Kv
+	SortedColumns []*Kv
+}
+
+func (r *ResultRow) String() string {
+	if r == nil {
+		return "<nil>"
+	}
+	return fmt.Sprintf("ResultRow(%+v)", *r)
+}
+
+func NewResultRow(result *proto.Result) *ResultRow {
+	// empty response
+	if len(result.GetCell()) == 0 {
+		return nil
+	}
+	res := &ResultRow{}
+	res.Columns = make(map[string]*Kv)
+	res.SortedColumns = make([]*Kv, 0)
+
+	for _, cell := range result.GetCell() {
+		res.Row = cell.GetRow()
+
+		col := &Kv{
+			Row: res.Row,
+			Column: Column{
+				Family: cell.GetFamily(),
+				Qual:   cell.GetQualifier(),
+			},
+			Value: cell.GetValue(),
+			Ts:    cell.GetTimestamp(),
+		}
+
+		colName := string(col.Column.Family) + ":" + string(col.Column.Qual)
+
+		if v, exists := res.Columns[colName]; exists {
+			// renew the same cf result
+			if col.Ts > v.Ts {
+				v.Value = col.Value
+				v.Ts = col.Ts
+			}
+			v.Values[col.Ts] = col.Value
+		} else {
+			col.Values = map[uint64][]byte{col.Ts: col.Value}
+			res.Columns[colName] = col
+			res.SortedColumns = append(res.SortedColumns, col)
+		}
+	}
+	return res
+}

vendor/github.com/pingcap/go-hbase/scan.go

@@ -0,0 +1,397 @@
+package hbase
+
+import (
+	"bytes"
+
+	pb "github.com/golang/protobuf/proto"
+	"github.com/juju/errors"
+	"github.com/ngaut/log"
+	"github.com/pingcap/go-hbase/proto"
+)
+
+// nextKey returns the next key in byte-order.
+// for example:
+// nil -> [0]
+// [] -> [0]
+// [0] -> [1]
+// [1, 2, 3] -> [1, 2, 4]
+// [1, 255] -> [2, 0]
+// [255] -> [0, 0]
+func nextKey(data []byte) []byte {
+	// nil or []byte{}
+	dataLen := len(data)
+	if dataLen == 0 {
+		return []byte{0}
+	}
+
+	// Check and process carry bit.
+	i := dataLen - 1
+	data[i]++
+	for i > 0 {
+		if data[i] == 0 {
+			i--
+			data[i]++
+		} else {
+			break
+		}
+	}
+
+	// Check whether need to add another byte for carry bit,
+	// like [255] -> [0, 0]
+	if data[i] == 0 {
+		data = append([]byte{0}, data...)
+	}
+
+	return data
+}
+
+const (
+	defaultScanMaxRetries = 3
+)
+
+type Scan struct {
+	client *client
+	id     uint64
+	table  []byte
+	// row key
+	StartRow     []byte
+	StopRow      []byte
+	families     [][]byte
+	qualifiers   [][][]byte
+	nextStartKey []byte
+	numCached    int
+	closed       bool
+	location     *RegionInfo
+	server       *connection
+	cache        []*ResultRow
+	attrs        map[string][]byte
+	MaxVersions  uint32
+	TsRangeFrom  uint64
+	TsRangeTo    uint64
+	lastResult   *ResultRow
+	// if region split, set startKey = lastResult.Row, but must skip the first
+	skipFirst  bool
+	maxRetries int
+}
+
+func NewScan(table []byte, batchSize int, c HBaseClient) *Scan {
+	if batchSize <= 0 {
+		batchSize = 100
+	}
+	return &Scan{
+		client:       c.(*client),
+		table:        table,
+		nextStartKey: nil,
+		families:     make([][]byte, 0),
+		qualifiers:   make([][][]byte, 0),
+		numCached:    batchSize,
+		closed:       false,
+		attrs:        make(map[string][]byte),
+		maxRetries:   defaultScanMaxRetries,
+	}
+}
+
+func (s *Scan) Close() error {
+	if s.closed {
+		return nil
+	}
+
+	err := s.closeScan(s.server, s.location, s.id)
+	if err != nil {
+		return errors.Trace(err)
+	}
+
+	s.closed = true
+	return nil
+}
+
+func (s *Scan) AddColumn(family, qual []byte) {
+	s.AddFamily(family)
+	pos := s.posOfFamily(family)
+	s.qualifiers[pos] = append(s.qualifiers[pos], qual)
+}
+
+func (s *Scan) AddStringColumn(family, qual string) {
+	s.AddColumn([]byte(family), []byte(qual))
+}
+
+func (s *Scan) AddFamily(family []byte) {
+	pos := s.posOfFamily(family)
+	if pos == -1 {
+		s.families = append(s.families, family)
+		s.qualifiers = append(s.qualifiers, make([][]byte, 0))
+	}
+}
+
+func (s *Scan) AddStringFamily(family string) {
+	s.AddFamily([]byte(family))
+}
+
+func (s *Scan) posOfFamily(family []byte) int {
+	for p, v := range s.families {
+		if bytes.Equal(family, v) {
+			return p
+		}
+	}
+	return -1
+}
+
+func (s *Scan) AddAttr(name string, val []byte) {
+	s.attrs[name] = val
+}
+
+func (s *Scan) AddTimeRange(from uint64, to uint64) {
+	s.TsRangeFrom = from
+	s.TsRangeTo = to
+}
+
+func (s *Scan) Closed() bool {
+	return s.closed
+}
+
+func (s *Scan) CreateGetFromScan(row []byte) *Get {
+	g := NewGet(row)
+	for i, family := range s.families {
+		if len(s.qualifiers[i]) > 0 {
+			for _, qual := range s.qualifiers[i] {
+				g.AddColumn(family, qual)
+			}
+		} else {
+			g.AddFamily(family)
+		}
+	}
+	return g
+}
+
+func (s *Scan) getData(startKey []byte, retries int) ([]*ResultRow, error) {
+	server, location, err := s.getServerAndLocation(s.table, startKey)
+	if err != nil {
+		return nil, errors.Trace(err)
+	}
+
+	req := &proto.ScanRequest{
+		Region: &proto.RegionSpecifier{
+			Type:  proto.RegionSpecifier_REGION_NAME.Enum(),
+			Value: []byte(location.Name),
+		},
+		NumberOfRows: pb.Uint32(uint32(s.numCached)),
+		Scan:         &proto.Scan{},
+	}
+
+	// set attributes
+	var attrs []*proto.NameBytesPair
+	for k, v := range s.attrs {
+		p := &proto.NameBytesPair{
+			Name:  pb.String(k),
+			Value: v,
+		}
+		attrs = append(attrs, p)
+	}
+	if len(attrs) > 0 {
+		req.Scan.Attribute = attrs
+	}
+
+	if s.id > 0 {
+		req.ScannerId = pb.Uint64(s.id)
+	}
+	req.Scan.StartRow = startKey
+	if s.StopRow != nil {
+		req.Scan.StopRow = s.StopRow
+	}
+	if s.MaxVersions > 0 {
+		req.Scan.MaxVersions = &s.MaxVersions
+	}
+	if s.TsRangeTo > s.TsRangeFrom {
+		req.Scan.TimeRange = &proto.TimeRange{
+			From: pb.Uint64(s.TsRangeFrom),
+			To:   pb.Uint64(s.TsRangeTo),
+		}
+	}
+
+	for i, v := range s.families {
+		req.Scan.Column = append(req.Scan.Column, &proto.Column{
+			Family:    v,
+			Qualifier: s.qualifiers[i],
+		})
+	}
+
+	cl := newCall(req)
+	err = server.call(cl)
+	if err != nil {
+		return nil, errors.Trace(err)
+	}
+
+	msg := <-cl.responseCh
+	rs, err := s.processResponse(msg)
+	if err != nil && (isNotInRegionError(err) || isUnknownScannerError(err)) {
+		if retries <= s.maxRetries {
+			// clean this table region cache and try again
+			s.client.CleanRegionCache(s.table)
+			// create new scanner and set startRow to lastResult
+			s.id = 0
+			if s.lastResult != nil {
+				startKey = s.lastResult.Row
+				s.skipFirst = true
+			}
+			s.server = nil
+			s.location = nil
+			log.Warnf("Retryint get data for %d time(s)", retries+1)
+			retrySleep(retries + 1)
+			return s.getData(startKey, retries+1)
+		}
+	}
+	return rs, nil
+}
+
+func (s *Scan) processResponse(response pb.Message) ([]*ResultRow, error) {
+	var res *proto.ScanResponse
+	switch r := response.(type) {
+	case *proto.ScanResponse:
+		res = r
+	case *exception:
+		return nil, errors.New(r.msg)
+	default:
+		return nil, errors.Errorf("Invalid response seen [response: %#v]", response)
+	}
+
+	// Check whether response is nil.
+	if res == nil {
+		return nil, errors.Errorf("Empty response: [table=%s] [StartRow=%q] [StopRow=%q] ", s.table, s.StartRow, s.StopRow)
+	}
+
+	nextRegion := true
+	s.nextStartKey = nil
+	s.id = res.GetScannerId()
+
+	results := res.GetResults()
+	n := len(results)
+
+	if (n == s.numCached) ||
+		len(s.location.EndKey) == 0 ||
+		(s.StopRow != nil && bytes.Compare(s.location.EndKey, s.StopRow) > 0 && n < s.numCached) ||
+		res.GetMoreResultsInRegion() {
+		nextRegion = false
+	}
+
+	var err error
+	if nextRegion {
+		s.nextStartKey = s.location.EndKey
+		err = s.closeScan(s.server, s.location, s.id)
+		if err != nil {
+			return nil, errors.Trace(err)
+		}
+		s.server = nil
+		s.location = nil
+		s.id = 0
+	}
+
+	if n == 0 && !nextRegion {
+		err = s.Close()
+		if err != nil {
+			return nil, errors.Trace(err)
+		}
+	}
+
+	if s.skipFirst {
+		results = results[1:]
+		s.skipFirst = false
+		n = len(results)
+	}
+
+	tbr := make([]*ResultRow, n)
+	for i, v := range results {
+		if v != nil {
+			tbr[i] = NewResultRow(v)
+		}
+	}
+
+	return tbr, nil
+}
+
+func (s *Scan) nextBatch() int {
+	startKey := s.nextStartKey
+	if startKey == nil {
+		startKey = s.StartRow
+	}
+
+	// Notice: ignore error here.
+	// TODO: add error check, now only add a log.
+	rs, err := s.getData(startKey, 0)
+	if err != nil {
+		log.Errorf("scan next batch failed - [startKey=%q], %v", startKey, errors.ErrorStack(err))
+	}
+
+	// Current region get 0 data, try switch to next region.
+	if len(rs) == 0 && len(s.nextStartKey) > 0 {
+		// TODO: add error check, now only add a log.
+		rs, err = s.getData(s.nextStartKey, 0)
+		if err != nil {
+			log.Errorf("scan next batch failed - [startKey=%q], %v", s.nextStartKey, errors.ErrorStack(err))
+		}
+	}
+
+	s.cache = rs
+	return len(s.cache)
+}
+
+func (s *Scan) Next() *ResultRow {
+	if s.closed {
+		return nil
+	}
+	var ret *ResultRow
+	if len(s.cache) == 0 {
+		n := s.nextBatch()
+		// no data returned
+		if n == 0 {
+			return nil
+		}
+	}
+
+	ret = s.cache[0]
+	s.lastResult = ret
+	s.cache = s.cache[1:]
+	return ret
+}
+
+func (s *Scan) closeScan(server *connection, location *RegionInfo, id uint64) error {
+	if server == nil || location == nil {
+		return nil
+	}
+
+	req := &proto.ScanRequest{
+		Region: &proto.RegionSpecifier{
+			Type:  proto.RegionSpecifier_REGION_NAME.Enum(),
+			Value: []byte(location.Name),
+		},
+		ScannerId:    pb.Uint64(id),
+		CloseScanner: pb.Bool(true),
+	}
+
+	cl := newCall(req)
+	err := server.call(cl)
+	if err != nil {
+		return errors.Trace(err)
+	}
+
+	// TODO: add exception check.
+	<-cl.responseCh
+	return nil
+}
+
+func (s *Scan) getServerAndLocation(table, startRow []byte) (*connection, *RegionInfo, error) {
+	if s.server != nil && s.location != nil {
+		return s.server, s.location, nil
+	}
+
+	var err error
+	s.location, err = s.client.LocateRegion(table, startRow, true)
+	if err != nil {
+		return nil, nil, errors.Trace(err)
+	}
+
+	s.server, err = s.client.getClientConn(s.location.Server)
+	if err != nil {
+		return nil, nil, errors.Trace(err)
+	}
+	return s.server, s.location, nil
+}

vendor/github.com/pingcap/go-hbase/service_call.go

@@ -0,0 +1,22 @@
+package hbase
+
+import (
+	"github.com/pingcap/go-hbase/proto"
+	pb "github.com/golang/protobuf/proto"
+)
+
+type CoprocessorServiceCall struct {
+	Row          []byte
+	ServiceName  string
+	MethodName   string
+	RequestParam []byte
+}
+
+func (c *CoprocessorServiceCall) ToProto() pb.Message {
+	return &proto.CoprocessorServiceCall{
+		Row:         c.Row,
+		ServiceName: pb.String(c.ServiceName),
+		MethodName:  pb.String(c.MethodName),
+		Request:     c.RequestParam,
+	}
+}

vendor/github.com/pingcap/go-hbase/types.go

@@ -0,0 +1,40 @@
+package hbase
+
+import "bytes"
+
+type Type byte
+
+const (
+	TypeMinimum             = Type(0)
+	TypePut                 = Type(4)
+	TypeDelete              = Type(8)
+	TypeDeleteFamilyVersion = Type(10)
+	TypeDeleteColumn        = Type(12)
+	TypeDeleteFamily        = Type(14)
+	TypeMaximum             = Type(0xff)
+)
+
+type set map[string]struct{}
+
+func newSet() set {
+	return set(map[string]struct{}{})
+}
+
+func (s set) exists(k string) bool {
+	_, ok := s[k]
+	return ok
+}
+
+func (s set) add(k string) {
+	s[k] = struct{}{}
+}
+
+func (s set) remove(k string) {
+	delete(s, k)
+}
+
+type BytesSlice [][]byte
+
+func (s BytesSlice) Len() int           { return len(s) }
+func (s BytesSlice) Less(i, j int) bool { return bytes.Compare(s[i], s[j]) < 0 }
+func (s BytesSlice) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }

vendor/github.com/pingcap/go-hbase/utils.go

@@ -0,0 +1,51 @@
+package hbase
+
+import (
+	"bytes"
+	"time"
+
+	"github.com/juju/errors"
+	"github.com/pingcap/go-hbase/proto"
+)
+
+func retrySleep(retries int) {
+	time.Sleep(time.Duration(retries*500) * time.Millisecond)
+}
+
+func findKey(region *RegionInfo, key []byte) bool {
+	if region == nil {
+		return false
+	}
+	// StartKey <= key < EndKey
+	return (len(region.StartKey) == 0 || bytes.Compare(region.StartKey, key) <= 0) &&
+		(len(region.EndKey) == 0 || bytes.Compare(key, region.EndKey) < 0)
+}
+
+func NewRegionSpecifier(regionName string) *proto.RegionSpecifier {
+	return &proto.RegionSpecifier{
+		Type:  proto.RegionSpecifier_REGION_NAME.Enum(),
+		Value: []byte(regionName),
+	}
+}
+
+// TODO: The following functions can be moved later.
+// ErrorEqual returns a boolean indicating whether err1 is equal to err2.
+func ErrorEqual(err1, err2 error) bool {
+	e1 := errors.Cause(err1)
+	e2 := errors.Cause(err2)
+
+	if e1 == e2 {
+		return true
+	}
+
+	if e1 == nil || e2 == nil {
+		return e1 == e2
+	}
+
+	return e1.Error() == e2.Error()
+}
+
+// ErrorNotEqual returns a boolean indicating whether err1 isn't equal to err2.
+func ErrorNotEqual(err1, err2 error) bool {
+	return !ErrorEqual(err1, err2)
+}