repo stringlengths 5 67 | path stringlengths 4 218 | func_name stringlengths 0 151 | original_string stringlengths 52 373k | language stringclasses 6 values | code stringlengths 52 373k | code_tokens listlengths 10 512 | docstring stringlengths 3 47.2k | docstring_tokens listlengths 3 234 | sha stringlengths 40 40 | url stringlengths 85 339 | partition stringclasses 3 values |
|---|---|---|---|---|---|---|---|---|---|---|---|
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",
",",
"\"BroadcastSessionBind\"",
",",
"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",
",",
"\"Call\"",
",",
"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",
",",
"\"AddServer\"",
",",
"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",
",",
"\"RemoveServer\"",
",",
"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",
",",
"\"RemoveServer\"",
",",
"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",
",",
"\"OnUserBind\"",
",",
"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",
",",
"\"OnUserBind\"",
",",
"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",
"(",
"\"argument %+v\\n\"",
",",
"\\n",
")",
"\n",
"arg",
"\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",
"{",
"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",
"(",
"\"waiting for etcd lease\"",
")",
"\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",
"{",
"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",
"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",
"err",
"=",
"sd",
".",
"bootstrap",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"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",
"(",
"\"error resyncing servers: %s\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"case",
"<-",
"sd",
".",
"stopChan",
":",
"return",
"\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",
"(",
")",
",",
"\"servers/\"",
",",
"clientv3",
".",
"WithPrefix",
"(",
")",
",",
"clientv3",
".",
"WithKeysOnly",
"(",
")",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"allIds",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
")",
"\n",
"for",
"_",
",",
"kv",
":=",
"range",
"keys",
".",
"Kvs",
"{",
"svType",
",",
"svID",
",",
"err",
":=",
"parseEtcdKey",
"(",
"string",
"(",
"kv",
".",
"Key",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Log",
".",
"Warnf",
"(",
"\"failed to parse etcd key %s, error: %s\"",
",",
"kv",
".",
"Key",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"allIds",
"=",
"append",
"(",
"allIds",
",",
"svID",
")",
"\n",
"if",
"_",
",",
"ok",
":=",
"sd",
".",
"serverMapByID",
".",
"Load",
"(",
"svID",
")",
";",
"!",
"ok",
"{",
"logger",
".",
"Log",
".",
"Debugf",
"(",
"\"loading info from missing server: %s/%s\"",
",",
"svType",
",",
"svID",
")",
"\n",
"sv",
",",
"err",
":=",
"sd",
".",
"getServerFromEtcd",
"(",
"svType",
",",
"svID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Log",
".",
"Errorf",
"(",
"\"error getting server from etcd: %s, error: %s\"",
",",
"svID",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"sd",
".",
"addServer",
"(",
"sv",
")",
"\n",
"}",
"\n",
"}",
"\n",
"sd",
".",
"deleteLocalInvalidServers",
"(",
"allIds",
")",
"\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",
"(",
"\"waiting for etcd revoke\"",
")",
"\n",
"_",
",",
"err",
":=",
"sd",
".",
"cli",
".",
"Revoke",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"sd",
".",
"leaseID",
")",
"\n",
"c",
"<-",
"err",
"\n",
"logger",
".",
"Log",
".",
"Debug",
"(",
"\"finished waiting for etcd revoke\"",
")",
"\n",
"}",
"(",
")",
"\n",
"select",
"{",
"case",
"err",
":=",
"<-",
"c",
":",
"return",
"err",
"\n",
"case",
"<-",
"time",
".",
"After",
"(",
"sd",
".",
"revokeTimeout",
")",
":",
"logger",
".",
"Log",
".",
"Warn",
"(",
"\"timed out waiting for etcd revoke\"",
")",
"\n",
"return",
"nil",
"\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 |
topfreegames/pitaya | worker/mocks/rpc_job.go | NewMockRPCJob | func NewMockRPCJob(ctrl *gomock.Controller) *MockRPCJob {
mock := &MockRPCJob{ctrl: ctrl}
mock.recorder = &MockRPCJobMockRecorder{mock}
return mock
} | go | func NewMockRPCJob(ctrl *gomock.Controller) *MockRPCJob {
mock := &MockRPCJob{ctrl: ctrl}
mock.recorder = &MockRPCJobMockRecorder{mock}
return mock
} | [
"func",
"NewMockRPCJob",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockRPCJob",
"{",
"mock",
":=",
"&",
"MockRPCJob",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockRPCJobMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockRPCJob creates a new mock instance | [
"NewMockRPCJob",
"creates",
"a",
"new",
"mock",
"instance"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/worker/mocks/rpc_job.go#L26-L30 | train |
topfreegames/pitaya | worker/mocks/rpc_job.go | GetArgReply | func (m *MockRPCJob) GetArgReply(arg0 string) (proto.Message, proto.Message, error) {
ret := m.ctrl.Call(m, "GetArgReply", arg0)
ret0, _ := ret[0].(proto.Message)
ret1, _ := ret[1].(proto.Message)
ret2, _ := ret[2].(error)
return ret0, ret1, ret2
} | go | func (m *MockRPCJob) GetArgReply(arg0 string) (proto.Message, proto.Message, error) {
ret := m.ctrl.Call(m, "GetArgReply", arg0)
ret0, _ := ret[0].(proto.Message)
ret1, _ := ret[1].(proto.Message)
ret2, _ := ret[2].(error)
return ret0, ret1, ret2
} | [
"func",
"(",
"m",
"*",
"MockRPCJob",
")",
"GetArgReply",
"(",
"arg0",
"string",
")",
"(",
"proto",
".",
"Message",
",",
"proto",
".",
"Message",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"GetArgReply\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"proto",
".",
"Message",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"proto",
".",
"Message",
")",
"\n",
"ret2",
",",
"_",
":=",
"ret",
"[",
"2",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
",",
"ret2",
"\n",
"}"
] | // GetArgReply mocks base method | [
"GetArgReply",
"mocks",
"base",
"method"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/worker/mocks/rpc_job.go#L38-L44 | train |
topfreegames/pitaya | worker/mocks/rpc_job.go | GetArgReply | func (mr *MockRPCJobMockRecorder) GetArgReply(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetArgReply", reflect.TypeOf((*MockRPCJob)(nil).GetArgReply), arg0)
} | go | func (mr *MockRPCJobMockRecorder) GetArgReply(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetArgReply", reflect.TypeOf((*MockRPCJob)(nil).GetArgReply), arg0)
} | [
"func",
"(",
"mr",
"*",
"MockRPCJobMockRecorder",
")",
"GetArgReply",
"(",
"arg0",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"GetArgReply\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockRPCJob",
")",
"(",
"nil",
")",
".",
"GetArgReply",
")",
",",
"arg0",
")",
"\n",
"}"
] | // GetArgReply indicates an expected call of GetArgReply | [
"GetArgReply",
"indicates",
"an",
"expected",
"call",
"of",
"GetArgReply"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/worker/mocks/rpc_job.go#L47-L49 | train |
topfreegames/pitaya | worker/mocks/rpc_job.go | RPC | func (m *MockRPCJob) RPC(arg0 context.Context, arg1, arg2 string, arg3, arg4 proto.Message) error {
ret := m.ctrl.Call(m, "RPC", arg0, arg1, arg2, arg3, arg4)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockRPCJob) RPC(arg0 context.Context, arg1, arg2 string, arg3, arg4 proto.Message) error {
ret := m.ctrl.Call(m, "RPC", arg0, arg1, arg2, arg3, arg4)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockRPCJob",
")",
"RPC",
"(",
"arg0",
"context",
".",
"Context",
",",
"arg1",
",",
"arg2",
"string",
",",
"arg3",
",",
"arg4",
"proto",
".",
"Message",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"RPC\"",
",",
"arg0",
",",
"arg1",
",",
"arg2",
",",
"arg3",
",",
"arg4",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // RPC mocks base method | [
"RPC",
"mocks",
"base",
"method"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/worker/mocks/rpc_job.go#L52-L56 | train |
topfreegames/pitaya | worker/mocks/rpc_job.go | RPC | func (mr *MockRPCJobMockRecorder) RPC(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPC", reflect.TypeOf((*MockRPCJob)(nil).RPC), arg0, arg1, arg2, arg3, arg4)
} | go | func (mr *MockRPCJobMockRecorder) RPC(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPC", reflect.TypeOf((*MockRPCJob)(nil).RPC), arg0, arg1, arg2, arg3, arg4)
} | [
"func",
"(",
"mr",
"*",
"MockRPCJobMockRecorder",
")",
"RPC",
"(",
"arg0",
",",
"arg1",
",",
"arg2",
",",
"arg3",
",",
"arg4",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"RPC\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockRPCJob",
")",
"(",
"nil",
")",
".",
"RPC",
")",
",",
"arg0",
",",
"arg1",
",",
"arg2",
",",
"arg3",
",",
"arg4",
")",
"\n",
"}"
] | // RPC indicates an expected call of RPC | [
"RPC",
"indicates",
"an",
"expected",
"call",
"of",
"RPC"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/worker/mocks/rpc_job.go#L59-L61 | train |
topfreegames/pitaya | worker/mocks/rpc_job.go | ServerDiscovery | func (m *MockRPCJob) ServerDiscovery(arg0 string, arg1 map[string]interface{}) (string, error) {
ret := m.ctrl.Call(m, "ServerDiscovery", arg0, arg1)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockRPCJob) ServerDiscovery(arg0 string, arg1 map[string]interface{}) (string, error) {
ret := m.ctrl.Call(m, "ServerDiscovery", arg0, arg1)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockRPCJob",
")",
"ServerDiscovery",
"(",
"arg0",
"string",
",",
"arg1",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"(",
"string",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"ServerDiscovery\"",
",",
"arg0",
",",
"arg1",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"string",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // ServerDiscovery mocks base method | [
"ServerDiscovery",
"mocks",
"base",
"method"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/worker/mocks/rpc_job.go#L64-L69 | train |
topfreegames/pitaya | defaultpipelines/default_struct_validator.go | Validate | func (v *DefaultValidator) Validate(ctx context.Context, in interface{}) (interface{}, error) {
if in == nil {
return in, nil
}
v.lazyinit()
if err := v.validate.Struct(in); err != nil {
return nil, err
}
return in, nil
} | go | func (v *DefaultValidator) Validate(ctx context.Context, in interface{}) (interface{}, error) {
if in == nil {
return in, nil
}
v.lazyinit()
if err := v.validate.Struct(in); err != nil {
return nil, err
}
return in, nil
} | [
"func",
"(",
"v",
"*",
"DefaultValidator",
")",
"Validate",
"(",
"ctx",
"context",
".",
"Context",
",",
"in",
"interface",
"{",
"}",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"if",
"in",
"==",
"nil",
"{",
"return",
"in",
",",
"nil",
"\n",
"}",
"\n",
"v",
".",
"lazyinit",
"(",
")",
"\n",
"if",
"err",
":=",
"v",
".",
"validate",
".",
"Struct",
"(",
"in",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"in",
",",
"nil",
"\n",
"}"
] | // Validate is the the function responsible for validating the 'in' parameter
// based on the struct tags the parameter has.
// This function has the pipeline.Handler signature so
// it is possible to use it as a pipeline function | [
"Validate",
"is",
"the",
"the",
"function",
"responsible",
"for",
"validating",
"the",
"in",
"parameter",
"based",
"on",
"the",
"struct",
"tags",
"the",
"parameter",
"has",
".",
"This",
"function",
"has",
"the",
"pipeline",
".",
"Handler",
"signature",
"so",
"it",
"is",
"possible",
"to",
"use",
"it",
"as",
"a",
"pipeline",
"function"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/defaultpipelines/default_struct_validator.go#L21-L32 | train |
topfreegames/pitaya | app.go | Configure | func Configure(
isFrontend bool,
serverType string,
serverMode ServerMode,
serverMetadata map[string]string,
cfgs ...*viper.Viper,
) {
if app.configured {
logger.Log.Warn("pitaya configured twice!")
}
app.config = config.NewConfig(cfgs...)
if app.heartbeat == time.Duration(0) {
app.heartbeat = app.config.GetDuration("pitaya.heartbeat.interval")
}
app.server.Frontend = isFrontend
app.server.Type = serverType
app.serverMode = serverMode
app.server.Metadata = serverMetadata
app.messageEncoder = message.NewMessagesEncoder(app.config.GetBool("pitaya.handler.messages.compression"))
configureMetrics(serverType)
configureDefaultPipelines(app.config)
app.configured = true
} | go | func Configure(
isFrontend bool,
serverType string,
serverMode ServerMode,
serverMetadata map[string]string,
cfgs ...*viper.Viper,
) {
if app.configured {
logger.Log.Warn("pitaya configured twice!")
}
app.config = config.NewConfig(cfgs...)
if app.heartbeat == time.Duration(0) {
app.heartbeat = app.config.GetDuration("pitaya.heartbeat.interval")
}
app.server.Frontend = isFrontend
app.server.Type = serverType
app.serverMode = serverMode
app.server.Metadata = serverMetadata
app.messageEncoder = message.NewMessagesEncoder(app.config.GetBool("pitaya.handler.messages.compression"))
configureMetrics(serverType)
configureDefaultPipelines(app.config)
app.configured = true
} | [
"func",
"Configure",
"(",
"isFrontend",
"bool",
",",
"serverType",
"string",
",",
"serverMode",
"ServerMode",
",",
"serverMetadata",
"map",
"[",
"string",
"]",
"string",
",",
"cfgs",
"...",
"*",
"viper",
".",
"Viper",
",",
")",
"{",
"if",
"app",
".",
"configured",
"{",
"logger",
".",
"Log",
".",
"Warn",
"(",
"\"pitaya configured twice!\"",
")",
"\n",
"}",
"\n",
"app",
".",
"config",
"=",
"config",
".",
"NewConfig",
"(",
"cfgs",
"...",
")",
"\n",
"if",
"app",
".",
"heartbeat",
"==",
"time",
".",
"Duration",
"(",
"0",
")",
"{",
"app",
".",
"heartbeat",
"=",
"app",
".",
"config",
".",
"GetDuration",
"(",
"\"pitaya.heartbeat.interval\"",
")",
"\n",
"}",
"\n",
"app",
".",
"server",
".",
"Frontend",
"=",
"isFrontend",
"\n",
"app",
".",
"server",
".",
"Type",
"=",
"serverType",
"\n",
"app",
".",
"serverMode",
"=",
"serverMode",
"\n",
"app",
".",
"server",
".",
"Metadata",
"=",
"serverMetadata",
"\n",
"app",
".",
"messageEncoder",
"=",
"message",
".",
"NewMessagesEncoder",
"(",
"app",
".",
"config",
".",
"GetBool",
"(",
"\"pitaya.handler.messages.compression\"",
")",
")",
"\n",
"configureMetrics",
"(",
"serverType",
")",
"\n",
"configureDefaultPipelines",
"(",
"app",
".",
"config",
")",
"\n",
"app",
".",
"configured",
"=",
"true",
"\n",
"}"
] | // Configure configures the app | [
"Configure",
"configures",
"the",
"app"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/app.go#L119-L141 | train |
topfreegames/pitaya | app.go | AddAcceptor | func AddAcceptor(ac acceptor.Acceptor) {
if !app.server.Frontend {
logger.Log.Error("tried to add an acceptor to a backend server, skipping")
return
}
app.acceptors = append(app.acceptors, ac)
} | go | func AddAcceptor(ac acceptor.Acceptor) {
if !app.server.Frontend {
logger.Log.Error("tried to add an acceptor to a backend server, skipping")
return
}
app.acceptors = append(app.acceptors, ac)
} | [
"func",
"AddAcceptor",
"(",
"ac",
"acceptor",
".",
"Acceptor",
")",
"{",
"if",
"!",
"app",
".",
"server",
".",
"Frontend",
"{",
"logger",
".",
"Log",
".",
"Error",
"(",
"\"tried to add an acceptor to a backend server, skipping\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
"app",
".",
"acceptors",
"=",
"append",
"(",
"app",
".",
"acceptors",
",",
"ac",
")",
"\n",
"}"
] | // AddAcceptor adds a new acceptor to app | [
"AddAcceptor",
"adds",
"a",
"new",
"acceptor",
"to",
"app"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/app.go#L186-L192 | train |
topfreegames/pitaya | app.go | GetServerByID | func GetServerByID(id string) (*cluster.Server, error) {
return app.serviceDiscovery.GetServer(id)
} | go | func GetServerByID(id string) (*cluster.Server, error) {
return app.serviceDiscovery.GetServer(id)
} | [
"func",
"GetServerByID",
"(",
"id",
"string",
")",
"(",
"*",
"cluster",
".",
"Server",
",",
"error",
")",
"{",
"return",
"app",
".",
"serviceDiscovery",
".",
"GetServer",
"(",
"id",
")",
"\n",
"}"
] | // GetServerByID returns the server with the specified id | [
"GetServerByID",
"returns",
"the",
"server",
"with",
"the",
"specified",
"id"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/app.go#L271-L273 | train |
topfreegames/pitaya | app.go | GetServersByType | func GetServersByType(t string) (map[string]*cluster.Server, error) {
return app.serviceDiscovery.GetServersByType(t)
} | go | func GetServersByType(t string) (map[string]*cluster.Server, error) {
return app.serviceDiscovery.GetServersByType(t)
} | [
"func",
"GetServersByType",
"(",
"t",
"string",
")",
"(",
"map",
"[",
"string",
"]",
"*",
"cluster",
".",
"Server",
",",
"error",
")",
"{",
"return",
"app",
".",
"serviceDiscovery",
".",
"GetServersByType",
"(",
"t",
")",
"\n",
"}"
] | // GetServersByType get all servers of type | [
"GetServersByType",
"get",
"all",
"servers",
"of",
"type"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/app.go#L276-L278 | train |
topfreegames/pitaya | app.go | AddMetricsReporter | func AddMetricsReporter(mr metrics.Reporter) {
app.metricsReporters = append(app.metricsReporters, mr)
} | go | func AddMetricsReporter(mr metrics.Reporter) {
app.metricsReporters = append(app.metricsReporters, mr)
} | [
"func",
"AddMetricsReporter",
"(",
"mr",
"metrics",
".",
"Reporter",
")",
"{",
"app",
".",
"metricsReporters",
"=",
"append",
"(",
"app",
".",
"metricsReporters",
",",
"mr",
")",
"\n",
"}"
] | // AddMetricsReporter to be used | [
"AddMetricsReporter",
"to",
"be",
"used"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/app.go#L286-L288 | train |
topfreegames/pitaya | app.go | SetDictionary | func SetDictionary(dict map[string]uint16) error {
if app.running {
return constants.ErrChangeDictionaryWhileRunning
}
return message.SetDictionary(dict)
} | go | func SetDictionary(dict map[string]uint16) error {
if app.running {
return constants.ErrChangeDictionaryWhileRunning
}
return message.SetDictionary(dict)
} | [
"func",
"SetDictionary",
"(",
"dict",
"map",
"[",
"string",
"]",
"uint16",
")",
"error",
"{",
"if",
"app",
".",
"running",
"{",
"return",
"constants",
".",
"ErrChangeDictionaryWhileRunning",
"\n",
"}",
"\n",
"return",
"message",
".",
"SetDictionary",
"(",
"dict",
")",
"\n",
"}"
] | // SetDictionary sets routes map | [
"SetDictionary",
"sets",
"routes",
"map"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/app.go#L485-L490 | train |
topfreegames/pitaya | app.go | Error | func Error(err error, code string, metadata ...map[string]string) *errors.Error {
return errors.NewError(err, code, metadata...)
} | go | func Error(err error, code string, metadata ...map[string]string) *errors.Error {
return errors.NewError(err, code, metadata...)
} | [
"func",
"Error",
"(",
"err",
"error",
",",
"code",
"string",
",",
"metadata",
"...",
"map",
"[",
"string",
"]",
"string",
")",
"*",
"errors",
".",
"Error",
"{",
"return",
"errors",
".",
"NewError",
"(",
"err",
",",
"code",
",",
"metadata",
"...",
")",
"\n",
"}"
] | // Error creates a new error with a code, message and metadata | [
"Error",
"creates",
"a",
"new",
"error",
"with",
"a",
"code",
"message",
"and",
"metadata"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/app.go#L518-L520 | train |
topfreegames/pitaya | app.go | GetSessionFromCtx | func GetSessionFromCtx(ctx context.Context) *session.Session {
sessionVal := ctx.Value(constants.SessionCtxKey)
if sessionVal == nil {
logger.Log.Warn("ctx doesn't contain a session, are you calling GetSessionFromCtx from inside a remote?")
return nil
}
return sessionVal.(*session.Session)
} | go | func GetSessionFromCtx(ctx context.Context) *session.Session {
sessionVal := ctx.Value(constants.SessionCtxKey)
if sessionVal == nil {
logger.Log.Warn("ctx doesn't contain a session, are you calling GetSessionFromCtx from inside a remote?")
return nil
}
return sessionVal.(*session.Session)
} | [
"func",
"GetSessionFromCtx",
"(",
"ctx",
"context",
".",
"Context",
")",
"*",
"session",
".",
"Session",
"{",
"sessionVal",
":=",
"ctx",
".",
"Value",
"(",
"constants",
".",
"SessionCtxKey",
")",
"\n",
"if",
"sessionVal",
"==",
"nil",
"{",
"logger",
".",
"Log",
".",
"Warn",
"(",
"\"ctx doesn't contain a session, are you calling GetSessionFromCtx from inside a remote?\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"sessionVal",
".",
"(",
"*",
"session",
".",
"Session",
")",
"\n",
"}"
] | // GetSessionFromCtx retrieves a session from a given context | [
"GetSessionFromCtx",
"retrieves",
"a",
"session",
"from",
"a",
"given",
"context"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/app.go#L523-L530 | train |
topfreegames/pitaya | app.go | GetDefaultLoggerFromCtx | func GetDefaultLoggerFromCtx(ctx context.Context) logger.Logger {
return ctx.Value(constants.LoggerCtxKey).(logger.Logger)
} | go | func GetDefaultLoggerFromCtx(ctx context.Context) logger.Logger {
return ctx.Value(constants.LoggerCtxKey).(logger.Logger)
} | [
"func",
"GetDefaultLoggerFromCtx",
"(",
"ctx",
"context",
".",
"Context",
")",
"logger",
".",
"Logger",
"{",
"return",
"ctx",
".",
"Value",
"(",
"constants",
".",
"LoggerCtxKey",
")",
".",
"(",
"logger",
".",
"Logger",
")",
"\n",
"}"
] | // GetDefaultLoggerFromCtx returns the default logger from the given context | [
"GetDefaultLoggerFromCtx",
"returns",
"the",
"default",
"logger",
"from",
"the",
"given",
"context"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/app.go#L533-L535 | train |
topfreegames/pitaya | app.go | AddMetricTagsToPropagateCtx | func AddMetricTagsToPropagateCtx(
ctx context.Context,
tags map[string]string,
) context.Context {
return pcontext.AddToPropagateCtx(ctx, constants.MetricTagsKey, tags)
} | go | func AddMetricTagsToPropagateCtx(
ctx context.Context,
tags map[string]string,
) context.Context {
return pcontext.AddToPropagateCtx(ctx, constants.MetricTagsKey, tags)
} | [
"func",
"AddMetricTagsToPropagateCtx",
"(",
"ctx",
"context",
".",
"Context",
",",
"tags",
"map",
"[",
"string",
"]",
"string",
",",
")",
"context",
".",
"Context",
"{",
"return",
"pcontext",
".",
"AddToPropagateCtx",
"(",
"ctx",
",",
"constants",
".",
"MetricTagsKey",
",",
"tags",
")",
"\n",
"}"
] | // AddMetricTagsToPropagateCtx adds a key and metric tags that will
// be propagated through RPC calls. Use the same tags that are at
// 'pitaya.metrics.additionalTags' config | [
"AddMetricTagsToPropagateCtx",
"adds",
"a",
"key",
"and",
"metric",
"tags",
"that",
"will",
"be",
"propagated",
"through",
"RPC",
"calls",
".",
"Use",
"the",
"same",
"tags",
"that",
"are",
"at",
"pitaya",
".",
"metrics",
".",
"additionalTags",
"config"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/app.go#L540-L545 | train |
topfreegames/pitaya | app.go | GetFromPropagateCtx | func GetFromPropagateCtx(ctx context.Context, key string) interface{} {
return pcontext.GetFromPropagateCtx(ctx, key)
} | go | func GetFromPropagateCtx(ctx context.Context, key string) interface{} {
return pcontext.GetFromPropagateCtx(ctx, key)
} | [
"func",
"GetFromPropagateCtx",
"(",
"ctx",
"context",
".",
"Context",
",",
"key",
"string",
")",
"interface",
"{",
"}",
"{",
"return",
"pcontext",
".",
"GetFromPropagateCtx",
"(",
"ctx",
",",
"key",
")",
"\n",
"}"
] | // GetFromPropagateCtx adds a key and value that came through RPC calls | [
"GetFromPropagateCtx",
"adds",
"a",
"key",
"and",
"value",
"that",
"came",
"through",
"RPC",
"calls"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/app.go#L553-L555 | train |
topfreegames/pitaya | app.go | ExtractSpan | func ExtractSpan(ctx context.Context) (opentracing.SpanContext, error) {
return tracing.ExtractSpan(ctx)
} | go | func ExtractSpan(ctx context.Context) (opentracing.SpanContext, error) {
return tracing.ExtractSpan(ctx)
} | [
"func",
"ExtractSpan",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"opentracing",
".",
"SpanContext",
",",
"error",
")",
"{",
"return",
"tracing",
".",
"ExtractSpan",
"(",
"ctx",
")",
"\n",
"}"
] | // ExtractSpan retrieves an opentracing span context from the given context
// The span context can be received directly or via an RPC call | [
"ExtractSpan",
"retrieves",
"an",
"opentracing",
"span",
"context",
"from",
"the",
"given",
"context",
"The",
"span",
"context",
"can",
"be",
"received",
"directly",
"or",
"via",
"an",
"RPC",
"call"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/app.go#L559-L561 | train |
topfreegames/pitaya | app.go | Documentation | func Documentation(getPtrNames bool) (map[string]interface{}, error) {
handlerDocs, err := handlerService.Docs(getPtrNames)
if err != nil {
return nil, err
}
remoteDocs, err := remoteService.Docs(getPtrNames)
if err != nil {
return nil, err
}
return map[string]interface{}{
"handlers": handlerDocs,
"remotes": remoteDocs,
}, nil
} | go | func Documentation(getPtrNames bool) (map[string]interface{}, error) {
handlerDocs, err := handlerService.Docs(getPtrNames)
if err != nil {
return nil, err
}
remoteDocs, err := remoteService.Docs(getPtrNames)
if err != nil {
return nil, err
}
return map[string]interface{}{
"handlers": handlerDocs,
"remotes": remoteDocs,
}, nil
} | [
"func",
"Documentation",
"(",
"getPtrNames",
"bool",
")",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"handlerDocs",
",",
"err",
":=",
"handlerService",
".",
"Docs",
"(",
"getPtrNames",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"remoteDocs",
",",
"err",
":=",
"remoteService",
".",
"Docs",
"(",
"getPtrNames",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"handlers\"",
":",
"handlerDocs",
",",
"\"remotes\"",
":",
"remoteDocs",
",",
"}",
",",
"nil",
"\n",
"}"
] | // Documentation returns handler and remotes documentacion | [
"Documentation",
"returns",
"handler",
"and",
"remotes",
"documentacion"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/app.go#L564-L577 | train |
topfreegames/pitaya | app.go | AddGRPCInfoToMetadata | func AddGRPCInfoToMetadata(
metadata map[string]string,
region string,
host, port string,
externalHost, externalPort string,
) map[string]string {
metadata[constants.GRPCHostKey] = host
metadata[constants.GRPCPortKey] = port
metadata[constants.GRPCExternalHostKey] = externalHost
metadata[constants.GRPCExternalPortKey] = externalPort
metadata[constants.RegionKey] = region
return metadata
} | go | func AddGRPCInfoToMetadata(
metadata map[string]string,
region string,
host, port string,
externalHost, externalPort string,
) map[string]string {
metadata[constants.GRPCHostKey] = host
metadata[constants.GRPCPortKey] = port
metadata[constants.GRPCExternalHostKey] = externalHost
metadata[constants.GRPCExternalPortKey] = externalPort
metadata[constants.RegionKey] = region
return metadata
} | [
"func",
"AddGRPCInfoToMetadata",
"(",
"metadata",
"map",
"[",
"string",
"]",
"string",
",",
"region",
"string",
",",
"host",
",",
"port",
"string",
",",
"externalHost",
",",
"externalPort",
"string",
",",
")",
"map",
"[",
"string",
"]",
"string",
"{",
"metadata",
"[",
"constants",
".",
"GRPCHostKey",
"]",
"=",
"host",
"\n",
"metadata",
"[",
"constants",
".",
"GRPCPortKey",
"]",
"=",
"port",
"\n",
"metadata",
"[",
"constants",
".",
"GRPCExternalHostKey",
"]",
"=",
"externalHost",
"\n",
"metadata",
"[",
"constants",
".",
"GRPCExternalPortKey",
"]",
"=",
"externalPort",
"\n",
"metadata",
"[",
"constants",
".",
"RegionKey",
"]",
"=",
"region",
"\n",
"return",
"metadata",
"\n",
"}"
] | // AddGRPCInfoToMetadata adds host, external host and
// port into metadata | [
"AddGRPCInfoToMetadata",
"adds",
"host",
"external",
"host",
"and",
"port",
"into",
"metadata"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/app.go#L581-L593 | train |
topfreegames/pitaya | app.go | StartWorker | func StartWorker(config *config.Config) error {
var err error
app.worker, err = worker.NewWorker(config)
if err != nil {
return err
}
app.worker.Start()
return nil
} | go | func StartWorker(config *config.Config) error {
var err error
app.worker, err = worker.NewWorker(config)
if err != nil {
return err
}
app.worker.Start()
return nil
} | [
"func",
"StartWorker",
"(",
"config",
"*",
"config",
".",
"Config",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"app",
".",
"worker",
",",
"err",
"=",
"worker",
".",
"NewWorker",
"(",
"config",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"app",
".",
"worker",
".",
"Start",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // StartWorker configures, starts and returns pitaya worker | [
"StartWorker",
"configures",
"starts",
"and",
"returns",
"pitaya",
"worker"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/app.go#L601-L611 | train |
topfreegames/pitaya | app.go | RegisterRPCJob | func RegisterRPCJob(rpcJob worker.RPCJob) error {
err := app.worker.RegisterRPCJob(rpcJob)
return err
} | go | func RegisterRPCJob(rpcJob worker.RPCJob) error {
err := app.worker.RegisterRPCJob(rpcJob)
return err
} | [
"func",
"RegisterRPCJob",
"(",
"rpcJob",
"worker",
".",
"RPCJob",
")",
"error",
"{",
"err",
":=",
"app",
".",
"worker",
".",
"RegisterRPCJob",
"(",
"rpcJob",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // RegisterRPCJob registers rpc job to execute jobs with retries | [
"RegisterRPCJob",
"registers",
"rpc",
"job",
"to",
"execute",
"jobs",
"with",
"retries"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/app.go#L614-L617 | train |
topfreegames/pitaya | component/service.go | NewService | func NewService(comp Component, opts []Option) *Service {
s := &Service{
Type: reflect.TypeOf(comp),
Receiver: reflect.ValueOf(comp),
}
// apply options
for i := range opts {
opt := opts[i]
opt(&s.Options)
}
if name := s.Options.name; name != "" {
s.Name = name
} else {
s.Name = reflect.Indirect(s.Receiver).Type().Name()
}
return s
} | go | func NewService(comp Component, opts []Option) *Service {
s := &Service{
Type: reflect.TypeOf(comp),
Receiver: reflect.ValueOf(comp),
}
// apply options
for i := range opts {
opt := opts[i]
opt(&s.Options)
}
if name := s.Options.name; name != "" {
s.Name = name
} else {
s.Name = reflect.Indirect(s.Receiver).Type().Name()
}
return s
} | [
"func",
"NewService",
"(",
"comp",
"Component",
",",
"opts",
"[",
"]",
"Option",
")",
"*",
"Service",
"{",
"s",
":=",
"&",
"Service",
"{",
"Type",
":",
"reflect",
".",
"TypeOf",
"(",
"comp",
")",
",",
"Receiver",
":",
"reflect",
".",
"ValueOf",
"(",
"comp",
")",
",",
"}",
"\n",
"for",
"i",
":=",
"range",
"opts",
"{",
"opt",
":=",
"opts",
"[",
"i",
"]",
"\n",
"opt",
"(",
"&",
"s",
".",
"Options",
")",
"\n",
"}",
"\n",
"if",
"name",
":=",
"s",
".",
"Options",
".",
"name",
";",
"name",
"!=",
"\"\"",
"{",
"s",
".",
"Name",
"=",
"name",
"\n",
"}",
"else",
"{",
"s",
".",
"Name",
"=",
"reflect",
".",
"Indirect",
"(",
"s",
".",
"Receiver",
")",
".",
"Type",
"(",
")",
".",
"Name",
"(",
")",
"\n",
"}",
"\n",
"return",
"s",
"\n",
"}"
] | // NewService creates a new service | [
"NewService",
"creates",
"a",
"new",
"service"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/component/service.go#L62-L80 | train |
topfreegames/pitaya | component/service.go | ValidateMessageType | func (h *Handler) ValidateMessageType(msgType message.Type) (exitOnError bool, err error) {
if h.MessageType != msgType {
switch msgType {
case message.Request:
err = constants.ErrRequestOnNotify
exitOnError = true
case message.Notify:
err = constants.ErrNotifyOnRequest
}
}
return
} | go | func (h *Handler) ValidateMessageType(msgType message.Type) (exitOnError bool, err error) {
if h.MessageType != msgType {
switch msgType {
case message.Request:
err = constants.ErrRequestOnNotify
exitOnError = true
case message.Notify:
err = constants.ErrNotifyOnRequest
}
}
return
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"ValidateMessageType",
"(",
"msgType",
"message",
".",
"Type",
")",
"(",
"exitOnError",
"bool",
",",
"err",
"error",
")",
"{",
"if",
"h",
".",
"MessageType",
"!=",
"msgType",
"{",
"switch",
"msgType",
"{",
"case",
"message",
".",
"Request",
":",
"err",
"=",
"constants",
".",
"ErrRequestOnNotify",
"\n",
"exitOnError",
"=",
"true",
"\n",
"case",
"message",
".",
"Notify",
":",
"err",
"=",
"constants",
".",
"ErrNotifyOnRequest",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // ValidateMessageType validates a given message type against the handler's one
// and returns an error if it is a mismatch and a boolean indicating if the caller should
// exit in the presence of this error or not. | [
"ValidateMessageType",
"validates",
"a",
"given",
"message",
"type",
"against",
"the",
"handler",
"s",
"one",
"and",
"returns",
"an",
"error",
"if",
"it",
"is",
"a",
"mismatch",
"and",
"a",
"boolean",
"indicating",
"if",
"the",
"caller",
"should",
"exit",
"in",
"the",
"presence",
"of",
"this",
"error",
"or",
"not",
"."
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/component/service.go#L161-L173 | train |
topfreegames/pitaya | examples/demo/cluster_protobuf/services/room.go | Init | func (r *Room) Init() {
gsi := groups.NewMemoryGroupService(config.NewConfig())
pitaya.InitGroups(gsi)
pitaya.GroupCreate(context.Background(), "room")
} | go | func (r *Room) Init() {
gsi := groups.NewMemoryGroupService(config.NewConfig())
pitaya.InitGroups(gsi)
pitaya.GroupCreate(context.Background(), "room")
} | [
"func",
"(",
"r",
"*",
"Room",
")",
"Init",
"(",
")",
"{",
"gsi",
":=",
"groups",
".",
"NewMemoryGroupService",
"(",
"config",
".",
"NewConfig",
"(",
")",
")",
"\n",
"pitaya",
".",
"InitGroups",
"(",
"gsi",
")",
"\n",
"pitaya",
".",
"GroupCreate",
"(",
"context",
".",
"Background",
"(",
")",
",",
"\"room\"",
")",
"\n",
"}"
] | // Init runs on service initialization | [
"Init",
"runs",
"on",
"service",
"initialization"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/examples/demo/cluster_protobuf/services/room.go#L53-L57 | train |
topfreegames/pitaya | tracing/log.go | LogError | func LogError(span opentracing.Span, message string) {
span.SetTag("error", true)
span.LogFields(
log.String("event", "error"),
log.String("message", message),
)
} | go | func LogError(span opentracing.Span, message string) {
span.SetTag("error", true)
span.LogFields(
log.String("event", "error"),
log.String("message", message),
)
} | [
"func",
"LogError",
"(",
"span",
"opentracing",
".",
"Span",
",",
"message",
"string",
")",
"{",
"span",
".",
"SetTag",
"(",
"\"error\"",
",",
"true",
")",
"\n",
"span",
".",
"LogFields",
"(",
"log",
".",
"String",
"(",
"\"event\"",
",",
"\"error\"",
")",
",",
"log",
".",
"String",
"(",
"\"message\"",
",",
"message",
")",
",",
")",
"\n",
"}"
] | // LogError logs an error to an opentracing span | [
"LogError",
"logs",
"an",
"error",
"to",
"an",
"opentracing",
"span"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/tracing/log.go#L31-L37 | train |
topfreegames/pitaya | cluster/nats_rpc_client.go | BroadcastSessionBind | func (ns *NatsRPCClient) BroadcastSessionBind(uid string) error {
msg := &protos.BindMsg{
Uid: uid,
Fid: ns.server.ID,
}
msgData, err := proto.Marshal(msg)
if err != nil {
return err
}
return ns.Send(GetBindBroadcastTopic(ns.server.Type), msgData)
} | go | func (ns *NatsRPCClient) BroadcastSessionBind(uid string) error {
msg := &protos.BindMsg{
Uid: uid,
Fid: ns.server.ID,
}
msgData, err := proto.Marshal(msg)
if err != nil {
return err
}
return ns.Send(GetBindBroadcastTopic(ns.server.Type), msgData)
} | [
"func",
"(",
"ns",
"*",
"NatsRPCClient",
")",
"BroadcastSessionBind",
"(",
"uid",
"string",
")",
"error",
"{",
"msg",
":=",
"&",
"protos",
".",
"BindMsg",
"{",
"Uid",
":",
"uid",
",",
"Fid",
":",
"ns",
".",
"server",
".",
"ID",
",",
"}",
"\n",
"msgData",
",",
"err",
":=",
"proto",
".",
"Marshal",
"(",
"msg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"ns",
".",
"Send",
"(",
"GetBindBroadcastTopic",
"(",
"ns",
".",
"server",
".",
"Type",
")",
",",
"msgData",
")",
"\n",
"}"
] | // BroadcastSessionBind sends the binding information to other servers that may br interested in this info | [
"BroadcastSessionBind",
"sends",
"the",
"binding",
"information",
"to",
"other",
"servers",
"that",
"may",
"br",
"interested",
"in",
"this",
"info"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/nats_rpc_client.go#L91-L101 | train |
topfreegames/pitaya | cluster/nats_rpc_client.go | Send | func (ns *NatsRPCClient) Send(topic string, data []byte) error {
if !ns.running {
return constants.ErrRPCClientNotInitialized
}
return ns.conn.Publish(topic, data)
} | go | func (ns *NatsRPCClient) Send(topic string, data []byte) error {
if !ns.running {
return constants.ErrRPCClientNotInitialized
}
return ns.conn.Publish(topic, data)
} | [
"func",
"(",
"ns",
"*",
"NatsRPCClient",
")",
"Send",
"(",
"topic",
"string",
",",
"data",
"[",
"]",
"byte",
")",
"error",
"{",
"if",
"!",
"ns",
".",
"running",
"{",
"return",
"constants",
".",
"ErrRPCClientNotInitialized",
"\n",
"}",
"\n",
"return",
"ns",
".",
"conn",
".",
"Publish",
"(",
"topic",
",",
"data",
")",
"\n",
"}"
] | // Send publishes a message in a given topic | [
"Send",
"publishes",
"a",
"message",
"in",
"a",
"given",
"topic"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/nats_rpc_client.go#L104-L109 | train |
topfreegames/pitaya | cluster/nats_rpc_client.go | SendPush | func (ns *NatsRPCClient) SendPush(userID string, frontendSv *Server, push *protos.Push) error {
topic := GetUserMessagesTopic(userID, frontendSv.Type)
msg, err := proto.Marshal(push)
if err != nil {
return err
}
return ns.Send(topic, msg)
} | go | func (ns *NatsRPCClient) SendPush(userID string, frontendSv *Server, push *protos.Push) error {
topic := GetUserMessagesTopic(userID, frontendSv.Type)
msg, err := proto.Marshal(push)
if err != nil {
return err
}
return ns.Send(topic, msg)
} | [
"func",
"(",
"ns",
"*",
"NatsRPCClient",
")",
"SendPush",
"(",
"userID",
"string",
",",
"frontendSv",
"*",
"Server",
",",
"push",
"*",
"protos",
".",
"Push",
")",
"error",
"{",
"topic",
":=",
"GetUserMessagesTopic",
"(",
"userID",
",",
"frontendSv",
".",
"Type",
")",
"\n",
"msg",
",",
"err",
":=",
"proto",
".",
"Marshal",
"(",
"push",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"ns",
".",
"Send",
"(",
"topic",
",",
"msg",
")",
"\n",
"}"
] | // SendPush sends a message to a user | [
"SendPush",
"sends",
"a",
"message",
"to",
"a",
"user"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/nats_rpc_client.go#L112-L119 | train |
topfreegames/pitaya | cluster/nats_rpc_client.go | SendKick | func (ns *NatsRPCClient) SendKick(userID string, serverType string, kick *protos.KickMsg) error {
topic := GetUserKickTopic(userID, serverType)
msg, err := proto.Marshal(kick)
if err != nil {
return err
}
return ns.Send(topic, msg)
} | go | func (ns *NatsRPCClient) SendKick(userID string, serverType string, kick *protos.KickMsg) error {
topic := GetUserKickTopic(userID, serverType)
msg, err := proto.Marshal(kick)
if err != nil {
return err
}
return ns.Send(topic, msg)
} | [
"func",
"(",
"ns",
"*",
"NatsRPCClient",
")",
"SendKick",
"(",
"userID",
"string",
",",
"serverType",
"string",
",",
"kick",
"*",
"protos",
".",
"KickMsg",
")",
"error",
"{",
"topic",
":=",
"GetUserKickTopic",
"(",
"userID",
",",
"serverType",
")",
"\n",
"msg",
",",
"err",
":=",
"proto",
".",
"Marshal",
"(",
"kick",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"ns",
".",
"Send",
"(",
"topic",
",",
"msg",
")",
"\n",
"}"
] | // SendKick kicks an user | [
"SendKick",
"kicks",
"an",
"user"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/nats_rpc_client.go#L122-L129 | train |
topfreegames/pitaya | cluster/nats_rpc_client.go | Call | func (ns *NatsRPCClient) Call(
ctx context.Context,
rpcType protos.RPCType,
route *route.Route,
session *session.Session,
msg *message.Message,
server *Server,
) (*protos.Response, error) {
parent, err := tracing.ExtractSpan(ctx)
if err != nil {
logger.Log.Warnf("failed to retrieve parent span: %s", err.Error())
}
tags := opentracing.Tags{
"span.kind": "client",
"local.id": ns.server.ID,
"peer.serverType": server.Type,
"peer.id": server.ID,
}
ctx = tracing.StartSpan(ctx, "RPC Call", tags, parent)
defer tracing.FinishSpan(ctx, err)
if !ns.running {
err = constants.ErrRPCClientNotInitialized
return nil, err
}
req, err := buildRequest(ctx, rpcType, route, session, msg, ns.server)
if err != nil {
return nil, err
}
marshalledData, err := proto.Marshal(&req)
if err != nil {
return nil, err
}
var m *nats.Msg
if ns.metricsReporters != nil {
startTime := time.Now()
ctx = pcontext.AddToPropagateCtx(ctx, constants.StartTimeKey, startTime.UnixNano())
ctx = pcontext.AddToPropagateCtx(ctx, constants.RouteKey, route.String())
defer func() {
typ := "rpc"
metrics.ReportTimingFromCtx(ctx, ns.metricsReporters, typ, err)
}()
}
m, err = ns.conn.Request(getChannel(server.Type, server.ID), marshalledData, ns.reqTimeout)
if err != nil {
return nil, err
}
res := &protos.Response{}
err = proto.Unmarshal(m.Data, res)
if err != nil {
return nil, err
}
if res.Error != nil {
if res.Error.Code == "" {
res.Error.Code = errors.ErrUnknownCode
}
err = &errors.Error{
Code: res.Error.Code,
Message: res.Error.Msg,
Metadata: res.Error.Metadata,
}
return nil, err
}
return res, nil
} | go | func (ns *NatsRPCClient) Call(
ctx context.Context,
rpcType protos.RPCType,
route *route.Route,
session *session.Session,
msg *message.Message,
server *Server,
) (*protos.Response, error) {
parent, err := tracing.ExtractSpan(ctx)
if err != nil {
logger.Log.Warnf("failed to retrieve parent span: %s", err.Error())
}
tags := opentracing.Tags{
"span.kind": "client",
"local.id": ns.server.ID,
"peer.serverType": server.Type,
"peer.id": server.ID,
}
ctx = tracing.StartSpan(ctx, "RPC Call", tags, parent)
defer tracing.FinishSpan(ctx, err)
if !ns.running {
err = constants.ErrRPCClientNotInitialized
return nil, err
}
req, err := buildRequest(ctx, rpcType, route, session, msg, ns.server)
if err != nil {
return nil, err
}
marshalledData, err := proto.Marshal(&req)
if err != nil {
return nil, err
}
var m *nats.Msg
if ns.metricsReporters != nil {
startTime := time.Now()
ctx = pcontext.AddToPropagateCtx(ctx, constants.StartTimeKey, startTime.UnixNano())
ctx = pcontext.AddToPropagateCtx(ctx, constants.RouteKey, route.String())
defer func() {
typ := "rpc"
metrics.ReportTimingFromCtx(ctx, ns.metricsReporters, typ, err)
}()
}
m, err = ns.conn.Request(getChannel(server.Type, server.ID), marshalledData, ns.reqTimeout)
if err != nil {
return nil, err
}
res := &protos.Response{}
err = proto.Unmarshal(m.Data, res)
if err != nil {
return nil, err
}
if res.Error != nil {
if res.Error.Code == "" {
res.Error.Code = errors.ErrUnknownCode
}
err = &errors.Error{
Code: res.Error.Code,
Message: res.Error.Msg,
Metadata: res.Error.Metadata,
}
return nil, err
}
return res, nil
} | [
"func",
"(",
"ns",
"*",
"NatsRPCClient",
")",
"Call",
"(",
"ctx",
"context",
".",
"Context",
",",
"rpcType",
"protos",
".",
"RPCType",
",",
"route",
"*",
"route",
".",
"Route",
",",
"session",
"*",
"session",
".",
"Session",
",",
"msg",
"*",
"message",
".",
"Message",
",",
"server",
"*",
"Server",
",",
")",
"(",
"*",
"protos",
".",
"Response",
",",
"error",
")",
"{",
"parent",
",",
"err",
":=",
"tracing",
".",
"ExtractSpan",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Log",
".",
"Warnf",
"(",
"\"failed to retrieve parent span: %s\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"tags",
":=",
"opentracing",
".",
"Tags",
"{",
"\"span.kind\"",
":",
"\"client\"",
",",
"\"local.id\"",
":",
"ns",
".",
"server",
".",
"ID",
",",
"\"peer.serverType\"",
":",
"server",
".",
"Type",
",",
"\"peer.id\"",
":",
"server",
".",
"ID",
",",
"}",
"\n",
"ctx",
"=",
"tracing",
".",
"StartSpan",
"(",
"ctx",
",",
"\"RPC Call\"",
",",
"tags",
",",
"parent",
")",
"\n",
"defer",
"tracing",
".",
"FinishSpan",
"(",
"ctx",
",",
"err",
")",
"\n",
"if",
"!",
"ns",
".",
"running",
"{",
"err",
"=",
"constants",
".",
"ErrRPCClientNotInitialized",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"req",
",",
"err",
":=",
"buildRequest",
"(",
"ctx",
",",
"rpcType",
",",
"route",
",",
"session",
",",
"msg",
",",
"ns",
".",
"server",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"marshalledData",
",",
"err",
":=",
"proto",
".",
"Marshal",
"(",
"&",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"var",
"m",
"*",
"nats",
".",
"Msg",
"\n",
"if",
"ns",
".",
"metricsReporters",
"!=",
"nil",
"{",
"startTime",
":=",
"time",
".",
"Now",
"(",
")",
"\n",
"ctx",
"=",
"pcontext",
".",
"AddToPropagateCtx",
"(",
"ctx",
",",
"constants",
".",
"StartTimeKey",
",",
"startTime",
".",
"UnixNano",
"(",
")",
")",
"\n",
"ctx",
"=",
"pcontext",
".",
"AddToPropagateCtx",
"(",
"ctx",
",",
"constants",
".",
"RouteKey",
",",
"route",
".",
"String",
"(",
")",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"typ",
":=",
"\"rpc\"",
"\n",
"metrics",
".",
"ReportTimingFromCtx",
"(",
"ctx",
",",
"ns",
".",
"metricsReporters",
",",
"typ",
",",
"err",
")",
"\n",
"}",
"(",
")",
"\n",
"}",
"\n",
"m",
",",
"err",
"=",
"ns",
".",
"conn",
".",
"Request",
"(",
"getChannel",
"(",
"server",
".",
"Type",
",",
"server",
".",
"ID",
")",
",",
"marshalledData",
",",
"ns",
".",
"reqTimeout",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
":=",
"&",
"protos",
".",
"Response",
"{",
"}",
"\n",
"err",
"=",
"proto",
".",
"Unmarshal",
"(",
"m",
".",
"Data",
",",
"res",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"res",
".",
"Error",
"!=",
"nil",
"{",
"if",
"res",
".",
"Error",
".",
"Code",
"==",
"\"\"",
"{",
"res",
".",
"Error",
".",
"Code",
"=",
"errors",
".",
"ErrUnknownCode",
"\n",
"}",
"\n",
"err",
"=",
"&",
"errors",
".",
"Error",
"{",
"Code",
":",
"res",
".",
"Error",
".",
"Code",
",",
"Message",
":",
"res",
".",
"Error",
".",
"Msg",
",",
"Metadata",
":",
"res",
".",
"Error",
".",
"Metadata",
",",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] | // Call calls a method remotelly | [
"Call",
"calls",
"a",
"method",
"remotelly"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/nats_rpc_client.go#L132-L200 | train |
topfreegames/pitaya | cluster/nats_rpc_client.go | Init | func (ns *NatsRPCClient) Init() error {
ns.running = true
conn, err := setupNatsConn(ns.connString, ns.appDieChan, nats.MaxReconnects(ns.maxReconnectionRetries))
if err != nil {
return err
}
ns.conn = conn
return nil
} | go | func (ns *NatsRPCClient) Init() error {
ns.running = true
conn, err := setupNatsConn(ns.connString, ns.appDieChan, nats.MaxReconnects(ns.maxReconnectionRetries))
if err != nil {
return err
}
ns.conn = conn
return nil
} | [
"func",
"(",
"ns",
"*",
"NatsRPCClient",
")",
"Init",
"(",
")",
"error",
"{",
"ns",
".",
"running",
"=",
"true",
"\n",
"conn",
",",
"err",
":=",
"setupNatsConn",
"(",
"ns",
".",
"connString",
",",
"ns",
".",
"appDieChan",
",",
"nats",
".",
"MaxReconnects",
"(",
"ns",
".",
"maxReconnectionRetries",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"ns",
".",
"conn",
"=",
"conn",
"\n",
"return",
"nil",
"\n",
"}"
] | // Init inits nats rpc client | [
"Init",
"inits",
"nats",
"rpc",
"client"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/nats_rpc_client.go#L203-L211 | train |
topfreegames/pitaya | agent/agent_remote.go | NewRemote | func NewRemote(
sess *protos.Session,
reply string,
rpcClient cluster.RPCClient,
encoder codec.PacketEncoder,
serializer serialize.Serializer,
serviceDiscovery cluster.ServiceDiscovery,
frontendID string,
messageEncoder message.Encoder,
) (*Remote, error) {
a := &Remote{
chDie: make(chan struct{}),
reply: reply, // TODO this is totally coupled with NATS
serializer: serializer,
encoder: encoder,
rpcClient: rpcClient,
serviceDiscovery: serviceDiscovery,
frontendID: frontendID,
messageEncoder: messageEncoder,
}
// binding session
s := session.New(a, false, sess.GetUid())
s.SetFrontendData(frontendID, sess.GetId())
err := s.SetDataEncoded(sess.GetData())
if err != nil {
return nil, err
}
a.Session = s
return a, nil
} | go | func NewRemote(
sess *protos.Session,
reply string,
rpcClient cluster.RPCClient,
encoder codec.PacketEncoder,
serializer serialize.Serializer,
serviceDiscovery cluster.ServiceDiscovery,
frontendID string,
messageEncoder message.Encoder,
) (*Remote, error) {
a := &Remote{
chDie: make(chan struct{}),
reply: reply, // TODO this is totally coupled with NATS
serializer: serializer,
encoder: encoder,
rpcClient: rpcClient,
serviceDiscovery: serviceDiscovery,
frontendID: frontendID,
messageEncoder: messageEncoder,
}
// binding session
s := session.New(a, false, sess.GetUid())
s.SetFrontendData(frontendID, sess.GetId())
err := s.SetDataEncoded(sess.GetData())
if err != nil {
return nil, err
}
a.Session = s
return a, nil
} | [
"func",
"NewRemote",
"(",
"sess",
"*",
"protos",
".",
"Session",
",",
"reply",
"string",
",",
"rpcClient",
"cluster",
".",
"RPCClient",
",",
"encoder",
"codec",
".",
"PacketEncoder",
",",
"serializer",
"serialize",
".",
"Serializer",
",",
"serviceDiscovery",
"cluster",
".",
"ServiceDiscovery",
",",
"frontendID",
"string",
",",
"messageEncoder",
"message",
".",
"Encoder",
",",
")",
"(",
"*",
"Remote",
",",
"error",
")",
"{",
"a",
":=",
"&",
"Remote",
"{",
"chDie",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"reply",
":",
"reply",
",",
"serializer",
":",
"serializer",
",",
"encoder",
":",
"encoder",
",",
"rpcClient",
":",
"rpcClient",
",",
"serviceDiscovery",
":",
"serviceDiscovery",
",",
"frontendID",
":",
"frontendID",
",",
"messageEncoder",
":",
"messageEncoder",
",",
"}",
"\n",
"s",
":=",
"session",
".",
"New",
"(",
"a",
",",
"false",
",",
"sess",
".",
"GetUid",
"(",
")",
")",
"\n",
"s",
".",
"SetFrontendData",
"(",
"frontendID",
",",
"sess",
".",
"GetId",
"(",
")",
")",
"\n",
"err",
":=",
"s",
".",
"SetDataEncoded",
"(",
"sess",
".",
"GetData",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"a",
".",
"Session",
"=",
"s",
"\n",
"return",
"a",
",",
"nil",
"\n",
"}"
] | // NewRemote create new Remote instance | [
"NewRemote",
"create",
"new",
"Remote",
"instance"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/agent/agent_remote.go#L56-L87 | train |
topfreegames/pitaya | agent/agent_remote.go | Push | func (a *Remote) Push(route string, v interface{}) error {
if (reflect.TypeOf(a.rpcClient) == reflect.TypeOf(&cluster.NatsRPCClient{}) &&
a.Session.UID() == "") {
return constants.ErrNoUIDBind
}
switch d := v.(type) {
case []byte:
logger.Log.Debugf("Type=Push, ID=%d, UID=%d, Route=%s, Data=%dbytes",
a.Session.ID(), a.Session.UID(), route, len(d))
default:
logger.Log.Debugf("Type=Push, ID=%d, UID=%d, Route=%s, Data=%+v",
a.Session.ID(), a.Session.UID(), route, v)
}
sv, err := a.serviceDiscovery.GetServer(a.frontendID)
if err != nil {
return err
}
return a.sendPush(
pendingMessage{typ: message.Push, route: route, payload: v},
a.Session.UID(), sv,
)
} | go | func (a *Remote) Push(route string, v interface{}) error {
if (reflect.TypeOf(a.rpcClient) == reflect.TypeOf(&cluster.NatsRPCClient{}) &&
a.Session.UID() == "") {
return constants.ErrNoUIDBind
}
switch d := v.(type) {
case []byte:
logger.Log.Debugf("Type=Push, ID=%d, UID=%d, Route=%s, Data=%dbytes",
a.Session.ID(), a.Session.UID(), route, len(d))
default:
logger.Log.Debugf("Type=Push, ID=%d, UID=%d, Route=%s, Data=%+v",
a.Session.ID(), a.Session.UID(), route, v)
}
sv, err := a.serviceDiscovery.GetServer(a.frontendID)
if err != nil {
return err
}
return a.sendPush(
pendingMessage{typ: message.Push, route: route, payload: v},
a.Session.UID(), sv,
)
} | [
"func",
"(",
"a",
"*",
"Remote",
")",
"Push",
"(",
"route",
"string",
",",
"v",
"interface",
"{",
"}",
")",
"error",
"{",
"if",
"(",
"reflect",
".",
"TypeOf",
"(",
"a",
".",
"rpcClient",
")",
"==",
"reflect",
".",
"TypeOf",
"(",
"&",
"cluster",
".",
"NatsRPCClient",
"{",
"}",
")",
"&&",
"a",
".",
"Session",
".",
"UID",
"(",
")",
"==",
"\"\"",
")",
"{",
"return",
"constants",
".",
"ErrNoUIDBind",
"\n",
"}",
"\n",
"switch",
"d",
":=",
"v",
".",
"(",
"type",
")",
"{",
"case",
"[",
"]",
"byte",
":",
"logger",
".",
"Log",
".",
"Debugf",
"(",
"\"Type=Push, ID=%d, UID=%d, Route=%s, Data=%dbytes\"",
",",
"a",
".",
"Session",
".",
"ID",
"(",
")",
",",
"a",
".",
"Session",
".",
"UID",
"(",
")",
",",
"route",
",",
"len",
"(",
"d",
")",
")",
"\n",
"default",
":",
"logger",
".",
"Log",
".",
"Debugf",
"(",
"\"Type=Push, ID=%d, UID=%d, Route=%s, Data=%+v\"",
",",
"a",
".",
"Session",
".",
"ID",
"(",
")",
",",
"a",
".",
"Session",
".",
"UID",
"(",
")",
",",
"route",
",",
"v",
")",
"\n",
"}",
"\n",
"sv",
",",
"err",
":=",
"a",
".",
"serviceDiscovery",
".",
"GetServer",
"(",
"a",
".",
"frontendID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"a",
".",
"sendPush",
"(",
"pendingMessage",
"{",
"typ",
":",
"message",
".",
"Push",
",",
"route",
":",
"route",
",",
"payload",
":",
"v",
"}",
",",
"a",
".",
"Session",
".",
"UID",
"(",
")",
",",
"sv",
",",
")",
"\n",
"}"
] | // Push pushes the message to the user | [
"Push",
"pushes",
"the",
"message",
"to",
"the",
"user"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/agent/agent_remote.go#L105-L127 | train |
topfreegames/pitaya | agent/agent_remote.go | ResponseMID | func (a *Remote) ResponseMID(ctx context.Context, mid uint, v interface{}, isError ...bool) error {
err := false
if len(isError) > 0 {
err = isError[0]
}
if mid <= 0 {
return constants.ErrSessionOnNotify
}
switch d := v.(type) {
case []byte:
logger.Log.Debugf("Type=Response, ID=%d, MID=%d, Data=%dbytes",
a.Session.ID(), mid, len(d))
default:
logger.Log.Infof("Type=Response, ID=%d, MID=%d, Data=%+v",
a.Session.ID(), mid, v)
}
return a.send(pendingMessage{ctx: ctx, typ: message.Response, mid: mid, payload: v, err: err}, a.reply)
} | go | func (a *Remote) ResponseMID(ctx context.Context, mid uint, v interface{}, isError ...bool) error {
err := false
if len(isError) > 0 {
err = isError[0]
}
if mid <= 0 {
return constants.ErrSessionOnNotify
}
switch d := v.(type) {
case []byte:
logger.Log.Debugf("Type=Response, ID=%d, MID=%d, Data=%dbytes",
a.Session.ID(), mid, len(d))
default:
logger.Log.Infof("Type=Response, ID=%d, MID=%d, Data=%+v",
a.Session.ID(), mid, v)
}
return a.send(pendingMessage{ctx: ctx, typ: message.Response, mid: mid, payload: v, err: err}, a.reply)
} | [
"func",
"(",
"a",
"*",
"Remote",
")",
"ResponseMID",
"(",
"ctx",
"context",
".",
"Context",
",",
"mid",
"uint",
",",
"v",
"interface",
"{",
"}",
",",
"isError",
"...",
"bool",
")",
"error",
"{",
"err",
":=",
"false",
"\n",
"if",
"len",
"(",
"isError",
")",
">",
"0",
"{",
"err",
"=",
"isError",
"[",
"0",
"]",
"\n",
"}",
"\n",
"if",
"mid",
"<=",
"0",
"{",
"return",
"constants",
".",
"ErrSessionOnNotify",
"\n",
"}",
"\n",
"switch",
"d",
":=",
"v",
".",
"(",
"type",
")",
"{",
"case",
"[",
"]",
"byte",
":",
"logger",
".",
"Log",
".",
"Debugf",
"(",
"\"Type=Response, ID=%d, MID=%d, Data=%dbytes\"",
",",
"a",
".",
"Session",
".",
"ID",
"(",
")",
",",
"mid",
",",
"len",
"(",
"d",
")",
")",
"\n",
"default",
":",
"logger",
".",
"Log",
".",
"Infof",
"(",
"\"Type=Response, ID=%d, MID=%d, Data=%+v\"",
",",
"a",
".",
"Session",
".",
"ID",
"(",
")",
",",
"mid",
",",
"v",
")",
"\n",
"}",
"\n",
"return",
"a",
".",
"send",
"(",
"pendingMessage",
"{",
"ctx",
":",
"ctx",
",",
"typ",
":",
"message",
".",
"Response",
",",
"mid",
":",
"mid",
",",
"payload",
":",
"v",
",",
"err",
":",
"err",
"}",
",",
"a",
".",
"reply",
")",
"\n",
"}"
] | // ResponseMID reponds the message with mid to the user | [
"ResponseMID",
"reponds",
"the",
"message",
"with",
"mid",
"to",
"the",
"user"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/agent/agent_remote.go#L130-L150 | train |
topfreegames/pitaya | errors/errors.go | CodeFromError | func CodeFromError(err error) string {
if err == nil {
return ""
}
pitayaErr, ok := err.(*Error)
if !ok {
return ErrUnknownCode
}
if pitayaErr == nil {
return ""
}
return pitayaErr.Code
} | go | func CodeFromError(err error) string {
if err == nil {
return ""
}
pitayaErr, ok := err.(*Error)
if !ok {
return ErrUnknownCode
}
if pitayaErr == nil {
return ""
}
return pitayaErr.Code
} | [
"func",
"CodeFromError",
"(",
"err",
"error",
")",
"string",
"{",
"if",
"err",
"==",
"nil",
"{",
"return",
"\"\"",
"\n",
"}",
"\n",
"pitayaErr",
",",
"ok",
":=",
"err",
".",
"(",
"*",
"Error",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"ErrUnknownCode",
"\n",
"}",
"\n",
"if",
"pitayaErr",
"==",
"nil",
"{",
"return",
"\"\"",
"\n",
"}",
"\n",
"return",
"pitayaErr",
".",
"Code",
"\n",
"}"
] | // CodeFromError returns the code of error.
// If error is nil, return empty string.
// If error is not a pitaya error, returns unkown code | [
"CodeFromError",
"returns",
"the",
"code",
"of",
"error",
".",
"If",
"error",
"is",
"nil",
"return",
"empty",
"string",
".",
"If",
"error",
"is",
"not",
"a",
"pitaya",
"error",
"returns",
"unkown",
"code"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/errors/errors.go#L81-L96 | train |
topfreegames/pitaya | timer.go | NewTimer | func NewTimer(interval time.Duration, fn timer.Func) *timer.Timer {
return NewCountTimer(interval, timer.LoopForever, fn)
} | go | func NewTimer(interval time.Duration, fn timer.Func) *timer.Timer {
return NewCountTimer(interval, timer.LoopForever, fn)
} | [
"func",
"NewTimer",
"(",
"interval",
"time",
".",
"Duration",
",",
"fn",
"timer",
".",
"Func",
")",
"*",
"timer",
".",
"Timer",
"{",
"return",
"NewCountTimer",
"(",
"interval",
",",
"timer",
".",
"LoopForever",
",",
"fn",
")",
"\n",
"}"
] | // NewTimer returns a new Timer containing a function that will be called
// with a period specified by the duration argument. It adjusts the intervals
// for slow receivers.
// The duration d must be greater than zero; if not, NewTimer will panic.
// Stop the timer to release associated resources. | [
"NewTimer",
"returns",
"a",
"new",
"Timer",
"containing",
"a",
"function",
"that",
"will",
"be",
"called",
"with",
"a",
"period",
"specified",
"by",
"the",
"duration",
"argument",
".",
"It",
"adjusts",
"the",
"intervals",
"for",
"slow",
"receivers",
".",
"The",
"duration",
"d",
"must",
"be",
"greater",
"than",
"zero",
";",
"if",
"not",
"NewTimer",
"will",
"panic",
".",
"Stop",
"the",
"timer",
"to",
"release",
"associated",
"resources",
"."
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/timer.go#L36-L38 | train |
topfreegames/pitaya | timer.go | NewCountTimer | func NewCountTimer(interval time.Duration, count int, fn timer.Func) *timer.Timer {
if fn == nil {
panic("pitaya/timer: nil timer function")
}
if interval <= 0 {
panic("non-positive interval for NewTimer")
}
t := timer.NewTimer(fn, interval, count)
// add to manager
timer.Manager.ChCreatedTimer <- t
return t
} | go | func NewCountTimer(interval time.Duration, count int, fn timer.Func) *timer.Timer {
if fn == nil {
panic("pitaya/timer: nil timer function")
}
if interval <= 0 {
panic("non-positive interval for NewTimer")
}
t := timer.NewTimer(fn, interval, count)
// add to manager
timer.Manager.ChCreatedTimer <- t
return t
} | [
"func",
"NewCountTimer",
"(",
"interval",
"time",
".",
"Duration",
",",
"count",
"int",
",",
"fn",
"timer",
".",
"Func",
")",
"*",
"timer",
".",
"Timer",
"{",
"if",
"fn",
"==",
"nil",
"{",
"panic",
"(",
"\"pitaya/timer: nil timer function\"",
")",
"\n",
"}",
"\n",
"if",
"interval",
"<=",
"0",
"{",
"panic",
"(",
"\"non-positive interval for NewTimer\"",
")",
"\n",
"}",
"\n",
"t",
":=",
"timer",
".",
"NewTimer",
"(",
"fn",
",",
"interval",
",",
"count",
")",
"\n",
"timer",
".",
"Manager",
".",
"ChCreatedTimer",
"<-",
"t",
"\n",
"return",
"t",
"\n",
"}"
] | // NewCountTimer returns a new Timer containing a function that will be called
// with a period specified by the duration argument. After count times, timer
// will be stopped automatically, It adjusts the intervals for slow receivers.
// The duration d must be greater than zero; if not, NewCountTimer will panic.
// Stop the timer to release associated resources. | [
"NewCountTimer",
"returns",
"a",
"new",
"Timer",
"containing",
"a",
"function",
"that",
"will",
"be",
"called",
"with",
"a",
"period",
"specified",
"by",
"the",
"duration",
"argument",
".",
"After",
"count",
"times",
"timer",
"will",
"be",
"stopped",
"automatically",
"It",
"adjusts",
"the",
"intervals",
"for",
"slow",
"receivers",
".",
"The",
"duration",
"d",
"must",
"be",
"greater",
"than",
"zero",
";",
"if",
"not",
"NewCountTimer",
"will",
"panic",
".",
"Stop",
"the",
"timer",
"to",
"release",
"associated",
"resources",
"."
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/timer.go#L45-L57 | train |
topfreegames/pitaya | timer.go | NewAfterTimer | func NewAfterTimer(duration time.Duration, fn timer.Func) *timer.Timer {
return NewCountTimer(duration, 1, fn)
} | go | func NewAfterTimer(duration time.Duration, fn timer.Func) *timer.Timer {
return NewCountTimer(duration, 1, fn)
} | [
"func",
"NewAfterTimer",
"(",
"duration",
"time",
".",
"Duration",
",",
"fn",
"timer",
".",
"Func",
")",
"*",
"timer",
".",
"Timer",
"{",
"return",
"NewCountTimer",
"(",
"duration",
",",
"1",
",",
"fn",
")",
"\n",
"}"
] | // NewAfterTimer returns a new Timer containing a function that will be called
// after duration that specified by the duration argument.
// The duration d must be greater than zero; if not, NewAfterTimer will panic.
// Stop the timer to release associated resources. | [
"NewAfterTimer",
"returns",
"a",
"new",
"Timer",
"containing",
"a",
"function",
"that",
"will",
"be",
"called",
"after",
"duration",
"that",
"specified",
"by",
"the",
"duration",
"argument",
".",
"The",
"duration",
"d",
"must",
"be",
"greater",
"than",
"zero",
";",
"if",
"not",
"NewAfterTimer",
"will",
"panic",
".",
"Stop",
"the",
"timer",
"to",
"release",
"associated",
"resources",
"."
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/timer.go#L63-L65 | train |
topfreegames/pitaya | timer.go | NewCondTimer | func NewCondTimer(condition timer.Condition, fn timer.Func) (*timer.Timer, error) {
if condition == nil {
return nil, constants.ErrNilCondition
}
t := NewCountTimer(time.Duration(math.MaxInt64), timer.LoopForever, fn)
t.SetCondition(condition)
return t, nil
} | go | func NewCondTimer(condition timer.Condition, fn timer.Func) (*timer.Timer, error) {
if condition == nil {
return nil, constants.ErrNilCondition
}
t := NewCountTimer(time.Duration(math.MaxInt64), timer.LoopForever, fn)
t.SetCondition(condition)
return t, nil
} | [
"func",
"NewCondTimer",
"(",
"condition",
"timer",
".",
"Condition",
",",
"fn",
"timer",
".",
"Func",
")",
"(",
"*",
"timer",
".",
"Timer",
",",
"error",
")",
"{",
"if",
"condition",
"==",
"nil",
"{",
"return",
"nil",
",",
"constants",
".",
"ErrNilCondition",
"\n",
"}",
"\n",
"t",
":=",
"NewCountTimer",
"(",
"time",
".",
"Duration",
"(",
"math",
".",
"MaxInt64",
")",
",",
"timer",
".",
"LoopForever",
",",
"fn",
")",
"\n",
"t",
".",
"SetCondition",
"(",
"condition",
")",
"\n",
"return",
"t",
",",
"nil",
"\n",
"}"
] | // NewCondTimer returns a new Timer containing a function that will be called
// when condition satisfied that specified by the condition argument.
// The duration d must be greater than zero; if not, NewCondTimer will panic.
// Stop the timer to release associated resources. | [
"NewCondTimer",
"returns",
"a",
"new",
"Timer",
"containing",
"a",
"function",
"that",
"will",
"be",
"called",
"when",
"condition",
"satisfied",
"that",
"specified",
"by",
"the",
"condition",
"argument",
".",
"The",
"duration",
"d",
"must",
"be",
"greater",
"than",
"zero",
";",
"if",
"not",
"NewCondTimer",
"will",
"panic",
".",
"Stop",
"the",
"timer",
"to",
"release",
"associated",
"resources",
"."
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/timer.go#L71-L79 | train |
topfreegames/pitaya | timer.go | SetTimerPrecision | func SetTimerPrecision(precision time.Duration) {
if precision < time.Millisecond {
panic("time precision can not less than a Millisecond")
}
timer.Precision = precision
} | go | func SetTimerPrecision(precision time.Duration) {
if precision < time.Millisecond {
panic("time precision can not less than a Millisecond")
}
timer.Precision = precision
} | [
"func",
"SetTimerPrecision",
"(",
"precision",
"time",
".",
"Duration",
")",
"{",
"if",
"precision",
"<",
"time",
".",
"Millisecond",
"{",
"panic",
"(",
"\"time precision can not less than a Millisecond\"",
")",
"\n",
"}",
"\n",
"timer",
".",
"Precision",
"=",
"precision",
"\n",
"}"
] | // SetTimerPrecision set the ticker precision, and time precision can not less
// than a Millisecond, and can not change after application running. The default
// precision is time.Second | [
"SetTimerPrecision",
"set",
"the",
"ticker",
"precision",
"and",
"time",
"precision",
"can",
"not",
"less",
"than",
"a",
"Millisecond",
"and",
"can",
"not",
"change",
"after",
"application",
"running",
".",
"The",
"default",
"precision",
"is",
"time",
".",
"Second"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/timer.go#L84-L89 | train |
topfreegames/pitaya | examples/demo/cluster/services/connector.go | NotifySessionData | func (c *Connector) NotifySessionData(ctx context.Context, data *SessionData) {
s := pitaya.GetSessionFromCtx(ctx)
err := s.SetData(data.Data)
if err != nil {
fmt.Println("got error on notify", err)
}
} | go | func (c *Connector) NotifySessionData(ctx context.Context, data *SessionData) {
s := pitaya.GetSessionFromCtx(ctx)
err := s.SetData(data.Data)
if err != nil {
fmt.Println("got error on notify", err)
}
} | [
"func",
"(",
"c",
"*",
"Connector",
")",
"NotifySessionData",
"(",
"ctx",
"context",
".",
"Context",
",",
"data",
"*",
"SessionData",
")",
"{",
"s",
":=",
"pitaya",
".",
"GetSessionFromCtx",
"(",
"ctx",
")",
"\n",
"err",
":=",
"s",
".",
"SetData",
"(",
"data",
".",
"Data",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Println",
"(",
"\"got error on notify\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}"
] | // NotifySessionData sets the session data | [
"NotifySessionData",
"sets",
"the",
"session",
"data"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/examples/demo/cluster/services/connector.go#L62-L68 | train |
topfreegames/pitaya | examples/demo/cluster/services/connector.go | Docs | func (c *ConnectorRemote) Docs(ctx context.Context, ddd *protos.Doc) (*protos.Doc, error) {
d, err := pitaya.Documentation(true)
if err != nil {
return nil, err
}
doc, err := json.Marshal(d)
if err != nil {
return nil, err
}
return &protos.Doc{Doc: string(doc)}, nil
} | go | func (c *ConnectorRemote) Docs(ctx context.Context, ddd *protos.Doc) (*protos.Doc, error) {
d, err := pitaya.Documentation(true)
if err != nil {
return nil, err
}
doc, err := json.Marshal(d)
if err != nil {
return nil, err
}
return &protos.Doc{Doc: string(doc)}, nil
} | [
"func",
"(",
"c",
"*",
"ConnectorRemote",
")",
"Docs",
"(",
"ctx",
"context",
".",
"Context",
",",
"ddd",
"*",
"protos",
".",
"Doc",
")",
"(",
"*",
"protos",
".",
"Doc",
",",
"error",
")",
"{",
"d",
",",
"err",
":=",
"pitaya",
".",
"Documentation",
"(",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"doc",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"d",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"protos",
".",
"Doc",
"{",
"Doc",
":",
"string",
"(",
"doc",
")",
"}",
",",
"nil",
"\n",
"}"
] | // Docs returns documentation | [
"Docs",
"returns",
"documentation"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/examples/demo/cluster/services/connector.go#L79-L91 | train |
topfreegames/pitaya | acceptor/tcp_acceptor.go | NewTCPAcceptor | func NewTCPAcceptor(addr string, certs ...string) *TCPAcceptor {
keyFile := ""
certFile := ""
if len(certs) != 2 && len(certs) != 0 {
panic(constants.ErrInvalidCertificates)
} else if len(certs) == 2 {
certFile = certs[0]
keyFile = certs[1]
}
return &TCPAcceptor{
addr: addr,
connChan: make(chan net.Conn),
running: false,
certFile: certFile,
keyFile: keyFile,
}
} | go | func NewTCPAcceptor(addr string, certs ...string) *TCPAcceptor {
keyFile := ""
certFile := ""
if len(certs) != 2 && len(certs) != 0 {
panic(constants.ErrInvalidCertificates)
} else if len(certs) == 2 {
certFile = certs[0]
keyFile = certs[1]
}
return &TCPAcceptor{
addr: addr,
connChan: make(chan net.Conn),
running: false,
certFile: certFile,
keyFile: keyFile,
}
} | [
"func",
"NewTCPAcceptor",
"(",
"addr",
"string",
",",
"certs",
"...",
"string",
")",
"*",
"TCPAcceptor",
"{",
"keyFile",
":=",
"\"\"",
"\n",
"certFile",
":=",
"\"\"",
"\n",
"if",
"len",
"(",
"certs",
")",
"!=",
"2",
"&&",
"len",
"(",
"certs",
")",
"!=",
"0",
"{",
"panic",
"(",
"constants",
".",
"ErrInvalidCertificates",
")",
"\n",
"}",
"else",
"if",
"len",
"(",
"certs",
")",
"==",
"2",
"{",
"certFile",
"=",
"certs",
"[",
"0",
"]",
"\n",
"keyFile",
"=",
"certs",
"[",
"1",
"]",
"\n",
"}",
"\n",
"return",
"&",
"TCPAcceptor",
"{",
"addr",
":",
"addr",
",",
"connChan",
":",
"make",
"(",
"chan",
"net",
".",
"Conn",
")",
",",
"running",
":",
"false",
",",
"certFile",
":",
"certFile",
",",
"keyFile",
":",
"keyFile",
",",
"}",
"\n",
"}"
] | // NewTCPAcceptor creates a new instance of tcp acceptor | [
"NewTCPAcceptor",
"creates",
"a",
"new",
"instance",
"of",
"tcp",
"acceptor"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/acceptor/tcp_acceptor.go#L42-L59 | train |
topfreegames/pitaya | acceptor/tcp_acceptor.go | ListenAndServe | func (a *TCPAcceptor) ListenAndServe() {
if a.hasTLSCertificates() {
a.ListenAndServeTLS(a.certFile, a.keyFile)
return
}
listener, err := net.Listen("tcp", a.addr)
if err != nil {
logger.Log.Fatalf("Failed to listen: %s", err.Error())
}
a.listener = listener
a.running = true
a.serve()
} | go | func (a *TCPAcceptor) ListenAndServe() {
if a.hasTLSCertificates() {
a.ListenAndServeTLS(a.certFile, a.keyFile)
return
}
listener, err := net.Listen("tcp", a.addr)
if err != nil {
logger.Log.Fatalf("Failed to listen: %s", err.Error())
}
a.listener = listener
a.running = true
a.serve()
} | [
"func",
"(",
"a",
"*",
"TCPAcceptor",
")",
"ListenAndServe",
"(",
")",
"{",
"if",
"a",
".",
"hasTLSCertificates",
"(",
")",
"{",
"a",
".",
"ListenAndServeTLS",
"(",
"a",
".",
"certFile",
",",
"a",
".",
"keyFile",
")",
"\n",
"return",
"\n",
"}",
"\n",
"listener",
",",
"err",
":=",
"net",
".",
"Listen",
"(",
"\"tcp\"",
",",
"a",
".",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Log",
".",
"Fatalf",
"(",
"\"Failed to listen: %s\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"a",
".",
"listener",
"=",
"listener",
"\n",
"a",
".",
"running",
"=",
"true",
"\n",
"a",
".",
"serve",
"(",
")",
"\n",
"}"
] | // ListenAndServe using tcp acceptor | [
"ListenAndServe",
"using",
"tcp",
"acceptor"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/acceptor/tcp_acceptor.go#L85-L98 | train |
topfreegames/pitaya | acceptor/tcp_acceptor.go | ListenAndServeTLS | func (a *TCPAcceptor) ListenAndServeTLS(cert, key string) {
crt, err := tls.LoadX509KeyPair(cert, key)
if err != nil {
logger.Log.Fatalf("Failed to listen: %s", err.Error())
}
tlsCfg := &tls.Config{Certificates: []tls.Certificate{crt}}
listener, err := tls.Listen("tcp", a.addr, tlsCfg)
a.listener = listener
a.running = true
a.serve()
} | go | func (a *TCPAcceptor) ListenAndServeTLS(cert, key string) {
crt, err := tls.LoadX509KeyPair(cert, key)
if err != nil {
logger.Log.Fatalf("Failed to listen: %s", err.Error())
}
tlsCfg := &tls.Config{Certificates: []tls.Certificate{crt}}
listener, err := tls.Listen("tcp", a.addr, tlsCfg)
a.listener = listener
a.running = true
a.serve()
} | [
"func",
"(",
"a",
"*",
"TCPAcceptor",
")",
"ListenAndServeTLS",
"(",
"cert",
",",
"key",
"string",
")",
"{",
"crt",
",",
"err",
":=",
"tls",
".",
"LoadX509KeyPair",
"(",
"cert",
",",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Log",
".",
"Fatalf",
"(",
"\"Failed to listen: %s\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"tlsCfg",
":=",
"&",
"tls",
".",
"Config",
"{",
"Certificates",
":",
"[",
"]",
"tls",
".",
"Certificate",
"{",
"crt",
"}",
"}",
"\n",
"listener",
",",
"err",
":=",
"tls",
".",
"Listen",
"(",
"\"tcp\"",
",",
"a",
".",
"addr",
",",
"tlsCfg",
")",
"\n",
"a",
".",
"listener",
"=",
"listener",
"\n",
"a",
".",
"running",
"=",
"true",
"\n",
"a",
".",
"serve",
"(",
")",
"\n",
"}"
] | // ListenAndServeTLS listens using tls | [
"ListenAndServeTLS",
"listens",
"using",
"tls"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/acceptor/tcp_acceptor.go#L101-L113 | train |
topfreegames/pitaya | acceptor/ws_acceptor.go | NewWSAcceptor | func NewWSAcceptor(addr string, certs ...string) *WSAcceptor {
keyFile := ""
certFile := ""
if len(certs) != 2 && len(certs) != 0 {
panic(constants.ErrInvalidCertificates)
} else if len(certs) == 2 {
certFile = certs[0]
keyFile = certs[1]
}
w := &WSAcceptor{
addr: addr,
connChan: make(chan net.Conn),
certFile: certFile,
keyFile: keyFile,
}
return w
} | go | func NewWSAcceptor(addr string, certs ...string) *WSAcceptor {
keyFile := ""
certFile := ""
if len(certs) != 2 && len(certs) != 0 {
panic(constants.ErrInvalidCertificates)
} else if len(certs) == 2 {
certFile = certs[0]
keyFile = certs[1]
}
w := &WSAcceptor{
addr: addr,
connChan: make(chan net.Conn),
certFile: certFile,
keyFile: keyFile,
}
return w
} | [
"func",
"NewWSAcceptor",
"(",
"addr",
"string",
",",
"certs",
"...",
"string",
")",
"*",
"WSAcceptor",
"{",
"keyFile",
":=",
"\"\"",
"\n",
"certFile",
":=",
"\"\"",
"\n",
"if",
"len",
"(",
"certs",
")",
"!=",
"2",
"&&",
"len",
"(",
"certs",
")",
"!=",
"0",
"{",
"panic",
"(",
"constants",
".",
"ErrInvalidCertificates",
")",
"\n",
"}",
"else",
"if",
"len",
"(",
"certs",
")",
"==",
"2",
"{",
"certFile",
"=",
"certs",
"[",
"0",
"]",
"\n",
"keyFile",
"=",
"certs",
"[",
"1",
"]",
"\n",
"}",
"\n",
"w",
":=",
"&",
"WSAcceptor",
"{",
"addr",
":",
"addr",
",",
"connChan",
":",
"make",
"(",
"chan",
"net",
".",
"Conn",
")",
",",
"certFile",
":",
"certFile",
",",
"keyFile",
":",
"keyFile",
",",
"}",
"\n",
"return",
"w",
"\n",
"}"
] | // NewWSAcceptor returns a new instance of WSAcceptor | [
"NewWSAcceptor",
"returns",
"a",
"new",
"instance",
"of",
"WSAcceptor"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/acceptor/ws_acceptor.go#L45-L62 | train |
topfreegames/pitaya | acceptor/ws_acceptor.go | ListenAndServe | func (w *WSAcceptor) ListenAndServe() {
if w.hasTLSCertificates() {
w.ListenAndServeTLS(w.certFile, w.keyFile)
return
}
var upgrader = websocket.Upgrader{
ReadBufferSize: 1024,
WriteBufferSize: 1024,
CheckOrigin: func(r *http.Request) bool {
return true
},
}
listener, err := net.Listen("tcp", w.addr)
if err != nil {
logger.Log.Fatalf("Failed to listen: %s", err.Error())
}
w.listener = listener
w.serve(&upgrader)
} | go | func (w *WSAcceptor) ListenAndServe() {
if w.hasTLSCertificates() {
w.ListenAndServeTLS(w.certFile, w.keyFile)
return
}
var upgrader = websocket.Upgrader{
ReadBufferSize: 1024,
WriteBufferSize: 1024,
CheckOrigin: func(r *http.Request) bool {
return true
},
}
listener, err := net.Listen("tcp", w.addr)
if err != nil {
logger.Log.Fatalf("Failed to listen: %s", err.Error())
}
w.listener = listener
w.serve(&upgrader)
} | [
"func",
"(",
"w",
"*",
"WSAcceptor",
")",
"ListenAndServe",
"(",
")",
"{",
"if",
"w",
".",
"hasTLSCertificates",
"(",
")",
"{",
"w",
".",
"ListenAndServeTLS",
"(",
"w",
".",
"certFile",
",",
"w",
".",
"keyFile",
")",
"\n",
"return",
"\n",
"}",
"\n",
"var",
"upgrader",
"=",
"websocket",
".",
"Upgrader",
"{",
"ReadBufferSize",
":",
"1024",
",",
"WriteBufferSize",
":",
"1024",
",",
"CheckOrigin",
":",
"func",
"(",
"r",
"*",
"http",
".",
"Request",
")",
"bool",
"{",
"return",
"true",
"\n",
"}",
",",
"}",
"\n",
"listener",
",",
"err",
":=",
"net",
".",
"Listen",
"(",
"\"tcp\"",
",",
"w",
".",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Log",
".",
"Fatalf",
"(",
"\"Failed to listen: %s\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"w",
".",
"listener",
"=",
"listener",
"\n",
"w",
".",
"serve",
"(",
"&",
"upgrader",
")",
"\n",
"}"
] | // ListenAndServe listens and serve in the specified addr | [
"ListenAndServe",
"listens",
"and",
"serve",
"in",
"the",
"specified",
"addr"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/acceptor/ws_acceptor.go#L102-L123 | train |
topfreegames/pitaya | acceptor/ws_acceptor.go | ListenAndServeTLS | func (w *WSAcceptor) ListenAndServeTLS(cert, key string) {
var upgrader = websocket.Upgrader{
ReadBufferSize: 1024,
WriteBufferSize: 1024,
}
crt, err := tls.LoadX509KeyPair(cert, key)
if err != nil {
logger.Log.Fatalf("Failed to load x509: %s", err.Error())
}
tlsCfg := &tls.Config{Certificates: []tls.Certificate{crt}}
listener, err := tls.Listen("tcp", w.addr, tlsCfg)
if err != nil {
logger.Log.Fatalf("Failed to listen: %s", err.Error())
}
w.listener = listener
w.serve(&upgrader)
} | go | func (w *WSAcceptor) ListenAndServeTLS(cert, key string) {
var upgrader = websocket.Upgrader{
ReadBufferSize: 1024,
WriteBufferSize: 1024,
}
crt, err := tls.LoadX509KeyPair(cert, key)
if err != nil {
logger.Log.Fatalf("Failed to load x509: %s", err.Error())
}
tlsCfg := &tls.Config{Certificates: []tls.Certificate{crt}}
listener, err := tls.Listen("tcp", w.addr, tlsCfg)
if err != nil {
logger.Log.Fatalf("Failed to listen: %s", err.Error())
}
w.listener = listener
w.serve(&upgrader)
} | [
"func",
"(",
"w",
"*",
"WSAcceptor",
")",
"ListenAndServeTLS",
"(",
"cert",
",",
"key",
"string",
")",
"{",
"var",
"upgrader",
"=",
"websocket",
".",
"Upgrader",
"{",
"ReadBufferSize",
":",
"1024",
",",
"WriteBufferSize",
":",
"1024",
",",
"}",
"\n",
"crt",
",",
"err",
":=",
"tls",
".",
"LoadX509KeyPair",
"(",
"cert",
",",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Log",
".",
"Fatalf",
"(",
"\"Failed to load x509: %s\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"tlsCfg",
":=",
"&",
"tls",
".",
"Config",
"{",
"Certificates",
":",
"[",
"]",
"tls",
".",
"Certificate",
"{",
"crt",
"}",
"}",
"\n",
"listener",
",",
"err",
":=",
"tls",
".",
"Listen",
"(",
"\"tcp\"",
",",
"w",
".",
"addr",
",",
"tlsCfg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Log",
".",
"Fatalf",
"(",
"\"Failed to listen: %s\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"w",
".",
"listener",
"=",
"listener",
"\n",
"w",
".",
"serve",
"(",
"&",
"upgrader",
")",
"\n",
"}"
] | // ListenAndServeTLS listens and serve in the specified addr using tls | [
"ListenAndServeTLS",
"listens",
"and",
"serve",
"in",
"the",
"specified",
"addr",
"using",
"tls"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/acceptor/ws_acceptor.go#L126-L144 | train |
topfreegames/pitaya | acceptor/ws_acceptor.go | Stop | func (w *WSAcceptor) Stop() {
err := w.listener.Close()
if err != nil {
logger.Log.Errorf("Failed to stop: %s", err.Error())
}
} | go | func (w *WSAcceptor) Stop() {
err := w.listener.Close()
if err != nil {
logger.Log.Errorf("Failed to stop: %s", err.Error())
}
} | [
"func",
"(",
"w",
"*",
"WSAcceptor",
")",
"Stop",
"(",
")",
"{",
"err",
":=",
"w",
".",
"listener",
".",
"Close",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Log",
".",
"Errorf",
"(",
"\"Failed to stop: %s\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}"
] | // Stop stops the acceptor | [
"Stop",
"stops",
"the",
"acceptor"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/acceptor/ws_acceptor.go#L156-L161 | train |
topfreegames/pitaya | client/client.go | New | func New(logLevel logrus.Level, requestTimeout ...time.Duration) *Client {
l := logrus.New()
l.Formatter = &logrus.TextFormatter{}
l.SetLevel(logLevel)
logger.Log = l
reqTimeout := 5 * time.Second
if len(requestTimeout) > 0 {
reqTimeout = requestTimeout[0]
}
return &Client{
Connected: false,
packetEncoder: codec.NewPomeloPacketEncoder(),
packetDecoder: codec.NewPomeloPacketDecoder(),
packetChan: make(chan *packet.Packet, 10),
pendingRequests: make(map[uint]*pendingRequest),
requestTimeout: reqTimeout,
// 30 here is the limit of inflight messages
// TODO this should probably be configurable
pendingChan: make(chan bool, 30),
messageEncoder: message.NewMessagesEncoder(true),
}
} | go | func New(logLevel logrus.Level, requestTimeout ...time.Duration) *Client {
l := logrus.New()
l.Formatter = &logrus.TextFormatter{}
l.SetLevel(logLevel)
logger.Log = l
reqTimeout := 5 * time.Second
if len(requestTimeout) > 0 {
reqTimeout = requestTimeout[0]
}
return &Client{
Connected: false,
packetEncoder: codec.NewPomeloPacketEncoder(),
packetDecoder: codec.NewPomeloPacketDecoder(),
packetChan: make(chan *packet.Packet, 10),
pendingRequests: make(map[uint]*pendingRequest),
requestTimeout: reqTimeout,
// 30 here is the limit of inflight messages
// TODO this should probably be configurable
pendingChan: make(chan bool, 30),
messageEncoder: message.NewMessagesEncoder(true),
}
} | [
"func",
"New",
"(",
"logLevel",
"logrus",
".",
"Level",
",",
"requestTimeout",
"...",
"time",
".",
"Duration",
")",
"*",
"Client",
"{",
"l",
":=",
"logrus",
".",
"New",
"(",
")",
"\n",
"l",
".",
"Formatter",
"=",
"&",
"logrus",
".",
"TextFormatter",
"{",
"}",
"\n",
"l",
".",
"SetLevel",
"(",
"logLevel",
")",
"\n",
"logger",
".",
"Log",
"=",
"l",
"\n",
"reqTimeout",
":=",
"5",
"*",
"time",
".",
"Second",
"\n",
"if",
"len",
"(",
"requestTimeout",
")",
">",
"0",
"{",
"reqTimeout",
"=",
"requestTimeout",
"[",
"0",
"]",
"\n",
"}",
"\n",
"return",
"&",
"Client",
"{",
"Connected",
":",
"false",
",",
"packetEncoder",
":",
"codec",
".",
"NewPomeloPacketEncoder",
"(",
")",
",",
"packetDecoder",
":",
"codec",
".",
"NewPomeloPacketDecoder",
"(",
")",
",",
"packetChan",
":",
"make",
"(",
"chan",
"*",
"packet",
".",
"Packet",
",",
"10",
")",
",",
"pendingRequests",
":",
"make",
"(",
"map",
"[",
"uint",
"]",
"*",
"pendingRequest",
")",
",",
"requestTimeout",
":",
"reqTimeout",
",",
"pendingChan",
":",
"make",
"(",
"chan",
"bool",
",",
"30",
")",
",",
"messageEncoder",
":",
"message",
".",
"NewMessagesEncoder",
"(",
"true",
")",
",",
"}",
"\n",
"}"
] | // New returns a new client | [
"New",
"returns",
"a",
"new",
"client"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/client/client.go#L104-L128 | train |
topfreegames/pitaya | client/client.go | pendingRequestsReaper | func (c *Client) pendingRequestsReaper() {
ticker := time.NewTicker(1 * time.Second)
defer ticker.Stop()
for {
select {
case <-ticker.C:
toDelete := make([]*pendingRequest, 0)
c.pendingReqMutex.Lock()
for _, v := range c.pendingRequests {
if time.Now().Sub(v.sentAt) > c.requestTimeout {
toDelete = append(toDelete, v)
}
}
for _, pendingReq := range toDelete {
err := pitaya.Error(errors.New("request timeout"), "PIT-504")
errMarshalled, _ := json.Marshal(err)
// send a timeout to incoming msg chan
m := &message.Message{
Type: message.Response,
ID: pendingReq.msg.ID,
Route: pendingReq.msg.Route,
Data: errMarshalled,
Err: true,
}
delete(c.pendingRequests, pendingReq.msg.ID)
<-c.pendingChan
c.IncomingMsgChan <- m
}
c.pendingReqMutex.Unlock()
case <-c.closeChan:
return
}
}
} | go | func (c *Client) pendingRequestsReaper() {
ticker := time.NewTicker(1 * time.Second)
defer ticker.Stop()
for {
select {
case <-ticker.C:
toDelete := make([]*pendingRequest, 0)
c.pendingReqMutex.Lock()
for _, v := range c.pendingRequests {
if time.Now().Sub(v.sentAt) > c.requestTimeout {
toDelete = append(toDelete, v)
}
}
for _, pendingReq := range toDelete {
err := pitaya.Error(errors.New("request timeout"), "PIT-504")
errMarshalled, _ := json.Marshal(err)
// send a timeout to incoming msg chan
m := &message.Message{
Type: message.Response,
ID: pendingReq.msg.ID,
Route: pendingReq.msg.Route,
Data: errMarshalled,
Err: true,
}
delete(c.pendingRequests, pendingReq.msg.ID)
<-c.pendingChan
c.IncomingMsgChan <- m
}
c.pendingReqMutex.Unlock()
case <-c.closeChan:
return
}
}
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"pendingRequestsReaper",
"(",
")",
"{",
"ticker",
":=",
"time",
".",
"NewTicker",
"(",
"1",
"*",
"time",
".",
"Second",
")",
"\n",
"defer",
"ticker",
".",
"Stop",
"(",
")",
"\n",
"for",
"{",
"select",
"{",
"case",
"<-",
"ticker",
".",
"C",
":",
"toDelete",
":=",
"make",
"(",
"[",
"]",
"*",
"pendingRequest",
",",
"0",
")",
"\n",
"c",
".",
"pendingReqMutex",
".",
"Lock",
"(",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"c",
".",
"pendingRequests",
"{",
"if",
"time",
".",
"Now",
"(",
")",
".",
"Sub",
"(",
"v",
".",
"sentAt",
")",
">",
"c",
".",
"requestTimeout",
"{",
"toDelete",
"=",
"append",
"(",
"toDelete",
",",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"for",
"_",
",",
"pendingReq",
":=",
"range",
"toDelete",
"{",
"err",
":=",
"pitaya",
".",
"Error",
"(",
"errors",
".",
"New",
"(",
"\"request timeout\"",
")",
",",
"\"PIT-504\"",
")",
"\n",
"errMarshalled",
",",
"_",
":=",
"json",
".",
"Marshal",
"(",
"err",
")",
"\n",
"m",
":=",
"&",
"message",
".",
"Message",
"{",
"Type",
":",
"message",
".",
"Response",
",",
"ID",
":",
"pendingReq",
".",
"msg",
".",
"ID",
",",
"Route",
":",
"pendingReq",
".",
"msg",
".",
"Route",
",",
"Data",
":",
"errMarshalled",
",",
"Err",
":",
"true",
",",
"}",
"\n",
"delete",
"(",
"c",
".",
"pendingRequests",
",",
"pendingReq",
".",
"msg",
".",
"ID",
")",
"\n",
"<-",
"c",
".",
"pendingChan",
"\n",
"c",
".",
"IncomingMsgChan",
"<-",
"m",
"\n",
"}",
"\n",
"c",
".",
"pendingReqMutex",
".",
"Unlock",
"(",
")",
"\n",
"case",
"<-",
"c",
".",
"closeChan",
":",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // pendingRequestsReaper delete timedout requests | [
"pendingRequestsReaper",
"delete",
"timedout",
"requests"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/client/client.go#L189-L222 | train |
topfreegames/pitaya | client/client.go | Disconnect | func (c *Client) Disconnect() {
if c.Connected {
c.Connected = false
close(c.closeChan)
c.conn.Close()
}
} | go | func (c *Client) Disconnect() {
if c.Connected {
c.Connected = false
close(c.closeChan)
c.conn.Close()
}
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Disconnect",
"(",
")",
"{",
"if",
"c",
".",
"Connected",
"{",
"c",
".",
"Connected",
"=",
"false",
"\n",
"close",
"(",
"c",
".",
"closeChan",
")",
"\n",
"c",
".",
"conn",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // Disconnect disconnects the client | [
"Disconnect",
"disconnects",
"the",
"client"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/client/client.go#L317-L323 | train |
topfreegames/pitaya | client/client.go | sendMsg | func (c *Client) sendMsg(msgType message.Type, route string, data []byte) (uint, error) {
// TODO mount msg and encode
m := message.Message{
Type: msgType,
ID: uint(atomic.AddUint32(&c.nextID, 1)),
Route: route,
Data: data,
Err: false,
}
p, err := c.buildPacket(m)
if msgType == message.Request {
c.pendingChan <- true
c.pendingReqMutex.Lock()
if _, ok := c.pendingRequests[m.ID]; !ok {
c.pendingRequests[m.ID] = &pendingRequest{
msg: &m,
sentAt: time.Now(),
}
}
c.pendingReqMutex.Unlock()
}
if err != nil {
return m.ID, err
}
_, err = c.conn.Write(p)
return m.ID, err
} | go | func (c *Client) sendMsg(msgType message.Type, route string, data []byte) (uint, error) {
// TODO mount msg and encode
m := message.Message{
Type: msgType,
ID: uint(atomic.AddUint32(&c.nextID, 1)),
Route: route,
Data: data,
Err: false,
}
p, err := c.buildPacket(m)
if msgType == message.Request {
c.pendingChan <- true
c.pendingReqMutex.Lock()
if _, ok := c.pendingRequests[m.ID]; !ok {
c.pendingRequests[m.ID] = &pendingRequest{
msg: &m,
sentAt: time.Now(),
}
}
c.pendingReqMutex.Unlock()
}
if err != nil {
return m.ID, err
}
_, err = c.conn.Write(p)
return m.ID, err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"sendMsg",
"(",
"msgType",
"message",
".",
"Type",
",",
"route",
"string",
",",
"data",
"[",
"]",
"byte",
")",
"(",
"uint",
",",
"error",
")",
"{",
"m",
":=",
"message",
".",
"Message",
"{",
"Type",
":",
"msgType",
",",
"ID",
":",
"uint",
"(",
"atomic",
".",
"AddUint32",
"(",
"&",
"c",
".",
"nextID",
",",
"1",
")",
")",
",",
"Route",
":",
"route",
",",
"Data",
":",
"data",
",",
"Err",
":",
"false",
",",
"}",
"\n",
"p",
",",
"err",
":=",
"c",
".",
"buildPacket",
"(",
"m",
")",
"\n",
"if",
"msgType",
"==",
"message",
".",
"Request",
"{",
"c",
".",
"pendingChan",
"<-",
"true",
"\n",
"c",
".",
"pendingReqMutex",
".",
"Lock",
"(",
")",
"\n",
"if",
"_",
",",
"ok",
":=",
"c",
".",
"pendingRequests",
"[",
"m",
".",
"ID",
"]",
";",
"!",
"ok",
"{",
"c",
".",
"pendingRequests",
"[",
"m",
".",
"ID",
"]",
"=",
"&",
"pendingRequest",
"{",
"msg",
":",
"&",
"m",
",",
"sentAt",
":",
"time",
".",
"Now",
"(",
")",
",",
"}",
"\n",
"}",
"\n",
"c",
".",
"pendingReqMutex",
".",
"Unlock",
"(",
")",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"m",
".",
"ID",
",",
"err",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"c",
".",
"conn",
".",
"Write",
"(",
"p",
")",
"\n",
"return",
"m",
".",
"ID",
",",
"err",
"\n",
"}"
] | // sendMsg sends the request to the server | [
"sendMsg",
"sends",
"the",
"request",
"to",
"the",
"server"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/client/client.go#L400-L427 | train |
topfreegames/pitaya | cluster/mocks/service_discovery.go | NewMockServiceDiscovery | func NewMockServiceDiscovery(ctrl *gomock.Controller) *MockServiceDiscovery {
mock := &MockServiceDiscovery{ctrl: ctrl}
mock.recorder = &MockServiceDiscoveryMockRecorder{mock}
return mock
} | go | func NewMockServiceDiscovery(ctrl *gomock.Controller) *MockServiceDiscovery {
mock := &MockServiceDiscovery{ctrl: ctrl}
mock.recorder = &MockServiceDiscoveryMockRecorder{mock}
return mock
} | [
"func",
"NewMockServiceDiscovery",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockServiceDiscovery",
"{",
"mock",
":=",
"&",
"MockServiceDiscovery",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockServiceDiscoveryMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockServiceDiscovery creates a new mock instance | [
"NewMockServiceDiscovery",
"creates",
"a",
"new",
"mock",
"instance"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/mocks/service_discovery.go#L25-L29 | train |
topfreegames/pitaya | cluster/mocks/service_discovery.go | GetServersByType | func (m *MockServiceDiscovery) GetServersByType(serverType string) (map[string]*cluster.Server, error) {
ret := m.ctrl.Call(m, "GetServersByType", serverType)
ret0, _ := ret[0].(map[string]*cluster.Server)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockServiceDiscovery) GetServersByType(serverType string) (map[string]*cluster.Server, error) {
ret := m.ctrl.Call(m, "GetServersByType", serverType)
ret0, _ := ret[0].(map[string]*cluster.Server)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockServiceDiscovery",
")",
"GetServersByType",
"(",
"serverType",
"string",
")",
"(",
"map",
"[",
"string",
"]",
"*",
"cluster",
".",
"Server",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"GetServersByType\"",
",",
"serverType",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"map",
"[",
"string",
"]",
"*",
"cluster",
".",
"Server",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // GetServersByType mocks base method | [
"GetServersByType",
"mocks",
"base",
"method"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/mocks/service_discovery.go#L37-L42 | train |
topfreegames/pitaya | cluster/mocks/service_discovery.go | GetServersByType | func (mr *MockServiceDiscoveryMockRecorder) GetServersByType(serverType interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServersByType", reflect.TypeOf((*MockServiceDiscovery)(nil).GetServersByType), serverType)
} | go | func (mr *MockServiceDiscoveryMockRecorder) GetServersByType(serverType interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServersByType", reflect.TypeOf((*MockServiceDiscovery)(nil).GetServersByType), serverType)
} | [
"func",
"(",
"mr",
"*",
"MockServiceDiscoveryMockRecorder",
")",
"GetServersByType",
"(",
"serverType",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"GetServersByType\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockServiceDiscovery",
")",
"(",
"nil",
")",
".",
"GetServersByType",
")",
",",
"serverType",
")",
"\n",
"}"
] | // GetServersByType indicates an expected call of GetServersByType | [
"GetServersByType",
"indicates",
"an",
"expected",
"call",
"of",
"GetServersByType"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/mocks/service_discovery.go#L45-L47 | train |
topfreegames/pitaya | cluster/mocks/service_discovery.go | GetServer | func (m *MockServiceDiscovery) GetServer(id string) (*cluster.Server, error) {
ret := m.ctrl.Call(m, "GetServer", id)
ret0, _ := ret[0].(*cluster.Server)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockServiceDiscovery) GetServer(id string) (*cluster.Server, error) {
ret := m.ctrl.Call(m, "GetServer", id)
ret0, _ := ret[0].(*cluster.Server)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockServiceDiscovery",
")",
"GetServer",
"(",
"id",
"string",
")",
"(",
"*",
"cluster",
".",
"Server",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"GetServer\"",
",",
"id",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"cluster",
".",
"Server",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // GetServer mocks base method | [
"GetServer",
"mocks",
"base",
"method"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/mocks/service_discovery.go#L50-L55 | train |
topfreegames/pitaya | cluster/mocks/service_discovery.go | GetServer | func (mr *MockServiceDiscoveryMockRecorder) GetServer(id interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServer", reflect.TypeOf((*MockServiceDiscovery)(nil).GetServer), id)
} | go | func (mr *MockServiceDiscoveryMockRecorder) GetServer(id interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServer", reflect.TypeOf((*MockServiceDiscovery)(nil).GetServer), id)
} | [
"func",
"(",
"mr",
"*",
"MockServiceDiscoveryMockRecorder",
")",
"GetServer",
"(",
"id",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"GetServer\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockServiceDiscovery",
")",
"(",
"nil",
")",
".",
"GetServer",
")",
",",
"id",
")",
"\n",
"}"
] | // GetServer indicates an expected call of GetServer | [
"GetServer",
"indicates",
"an",
"expected",
"call",
"of",
"GetServer"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/mocks/service_discovery.go#L58-L60 | train |
topfreegames/pitaya | cluster/mocks/service_discovery.go | GetServers | func (m *MockServiceDiscovery) GetServers() []*cluster.Server {
ret := m.ctrl.Call(m, "GetServers")
ret0, _ := ret[0].([]*cluster.Server)
return ret0
} | go | func (m *MockServiceDiscovery) GetServers() []*cluster.Server {
ret := m.ctrl.Call(m, "GetServers")
ret0, _ := ret[0].([]*cluster.Server)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockServiceDiscovery",
")",
"GetServers",
"(",
")",
"[",
"]",
"*",
"cluster",
".",
"Server",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"GetServers\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"[",
"]",
"*",
"cluster",
".",
"Server",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // GetServers mocks base method | [
"GetServers",
"mocks",
"base",
"method"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/mocks/service_discovery.go#L63-L67 | train |
topfreegames/pitaya | cluster/mocks/service_discovery.go | AddListener | func (m *MockServiceDiscovery) AddListener(listener cluster.SDListener) {
m.ctrl.Call(m, "AddListener", listener)
} | go | func (m *MockServiceDiscovery) AddListener(listener cluster.SDListener) {
m.ctrl.Call(m, "AddListener", listener)
} | [
"func",
"(",
"m",
"*",
"MockServiceDiscovery",
")",
"AddListener",
"(",
"listener",
"cluster",
".",
"SDListener",
")",
"{",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"AddListener\"",
",",
"listener",
")",
"\n",
"}"
] | // AddListener mocks base method | [
"AddListener",
"mocks",
"base",
"method"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/mocks/service_discovery.go#L87-L89 | train |
topfreegames/pitaya | cluster/mocks/service_discovery.go | AddListener | func (mr *MockServiceDiscoveryMockRecorder) AddListener(listener interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddListener", reflect.TypeOf((*MockServiceDiscovery)(nil).AddListener), listener)
} | go | func (mr *MockServiceDiscoveryMockRecorder) AddListener(listener interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddListener", reflect.TypeOf((*MockServiceDiscovery)(nil).AddListener), listener)
} | [
"func",
"(",
"mr",
"*",
"MockServiceDiscoveryMockRecorder",
")",
"AddListener",
"(",
"listener",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"AddListener\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockServiceDiscovery",
")",
"(",
"nil",
")",
".",
"AddListener",
")",
",",
"listener",
")",
"\n",
"}"
] | // AddListener indicates an expected call of AddListener | [
"AddListener",
"indicates",
"an",
"expected",
"call",
"of",
"AddListener"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/cluster/mocks/service_discovery.go#L92-L94 | train |
topfreegames/pitaya | conn/message/mocks/message_encoder.go | NewMockEncoder | func NewMockEncoder(ctrl *gomock.Controller) *MockEncoder {
mock := &MockEncoder{ctrl: ctrl}
mock.recorder = &MockEncoderMockRecorder{mock}
return mock
} | go | func NewMockEncoder(ctrl *gomock.Controller) *MockEncoder {
mock := &MockEncoder{ctrl: ctrl}
mock.recorder = &MockEncoderMockRecorder{mock}
return mock
} | [
"func",
"NewMockEncoder",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockEncoder",
"{",
"mock",
":=",
"&",
"MockEncoder",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockEncoderMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockEncoder creates a new mock instance | [
"NewMockEncoder",
"creates",
"a",
"new",
"mock",
"instance"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/conn/message/mocks/message_encoder.go#L25-L29 | train |
topfreegames/pitaya | conn/message/mocks/message_encoder.go | IsCompressionEnabled | func (m *MockEncoder) IsCompressionEnabled() bool {
ret := m.ctrl.Call(m, "IsCompressionEnabled")
ret0, _ := ret[0].(bool)
return ret0
} | go | func (m *MockEncoder) IsCompressionEnabled() bool {
ret := m.ctrl.Call(m, "IsCompressionEnabled")
ret0, _ := ret[0].(bool)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockEncoder",
")",
"IsCompressionEnabled",
"(",
")",
"bool",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"IsCompressionEnabled\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"bool",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // IsCompressionEnabled mocks base method | [
"IsCompressionEnabled",
"mocks",
"base",
"method"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/conn/message/mocks/message_encoder.go#L37-L41 | train |
topfreegames/pitaya | conn/message/mocks/message_encoder.go | IsCompressionEnabled | func (mr *MockEncoderMockRecorder) IsCompressionEnabled() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsCompressionEnabled", reflect.TypeOf((*MockEncoder)(nil).IsCompressionEnabled))
} | go | func (mr *MockEncoderMockRecorder) IsCompressionEnabled() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsCompressionEnabled", reflect.TypeOf((*MockEncoder)(nil).IsCompressionEnabled))
} | [
"func",
"(",
"mr",
"*",
"MockEncoderMockRecorder",
")",
"IsCompressionEnabled",
"(",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"IsCompressionEnabled\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockEncoder",
")",
"(",
"nil",
")",
".",
"IsCompressionEnabled",
")",
")",
"\n",
"}"
] | // IsCompressionEnabled indicates an expected call of IsCompressionEnabled | [
"IsCompressionEnabled",
"indicates",
"an",
"expected",
"call",
"of",
"IsCompressionEnabled"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/conn/message/mocks/message_encoder.go#L44-L46 | train |
topfreegames/pitaya | examples/demo/cluster_grpc/services/connector.go | SendPushToUser | func (c *Connector) SendPushToUser(ctx context.Context, msg *UserMessage) (*Response, error) {
_, err := pitaya.SendPushToUsers("onMessage", msg, []string{"2"}, "connector")
if err != nil {
return nil, err
}
return &Response{
Code: 200,
Msg: "boa",
}, nil
} | go | func (c *Connector) SendPushToUser(ctx context.Context, msg *UserMessage) (*Response, error) {
_, err := pitaya.SendPushToUsers("onMessage", msg, []string{"2"}, "connector")
if err != nil {
return nil, err
}
return &Response{
Code: 200,
Msg: "boa",
}, nil
} | [
"func",
"(",
"c",
"*",
"Connector",
")",
"SendPushToUser",
"(",
"ctx",
"context",
".",
"Context",
",",
"msg",
"*",
"UserMessage",
")",
"(",
"*",
"Response",
",",
"error",
")",
"{",
"_",
",",
"err",
":=",
"pitaya",
".",
"SendPushToUsers",
"(",
"\"onMessage\"",
",",
"msg",
",",
"[",
"]",
"string",
"{",
"\"2\"",
"}",
",",
"\"connector\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"Response",
"{",
"Code",
":",
"200",
",",
"Msg",
":",
"\"boa\"",
",",
"}",
",",
"nil",
"\n",
"}"
] | // SendPushToUser sends a push to a user | [
"SendPushToUser",
"sends",
"a",
"push",
"to",
"a",
"user"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/examples/demo/cluster_grpc/services/connector.go#L70-L79 | train |
topfreegames/pitaya | examples/demo/cluster_grpc/services/connector.go | RemoteFunc | func (c *ConnectorRemote) RemoteFunc(ctx context.Context, msg *protos.RPCMsg) (*protos.RPCRes, error) {
fmt.Printf("received a remote call with this message: %s\n", msg)
return &protos.RPCRes{
Msg: fmt.Sprintf("received msg: %s", msg.GetMsg()),
}, nil
} | go | func (c *ConnectorRemote) RemoteFunc(ctx context.Context, msg *protos.RPCMsg) (*protos.RPCRes, error) {
fmt.Printf("received a remote call with this message: %s\n", msg)
return &protos.RPCRes{
Msg: fmt.Sprintf("received msg: %s", msg.GetMsg()),
}, nil
} | [
"func",
"(",
"c",
"*",
"ConnectorRemote",
")",
"RemoteFunc",
"(",
"ctx",
"context",
".",
"Context",
",",
"msg",
"*",
"protos",
".",
"RPCMsg",
")",
"(",
"*",
"protos",
".",
"RPCRes",
",",
"error",
")",
"{",
"fmt",
".",
"Printf",
"(",
"\"received a remote call with this message: %s\\n\"",
",",
"\\n",
")",
"\n",
"msg",
"\n",
"}"
] | // RemoteFunc is a function that will be called remotely | [
"RemoteFunc",
"is",
"a",
"function",
"that",
"will",
"be",
"called",
"remotely"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/examples/demo/cluster_grpc/services/connector.go#L82-L87 | train |
topfreegames/pitaya | helpers/helpers.go | GetFreePort | func GetFreePort(t testing.TB) int {
t.Helper()
addr, err := net.ResolveTCPAddr("tcp", "localhost:0")
if err != nil {
t.Fatal(err)
}
l, err := net.ListenTCP("tcp", addr)
if err != nil {
t.Fatal(err)
}
defer l.Close()
return l.Addr().(*net.TCPAddr).Port
} | go | func GetFreePort(t testing.TB) int {
t.Helper()
addr, err := net.ResolveTCPAddr("tcp", "localhost:0")
if err != nil {
t.Fatal(err)
}
l, err := net.ListenTCP("tcp", addr)
if err != nil {
t.Fatal(err)
}
defer l.Close()
return l.Addr().(*net.TCPAddr).Port
} | [
"func",
"GetFreePort",
"(",
"t",
"testing",
".",
"TB",
")",
"int",
"{",
"t",
".",
"Helper",
"(",
")",
"\n",
"addr",
",",
"err",
":=",
"net",
".",
"ResolveTCPAddr",
"(",
"\"tcp\"",
",",
"\"localhost:0\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"t",
".",
"Fatal",
"(",
"err",
")",
"\n",
"}",
"\n",
"l",
",",
"err",
":=",
"net",
".",
"ListenTCP",
"(",
"\"tcp\"",
",",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"t",
".",
"Fatal",
"(",
"err",
")",
"\n",
"}",
"\n",
"defer",
"l",
".",
"Close",
"(",
")",
"\n",
"return",
"l",
".",
"Addr",
"(",
")",
".",
"(",
"*",
"net",
".",
"TCPAddr",
")",
".",
"Port",
"\n",
"}"
] | // GetFreePort returns a free port | [
"GetFreePort",
"returns",
"a",
"free",
"port"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/helpers/helpers.go#L24-L37 | train |
topfreegames/pitaya | helpers/helpers.go | GetMapKeys | func GetMapKeys(t *testing.T, m interface{}) []string {
if reflect.ValueOf(m).Kind() != reflect.Map {
t.Fatal(errors.New("GetMapKeys should receive a map"))
}
if reflect.TypeOf(m).Key() != reflect.TypeOf("bla") {
t.Fatal(errors.New("GetMapKeys should receive a map with string keys"))
}
t.Helper()
res := make([]string, 0)
for _, k := range reflect.ValueOf(m).MapKeys() {
res = append(res, k.String())
}
return res
} | go | func GetMapKeys(t *testing.T, m interface{}) []string {
if reflect.ValueOf(m).Kind() != reflect.Map {
t.Fatal(errors.New("GetMapKeys should receive a map"))
}
if reflect.TypeOf(m).Key() != reflect.TypeOf("bla") {
t.Fatal(errors.New("GetMapKeys should receive a map with string keys"))
}
t.Helper()
res := make([]string, 0)
for _, k := range reflect.ValueOf(m).MapKeys() {
res = append(res, k.String())
}
return res
} | [
"func",
"GetMapKeys",
"(",
"t",
"*",
"testing",
".",
"T",
",",
"m",
"interface",
"{",
"}",
")",
"[",
"]",
"string",
"{",
"if",
"reflect",
".",
"ValueOf",
"(",
"m",
")",
".",
"Kind",
"(",
")",
"!=",
"reflect",
".",
"Map",
"{",
"t",
".",
"Fatal",
"(",
"errors",
".",
"New",
"(",
"\"GetMapKeys should receive a map\"",
")",
")",
"\n",
"}",
"\n",
"if",
"reflect",
".",
"TypeOf",
"(",
"m",
")",
".",
"Key",
"(",
")",
"!=",
"reflect",
".",
"TypeOf",
"(",
"\"bla\"",
")",
"{",
"t",
".",
"Fatal",
"(",
"errors",
".",
"New",
"(",
"\"GetMapKeys should receive a map with string keys\"",
")",
")",
"\n",
"}",
"\n",
"t",
".",
"Helper",
"(",
")",
"\n",
"res",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
")",
"\n",
"for",
"_",
",",
"k",
":=",
"range",
"reflect",
".",
"ValueOf",
"(",
"m",
")",
".",
"MapKeys",
"(",
")",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"k",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"res",
"\n",
"}"
] | // GetMapKeys returns a string slice with the map keys | [
"GetMapKeys",
"returns",
"a",
"string",
"slice",
"with",
"the",
"map",
"keys"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/helpers/helpers.go#L40-L53 | train |
topfreegames/pitaya | helpers/helpers.go | WriteFile | func WriteFile(t *testing.T, filepath string, bytes []byte) {
t.Helper()
if err := ioutil.WriteFile(filepath, bytes, 0644); err != nil {
t.Fatalf("failed writing file: %s", err)
}
} | go | func WriteFile(t *testing.T, filepath string, bytes []byte) {
t.Helper()
if err := ioutil.WriteFile(filepath, bytes, 0644); err != nil {
t.Fatalf("failed writing file: %s", err)
}
} | [
"func",
"WriteFile",
"(",
"t",
"*",
"testing",
".",
"T",
",",
"filepath",
"string",
",",
"bytes",
"[",
"]",
"byte",
")",
"{",
"t",
".",
"Helper",
"(",
")",
"\n",
"if",
"err",
":=",
"ioutil",
".",
"WriteFile",
"(",
"filepath",
",",
"bytes",
",",
"0644",
")",
";",
"err",
"!=",
"nil",
"{",
"t",
".",
"Fatalf",
"(",
"\"failed writing file: %s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}"
] | // WriteFile test helper | [
"WriteFile",
"test",
"helper"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/helpers/helpers.go#L73-L78 | train |
topfreegames/pitaya | helpers/helpers.go | ReadFile | func ReadFile(t *testing.T, filepath string) []byte {
t.Helper()
b, err := ioutil.ReadFile(filepath)
if err != nil {
t.Fatalf("failed reading file: %s", err)
}
return b
} | go | func ReadFile(t *testing.T, filepath string) []byte {
t.Helper()
b, err := ioutil.ReadFile(filepath)
if err != nil {
t.Fatalf("failed reading file: %s", err)
}
return b
} | [
"func",
"ReadFile",
"(",
"t",
"*",
"testing",
".",
"T",
",",
"filepath",
"string",
")",
"[",
"]",
"byte",
"{",
"t",
".",
"Helper",
"(",
")",
"\n",
"b",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"filepath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"t",
".",
"Fatalf",
"(",
"\"failed reading file: %s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"b",
"\n",
"}"
] | // ReadFile test helper | [
"ReadFile",
"test",
"helper"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/helpers/helpers.go#L81-L88 | train |
topfreegames/pitaya | helpers/helpers.go | StartProcess | func StartProcess(t testing.TB, program string, args ...string) *exec.Cmd {
t.Helper()
return exec.Command(program, args...)
} | go | func StartProcess(t testing.TB, program string, args ...string) *exec.Cmd {
t.Helper()
return exec.Command(program, args...)
} | [
"func",
"StartProcess",
"(",
"t",
"testing",
".",
"TB",
",",
"program",
"string",
",",
"args",
"...",
"string",
")",
"*",
"exec",
".",
"Cmd",
"{",
"t",
".",
"Helper",
"(",
")",
"\n",
"return",
"exec",
".",
"Command",
"(",
"program",
",",
"args",
"...",
")",
"\n",
"}"
] | // StartProcess starts a process | [
"StartProcess",
"starts",
"a",
"process"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/helpers/helpers.go#L91-L94 | train |
topfreegames/pitaya | helpers/helpers.go | StartServer | func StartServer(t testing.TB, frontend bool, debug bool, svType string, port int, sdPrefix string, grpc bool) func() {
grpcPort := GetFreePort(t)
promPort := GetFreePort(t)
var useGRPC string
if grpc {
useGRPC = "true"
} else {
useGRPC = "false"
}
t.Helper()
args := []string{
"-type",
svType,
"-port",
strconv.Itoa(port),
fmt.Sprintf("-frontend=%s", strconv.FormatBool(frontend)),
"-sdprefix", sdPrefix,
"-grpcport", fmt.Sprintf("%d", grpcPort),
fmt.Sprintf("-grpc=%s", useGRPC),
}
if debug {
args = append(args, "-debug")
}
cmd := StartProcess(
t,
"../examples/testing/server",
args...,
)
// always use a random port for prometheus, for avoiding e2e conflicts
cmd.Env = []string{fmt.Sprintf("PITAYA_METRICS_PROMETHEUS_PORT=%d", promPort)}
outPipe, err := cmd.StderrPipe()
if err != nil {
t.Fatal(err)
}
err = cmd.Start()
if err != nil {
t.Fatal(err)
}
waitForServerToBeReady(t, bufio.NewReader(outPipe))
return func() {
err := cmd.Process.Kill()
if err != nil {
t.Fatal(err)
}
}
} | go | func StartServer(t testing.TB, frontend bool, debug bool, svType string, port int, sdPrefix string, grpc bool) func() {
grpcPort := GetFreePort(t)
promPort := GetFreePort(t)
var useGRPC string
if grpc {
useGRPC = "true"
} else {
useGRPC = "false"
}
t.Helper()
args := []string{
"-type",
svType,
"-port",
strconv.Itoa(port),
fmt.Sprintf("-frontend=%s", strconv.FormatBool(frontend)),
"-sdprefix", sdPrefix,
"-grpcport", fmt.Sprintf("%d", grpcPort),
fmt.Sprintf("-grpc=%s", useGRPC),
}
if debug {
args = append(args, "-debug")
}
cmd := StartProcess(
t,
"../examples/testing/server",
args...,
)
// always use a random port for prometheus, for avoiding e2e conflicts
cmd.Env = []string{fmt.Sprintf("PITAYA_METRICS_PROMETHEUS_PORT=%d", promPort)}
outPipe, err := cmd.StderrPipe()
if err != nil {
t.Fatal(err)
}
err = cmd.Start()
if err != nil {
t.Fatal(err)
}
waitForServerToBeReady(t, bufio.NewReader(outPipe))
return func() {
err := cmd.Process.Kill()
if err != nil {
t.Fatal(err)
}
}
} | [
"func",
"StartServer",
"(",
"t",
"testing",
".",
"TB",
",",
"frontend",
"bool",
",",
"debug",
"bool",
",",
"svType",
"string",
",",
"port",
"int",
",",
"sdPrefix",
"string",
",",
"grpc",
"bool",
")",
"func",
"(",
")",
"{",
"grpcPort",
":=",
"GetFreePort",
"(",
"t",
")",
"\n",
"promPort",
":=",
"GetFreePort",
"(",
"t",
")",
"\n",
"var",
"useGRPC",
"string",
"\n",
"if",
"grpc",
"{",
"useGRPC",
"=",
"\"true\"",
"\n",
"}",
"else",
"{",
"useGRPC",
"=",
"\"false\"",
"\n",
"}",
"\n",
"t",
".",
"Helper",
"(",
")",
"\n",
"args",
":=",
"[",
"]",
"string",
"{",
"\"-type\"",
",",
"svType",
",",
"\"-port\"",
",",
"strconv",
".",
"Itoa",
"(",
"port",
")",
",",
"fmt",
".",
"Sprintf",
"(",
"\"-frontend=%s\"",
",",
"strconv",
".",
"FormatBool",
"(",
"frontend",
")",
")",
",",
"\"-sdprefix\"",
",",
"sdPrefix",
",",
"\"-grpcport\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"%d\"",
",",
"grpcPort",
")",
",",
"fmt",
".",
"Sprintf",
"(",
"\"-grpc=%s\"",
",",
"useGRPC",
")",
",",
"}",
"\n",
"if",
"debug",
"{",
"args",
"=",
"append",
"(",
"args",
",",
"\"-debug\"",
")",
"\n",
"}",
"\n",
"cmd",
":=",
"StartProcess",
"(",
"t",
",",
"\"../examples/testing/server\"",
",",
"args",
"...",
",",
")",
"\n",
"cmd",
".",
"Env",
"=",
"[",
"]",
"string",
"{",
"fmt",
".",
"Sprintf",
"(",
"\"PITAYA_METRICS_PROMETHEUS_PORT=%d\"",
",",
"promPort",
")",
"}",
"\n",
"outPipe",
",",
"err",
":=",
"cmd",
".",
"StderrPipe",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"t",
".",
"Fatal",
"(",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"cmd",
".",
"Start",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"t",
".",
"Fatal",
"(",
"err",
")",
"\n",
"}",
"\n",
"waitForServerToBeReady",
"(",
"t",
",",
"bufio",
".",
"NewReader",
"(",
"outPipe",
")",
")",
"\n",
"return",
"func",
"(",
")",
"{",
"err",
":=",
"cmd",
".",
"Process",
".",
"Kill",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"t",
".",
"Fatal",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // StartServer starts a server | [
"StartServer",
"starts",
"a",
"server"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/helpers/helpers.go#L108-L157 | train |
topfreegames/pitaya | helpers/helpers.go | FixtureGoldenFileName | func FixtureGoldenFileName(t *testing.T, name string) string {
t.Helper()
return filepath.Join("fixtures", name+".golden")
} | go | func FixtureGoldenFileName(t *testing.T, name string) string {
t.Helper()
return filepath.Join("fixtures", name+".golden")
} | [
"func",
"FixtureGoldenFileName",
"(",
"t",
"*",
"testing",
".",
"T",
",",
"name",
"string",
")",
"string",
"{",
"t",
".",
"Helper",
"(",
")",
"\n",
"return",
"filepath",
".",
"Join",
"(",
"\"fixtures\"",
",",
"name",
"+",
"\".golden\"",
")",
"\n",
"}"
] | // FixtureGoldenFileName returns the golden file name on fixtures path | [
"FixtureGoldenFileName",
"returns",
"the",
"golden",
"file",
"name",
"on",
"fixtures",
"path"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/helpers/helpers.go#L160-L163 | train |
topfreegames/pitaya | helpers/helpers.go | ShouldEventuallyReceive | func ShouldEventuallyReceive(t testing.TB, c interface{}, timeouts ...time.Duration) interface{} {
t.Helper()
if !isChan(c) {
t.Fatal("ShouldEventuallyReceive c argument should be a channel")
}
v := reflect.ValueOf(c)
timeout := time.After(500 * time.Millisecond)
if len(timeouts) > 0 {
timeout = time.After(timeouts[0])
}
recvChan := make(chan reflect.Value)
go func() {
v, ok := v.Recv()
if ok {
recvChan <- v
}
}()
select {
case <-timeout:
t.Fatal(errors.New("timed out waiting for channel to receive"))
case a := <-recvChan:
return a.Interface()
}
return nil
} | go | func ShouldEventuallyReceive(t testing.TB, c interface{}, timeouts ...time.Duration) interface{} {
t.Helper()
if !isChan(c) {
t.Fatal("ShouldEventuallyReceive c argument should be a channel")
}
v := reflect.ValueOf(c)
timeout := time.After(500 * time.Millisecond)
if len(timeouts) > 0 {
timeout = time.After(timeouts[0])
}
recvChan := make(chan reflect.Value)
go func() {
v, ok := v.Recv()
if ok {
recvChan <- v
}
}()
select {
case <-timeout:
t.Fatal(errors.New("timed out waiting for channel to receive"))
case a := <-recvChan:
return a.Interface()
}
return nil
} | [
"func",
"ShouldEventuallyReceive",
"(",
"t",
"testing",
".",
"TB",
",",
"c",
"interface",
"{",
"}",
",",
"timeouts",
"...",
"time",
".",
"Duration",
")",
"interface",
"{",
"}",
"{",
"t",
".",
"Helper",
"(",
")",
"\n",
"if",
"!",
"isChan",
"(",
"c",
")",
"{",
"t",
".",
"Fatal",
"(",
"\"ShouldEventuallyReceive c argument should be a channel\"",
")",
"\n",
"}",
"\n",
"v",
":=",
"reflect",
".",
"ValueOf",
"(",
"c",
")",
"\n",
"timeout",
":=",
"time",
".",
"After",
"(",
"500",
"*",
"time",
".",
"Millisecond",
")",
"\n",
"if",
"len",
"(",
"timeouts",
")",
">",
"0",
"{",
"timeout",
"=",
"time",
".",
"After",
"(",
"timeouts",
"[",
"0",
"]",
")",
"\n",
"}",
"\n",
"recvChan",
":=",
"make",
"(",
"chan",
"reflect",
".",
"Value",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"v",
",",
"ok",
":=",
"v",
".",
"Recv",
"(",
")",
"\n",
"if",
"ok",
"{",
"recvChan",
"<-",
"v",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"select",
"{",
"case",
"<-",
"timeout",
":",
"t",
".",
"Fatal",
"(",
"errors",
".",
"New",
"(",
"\"timed out waiting for channel to receive\"",
")",
")",
"\n",
"case",
"a",
":=",
"<-",
"recvChan",
":",
"return",
"a",
".",
"Interface",
"(",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // ShouldEventuallyReceive should asserts that eventually channel c receives a value | [
"ShouldEventuallyReceive",
"should",
"asserts",
"that",
"eventually",
"channel",
"c",
"receives",
"a",
"value"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/helpers/helpers.go#L196-L226 | train |
topfreegames/pitaya | examples/demo/worker/services/room.go | CallLog | func (*Room) CallLog(ctx context.Context, arg *protos.Arg) (*protos.Response, error) {
route := "metagame.metagame.logremote"
reply := &protos.Response{}
jid, err := pitaya.ReliableRPC(route, nil, reply, arg)
if err != nil {
logger.Log.Infof("failed to enqueue rpc: %q", err)
return nil, err
}
logger.Log.Infof("enqueue rpc job: %d", jid)
return &protos.Response{Code: 200, Msg: "ok"}, nil
} | go | func (*Room) CallLog(ctx context.Context, arg *protos.Arg) (*protos.Response, error) {
route := "metagame.metagame.logremote"
reply := &protos.Response{}
jid, err := pitaya.ReliableRPC(route, nil, reply, arg)
if err != nil {
logger.Log.Infof("failed to enqueue rpc: %q", err)
return nil, err
}
logger.Log.Infof("enqueue rpc job: %d", jid)
return &protos.Response{Code: 200, Msg: "ok"}, nil
} | [
"func",
"(",
"*",
"Room",
")",
"CallLog",
"(",
"ctx",
"context",
".",
"Context",
",",
"arg",
"*",
"protos",
".",
"Arg",
")",
"(",
"*",
"protos",
".",
"Response",
",",
"error",
")",
"{",
"route",
":=",
"\"metagame.metagame.logremote\"",
"\n",
"reply",
":=",
"&",
"protos",
".",
"Response",
"{",
"}",
"\n",
"jid",
",",
"err",
":=",
"pitaya",
".",
"ReliableRPC",
"(",
"route",
",",
"nil",
",",
"reply",
",",
"arg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Log",
".",
"Infof",
"(",
"\"failed to enqueue rpc: %q\"",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"logger",
".",
"Log",
".",
"Infof",
"(",
"\"enqueue rpc job: %d\"",
",",
"jid",
")",
"\n",
"return",
"&",
"protos",
".",
"Response",
"{",
"Code",
":",
"200",
",",
"Msg",
":",
"\"ok\"",
"}",
",",
"nil",
"\n",
"}"
] | // CallLog makes ReliableRPC to metagame LogRemote | [
"CallLog",
"makes",
"ReliableRPC",
"to",
"metagame",
"LogRemote"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/examples/demo/worker/services/room.go#L18-L29 | train |
topfreegames/pitaya | serialize/mocks/serializer.go | NewMockSerializer | func NewMockSerializer(ctrl *gomock.Controller) *MockSerializer {
mock := &MockSerializer{ctrl: ctrl}
mock.recorder = &MockSerializerMockRecorder{mock}
return mock
} | go | func NewMockSerializer(ctrl *gomock.Controller) *MockSerializer {
mock := &MockSerializer{ctrl: ctrl}
mock.recorder = &MockSerializerMockRecorder{mock}
return mock
} | [
"func",
"NewMockSerializer",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockSerializer",
"{",
"mock",
":=",
"&",
"MockSerializer",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockSerializerMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockSerializer creates a new mock instance | [
"NewMockSerializer",
"creates",
"a",
"new",
"mock",
"instance"
] | b92161d7a48c87a7759ac9cabcc23e7d56f9eebd | https://github.com/topfreegames/pitaya/blob/b92161d7a48c87a7759ac9cabcc23e7d56f9eebd/serialize/mocks/serializer.go#L24-L28 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.