Ma/origin
1
0
Fork 0
mirror of https://github.com/duanhf2012/origin.git synced 2026-03-02 11:21:11 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

新增rpc被调用时可以异步返回，详情请参照originserver示例

Browse Source
This commit is contained in:
boyce
2020-11-25 17:35:04 +08:00
parent f98f39d470
commit 6b11bd91ec
18 changed files with 240 additions and 1473 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
go.mod Normal file
View File

@@ -0,0 +1,3 @@
module github.com/duanhf2012/origin
go 1.15

8
rpc/client.go
View File

@@ -178,7 +178,7 @@ func (client *Client) AsyncCall(rpcHandler IRpcHandler,serviceMethod string,call
request := &RpcRequest{} request := &RpcRequest{}
call.Seq = client.generateSeq() call.Seq = client.generateSeq()
request.RpcRequestData = processor.MakeRpcRequest(client.startSeq,serviceMethod,false,InParam,nil) request.RpcRequestData = processor.MakeRpcRequest(client.startSeq,serviceMethod,false,InParam)
client.AddPending(call) client.AddPending(call)
bytes,err := processor.Marshal(request.RpcRequestData) bytes,err := processor.Marshal(request.RpcRequestData)
@@ -204,7 +204,7 @@ func (client *Client) AsyncCall(rpcHandler IRpcHandler,serviceMethod string,call
return err return err
} }
func (client *Client) RawGo(processor IRpcProcessor,noReply bool,serviceMethod string,args []byte,additionParam interface{},reply interface{}) *Call { func (client *Client) RawGo(processor IRpcProcessor,noReply bool,serviceMethod string,args []byte,reply interface{}) *Call {
call := MakeCall() call := MakeCall()
call.ServiceMethod = serviceMethod call.ServiceMethod = serviceMethod
call.Reply = reply call.Reply = reply
@@ -214,7 +214,7 @@ func (client *Client) RawGo(processor IRpcProcessor,noReply bool,serviceMethod s
if noReply == false { if noReply == false {
client.AddPending(call) client.AddPending(call)
} }
request.RpcRequestData = processor.MakeRpcRequest(client.startSeq,serviceMethod,noReply,args,additionParam) request.RpcRequestData = processor.MakeRpcRequest(client.startSeq,serviceMethod,noReply,args)
bytes,err := processor.Marshal(request.RpcRequestData) bytes,err := processor.Marshal(request.RpcRequestData)
processor.ReleaseRpcRequest(request.RpcRequestData) processor.ReleaseRpcRequest(request.RpcRequestData)
if err != nil { if err != nil {
@@ -246,7 +246,7 @@ func (client *Client) Go(noReply bool,serviceMethod string, args interface{},rep
call.Err = err call.Err = err
} }
return client.RawGo(processor,noReply,serviceMethod,InParam,nil,reply) return client.RawGo(processor,noReply,serviceMethod,InParam,reply)
} }
func (client *Client) Run(){ func (client *Client) Run(){

12
rpc/jsonprocessor.go
View File

@@ -17,7 +17,6 @@ type JsonRpcRequestData struct {
NoReply bool //是否需要返回 NoReply bool //是否需要返回
//packbody //packbody
InParam []byte InParam []byte
AdditionParam interface{}
} }
type JsonRpcResponseData struct { type JsonRpcResponseData struct {
@@ -50,13 +49,12 @@ func (jsonProcessor *JsonProcessor) Unmarshal(data []byte, v interface{}) error{
return json.Unmarshal(data,v) return json.Unmarshal(data,v)
} }
func (jsonProcessor *JsonProcessor) MakeRpcRequest(seq uint64,serviceMethod string,noReply bool,inParam []byte,additionParam interface{}) IRpcRequestData{ func (jsonProcessor *JsonProcessor) MakeRpcRequest(seq uint64,serviceMethod string,noReply bool,inParam []byte) IRpcRequestData{
jsonRpcRequestData := rpcJsonRequestDataPool.Get().(*JsonRpcRequestData) jsonRpcRequestData := rpcJsonRequestDataPool.Get().(*JsonRpcRequestData)
jsonRpcRequestData.Seq = seq jsonRpcRequestData.Seq = seq
jsonRpcRequestData.ServiceMethod = serviceMethod jsonRpcRequestData.ServiceMethod = serviceMethod
jsonRpcRequestData.NoReply = noReply jsonRpcRequestData.NoReply = noReply
jsonRpcRequestData.InParam = inParam jsonRpcRequestData.InParam = inParam
jsonRpcRequestData.AdditionParam = additionParam
return jsonRpcRequestData return jsonRpcRequestData
} }
@@ -102,14 +100,6 @@ func (jsonRpcRequestData *JsonRpcRequestData) GetInParam() []byte{
return jsonRpcRequestData.InParam return jsonRpcRequestData.InParam
} }
func (jsonRpcRequestData *JsonRpcRequestData) GetParamValue() interface{}{
return jsonRpcRequestData.AdditionParam
}
func (jsonRpcRequestData *JsonRpcRequestData) GetAdditionParams() IRawAdditionParam{
return jsonRpcRequestData
}
func (jsonRpcResponseData *JsonRpcResponseData) GetSeq() uint64 { func (jsonRpcResponseData *JsonRpcResponseData) GetSeq() uint64 {
return jsonRpcResponseData.Seq return jsonRpcResponseData.Seq
} }

63
rpc/pbprocessor.go
View File

@@ -1,7 +1,6 @@
package rpc package rpc
import ( import (
"fmt"
"github.com/golang/protobuf/proto" "github.com/golang/protobuf/proto"
"sync" "sync"
) )
@@ -23,68 +22,12 @@ func init(){
} }
} }
func (m *PBRpcRequestData) GetParamValue() interface{}{ func (slf *PBRpcRequestData) MakeRequest(seq uint64,serviceMethod string,noReply bool,inParam []byte) *PBRpcRequestData{
if m.GetAddtionParam() == nil {
return nil
}
switch x := m.AddtionParam.AdditionOneof.(type) {
case *AdditionParam_SParam:
return x.SParam
case *AdditionParam_UParam:
return x.UParam
case *AdditionParam_StrParam:
return x.StrParam
case *AdditionParam_BParam:
return x.BParam
}
return nil
}
func (m *PBRpcRequestData) GetAdditionParams() IRawAdditionParam{
if m.GetAddtionParam() == nil {
return nil
}
return m
}
func (slf *PBRpcRequestData) MakeRequest(seq uint64,serviceMethod string,noReply bool,inParam []byte,inAdditionParam interface{}) *PBRpcRequestData{
slf.Seq = proto.Uint64(seq) slf.Seq = proto.Uint64(seq)
slf.ServiceMethod = proto.String(serviceMethod) slf.ServiceMethod = proto.String(serviceMethod)
slf.NoReply = proto.Bool(noReply) slf.NoReply = proto.Bool(noReply)
slf.InParam = inParam slf.InParam = inParam
if inAdditionParam == nil {
return slf
}
switch inAdditionParam.(type) {
case int:
slf.AddtionParam = &AdditionParam{AdditionOneof:&AdditionParam_SParam{int64(inAdditionParam.(int))}}
case int32:
slf.AddtionParam = &AdditionParam{AdditionOneof:&AdditionParam_SParam{int64(inAdditionParam.(int32))}}
case int16:
slf.AddtionParam = &AdditionParam{AdditionOneof:&AdditionParam_SParam{int64(inAdditionParam.(int16))}}
case int64:
slf.AddtionParam = &AdditionParam{AdditionOneof:&AdditionParam_SParam{inAdditionParam.(int64)}}
case uint:
slf.AddtionParam = &AdditionParam{AdditionOneof:&AdditionParam_UParam{uint64(inAdditionParam.(uint))}}
case uint32:
slf.AddtionParam = &AdditionParam{AdditionOneof:&AdditionParam_UParam{uint64(inAdditionParam.(uint32))}}
case uint16:
slf.AddtionParam = &AdditionParam{AdditionOneof:&AdditionParam_UParam{uint64(inAdditionParam.(uint16))}}
case uint64:
slf.AddtionParam = &AdditionParam{AdditionOneof:&AdditionParam_UParam{inAdditionParam.(uint64)}}
case string:
slf.AddtionParam = &AdditionParam{AdditionOneof:&AdditionParam_StrParam{inAdditionParam.(string)}}
case []byte:
slf.AddtionParam = &AdditionParam{AdditionOneof: &AdditionParam_BParam{inAdditionParam.([]byte)}}
default:
panic(fmt.Sprintf("not support type %+v",inAdditionParam))
}
return slf return slf
} }
@@ -105,9 +48,9 @@ func (slf *PBProcessor) Unmarshal(data []byte, msg interface{}) error{
return proto.Unmarshal(data, protoMsg) return proto.Unmarshal(data, protoMsg)
} }
func (slf *PBProcessor) MakeRpcRequest(seq uint64,serviceMethod string,noReply bool,inParam []byte,inAdditionParam interface{}) IRpcRequestData{ func (slf *PBProcessor) MakeRpcRequest(seq uint64,serviceMethod string,noReply bool,inParam []byte) IRpcRequestData{
pPbRpcRequestData := rpcPbRequestDataPool.Get().(*PBRpcRequestData) pPbRpcRequestData := rpcPbRequestDataPool.Get().(*PBRpcRequestData)
pPbRpcRequestData.MakeRequest(seq,serviceMethod,noReply,inParam,inAdditionParam) pPbRpcRequestData.MakeRequest(seq,serviceMethod,noReply,inParam)
return pPbRpcRequestData return pPbRpcRequestData
} }

2
rpc/processor.go
View File

@@ -3,7 +3,7 @@ package rpc
type IRpcProcessor interface { type IRpcProcessor interface {
Marshal(v interface{}) ([]byte, error) //b表示自定义缓冲区，可以填nil，由系统自动分配 Marshal(v interface{}) ([]byte, error) //b表示自定义缓冲区，可以填nil，由系统自动分配
Unmarshal(data []byte, v interface{}) error Unmarshal(data []byte, v interface{}) error
MakeRpcRequest(seq uint64,serviceMethod string,noReply bool,inParam []byte,additionParam interface{}) IRpcRequestData MakeRpcRequest(seq uint64,serviceMethod string,noReply bool,inParam []byte) IRpcRequestData
MakeRpcResponse(seq uint64,err RpcError,reply []byte) IRpcResponseData MakeRpcResponse(seq uint64,err RpcError,reply []byte) IRpcResponseData
ReleaseRpcRequest(rpcRequestData IRpcRequestData) ReleaseRpcRequest(rpcRequestData IRpcRequestData)

12
rpc/rpc.go
View File

@@ -23,20 +23,18 @@ type RpcResponse struct {
RpcResponseData IRpcResponseData RpcResponseData IRpcResponseData
} }
type Responder = RequestHandler
//var rpcResponsePool sync.Pool //var rpcResponsePool sync.Pool
var rpcRequestPool sync.Pool var rpcRequestPool sync.Pool
var rpcCallPool sync.Pool var rpcCallPool sync.Pool
type IRawAdditionParam interface {
GetParamValue() interface{}
}
type IRpcRequestData interface { type IRpcRequestData interface {
GetSeq() uint64 GetSeq() uint64
GetServiceMethod() string GetServiceMethod() string
GetInParam() []byte GetInParam() []byte
IsNoReply() bool IsNoReply() bool
GetAdditionParams() IRawAdditionParam
} }
type IRpcResponseData interface { type IRpcResponseData interface {
@@ -47,7 +45,6 @@ type IRpcResponseData interface {
type IRawInputArgs interface { type IRawInputArgs interface {
GetRawData() []byte //获取原始数据 GetRawData() []byte //获取原始数据
GetAdditionParam() interface{} //获取附加数据
DoGc() //处理完成,回收内存 DoGc() //处理完成,回收内存
} }
@@ -56,8 +53,6 @@ type RpcHandleFinder interface {
} }
type RequestHandler func(Returns interface{},Err RpcError) type RequestHandler func(Returns interface{},Err RpcError)
type RawAdditionParamNull struct {
}
type Call struct { type Call struct {
Seq uint64 Seq uint64
@@ -135,6 +130,3 @@ func ReleaseCall(call *Call){
rpcCallPool.Put(call) rpcCallPool.Put(call)
} }
func (slf *RawAdditionParamNull) GetParamValue() interface{}{
return nil
}

514
rpc/rpc.pb.go
View File

@@ -1,371 +1,253 @@
// Code generated by protoc-gen-go. DO NOT EDIT. // Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.23.0
// protoc (unknown)
// source: rpc.proto // source: rpc.proto
package rpc package rpc
import ( import (
fmt "fmt"
proto "github.com/golang/protobuf/proto" proto "github.com/golang/protobuf/proto"
math "math" protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
) )
// Reference imports to suppress errors if they are not otherwise used. const (
var _ = proto.Marshal // Verify that this generated code is sufficiently up-to-date.
var _ = fmt.Errorf _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
var _ = math.Inf // Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
// This is a compile-time assertion to ensure that this generated file // This is a compile-time assertion that a sufficiently up-to-date version
// is compatible with the proto package it is being compiled against. // of the legacy proto package is being used.
// A compilation error at this line likely means your copy of the const _ = proto.ProtoPackageIsVersion4
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type AdditionParam struct {
// Types that are valid to be assigned to AdditionOneof:
// *AdditionParam_SParam
// *AdditionParam_UParam
// *AdditionParam_StrParam
// *AdditionParam_BParam
AdditionOneof isAdditionParam_AdditionOneof `protobuf_oneof:"addition_oneof"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *AdditionParam) Reset() { *m = AdditionParam{} }
func (m *AdditionParam) String() string { return proto.CompactTextString(m) }
func (*AdditionParam) ProtoMessage() {}
func (*AdditionParam) Descriptor() ([]byte, []int) {
return fileDescriptor_77a6da22d6a3feb1, []int{0}
}
func (m *AdditionParam) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_AdditionParam.Unmarshal(m, b)
}
func (m *AdditionParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_AdditionParam.Marshal(b, m, deterministic)
}
func (m *AdditionParam) XXX_Merge(src proto.Message) {
xxx_messageInfo_AdditionParam.Merge(m, src)
}
func (m *AdditionParam) XXX_Size() int {
return xxx_messageInfo_AdditionParam.Size(m)
}
func (m *AdditionParam) XXX_DiscardUnknown() {
xxx_messageInfo_AdditionParam.DiscardUnknown(m)
}
var xxx_messageInfo_AdditionParam proto.InternalMessageInfo
type isAdditionParam_AdditionOneof interface {
isAdditionParam_AdditionOneof()
}
type AdditionParam_SParam struct {
SParam int64 `protobuf:"varint,10,opt,name=SParam,oneof"`
}
type AdditionParam_UParam struct {
UParam uint64 `protobuf:"varint,11,opt,name=UParam,oneof"`
}
type AdditionParam_StrParam struct {
StrParam string `protobuf:"bytes,12,opt,name=StrParam,oneof"`
}
type AdditionParam_BParam struct {
BParam []byte `protobuf:"bytes,13,opt,name=BParam,oneof"`
}
func (*AdditionParam_SParam) isAdditionParam_AdditionOneof() {}
func (*AdditionParam_UParam) isAdditionParam_AdditionOneof() {}
func (*AdditionParam_StrParam) isAdditionParam_AdditionOneof() {}
func (*AdditionParam_BParam) isAdditionParam_AdditionOneof() {}
func (m *AdditionParam) GetAdditionOneof() isAdditionParam_AdditionOneof {
if m != nil {
return m.AdditionOneof
}
return nil
}
func (m *AdditionParam) GetSParam() int64 {
if x, ok := m.GetAdditionOneof().(*AdditionParam_SParam); ok {
return x.SParam
}
return 0
}
func (m *AdditionParam) GetUParam() uint64 {
if x, ok := m.GetAdditionOneof().(*AdditionParam_UParam); ok {
return x.UParam
}
return 0
}
func (m *AdditionParam) GetStrParam() string {
if x, ok := m.GetAdditionOneof().(*AdditionParam_StrParam); ok {
return x.StrParam
}
return ""
}
func (m *AdditionParam) GetBParam() []byte {
if x, ok := m.GetAdditionOneof().(*AdditionParam_BParam); ok {
return x.BParam
}
return nil
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*AdditionParam) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _AdditionParam_OneofMarshaler, _AdditionParam_OneofUnmarshaler, _AdditionParam_OneofSizer, []interface{}{
(*AdditionParam_SParam)(nil),
(*AdditionParam_UParam)(nil),
(*AdditionParam_StrParam)(nil),
(*AdditionParam_BParam)(nil),
}
}
func _AdditionParam_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*AdditionParam)
// addition_oneof
switch x := m.AdditionOneof.(type) {
case *AdditionParam_SParam:
b.EncodeVarint(10<<3 | proto.WireVarint)
b.EncodeVarint(uint64(x.SParam))
case *AdditionParam_UParam:
b.EncodeVarint(11<<3 | proto.WireVarint)
b.EncodeVarint(uint64(x.UParam))
case *AdditionParam_StrParam:
b.EncodeVarint(12<<3 | proto.WireBytes)
b.EncodeStringBytes(x.StrParam)
case *AdditionParam_BParam:
b.EncodeVarint(13<<3 | proto.WireBytes)
b.EncodeRawBytes(x.BParam)
case nil:
default:
return fmt.Errorf("AdditionParam.AdditionOneof has unexpected type %T", x)
}
return nil
}
func _AdditionParam_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*AdditionParam)
switch tag {
case 10: // addition_oneof.SParam
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.AdditionOneof = &AdditionParam_SParam{int64(x)}
return true, err
case 11: // addition_oneof.UParam
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.AdditionOneof = &AdditionParam_UParam{x}
return true, err
case 12: // addition_oneof.StrParam
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.AdditionOneof = &AdditionParam_StrParam{x}
return true, err
case 13: // addition_oneof.BParam
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeRawBytes(true)
m.AdditionOneof = &AdditionParam_BParam{x}
return true, err
default:
return false, nil
}
}
func _AdditionParam_OneofSizer(msg proto.Message) (n int) {
m := msg.(*AdditionParam)
// addition_oneof
switch x := m.AdditionOneof.(type) {
case *AdditionParam_SParam:
n += 1 // tag and wire
n += proto.SizeVarint(uint64(x.SParam))
case *AdditionParam_UParam:
n += 1 // tag and wire
n += proto.SizeVarint(uint64(x.UParam))
case *AdditionParam_StrParam:
n += 1 // tag and wire
n += proto.SizeVarint(uint64(len(x.StrParam)))
n += len(x.StrParam)
case *AdditionParam_BParam:
n += 1 // tag and wire
n += proto.SizeVarint(uint64(len(x.BParam)))
n += len(x.BParam)
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
type PBRpcRequestData struct { type PBRpcRequestData struct {
Seq *uint64 `protobuf:"varint,1,opt,name=Seq" json:"Seq,omitempty"` state protoimpl.MessageState
ServiceMethod *string `protobuf:"bytes,2,opt,name=ServiceMethod" json:"ServiceMethod,omitempty"` sizeCache protoimpl.SizeCache
NoReply *bool `protobuf:"varint,3,opt,name=NoReply" json:"NoReply,omitempty"` unknownFields protoimpl.UnknownFields
InParam []byte `protobuf:"bytes,4,opt,name=InParam" json:"InParam,omitempty"`
AddtionParam *AdditionParam `protobuf:"bytes,5,opt,name=addtionParam" json:"addtionParam,omitempty"` Seq *uint64 `protobuf:"varint,1,opt,name=Seq" json:"Seq,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"` ServiceMethod *string `protobuf:"bytes,2,opt,name=ServiceMethod" json:"ServiceMethod,omitempty"`
XXX_unrecognized []byte `json:"-"` NoReply *bool `protobuf:"varint,3,opt,name=NoReply" json:"NoReply,omitempty"`
XXX_sizecache int32 `json:"-"` InParam []byte `protobuf:"bytes,4,opt,name=InParam" json:"InParam,omitempty"`
} }
func (m *PBRpcRequestData) Reset() { *m = PBRpcRequestData{} } func (x *PBRpcRequestData) Reset() {
func (m *PBRpcRequestData) String() string { return proto.CompactTextString(m) } *x = PBRpcRequestData{}
func (*PBRpcRequestData) ProtoMessage() {} if protoimpl.UnsafeEnabled {
mi := &file_rpc_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *PBRpcRequestData) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*PBRpcRequestData) ProtoMessage() {}
func (x *PBRpcRequestData) ProtoReflect() protoreflect.Message {
mi := &file_rpc_proto_msgTypes[0]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use PBRpcRequestData.ProtoReflect.Descriptor instead.
func (*PBRpcRequestData) Descriptor() ([]byte, []int) { func (*PBRpcRequestData) Descriptor() ([]byte, []int) {
return fileDescriptor_77a6da22d6a3feb1, []int{1} return file_rpc_proto_rawDescGZIP(), []int{0}
} }
func (m *PBRpcRequestData) XXX_Unmarshal(b []byte) error { func (x *PBRpcRequestData) GetSeq() uint64 {
return xxx_messageInfo_PBRpcRequestData.Unmarshal(m, b) if x != nil && x.Seq != nil {
} return *x.Seq
func (m *PBRpcRequestData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_PBRpcRequestData.Marshal(b, m, deterministic)
}
func (m *PBRpcRequestData) XXX_Merge(src proto.Message) {
xxx_messageInfo_PBRpcRequestData.Merge(m, src)
}
func (m *PBRpcRequestData) XXX_Size() int {
return xxx_messageInfo_PBRpcRequestData.Size(m)
}
func (m *PBRpcRequestData) XXX_DiscardUnknown() {
xxx_messageInfo_PBRpcRequestData.DiscardUnknown(m)
}
var xxx_messageInfo_PBRpcRequestData proto.InternalMessageInfo
func (m *PBRpcRequestData) GetSeq() uint64 {
if m != nil && m.Seq != nil {
return *m.Seq
} }
return 0 return 0
} }
func (m *PBRpcRequestData) GetServiceMethod() string { func (x *PBRpcRequestData) GetServiceMethod() string {
if m != nil && m.ServiceMethod != nil { if x != nil && x.ServiceMethod != nil {
return *m.ServiceMethod return *x.ServiceMethod
} }
return "" return ""
} }
func (m *PBRpcRequestData) GetNoReply() bool { func (x *PBRpcRequestData) GetNoReply() bool {
if m != nil && m.NoReply != nil { if x != nil && x.NoReply != nil {
return *m.NoReply return *x.NoReply
} }
return false return false
} }
func (m *PBRpcRequestData) GetInParam() []byte { func (x *PBRpcRequestData) GetInParam() []byte {
if m != nil { if x != nil {
return m.InParam return x.InParam
}
return nil
}
func (m *PBRpcRequestData) GetAddtionParam() *AdditionParam {
if m != nil {
return m.AddtionParam
} }
return nil return nil
} }
type PBRpcResponseData struct { type PBRpcResponseData struct {
Seq *uint64 `protobuf:"varint,1,opt,name=Seq" json:"Seq,omitempty"` state protoimpl.MessageState
Error *string `protobuf:"bytes,2,opt,name=Error" json:"Error,omitempty"` sizeCache protoimpl.SizeCache
Reply []byte `protobuf:"bytes,3,opt,name=Reply" json:"Reply,omitempty"` unknownFields protoimpl.UnknownFields
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"` Seq *uint64 `protobuf:"varint,1,opt,name=Seq" json:"Seq,omitempty"`
XXX_sizecache int32 `json:"-"` Error *string `protobuf:"bytes,2,opt,name=Error" json:"Error,omitempty"`
Reply []byte `protobuf:"bytes,3,opt,name=Reply" json:"Reply,omitempty"`
} }
func (m *PBRpcResponseData) Reset() { *m = PBRpcResponseData{} } func (x *PBRpcResponseData) Reset() {
func (m *PBRpcResponseData) String() string { return proto.CompactTextString(m) } *x = PBRpcResponseData{}
func (*PBRpcResponseData) ProtoMessage() {} if protoimpl.UnsafeEnabled {
mi := &file_rpc_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *PBRpcResponseData) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*PBRpcResponseData) ProtoMessage() {}
func (x *PBRpcResponseData) ProtoReflect() protoreflect.Message {
mi := &file_rpc_proto_msgTypes[1]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use PBRpcResponseData.ProtoReflect.Descriptor instead.
func (*PBRpcResponseData) Descriptor() ([]byte, []int) { func (*PBRpcResponseData) Descriptor() ([]byte, []int) {
return fileDescriptor_77a6da22d6a3feb1, []int{2} return file_rpc_proto_rawDescGZIP(), []int{1}
} }
func (m *PBRpcResponseData) XXX_Unmarshal(b []byte) error { func (x *PBRpcResponseData) GetSeq() uint64 {
return xxx_messageInfo_PBRpcResponseData.Unmarshal(m, b) if x != nil && x.Seq != nil {
} return *x.Seq
func (m *PBRpcResponseData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_PBRpcResponseData.Marshal(b, m, deterministic)
}
func (m *PBRpcResponseData) XXX_Merge(src proto.Message) {
xxx_messageInfo_PBRpcResponseData.Merge(m, src)
}
func (m *PBRpcResponseData) XXX_Size() int {
return xxx_messageInfo_PBRpcResponseData.Size(m)
}
func (m *PBRpcResponseData) XXX_DiscardUnknown() {
xxx_messageInfo_PBRpcResponseData.DiscardUnknown(m)
}
var xxx_messageInfo_PBRpcResponseData proto.InternalMessageInfo
func (m *PBRpcResponseData) GetSeq() uint64 {
if m != nil && m.Seq != nil {
return *m.Seq
} }
return 0 return 0
} }
func (m *PBRpcResponseData) GetError() string { func (x *PBRpcResponseData) GetError() string {
if m != nil && m.Error != nil { if x != nil && x.Error != nil {
return *m.Error return *x.Error
} }
return "" return ""
} }
func (m *PBRpcResponseData) GetReply() []byte { func (x *PBRpcResponseData) GetReply() []byte {
if m != nil { if x != nil {
return m.Reply return x.Reply
} }
return nil return nil
} }
func init() { var File_rpc_proto protoreflect.FileDescriptor
proto.RegisterType((*AdditionParam)(nil), "rpc.AdditionParam")
proto.RegisterType((*PBRpcRequestData)(nil), "rpc.PBRpcRequestData") var file_rpc_proto_rawDesc = []byte{
proto.RegisterType((*PBRpcResponseData)(nil), "rpc.PBRpcResponseData") 0x0a, 0x09, 0x72, 0x70, 0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x03, 0x72, 0x70, 0x63,
0x22, 0x58, 0x0a, 0x10, 0x50, 0x42, 0x52, 0x70, 0x63, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
0x44, 0x61, 0x74, 0x61, 0x12, 0x0b, 0x0a, 0x03, 0x53, 0x65, 0x71, 0x18, 0x01, 0x20, 0x01, 0x28,
0x04, 0x12, 0x15, 0x0a, 0x0d, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x4d, 0x65, 0x74, 0x68,
0x6f, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x12, 0x0f, 0x0a, 0x07, 0x4e, 0x6f, 0x52, 0x65,
0x70, 0x6c, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x12, 0x0f, 0x0a, 0x07, 0x49, 0x6e, 0x50,
0x61, 0x72, 0x61, 0x6d, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x22, 0x3e, 0x0a, 0x11, 0x50, 0x42,
0x52, 0x70, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x44, 0x61, 0x74, 0x61, 0x12,
0x0b, 0x0a, 0x03, 0x53, 0x65, 0x71, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x12, 0x0d, 0x0a, 0x05,
0x45, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x12, 0x0d, 0x0a, 0x05, 0x52,
0x65, 0x70, 0x6c, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x07, 0x5a, 0x05, 0x2e, 0x3b,
0x72, 0x70, 0x63,
} }
func init() { proto.RegisterFile("rpc.proto", fileDescriptor_77a6da22d6a3feb1) } var (
file_rpc_proto_rawDescOnce sync.Once
file_rpc_proto_rawDescData = file_rpc_proto_rawDesc
)
var fileDescriptor_77a6da22d6a3feb1 = []byte{ func file_rpc_proto_rawDescGZIP() []byte {
// 274 bytes of a gzipped FileDescriptorProto file_rpc_proto_rawDescOnce.Do(func() {
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x90, 0xb1, 0x4e, 0xc3, 0x30, file_rpc_proto_rawDescData = protoimpl.X.CompressGZIP(file_rpc_proto_rawDescData)
0x10, 0x86, 0x6b, 0xd2, 0x42, 0x7b, 0x4d, 0x50, 0xb0, 0x18, 0x3c, 0x30, 0x58, 0x11, 0x83, 0xa7, })
0x0e, 0x0c, 0xec, 0x44, 0x20, 0x95, 0x01, 0x54, 0x2e, 0x62, 0x46, 0x56, 0x62, 0x44, 0x24, 0x88, return file_rpc_proto_rawDescData
0x5d, 0xc7, 0x20, 0xf1, 0x10, 0xbc, 0x0e, 0xcf, 0x87, 0x0e, 0xa7, 0x45, 0x19, 0xd8, 0xee, 0xbb, }
0xcf, 0xa7, 0xfb, 0x7d, 0xb0, 0xf0, 0xae, 0x5e, 0x39, 0x6f, 0x83, 0xe5, 0x89, 0x77, 0x75, 0xf1,
0xc5, 0x20, 0xbb, 0x6a, 0x9a, 0x36, 0xb4, 0xb6, 0xdb, 0x68, 0xaf, 0xdf, 0xb8, 0x80, 0xc3, 0xea, var file_rpc_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
0xb7, 0x12, 0x20, 0x99, 0x4a, 0xd6, 0x13, 0x1c, 0x98, 0xcc, 0x63, 0x34, 0x4b, 0xc9, 0xd4, 0x94, var file_rpc_proto_goTypes = []interface{}{
0x4c, 0x64, 0x7e, 0x06, 0xf3, 0x2a, 0xf8, 0xe8, 0x52, 0xc9, 0xd4, 0x62, 0x3d, 0xc1, 0x7d, 0x87, (*PBRpcRequestData)(nil), // 0: rpc.PBRpcRequestData
0xe6, 0xca, 0xe8, 0x32, 0xc9, 0x54, 0x4a, 0x73, 0x91, 0xcb, 0x1c, 0x8e, 0xf5, 0xb0, 0xfc, 0xc9, (*PBRpcResponseData)(nil), // 1: rpc.PBRpcResponseData
0x76, 0xc6, 0x3e, 0x17, 0xdf, 0x0c, 0xf2, 0x4d, 0x89, 0xae, 0x46, 0xb3, 0x7d, 0x37, 0x7d, 0xb8, }
0xd6, 0x41, 0xf3, 0x1c, 0x92, 0xca, 0x6c, 0x05, 0xa3, 0xad, 0x48, 0x25, 0x3f, 0x87, 0xac, 0x32, var file_rpc_proto_depIdxs = []int32{
0xfe, 0xa3, 0xad, 0xcd, 0x9d, 0x09, 0x2f, 0xb6, 0x11, 0x07, 0xb4, 0x15, 0xc7, 0x4d, 0x2e, 0xe0, 0, // [0:0] is the sub-list for method output_type
0xe8, 0xde, 0xa2, 0x71, 0xaf, 0x9f, 0x22, 0x91, 0x4c, 0xcd, 0x71, 0x87, 0x64, 0x6e, 0xe3, 0x7f, 0, // [0:0] is the sub-list for method input_type
0xc5, 0x94, 0x32, 0xe1, 0x0e, 0xf9, 0x25, 0xa4, 0xba, 0x69, 0xf6, 0xe7, 0x10, 0x33, 0xc9, 0xd4, 0, // [0:0] is the sub-list for extension type_name
0xf2, 0x82, 0xaf, 0xe8, 0x6e, 0xa3, 0x43, 0xe1, 0xe8, 0x5d, 0xf1, 0x00, 0x27, 0x43, 0xee, 0xde, 0, // [0:0] is the sub-list for extension extendee
0xd9, 0xae, 0x37, 0xff, 0x04, 0x3f, 0x85, 0xd9, 0x8d, 0xf7, 0xd6, 0x0f, 0x81, 0x23, 0x50, 0xf7, 0, // [0:0] is the sub-list for field type_name
0x2f, 0x66, 0x8a, 0x11, 0x7e, 0x02, 0x00, 0x00, 0xff, 0xff, 0x00, 0x25, 0x65, 0x17, 0xac, 0x01, }
0x00, 0x00,
func init() { file_rpc_proto_init() }
func file_rpc_proto_init() {
if File_rpc_proto != nil {
return
}
if !protoimpl.UnsafeEnabled {
file_rpc_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*PBRpcRequestData); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_rpc_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*PBRpcResponseData); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_rpc_proto_rawDesc,
NumEnums: 0,
NumMessages: 2,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_rpc_proto_goTypes,
DependencyIndexes: file_rpc_proto_depIdxs,
MessageInfos: file_rpc_proto_msgTypes,
}.Build()
File_rpc_proto = out.File
file_rpc_proto_rawDesc = nil
file_rpc_proto_goTypes = nil
file_rpc_proto_depIdxs = nil
} }

15
rpc/rpc.proto
View File

@@ -1,24 +1,11 @@
syntax = "proto2"; syntax = "proto2";
package rpc; package rpc;
option go_package =".;rpc";
message AdditionParam {
oneof addition_oneof {
int64 SParam = 10;
uint64 UParam = 11;
string StrParam = 12;
bytes BParam = 13;
}
}
message PBRpcRequestData{ message PBRpcRequestData{
optional uint64 Seq = 1; optional uint64 Seq = 1;
optional string ServiceMethod = 2; optional string ServiceMethod = 2;
optional bool NoReply = 3; optional bool NoReply = 3;
optional bytes InParam = 4; optional bytes InParam = 4;
optional AdditionParam addtionParam = 5;
} }
message PBRpcResponseData{ message PBRpcResponseData{

46
rpc/rpchandler.go
View File

@@ -13,17 +13,17 @@ import (
const maxClusterNode int = 128 const maxClusterNode int = 128
type FuncRpcClient func(nodeId int,serviceMethod string,client []*Client) (error,int) type FuncRpcClient func(nodeId int,serviceMethod string,client []*Client) (error,int)
type FuncRpcServer func() (*Server) type FuncRpcServer func() (*Server)
var NilError = reflect.Zero(reflect.TypeOf((*error)(nil)).Elem()) var nilError = reflect.Zero(reflect.TypeOf((*error)(nil)).Elem())
type RpcError string type RpcError string
var noError RpcError var NilError RpcError
func (e RpcError) Error() string { func (e RpcError) Error() string {
return string(e) return string(e)
} }
func ConvertError(e error) RpcError{ func ConvertError(e error) RpcError{
if e == nil { if e == nil {
return noError return NilError
} }
rpcErr := RpcError(e.Error()) rpcErr := RpcError(e.Error())
@@ -41,8 +41,7 @@ type RpcMethodInfo struct {
inParamValue reflect.Value inParamValue reflect.Value
inParam interface{} inParam interface{}
outParamValue reflect.Value outParamValue reflect.Value
additionParam reflect.Value hasResponder bool
hasAdditionParam bool
rpcProcessorType RpcProcessorType rpcProcessorType RpcProcessorType
} }
@@ -78,10 +77,14 @@ type IRpcHandler interface {
IsSingleCoroutine() bool IsSingleCoroutine() bool
} }
var rawAdditionParamValueNull reflect.Value func reqHandlerNull(Returns interface{},Err RpcError) {
func init(){
rawAdditionParamValueNull = reflect.ValueOf(&RawAdditionParamNull{})
} }
var requestHandlerNull reflect.Value
func init(){
requestHandlerNull = reflect.ValueOf(reqHandlerNull)
}
func (handler *RpcHandler) GetRpcHandler() IRpcHandler{ func (handler *RpcHandler) GetRpcHandler() IRpcHandler{
return handler.rpcHandler return handler.rpcHandler
} }
@@ -137,9 +140,9 @@ func (handler *RpcHandler) suitableMethods(method reflect.Method) error {
//1.判断第一个参数 //1.判断第一个参数
var parIdx int = 1 var parIdx int = 1
if typ.In(parIdx).String() == "rpc.IRawAdditionParam" { if typ.In(parIdx).String() == "rpc.RequestHandler" {
parIdx += 1 parIdx += 1
rpcMethodInfo.hasAdditionParam = true rpcMethodInfo.hasResponder = true
} }
for i:= parIdx ;i<typ.NumIn();i++{ for i:= parIdx ;i<typ.NumIn();i++{
@@ -208,7 +211,7 @@ func (handler *RpcHandler) HandlerRpcResponseCB(call *Call){
}() }()
if call.Err == nil { if call.Err == nil {
call.callback.Call([]reflect.Value{reflect.ValueOf(call.Reply),NilError}) call.callback.Call([]reflect.Value{reflect.ValueOf(call.Reply),nilError})
}else{ }else{
call.callback.Call([]reflect.Value{reflect.ValueOf(call.Reply),reflect.ValueOf(call.Err)}) call.callback.Call([]reflect.Value{reflect.ValueOf(call.Reply),reflect.ValueOf(call.Err)})
} }
@@ -287,13 +290,12 @@ func (handler *RpcHandler) HandlerRpcRequest(request *RpcRequest) {
} }
paramList = append(paramList,reflect.ValueOf(handler.GetRpcHandler())) //接受者 paramList = append(paramList,reflect.ValueOf(handler.GetRpcHandler())) //接受者
additionParams := request.RpcRequestData.GetAdditionParams() if v.hasResponder == true {
if v.hasAdditionParam == true{ if request.requestHandle!=nil {
if additionParams!=nil && additionParams.GetParamValue()!=nil{ responder := reflect.ValueOf(request.requestHandle)
additionVal := reflect.ValueOf(additionParams) paramList = append(paramList,responder)
paramList = append(paramList,additionVal)
}else{ }else{
paramList = append(paramList,rawAdditionParamValueNull) paramList = append(paramList,requestHandlerNull)
} }
} }
@@ -308,8 +310,8 @@ func (handler *RpcHandler) HandlerRpcRequest(request *RpcRequest) {
oParam = reflect.New(v.outParamValue.Type().Elem()) oParam = reflect.New(v.outParamValue.Type().Elem())
} }
paramList = append(paramList,oParam) //输出参数 paramList = append(paramList,oParam) //输出参数
}else if request.requestHandle != nil { //调用方有返回值，但被调用函数没有返回参数 }else if request.requestHandle != nil && v.hasResponder==false{ //调用方有返回值，但被调用函数没有返回参数
rErr := "Call Rpc "+request.RpcRequestData.GetServiceMethod()+"without return parameter!" rErr := "Call Rpc "+request.RpcRequestData.GetServiceMethod()+" without return parameter!"
log.Error(rErr) log.Error(rErr)
request.requestHandle(nil, RpcError(rErr)) request.requestHandle(nil, RpcError(rErr))
return return
@@ -320,7 +322,7 @@ func (handler *RpcHandler) HandlerRpcRequest(request *RpcRequest) {
err = errInter.(error) err = errInter.(error)
} }
if request.requestHandle!=nil { if request.requestHandle!=nil && v.hasResponder==false {
request.requestHandle(oParam.Interface(), ConvertError(err)) request.requestHandle(oParam.Interface(), ConvertError(err))
} }
} }
@@ -503,7 +505,7 @@ func (handler *RpcHandler) asyncCallRpc(nodeid int,serviceMethod string,args int
if serviceName == handler.rpcHandler.GetName() { //自己服务调用 if serviceName == handler.rpcHandler.GetName() { //自己服务调用
err := pLocalRpcServer.myselfRpcHandlerGo(serviceName,serviceMethod,args,reply) err := pLocalRpcServer.myselfRpcHandlerGo(serviceName,serviceMethod,args,reply)
if err == nil { if err == nil {
fVal.Call([]reflect.Value{reflect.ValueOf(reply),NilError}) fVal.Call([]reflect.Value{reflect.ValueOf(reply),nilError})
}else{ }else{
fVal.Call([]reflect.Value{reflect.ValueOf(reply),reflect.ValueOf(err)}) fVal.Call([]reflect.Value{reflect.ValueOf(reply),reflect.ValueOf(err)})
} }
@@ -618,7 +620,7 @@ func (handler *RpcHandler) RawGoNode(rpcProcessorType RpcProcessorType,nodeId in
} }
//跨node调用 //跨node调用
pCall := pClientList[i].RawGo(processor,true,serviceMethod,args.GetRawData(),args.GetAdditionParam(),nil) pCall := pClientList[i].RawGo(processor,true,serviceMethod,args.GetRawData(),nil)
args.DoGc() args.DoGc()
if pCall.Err!=nil { if pCall.Err!=nil {
err = pCall.Err err = pCall.Err

10
rpc/server.go
View File

@@ -129,7 +129,7 @@ func (agent *RpcAgent) Run() {
//解析head //解析head
req := MakeRpcRequest() req := MakeRpcRequest()
req.rpcProcessor = processor req.rpcProcessor = processor
req.RpcRequestData = processor.MakeRpcRequest(0,"",false,nil,nil) req.RpcRequestData = processor.MakeRpcRequest(0,"",false,nil)
err = processor.Unmarshal(data[1:],req.RpcRequestData) err = processor.Unmarshal(data[1:],req.RpcRequestData)
agent.conn.ReleaseReadMsg(data) agent.conn.ReleaseReadMsg(data)
if err != nil { if err != nil {
@@ -252,12 +252,8 @@ func (server *Server) selfNodeRpcHandlerGo(processor IRpcProcessor,client *Clien
if processor == nil { if processor == nil {
_,processor = GetProcessorType(args) _,processor = GetProcessorType(args)
} }
var additionParam interface{}
if inputArgs!=nil {
additionParam = inputArgs.GetAdditionParam()
}
req.RpcRequestData = processor.MakeRpcRequest(0, serviceMethod,noReply,nil,additionParam) req.RpcRequestData = processor.MakeRpcRequest(0, serviceMethod,noReply,nil)
req.rpcProcessor = processor req.rpcProcessor = processor
if noReply == false { if noReply == false {
client.AddPending(pCall) client.AddPending(pCall)
@@ -308,7 +304,7 @@ func (server *Server) selfNodeRpcHandlerAsyncGo(client *Client,callerRpcHandler
req.bLocalRequest = true req.bLocalRequest = true
_,processor := GetProcessorType(args) _,processor := GetProcessorType(args)
req.rpcProcessor =processor req.rpcProcessor =processor
req.RpcRequestData = processor.MakeRpcRequest(0,serviceMethod,noReply,nil,nil) req.RpcRequestData = processor.MakeRpcRequest(0,serviceMethod,noReply,nil)
if noReply == false { if noReply == false {
client.AddPending(pCall) client.AddPending(pCall)
req.requestHandle = func(Returns interface{},Err RpcError){ req.requestHandle = func(Returns interface{},Err RpcError){

73
sysservice/tcpgateway/GateProxyModule.go
View File

@@ -1,73 +0,0 @@
package tcpgateway
import (
"fmt"
"github.com/duanhf2012/origin/service"
"github.com/duanhf2012/origin/sysservice/tcpservice"
"github.com/golang/protobuf/proto"
)
type GateProxyModule struct{
service.Module
defaultGateRpc string
}
func NewGateProxyModule() *GateProxyModule{
return &GateProxyModule{defaultGateRpc:"TcpGateService.RPC_Dispatch"}
}
func (gate *GateProxyModule) Send(clientId interface{},msgType uint16,msg proto.Message) error {
//对agentId进行分组
mapNodeClientId := map[int][]uint64{}
switch clientId.(type) {
case uint64:
id := clientId.(uint64)
nodeId := tcpservice.GetNodeId(id)
mapNodeClientId[nodeId] = append(mapNodeClientId[nodeId],id)
case []uint64:
idList := clientId.([]uint64)
for _,id := range idList{
nodeId := tcpservice.GetNodeId(id)
mapNodeClientId[nodeId] = append(mapNodeClientId[nodeId],id)
}
}
bData,err := proto.Marshal(msg)
if err!=nil {
return err
}
var replyMsg ReplyMessage
replyMsg.MsgType = proto.Uint32(uint32(msgType))
replyMsg.Msg = bData
for nodeId,clientIdList := range mapNodeClientId {
if nodeId <0 || nodeId>tcpservice.MaxNodeId {
fmt.Errorf("nodeid is error %d",nodeId)
continue
}
replyMsg.ClientList = clientIdList
gate.GetService().GetRpcHandler().GoNode(nodeId,gate.defaultGateRpc,&replyMsg)
}
return nil
}
func (gate *GateProxyModule) SetDefaultGateRpcMethodName(rpcMethodName string){
gate.defaultGateRpc = rpcMethodName
}
func (gate *GateProxyModule) send(clientId uint64,msgType uint16,msg []byte) error {
nodeId := tcpservice.GetNodeId(clientId)
if nodeId <0 || nodeId>tcpservice.MaxNodeId {
return fmt.Errorf("nodeid is error %d",nodeId)
}
var replyMsg ReplyMessage
replyMsg.MsgType = proto.Uint32(uint32(msgType))
replyMsg.Msg = msg
replyMsg.ClientList = append(replyMsg.ClientList ,clientId)
return gate.GetService().GetRpcHandler().GoNode(nodeId, gate.defaultGateRpc,&replyMsg)
}

5
sysservice/tcpgateway/ILoadBalance.go
View File

@@ -1,5 +0,0 @@
package tcpgateway
type ILoadBalance interface {
SelectNode(serviceName string,clientId uint64,eventType string,msgType uint16,msg []byte) int //选择一个结点，通过服务名称
}

11
sysservice/tcpgateway/IRouter.go
View File

@@ -1,11 +0,0 @@
package tcpgateway
type IRouter interface {
RouterMessage(clientId uint64,msgType uint16,msg []byte) //消息转发
RouterEvent(clientId uint64,eventType string) bool//消息转发
Load() //加载路由规则
OnDisconnected(clientId uint64)
OnConnected(clientId uint64)
//ReplyMessage(clientId uint64,msg []byte)
}

8
sysservice/tcpgateway/LoadBalance.go
View File

@@ -1,8 +0,0 @@
package tcpgateway
type LoadBalance struct {
}
func (balance *LoadBalance) SelectNode(serviceName string,clientId uint64,eventType string,msgType uint16,msg []byte) int {
return 1
}

302
sysservice/tcpgateway/Router.go
View File

@@ -1,302 +0,0 @@
package tcpgateway
import (
"github.com/duanhf2012/origin/log"
"github.com/duanhf2012/origin/network"
"github.com/duanhf2012/origin/node"
"github.com/duanhf2012/origin/rpc"
"github.com/duanhf2012/origin/sysservice/tcpservice"
"strconv"
"strings"
)
type RouterCfg struct {
}
type Router struct {
loadBalance ILoadBalance
rpcHandler rpc.IRpcHandler
mapMsgRouterInfo map[uint16]*MsgRouterInfo
mapEventRouterInfo map[string]*EventRouterInfo
tcpService *tcpservice.TcpService
mapClientRouterCache map[uint64]map[string]int //map[clientid]nodeid
}
type MsgRouterInfo struct {
Rpc string
ServiceName string
LoadBalanceType string
}
type EventRouterInfo struct {
Rpc string
ServiceName string
LoadBalanceType string
}
func NewRouter(loadBalance ILoadBalance,rpcHandler rpc.IRpcHandler,cfg interface{}) IRouter {
router := &Router{}
router.loadBalance = loadBalance
router.rpcHandler = rpcHandler
router.tcpService = node.GetService("TcpService").(*tcpservice.TcpService)
router.loadCfg(cfg)
router.mapClientRouterCache = map[uint64]map[string]int{}
return router
}
func (r *Router) loadCfg(cfg interface{}){
r.mapMsgRouterInfo = map[uint16]*MsgRouterInfo{}
r.mapEventRouterInfo = map[string]*EventRouterInfo{}
mapRouter,ok := cfg.(map[string]interface{})
if ok == false{
//error....
return
}
//parse MsgRouter
routerInfo,ok := mapRouter["MsgRouter"]
if ok == false{
//error...
return
}
//ar routerList []RouterItem
routerList,ok := routerInfo.([]interface{})
if ok == false{
//error...
return
}
for _,v := range routerList{
mapItem := v.(map[string]interface{})
var iMsgId interface{}
var iRpc interface{}
var iLoadBalanceType interface{}
if iMsgId,ok = mapItem["MsgId"];ok == false {
//error ...
continue
}
if iRpc,ok = mapItem["Rpc"];ok == false {
//error ...
continue
}
if iLoadBalanceType,ok = mapItem["LoadBalanceType"];ok == false {
//error ...
continue
}
msgIdList,ok := iMsgId.(string)
if ok == false {
//error ...
continue
}
var startMsgId int
var endMsgId int
var err error
sliceId := strings.Split(msgIdList,"-")
if len(sliceId) == 1 {
startMsgId,err = strconv.Atoi(msgIdList)
if err != nil {
log.Fatal("TcpGateService %s config is error!",iRpc.(string))
continue
}
endMsgId = startMsgId
} else if len(sliceId) == 2 {
startMsgId,err = strconv.Atoi(sliceId[0])
if err != nil {
log.Fatal("TcpGateService %s config is error!",iRpc.(string))
continue
}
endMsgId,err = strconv.Atoi(sliceId[1])
if err != nil {
log.Fatal("TcpGateService %s config is error!",iRpc.(string))
continue
}
if startMsgId>endMsgId {
log.Fatal("TcpGateService %s config is error!",iRpc.(string))
continue
}
}else {
log.Fatal("TcpGateService %s config is error!",iRpc.(string))
continue
}
strService := strings.Split(iRpc.(string),".")
if len(strService)!=2 {
//error ...
continue
}
msgInfo := &MsgRouterInfo{ServiceName: strService[0],Rpc: iRpc.(string),LoadBalanceType: iLoadBalanceType.(string)}
for i:=startMsgId;i<=endMsgId;i++{
r.mapMsgRouterInfo[uint16(i)] = msgInfo
}
}
//parse EventRouter
eventRouterInfo,ok := mapRouter["EventRouter"]
if ok == false{
//error...
return
}
//ar routerList []RouterItem
eRouterList,ok := eventRouterInfo.([]interface{})
if ok == false{
//error...
return
}
for _,v := range eRouterList{
mapItem := v.(map[string]interface{})
var eventType interface{}
var iRpc interface{}
var iLoadBalanceType interface{}
if eventType,ok = mapItem["EventType"];ok == false {
//error ...
continue
}
if iRpc,ok = mapItem["Rpc"];ok == false {
//error ...
continue
}
if iLoadBalanceType,ok = mapItem["LoadBalanceType"];ok == false {
//error ...
continue
}
strEventType,ok := eventType.(string)
if ok == false {
//error ...
continue
}
strService := strings.Split(iRpc.(string),".")
if len(strService)!=2 {
//error ...
continue
}
r.mapEventRouterInfo[strEventType] = &EventRouterInfo{ServiceName: strService[0],Rpc: iRpc.(string),LoadBalanceType: iLoadBalanceType.(string)}
}
}
func (r *Router) GetMsgRouterService(msgType uint16) *MsgRouterInfo{
info,ok := r.mapMsgRouterInfo[msgType]
if ok == false {
return nil
}
return info
}
func (r *Router) GetEventRouterService(eventType string) *EventRouterInfo{
info,ok := r.mapEventRouterInfo[eventType]
if ok == false {
return nil
}
return info
}
func (r *Router) GetRouterId(clientId uint64,serviceName *string) int {
mapServiceRouter,ok := r.mapClientRouterCache[clientId]
if ok == false{
return 0
}
routerId,ok := mapServiceRouter[*serviceName]
if ok == false {
return 0
}
return routerId
}
func (r *Router) SetRouterId(clientId uint64,serviceName string,routerId int){
r.mapClientRouterCache[clientId][serviceName] = routerId
}
type RawInputArgs struct {
rawData []byte
clientId uint64
}
var rawInputEmpty []byte
func (args RawInputArgs) GetRawData() []byte{
if len(args.rawData) < 2 {
return args.rawData
}
return args.rawData[2:]
}
func (args RawInputArgs) GetAdditionParam() interface{}{
return args.clientId
}
func (args RawInputArgs) DoGc() {
if len(args.rawData) < 2 {
return
}
network.ReleaseByteSlice(args.rawData)
}
var msgEventType string
func (r *Router) RouterMessage(cliId uint64,msgType uint16,msg []byte) {
routerInfo:= r.GetMsgRouterService(msgType)
if routerInfo==nil {
log.Error("The message type is %d with no configured route!",msgType)
return
}
routerId := r.GetRouterId(cliId,&routerInfo.ServiceName)
if routerId ==0 {
routerId = r.loadBalance.SelectNode(routerInfo.ServiceName,cliId,msgEventType,msgType,msg)
r.SetRouterId(cliId,routerInfo.ServiceName,routerId)
}
if routerId>0 {
r.rpcHandler.RawGoNode(rpc.RpcProcessorPb,routerId,routerInfo.Rpc,RawInputArgs{rawData: msg,clientId: cliId})
}
}
func (r *Router) Load(){
}
func (r *Router) RouterEvent(clientId uint64,eventType string) bool{
routerInfo:= r.GetEventRouterService(eventType)
if routerInfo==nil {
log.Error("The event type is %s with no register!",eventType)
return false
}
routerId := r.GetRouterId(clientId,&routerInfo.ServiceName)
if routerId ==0 {
routerId = r.loadBalance.SelectNode(routerInfo.ServiceName,clientId,eventType,0,nil)
r.SetRouterId(clientId,routerInfo.ServiceName,routerId)
}
if routerId>0 {
r.rpcHandler.RawGoNode(rpc.RpcProcessorPb,routerId,routerInfo.Rpc,RawInputArgs{rawData: rawInputEmpty,clientId: clientId})
return true
}
return false
}
func (r *Router) OnDisconnected(clientId uint64){
delete(r.mapClientRouterCache,clientId)
//通知事件
r.RouterEvent(clientId,"DisConnect")
}
func (r *Router) OnConnected(clientId uint64){
r.mapClientRouterCache[clientId] = map[string]int{}
r.RouterEvent(clientId,"Connect")
}

101
sysservice/tcpgateway/TcpGateService.go
View File

@@ -1,101 +0,0 @@
package tcpgateway
import (
"github.com/duanhf2012/origin/log"
"github.com/duanhf2012/origin/network/processor"
"github.com/duanhf2012/origin/node"
"github.com/duanhf2012/origin/service"
"github.com/duanhf2012/origin/sysservice/tcpservice"
)
type MsgTypeRouterInfo struct {
router IRouter
serviceName string
}
type TcpGateService struct {
service.Service
processor processor.IRawProcessor
tcpService *tcpservice.TcpService
loadBalance ILoadBalance
router IRouter
}
func (gateService *TcpGateService) OnInit() error {
gateService.OnLoad()
//注册监听客户连接断开事件
gateService.processor.SetDisConnectedHandler(gateService.router.OnDisconnected)
//注册监听客户连接事件
gateService.processor.SetConnectedHandler(gateService.router.OnConnected)
//注册监听消息类型MsgType_MsgReq，并注册回调
gateService.processor.SetRawMsgHandler(gateService.router.RouterMessage)
//将protobuf消息处理器设置到TcpService服务中
gateService.tcpService.SetProcessor(gateService.processor, gateService.GetEventHandler())
return nil
}
func (gateService *TcpGateService) SetEventChannel(channelNum int){
gateService.GetEventProcessor().SetEventChannel(channelNum)
}
func (gateService *TcpGateService) OnLoad() {
//设置默认LoadBalance
if gateService.loadBalance == nil {
gateService.loadBalance = &LoadBalance{}
}
//设置默认Router
if gateService.router == nil {
gateService.router = NewRouter(gateService.loadBalance, gateService, gateService.GetServiceCfg())
}
//新建内置的protobuf处理器，您也可以自定义路由器，比如json
if gateService.processor == nil {
gateService.processor = processor.NewPBRawProcessor()
}
//加载路由
gateService.router.Load()
//设置默认的TcpService服务
if gateService.tcpService == nil {
gateService.tcpService = node.GetService("TcpService").(*tcpservice.TcpService)
}
if gateService.tcpService == nil {
panic("TcpService is not installed!")
}
}
func (gateService *TcpGateService) SetLoadBalance(loadBalance ILoadBalance){
gateService.loadBalance = loadBalance
}
func (gateService *TcpGateService) SetRouter(router IRouter){
gateService.router = router
}
func (gateService *TcpGateService) SetRawProcessor(processor processor.IRawProcessor){
gateService.processor = processor
}
func (gateService *TcpGateService) SetTcpGateService(tcpService *tcpservice.TcpService){
gateService.tcpService = tcpService
}
func (gateService *TcpGateService) RPC_Dispatch(replyMsg *ReplyMessage) error {
for _,id := range replyMsg.ClientList {
err := gateService.tcpService.SendRawMsg(id,replyMsg.Msg)
if err != nil {
log.Debug("SendRawMsg fail:%+v!",err)
}
}
return nil
}

473
sysservice/tcpgateway/base.pb.go
View File

@@ -1,473 +0,0 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: base/base.proto
package tcpgateway
import (
fmt "fmt"
proto "github.com/golang/protobuf/proto"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type Int struct {
Value *int32 `protobuf:"varint,1,opt,name=value" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Int) Reset() { *m = Int{} }
func (m *Int) String() string { return proto.CompactTextString(m) }
func (*Int) ProtoMessage() {}
func (*Int) Descriptor() ([]byte, []int) {
return fileDescriptor_d66ec2e140567106, []int{0}
}
func (m *Int) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Int.Unmarshal(m, b)
}
func (m *Int) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Int.Marshal(b, m, deterministic)
}
func (m *Int) XXX_Merge(src proto.Message) {
xxx_messageInfo_Int.Merge(m, src)
}
func (m *Int) XXX_Size() int {
return xxx_messageInfo_Int.Size(m)
}
func (m *Int) XXX_DiscardUnknown() {
xxx_messageInfo_Int.DiscardUnknown(m)
}
var xxx_messageInfo_Int proto.InternalMessageInfo
func (m *Int) GetValue() int32 {
if m != nil && m.Value != nil {
return *m.Value
}
return 0
}
type Int64 struct {
Value *int64 `protobuf:"varint,1,opt,name=value" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Int64) Reset() { *m = Int64{} }
func (m *Int64) String() string { return proto.CompactTextString(m) }
func (*Int64) ProtoMessage() {}
func (*Int64) Descriptor() ([]byte, []int) {
return fileDescriptor_d66ec2e140567106, []int{1}
}
func (m *Int64) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Int64.Unmarshal(m, b)
}
func (m *Int64) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Int64.Marshal(b, m, deterministic)
}
func (m *Int64) XXX_Merge(src proto.Message) {
xxx_messageInfo_Int64.Merge(m, src)
}
func (m *Int64) XXX_Size() int {
return xxx_messageInfo_Int64.Size(m)
}
func (m *Int64) XXX_DiscardUnknown() {
xxx_messageInfo_Int64.DiscardUnknown(m)
}
var xxx_messageInfo_Int64 proto.InternalMessageInfo
func (m *Int64) GetValue() int64 {
if m != nil && m.Value != nil {
return *m.Value
}
return 0
}
type Bool struct {
Value *bool `protobuf:"varint,1,opt,name=value" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Bool) Reset() { *m = Bool{} }
func (m *Bool) String() string { return proto.CompactTextString(m) }
func (*Bool) ProtoMessage() {}
func (*Bool) Descriptor() ([]byte, []int) {
return fileDescriptor_d66ec2e140567106, []int{2}
}
func (m *Bool) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Bool.Unmarshal(m, b)
}
func (m *Bool) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Bool.Marshal(b, m, deterministic)
}
func (m *Bool) XXX_Merge(src proto.Message) {
xxx_messageInfo_Bool.Merge(m, src)
}
func (m *Bool) XXX_Size() int {
return xxx_messageInfo_Bool.Size(m)
}
func (m *Bool) XXX_DiscardUnknown() {
xxx_messageInfo_Bool.DiscardUnknown(m)
}
var xxx_messageInfo_Bool proto.InternalMessageInfo
func (m *Bool) GetValue() bool {
if m != nil && m.Value != nil {
return *m.Value
}
return false
}
type String struct {
Value *string `protobuf:"bytes,1,opt,name=value" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *String) Reset() { *m = String{} }
func (m *String) String() string { return proto.CompactTextString(m) }
func (*String) ProtoMessage() {}
func (*String) Descriptor() ([]byte, []int) {
return fileDescriptor_d66ec2e140567106, []int{3}
}
func (m *String) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_String.Unmarshal(m, b)
}
func (m *String) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_String.Marshal(b, m, deterministic)
}
func (m *String) XXX_Merge(src proto.Message) {
xxx_messageInfo_String.Merge(m, src)
}
func (m *String) XXX_Size() int {
return xxx_messageInfo_String.Size(m)
}
func (m *String) XXX_DiscardUnknown() {
xxx_messageInfo_String.DiscardUnknown(m)
}
var xxx_messageInfo_String proto.InternalMessageInfo
func (m *String) GetValue() string {
if m != nil && m.Value != nil {
return *m.Value
}
return ""
}
type Bytes struct {
Value []byte `protobuf:"bytes,1,opt,name=value" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Bytes) Reset() { *m = Bytes{} }
func (m *Bytes) String() string { return proto.CompactTextString(m) }
func (*Bytes) ProtoMessage() {}
func (*Bytes) Descriptor() ([]byte, []int) {
return fileDescriptor_d66ec2e140567106, []int{4}
}
func (m *Bytes) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Bytes.Unmarshal(m, b)
}
func (m *Bytes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Bytes.Marshal(b, m, deterministic)
}
func (m *Bytes) XXX_Merge(src proto.Message) {
xxx_messageInfo_Bytes.Merge(m, src)
}
func (m *Bytes) XXX_Size() int {
return xxx_messageInfo_Bytes.Size(m)
}
func (m *Bytes) XXX_DiscardUnknown() {
xxx_messageInfo_Bytes.DiscardUnknown(m)
}
var xxx_messageInfo_Bytes proto.InternalMessageInfo
func (m *Bytes) GetValue() []byte {
if m != nil {
return m.Value
}
return nil
}
type MsgHead struct {
Cid *int32 `protobuf:"varint,1,opt,name=cid" json:"cid,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *MsgHead) Reset() { *m = MsgHead{} }
func (m *MsgHead) String() string { return proto.CompactTextString(m) }
func (*MsgHead) ProtoMessage() {}
func (*MsgHead) Descriptor() ([]byte, []int) {
return fileDescriptor_d66ec2e140567106, []int{5}
}
func (m *MsgHead) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_MsgHead.Unmarshal(m, b)
}
func (m *MsgHead) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_MsgHead.Marshal(b, m, deterministic)
}
func (m *MsgHead) XXX_Merge(src proto.Message) {
xxx_messageInfo_MsgHead.Merge(m, src)
}
func (m *MsgHead) XXX_Size() int {
return xxx_messageInfo_MsgHead.Size(m)
}
func (m *MsgHead) XXX_DiscardUnknown() {
xxx_messageInfo_MsgHead.DiscardUnknown(m)
}
var xxx_messageInfo_MsgHead proto.InternalMessageInfo
func (m *MsgHead) GetCid() int32 {
if m != nil && m.Cid != nil {
return *m.Cid
}
return 0
}
type Msg struct {
Head *MsgHead `protobuf:"bytes,1,opt,name=head" json:"head,omitempty"`
Ret *int32 `protobuf:"varint,2,opt,name=ret" json:"ret,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
proto.XXX_InternalExtensions `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Msg) Reset() { *m = Msg{} }
func (m *Msg) String() string { return proto.CompactTextString(m) }
func (*Msg) ProtoMessage() {}
func (*Msg) Descriptor() ([]byte, []int) {
return fileDescriptor_d66ec2e140567106, []int{6}
}
var extRange_Msg = []proto.ExtensionRange{
{Start: 100, End: 10000},
}
func (*Msg) ExtensionRangeArray() []proto.ExtensionRange {
return extRange_Msg
}
func (m *Msg) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Msg.Unmarshal(m, b)
}
func (m *Msg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Msg.Marshal(b, m, deterministic)
}
func (m *Msg) XXX_Merge(src proto.Message) {
xxx_messageInfo_Msg.Merge(m, src)
}
func (m *Msg) XXX_Size() int {
return xxx_messageInfo_Msg.Size(m)
}
func (m *Msg) XXX_DiscardUnknown() {
xxx_messageInfo_Msg.DiscardUnknown(m)
}
var xxx_messageInfo_Msg proto.InternalMessageInfo
func (m *Msg) GetHead() *MsgHead {
if m != nil {
return m.Head
}
return nil
}
func (m *Msg) GetRet() int32 {
if m != nil && m.Ret != nil {
return *m.Ret
}
return 0
}
type ClientList struct {
ClientList []uint64 `protobuf:"varint,1,rep,name=clientList" json:"clientList,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ClientList) Reset() { *m = ClientList{} }
func (m *ClientList) String() string { return proto.CompactTextString(m) }
func (*ClientList) ProtoMessage() {}
func (*ClientList) Descriptor() ([]byte, []int) {
return fileDescriptor_d66ec2e140567106, []int{7}
}
func (m *ClientList) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ClientList.Unmarshal(m, b)
}
func (m *ClientList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ClientList.Marshal(b, m, deterministic)
}
func (m *ClientList) XXX_Merge(src proto.Message) {
xxx_messageInfo_ClientList.Merge(m, src)
}
func (m *ClientList) XXX_Size() int {
return xxx_messageInfo_ClientList.Size(m)
}
func (m *ClientList) XXX_DiscardUnknown() {
xxx_messageInfo_ClientList.DiscardUnknown(m)
}
var xxx_messageInfo_ClientList proto.InternalMessageInfo
func (m *ClientList) GetClientList() []uint64 {
if m != nil {
return m.ClientList
}
return nil
}
type ReplyMessage struct {
ClientList []uint64 `protobuf:"varint,1,rep,name=clientList" json:"clientList,omitempty"`
MsgType *uint32 `protobuf:"varint,2,opt,name=msgType" json:"msgType,omitempty"`
Msg []byte `protobuf:"bytes,3,opt,name=msg" json:"msg,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ReplyMessage) Reset() { *m = ReplyMessage{} }
func (m *ReplyMessage) String() string { return proto.CompactTextString(m) }
func (*ReplyMessage) ProtoMessage() {}
func (*ReplyMessage) Descriptor() ([]byte, []int) {
return fileDescriptor_d66ec2e140567106, []int{8}
}
func (m *ReplyMessage) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ReplyMessage.Unmarshal(m, b)
}
func (m *ReplyMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ReplyMessage.Marshal(b, m, deterministic)
}
func (m *ReplyMessage) XXX_Merge(src proto.Message) {
xxx_messageInfo_ReplyMessage.Merge(m, src)
}
func (m *ReplyMessage) XXX_Size() int {
return xxx_messageInfo_ReplyMessage.Size(m)
}
func (m *ReplyMessage) XXX_DiscardUnknown() {
xxx_messageInfo_ReplyMessage.DiscardUnknown(m)
}
var xxx_messageInfo_ReplyMessage proto.InternalMessageInfo
func (m *ReplyMessage) GetClientList() []uint64 {
if m != nil {
return m.ClientList
}
return nil
}
func (m *ReplyMessage) GetMsgType() uint32 {
if m != nil && m.MsgType != nil {
return *m.MsgType
}
return 0
}
func (m *ReplyMessage) GetMsg() []byte {
if m != nil {
return m.Msg
}
return nil
}
type PlaceHolders struct {
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *PlaceHolders) Reset() { *m = PlaceHolders{} }
func (m *PlaceHolders) String() string { return proto.CompactTextString(m) }
func (*PlaceHolders) ProtoMessage() {}
func (*PlaceHolders) Descriptor() ([]byte, []int) {
return fileDescriptor_d66ec2e140567106, []int{9}
}
func (m *PlaceHolders) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_PlaceHolders.Unmarshal(m, b)
}
func (m *PlaceHolders) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_PlaceHolders.Marshal(b, m, deterministic)
}
func (m *PlaceHolders) XXX_Merge(src proto.Message) {
xxx_messageInfo_PlaceHolders.Merge(m, src)
}
func (m *PlaceHolders) XXX_Size() int {
return xxx_messageInfo_PlaceHolders.Size(m)
}
func (m *PlaceHolders) XXX_DiscardUnknown() {
xxx_messageInfo_PlaceHolders.DiscardUnknown(m)
}
var xxx_messageInfo_PlaceHolders proto.InternalMessageInfo
func init() {
proto.RegisterType((*Int)(nil), "tcpgateway.Int")
proto.RegisterType((*Int64)(nil), "tcpgateway.Int64")
proto.RegisterType((*Bool)(nil), "tcpgateway.Bool")
proto.RegisterType((*String)(nil), "tcpgateway.String")
proto.RegisterType((*Bytes)(nil), "tcpgateway.Bytes")
proto.RegisterType((*MsgHead)(nil), "tcpgateway.MsgHead")
proto.RegisterType((*Msg)(nil), "tcpgateway.Msg")
proto.RegisterType((*ClientList)(nil), "tcpgateway.ClientList")
proto.RegisterType((*ReplyMessage)(nil), "tcpgateway.ReplyMessage")
proto.RegisterType((*PlaceHolders)(nil), "tcpgateway.PlaceHolders")
}
func init() { proto.RegisterFile("base/base.proto", fileDescriptor_d66ec2e140567106) }
var fileDescriptor_d66ec2e140567106 = []byte{
// 276 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x8f, 0x41, 0x4b, 0xc3, 0x40,
0x10, 0x85, 0xa9, 0x9b, 0xd8, 0x3a, 0x46, 0x2d, 0xab, 0x87, 0x40, 0xb5, 0x94, 0xbd, 0x58, 0x44,
0x22, 0x88, 0xf8, 0x03, 0xea, 0xc1, 0x16, 0x8c, 0x48, 0xf4, 0xe4, 0x6d, 0x4d, 0x86, 0x35, 0xb0,
0x4d, 0x42, 0x66, 0x54, 0xf2, 0x33, 0xfc, 0xc7, 0x92, 0xa4, 0xd1, 0xe6, 0xe4, 0x65, 0x99, 0xb7,
0xdf, 0xec, 0xdb, 0xf7, 0xe0, 0xe8, 0x4d, 0x13, 0x5e, 0xd5, 0x47, 0x50, 0x94, 0x39, 0xe7, 0x12,
0x38, 0x2e, 0x8c, 0x66, 0xfc, 0xd2, 0x95, 0x9a, 0x80, 0x58, 0x65, 0x2c, 0x4f, 0xc0, 0xfd, 0xd4,
0xf6, 0x03, 0xfd, 0xc1, 0x6c, 0x30, 0x77, 0xa3, 0x56, 0xa8, 0x33, 0x70, 0x57, 0x19, 0xdf, 0xde,
0xf4, 0xb1, 0xe8, 0xf0, 0x29, 0x38, 0x8b, 0x3c, 0xb7, 0x7d, 0x3a, 0xea, 0xe8, 0x14, 0x76, 0x9f,
0xb9, 0x4c, 0x33, 0xd3, 0xe7, 0x7b, 0x5b, 0xe6, 0x8b, 0x8a, 0x91, 0xfa, 0xd8, 0xeb, 0xf0, 0x04,
0x86, 0x21, 0x99, 0x25, 0xea, 0x44, 0x8e, 0x41, 0xc4, 0x69, 0xb2, 0x89, 0x56, 0x8f, 0xea, 0x1e,
0x44, 0x48, 0x46, 0x9e, 0x83, 0xf3, 0x8e, 0xba, 0x25, 0xfb, 0xd7, 0xc7, 0xc1, 0x5f, 0xaf, 0x60,
0xf3, 0x36, 0x6a, 0x16, 0x6a, 0x87, 0x12, 0xd9, 0xdf, 0x69, 0x1d, 0x4a, 0xe4, 0x0b, 0x77, 0x94,
0x8c, 0xbf, 0x1f, 0xd5, 0x25, 0xc0, 0x9d, 0x4d, 0x31, 0xe3, 0x87, 0x94, 0x58, 0x4e, 0x01, 0xe2,
0x5f, 0xe5, 0x0f, 0x66, 0x62, 0xee, 0x44, 0x5b, 0x37, 0xea, 0x15, 0xbc, 0x08, 0x0b, 0x5b, 0x85,
0x48, 0xa4, 0x0d, 0xfe, 0xb7, 0x2f, 0x7d, 0x18, 0xae, 0xc9, 0xbc, 0x54, 0x05, 0x36, 0x5f, 0x1f,
0x44, 0x9d, 0xac, 0x03, 0xad, 0xc9, 0xf8, 0xa2, 0x69, 0x5c, 0x8f, 0xea, 0x10, 0xbc, 0x27, 0xab,
0x63, 0x5c, 0xe6, 0x36, 0xc1, 0x92, 0x7e, 0x02, 0x00, 0x00, 0xff, 0xff, 0xc7, 0xb1, 0xeb, 0xcb,
0xb6, 0x01, 0x00, 0x00,
}

55
sysservice/tcpgateway/base.proto
View File

@@ -1,55 +0,0 @@
syntax = "proto2";
package tcpgateway;
message Int{
optional int32 value = 1;
}
message Int64{
optional int64 value = 1;
}
message Bool{
optional bool value = 1;
}
message String{
optional string value = 1;
}
message Bytes{
optional bytes value = 1;
}
message MsgHead
{
optional int32 cid = 1;
}
message Msg
{
optional MsgHead head = 1;
optional int32 ret = 2;
extensions 100 to 10000;
}
message ClientList
{
repeated uint64 clientList = 1;
}
message ReplyMessage
{
repeated uint64 clientList = 1;
optional uint32 msgType = 2;
optional bytes msg = 3;
}
message PlaceHolders
{
}