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

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