_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q28100 | getKeys | train | func getKeys(info map[string]interface{}, keysSet map[string]bool) {
for k, v := range info {
if strings.Contains(k, "*") {
kew := strings.Replace(k, "*", "", 1)
keysSet[kew] = true
}
listofouts, ok := v.([]interface{})
if ok {
for i := range listofouts {
aux, ok := listofouts[i].(map[string]inte... | go | {
"resource": ""
} |
q28101 | newProto | train | func newProto(docslogLevel logrus.Level, requestTimeout ...time.Duration) *ProtoClient {
return &ProtoClient{
Client: *New(docslogLevel, requestTimeout...),
descriptorsNames: make(map[string]bool),
info: ProtoBufferInfo{
Commands: make(map[string]*Command),
},
docsRoute: "",
descriptors... | go | {
"resource": ""
} |
q28102 | NewProto | train | func NewProto(docsRoute string, docslogLevel logrus.Level, requestTimeout ...time.Duration) *ProtoClient {
newclient := newProto(docslogLevel, requestTimeout...)
newclient.docsRoute = docsRoute
return newclient
} | go | {
"resource": ""
} |
q28103 | NewWithDescriptor | train | func NewWithDescriptor(descriptorsRoute string, docsRoute string, docslogLevel logrus.Level, requestTimeout ...time.Duration) *ProtoClient {
newclient := newProto(docslogLevel, requestTimeout...)
newclient.docsRoute = docsRoute
newclient.descriptorsRoute = descriptorsRoute
return newclient
} | go | {
"resource": ""
} |
q28104 | LoadServerInfo | train | func (pc *ProtoClient) LoadServerInfo(addr string) error {
pc.ready = false
if err := pc.Client.ConnectToTLS(addr, true); err != nil {
if err.Error() == "EOF" {
if err := pc.Client.ConnectTo(addr); err != nil {
return err
}
} else {
return err
}
}
// request doc info
_, err := pc.SendRequest(p... | go | {
"resource": ""
} |
q28105 | Disconnect | train | func (pc *ProtoClient) Disconnect() {
pc.Client.Disconnect()
if pc.ready {
pc.closeChan <- true
}
} | go | {
"resource": ""
} |
q28106 | waitForData | train | func (pc *ProtoClient) waitForData() {
for {
select {
case response := <-pc.Client.IncomingMsgChan:
inputMsg := dynamic.NewMessage(pc.expectedInputDescriptor)
msg, ok := pc.info.Commands[response.Route]
if ok {
inputMsg = dynamic.NewMessage(msg.outputMsgDescriptor)
} else {
pc.expectedInputDe... | go | {
"resource": ""
} |
q28107 | LoadInfo | train | func (pc *ProtoClient) LoadInfo(info *ProtoBufferInfo) error {
if info == nil {
return errors.New("protobuffer information invalid")
}
pc.info = *info
pc.ready = true
return nil
} | go | {
"resource": ""
} |
q28108 | AddPushResponse | train | func (pc *ProtoClient) AddPushResponse(route string, protoName string) {
if route != "" && protoName != "" {
var command Command
command.input = ""
command.output = protoName
pc.info.Commands[route] = &command
}
} | go | {
"resource": ""
} |
q28109 | NewMockAddr | train | func NewMockAddr(ctrl *gomock.Controller) *MockAddr {
mock := &MockAddr{ctrl: ctrl}
mock.recorder = &MockAddrMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q28110 | NewMockConn | train | func NewMockConn(ctrl *gomock.Controller) *MockConn {
mock := &MockConn{ctrl: ctrl}
mock.recorder = &MockConnMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q28111 | Read | train | func (mr *MockConnMockRecorder) Read(b interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockConn)(nil).Read), b)
} | go | {
"resource": ""
} |
q28112 | LocalAddr | train | func (m *MockConn) LocalAddr() net.Addr {
ret := m.ctrl.Call(m, "LocalAddr")
ret0, _ := ret[0].(net.Addr)
return ret0
} | go | {
"resource": ""
} |
q28113 | SetReadDeadline | train | func (mr *MockConnMockRecorder) SetReadDeadline(t interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetReadDeadline", reflect.TypeOf((*MockConn)(nil).SetReadDeadline), t)
} | go | {
"resource": ""
} |
q28114 | SetWriteDeadline | train | func (m *MockConn) SetWriteDeadline(t time.Time) error {
ret := m.ctrl.Call(m, "SetWriteDeadline", t)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q28115 | NewMockPitayaClient | train | func NewMockPitayaClient(ctrl *gomock.Controller) *MockPitayaClient {
mock := &MockPitayaClient{ctrl: ctrl}
mock.recorder = &MockPitayaClientMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q28116 | PushToUser | train | func (mr *MockPitayaClientMockRecorder) PushToUser(ctx, in interface{}, opts ...interface{}) *gomock.Call {
varargs := append([]interface{}{ctx, in}, opts...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PushToUser", reflect.TypeOf((*MockPitayaClient)(nil).PushToUser), varargs...)
} | go | {
"resource": ""
} |
q28117 | NewMockPitayaServer | train | func NewMockPitayaServer(ctrl *gomock.Controller) *MockPitayaServer {
mock := &MockPitayaServer{ctrl: ctrl}
mock.recorder = &MockPitayaServerMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q28118 | PushToUser | train | func (m *MockPitayaServer) PushToUser(arg0 context.Context, arg1 *protos.Push) (*protos.Response, error) {
ret := m.ctrl.Call(m, "PushToUser", arg0, arg1)
ret0, _ := ret[0].(*protos.Response)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q28119 | NewUniqueSession | train | func NewUniqueSession(server *cluster.Server, rpcServer cluster.RPCServer, rpcClient cluster.RPCClient) *UniqueSession {
return &UniqueSession{
server: server,
rpcClient: rpcClient,
}
} | go | {
"resource": ""
} |
q28120 | OnUserBind | train | func (u *UniqueSession) OnUserBind(uid, fid string) {
if u.server.ID == fid {
return
}
oldSession := session.GetSessionByUID(uid)
if oldSession != nil {
// TODO: it would be nice to set this correctly
oldSession.Kick(context.Background())
}
} | go | {
"resource": ""
} |
q28121 | Init | train | func (u *UniqueSession) Init() error {
session.OnSessionBind(func(ctx context.Context, s *session.Session) error {
oldSession := session.GetSessionByUID(s.UID())
if oldSession != nil {
return oldSession.Kick(ctx)
}
err := u.rpcClient.BroadcastSessionBind(s.UID())
return err
})
return nil
} | go | {
"resource": ""
} |
q28122 | NewBinary | train | func NewBinary(binPath string, args []string, gracefulShutdownInterval ...time.Duration) *Binary {
gracefulTime := 15 * time.Second
if len(gracefulShutdownInterval) > 0 {
gracefulTime = gracefulShutdownInterval[0]
}
return &Binary{
binPath: binPath,
args: args,
gracefulS... | go | {
"resource": ""
} |
q28123 | Init | train | func (b *Binary) Init() error {
b.cmd = exec.Command(b.binPath, b.args...)
stdout, _ := b.cmd.StdoutPipe()
stdOutScanner := bufio.NewScanner(stdout)
stderr, _ := b.cmd.StderrPipe()
stdErrScanner := bufio.NewScanner(stderr)
go func() {
for stdOutScanner.Scan() {
logger.Log.Info(stdOutScanner.Text())
}
}()
... | go | {
"resource": ""
} |
q28124 | Shutdown | train | func (b *Binary) Shutdown() error {
err := b.cmd.Process.Signal(syscall.SIGTERM)
if err != nil {
return err
}
timeout := time.After(b.gracefulShutdownInterval)
select {
case <-b.exitCh:
return nil
case <-timeout:
b.cmd.Process.Kill()
return constants.ErrTimeoutTerminatingBinaryModule
}
} | go | {
"resource": ""
} |
q28125 | GetPrometheusReporter | train | func GetPrometheusReporter(
serverType string,
config *config.Config,
constLabels map[string]string,
) (*PrometheusReporter, error) {
var (
port = config.GetInt("pitaya.metrics.prometheus.port")
game = config.GetString("pitaya.game")
additionalLabels = config.GetStringMapString("pitaya... | go | {
"resource": ""
} |
q28126 | ReportSummary | train | func (p *PrometheusReporter) ReportSummary(metric string, labels map[string]string, value float64) error {
sum := p.summaryReportersMap[metric]
if sum != nil {
labels = p.ensureLabels(labels)
sum.With(labels).Observe(value)
return nil
}
return constants.ErrMetricNotKnown
} | go | {
"resource": ""
} |
q28127 | ReportCount | train | func (p *PrometheusReporter) ReportCount(metric string, labels map[string]string, count float64) error {
cnt := p.countReportersMap[metric]
if cnt != nil {
labels = p.ensureLabels(labels)
cnt.With(labels).Add(count)
return nil
}
return constants.ErrMetricNotKnown
} | go | {
"resource": ""
} |
q28128 | ReportGauge | train | func (p *PrometheusReporter) ReportGauge(metric string, labels map[string]string, value float64) error {
g := p.gaugeReportersMap[metric]
if g != nil {
labels = p.ensureLabels(labels)
g.With(labels).Set(value)
return nil
}
return constants.ErrMetricNotKnown
} | go | {
"resource": ""
} |
q28129 | ensureLabels | train | func (p *PrometheusReporter) ensureLabels(labels map[string]string) map[string]string {
for key, defaultVal := range p.additionalLabels {
if _, ok := labels[key]; !ok {
labels[key] = defaultVal
}
}
return labels
} | go | {
"resource": ""
} |
q28130 | Configure | train | func (w *Worker) Configure() error {
err := pitaya.StartWorker(pitaya.GetConfig())
if err != nil {
return err
}
pitaya.RegisterRPCJob(&RPCJob{})
return nil
} | go | {
"resource": ""
} |
q28131 | ServerDiscovery | train | func (r *RPCJob) ServerDiscovery(
route string,
rpcMetadata map[string]interface{},
) (serverID string, err error) {
return "", nil
} | go | {
"resource": ""
} |
q28132 | RPC | train | func (r *RPCJob) RPC(
ctx context.Context,
serverID, routeStr string,
reply, arg proto.Message,
) error {
return pitaya.RPCTo(ctx, serverID, routeStr, reply, arg)
} | go | {
"resource": ""
} |
q28133 | GetArgReply | train | func (r *RPCJob) GetArgReply(
route string,
) (arg, reply proto.Message, err error) {
return &protos.Arg{}, &protos.Response{}, nil
} | go | {
"resource": ""
} |
q28134 | NewMockModule | train | func NewMockModule(ctrl *gomock.Controller) *MockModule {
mock := &MockModule{ctrl: ctrl}
mock.recorder = &MockModuleMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q28135 | AfterInit | train | func (mr *MockModuleMockRecorder) AfterInit() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AfterInit", reflect.TypeOf((*MockModule)(nil).AfterInit))
} | go | {
"resource": ""
} |
q28136 | NewMockBindingStorage | train | func NewMockBindingStorage(ctrl *gomock.Controller) *MockBindingStorage {
mock := &MockBindingStorage{ctrl: ctrl}
mock.recorder = &MockBindingStorageMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q28137 | GetUserFrontendID | train | func (m *MockBindingStorage) GetUserFrontendID(uid, frontendType string) (string, error) {
ret := m.ctrl.Call(m, "GetUserFrontendID", uid, frontendType)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q28138 | GetUserFrontendID | train | func (mr *MockBindingStorageMockRecorder) GetUserFrontendID(uid, frontendType interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserFrontendID", reflect.TypeOf((*MockBindingStorage)(nil).GetUserFrontendID), uid, frontendType)
} | go | {
"resource": ""
} |
q28139 | PutBinding | train | func (m *MockBindingStorage) PutBinding(uid string) error {
ret := m.ctrl.Call(m, "PutBinding", uid)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q28140 | ProtoDescriptors | train | func ProtoDescriptors(protoName string) ([]byte, error) {
if strings.HasSuffix(protoName, ".proto") {
descriptor := proto.FileDescriptor(protoName)
if descriptor == nil {
return nil, constants.ErrProtodescriptor
}
return descriptor, nil
}
if strings.HasPrefix(protoName, "types.") {
protoName = strings.... | go | {
"resource": ""
} |
q28141 | NewMockPacketDecoder | train | func NewMockPacketDecoder(ctrl *gomock.Controller) *MockPacketDecoder {
mock := &MockPacketDecoder{ctrl: ctrl}
mock.recorder = &MockPacketDecoderMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q28142 | Decode | train | func (m *MockPacketDecoder) Decode(data []byte) ([]*packet.Packet, error) {
ret := m.ctrl.Call(m, "Decode", data)
ret0, _ := ret[0].([]*packet.Packet)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q28143 | Decode | train | func (mr *MockPacketDecoderMockRecorder) Decode(data interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Decode", reflect.TypeOf((*MockPacketDecoder)(nil).Decode), data)
} | go | {
"resource": ""
} |
q28144 | NewMockRPCServer | train | func NewMockRPCServer(ctrl *gomock.Controller) *MockRPCServer {
mock := &MockRPCServer{ctrl: ctrl}
mock.recorder = &MockRPCServerMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q28145 | SetPitayaServer | train | func (m *MockRPCServer) SetPitayaServer(arg0 protos.PitayaServer) {
m.ctrl.Call(m, "SetPitayaServer", arg0)
} | go | {
"resource": ""
} |
q28146 | SetPitayaServer | train | func (mr *MockRPCServerMockRecorder) SetPitayaServer(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPitayaServer", reflect.TypeOf((*MockRPCServer)(nil).SetPitayaServer), arg0)
} | go | {
"resource": ""
} |
q28147 | NewMockRPCClient | train | func NewMockRPCClient(ctrl *gomock.Controller) *MockRPCClient {
mock := &MockRPCClient{ctrl: ctrl}
mock.recorder = &MockRPCClientMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q28148 | Send | train | func (mr *MockRPCClientMockRecorder) Send(route, data interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockRPCClient)(nil).Send), route, data)
} | go | {
"resource": ""
} |
q28149 | SendPush | train | func (m *MockRPCClient) SendPush(userID string, frontendSv *cluster.Server, push *protos.Push) error {
ret := m.ctrl.Call(m, "SendPush", userID, frontendSv, push)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q28150 | SendPush | train | func (mr *MockRPCClientMockRecorder) SendPush(userID, frontendSv, push interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendPush", reflect.TypeOf((*MockRPCClient)(nil).SendPush), userID, frontendSv, push)
} | go | {
"resource": ""
} |
q28151 | SendKick | train | func (m *MockRPCClient) SendKick(userID, serverType string, kick *protos.KickMsg) error {
ret := m.ctrl.Call(m, "SendKick", userID, serverType, kick)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q28152 | SendKick | train | func (mr *MockRPCClientMockRecorder) SendKick(userID, serverType, kick interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendKick", reflect.TypeOf((*MockRPCClient)(nil).SendKick), userID, serverType, kick)
} | go | {
"resource": ""
} |
q28153 | BroadcastSessionBind | train | func (m *MockRPCClient) BroadcastSessionBind(uid string) error {
ret := m.ctrl.Call(m, "BroadcastSessionBind", uid)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q28154 | BroadcastSessionBind | train | func (mr *MockRPCClientMockRecorder) BroadcastSessionBind(uid interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BroadcastSessionBind", reflect.TypeOf((*MockRPCClient)(nil).BroadcastSessionBind), uid)
} | go | {
"resource": ""
} |
q28155 | Call | train | 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, _ := re... | go | {
"resource": ""
} |
q28156 | NewMockSDListener | train | func NewMockSDListener(ctrl *gomock.Controller) *MockSDListener {
mock := &MockSDListener{ctrl: ctrl}
mock.recorder = &MockSDListenerMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q28157 | AddServer | train | func (m *MockSDListener) AddServer(arg0 *cluster.Server) {
m.ctrl.Call(m, "AddServer", arg0)
} | go | {
"resource": ""
} |
q28158 | RemoveServer | train | func (m *MockSDListener) RemoveServer(arg0 *cluster.Server) {
m.ctrl.Call(m, "RemoveServer", arg0)
} | go | {
"resource": ""
} |
q28159 | RemoveServer | train | func (mr *MockSDListenerMockRecorder) RemoveServer(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveServer", reflect.TypeOf((*MockSDListener)(nil).RemoveServer), arg0)
} | go | {
"resource": ""
} |
q28160 | NewMockRemoteBindingListener | train | func NewMockRemoteBindingListener(ctrl *gomock.Controller) *MockRemoteBindingListener {
mock := &MockRemoteBindingListener{ctrl: ctrl}
mock.recorder = &MockRemoteBindingListenerMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q28161 | OnUserBind | train | func (m *MockRemoteBindingListener) OnUserBind(uid, fid string) {
m.ctrl.Call(m, "OnUserBind", uid, fid)
} | go | {
"resource": ""
} |
q28162 | OnUserBind | train | 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 | {
"resource": ""
} |
q28163 | LogRemote | train | 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 | {
"resource": ""
} |
q28164 | GetFromPropagateCtx | train | func GetFromPropagateCtx(ctx context.Context, key string) interface{} {
propagate := ToMap(ctx)
if val, ok := propagate[key]; ok {
return val
}
return nil
} | go | {
"resource": ""
} |
q28165 | FromMap | train | func FromMap(val map[string]interface{}) context.Context {
return context.WithValue(context.Background(), constants.PropagateCtxKey, val)
} | go | {
"resource": ""
} |
q28166 | Encode | train | func Encode(ctx context.Context) ([]byte, error) {
m := ToMap(ctx)
if len(m) > 0 {
return json.Marshal(m)
}
return nil, nil
} | go | {
"resource": ""
} |
q28167 | Decode | train | 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 | {
"resource": ""
} |
q28168 | renewLease | train | 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... | go | {
"resource": ""
} |
q28169 | AddListener | train | func (sd *etcdServiceDiscovery) AddListener(listener SDListener) {
sd.listeners = append(sd.listeners, listener)
} | go | {
"resource": ""
} |
q28170 | GetServersByType | train | 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 prevent... | go | {
"resource": ""
} |
q28171 | GetServers | train | 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 | {
"resource": ""
} |
q28172 | GetServer | train | 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 | {
"resource": ""
} |
q28173 | Init | train | 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 ... | go | {
"resource": ""
} |
q28174 | SyncServers | train | 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... | go | {
"resource": ""
} |
q28175 | revoke | train | 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 := ... | go | {
"resource": ""
} |
q28176 | NewMockRPCJob | train | func NewMockRPCJob(ctrl *gomock.Controller) *MockRPCJob {
mock := &MockRPCJob{ctrl: ctrl}
mock.recorder = &MockRPCJobMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q28177 | GetArgReply | train | 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 | {
"resource": ""
} |
q28178 | GetArgReply | train | func (mr *MockRPCJobMockRecorder) GetArgReply(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetArgReply", reflect.TypeOf((*MockRPCJob)(nil).GetArgReply), arg0)
} | go | {
"resource": ""
} |
q28179 | RPC | train | 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 | {
"resource": ""
} |
q28180 | RPC | train | 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 | {
"resource": ""
} |
q28181 | ServerDiscovery | train | 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 | {
"resource": ""
} |
q28182 | Validate | train | 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 | {
"resource": ""
} |
q28183 | Configure | train | 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.G... | go | {
"resource": ""
} |
q28184 | AddAcceptor | train | 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 | {
"resource": ""
} |
q28185 | GetServerByID | train | func GetServerByID(id string) (*cluster.Server, error) {
return app.serviceDiscovery.GetServer(id)
} | go | {
"resource": ""
} |
q28186 | GetServersByType | train | func GetServersByType(t string) (map[string]*cluster.Server, error) {
return app.serviceDiscovery.GetServersByType(t)
} | go | {
"resource": ""
} |
q28187 | AddMetricsReporter | train | func AddMetricsReporter(mr metrics.Reporter) {
app.metricsReporters = append(app.metricsReporters, mr)
} | go | {
"resource": ""
} |
q28188 | SetDictionary | train | func SetDictionary(dict map[string]uint16) error {
if app.running {
return constants.ErrChangeDictionaryWhileRunning
}
return message.SetDictionary(dict)
} | go | {
"resource": ""
} |
q28189 | Error | train | func Error(err error, code string, metadata ...map[string]string) *errors.Error {
return errors.NewError(err, code, metadata...)
} | go | {
"resource": ""
} |
q28190 | GetSessionFromCtx | train | 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 | {
"resource": ""
} |
q28191 | GetDefaultLoggerFromCtx | train | func GetDefaultLoggerFromCtx(ctx context.Context) logger.Logger {
return ctx.Value(constants.LoggerCtxKey).(logger.Logger)
} | go | {
"resource": ""
} |
q28192 | AddMetricTagsToPropagateCtx | train | func AddMetricTagsToPropagateCtx(
ctx context.Context,
tags map[string]string,
) context.Context {
return pcontext.AddToPropagateCtx(ctx, constants.MetricTagsKey, tags)
} | go | {
"resource": ""
} |
q28193 | GetFromPropagateCtx | train | func GetFromPropagateCtx(ctx context.Context, key string) interface{} {
return pcontext.GetFromPropagateCtx(ctx, key)
} | go | {
"resource": ""
} |
q28194 | ExtractSpan | train | func ExtractSpan(ctx context.Context) (opentracing.SpanContext, error) {
return tracing.ExtractSpan(ctx)
} | go | {
"resource": ""
} |
q28195 | Documentation | train | 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,
"remot... | go | {
"resource": ""
} |
q28196 | AddGRPCInfoToMetadata | train | 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.GRPCExternalP... | go | {
"resource": ""
} |
q28197 | StartWorker | train | 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 | {
"resource": ""
} |
q28198 | RegisterRPCJob | train | func RegisterRPCJob(rpcJob worker.RPCJob) error {
err := app.worker.RegisterRPCJob(rpcJob)
return err
} | go | {
"resource": ""
} |
q28199 | NewService | train | 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... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.