repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
list | docstring
stringlengths 6
2.61k
| docstring_tokens
list | sha
stringlengths 40
40
| url
stringlengths 85
252
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
topfreegames/pitaya
|
examples/demo/cluster_grpc/services/room.go
|
Outbound
|
func (Stats *Stats) Outbound(ctx context.Context, in []byte) ([]byte, error) {
Stats.outboundBytes += len(in)
return in, nil
}
|
go
|
func (Stats *Stats) Outbound(ctx context.Context, in []byte) ([]byte, error) {
Stats.outboundBytes += len(in)
return in, nil
}
|
[
"func",
"(",
"Stats",
"*",
"Stats",
")",
"Outbound",
"(",
"ctx",
"context",
".",
"Context",
",",
"in",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"Stats",
".",
"outboundBytes",
"+=",
"len",
"(",
"in",
")",
"\n",
"return",
"in",
",",
"nil",
"\n",
"}"
] |
// Outbound gets the outbound status
|
[
"Outbound",
"gets",
"the",
"outbound",
"status"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/examples/demo/cluster_grpc/services/room.go#L64-L67
|
train
|
topfreegames/pitaya
|
examples/demo/cluster_grpc/services/room.go
|
Inbound
|
func (Stats *Stats) Inbound(ctx context.Context, in []byte) ([]byte, error) {
Stats.inboundBytes += len(in)
return in, nil
}
|
go
|
func (Stats *Stats) Inbound(ctx context.Context, in []byte) ([]byte, error) {
Stats.inboundBytes += len(in)
return in, nil
}
|
[
"func",
"(",
"Stats",
"*",
"Stats",
")",
"Inbound",
"(",
"ctx",
"context",
".",
"Context",
",",
"in",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"Stats",
".",
"inboundBytes",
"+=",
"len",
"(",
"in",
")",
"\n",
"return",
"in",
",",
"nil",
"\n",
"}"
] |
// Inbound gets the inbound status
|
[
"Inbound",
"gets",
"the",
"inbound",
"status"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/examples/demo/cluster_grpc/services/room.go#L70-L73
|
train
|
topfreegames/pitaya
|
examples/demo/cluster_grpc/services/room.go
|
MessageRemote
|
func (r *Room) MessageRemote(ctx context.Context, msg *UserMessage, b bool, s string) (*UserMessage, error) {
return msg, nil
}
|
go
|
func (r *Room) MessageRemote(ctx context.Context, msg *UserMessage, b bool, s string) (*UserMessage, error) {
return msg, nil
}
|
[
"func",
"(",
"r",
"*",
"Room",
")",
"MessageRemote",
"(",
"ctx",
"context",
".",
"Context",
",",
"msg",
"*",
"UserMessage",
",",
"b",
"bool",
",",
"s",
"string",
")",
"(",
"*",
"UserMessage",
",",
"error",
")",
"{",
"return",
"msg",
",",
"nil",
"\n",
"}"
] |
// MessageRemote just echoes the given message
|
[
"MessageRemote",
"just",
"echoes",
"the",
"given",
"message"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/examples/demo/cluster_grpc/services/room.go#L175-L177
|
train
|
topfreegames/pitaya
|
session/mocks/session.go
|
NewMockNetworkEntity
|
func NewMockNetworkEntity(ctrl *gomock.Controller) *MockNetworkEntity {
mock := &MockNetworkEntity{ctrl: ctrl}
mock.recorder = &MockNetworkEntityMockRecorder{mock}
return mock
}
|
go
|
func NewMockNetworkEntity(ctrl *gomock.Controller) *MockNetworkEntity {
mock := &MockNetworkEntity{ctrl: ctrl}
mock.recorder = &MockNetworkEntityMockRecorder{mock}
return mock
}
|
[
"func",
"NewMockNetworkEntity",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockNetworkEntity",
"{",
"mock",
":=",
"&",
"MockNetworkEntity",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockNetworkEntityMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] |
// NewMockNetworkEntity creates a new mock instance
|
[
"NewMockNetworkEntity",
"creates",
"a",
"new",
"mock",
"instance"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/session/mocks/session.go#L27-L31
|
train
|
topfreegames/pitaya
|
session/mocks/session.go
|
Push
|
func (m *MockNetworkEntity) Push(route string, v interface{}) error {
ret := m.ctrl.Call(m, "Push", route, v)
ret0, _ := ret[0].(error)
return ret0
}
|
go
|
func (m *MockNetworkEntity) Push(route string, v interface{}) error {
ret := m.ctrl.Call(m, "Push", route, v)
ret0, _ := ret[0].(error)
return ret0
}
|
[
"func",
"(",
"m",
"*",
"MockNetworkEntity",
")",
"Push",
"(",
"route",
"string",
",",
"v",
"interface",
"{",
"}",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"route",
",",
"v",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] |
// Push mocks base method
|
[
"Push",
"mocks",
"base",
"method"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/session/mocks/session.go#L39-L43
|
train
|
topfreegames/pitaya
|
session/mocks/session.go
|
Push
|
func (mr *MockNetworkEntityMockRecorder) Push(route, v interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Push", reflect.TypeOf((*MockNetworkEntity)(nil).Push), route, v)
}
|
go
|
func (mr *MockNetworkEntityMockRecorder) Push(route, v interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Push", reflect.TypeOf((*MockNetworkEntity)(nil).Push), route, v)
}
|
[
"func",
"(",
"mr",
"*",
"MockNetworkEntityMockRecorder",
")",
"Push",
"(",
"route",
",",
"v",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockNetworkEntity",
")",
"(",
"nil",
")",
".",
"Push",
")",
",",
"route",
",",
"v",
")",
"\n",
"}"
] |
// Push indicates an expected call of Push
|
[
"Push",
"indicates",
"an",
"expected",
"call",
"of",
"Push"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/session/mocks/session.go#L46-L48
|
train
|
topfreegames/pitaya
|
session/mocks/session.go
|
ResponseMID
|
func (m *MockNetworkEntity) ResponseMID(ctx context.Context, mid uint, v interface{}, isError ...bool) error {
varargs := []interface{}{ctx, mid, v}
for _, a := range isError {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ResponseMID", varargs...)
ret0, _ := ret[0].(error)
return ret0
}
|
go
|
func (m *MockNetworkEntity) ResponseMID(ctx context.Context, mid uint, v interface{}, isError ...bool) error {
varargs := []interface{}{ctx, mid, v}
for _, a := range isError {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ResponseMID", varargs...)
ret0, _ := ret[0].(error)
return ret0
}
|
[
"func",
"(",
"m",
"*",
"MockNetworkEntity",
")",
"ResponseMID",
"(",
"ctx",
"context",
".",
"Context",
",",
"mid",
"uint",
",",
"v",
"interface",
"{",
"}",
",",
"isError",
"...",
"bool",
")",
"error",
"{",
"varargs",
":=",
"[",
"]",
"interface",
"{",
"}",
"{",
"ctx",
",",
"mid",
",",
"v",
"}",
"\n",
"for",
"_",
",",
"a",
":=",
"range",
"isError",
"{",
"varargs",
"=",
"append",
"(",
"varargs",
",",
"a",
")",
"\n",
"}",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"varargs",
"...",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] |
// ResponseMID mocks base method
|
[
"ResponseMID",
"mocks",
"base",
"method"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/session/mocks/session.go#L51-L59
|
train
|
topfreegames/pitaya
|
session/mocks/session.go
|
ResponseMID
|
func (mr *MockNetworkEntityMockRecorder) ResponseMID(ctx, mid, v interface{}, isError ...interface{}) *gomock.Call {
varargs := append([]interface{}{ctx, mid, v}, isError...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResponseMID", reflect.TypeOf((*MockNetworkEntity)(nil).ResponseMID), varargs...)
}
|
go
|
func (mr *MockNetworkEntityMockRecorder) ResponseMID(ctx, mid, v interface{}, isError ...interface{}) *gomock.Call {
varargs := append([]interface{}{ctx, mid, v}, isError...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResponseMID", reflect.TypeOf((*MockNetworkEntity)(nil).ResponseMID), varargs...)
}
|
[
"func",
"(",
"mr",
"*",
"MockNetworkEntityMockRecorder",
")",
"ResponseMID",
"(",
"ctx",
",",
"mid",
",",
"v",
"interface",
"{",
"}",
",",
"isError",
"...",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"varargs",
":=",
"append",
"(",
"[",
"]",
"interface",
"{",
"}",
"{",
"ctx",
",",
"mid",
",",
"v",
"}",
",",
"isError",
"...",
")",
"\n",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockNetworkEntity",
")",
"(",
"nil",
")",
".",
"ResponseMID",
")",
",",
"varargs",
"...",
")",
"\n",
"}"
] |
// ResponseMID indicates an expected call of ResponseMID
|
[
"ResponseMID",
"indicates",
"an",
"expected",
"call",
"of",
"ResponseMID"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/session/mocks/session.go#L62-L65
|
train
|
topfreegames/pitaya
|
session/mocks/session.go
|
Kick
|
func (m *MockNetworkEntity) Kick(ctx context.Context) error {
ret := m.ctrl.Call(m, "Kick", ctx)
ret0, _ := ret[0].(error)
return ret0
}
|
go
|
func (m *MockNetworkEntity) Kick(ctx context.Context) error {
ret := m.ctrl.Call(m, "Kick", ctx)
ret0, _ := ret[0].(error)
return ret0
}
|
[
"func",
"(",
"m",
"*",
"MockNetworkEntity",
")",
"Kick",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"ctx",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] |
// Kick mocks base method
|
[
"Kick",
"mocks",
"base",
"method"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/session/mocks/session.go#L80-L84
|
train
|
topfreegames/pitaya
|
session/mocks/session.go
|
Kick
|
func (mr *MockNetworkEntityMockRecorder) Kick(ctx interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Kick", reflect.TypeOf((*MockNetworkEntity)(nil).Kick), ctx)
}
|
go
|
func (mr *MockNetworkEntityMockRecorder) Kick(ctx interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Kick", reflect.TypeOf((*MockNetworkEntity)(nil).Kick), ctx)
}
|
[
"func",
"(",
"mr",
"*",
"MockNetworkEntityMockRecorder",
")",
"Kick",
"(",
"ctx",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockNetworkEntity",
")",
"(",
"nil",
")",
".",
"Kick",
")",
",",
"ctx",
")",
"\n",
"}"
] |
// Kick indicates an expected call of Kick
|
[
"Kick",
"indicates",
"an",
"expected",
"call",
"of",
"Kick"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/session/mocks/session.go#L87-L89
|
train
|
topfreegames/pitaya
|
session/mocks/session.go
|
RemoteAddr
|
func (mr *MockNetworkEntityMockRecorder) RemoteAddr() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoteAddr", reflect.TypeOf((*MockNetworkEntity)(nil).RemoteAddr))
}
|
go
|
func (mr *MockNetworkEntityMockRecorder) RemoteAddr() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoteAddr", reflect.TypeOf((*MockNetworkEntity)(nil).RemoteAddr))
}
|
[
"func",
"(",
"mr",
"*",
"MockNetworkEntityMockRecorder",
")",
"RemoteAddr",
"(",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockNetworkEntity",
")",
"(",
"nil",
")",
".",
"RemoteAddr",
")",
")",
"\n",
"}"
] |
// RemoteAddr indicates an expected call of RemoteAddr
|
[
"RemoteAddr",
"indicates",
"an",
"expected",
"call",
"of",
"RemoteAddr"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/session/mocks/session.go#L99-L101
|
train
|
topfreegames/pitaya
|
session/mocks/session.go
|
SendRequest
|
func (m *MockNetworkEntity) SendRequest(ctx context.Context, serverID, route string, v interface{}) (*protos.Response, error) {
ret := m.ctrl.Call(m, "SendRequest", ctx, serverID, route, v)
ret0, _ := ret[0].(*protos.Response)
ret1, _ := ret[1].(error)
return ret0, ret1
}
|
go
|
func (m *MockNetworkEntity) SendRequest(ctx context.Context, serverID, route string, v interface{}) (*protos.Response, error) {
ret := m.ctrl.Call(m, "SendRequest", ctx, serverID, route, v)
ret0, _ := ret[0].(*protos.Response)
ret1, _ := ret[1].(error)
return ret0, ret1
}
|
[
"func",
"(",
"m",
"*",
"MockNetworkEntity",
")",
"SendRequest",
"(",
"ctx",
"context",
".",
"Context",
",",
"serverID",
",",
"route",
"string",
",",
"v",
"interface",
"{",
"}",
")",
"(",
"*",
"protos",
".",
"Response",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"ctx",
",",
"serverID",
",",
"route",
",",
"v",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"protos",
".",
"Response",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] |
// SendRequest mocks base method
|
[
"SendRequest",
"mocks",
"base",
"method"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/session/mocks/session.go#L104-L109
|
train
|
topfreegames/pitaya
|
session/mocks/session.go
|
SendRequest
|
func (mr *MockNetworkEntityMockRecorder) SendRequest(ctx, serverID, route, v interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendRequest", reflect.TypeOf((*MockNetworkEntity)(nil).SendRequest), ctx, serverID, route, v)
}
|
go
|
func (mr *MockNetworkEntityMockRecorder) SendRequest(ctx, serverID, route, v interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendRequest", reflect.TypeOf((*MockNetworkEntity)(nil).SendRequest), ctx, serverID, route, v)
}
|
[
"func",
"(",
"mr",
"*",
"MockNetworkEntityMockRecorder",
")",
"SendRequest",
"(",
"ctx",
",",
"serverID",
",",
"route",
",",
"v",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockNetworkEntity",
")",
"(",
"nil",
")",
".",
"SendRequest",
")",
",",
"ctx",
",",
"serverID",
",",
"route",
",",
"v",
")",
"\n",
"}"
] |
// SendRequest indicates an expected call of SendRequest
|
[
"SendRequest",
"indicates",
"an",
"expected",
"call",
"of",
"SendRequest"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/session/mocks/session.go#L112-L114
|
train
|
topfreegames/pitaya
|
service/handler.go
|
NewHandlerService
|
func NewHandlerService(
dieChan chan bool,
packetDecoder codec.PacketDecoder,
packetEncoder codec.PacketEncoder,
serializer serialize.Serializer,
heartbeatTime time.Duration,
messagesBufferSize,
localProcessBufferSize,
remoteProcessBufferSize int,
server *cluster.Server,
remoteService *RemoteService,
messageEncoder message.Encoder,
metricsReporters []metrics.Reporter,
) *HandlerService {
h := &HandlerService{
services: make(map[string]*component.Service),
chLocalProcess: make(chan unhandledMessage, localProcessBufferSize),
chRemoteProcess: make(chan unhandledMessage, remoteProcessBufferSize),
decoder: packetDecoder,
encoder: packetEncoder,
messagesBufferSize: messagesBufferSize,
serializer: serializer,
heartbeatTimeout: heartbeatTime,
appDieChan: dieChan,
server: server,
remoteService: remoteService,
messageEncoder: messageEncoder,
metricsReporters: metricsReporters,
}
return h
}
|
go
|
func NewHandlerService(
dieChan chan bool,
packetDecoder codec.PacketDecoder,
packetEncoder codec.PacketEncoder,
serializer serialize.Serializer,
heartbeatTime time.Duration,
messagesBufferSize,
localProcessBufferSize,
remoteProcessBufferSize int,
server *cluster.Server,
remoteService *RemoteService,
messageEncoder message.Encoder,
metricsReporters []metrics.Reporter,
) *HandlerService {
h := &HandlerService{
services: make(map[string]*component.Service),
chLocalProcess: make(chan unhandledMessage, localProcessBufferSize),
chRemoteProcess: make(chan unhandledMessage, remoteProcessBufferSize),
decoder: packetDecoder,
encoder: packetEncoder,
messagesBufferSize: messagesBufferSize,
serializer: serializer,
heartbeatTimeout: heartbeatTime,
appDieChan: dieChan,
server: server,
remoteService: remoteService,
messageEncoder: messageEncoder,
metricsReporters: metricsReporters,
}
return h
}
|
[
"func",
"NewHandlerService",
"(",
"dieChan",
"chan",
"bool",
",",
"packetDecoder",
"codec",
".",
"PacketDecoder",
",",
"packetEncoder",
"codec",
".",
"PacketEncoder",
",",
"serializer",
"serialize",
".",
"Serializer",
",",
"heartbeatTime",
"time",
".",
"Duration",
",",
"messagesBufferSize",
",",
"localProcessBufferSize",
",",
"remoteProcessBufferSize",
"int",
",",
"server",
"*",
"cluster",
".",
"Server",
",",
"remoteService",
"*",
"RemoteService",
",",
"messageEncoder",
"message",
".",
"Encoder",
",",
"metricsReporters",
"[",
"]",
"metrics",
".",
"Reporter",
",",
")",
"*",
"HandlerService",
"{",
"h",
":=",
"&",
"HandlerService",
"{",
"services",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"component",
".",
"Service",
")",
",",
"chLocalProcess",
":",
"make",
"(",
"chan",
"unhandledMessage",
",",
"localProcessBufferSize",
")",
",",
"chRemoteProcess",
":",
"make",
"(",
"chan",
"unhandledMessage",
",",
"remoteProcessBufferSize",
")",
",",
"decoder",
":",
"packetDecoder",
",",
"encoder",
":",
"packetEncoder",
",",
"messagesBufferSize",
":",
"messagesBufferSize",
",",
"serializer",
":",
"serializer",
",",
"heartbeatTimeout",
":",
"heartbeatTime",
",",
"appDieChan",
":",
"dieChan",
",",
"server",
":",
"server",
",",
"remoteService",
":",
"remoteService",
",",
"messageEncoder",
":",
"messageEncoder",
",",
"metricsReporters",
":",
"metricsReporters",
",",
"}",
"\n\n",
"return",
"h",
"\n",
"}"
] |
// NewHandlerService creates and returns a new handler service
|
[
"NewHandlerService",
"creates",
"and",
"returns",
"a",
"new",
"handler",
"service"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/service/handler.go#L84-L115
|
train
|
topfreegames/pitaya
|
service/handler.go
|
Dispatch
|
func (h *HandlerService) Dispatch(thread int) {
// TODO: This timer is being stopped multiple times, it probably doesn't need to be stopped here
defer timer.GlobalTicker.Stop()
for {
// Calls to remote servers block calls to local server
select {
case lm := <-h.chLocalProcess:
metrics.ReportMessageProcessDelayFromCtx(lm.ctx, h.metricsReporters, "local")
h.localProcess(lm.ctx, lm.agent, lm.route, lm.msg)
case rm := <-h.chRemoteProcess:
metrics.ReportMessageProcessDelayFromCtx(rm.ctx, h.metricsReporters, "remote")
h.remoteService.remoteProcess(rm.ctx, nil, rm.agent, rm.route, rm.msg)
case <-timer.GlobalTicker.C: // execute cron task
timer.Cron()
case t := <-timer.Manager.ChCreatedTimer: // new Timers
timer.AddTimer(t)
case id := <-timer.Manager.ChClosingTimer: // closing Timers
timer.RemoveTimer(id)
}
}
}
|
go
|
func (h *HandlerService) Dispatch(thread int) {
// TODO: This timer is being stopped multiple times, it probably doesn't need to be stopped here
defer timer.GlobalTicker.Stop()
for {
// Calls to remote servers block calls to local server
select {
case lm := <-h.chLocalProcess:
metrics.ReportMessageProcessDelayFromCtx(lm.ctx, h.metricsReporters, "local")
h.localProcess(lm.ctx, lm.agent, lm.route, lm.msg)
case rm := <-h.chRemoteProcess:
metrics.ReportMessageProcessDelayFromCtx(rm.ctx, h.metricsReporters, "remote")
h.remoteService.remoteProcess(rm.ctx, nil, rm.agent, rm.route, rm.msg)
case <-timer.GlobalTicker.C: // execute cron task
timer.Cron()
case t := <-timer.Manager.ChCreatedTimer: // new Timers
timer.AddTimer(t)
case id := <-timer.Manager.ChClosingTimer: // closing Timers
timer.RemoveTimer(id)
}
}
}
|
[
"func",
"(",
"h",
"*",
"HandlerService",
")",
"Dispatch",
"(",
"thread",
"int",
")",
"{",
"// TODO: This timer is being stopped multiple times, it probably doesn't need to be stopped here",
"defer",
"timer",
".",
"GlobalTicker",
".",
"Stop",
"(",
")",
"\n\n",
"for",
"{",
"// Calls to remote servers block calls to local server",
"select",
"{",
"case",
"lm",
":=",
"<-",
"h",
".",
"chLocalProcess",
":",
"metrics",
".",
"ReportMessageProcessDelayFromCtx",
"(",
"lm",
".",
"ctx",
",",
"h",
".",
"metricsReporters",
",",
"\"",
"\"",
")",
"\n",
"h",
".",
"localProcess",
"(",
"lm",
".",
"ctx",
",",
"lm",
".",
"agent",
",",
"lm",
".",
"route",
",",
"lm",
".",
"msg",
")",
"\n\n",
"case",
"rm",
":=",
"<-",
"h",
".",
"chRemoteProcess",
":",
"metrics",
".",
"ReportMessageProcessDelayFromCtx",
"(",
"rm",
".",
"ctx",
",",
"h",
".",
"metricsReporters",
",",
"\"",
"\"",
")",
"\n",
"h",
".",
"remoteService",
".",
"remoteProcess",
"(",
"rm",
".",
"ctx",
",",
"nil",
",",
"rm",
".",
"agent",
",",
"rm",
".",
"route",
",",
"rm",
".",
"msg",
")",
"\n\n",
"case",
"<-",
"timer",
".",
"GlobalTicker",
".",
"C",
":",
"// execute cron task",
"timer",
".",
"Cron",
"(",
")",
"\n\n",
"case",
"t",
":=",
"<-",
"timer",
".",
"Manager",
".",
"ChCreatedTimer",
":",
"// new Timers",
"timer",
".",
"AddTimer",
"(",
"t",
")",
"\n\n",
"case",
"id",
":=",
"<-",
"timer",
".",
"Manager",
".",
"ChClosingTimer",
":",
"// closing Timers",
"timer",
".",
"RemoveTimer",
"(",
"id",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Dispatch message to corresponding logic handler
|
[
"Dispatch",
"message",
"to",
"corresponding",
"logic",
"handler"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/service/handler.go#L118-L143
|
train
|
topfreegames/pitaya
|
service/handler.go
|
Handle
|
func (h *HandlerService) Handle(conn net.Conn) {
// create a client agent and startup write goroutine
a := agent.NewAgent(conn, h.decoder, h.encoder, h.serializer, h.heartbeatTimeout, h.messagesBufferSize, h.appDieChan, h.messageEncoder, h.metricsReporters)
// startup agent goroutine
go a.Handle()
logger.Log.Debugf("New session established: %s", a.String())
// guarantee agent related resource is destroyed
defer func() {
a.Session.Close()
logger.Log.Debugf("Session read goroutine exit, SessionID=%d, UID=%d", a.Session.ID(), a.Session.UID())
}()
// read loop
buf := make([]byte, 2048)
for {
n, err := conn.Read(buf)
if err != nil {
logger.Log.Debugf("Read message error: %s, session will be closed immediately", err.Error())
return
}
logger.Log.Debug("Received data on connection")
// (warning): decoder uses slice for performance, packet data should be copied before next Decode
packets, err := h.decoder.Decode(buf[:n])
if err != nil {
logger.Log.Errorf("Failed to decode message: %s", err.Error())
return
}
if len(packets) < 1 {
logger.Log.Warnf("Read no packets, data: %v", buf[:n])
continue
}
// process all packet
for i := range packets {
if err := h.processPacket(a, packets[i]); err != nil {
logger.Log.Errorf("Failed to process packet: %s", err.Error())
return
}
}
}
}
|
go
|
func (h *HandlerService) Handle(conn net.Conn) {
// create a client agent and startup write goroutine
a := agent.NewAgent(conn, h.decoder, h.encoder, h.serializer, h.heartbeatTimeout, h.messagesBufferSize, h.appDieChan, h.messageEncoder, h.metricsReporters)
// startup agent goroutine
go a.Handle()
logger.Log.Debugf("New session established: %s", a.String())
// guarantee agent related resource is destroyed
defer func() {
a.Session.Close()
logger.Log.Debugf("Session read goroutine exit, SessionID=%d, UID=%d", a.Session.ID(), a.Session.UID())
}()
// read loop
buf := make([]byte, 2048)
for {
n, err := conn.Read(buf)
if err != nil {
logger.Log.Debugf("Read message error: %s, session will be closed immediately", err.Error())
return
}
logger.Log.Debug("Received data on connection")
// (warning): decoder uses slice for performance, packet data should be copied before next Decode
packets, err := h.decoder.Decode(buf[:n])
if err != nil {
logger.Log.Errorf("Failed to decode message: %s", err.Error())
return
}
if len(packets) < 1 {
logger.Log.Warnf("Read no packets, data: %v", buf[:n])
continue
}
// process all packet
for i := range packets {
if err := h.processPacket(a, packets[i]); err != nil {
logger.Log.Errorf("Failed to process packet: %s", err.Error())
return
}
}
}
}
|
[
"func",
"(",
"h",
"*",
"HandlerService",
")",
"Handle",
"(",
"conn",
"net",
".",
"Conn",
")",
"{",
"// create a client agent and startup write goroutine",
"a",
":=",
"agent",
".",
"NewAgent",
"(",
"conn",
",",
"h",
".",
"decoder",
",",
"h",
".",
"encoder",
",",
"h",
".",
"serializer",
",",
"h",
".",
"heartbeatTimeout",
",",
"h",
".",
"messagesBufferSize",
",",
"h",
".",
"appDieChan",
",",
"h",
".",
"messageEncoder",
",",
"h",
".",
"metricsReporters",
")",
"\n\n",
"// startup agent goroutine",
"go",
"a",
".",
"Handle",
"(",
")",
"\n\n",
"logger",
".",
"Log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"a",
".",
"String",
"(",
")",
")",
"\n\n",
"// guarantee agent related resource is destroyed",
"defer",
"func",
"(",
")",
"{",
"a",
".",
"Session",
".",
"Close",
"(",
")",
"\n",
"logger",
".",
"Log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"a",
".",
"Session",
".",
"ID",
"(",
")",
",",
"a",
".",
"Session",
".",
"UID",
"(",
")",
")",
"\n",
"}",
"(",
")",
"\n\n",
"// read loop",
"buf",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"2048",
")",
"\n",
"for",
"{",
"n",
",",
"err",
":=",
"conn",
".",
"Read",
"(",
"buf",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"logger",
".",
"Log",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n\n",
"// (warning): decoder uses slice for performance, packet data should be copied before next Decode",
"packets",
",",
"err",
":=",
"h",
".",
"decoder",
".",
"Decode",
"(",
"buf",
"[",
":",
"n",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"packets",
")",
"<",
"1",
"{",
"logger",
".",
"Log",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"buf",
"[",
":",
"n",
"]",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"// process all packet",
"for",
"i",
":=",
"range",
"packets",
"{",
"if",
"err",
":=",
"h",
".",
"processPacket",
"(",
"a",
",",
"packets",
"[",
"i",
"]",
")",
";",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Handle handles messages from a conn
|
[
"Handle",
"handles",
"messages",
"from",
"a",
"conn"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/service/handler.go#L166-L212
|
train
|
topfreegames/pitaya
|
service/handler.go
|
DumpServices
|
func (h *HandlerService) DumpServices() {
for name := range handlers {
logger.Log.Infof("registered handler %s, isRawArg: %s", name, handlers[name].IsRawArg)
}
}
|
go
|
func (h *HandlerService) DumpServices() {
for name := range handlers {
logger.Log.Infof("registered handler %s, isRawArg: %s", name, handlers[name].IsRawArg)
}
}
|
[
"func",
"(",
"h",
"*",
"HandlerService",
")",
"DumpServices",
"(",
")",
"{",
"for",
"name",
":=",
"range",
"handlers",
"{",
"logger",
".",
"Log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"name",
",",
"handlers",
"[",
"name",
"]",
".",
"IsRawArg",
")",
"\n",
"}",
"\n",
"}"
] |
// DumpServices outputs all registered services
|
[
"DumpServices",
"outputs",
"all",
"registered",
"services"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/service/handler.go#L332-L336
|
train
|
topfreegames/pitaya
|
service/handler.go
|
Docs
|
func (h *HandlerService) Docs(getPtrNames bool) (map[string]interface{}, error) {
if h == nil {
return map[string]interface{}{}, nil
}
return docgenerator.HandlersDocs(h.server.Type, h.services, getPtrNames)
}
|
go
|
func (h *HandlerService) Docs(getPtrNames bool) (map[string]interface{}, error) {
if h == nil {
return map[string]interface{}{}, nil
}
return docgenerator.HandlersDocs(h.server.Type, h.services, getPtrNames)
}
|
[
"func",
"(",
"h",
"*",
"HandlerService",
")",
"Docs",
"(",
"getPtrNames",
"bool",
")",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"if",
"h",
"==",
"nil",
"{",
"return",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"}",
",",
"nil",
"\n",
"}",
"\n",
"return",
"docgenerator",
".",
"HandlersDocs",
"(",
"h",
".",
"server",
".",
"Type",
",",
"h",
".",
"services",
",",
"getPtrNames",
")",
"\n",
"}"
] |
// Docs returns documentation for handlers
|
[
"Docs",
"returns",
"documentation",
"for",
"handlers"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/service/handler.go#L339-L344
|
train
|
topfreegames/pitaya
|
worker/worker.go
|
EnqueueRPC
|
func (w *Worker) EnqueueRPC(
routeStr string,
metadata map[string]interface{},
reply, arg proto.Message,
) (jid string, err error) {
opts := w.enqueueOptions(w.opts)
return workers.EnqueueWithOptions(rpcQueue, class, &rpcInfo{
Route: routeStr,
Metadata: metadata,
Arg: arg,
Reply: reply,
}, opts)
}
|
go
|
func (w *Worker) EnqueueRPC(
routeStr string,
metadata map[string]interface{},
reply, arg proto.Message,
) (jid string, err error) {
opts := w.enqueueOptions(w.opts)
return workers.EnqueueWithOptions(rpcQueue, class, &rpcInfo{
Route: routeStr,
Metadata: metadata,
Arg: arg,
Reply: reply,
}, opts)
}
|
[
"func",
"(",
"w",
"*",
"Worker",
")",
"EnqueueRPC",
"(",
"routeStr",
"string",
",",
"metadata",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"reply",
",",
"arg",
"proto",
".",
"Message",
",",
")",
"(",
"jid",
"string",
",",
"err",
"error",
")",
"{",
"opts",
":=",
"w",
".",
"enqueueOptions",
"(",
"w",
".",
"opts",
")",
"\n",
"return",
"workers",
".",
"EnqueueWithOptions",
"(",
"rpcQueue",
",",
"class",
",",
"&",
"rpcInfo",
"{",
"Route",
":",
"routeStr",
",",
"Metadata",
":",
"metadata",
",",
"Arg",
":",
"arg",
",",
"Reply",
":",
"reply",
",",
"}",
",",
"opts",
")",
"\n",
"}"
] |
// EnqueueRPC enqueues rpc job to worker
|
[
"EnqueueRPC",
"enqueues",
"rpc",
"job",
"to",
"worker"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/worker/worker.go#L83-L95
|
train
|
topfreegames/pitaya
|
worker/worker.go
|
RegisterRPCJob
|
func (w *Worker) RegisterRPCJob(rpcJob RPCJob) error {
if w.registered {
return constants.ErrRPCJobAlreadyRegistered
}
job := w.parsedRPCJob(rpcJob)
workers.Process(rpcQueue, job, w.concurrency)
w.registered = true
return nil
}
|
go
|
func (w *Worker) RegisterRPCJob(rpcJob RPCJob) error {
if w.registered {
return constants.ErrRPCJobAlreadyRegistered
}
job := w.parsedRPCJob(rpcJob)
workers.Process(rpcQueue, job, w.concurrency)
w.registered = true
return nil
}
|
[
"func",
"(",
"w",
"*",
"Worker",
")",
"RegisterRPCJob",
"(",
"rpcJob",
"RPCJob",
")",
"error",
"{",
"if",
"w",
".",
"registered",
"{",
"return",
"constants",
".",
"ErrRPCJobAlreadyRegistered",
"\n",
"}",
"\n\n",
"job",
":=",
"w",
".",
"parsedRPCJob",
"(",
"rpcJob",
")",
"\n",
"workers",
".",
"Process",
"(",
"rpcQueue",
",",
"job",
",",
"w",
".",
"concurrency",
")",
"\n",
"w",
".",
"registered",
"=",
"true",
"\n",
"return",
"nil",
"\n",
"}"
] |
// RegisterRPCJob registers a RPC job
|
[
"RegisterRPCJob",
"registers",
"a",
"RPC",
"job"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/worker/worker.go#L113-L122
|
train
|
topfreegames/pitaya
|
kick.go
|
SendKickToUsers
|
func SendKickToUsers(uids []string, frontendType string) ([]string, error) {
if !app.server.Frontend && frontendType == "" {
return uids, constants.ErrFrontendTypeNotSpecified
}
var notKickedUids []string
for _, uid := range uids {
if s := session.GetSessionByUID(uid); s != nil {
if err := s.Kick(context.Background()); err != nil {
notKickedUids = append(notKickedUids, uid)
logger.Log.Errorf("Session kick error, ID=%d, UID=%d, ERROR=%s", s.ID(), s.UID(), err.Error())
}
} else if app.rpcClient != nil {
kick := &protos.KickMsg{UserId: uid}
if err := app.rpcClient.SendKick(uid, frontendType, kick); err != nil {
notKickedUids = append(notKickedUids, uid)
logger.Log.Errorf("RPCClient send kick error, UID=%d, SvType=%s, Error=%s", uid, frontendType, err.Error())
}
} else {
notKickedUids = append(notKickedUids, uid)
}
}
if len(notKickedUids) != 0 {
return notKickedUids, constants.ErrKickingUsers
}
return nil, nil
}
|
go
|
func SendKickToUsers(uids []string, frontendType string) ([]string, error) {
if !app.server.Frontend && frontendType == "" {
return uids, constants.ErrFrontendTypeNotSpecified
}
var notKickedUids []string
for _, uid := range uids {
if s := session.GetSessionByUID(uid); s != nil {
if err := s.Kick(context.Background()); err != nil {
notKickedUids = append(notKickedUids, uid)
logger.Log.Errorf("Session kick error, ID=%d, UID=%d, ERROR=%s", s.ID(), s.UID(), err.Error())
}
} else if app.rpcClient != nil {
kick := &protos.KickMsg{UserId: uid}
if err := app.rpcClient.SendKick(uid, frontendType, kick); err != nil {
notKickedUids = append(notKickedUids, uid)
logger.Log.Errorf("RPCClient send kick error, UID=%d, SvType=%s, Error=%s", uid, frontendType, err.Error())
}
} else {
notKickedUids = append(notKickedUids, uid)
}
}
if len(notKickedUids) != 0 {
return notKickedUids, constants.ErrKickingUsers
}
return nil, nil
}
|
[
"func",
"SendKickToUsers",
"(",
"uids",
"[",
"]",
"string",
",",
"frontendType",
"string",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"if",
"!",
"app",
".",
"server",
".",
"Frontend",
"&&",
"frontendType",
"==",
"\"",
"\"",
"{",
"return",
"uids",
",",
"constants",
".",
"ErrFrontendTypeNotSpecified",
"\n",
"}",
"\n\n",
"var",
"notKickedUids",
"[",
"]",
"string",
"\n\n",
"for",
"_",
",",
"uid",
":=",
"range",
"uids",
"{",
"if",
"s",
":=",
"session",
".",
"GetSessionByUID",
"(",
"uid",
")",
";",
"s",
"!=",
"nil",
"{",
"if",
"err",
":=",
"s",
".",
"Kick",
"(",
"context",
".",
"Background",
"(",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"notKickedUids",
"=",
"append",
"(",
"notKickedUids",
",",
"uid",
")",
"\n",
"logger",
".",
"Log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"s",
".",
"ID",
"(",
")",
",",
"s",
".",
"UID",
"(",
")",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"else",
"if",
"app",
".",
"rpcClient",
"!=",
"nil",
"{",
"kick",
":=",
"&",
"protos",
".",
"KickMsg",
"{",
"UserId",
":",
"uid",
"}",
"\n",
"if",
"err",
":=",
"app",
".",
"rpcClient",
".",
"SendKick",
"(",
"uid",
",",
"frontendType",
",",
"kick",
")",
";",
"err",
"!=",
"nil",
"{",
"notKickedUids",
"=",
"append",
"(",
"notKickedUids",
",",
"uid",
")",
"\n",
"logger",
".",
"Log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"uid",
",",
"frontendType",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"notKickedUids",
"=",
"append",
"(",
"notKickedUids",
",",
"uid",
")",
"\n",
"}",
"\n\n",
"}",
"\n\n",
"if",
"len",
"(",
"notKickedUids",
")",
"!=",
"0",
"{",
"return",
"notKickedUids",
",",
"constants",
".",
"ErrKickingUsers",
"\n",
"}",
"\n\n",
"return",
"nil",
",",
"nil",
"\n",
"}"
] |
// SendKickToUsers sends kick to an user array
|
[
"SendKickToUsers",
"sends",
"kick",
"to",
"an",
"user",
"array"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/kick.go#L33-L63
|
train
|
topfreegames/pitaya
|
client/protoclient.go
|
unpackDescriptor
|
func unpackDescriptor(compressedDescriptor []byte) (*protobuf.FileDescriptorProto, error) {
r, err := gzip.NewReader(bytes.NewReader(compressedDescriptor))
if err != nil {
return nil, err
}
defer r.Close()
b, err := ioutil.ReadAll(r)
if err != nil {
return nil, err
}
var fileDescriptorProto protobuf.FileDescriptorProto
if err = proto.Unmarshal(b, &fileDescriptorProto); err != nil {
return nil, err
}
return &fileDescriptorProto, nil
}
|
go
|
func unpackDescriptor(compressedDescriptor []byte) (*protobuf.FileDescriptorProto, error) {
r, err := gzip.NewReader(bytes.NewReader(compressedDescriptor))
if err != nil {
return nil, err
}
defer r.Close()
b, err := ioutil.ReadAll(r)
if err != nil {
return nil, err
}
var fileDescriptorProto protobuf.FileDescriptorProto
if err = proto.Unmarshal(b, &fileDescriptorProto); err != nil {
return nil, err
}
return &fileDescriptorProto, nil
}
|
[
"func",
"unpackDescriptor",
"(",
"compressedDescriptor",
"[",
"]",
"byte",
")",
"(",
"*",
"protobuf",
".",
"FileDescriptorProto",
",",
"error",
")",
"{",
"r",
",",
"err",
":=",
"gzip",
".",
"NewReader",
"(",
"bytes",
".",
"NewReader",
"(",
"compressedDescriptor",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"r",
".",
"Close",
"(",
")",
"\n\n",
"b",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"fileDescriptorProto",
"protobuf",
".",
"FileDescriptorProto",
"\n\n",
"if",
"err",
"=",
"proto",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"fileDescriptorProto",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"fileDescriptorProto",
",",
"nil",
"\n",
"}"
] |
// Receive a compressed byte slice and unpack it to a FileDescriptorProto
|
[
"Receive",
"a",
"compressed",
"byte",
"slice",
"and",
"unpack",
"it",
"to",
"a",
"FileDescriptorProto"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/client/protoclient.go#L75-L94
|
train
|
topfreegames/pitaya
|
client/protoclient.go
|
buildProtosFromDescriptor
|
func (pc *ProtoClient) buildProtosFromDescriptor(descriptorArray []*protobuf.FileDescriptorProto) error {
descriptorsMap := make(map[string]*desc.MessageDescriptor)
descriptors, err := desc.CreateFileDescriptors(descriptorArray)
if err != nil {
return err
}
for name := range pc.descriptorsNames {
for _, v := range descriptors {
message := v.FindMessage(name)
if message != nil {
descriptorsMap[name] = message
}
}
}
for name, cmd := range pc.info.Commands {
if msg, ok := descriptorsMap[cmd.input]; ok {
pc.info.Commands[name].inputMsgDescriptor = msg
}
if msg, ok := descriptorsMap[cmd.output]; ok {
pc.info.Commands[name].outputMsgDescriptor = msg
}
}
return nil
}
|
go
|
func (pc *ProtoClient) buildProtosFromDescriptor(descriptorArray []*protobuf.FileDescriptorProto) error {
descriptorsMap := make(map[string]*desc.MessageDescriptor)
descriptors, err := desc.CreateFileDescriptors(descriptorArray)
if err != nil {
return err
}
for name := range pc.descriptorsNames {
for _, v := range descriptors {
message := v.FindMessage(name)
if message != nil {
descriptorsMap[name] = message
}
}
}
for name, cmd := range pc.info.Commands {
if msg, ok := descriptorsMap[cmd.input]; ok {
pc.info.Commands[name].inputMsgDescriptor = msg
}
if msg, ok := descriptorsMap[cmd.output]; ok {
pc.info.Commands[name].outputMsgDescriptor = msg
}
}
return nil
}
|
[
"func",
"(",
"pc",
"*",
"ProtoClient",
")",
"buildProtosFromDescriptor",
"(",
"descriptorArray",
"[",
"]",
"*",
"protobuf",
".",
"FileDescriptorProto",
")",
"error",
"{",
"descriptorsMap",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"desc",
".",
"MessageDescriptor",
")",
"\n\n",
"descriptors",
",",
"err",
":=",
"desc",
".",
"CreateFileDescriptors",
"(",
"descriptorArray",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"for",
"name",
":=",
"range",
"pc",
".",
"descriptorsNames",
"{",
"for",
"_",
",",
"v",
":=",
"range",
"descriptors",
"{",
"message",
":=",
"v",
".",
"FindMessage",
"(",
"name",
")",
"\n",
"if",
"message",
"!=",
"nil",
"{",
"descriptorsMap",
"[",
"name",
"]",
"=",
"message",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"for",
"name",
",",
"cmd",
":=",
"range",
"pc",
".",
"info",
".",
"Commands",
"{",
"if",
"msg",
",",
"ok",
":=",
"descriptorsMap",
"[",
"cmd",
".",
"input",
"]",
";",
"ok",
"{",
"pc",
".",
"info",
".",
"Commands",
"[",
"name",
"]",
".",
"inputMsgDescriptor",
"=",
"msg",
"\n",
"}",
"\n",
"if",
"msg",
",",
"ok",
":=",
"descriptorsMap",
"[",
"cmd",
".",
"output",
"]",
";",
"ok",
"{",
"pc",
".",
"info",
".",
"Commands",
"[",
"name",
"]",
".",
"outputMsgDescriptor",
"=",
"msg",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Receive an array of descriptors in binary format. The function creates the
// protobuffer from this data and associates it to the message.
|
[
"Receive",
"an",
"array",
"of",
"descriptors",
"in",
"binary",
"format",
".",
"The",
"function",
"creates",
"the",
"protobuffer",
"from",
"this",
"data",
"and",
"associates",
"it",
"to",
"the",
"message",
"."
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/client/protoclient.go#L98-L126
|
train
|
topfreegames/pitaya
|
client/protoclient.go
|
getOutputInputNames
|
func getOutputInputNames(command map[string]interface{}) (string, string, error) {
outputName := ""
inputName := ""
in := command["input"]
inputDocs, ok := in.(map[string]interface{})
if ok {
for k := range inputDocs {
if strings.Contains(k, "proto") {
inputName = strings.Replace(k, "*", "", 1)
}
}
}
out := command["output"]
outputDocsArr := out.([]interface{})
outputDocs, ok := outputDocsArr[0].(map[string]interface{})
if ok {
for k := range outputDocs {
if strings.Contains(k, "proto") {
outputName = strings.Replace(k, "*", "", 1)
}
}
}
return inputName, outputName, nil
}
|
go
|
func getOutputInputNames(command map[string]interface{}) (string, string, error) {
outputName := ""
inputName := ""
in := command["input"]
inputDocs, ok := in.(map[string]interface{})
if ok {
for k := range inputDocs {
if strings.Contains(k, "proto") {
inputName = strings.Replace(k, "*", "", 1)
}
}
}
out := command["output"]
outputDocsArr := out.([]interface{})
outputDocs, ok := outputDocsArr[0].(map[string]interface{})
if ok {
for k := range outputDocs {
if strings.Contains(k, "proto") {
outputName = strings.Replace(k, "*", "", 1)
}
}
}
return inputName, outputName, nil
}
|
[
"func",
"getOutputInputNames",
"(",
"command",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"(",
"string",
",",
"string",
",",
"error",
")",
"{",
"outputName",
":=",
"\"",
"\"",
"\n",
"inputName",
":=",
"\"",
"\"",
"\n\n",
"in",
":=",
"command",
"[",
"\"",
"\"",
"]",
"\n",
"inputDocs",
",",
"ok",
":=",
"in",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"if",
"ok",
"{",
"for",
"k",
":=",
"range",
"inputDocs",
"{",
"if",
"strings",
".",
"Contains",
"(",
"k",
",",
"\"",
"\"",
")",
"{",
"inputName",
"=",
"strings",
".",
"Replace",
"(",
"k",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"1",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"out",
":=",
"command",
"[",
"\"",
"\"",
"]",
"\n",
"outputDocsArr",
":=",
"out",
".",
"(",
"[",
"]",
"interface",
"{",
"}",
")",
"\n",
"outputDocs",
",",
"ok",
":=",
"outputDocsArr",
"[",
"0",
"]",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"if",
"ok",
"{",
"for",
"k",
":=",
"range",
"outputDocs",
"{",
"if",
"strings",
".",
"Contains",
"(",
"k",
",",
"\"",
"\"",
")",
"{",
"outputName",
"=",
"strings",
".",
"Replace",
"(",
"k",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"1",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"inputName",
",",
"outputName",
",",
"nil",
"\n",
"}"
] |
// Receives each entry from the Unmarshal json from the Docs and read the inputs and
// outputs associated with it. Return the output type, the input and the error.
|
[
"Receives",
"each",
"entry",
"from",
"the",
"Unmarshal",
"json",
"from",
"the",
"Docs",
"and",
"read",
"the",
"inputs",
"and",
"outputs",
"associated",
"with",
"it",
".",
"Return",
"the",
"output",
"type",
"the",
"input",
"and",
"the",
"error",
"."
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/client/protoclient.go#L130-L156
|
train
|
topfreegames/pitaya
|
client/protoclient.go
|
getKeys
|
func getKeys(info map[string]interface{}, keysSet map[string]bool) {
for k, v := range info {
if strings.Contains(k, "*") {
kew := strings.Replace(k, "*", "", 1)
keysSet[kew] = true
}
listofouts, ok := v.([]interface{})
if ok {
for i := range listofouts {
aux, ok := listofouts[i].(map[string]interface{})
if !ok {
continue
}
getKeys(aux, keysSet)
}
}
if aux, ok := v.(map[string]interface{}); ok {
getKeys(aux, keysSet)
}
}
}
|
go
|
func getKeys(info map[string]interface{}, keysSet map[string]bool) {
for k, v := range info {
if strings.Contains(k, "*") {
kew := strings.Replace(k, "*", "", 1)
keysSet[kew] = true
}
listofouts, ok := v.([]interface{})
if ok {
for i := range listofouts {
aux, ok := listofouts[i].(map[string]interface{})
if !ok {
continue
}
getKeys(aux, keysSet)
}
}
if aux, ok := v.(map[string]interface{}); ok {
getKeys(aux, keysSet)
}
}
}
|
[
"func",
"getKeys",
"(",
"info",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"keysSet",
"map",
"[",
"string",
"]",
"bool",
")",
"{",
"for",
"k",
",",
"v",
":=",
"range",
"info",
"{",
"if",
"strings",
".",
"Contains",
"(",
"k",
",",
"\"",
"\"",
")",
"{",
"kew",
":=",
"strings",
".",
"Replace",
"(",
"k",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"1",
")",
"\n",
"keysSet",
"[",
"kew",
"]",
"=",
"true",
"\n",
"}",
"\n\n",
"listofouts",
",",
"ok",
":=",
"v",
".",
"(",
"[",
"]",
"interface",
"{",
"}",
")",
"\n",
"if",
"ok",
"{",
"for",
"i",
":=",
"range",
"listofouts",
"{",
"aux",
",",
"ok",
":=",
"listofouts",
"[",
"i",
"]",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"if",
"!",
"ok",
"{",
"continue",
"\n",
"}",
"\n",
"getKeys",
"(",
"aux",
",",
"keysSet",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"aux",
",",
"ok",
":=",
"v",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
";",
"ok",
"{",
"getKeys",
"(",
"aux",
",",
"keysSet",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Get recursively all protos needed in a Unmarshal json.
|
[
"Get",
"recursively",
"all",
"protos",
"needed",
"in",
"a",
"Unmarshal",
"json",
"."
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/client/protoclient.go#L159-L181
|
train
|
topfreegames/pitaya
|
client/protoclient.go
|
newProto
|
func newProto(docslogLevel logrus.Level, requestTimeout ...time.Duration) *ProtoClient {
return &ProtoClient{
Client: *New(docslogLevel, requestTimeout...),
descriptorsNames: make(map[string]bool),
info: ProtoBufferInfo{
Commands: make(map[string]*Command),
},
docsRoute: "",
descriptorsRoute: "",
IncomingMsgChan: make(chan *message.Message, 10),
closeChan: make(chan bool),
}
}
|
go
|
func newProto(docslogLevel logrus.Level, requestTimeout ...time.Duration) *ProtoClient {
return &ProtoClient{
Client: *New(docslogLevel, requestTimeout...),
descriptorsNames: make(map[string]bool),
info: ProtoBufferInfo{
Commands: make(map[string]*Command),
},
docsRoute: "",
descriptorsRoute: "",
IncomingMsgChan: make(chan *message.Message, 10),
closeChan: make(chan bool),
}
}
|
[
"func",
"newProto",
"(",
"docslogLevel",
"logrus",
".",
"Level",
",",
"requestTimeout",
"...",
"time",
".",
"Duration",
")",
"*",
"ProtoClient",
"{",
"return",
"&",
"ProtoClient",
"{",
"Client",
":",
"*",
"New",
"(",
"docslogLevel",
",",
"requestTimeout",
"...",
")",
",",
"descriptorsNames",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"bool",
")",
",",
"info",
":",
"ProtoBufferInfo",
"{",
"Commands",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"Command",
")",
",",
"}",
",",
"docsRoute",
":",
"\"",
"\"",
",",
"descriptorsRoute",
":",
"\"",
"\"",
",",
"IncomingMsgChan",
":",
"make",
"(",
"chan",
"*",
"message",
".",
"Message",
",",
"10",
")",
",",
"closeChan",
":",
"make",
"(",
"chan",
"bool",
")",
",",
"}",
"\n",
"}"
] |
// Return the basic structure for the ProtoClient struct.
|
[
"Return",
"the",
"basic",
"structure",
"for",
"the",
"ProtoClient",
"struct",
"."
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/client/protoclient.go#L285-L297
|
train
|
topfreegames/pitaya
|
client/protoclient.go
|
NewProto
|
func NewProto(docsRoute string, docslogLevel logrus.Level, requestTimeout ...time.Duration) *ProtoClient {
newclient := newProto(docslogLevel, requestTimeout...)
newclient.docsRoute = docsRoute
return newclient
}
|
go
|
func NewProto(docsRoute string, docslogLevel logrus.Level, requestTimeout ...time.Duration) *ProtoClient {
newclient := newProto(docslogLevel, requestTimeout...)
newclient.docsRoute = docsRoute
return newclient
}
|
[
"func",
"NewProto",
"(",
"docsRoute",
"string",
",",
"docslogLevel",
"logrus",
".",
"Level",
",",
"requestTimeout",
"...",
"time",
".",
"Duration",
")",
"*",
"ProtoClient",
"{",
"newclient",
":=",
"newProto",
"(",
"docslogLevel",
",",
"requestTimeout",
"...",
")",
"\n",
"newclient",
".",
"docsRoute",
"=",
"docsRoute",
"\n",
"return",
"newclient",
"\n",
"}"
] |
// NewProto returns a new protoclient with the auto documentation route.
|
[
"NewProto",
"returns",
"a",
"new",
"protoclient",
"with",
"the",
"auto",
"documentation",
"route",
"."
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/client/protoclient.go#L300-L304
|
train
|
topfreegames/pitaya
|
client/protoclient.go
|
NewWithDescriptor
|
func NewWithDescriptor(descriptorsRoute string, docsRoute string, docslogLevel logrus.Level, requestTimeout ...time.Duration) *ProtoClient {
newclient := newProto(docslogLevel, requestTimeout...)
newclient.docsRoute = docsRoute
newclient.descriptorsRoute = descriptorsRoute
return newclient
}
|
go
|
func NewWithDescriptor(descriptorsRoute string, docsRoute string, docslogLevel logrus.Level, requestTimeout ...time.Duration) *ProtoClient {
newclient := newProto(docslogLevel, requestTimeout...)
newclient.docsRoute = docsRoute
newclient.descriptorsRoute = descriptorsRoute
return newclient
}
|
[
"func",
"NewWithDescriptor",
"(",
"descriptorsRoute",
"string",
",",
"docsRoute",
"string",
",",
"docslogLevel",
"logrus",
".",
"Level",
",",
"requestTimeout",
"...",
"time",
".",
"Duration",
")",
"*",
"ProtoClient",
"{",
"newclient",
":=",
"newProto",
"(",
"docslogLevel",
",",
"requestTimeout",
"...",
")",
"\n",
"newclient",
".",
"docsRoute",
"=",
"docsRoute",
"\n",
"newclient",
".",
"descriptorsRoute",
"=",
"descriptorsRoute",
"\n",
"return",
"newclient",
"\n",
"}"
] |
// NewWithDescriptor returns a new protoclient with the descriptors route and
// auto documentation route.
|
[
"NewWithDescriptor",
"returns",
"a",
"new",
"protoclient",
"with",
"the",
"descriptors",
"route",
"and",
"auto",
"documentation",
"route",
"."
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/client/protoclient.go#L308-L313
|
train
|
topfreegames/pitaya
|
client/protoclient.go
|
LoadServerInfo
|
func (pc *ProtoClient) LoadServerInfo(addr string) error {
pc.ready = false
if err := pc.Client.ConnectToTLS(addr, true); err != nil {
if err.Error() == "EOF" {
if err := pc.Client.ConnectTo(addr); err != nil {
return err
}
} else {
return err
}
}
// request doc info
_, err := pc.SendRequest(pc.docsRoute, make([]byte, 0))
if err != nil {
return err
}
response := <-pc.Client.IncomingMsgChan
docs := &protos.Doc{}
if err := proto.Unmarshal(response.Data, docs); err != nil {
return err
}
if err := pc.getDescriptors(docs.Doc); err != nil {
return err
}
pc.Disconnect()
pc.ready = true
return nil
}
|
go
|
func (pc *ProtoClient) LoadServerInfo(addr string) error {
pc.ready = false
if err := pc.Client.ConnectToTLS(addr, true); err != nil {
if err.Error() == "EOF" {
if err := pc.Client.ConnectTo(addr); err != nil {
return err
}
} else {
return err
}
}
// request doc info
_, err := pc.SendRequest(pc.docsRoute, make([]byte, 0))
if err != nil {
return err
}
response := <-pc.Client.IncomingMsgChan
docs := &protos.Doc{}
if err := proto.Unmarshal(response.Data, docs); err != nil {
return err
}
if err := pc.getDescriptors(docs.Doc); err != nil {
return err
}
pc.Disconnect()
pc.ready = true
return nil
}
|
[
"func",
"(",
"pc",
"*",
"ProtoClient",
")",
"LoadServerInfo",
"(",
"addr",
"string",
")",
"error",
"{",
"pc",
".",
"ready",
"=",
"false",
"\n\n",
"if",
"err",
":=",
"pc",
".",
"Client",
".",
"ConnectToTLS",
"(",
"addr",
",",
"true",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"err",
".",
"Error",
"(",
")",
"==",
"\"",
"\"",
"{",
"if",
"err",
":=",
"pc",
".",
"Client",
".",
"ConnectTo",
"(",
"addr",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"// request doc info",
"_",
",",
"err",
":=",
"pc",
".",
"SendRequest",
"(",
"pc",
".",
"docsRoute",
",",
"make",
"(",
"[",
"]",
"byte",
",",
"0",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"response",
":=",
"<-",
"pc",
".",
"Client",
".",
"IncomingMsgChan",
"\n\n",
"docs",
":=",
"&",
"protos",
".",
"Doc",
"{",
"}",
"\n",
"if",
"err",
":=",
"proto",
".",
"Unmarshal",
"(",
"response",
".",
"Data",
",",
"docs",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"pc",
".",
"getDescriptors",
"(",
"docs",
".",
"Doc",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"pc",
".",
"Disconnect",
"(",
")",
"\n",
"pc",
".",
"ready",
"=",
"true",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// LoadServerInfo load commands information from the server. Addr is the
// server address.
|
[
"LoadServerInfo",
"load",
"commands",
"information",
"from",
"the",
"server",
".",
"Addr",
"is",
"the",
"server",
"address",
"."
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/client/protoclient.go#L317-L350
|
train
|
topfreegames/pitaya
|
client/protoclient.go
|
Disconnect
|
func (pc *ProtoClient) Disconnect() {
pc.Client.Disconnect()
if pc.ready {
pc.closeChan <- true
}
}
|
go
|
func (pc *ProtoClient) Disconnect() {
pc.Client.Disconnect()
if pc.ready {
pc.closeChan <- true
}
}
|
[
"func",
"(",
"pc",
"*",
"ProtoClient",
")",
"Disconnect",
"(",
")",
"{",
"pc",
".",
"Client",
".",
"Disconnect",
"(",
")",
"\n",
"if",
"pc",
".",
"ready",
"{",
"pc",
".",
"closeChan",
"<-",
"true",
"\n",
"}",
"\n",
"}"
] |
// Disconnect the client
|
[
"Disconnect",
"the",
"client"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/client/protoclient.go#L353-L358
|
train
|
topfreegames/pitaya
|
client/protoclient.go
|
waitForData
|
func (pc *ProtoClient) waitForData() {
for {
select {
case response := <-pc.Client.IncomingMsgChan:
inputMsg := dynamic.NewMessage(pc.expectedInputDescriptor)
msg, ok := pc.info.Commands[response.Route]
if ok {
inputMsg = dynamic.NewMessage(msg.outputMsgDescriptor)
} else {
pc.expectedInputDescriptor = nil
}
if response.Err {
errMsg := &protos.Error{}
err := proto.Unmarshal(response.Data, errMsg)
if err != nil {
logger.Log.Errorf("Erro decode error data: %s", string(response.Data))
continue
}
response.Data, err = json.Marshal(errMsg)
if err != nil {
logger.Log.Errorf("Erro encode error to json: %s", string(response.Data))
continue
}
pc.IncomingMsgChan <- response
continue
}
if inputMsg == nil {
logger.Log.Errorf("Not expected data: %s", string(response.Data))
continue
}
err := inputMsg.Unmarshal(response.Data)
if err != nil {
logger.Log.Errorf("Erro decode data: %s", string(response.Data))
continue
}
data, err2 := inputMsg.MarshalJSON()
if err2 != nil {
logger.Log.Errorf("Erro encode data to json: %s", string(response.Data))
continue
}
response.Data = data
pc.IncomingMsgChan <- response
case <-pc.closeChan:
return
}
}
}
|
go
|
func (pc *ProtoClient) waitForData() {
for {
select {
case response := <-pc.Client.IncomingMsgChan:
inputMsg := dynamic.NewMessage(pc.expectedInputDescriptor)
msg, ok := pc.info.Commands[response.Route]
if ok {
inputMsg = dynamic.NewMessage(msg.outputMsgDescriptor)
} else {
pc.expectedInputDescriptor = nil
}
if response.Err {
errMsg := &protos.Error{}
err := proto.Unmarshal(response.Data, errMsg)
if err != nil {
logger.Log.Errorf("Erro decode error data: %s", string(response.Data))
continue
}
response.Data, err = json.Marshal(errMsg)
if err != nil {
logger.Log.Errorf("Erro encode error to json: %s", string(response.Data))
continue
}
pc.IncomingMsgChan <- response
continue
}
if inputMsg == nil {
logger.Log.Errorf("Not expected data: %s", string(response.Data))
continue
}
err := inputMsg.Unmarshal(response.Data)
if err != nil {
logger.Log.Errorf("Erro decode data: %s", string(response.Data))
continue
}
data, err2 := inputMsg.MarshalJSON()
if err2 != nil {
logger.Log.Errorf("Erro encode data to json: %s", string(response.Data))
continue
}
response.Data = data
pc.IncomingMsgChan <- response
case <-pc.closeChan:
return
}
}
}
|
[
"func",
"(",
"pc",
"*",
"ProtoClient",
")",
"waitForData",
"(",
")",
"{",
"for",
"{",
"select",
"{",
"case",
"response",
":=",
"<-",
"pc",
".",
"Client",
".",
"IncomingMsgChan",
":",
"inputMsg",
":=",
"dynamic",
".",
"NewMessage",
"(",
"pc",
".",
"expectedInputDescriptor",
")",
"\n\n",
"msg",
",",
"ok",
":=",
"pc",
".",
"info",
".",
"Commands",
"[",
"response",
".",
"Route",
"]",
"\n",
"if",
"ok",
"{",
"inputMsg",
"=",
"dynamic",
".",
"NewMessage",
"(",
"msg",
".",
"outputMsgDescriptor",
")",
"\n",
"}",
"else",
"{",
"pc",
".",
"expectedInputDescriptor",
"=",
"nil",
"\n",
"}",
"\n\n",
"if",
"response",
".",
"Err",
"{",
"errMsg",
":=",
"&",
"protos",
".",
"Error",
"{",
"}",
"\n",
"err",
":=",
"proto",
".",
"Unmarshal",
"(",
"response",
".",
"Data",
",",
"errMsg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"string",
"(",
"response",
".",
"Data",
")",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"response",
".",
"Data",
",",
"err",
"=",
"json",
".",
"Marshal",
"(",
"errMsg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"string",
"(",
"response",
".",
"Data",
")",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"pc",
".",
"IncomingMsgChan",
"<-",
"response",
"\n",
"continue",
"\n",
"}",
"\n\n",
"if",
"inputMsg",
"==",
"nil",
"{",
"logger",
".",
"Log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"string",
"(",
"response",
".",
"Data",
")",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"err",
":=",
"inputMsg",
".",
"Unmarshal",
"(",
"response",
".",
"Data",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"string",
"(",
"response",
".",
"Data",
")",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"data",
",",
"err2",
":=",
"inputMsg",
".",
"MarshalJSON",
"(",
")",
"\n",
"if",
"err2",
"!=",
"nil",
"{",
"logger",
".",
"Log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"string",
"(",
"response",
".",
"Data",
")",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"response",
".",
"Data",
"=",
"data",
"\n",
"pc",
".",
"IncomingMsgChan",
"<-",
"response",
"\n",
"case",
"<-",
"pc",
".",
"closeChan",
":",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Wait for new messages from the server or the connection end. If the menssage
// has a response.Route, it decodes based on it. If not, it will try to decode
// the menssage using the last expected response.
|
[
"Wait",
"for",
"new",
"messages",
"from",
"the",
"server",
"or",
"the",
"connection",
"end",
".",
"If",
"the",
"menssage",
"has",
"a",
"response",
".",
"Route",
"it",
"decodes",
"based",
"on",
"it",
".",
"If",
"not",
"it",
"will",
"try",
"to",
"decode",
"the",
"menssage",
"using",
"the",
"last",
"expected",
"response",
"."
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/client/protoclient.go#L363-L416
|
train
|
topfreegames/pitaya
|
client/protoclient.go
|
LoadInfo
|
func (pc *ProtoClient) LoadInfo(info *ProtoBufferInfo) error {
if info == nil {
return errors.New("protobuffer information invalid")
}
pc.info = *info
pc.ready = true
return nil
}
|
go
|
func (pc *ProtoClient) LoadInfo(info *ProtoBufferInfo) error {
if info == nil {
return errors.New("protobuffer information invalid")
}
pc.info = *info
pc.ready = true
return nil
}
|
[
"func",
"(",
"pc",
"*",
"ProtoClient",
")",
"LoadInfo",
"(",
"info",
"*",
"ProtoBufferInfo",
")",
"error",
"{",
"if",
"info",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"pc",
".",
"info",
"=",
"*",
"info",
"\n",
"pc",
".",
"ready",
"=",
"true",
"\n",
"return",
"nil",
"\n",
"}"
] |
// LoadInfo load commands information form ProtoBufferInfo
|
[
"LoadInfo",
"load",
"commands",
"information",
"form",
"ProtoBufferInfo"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/client/protoclient.go#L469-L476
|
train
|
topfreegames/pitaya
|
client/protoclient.go
|
AddPushResponse
|
func (pc *ProtoClient) AddPushResponse(route string, protoName string) {
if route != "" && protoName != "" {
var command Command
command.input = ""
command.output = protoName
pc.info.Commands[route] = &command
}
}
|
go
|
func (pc *ProtoClient) AddPushResponse(route string, protoName string) {
if route != "" && protoName != "" {
var command Command
command.input = ""
command.output = protoName
pc.info.Commands[route] = &command
}
}
|
[
"func",
"(",
"pc",
"*",
"ProtoClient",
")",
"AddPushResponse",
"(",
"route",
"string",
",",
"protoName",
"string",
")",
"{",
"if",
"route",
"!=",
"\"",
"\"",
"&&",
"protoName",
"!=",
"\"",
"\"",
"{",
"var",
"command",
"Command",
"\n",
"command",
".",
"input",
"=",
"\"",
"\"",
"\n",
"command",
".",
"output",
"=",
"protoName",
"\n\n",
"pc",
".",
"info",
".",
"Commands",
"[",
"route",
"]",
"=",
"&",
"command",
"\n",
"}",
"\n",
"}"
] |
// AddPushResponse add a push response. Must be ladded before LoadInfo.
|
[
"AddPushResponse",
"add",
"a",
"push",
"response",
".",
"Must",
"be",
"ladded",
"before",
"LoadInfo",
"."
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/client/protoclient.go#L479-L487
|
train
|
topfreegames/pitaya
|
mocks/net.go
|
NewMockAddr
|
func NewMockAddr(ctrl *gomock.Controller) *MockAddr {
mock := &MockAddr{ctrl: ctrl}
mock.recorder = &MockAddrMockRecorder{mock}
return mock
}
|
go
|
func NewMockAddr(ctrl *gomock.Controller) *MockAddr {
mock := &MockAddr{ctrl: ctrl}
mock.recorder = &MockAddrMockRecorder{mock}
return mock
}
|
[
"func",
"NewMockAddr",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockAddr",
"{",
"mock",
":=",
"&",
"MockAddr",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockAddrMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] |
// NewMockAddr creates a new mock instance
|
[
"NewMockAddr",
"creates",
"a",
"new",
"mock",
"instance"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/mocks/net.go#L27-L31
|
train
|
topfreegames/pitaya
|
mocks/net.go
|
NewMockConn
|
func NewMockConn(ctrl *gomock.Controller) *MockConn {
mock := &MockConn{ctrl: ctrl}
mock.recorder = &MockConnMockRecorder{mock}
return mock
}
|
go
|
func NewMockConn(ctrl *gomock.Controller) *MockConn {
mock := &MockConn{ctrl: ctrl}
mock.recorder = &MockConnMockRecorder{mock}
return mock
}
|
[
"func",
"NewMockConn",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockConn",
"{",
"mock",
":=",
"&",
"MockConn",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockConnMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] |
// NewMockConn creates a new mock instance
|
[
"NewMockConn",
"creates",
"a",
"new",
"mock",
"instance"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/mocks/net.go#L74-L78
|
train
|
topfreegames/pitaya
|
mocks/net.go
|
Read
|
func (mr *MockConnMockRecorder) Read(b interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockConn)(nil).Read), b)
}
|
go
|
func (mr *MockConnMockRecorder) Read(b interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockConn)(nil).Read), b)
}
|
[
"func",
"(",
"mr",
"*",
"MockConnMockRecorder",
")",
"Read",
"(",
"b",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockConn",
")",
"(",
"nil",
")",
".",
"Read",
")",
",",
"b",
")",
"\n",
"}"
] |
// Read indicates an expected call of Read
|
[
"Read",
"indicates",
"an",
"expected",
"call",
"of",
"Read"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/mocks/net.go#L94-L96
|
train
|
topfreegames/pitaya
|
mocks/net.go
|
LocalAddr
|
func (m *MockConn) LocalAddr() net.Addr {
ret := m.ctrl.Call(m, "LocalAddr")
ret0, _ := ret[0].(net.Addr)
return ret0
}
|
go
|
func (m *MockConn) LocalAddr() net.Addr {
ret := m.ctrl.Call(m, "LocalAddr")
ret0, _ := ret[0].(net.Addr)
return ret0
}
|
[
"func",
"(",
"m",
"*",
"MockConn",
")",
"LocalAddr",
"(",
")",
"net",
".",
"Addr",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"net",
".",
"Addr",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] |
// LocalAddr mocks base method
|
[
"LocalAddr",
"mocks",
"base",
"method"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/mocks/net.go#L124-L128
|
train
|
topfreegames/pitaya
|
mocks/net.go
|
SetReadDeadline
|
func (mr *MockConnMockRecorder) SetReadDeadline(t interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetReadDeadline", reflect.TypeOf((*MockConn)(nil).SetReadDeadline), t)
}
|
go
|
func (mr *MockConnMockRecorder) SetReadDeadline(t interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetReadDeadline", reflect.TypeOf((*MockConn)(nil).SetReadDeadline), t)
}
|
[
"func",
"(",
"mr",
"*",
"MockConnMockRecorder",
")",
"SetReadDeadline",
"(",
"t",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockConn",
")",
"(",
"nil",
")",
".",
"SetReadDeadline",
")",
",",
"t",
")",
"\n",
"}"
] |
// SetReadDeadline indicates an expected call of SetReadDeadline
|
[
"SetReadDeadline",
"indicates",
"an",
"expected",
"call",
"of",
"SetReadDeadline"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/mocks/net.go#L167-L169
|
train
|
topfreegames/pitaya
|
mocks/net.go
|
SetWriteDeadline
|
func (m *MockConn) SetWriteDeadline(t time.Time) error {
ret := m.ctrl.Call(m, "SetWriteDeadline", t)
ret0, _ := ret[0].(error)
return ret0
}
|
go
|
func (m *MockConn) SetWriteDeadline(t time.Time) error {
ret := m.ctrl.Call(m, "SetWriteDeadline", t)
ret0, _ := ret[0].(error)
return ret0
}
|
[
"func",
"(",
"m",
"*",
"MockConn",
")",
"SetWriteDeadline",
"(",
"t",
"time",
".",
"Time",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"t",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] |
// SetWriteDeadline mocks base method
|
[
"SetWriteDeadline",
"mocks",
"base",
"method"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/mocks/net.go#L172-L176
|
train
|
topfreegames/pitaya
|
protos/mocks/pitaya.go
|
NewMockPitayaClient
|
func NewMockPitayaClient(ctrl *gomock.Controller) *MockPitayaClient {
mock := &MockPitayaClient{ctrl: ctrl}
mock.recorder = &MockPitayaClientMockRecorder{mock}
return mock
}
|
go
|
func NewMockPitayaClient(ctrl *gomock.Controller) *MockPitayaClient {
mock := &MockPitayaClient{ctrl: ctrl}
mock.recorder = &MockPitayaClientMockRecorder{mock}
return mock
}
|
[
"func",
"NewMockPitayaClient",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockPitayaClient",
"{",
"mock",
":=",
"&",
"MockPitayaClient",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockPitayaClientMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] |
// NewMockPitayaClient creates a new mock instance
|
[
"NewMockPitayaClient",
"creates",
"a",
"new",
"mock",
"instance"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/protos/mocks/pitaya.go#L27-L31
|
train
|
topfreegames/pitaya
|
protos/mocks/pitaya.go
|
PushToUser
|
func (mr *MockPitayaClientMockRecorder) PushToUser(ctx, in interface{}, opts ...interface{}) *gomock.Call {
varargs := append([]interface{}{ctx, in}, opts...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PushToUser", reflect.TypeOf((*MockPitayaClient)(nil).PushToUser), varargs...)
}
|
go
|
func (mr *MockPitayaClientMockRecorder) PushToUser(ctx, in interface{}, opts ...interface{}) *gomock.Call {
varargs := append([]interface{}{ctx, in}, opts...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PushToUser", reflect.TypeOf((*MockPitayaClient)(nil).PushToUser), varargs...)
}
|
[
"func",
"(",
"mr",
"*",
"MockPitayaClientMockRecorder",
")",
"PushToUser",
"(",
"ctx",
",",
"in",
"interface",
"{",
"}",
",",
"opts",
"...",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"varargs",
":=",
"append",
"(",
"[",
"]",
"interface",
"{",
"}",
"{",
"ctx",
",",
"in",
"}",
",",
"opts",
"...",
")",
"\n",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockPitayaClient",
")",
"(",
"nil",
")",
".",
"PushToUser",
")",
",",
"varargs",
"...",
")",
"\n",
"}"
] |
// PushToUser indicates an expected call of PushToUser
|
[
"PushToUser",
"indicates",
"an",
"expected",
"call",
"of",
"PushToUser"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/protos/mocks/pitaya.go#L69-L72
|
train
|
topfreegames/pitaya
|
protos/mocks/pitaya.go
|
NewMockPitayaServer
|
func NewMockPitayaServer(ctrl *gomock.Controller) *MockPitayaServer {
mock := &MockPitayaServer{ctrl: ctrl}
mock.recorder = &MockPitayaServerMockRecorder{mock}
return mock
}
|
go
|
func NewMockPitayaServer(ctrl *gomock.Controller) *MockPitayaServer {
mock := &MockPitayaServer{ctrl: ctrl}
mock.recorder = &MockPitayaServerMockRecorder{mock}
return mock
}
|
[
"func",
"NewMockPitayaServer",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockPitayaServer",
"{",
"mock",
":=",
"&",
"MockPitayaServer",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockPitayaServerMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] |
// NewMockPitayaServer creates a new mock instance
|
[
"NewMockPitayaServer",
"creates",
"a",
"new",
"mock",
"instance"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/protos/mocks/pitaya.go#L122-L126
|
train
|
topfreegames/pitaya
|
protos/mocks/pitaya.go
|
PushToUser
|
func (m *MockPitayaServer) PushToUser(arg0 context.Context, arg1 *protos.Push) (*protos.Response, error) {
ret := m.ctrl.Call(m, "PushToUser", arg0, arg1)
ret0, _ := ret[0].(*protos.Response)
ret1, _ := ret[1].(error)
return ret0, ret1
}
|
go
|
func (m *MockPitayaServer) PushToUser(arg0 context.Context, arg1 *protos.Push) (*protos.Response, error) {
ret := m.ctrl.Call(m, "PushToUser", arg0, arg1)
ret0, _ := ret[0].(*protos.Response)
ret1, _ := ret[1].(error)
return ret0, ret1
}
|
[
"func",
"(",
"m",
"*",
"MockPitayaServer",
")",
"PushToUser",
"(",
"arg0",
"context",
".",
"Context",
",",
"arg1",
"*",
"protos",
".",
"Push",
")",
"(",
"*",
"protos",
".",
"Response",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"protos",
".",
"Response",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] |
// PushToUser mocks base method
|
[
"PushToUser",
"mocks",
"base",
"method"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/protos/mocks/pitaya.go#L147-L152
|
train
|
topfreegames/pitaya
|
modules/unique_session.go
|
NewUniqueSession
|
func NewUniqueSession(server *cluster.Server, rpcServer cluster.RPCServer, rpcClient cluster.RPCClient) *UniqueSession {
return &UniqueSession{
server: server,
rpcClient: rpcClient,
}
}
|
go
|
func NewUniqueSession(server *cluster.Server, rpcServer cluster.RPCServer, rpcClient cluster.RPCClient) *UniqueSession {
return &UniqueSession{
server: server,
rpcClient: rpcClient,
}
}
|
[
"func",
"NewUniqueSession",
"(",
"server",
"*",
"cluster",
".",
"Server",
",",
"rpcServer",
"cluster",
".",
"RPCServer",
",",
"rpcClient",
"cluster",
".",
"RPCClient",
")",
"*",
"UniqueSession",
"{",
"return",
"&",
"UniqueSession",
"{",
"server",
":",
"server",
",",
"rpcClient",
":",
"rpcClient",
",",
"}",
"\n",
"}"
] |
// NewUniqueSession creates a new unique session module
|
[
"NewUniqueSession",
"creates",
"a",
"new",
"unique",
"session",
"module"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/modules/unique_session.go#L38-L43
|
train
|
topfreegames/pitaya
|
modules/unique_session.go
|
OnUserBind
|
func (u *UniqueSession) OnUserBind(uid, fid string) {
if u.server.ID == fid {
return
}
oldSession := session.GetSessionByUID(uid)
if oldSession != nil {
// TODO: it would be nice to set this correctly
oldSession.Kick(context.Background())
}
}
|
go
|
func (u *UniqueSession) OnUserBind(uid, fid string) {
if u.server.ID == fid {
return
}
oldSession := session.GetSessionByUID(uid)
if oldSession != nil {
// TODO: it would be nice to set this correctly
oldSession.Kick(context.Background())
}
}
|
[
"func",
"(",
"u",
"*",
"UniqueSession",
")",
"OnUserBind",
"(",
"uid",
",",
"fid",
"string",
")",
"{",
"if",
"u",
".",
"server",
".",
"ID",
"==",
"fid",
"{",
"return",
"\n",
"}",
"\n",
"oldSession",
":=",
"session",
".",
"GetSessionByUID",
"(",
"uid",
")",
"\n",
"if",
"oldSession",
"!=",
"nil",
"{",
"// TODO: it would be nice to set this correctly",
"oldSession",
".",
"Kick",
"(",
"context",
".",
"Background",
"(",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// OnUserBind method should be called when a user binds a session in remote servers
|
[
"OnUserBind",
"method",
"should",
"be",
"called",
"when",
"a",
"user",
"binds",
"a",
"session",
"in",
"remote",
"servers"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/modules/unique_session.go#L46-L55
|
train
|
topfreegames/pitaya
|
modules/unique_session.go
|
Init
|
func (u *UniqueSession) Init() error {
session.OnSessionBind(func(ctx context.Context, s *session.Session) error {
oldSession := session.GetSessionByUID(s.UID())
if oldSession != nil {
return oldSession.Kick(ctx)
}
err := u.rpcClient.BroadcastSessionBind(s.UID())
return err
})
return nil
}
|
go
|
func (u *UniqueSession) Init() error {
session.OnSessionBind(func(ctx context.Context, s *session.Session) error {
oldSession := session.GetSessionByUID(s.UID())
if oldSession != nil {
return oldSession.Kick(ctx)
}
err := u.rpcClient.BroadcastSessionBind(s.UID())
return err
})
return nil
}
|
[
"func",
"(",
"u",
"*",
"UniqueSession",
")",
"Init",
"(",
")",
"error",
"{",
"session",
".",
"OnSessionBind",
"(",
"func",
"(",
"ctx",
"context",
".",
"Context",
",",
"s",
"*",
"session",
".",
"Session",
")",
"error",
"{",
"oldSession",
":=",
"session",
".",
"GetSessionByUID",
"(",
"s",
".",
"UID",
"(",
")",
")",
"\n",
"if",
"oldSession",
"!=",
"nil",
"{",
"return",
"oldSession",
".",
"Kick",
"(",
"ctx",
")",
"\n",
"}",
"\n",
"err",
":=",
"u",
".",
"rpcClient",
".",
"BroadcastSessionBind",
"(",
"s",
".",
"UID",
"(",
")",
")",
"\n",
"return",
"err",
"\n",
"}",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Init initializes the module
|
[
"Init",
"initializes",
"the",
"module"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/modules/unique_session.go#L58-L68
|
train
|
topfreegames/pitaya
|
modules/binary.go
|
NewBinary
|
func NewBinary(binPath string, args []string, gracefulShutdownInterval ...time.Duration) *Binary {
gracefulTime := 15 * time.Second
if len(gracefulShutdownInterval) > 0 {
gracefulTime = gracefulShutdownInterval[0]
}
return &Binary{
binPath: binPath,
args: args,
gracefulShutdownInterval: gracefulTime,
exitCh: make(chan struct{}),
}
}
|
go
|
func NewBinary(binPath string, args []string, gracefulShutdownInterval ...time.Duration) *Binary {
gracefulTime := 15 * time.Second
if len(gracefulShutdownInterval) > 0 {
gracefulTime = gracefulShutdownInterval[0]
}
return &Binary{
binPath: binPath,
args: args,
gracefulShutdownInterval: gracefulTime,
exitCh: make(chan struct{}),
}
}
|
[
"func",
"NewBinary",
"(",
"binPath",
"string",
",",
"args",
"[",
"]",
"string",
",",
"gracefulShutdownInterval",
"...",
"time",
".",
"Duration",
")",
"*",
"Binary",
"{",
"gracefulTime",
":=",
"15",
"*",
"time",
".",
"Second",
"\n",
"if",
"len",
"(",
"gracefulShutdownInterval",
")",
">",
"0",
"{",
"gracefulTime",
"=",
"gracefulShutdownInterval",
"[",
"0",
"]",
"\n",
"}",
"\n",
"return",
"&",
"Binary",
"{",
"binPath",
":",
"binPath",
",",
"args",
":",
"args",
",",
"gracefulShutdownInterval",
":",
"gracefulTime",
",",
"exitCh",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"}",
"\n",
"}"
] |
// NewBinary creates a new binary module with the given path
|
[
"NewBinary",
"creates",
"a",
"new",
"binary",
"module",
"with",
"the",
"given",
"path"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/modules/binary.go#L45-L56
|
train
|
topfreegames/pitaya
|
modules/binary.go
|
Init
|
func (b *Binary) Init() error {
b.cmd = exec.Command(b.binPath, b.args...)
stdout, _ := b.cmd.StdoutPipe()
stdOutScanner := bufio.NewScanner(stdout)
stderr, _ := b.cmd.StderrPipe()
stdErrScanner := bufio.NewScanner(stderr)
go func() {
for stdOutScanner.Scan() {
logger.Log.Info(stdOutScanner.Text())
}
}()
go func() {
for stdErrScanner.Scan() {
logger.Log.Error(stdErrScanner.Text())
}
}()
err := b.cmd.Start()
go func() {
b.cmd.Wait()
close(b.exitCh)
}()
return err
}
|
go
|
func (b *Binary) Init() error {
b.cmd = exec.Command(b.binPath, b.args...)
stdout, _ := b.cmd.StdoutPipe()
stdOutScanner := bufio.NewScanner(stdout)
stderr, _ := b.cmd.StderrPipe()
stdErrScanner := bufio.NewScanner(stderr)
go func() {
for stdOutScanner.Scan() {
logger.Log.Info(stdOutScanner.Text())
}
}()
go func() {
for stdErrScanner.Scan() {
logger.Log.Error(stdErrScanner.Text())
}
}()
err := b.cmd.Start()
go func() {
b.cmd.Wait()
close(b.exitCh)
}()
return err
}
|
[
"func",
"(",
"b",
"*",
"Binary",
")",
"Init",
"(",
")",
"error",
"{",
"b",
".",
"cmd",
"=",
"exec",
".",
"Command",
"(",
"b",
".",
"binPath",
",",
"b",
".",
"args",
"...",
")",
"\n",
"stdout",
",",
"_",
":=",
"b",
".",
"cmd",
".",
"StdoutPipe",
"(",
")",
"\n",
"stdOutScanner",
":=",
"bufio",
".",
"NewScanner",
"(",
"stdout",
")",
"\n",
"stderr",
",",
"_",
":=",
"b",
".",
"cmd",
".",
"StderrPipe",
"(",
")",
"\n",
"stdErrScanner",
":=",
"bufio",
".",
"NewScanner",
"(",
"stderr",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"for",
"stdOutScanner",
".",
"Scan",
"(",
")",
"{",
"logger",
".",
"Log",
".",
"Info",
"(",
"stdOutScanner",
".",
"Text",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"for",
"stdErrScanner",
".",
"Scan",
"(",
")",
"{",
"logger",
".",
"Log",
".",
"Error",
"(",
"stdErrScanner",
".",
"Text",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"err",
":=",
"b",
".",
"cmd",
".",
"Start",
"(",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"b",
".",
"cmd",
".",
"Wait",
"(",
")",
"\n",
"close",
"(",
"b",
".",
"exitCh",
")",
"\n",
"}",
"(",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// Init initializes the binary
|
[
"Init",
"initializes",
"the",
"binary"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/modules/binary.go#L64-L86
|
train
|
topfreegames/pitaya
|
modules/binary.go
|
Shutdown
|
func (b *Binary) Shutdown() error {
err := b.cmd.Process.Signal(syscall.SIGTERM)
if err != nil {
return err
}
timeout := time.After(b.gracefulShutdownInterval)
select {
case <-b.exitCh:
return nil
case <-timeout:
b.cmd.Process.Kill()
return constants.ErrTimeoutTerminatingBinaryModule
}
}
|
go
|
func (b *Binary) Shutdown() error {
err := b.cmd.Process.Signal(syscall.SIGTERM)
if err != nil {
return err
}
timeout := time.After(b.gracefulShutdownInterval)
select {
case <-b.exitCh:
return nil
case <-timeout:
b.cmd.Process.Kill()
return constants.ErrTimeoutTerminatingBinaryModule
}
}
|
[
"func",
"(",
"b",
"*",
"Binary",
")",
"Shutdown",
"(",
")",
"error",
"{",
"err",
":=",
"b",
".",
"cmd",
".",
"Process",
".",
"Signal",
"(",
"syscall",
".",
"SIGTERM",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"timeout",
":=",
"time",
".",
"After",
"(",
"b",
".",
"gracefulShutdownInterval",
")",
"\n",
"select",
"{",
"case",
"<-",
"b",
".",
"exitCh",
":",
"return",
"nil",
"\n",
"case",
"<-",
"timeout",
":",
"b",
".",
"cmd",
".",
"Process",
".",
"Kill",
"(",
")",
"\n",
"return",
"constants",
".",
"ErrTimeoutTerminatingBinaryModule",
"\n",
"}",
"\n",
"}"
] |
// Shutdown shutdowns the binary module
|
[
"Shutdown",
"shutdowns",
"the",
"binary",
"module"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/modules/binary.go#L89-L102
|
train
|
topfreegames/pitaya
|
metrics/prometheus_reporter.go
|
GetPrometheusReporter
|
func GetPrometheusReporter(
serverType string,
config *config.Config,
constLabels map[string]string,
) (*PrometheusReporter, error) {
var (
port = config.GetInt("pitaya.metrics.prometheus.port")
game = config.GetString("pitaya.game")
additionalLabels = config.GetStringMapString("pitaya.metrics.additionalTags")
)
spec, err := NewCustomMetricsSpec(config)
if err != nil {
return nil, err
}
once.Do(func() {
prometheusReporter = &PrometheusReporter{
serverType: serverType,
game: game,
countReportersMap: make(map[string]*prometheus.CounterVec),
summaryReportersMap: make(map[string]*prometheus.SummaryVec),
gaugeReportersMap: make(map[string]*prometheus.GaugeVec),
}
prometheusReporter.registerMetrics(constLabels, additionalLabels, spec)
http.Handle("/metrics", prometheus.Handler())
go (func() {
log.Fatal(http.ListenAndServe(fmt.Sprintf(":%d", port), nil))
})()
})
return prometheusReporter, nil
}
|
go
|
func GetPrometheusReporter(
serverType string,
config *config.Config,
constLabels map[string]string,
) (*PrometheusReporter, error) {
var (
port = config.GetInt("pitaya.metrics.prometheus.port")
game = config.GetString("pitaya.game")
additionalLabels = config.GetStringMapString("pitaya.metrics.additionalTags")
)
spec, err := NewCustomMetricsSpec(config)
if err != nil {
return nil, err
}
once.Do(func() {
prometheusReporter = &PrometheusReporter{
serverType: serverType,
game: game,
countReportersMap: make(map[string]*prometheus.CounterVec),
summaryReportersMap: make(map[string]*prometheus.SummaryVec),
gaugeReportersMap: make(map[string]*prometheus.GaugeVec),
}
prometheusReporter.registerMetrics(constLabels, additionalLabels, spec)
http.Handle("/metrics", prometheus.Handler())
go (func() {
log.Fatal(http.ListenAndServe(fmt.Sprintf(":%d", port), nil))
})()
})
return prometheusReporter, nil
}
|
[
"func",
"GetPrometheusReporter",
"(",
"serverType",
"string",
",",
"config",
"*",
"config",
".",
"Config",
",",
"constLabels",
"map",
"[",
"string",
"]",
"string",
",",
")",
"(",
"*",
"PrometheusReporter",
",",
"error",
")",
"{",
"var",
"(",
"port",
"=",
"config",
".",
"GetInt",
"(",
"\"",
"\"",
")",
"\n",
"game",
"=",
"config",
".",
"GetString",
"(",
"\"",
"\"",
")",
"\n",
"additionalLabels",
"=",
"config",
".",
"GetStringMapString",
"(",
"\"",
"\"",
")",
"\n",
")",
"\n\n",
"spec",
",",
"err",
":=",
"NewCustomMetricsSpec",
"(",
"config",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"once",
".",
"Do",
"(",
"func",
"(",
")",
"{",
"prometheusReporter",
"=",
"&",
"PrometheusReporter",
"{",
"serverType",
":",
"serverType",
",",
"game",
":",
"game",
",",
"countReportersMap",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"prometheus",
".",
"CounterVec",
")",
",",
"summaryReportersMap",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"prometheus",
".",
"SummaryVec",
")",
",",
"gaugeReportersMap",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"prometheus",
".",
"GaugeVec",
")",
",",
"}",
"\n",
"prometheusReporter",
".",
"registerMetrics",
"(",
"constLabels",
",",
"additionalLabels",
",",
"spec",
")",
"\n",
"http",
".",
"Handle",
"(",
"\"",
"\"",
",",
"prometheus",
".",
"Handler",
"(",
")",
")",
"\n",
"go",
"(",
"func",
"(",
")",
"{",
"log",
".",
"Fatal",
"(",
"http",
".",
"ListenAndServe",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"port",
")",
",",
"nil",
")",
")",
"\n",
"}",
")",
"(",
")",
"\n",
"}",
")",
"\n\n",
"return",
"prometheusReporter",
",",
"nil",
"\n",
"}"
] |
// GetPrometheusReporter gets the prometheus reporter singleton
|
[
"GetPrometheusReporter",
"gets",
"the",
"prometheus",
"reporter",
"singleton"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/metrics/prometheus_reporter.go#L265-L297
|
train
|
topfreegames/pitaya
|
metrics/prometheus_reporter.go
|
ReportSummary
|
func (p *PrometheusReporter) ReportSummary(metric string, labels map[string]string, value float64) error {
sum := p.summaryReportersMap[metric]
if sum != nil {
labels = p.ensureLabels(labels)
sum.With(labels).Observe(value)
return nil
}
return constants.ErrMetricNotKnown
}
|
go
|
func (p *PrometheusReporter) ReportSummary(metric string, labels map[string]string, value float64) error {
sum := p.summaryReportersMap[metric]
if sum != nil {
labels = p.ensureLabels(labels)
sum.With(labels).Observe(value)
return nil
}
return constants.ErrMetricNotKnown
}
|
[
"func",
"(",
"p",
"*",
"PrometheusReporter",
")",
"ReportSummary",
"(",
"metric",
"string",
",",
"labels",
"map",
"[",
"string",
"]",
"string",
",",
"value",
"float64",
")",
"error",
"{",
"sum",
":=",
"p",
".",
"summaryReportersMap",
"[",
"metric",
"]",
"\n",
"if",
"sum",
"!=",
"nil",
"{",
"labels",
"=",
"p",
".",
"ensureLabels",
"(",
"labels",
")",
"\n",
"sum",
".",
"With",
"(",
"labels",
")",
".",
"Observe",
"(",
"value",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"constants",
".",
"ErrMetricNotKnown",
"\n",
"}"
] |
// ReportSummary reports a summary metric
|
[
"ReportSummary",
"reports",
"a",
"summary",
"metric"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/metrics/prometheus_reporter.go#L300-L308
|
train
|
topfreegames/pitaya
|
metrics/prometheus_reporter.go
|
ReportCount
|
func (p *PrometheusReporter) ReportCount(metric string, labels map[string]string, count float64) error {
cnt := p.countReportersMap[metric]
if cnt != nil {
labels = p.ensureLabels(labels)
cnt.With(labels).Add(count)
return nil
}
return constants.ErrMetricNotKnown
}
|
go
|
func (p *PrometheusReporter) ReportCount(metric string, labels map[string]string, count float64) error {
cnt := p.countReportersMap[metric]
if cnt != nil {
labels = p.ensureLabels(labels)
cnt.With(labels).Add(count)
return nil
}
return constants.ErrMetricNotKnown
}
|
[
"func",
"(",
"p",
"*",
"PrometheusReporter",
")",
"ReportCount",
"(",
"metric",
"string",
",",
"labels",
"map",
"[",
"string",
"]",
"string",
",",
"count",
"float64",
")",
"error",
"{",
"cnt",
":=",
"p",
".",
"countReportersMap",
"[",
"metric",
"]",
"\n",
"if",
"cnt",
"!=",
"nil",
"{",
"labels",
"=",
"p",
".",
"ensureLabels",
"(",
"labels",
")",
"\n",
"cnt",
".",
"With",
"(",
"labels",
")",
".",
"Add",
"(",
"count",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"constants",
".",
"ErrMetricNotKnown",
"\n",
"}"
] |
// ReportCount reports a summary metric
|
[
"ReportCount",
"reports",
"a",
"summary",
"metric"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/metrics/prometheus_reporter.go#L311-L319
|
train
|
topfreegames/pitaya
|
metrics/prometheus_reporter.go
|
ReportGauge
|
func (p *PrometheusReporter) ReportGauge(metric string, labels map[string]string, value float64) error {
g := p.gaugeReportersMap[metric]
if g != nil {
labels = p.ensureLabels(labels)
g.With(labels).Set(value)
return nil
}
return constants.ErrMetricNotKnown
}
|
go
|
func (p *PrometheusReporter) ReportGauge(metric string, labels map[string]string, value float64) error {
g := p.gaugeReportersMap[metric]
if g != nil {
labels = p.ensureLabels(labels)
g.With(labels).Set(value)
return nil
}
return constants.ErrMetricNotKnown
}
|
[
"func",
"(",
"p",
"*",
"PrometheusReporter",
")",
"ReportGauge",
"(",
"metric",
"string",
",",
"labels",
"map",
"[",
"string",
"]",
"string",
",",
"value",
"float64",
")",
"error",
"{",
"g",
":=",
"p",
".",
"gaugeReportersMap",
"[",
"metric",
"]",
"\n",
"if",
"g",
"!=",
"nil",
"{",
"labels",
"=",
"p",
".",
"ensureLabels",
"(",
"labels",
")",
"\n",
"g",
".",
"With",
"(",
"labels",
")",
".",
"Set",
"(",
"value",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"constants",
".",
"ErrMetricNotKnown",
"\n",
"}"
] |
// ReportGauge reports a gauge metric
|
[
"ReportGauge",
"reports",
"a",
"gauge",
"metric"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/metrics/prometheus_reporter.go#L322-L330
|
train
|
topfreegames/pitaya
|
metrics/prometheus_reporter.go
|
ensureLabels
|
func (p *PrometheusReporter) ensureLabels(labels map[string]string) map[string]string {
for key, defaultVal := range p.additionalLabels {
if _, ok := labels[key]; !ok {
labels[key] = defaultVal
}
}
return labels
}
|
go
|
func (p *PrometheusReporter) ensureLabels(labels map[string]string) map[string]string {
for key, defaultVal := range p.additionalLabels {
if _, ok := labels[key]; !ok {
labels[key] = defaultVal
}
}
return labels
}
|
[
"func",
"(",
"p",
"*",
"PrometheusReporter",
")",
"ensureLabels",
"(",
"labels",
"map",
"[",
"string",
"]",
"string",
")",
"map",
"[",
"string",
"]",
"string",
"{",
"for",
"key",
",",
"defaultVal",
":=",
"range",
"p",
".",
"additionalLabels",
"{",
"if",
"_",
",",
"ok",
":=",
"labels",
"[",
"key",
"]",
";",
"!",
"ok",
"{",
"labels",
"[",
"key",
"]",
"=",
"defaultVal",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"labels",
"\n",
"}"
] |
// ensureLabels checks if labels contains the additionalLabels values,
// otherwise adds them with the default values
|
[
"ensureLabels",
"checks",
"if",
"labels",
"contains",
"the",
"additionalLabels",
"values",
"otherwise",
"adds",
"them",
"with",
"the",
"default",
"values"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/metrics/prometheus_reporter.go#L334-L342
|
train
|
topfreegames/pitaya
|
examples/demo/worker/services/worker.go
|
Configure
|
func (w *Worker) Configure() error {
err := pitaya.StartWorker(pitaya.GetConfig())
if err != nil {
return err
}
pitaya.RegisterRPCJob(&RPCJob{})
return nil
}
|
go
|
func (w *Worker) Configure() error {
err := pitaya.StartWorker(pitaya.GetConfig())
if err != nil {
return err
}
pitaya.RegisterRPCJob(&RPCJob{})
return nil
}
|
[
"func",
"(",
"w",
"*",
"Worker",
")",
"Configure",
"(",
")",
"error",
"{",
"err",
":=",
"pitaya",
".",
"StartWorker",
"(",
"pitaya",
".",
"GetConfig",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"pitaya",
".",
"RegisterRPCJob",
"(",
"&",
"RPCJob",
"{",
"}",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Configure starts workers and register rpc job
|
[
"Configure",
"starts",
"workers",
"and",
"register",
"rpc",
"job"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/examples/demo/worker/services/worker.go#L18-L26
|
train
|
topfreegames/pitaya
|
examples/demo/worker/services/worker.go
|
ServerDiscovery
|
func (r *RPCJob) ServerDiscovery(
route string,
rpcMetadata map[string]interface{},
) (serverID string, err error) {
return "", nil
}
|
go
|
func (r *RPCJob) ServerDiscovery(
route string,
rpcMetadata map[string]interface{},
) (serverID string, err error) {
return "", nil
}
|
[
"func",
"(",
"r",
"*",
"RPCJob",
")",
"ServerDiscovery",
"(",
"route",
"string",
",",
"rpcMetadata",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
")",
"(",
"serverID",
"string",
",",
"err",
"error",
")",
"{",
"return",
"\"",
"\"",
",",
"nil",
"\n",
"}"
] |
// ServerDiscovery returns a serverID="", meaning any server
// is ok
|
[
"ServerDiscovery",
"returns",
"a",
"serverID",
"=",
"meaning",
"any",
"server",
"is",
"ok"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/examples/demo/worker/services/worker.go#L33-L38
|
train
|
topfreegames/pitaya
|
examples/demo/worker/services/worker.go
|
RPC
|
func (r *RPCJob) RPC(
ctx context.Context,
serverID, routeStr string,
reply, arg proto.Message,
) error {
return pitaya.RPCTo(ctx, serverID, routeStr, reply, arg)
}
|
go
|
func (r *RPCJob) RPC(
ctx context.Context,
serverID, routeStr string,
reply, arg proto.Message,
) error {
return pitaya.RPCTo(ctx, serverID, routeStr, reply, arg)
}
|
[
"func",
"(",
"r",
"*",
"RPCJob",
")",
"RPC",
"(",
"ctx",
"context",
".",
"Context",
",",
"serverID",
",",
"routeStr",
"string",
",",
"reply",
",",
"arg",
"proto",
".",
"Message",
",",
")",
"error",
"{",
"return",
"pitaya",
".",
"RPCTo",
"(",
"ctx",
",",
"serverID",
",",
"routeStr",
",",
"reply",
",",
"arg",
")",
"\n",
"}"
] |
// RPC calls pitaya's rpc
|
[
"RPC",
"calls",
"pitaya",
"s",
"rpc"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/examples/demo/worker/services/worker.go#L41-L47
|
train
|
topfreegames/pitaya
|
examples/demo/worker/services/worker.go
|
GetArgReply
|
func (r *RPCJob) GetArgReply(
route string,
) (arg, reply proto.Message, err error) {
return &protos.Arg{}, &protos.Response{}, nil
}
|
go
|
func (r *RPCJob) GetArgReply(
route string,
) (arg, reply proto.Message, err error) {
return &protos.Arg{}, &protos.Response{}, nil
}
|
[
"func",
"(",
"r",
"*",
"RPCJob",
")",
"GetArgReply",
"(",
"route",
"string",
",",
")",
"(",
"arg",
",",
"reply",
"proto",
".",
"Message",
",",
"err",
"error",
")",
"{",
"return",
"&",
"protos",
".",
"Arg",
"{",
"}",
",",
"&",
"protos",
".",
"Response",
"{",
"}",
",",
"nil",
"\n",
"}"
] |
// GetArgReply returns reply and arg of LogRemote,
// since we have no other methods in this example
|
[
"GetArgReply",
"returns",
"reply",
"and",
"arg",
"of",
"LogRemote",
"since",
"we",
"have",
"no",
"other",
"methods",
"in",
"this",
"example"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/examples/demo/worker/services/worker.go#L51-L55
|
train
|
topfreegames/pitaya
|
interfaces/mocks/interfaces.go
|
NewMockModule
|
func NewMockModule(ctrl *gomock.Controller) *MockModule {
mock := &MockModule{ctrl: ctrl}
mock.recorder = &MockModuleMockRecorder{mock}
return mock
}
|
go
|
func NewMockModule(ctrl *gomock.Controller) *MockModule {
mock := &MockModule{ctrl: ctrl}
mock.recorder = &MockModuleMockRecorder{mock}
return mock
}
|
[
"func",
"NewMockModule",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockModule",
"{",
"mock",
":=",
"&",
"MockModule",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockModuleMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] |
// NewMockModule creates a new mock instance
|
[
"NewMockModule",
"creates",
"a",
"new",
"mock",
"instance"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/interfaces/mocks/interfaces.go#L24-L28
|
train
|
topfreegames/pitaya
|
interfaces/mocks/interfaces.go
|
AfterInit
|
func (mr *MockModuleMockRecorder) AfterInit() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AfterInit", reflect.TypeOf((*MockModule)(nil).AfterInit))
}
|
go
|
func (mr *MockModuleMockRecorder) AfterInit() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AfterInit", reflect.TypeOf((*MockModule)(nil).AfterInit))
}
|
[
"func",
"(",
"mr",
"*",
"MockModuleMockRecorder",
")",
"AfterInit",
"(",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockModule",
")",
"(",
"nil",
")",
".",
"AfterInit",
")",
")",
"\n",
"}"
] |
// AfterInit indicates an expected call of AfterInit
|
[
"AfterInit",
"indicates",
"an",
"expected",
"call",
"of",
"AfterInit"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/interfaces/mocks/interfaces.go#L53-L55
|
train
|
topfreegames/pitaya
|
interfaces/mocks/interfaces.go
|
NewMockBindingStorage
|
func NewMockBindingStorage(ctrl *gomock.Controller) *MockBindingStorage {
mock := &MockBindingStorage{ctrl: ctrl}
mock.recorder = &MockBindingStorageMockRecorder{mock}
return mock
}
|
go
|
func NewMockBindingStorage(ctrl *gomock.Controller) *MockBindingStorage {
mock := &MockBindingStorage{ctrl: ctrl}
mock.recorder = &MockBindingStorageMockRecorder{mock}
return mock
}
|
[
"func",
"NewMockBindingStorage",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockBindingStorage",
"{",
"mock",
":=",
"&",
"MockBindingStorage",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockBindingStorageMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] |
// NewMockBindingStorage creates a new mock instance
|
[
"NewMockBindingStorage",
"creates",
"a",
"new",
"mock",
"instance"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/interfaces/mocks/interfaces.go#L91-L95
|
train
|
topfreegames/pitaya
|
interfaces/mocks/interfaces.go
|
GetUserFrontendID
|
func (m *MockBindingStorage) GetUserFrontendID(uid, frontendType string) (string, error) {
ret := m.ctrl.Call(m, "GetUserFrontendID", uid, frontendType)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
|
go
|
func (m *MockBindingStorage) GetUserFrontendID(uid, frontendType string) (string, error) {
ret := m.ctrl.Call(m, "GetUserFrontendID", uid, frontendType)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
|
[
"func",
"(",
"m",
"*",
"MockBindingStorage",
")",
"GetUserFrontendID",
"(",
"uid",
",",
"frontendType",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"uid",
",",
"frontendType",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"string",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] |
// GetUserFrontendID mocks base method
|
[
"GetUserFrontendID",
"mocks",
"base",
"method"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/interfaces/mocks/interfaces.go#L103-L108
|
train
|
topfreegames/pitaya
|
interfaces/mocks/interfaces.go
|
GetUserFrontendID
|
func (mr *MockBindingStorageMockRecorder) GetUserFrontendID(uid, frontendType interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserFrontendID", reflect.TypeOf((*MockBindingStorage)(nil).GetUserFrontendID), uid, frontendType)
}
|
go
|
func (mr *MockBindingStorageMockRecorder) GetUserFrontendID(uid, frontendType interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserFrontendID", reflect.TypeOf((*MockBindingStorage)(nil).GetUserFrontendID), uid, frontendType)
}
|
[
"func",
"(",
"mr",
"*",
"MockBindingStorageMockRecorder",
")",
"GetUserFrontendID",
"(",
"uid",
",",
"frontendType",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockBindingStorage",
")",
"(",
"nil",
")",
".",
"GetUserFrontendID",
")",
",",
"uid",
",",
"frontendType",
")",
"\n",
"}"
] |
// GetUserFrontendID indicates an expected call of GetUserFrontendID
|
[
"GetUserFrontendID",
"indicates",
"an",
"expected",
"call",
"of",
"GetUserFrontendID"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/interfaces/mocks/interfaces.go#L111-L113
|
train
|
topfreegames/pitaya
|
interfaces/mocks/interfaces.go
|
PutBinding
|
func (m *MockBindingStorage) PutBinding(uid string) error {
ret := m.ctrl.Call(m, "PutBinding", uid)
ret0, _ := ret[0].(error)
return ret0
}
|
go
|
func (m *MockBindingStorage) PutBinding(uid string) error {
ret := m.ctrl.Call(m, "PutBinding", uid)
ret0, _ := ret[0].(error)
return ret0
}
|
[
"func",
"(",
"m",
"*",
"MockBindingStorage",
")",
"PutBinding",
"(",
"uid",
"string",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"uid",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] |
// PutBinding mocks base method
|
[
"PutBinding",
"mocks",
"base",
"method"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/interfaces/mocks/interfaces.go#L116-L120
|
train
|
topfreegames/pitaya
|
docgenerator/descriptors.go
|
ProtoDescriptors
|
func ProtoDescriptors(protoName string) ([]byte, error) {
if strings.HasSuffix(protoName, ".proto") {
descriptor := proto.FileDescriptor(protoName)
if descriptor == nil {
return nil, constants.ErrProtodescriptor
}
return descriptor, nil
}
if strings.HasPrefix(protoName, "types.") {
protoName = strings.Replace(protoName, "types.", "google.protobuf.", 1)
}
protoReflectTypePointer := proto.MessageType(protoName)
if protoReflectTypePointer == nil {
return nil, constants.ErrProtodescriptor
}
protoReflectType := protoReflectTypePointer.Elem()
protoValue := reflect.New(protoReflectType)
descriptorMethod, ok := protoReflectTypePointer.MethodByName("Descriptor")
if !ok {
return nil, constants.ErrProtodescriptor
}
descriptorValue := descriptorMethod.Func.Call([]reflect.Value{protoValue})
protoDescriptor := descriptorValue[0].Bytes()
return protoDescriptor, nil
}
|
go
|
func ProtoDescriptors(protoName string) ([]byte, error) {
if strings.HasSuffix(protoName, ".proto") {
descriptor := proto.FileDescriptor(protoName)
if descriptor == nil {
return nil, constants.ErrProtodescriptor
}
return descriptor, nil
}
if strings.HasPrefix(protoName, "types.") {
protoName = strings.Replace(protoName, "types.", "google.protobuf.", 1)
}
protoReflectTypePointer := proto.MessageType(protoName)
if protoReflectTypePointer == nil {
return nil, constants.ErrProtodescriptor
}
protoReflectType := protoReflectTypePointer.Elem()
protoValue := reflect.New(protoReflectType)
descriptorMethod, ok := protoReflectTypePointer.MethodByName("Descriptor")
if !ok {
return nil, constants.ErrProtodescriptor
}
descriptorValue := descriptorMethod.Func.Call([]reflect.Value{protoValue})
protoDescriptor := descriptorValue[0].Bytes()
return protoDescriptor, nil
}
|
[
"func",
"ProtoDescriptors",
"(",
"protoName",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"strings",
".",
"HasSuffix",
"(",
"protoName",
",",
"\"",
"\"",
")",
"{",
"descriptor",
":=",
"proto",
".",
"FileDescriptor",
"(",
"protoName",
")",
"\n",
"if",
"descriptor",
"==",
"nil",
"{",
"return",
"nil",
",",
"constants",
".",
"ErrProtodescriptor",
"\n",
"}",
"\n",
"return",
"descriptor",
",",
"nil",
"\n",
"}",
"\n\n",
"if",
"strings",
".",
"HasPrefix",
"(",
"protoName",
",",
"\"",
"\"",
")",
"{",
"protoName",
"=",
"strings",
".",
"Replace",
"(",
"protoName",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"1",
")",
"\n",
"}",
"\n",
"protoReflectTypePointer",
":=",
"proto",
".",
"MessageType",
"(",
"protoName",
")",
"\n",
"if",
"protoReflectTypePointer",
"==",
"nil",
"{",
"return",
"nil",
",",
"constants",
".",
"ErrProtodescriptor",
"\n",
"}",
"\n\n",
"protoReflectType",
":=",
"protoReflectTypePointer",
".",
"Elem",
"(",
")",
"\n",
"protoValue",
":=",
"reflect",
".",
"New",
"(",
"protoReflectType",
")",
"\n",
"descriptorMethod",
",",
"ok",
":=",
"protoReflectTypePointer",
".",
"MethodByName",
"(",
"\"",
"\"",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"constants",
".",
"ErrProtodescriptor",
"\n",
"}",
"\n\n",
"descriptorValue",
":=",
"descriptorMethod",
".",
"Func",
".",
"Call",
"(",
"[",
"]",
"reflect",
".",
"Value",
"{",
"protoValue",
"}",
")",
"\n",
"protoDescriptor",
":=",
"descriptorValue",
"[",
"0",
"]",
".",
"Bytes",
"(",
")",
"\n\n",
"return",
"protoDescriptor",
",",
"nil",
"\n",
"}"
] |
// ProtoDescriptors returns the descriptor for a given message name or .proto file
|
[
"ProtoDescriptors",
"returns",
"the",
"descriptor",
"for",
"a",
"given",
"message",
"name",
"or",
".",
"proto",
"file"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/docgenerator/descriptors.go#L12-L40
|
train
|
topfreegames/pitaya
|
conn/codec/mocks/packet_decoder.go
|
NewMockPacketDecoder
|
func NewMockPacketDecoder(ctrl *gomock.Controller) *MockPacketDecoder {
mock := &MockPacketDecoder{ctrl: ctrl}
mock.recorder = &MockPacketDecoderMockRecorder{mock}
return mock
}
|
go
|
func NewMockPacketDecoder(ctrl *gomock.Controller) *MockPacketDecoder {
mock := &MockPacketDecoder{ctrl: ctrl}
mock.recorder = &MockPacketDecoderMockRecorder{mock}
return mock
}
|
[
"func",
"NewMockPacketDecoder",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockPacketDecoder",
"{",
"mock",
":=",
"&",
"MockPacketDecoder",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockPacketDecoderMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] |
// NewMockPacketDecoder creates a new mock instance
|
[
"NewMockPacketDecoder",
"creates",
"a",
"new",
"mock",
"instance"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/conn/codec/mocks/packet_decoder.go#L25-L29
|
train
|
topfreegames/pitaya
|
conn/codec/mocks/packet_decoder.go
|
Decode
|
func (m *MockPacketDecoder) Decode(data []byte) ([]*packet.Packet, error) {
ret := m.ctrl.Call(m, "Decode", data)
ret0, _ := ret[0].([]*packet.Packet)
ret1, _ := ret[1].(error)
return ret0, ret1
}
|
go
|
func (m *MockPacketDecoder) Decode(data []byte) ([]*packet.Packet, error) {
ret := m.ctrl.Call(m, "Decode", data)
ret0, _ := ret[0].([]*packet.Packet)
ret1, _ := ret[1].(error)
return ret0, ret1
}
|
[
"func",
"(",
"m",
"*",
"MockPacketDecoder",
")",
"Decode",
"(",
"data",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"*",
"packet",
".",
"Packet",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"data",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"[",
"]",
"*",
"packet",
".",
"Packet",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] |
// Decode mocks base method
|
[
"Decode",
"mocks",
"base",
"method"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/conn/codec/mocks/packet_decoder.go#L37-L42
|
train
|
topfreegames/pitaya
|
conn/codec/mocks/packet_decoder.go
|
Decode
|
func (mr *MockPacketDecoderMockRecorder) Decode(data interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Decode", reflect.TypeOf((*MockPacketDecoder)(nil).Decode), data)
}
|
go
|
func (mr *MockPacketDecoderMockRecorder) Decode(data interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Decode", reflect.TypeOf((*MockPacketDecoder)(nil).Decode), data)
}
|
[
"func",
"(",
"mr",
"*",
"MockPacketDecoderMockRecorder",
")",
"Decode",
"(",
"data",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockPacketDecoder",
")",
"(",
"nil",
")",
".",
"Decode",
")",
",",
"data",
")",
"\n",
"}"
] |
// Decode indicates an expected call of Decode
|
[
"Decode",
"indicates",
"an",
"expected",
"call",
"of",
"Decode"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/conn/codec/mocks/packet_decoder.go#L45-L47
|
train
|
topfreegames/pitaya
|
cluster/mocks/cluster.go
|
NewMockRPCServer
|
func NewMockRPCServer(ctrl *gomock.Controller) *MockRPCServer {
mock := &MockRPCServer{ctrl: ctrl}
mock.recorder = &MockRPCServerMockRecorder{mock}
return mock
}
|
go
|
func NewMockRPCServer(ctrl *gomock.Controller) *MockRPCServer {
mock := &MockRPCServer{ctrl: ctrl}
mock.recorder = &MockRPCServerMockRecorder{mock}
return mock
}
|
[
"func",
"NewMockRPCServer",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockRPCServer",
"{",
"mock",
":=",
"&",
"MockRPCServer",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockRPCServerMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] |
// NewMockRPCServer creates a new mock instance
|
[
"NewMockRPCServer",
"creates",
"a",
"new",
"mock",
"instance"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/mocks/cluster.go#L30-L34
|
train
|
topfreegames/pitaya
|
cluster/mocks/cluster.go
|
SetPitayaServer
|
func (m *MockRPCServer) SetPitayaServer(arg0 protos.PitayaServer) {
m.ctrl.Call(m, "SetPitayaServer", arg0)
}
|
go
|
func (m *MockRPCServer) SetPitayaServer(arg0 protos.PitayaServer) {
m.ctrl.Call(m, "SetPitayaServer", arg0)
}
|
[
"func",
"(",
"m",
"*",
"MockRPCServer",
")",
"SetPitayaServer",
"(",
"arg0",
"protos",
".",
"PitayaServer",
")",
"{",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"}"
] |
// SetPitayaServer mocks base method
|
[
"SetPitayaServer",
"mocks",
"base",
"method"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/mocks/cluster.go#L42-L44
|
train
|
topfreegames/pitaya
|
cluster/mocks/cluster.go
|
SetPitayaServer
|
func (mr *MockRPCServerMockRecorder) SetPitayaServer(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPitayaServer", reflect.TypeOf((*MockRPCServer)(nil).SetPitayaServer), arg0)
}
|
go
|
func (mr *MockRPCServerMockRecorder) SetPitayaServer(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPitayaServer", reflect.TypeOf((*MockRPCServer)(nil).SetPitayaServer), arg0)
}
|
[
"func",
"(",
"mr",
"*",
"MockRPCServerMockRecorder",
")",
"SetPitayaServer",
"(",
"arg0",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockRPCServer",
")",
"(",
"nil",
")",
".",
"SetPitayaServer",
")",
",",
"arg0",
")",
"\n",
"}"
] |
// SetPitayaServer indicates an expected call of SetPitayaServer
|
[
"SetPitayaServer",
"indicates",
"an",
"expected",
"call",
"of",
"SetPitayaServer"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/mocks/cluster.go#L47-L49
|
train
|
topfreegames/pitaya
|
cluster/mocks/cluster.go
|
NewMockRPCClient
|
func NewMockRPCClient(ctrl *gomock.Controller) *MockRPCClient {
mock := &MockRPCClient{ctrl: ctrl}
mock.recorder = &MockRPCClientMockRecorder{mock}
return mock
}
|
go
|
func NewMockRPCClient(ctrl *gomock.Controller) *MockRPCClient {
mock := &MockRPCClient{ctrl: ctrl}
mock.recorder = &MockRPCClientMockRecorder{mock}
return mock
}
|
[
"func",
"NewMockRPCClient",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockRPCClient",
"{",
"mock",
":=",
"&",
"MockRPCClient",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockRPCClientMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] |
// NewMockRPCClient creates a new mock instance
|
[
"NewMockRPCClient",
"creates",
"a",
"new",
"mock",
"instance"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/mocks/cluster.go#L107-L111
|
train
|
topfreegames/pitaya
|
cluster/mocks/cluster.go
|
Send
|
func (mr *MockRPCClientMockRecorder) Send(route, data interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockRPCClient)(nil).Send), route, data)
}
|
go
|
func (mr *MockRPCClientMockRecorder) Send(route, data interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockRPCClient)(nil).Send), route, data)
}
|
[
"func",
"(",
"mr",
"*",
"MockRPCClientMockRecorder",
")",
"Send",
"(",
"route",
",",
"data",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockRPCClient",
")",
"(",
"nil",
")",
".",
"Send",
")",
",",
"route",
",",
"data",
")",
"\n",
"}"
] |
// Send indicates an expected call of Send
|
[
"Send",
"indicates",
"an",
"expected",
"call",
"of",
"Send"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/mocks/cluster.go#L126-L128
|
train
|
topfreegames/pitaya
|
cluster/mocks/cluster.go
|
SendPush
|
func (m *MockRPCClient) SendPush(userID string, frontendSv *cluster.Server, push *protos.Push) error {
ret := m.ctrl.Call(m, "SendPush", userID, frontendSv, push)
ret0, _ := ret[0].(error)
return ret0
}
|
go
|
func (m *MockRPCClient) SendPush(userID string, frontendSv *cluster.Server, push *protos.Push) error {
ret := m.ctrl.Call(m, "SendPush", userID, frontendSv, push)
ret0, _ := ret[0].(error)
return ret0
}
|
[
"func",
"(",
"m",
"*",
"MockRPCClient",
")",
"SendPush",
"(",
"userID",
"string",
",",
"frontendSv",
"*",
"cluster",
".",
"Server",
",",
"push",
"*",
"protos",
".",
"Push",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"userID",
",",
"frontendSv",
",",
"push",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] |
// SendPush mocks base method
|
[
"SendPush",
"mocks",
"base",
"method"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/mocks/cluster.go#L131-L135
|
train
|
topfreegames/pitaya
|
cluster/mocks/cluster.go
|
SendPush
|
func (mr *MockRPCClientMockRecorder) SendPush(userID, frontendSv, push interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendPush", reflect.TypeOf((*MockRPCClient)(nil).SendPush), userID, frontendSv, push)
}
|
go
|
func (mr *MockRPCClientMockRecorder) SendPush(userID, frontendSv, push interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendPush", reflect.TypeOf((*MockRPCClient)(nil).SendPush), userID, frontendSv, push)
}
|
[
"func",
"(",
"mr",
"*",
"MockRPCClientMockRecorder",
")",
"SendPush",
"(",
"userID",
",",
"frontendSv",
",",
"push",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockRPCClient",
")",
"(",
"nil",
")",
".",
"SendPush",
")",
",",
"userID",
",",
"frontendSv",
",",
"push",
")",
"\n",
"}"
] |
// SendPush indicates an expected call of SendPush
|
[
"SendPush",
"indicates",
"an",
"expected",
"call",
"of",
"SendPush"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/mocks/cluster.go#L138-L140
|
train
|
topfreegames/pitaya
|
cluster/mocks/cluster.go
|
SendKick
|
func (m *MockRPCClient) SendKick(userID, serverType string, kick *protos.KickMsg) error {
ret := m.ctrl.Call(m, "SendKick", userID, serverType, kick)
ret0, _ := ret[0].(error)
return ret0
}
|
go
|
func (m *MockRPCClient) SendKick(userID, serverType string, kick *protos.KickMsg) error {
ret := m.ctrl.Call(m, "SendKick", userID, serverType, kick)
ret0, _ := ret[0].(error)
return ret0
}
|
[
"func",
"(",
"m",
"*",
"MockRPCClient",
")",
"SendKick",
"(",
"userID",
",",
"serverType",
"string",
",",
"kick",
"*",
"protos",
".",
"KickMsg",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"userID",
",",
"serverType",
",",
"kick",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] |
// SendKick mocks base method
|
[
"SendKick",
"mocks",
"base",
"method"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/mocks/cluster.go#L143-L147
|
train
|
topfreegames/pitaya
|
cluster/mocks/cluster.go
|
SendKick
|
func (mr *MockRPCClientMockRecorder) SendKick(userID, serverType, kick interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendKick", reflect.TypeOf((*MockRPCClient)(nil).SendKick), userID, serverType, kick)
}
|
go
|
func (mr *MockRPCClientMockRecorder) SendKick(userID, serverType, kick interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendKick", reflect.TypeOf((*MockRPCClient)(nil).SendKick), userID, serverType, kick)
}
|
[
"func",
"(",
"mr",
"*",
"MockRPCClientMockRecorder",
")",
"SendKick",
"(",
"userID",
",",
"serverType",
",",
"kick",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockRPCClient",
")",
"(",
"nil",
")",
".",
"SendKick",
")",
",",
"userID",
",",
"serverType",
",",
"kick",
")",
"\n",
"}"
] |
// SendKick indicates an expected call of SendKick
|
[
"SendKick",
"indicates",
"an",
"expected",
"call",
"of",
"SendKick"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/mocks/cluster.go#L150-L152
|
train
|
topfreegames/pitaya
|
cluster/mocks/cluster.go
|
BroadcastSessionBind
|
func (m *MockRPCClient) BroadcastSessionBind(uid string) error {
ret := m.ctrl.Call(m, "BroadcastSessionBind", uid)
ret0, _ := ret[0].(error)
return ret0
}
|
go
|
func (m *MockRPCClient) BroadcastSessionBind(uid string) error {
ret := m.ctrl.Call(m, "BroadcastSessionBind", uid)
ret0, _ := ret[0].(error)
return ret0
}
|
[
"func",
"(",
"m",
"*",
"MockRPCClient",
")",
"BroadcastSessionBind",
"(",
"uid",
"string",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"uid",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] |
// BroadcastSessionBind mocks base method
|
[
"BroadcastSessionBind",
"mocks",
"base",
"method"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/mocks/cluster.go#L155-L159
|
train
|
topfreegames/pitaya
|
cluster/mocks/cluster.go
|
BroadcastSessionBind
|
func (mr *MockRPCClientMockRecorder) BroadcastSessionBind(uid interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BroadcastSessionBind", reflect.TypeOf((*MockRPCClient)(nil).BroadcastSessionBind), uid)
}
|
go
|
func (mr *MockRPCClientMockRecorder) BroadcastSessionBind(uid interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BroadcastSessionBind", reflect.TypeOf((*MockRPCClient)(nil).BroadcastSessionBind), uid)
}
|
[
"func",
"(",
"mr",
"*",
"MockRPCClientMockRecorder",
")",
"BroadcastSessionBind",
"(",
"uid",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockRPCClient",
")",
"(",
"nil",
")",
".",
"BroadcastSessionBind",
")",
",",
"uid",
")",
"\n",
"}"
] |
// BroadcastSessionBind indicates an expected call of BroadcastSessionBind
|
[
"BroadcastSessionBind",
"indicates",
"an",
"expected",
"call",
"of",
"BroadcastSessionBind"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/mocks/cluster.go#L162-L164
|
train
|
topfreegames/pitaya
|
cluster/mocks/cluster.go
|
Call
|
func (m *MockRPCClient) Call(ctx context.Context, rpcType protos.RPCType, route *route.Route, session *session.Session, msg *message.Message, server *cluster.Server) (*protos.Response, error) {
ret := m.ctrl.Call(m, "Call", ctx, rpcType, route, session, msg, server)
ret0, _ := ret[0].(*protos.Response)
ret1, _ := ret[1].(error)
return ret0, ret1
}
|
go
|
func (m *MockRPCClient) Call(ctx context.Context, rpcType protos.RPCType, route *route.Route, session *session.Session, msg *message.Message, server *cluster.Server) (*protos.Response, error) {
ret := m.ctrl.Call(m, "Call", ctx, rpcType, route, session, msg, server)
ret0, _ := ret[0].(*protos.Response)
ret1, _ := ret[1].(error)
return ret0, ret1
}
|
[
"func",
"(",
"m",
"*",
"MockRPCClient",
")",
"Call",
"(",
"ctx",
"context",
".",
"Context",
",",
"rpcType",
"protos",
".",
"RPCType",
",",
"route",
"*",
"route",
".",
"Route",
",",
"session",
"*",
"session",
".",
"Session",
",",
"msg",
"*",
"message",
".",
"Message",
",",
"server",
"*",
"cluster",
".",
"Server",
")",
"(",
"*",
"protos",
".",
"Response",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"ctx",
",",
"rpcType",
",",
"route",
",",
"session",
",",
"msg",
",",
"server",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"protos",
".",
"Response",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] |
// Call mocks base method
|
[
"Call",
"mocks",
"base",
"method"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/mocks/cluster.go#L167-L172
|
train
|
topfreegames/pitaya
|
cluster/mocks/cluster.go
|
NewMockSDListener
|
func NewMockSDListener(ctrl *gomock.Controller) *MockSDListener {
mock := &MockSDListener{ctrl: ctrl}
mock.recorder = &MockSDListenerMockRecorder{mock}
return mock
}
|
go
|
func NewMockSDListener(ctrl *gomock.Controller) *MockSDListener {
mock := &MockSDListener{ctrl: ctrl}
mock.recorder = &MockSDListenerMockRecorder{mock}
return mock
}
|
[
"func",
"NewMockSDListener",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockSDListener",
"{",
"mock",
":=",
"&",
"MockSDListener",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockSDListenerMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] |
// NewMockSDListener creates a new mock instance
|
[
"NewMockSDListener",
"creates",
"a",
"new",
"mock",
"instance"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/mocks/cluster.go#L235-L239
|
train
|
topfreegames/pitaya
|
cluster/mocks/cluster.go
|
AddServer
|
func (m *MockSDListener) AddServer(arg0 *cluster.Server) {
m.ctrl.Call(m, "AddServer", arg0)
}
|
go
|
func (m *MockSDListener) AddServer(arg0 *cluster.Server) {
m.ctrl.Call(m, "AddServer", arg0)
}
|
[
"func",
"(",
"m",
"*",
"MockSDListener",
")",
"AddServer",
"(",
"arg0",
"*",
"cluster",
".",
"Server",
")",
"{",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"}"
] |
// AddServer mocks base method
|
[
"AddServer",
"mocks",
"base",
"method"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/mocks/cluster.go#L247-L249
|
train
|
topfreegames/pitaya
|
cluster/mocks/cluster.go
|
RemoveServer
|
func (m *MockSDListener) RemoveServer(arg0 *cluster.Server) {
m.ctrl.Call(m, "RemoveServer", arg0)
}
|
go
|
func (m *MockSDListener) RemoveServer(arg0 *cluster.Server) {
m.ctrl.Call(m, "RemoveServer", arg0)
}
|
[
"func",
"(",
"m",
"*",
"MockSDListener",
")",
"RemoveServer",
"(",
"arg0",
"*",
"cluster",
".",
"Server",
")",
"{",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"}"
] |
// RemoveServer mocks base method
|
[
"RemoveServer",
"mocks",
"base",
"method"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/mocks/cluster.go#L257-L259
|
train
|
topfreegames/pitaya
|
cluster/mocks/cluster.go
|
RemoveServer
|
func (mr *MockSDListenerMockRecorder) RemoveServer(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveServer", reflect.TypeOf((*MockSDListener)(nil).RemoveServer), arg0)
}
|
go
|
func (mr *MockSDListenerMockRecorder) RemoveServer(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveServer", reflect.TypeOf((*MockSDListener)(nil).RemoveServer), arg0)
}
|
[
"func",
"(",
"mr",
"*",
"MockSDListenerMockRecorder",
")",
"RemoveServer",
"(",
"arg0",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockSDListener",
")",
"(",
"nil",
")",
".",
"RemoveServer",
")",
",",
"arg0",
")",
"\n",
"}"
] |
// RemoveServer indicates an expected call of RemoveServer
|
[
"RemoveServer",
"indicates",
"an",
"expected",
"call",
"of",
"RemoveServer"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/mocks/cluster.go#L262-L264
|
train
|
topfreegames/pitaya
|
cluster/mocks/cluster.go
|
NewMockRemoteBindingListener
|
func NewMockRemoteBindingListener(ctrl *gomock.Controller) *MockRemoteBindingListener {
mock := &MockRemoteBindingListener{ctrl: ctrl}
mock.recorder = &MockRemoteBindingListenerMockRecorder{mock}
return mock
}
|
go
|
func NewMockRemoteBindingListener(ctrl *gomock.Controller) *MockRemoteBindingListener {
mock := &MockRemoteBindingListener{ctrl: ctrl}
mock.recorder = &MockRemoteBindingListenerMockRecorder{mock}
return mock
}
|
[
"func",
"NewMockRemoteBindingListener",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockRemoteBindingListener",
"{",
"mock",
":=",
"&",
"MockRemoteBindingListener",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockRemoteBindingListenerMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] |
// NewMockRemoteBindingListener creates a new mock instance
|
[
"NewMockRemoteBindingListener",
"creates",
"a",
"new",
"mock",
"instance"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/mocks/cluster.go#L278-L282
|
train
|
topfreegames/pitaya
|
cluster/mocks/cluster.go
|
OnUserBind
|
func (m *MockRemoteBindingListener) OnUserBind(uid, fid string) {
m.ctrl.Call(m, "OnUserBind", uid, fid)
}
|
go
|
func (m *MockRemoteBindingListener) OnUserBind(uid, fid string) {
m.ctrl.Call(m, "OnUserBind", uid, fid)
}
|
[
"func",
"(",
"m",
"*",
"MockRemoteBindingListener",
")",
"OnUserBind",
"(",
"uid",
",",
"fid",
"string",
")",
"{",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"uid",
",",
"fid",
")",
"\n",
"}"
] |
// OnUserBind mocks base method
|
[
"OnUserBind",
"mocks",
"base",
"method"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/mocks/cluster.go#L290-L292
|
train
|
topfreegames/pitaya
|
cluster/mocks/cluster.go
|
OnUserBind
|
func (mr *MockRemoteBindingListenerMockRecorder) OnUserBind(uid, fid interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnUserBind", reflect.TypeOf((*MockRemoteBindingListener)(nil).OnUserBind), uid, fid)
}
|
go
|
func (mr *MockRemoteBindingListenerMockRecorder) OnUserBind(uid, fid interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnUserBind", reflect.TypeOf((*MockRemoteBindingListener)(nil).OnUserBind), uid, fid)
}
|
[
"func",
"(",
"mr",
"*",
"MockRemoteBindingListenerMockRecorder",
")",
"OnUserBind",
"(",
"uid",
",",
"fid",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockRemoteBindingListener",
")",
"(",
"nil",
")",
".",
"OnUserBind",
")",
",",
"uid",
",",
"fid",
")",
"\n",
"}"
] |
// OnUserBind indicates an expected call of OnUserBind
|
[
"OnUserBind",
"indicates",
"an",
"expected",
"call",
"of",
"OnUserBind"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/mocks/cluster.go#L295-L297
|
train
|
topfreegames/pitaya
|
examples/demo/worker/services/metagame.go
|
LogRemote
|
func (m *Metagame) LogRemote(ctx context.Context, arg *protos.Arg) (*protos.Response, error) {
logger.Log.Infof("argument %+v\n", arg)
return &protos.Response{Code: 200, Msg: "ok"}, nil
}
|
go
|
func (m *Metagame) LogRemote(ctx context.Context, arg *protos.Arg) (*protos.Response, error) {
logger.Log.Infof("argument %+v\n", arg)
return &protos.Response{Code: 200, Msg: "ok"}, nil
}
|
[
"func",
"(",
"m",
"*",
"Metagame",
")",
"LogRemote",
"(",
"ctx",
"context",
".",
"Context",
",",
"arg",
"*",
"protos",
".",
"Arg",
")",
"(",
"*",
"protos",
".",
"Response",
",",
"error",
")",
"{",
"logger",
".",
"Log",
".",
"Infof",
"(",
"\"",
"\\n",
"\"",
",",
"arg",
")",
"\n",
"return",
"&",
"protos",
".",
"Response",
"{",
"Code",
":",
"200",
",",
"Msg",
":",
"\"",
"\"",
"}",
",",
"nil",
"\n",
"}"
] |
// LogRemote logs argument when called
|
[
"LogRemote",
"logs",
"argument",
"when",
"called"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/examples/demo/worker/services/metagame.go#L17-L20
|
train
|
topfreegames/pitaya
|
context/context.go
|
GetFromPropagateCtx
|
func GetFromPropagateCtx(ctx context.Context, key string) interface{} {
propagate := ToMap(ctx)
if val, ok := propagate[key]; ok {
return val
}
return nil
}
|
go
|
func GetFromPropagateCtx(ctx context.Context, key string) interface{} {
propagate := ToMap(ctx)
if val, ok := propagate[key]; ok {
return val
}
return nil
}
|
[
"func",
"GetFromPropagateCtx",
"(",
"ctx",
"context",
".",
"Context",
",",
"key",
"string",
")",
"interface",
"{",
"}",
"{",
"propagate",
":=",
"ToMap",
"(",
"ctx",
")",
"\n",
"if",
"val",
",",
"ok",
":=",
"propagate",
"[",
"key",
"]",
";",
"ok",
"{",
"return",
"val",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// GetFromPropagateCtx get a value from the propagate
|
[
"GetFromPropagateCtx",
"get",
"a",
"value",
"from",
"the",
"propagate"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/context/context.go#L38-L44
|
train
|
topfreegames/pitaya
|
context/context.go
|
FromMap
|
func FromMap(val map[string]interface{}) context.Context {
return context.WithValue(context.Background(), constants.PropagateCtxKey, val)
}
|
go
|
func FromMap(val map[string]interface{}) context.Context {
return context.WithValue(context.Background(), constants.PropagateCtxKey, val)
}
|
[
"func",
"FromMap",
"(",
"val",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"context",
".",
"Context",
"{",
"return",
"context",
".",
"WithValue",
"(",
"context",
".",
"Background",
"(",
")",
",",
"constants",
".",
"PropagateCtxKey",
",",
"val",
")",
"\n",
"}"
] |
// FromMap creates a new context from a map with propagated values
|
[
"FromMap",
"creates",
"a",
"new",
"context",
"from",
"a",
"map",
"with",
"propagated",
"values"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/context/context.go#L59-L61
|
train
|
topfreegames/pitaya
|
context/context.go
|
Encode
|
func Encode(ctx context.Context) ([]byte, error) {
m := ToMap(ctx)
if len(m) > 0 {
return json.Marshal(m)
}
return nil, nil
}
|
go
|
func Encode(ctx context.Context) ([]byte, error) {
m := ToMap(ctx)
if len(m) > 0 {
return json.Marshal(m)
}
return nil, nil
}
|
[
"func",
"Encode",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"m",
":=",
"ToMap",
"(",
"ctx",
")",
"\n",
"if",
"len",
"(",
"m",
")",
">",
"0",
"{",
"return",
"json",
".",
"Marshal",
"(",
"m",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"nil",
"\n",
"}"
] |
// Encode returns the given propagatable context encoded in binary format
|
[
"Encode",
"returns",
"the",
"given",
"propagatable",
"context",
"encoded",
"in",
"binary",
"format"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/context/context.go#L64-L70
|
train
|
topfreegames/pitaya
|
context/context.go
|
Decode
|
func Decode(m []byte) (context.Context, error) {
if len(m) == 0 {
// TODO maybe return an error
return nil, nil
}
mp := make(map[string]interface{}, 0)
err := json.Unmarshal(m, &mp)
if err != nil {
return nil, err
}
return FromMap(mp), nil
}
|
go
|
func Decode(m []byte) (context.Context, error) {
if len(m) == 0 {
// TODO maybe return an error
return nil, nil
}
mp := make(map[string]interface{}, 0)
err := json.Unmarshal(m, &mp)
if err != nil {
return nil, err
}
return FromMap(mp), nil
}
|
[
"func",
"Decode",
"(",
"m",
"[",
"]",
"byte",
")",
"(",
"context",
".",
"Context",
",",
"error",
")",
"{",
"if",
"len",
"(",
"m",
")",
"==",
"0",
"{",
"// TODO maybe return an error",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"mp",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"0",
")",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"m",
",",
"&",
"mp",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"FromMap",
"(",
"mp",
")",
",",
"nil",
"\n",
"}"
] |
// Decode returns a context given a binary encoded message
|
[
"Decode",
"returns",
"a",
"context",
"given",
"a",
"binary",
"encoded",
"message"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/context/context.go#L73-L84
|
train
|
topfreegames/pitaya
|
cluster/etcd_service_discovery.go
|
renewLease
|
func (sd *etcdServiceDiscovery) renewLease() error {
c := make(chan error)
go func() {
defer close(c)
logger.Log.Infof("waiting for etcd lease")
err := sd.grantLease()
if err != nil {
c <- err
return
}
err = sd.bootstrapServer(sd.server)
c <- err
}()
select {
case err := <-c:
return err
case <-time.After(sd.grantLeaseTimeout):
return constants.ErrEtcdGrantLeaseTimeout
}
}
|
go
|
func (sd *etcdServiceDiscovery) renewLease() error {
c := make(chan error)
go func() {
defer close(c)
logger.Log.Infof("waiting for etcd lease")
err := sd.grantLease()
if err != nil {
c <- err
return
}
err = sd.bootstrapServer(sd.server)
c <- err
}()
select {
case err := <-c:
return err
case <-time.After(sd.grantLeaseTimeout):
return constants.ErrEtcdGrantLeaseTimeout
}
}
|
[
"func",
"(",
"sd",
"*",
"etcdServiceDiscovery",
")",
"renewLease",
"(",
")",
"error",
"{",
"c",
":=",
"make",
"(",
"chan",
"error",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"defer",
"close",
"(",
"c",
")",
"\n",
"logger",
".",
"Log",
".",
"Infof",
"(",
"\"",
"\"",
")",
"\n",
"err",
":=",
"sd",
".",
"grantLease",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"c",
"<-",
"err",
"\n",
"return",
"\n",
"}",
"\n",
"err",
"=",
"sd",
".",
"bootstrapServer",
"(",
"sd",
".",
"server",
")",
"\n",
"c",
"<-",
"err",
"\n",
"}",
"(",
")",
"\n",
"select",
"{",
"case",
"err",
":=",
"<-",
"c",
":",
"return",
"err",
"\n",
"case",
"<-",
"time",
".",
"After",
"(",
"sd",
".",
"grantLeaseTimeout",
")",
":",
"return",
"constants",
".",
"ErrEtcdGrantLeaseTimeout",
"\n",
"}",
"\n",
"}"
] |
// renewLease reestablishes connection with etcd
|
[
"renewLease",
"reestablishes",
"connection",
"with",
"etcd"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/etcd_service_discovery.go#L155-L174
|
train
|
topfreegames/pitaya
|
cluster/etcd_service_discovery.go
|
AddListener
|
func (sd *etcdServiceDiscovery) AddListener(listener SDListener) {
sd.listeners = append(sd.listeners, listener)
}
|
go
|
func (sd *etcdServiceDiscovery) AddListener(listener SDListener) {
sd.listeners = append(sd.listeners, listener)
}
|
[
"func",
"(",
"sd",
"*",
"etcdServiceDiscovery",
")",
"AddListener",
"(",
"listener",
"SDListener",
")",
"{",
"sd",
".",
"listeners",
"=",
"append",
"(",
"sd",
".",
"listeners",
",",
"listener",
")",
"\n",
"}"
] |
// AddListener adds a listener to etcd service discovery
|
[
"AddListener",
"adds",
"a",
"listener",
"to",
"etcd",
"service",
"discovery"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/etcd_service_discovery.go#L217-L219
|
train
|
topfreegames/pitaya
|
cluster/etcd_service_discovery.go
|
GetServersByType
|
func (sd *etcdServiceDiscovery) GetServersByType(serverType string) (map[string]*Server, error) {
sd.mapByTypeLock.RLock()
defer sd.mapByTypeLock.RUnlock()
if m, ok := sd.serverMapByType[serverType]; ok && len(m) > 0 {
// Create a new map to avoid concurrent read and write access to the
// map, this also prevents accidental changes to the list of servers
// kept by the service discovery.
ret := make(map[string]*Server, len(sd.serverMapByType))
for k, v := range sd.serverMapByType[serverType] {
ret[k] = v
}
return ret, nil
}
return nil, constants.ErrNoServersAvailableOfType
}
|
go
|
func (sd *etcdServiceDiscovery) GetServersByType(serverType string) (map[string]*Server, error) {
sd.mapByTypeLock.RLock()
defer sd.mapByTypeLock.RUnlock()
if m, ok := sd.serverMapByType[serverType]; ok && len(m) > 0 {
// Create a new map to avoid concurrent read and write access to the
// map, this also prevents accidental changes to the list of servers
// kept by the service discovery.
ret := make(map[string]*Server, len(sd.serverMapByType))
for k, v := range sd.serverMapByType[serverType] {
ret[k] = v
}
return ret, nil
}
return nil, constants.ErrNoServersAvailableOfType
}
|
[
"func",
"(",
"sd",
"*",
"etcdServiceDiscovery",
")",
"GetServersByType",
"(",
"serverType",
"string",
")",
"(",
"map",
"[",
"string",
"]",
"*",
"Server",
",",
"error",
")",
"{",
"sd",
".",
"mapByTypeLock",
".",
"RLock",
"(",
")",
"\n",
"defer",
"sd",
".",
"mapByTypeLock",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"m",
",",
"ok",
":=",
"sd",
".",
"serverMapByType",
"[",
"serverType",
"]",
";",
"ok",
"&&",
"len",
"(",
"m",
")",
">",
"0",
"{",
"// Create a new map to avoid concurrent read and write access to the",
"// map, this also prevents accidental changes to the list of servers",
"// kept by the service discovery.",
"ret",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"Server",
",",
"len",
"(",
"sd",
".",
"serverMapByType",
")",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"sd",
".",
"serverMapByType",
"[",
"serverType",
"]",
"{",
"ret",
"[",
"k",
"]",
"=",
"v",
"\n",
"}",
"\n",
"return",
"ret",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"constants",
".",
"ErrNoServersAvailableOfType",
"\n",
"}"
] |
// GetServersByType returns a slice with all the servers of a certain type
|
[
"GetServersByType",
"returns",
"a",
"slice",
"with",
"all",
"the",
"servers",
"of",
"a",
"certain",
"type"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/etcd_service_discovery.go#L282-L296
|
train
|
topfreegames/pitaya
|
cluster/etcd_service_discovery.go
|
GetServers
|
func (sd *etcdServiceDiscovery) GetServers() []*Server {
ret := make([]*Server, 0)
sd.serverMapByID.Range(func(k, v interface{}) bool {
ret = append(ret, v.(*Server))
return true
})
return ret
}
|
go
|
func (sd *etcdServiceDiscovery) GetServers() []*Server {
ret := make([]*Server, 0)
sd.serverMapByID.Range(func(k, v interface{}) bool {
ret = append(ret, v.(*Server))
return true
})
return ret
}
|
[
"func",
"(",
"sd",
"*",
"etcdServiceDiscovery",
")",
"GetServers",
"(",
")",
"[",
"]",
"*",
"Server",
"{",
"ret",
":=",
"make",
"(",
"[",
"]",
"*",
"Server",
",",
"0",
")",
"\n",
"sd",
".",
"serverMapByID",
".",
"Range",
"(",
"func",
"(",
"k",
",",
"v",
"interface",
"{",
"}",
")",
"bool",
"{",
"ret",
"=",
"append",
"(",
"ret",
",",
"v",
".",
"(",
"*",
"Server",
")",
")",
"\n",
"return",
"true",
"\n",
"}",
")",
"\n",
"return",
"ret",
"\n",
"}"
] |
// GetServers returns a slice with all the servers
|
[
"GetServers",
"returns",
"a",
"slice",
"with",
"all",
"the",
"servers"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/etcd_service_discovery.go#L299-L306
|
train
|
topfreegames/pitaya
|
cluster/etcd_service_discovery.go
|
GetServer
|
func (sd *etcdServiceDiscovery) GetServer(id string) (*Server, error) {
if sv, ok := sd.serverMapByID.Load(id); ok {
return sv.(*Server), nil
}
return nil, constants.ErrNoServerWithID
}
|
go
|
func (sd *etcdServiceDiscovery) GetServer(id string) (*Server, error) {
if sv, ok := sd.serverMapByID.Load(id); ok {
return sv.(*Server), nil
}
return nil, constants.ErrNoServerWithID
}
|
[
"func",
"(",
"sd",
"*",
"etcdServiceDiscovery",
")",
"GetServer",
"(",
"id",
"string",
")",
"(",
"*",
"Server",
",",
"error",
")",
"{",
"if",
"sv",
",",
"ok",
":=",
"sd",
".",
"serverMapByID",
".",
"Load",
"(",
"id",
")",
";",
"ok",
"{",
"return",
"sv",
".",
"(",
"*",
"Server",
")",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"constants",
".",
"ErrNoServerWithID",
"\n",
"}"
] |
// GetServer returns a server given it's id
|
[
"GetServer",
"returns",
"a",
"server",
"given",
"it",
"s",
"id"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/etcd_service_discovery.go#L321-L326
|
train
|
topfreegames/pitaya
|
cluster/etcd_service_discovery.go
|
Init
|
func (sd *etcdServiceDiscovery) Init() error {
sd.running = true
var cli *clientv3.Client
var err error
if sd.cli == nil {
cli, err = clientv3.New(clientv3.Config{
Endpoints: sd.etcdEndpoints,
DialTimeout: sd.etcdDialTimeout,
})
if err != nil {
return err
}
sd.cli = cli
}
// namespaced etcd :)
sd.cli.KV = namespace.NewKV(sd.cli.KV, sd.etcdPrefix)
sd.cli.Watcher = namespace.NewWatcher(sd.cli.Watcher, sd.etcdPrefix)
sd.cli.Lease = namespace.NewLease(sd.cli.Lease, sd.etcdPrefix)
err = sd.bootstrap()
if err != nil {
return err
}
// update servers
syncServersTicker := time.NewTicker(sd.syncServersInterval)
go func() {
for sd.running {
select {
case <-syncServersTicker.C:
err := sd.SyncServers()
if err != nil {
logger.Log.Errorf("error resyncing servers: %s", err.Error())
}
case <-sd.stopChan:
return
}
}
}()
go sd.watchEtcdChanges()
return nil
}
|
go
|
func (sd *etcdServiceDiscovery) Init() error {
sd.running = true
var cli *clientv3.Client
var err error
if sd.cli == nil {
cli, err = clientv3.New(clientv3.Config{
Endpoints: sd.etcdEndpoints,
DialTimeout: sd.etcdDialTimeout,
})
if err != nil {
return err
}
sd.cli = cli
}
// namespaced etcd :)
sd.cli.KV = namespace.NewKV(sd.cli.KV, sd.etcdPrefix)
sd.cli.Watcher = namespace.NewWatcher(sd.cli.Watcher, sd.etcdPrefix)
sd.cli.Lease = namespace.NewLease(sd.cli.Lease, sd.etcdPrefix)
err = sd.bootstrap()
if err != nil {
return err
}
// update servers
syncServersTicker := time.NewTicker(sd.syncServersInterval)
go func() {
for sd.running {
select {
case <-syncServersTicker.C:
err := sd.SyncServers()
if err != nil {
logger.Log.Errorf("error resyncing servers: %s", err.Error())
}
case <-sd.stopChan:
return
}
}
}()
go sd.watchEtcdChanges()
return nil
}
|
[
"func",
"(",
"sd",
"*",
"etcdServiceDiscovery",
")",
"Init",
"(",
")",
"error",
"{",
"sd",
".",
"running",
"=",
"true",
"\n",
"var",
"cli",
"*",
"clientv3",
".",
"Client",
"\n",
"var",
"err",
"error",
"\n",
"if",
"sd",
".",
"cli",
"==",
"nil",
"{",
"cli",
",",
"err",
"=",
"clientv3",
".",
"New",
"(",
"clientv3",
".",
"Config",
"{",
"Endpoints",
":",
"sd",
".",
"etcdEndpoints",
",",
"DialTimeout",
":",
"sd",
".",
"etcdDialTimeout",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"sd",
".",
"cli",
"=",
"cli",
"\n",
"}",
"\n\n",
"// namespaced etcd :)",
"sd",
".",
"cli",
".",
"KV",
"=",
"namespace",
".",
"NewKV",
"(",
"sd",
".",
"cli",
".",
"KV",
",",
"sd",
".",
"etcdPrefix",
")",
"\n",
"sd",
".",
"cli",
".",
"Watcher",
"=",
"namespace",
".",
"NewWatcher",
"(",
"sd",
".",
"cli",
".",
"Watcher",
",",
"sd",
".",
"etcdPrefix",
")",
"\n",
"sd",
".",
"cli",
".",
"Lease",
"=",
"namespace",
".",
"NewLease",
"(",
"sd",
".",
"cli",
".",
"Lease",
",",
"sd",
".",
"etcdPrefix",
")",
"\n\n",
"err",
"=",
"sd",
".",
"bootstrap",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// update servers",
"syncServersTicker",
":=",
"time",
".",
"NewTicker",
"(",
"sd",
".",
"syncServersInterval",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"for",
"sd",
".",
"running",
"{",
"select",
"{",
"case",
"<-",
"syncServersTicker",
".",
"C",
":",
"err",
":=",
"sd",
".",
"SyncServers",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"case",
"<-",
"sd",
".",
"stopChan",
":",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"go",
"sd",
".",
"watchEtcdChanges",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Init starts the service discovery client
|
[
"Init",
"starts",
"the",
"service",
"discovery",
"client"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/etcd_service_discovery.go#L329-L372
|
train
|
topfreegames/pitaya
|
cluster/etcd_service_discovery.go
|
SyncServers
|
func (sd *etcdServiceDiscovery) SyncServers() error {
keys, err := sd.cli.Get(
context.TODO(),
"servers/",
clientv3.WithPrefix(),
clientv3.WithKeysOnly(),
)
if err != nil {
return err
}
// delete invalid servers (local ones that are not in etcd)
allIds := make([]string, 0)
// filter servers I need to grab info
for _, kv := range keys.Kvs {
svType, svID, err := parseEtcdKey(string(kv.Key))
if err != nil {
logger.Log.Warnf("failed to parse etcd key %s, error: %s", kv.Key, err.Error())
}
allIds = append(allIds, svID)
// TODO is this slow? if so we can paralellize
if _, ok := sd.serverMapByID.Load(svID); !ok {
logger.Log.Debugf("loading info from missing server: %s/%s", svType, svID)
sv, err := sd.getServerFromEtcd(svType, svID)
if err != nil {
logger.Log.Errorf("error getting server from etcd: %s, error: %s", svID, err.Error())
continue
}
sd.addServer(sv)
}
}
sd.deleteLocalInvalidServers(allIds)
sd.printServers()
sd.lastSyncTime = time.Now()
return nil
}
|
go
|
func (sd *etcdServiceDiscovery) SyncServers() error {
keys, err := sd.cli.Get(
context.TODO(),
"servers/",
clientv3.WithPrefix(),
clientv3.WithKeysOnly(),
)
if err != nil {
return err
}
// delete invalid servers (local ones that are not in etcd)
allIds := make([]string, 0)
// filter servers I need to grab info
for _, kv := range keys.Kvs {
svType, svID, err := parseEtcdKey(string(kv.Key))
if err != nil {
logger.Log.Warnf("failed to parse etcd key %s, error: %s", kv.Key, err.Error())
}
allIds = append(allIds, svID)
// TODO is this slow? if so we can paralellize
if _, ok := sd.serverMapByID.Load(svID); !ok {
logger.Log.Debugf("loading info from missing server: %s/%s", svType, svID)
sv, err := sd.getServerFromEtcd(svType, svID)
if err != nil {
logger.Log.Errorf("error getting server from etcd: %s, error: %s", svID, err.Error())
continue
}
sd.addServer(sv)
}
}
sd.deleteLocalInvalidServers(allIds)
sd.printServers()
sd.lastSyncTime = time.Now()
return nil
}
|
[
"func",
"(",
"sd",
"*",
"etcdServiceDiscovery",
")",
"SyncServers",
"(",
")",
"error",
"{",
"keys",
",",
"err",
":=",
"sd",
".",
"cli",
".",
"Get",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"\"",
"\"",
",",
"clientv3",
".",
"WithPrefix",
"(",
")",
",",
"clientv3",
".",
"WithKeysOnly",
"(",
")",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// delete invalid servers (local ones that are not in etcd)",
"allIds",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
")",
"\n\n",
"// filter servers I need to grab info",
"for",
"_",
",",
"kv",
":=",
"range",
"keys",
".",
"Kvs",
"{",
"svType",
",",
"svID",
",",
"err",
":=",
"parseEtcdKey",
"(",
"string",
"(",
"kv",
".",
"Key",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Log",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"kv",
".",
"Key",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"allIds",
"=",
"append",
"(",
"allIds",
",",
"svID",
")",
"\n",
"// TODO is this slow? if so we can paralellize",
"if",
"_",
",",
"ok",
":=",
"sd",
".",
"serverMapByID",
".",
"Load",
"(",
"svID",
")",
";",
"!",
"ok",
"{",
"logger",
".",
"Log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"svType",
",",
"svID",
")",
"\n",
"sv",
",",
"err",
":=",
"sd",
".",
"getServerFromEtcd",
"(",
"svType",
",",
"svID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"svID",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"sd",
".",
"addServer",
"(",
"sv",
")",
"\n",
"}",
"\n",
"}",
"\n",
"sd",
".",
"deleteLocalInvalidServers",
"(",
"allIds",
")",
"\n\n",
"sd",
".",
"printServers",
"(",
")",
"\n",
"sd",
".",
"lastSyncTime",
"=",
"time",
".",
"Now",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// SyncServers gets all servers from etcd
|
[
"SyncServers",
"gets",
"all",
"servers",
"from",
"etcd"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/etcd_service_discovery.go#L402-L439
|
train
|
topfreegames/pitaya
|
cluster/etcd_service_discovery.go
|
revoke
|
func (sd *etcdServiceDiscovery) revoke() error {
close(sd.stopLeaseChan)
c := make(chan error)
defer close(c)
go func() {
logger.Log.Debug("waiting for etcd revoke")
_, err := sd.cli.Revoke(context.TODO(), sd.leaseID)
c <- err
logger.Log.Debug("finished waiting for etcd revoke")
}()
select {
case err := <-c:
return err // completed normally
case <-time.After(sd.revokeTimeout):
logger.Log.Warn("timed out waiting for etcd revoke")
return nil // timed out
}
}
|
go
|
func (sd *etcdServiceDiscovery) revoke() error {
close(sd.stopLeaseChan)
c := make(chan error)
defer close(c)
go func() {
logger.Log.Debug("waiting for etcd revoke")
_, err := sd.cli.Revoke(context.TODO(), sd.leaseID)
c <- err
logger.Log.Debug("finished waiting for etcd revoke")
}()
select {
case err := <-c:
return err // completed normally
case <-time.After(sd.revokeTimeout):
logger.Log.Warn("timed out waiting for etcd revoke")
return nil // timed out
}
}
|
[
"func",
"(",
"sd",
"*",
"etcdServiceDiscovery",
")",
"revoke",
"(",
")",
"error",
"{",
"close",
"(",
"sd",
".",
"stopLeaseChan",
")",
"\n",
"c",
":=",
"make",
"(",
"chan",
"error",
")",
"\n",
"defer",
"close",
"(",
"c",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"logger",
".",
"Log",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"_",
",",
"err",
":=",
"sd",
".",
"cli",
".",
"Revoke",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"sd",
".",
"leaseID",
")",
"\n",
"c",
"<-",
"err",
"\n",
"logger",
".",
"Log",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"}",
"(",
")",
"\n",
"select",
"{",
"case",
"err",
":=",
"<-",
"c",
":",
"return",
"err",
"// completed normally",
"\n",
"case",
"<-",
"time",
".",
"After",
"(",
"sd",
".",
"revokeTimeout",
")",
":",
"logger",
".",
"Log",
".",
"Warn",
"(",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"// timed out",
"\n",
"}",
"\n",
"}"
] |
// revoke prevents Pitaya from crashing when etcd is not available
|
[
"revoke",
"prevents",
"Pitaya",
"from",
"crashing",
"when",
"etcd",
"is",
"not",
"available"
] |
b92161d7a48c87a7759ac9cabcc23e7d56f9eebd
|
https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/etcd_service_discovery.go#L455-L472
|
train
|
Subsets and Splits
SQL Console for semeru/code-text-go
Retrieves a limited set of code samples with their languages, with a specific case adjustment for 'Go' language.