mirror of https://github.com/go-gitea/gitea
Git with a cup of tea, painless self-hosted git service
Mirror for internal git.with.parts use
https://git.with.parts
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
319 lines
9.7 KiB
319 lines
9.7 KiB
// 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() {
|
|
}
|
|
|