1
0
Fork 0
mirror of https://codeberg.org/forgejo/forgejo.git synced 2024-12-23 12:59:11 -05:00
forgejo/vendor/github.com/pingcap/go-hbase/proto/ZooKeeper.pb.go
Thomas Boerger b6a95a8cb3 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
2016-11-30 00:26:36 +08:00

580 lines
17 KiB
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)
}