id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c28100 |
listofouts, ok := v.([]interface{})
if ok {
for i := range listofouts {
aux, ok := listofouts[i].(map[string]interface{})
if !ok {
continue
}
getKeys(aux, keysSet)
}
}
if aux, ok := v.(map[string]interface{}); ok {
getKeys(aux, keysSet)
}
}
} | |
c28101 | "",
descriptorsRoute: "",
IncomingMsgChan: make(chan *message.Message, 10),
closeChan: make(chan bool),
}
} | |
c28102 | := newProto(docslogLevel, requestTimeout...)
newclient.docsRoute = docsRoute
return newclient
} | |
c28103 | *ProtoClient {
newclient := newProto(docslogLevel, requestTimeout...)
newclient.docsRoute = docsRoute
newclient.descriptorsRoute = descriptorsRoute
return newclient
} | |
c28104 |
docs := &protos.Doc{}
if err := proto.Unmarshal(response.Data, docs); err != nil {
return err
}
if err := pc.getDescriptors(docs.Doc); err != nil {
return err
}
pc.Disconnect()
pc.ready = true
return nil
} | |
c28105 | pc.ready {
pc.closeChan <- true
}
} | |
c28106 | == nil {
logger.Log.Errorf("Not expected data: %s", string(response.Data))
continue
}
err := inputMsg.Unmarshal(response.Data)
if err != nil {
logger.Log.Errorf("Erro decode data: %s", string(response.Data))
continue
}
data, err2 := inputMsg.MarshalJSON()
if err2 != nil {
logger... | |
c28107 | nil {
return errors.New("protobuffer information invalid")
}
pc.info = *info
pc.ready = true
return nil
} | |
c28108 | != "" {
var command Command
command.input = ""
command.output = protoName
pc.info.Commands[route] = &command
}
} | |
c28109 | mock.recorder = &MockAddrMockRecorder{mock}
return mock
} | |
c28110 | mock.recorder = &MockConnMockRecorder{mock}
return mock
} | |
c28111 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockConn)(nil).Read), b)
} | |
c28112 | _ := ret[0].(net.Addr)
return ret0
} | |
c28113 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetReadDeadline", reflect.TypeOf((*MockConn)(nil).SetReadDeadline), t)
} | |
c28114 | t)
ret0, _ := ret[0].(error)
return ret0
} | |
c28115 |
mock.recorder = &MockPitayaClientMockRecorder{mock}
return mock
} | |
c28116 | return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PushToUser", reflect.TypeOf((*MockPitayaClient)(nil).PushToUser), varargs...)
} | |
c28117 |
mock.recorder = &MockPitayaServerMockRecorder{mock}
return mock
} | |
c28118 |
ret0, _ := ret[0].(*protos.Response)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c28119 | return &UniqueSession{
server: server,
rpcClient: rpcClient,
}
} | |
c28120 | // TODO: it would be nice to set this correctly
oldSession.Kick(context.Background())
}
} | |
c28121 |
return oldSession.Kick(ctx)
}
err := u.rpcClient.BroadcastSessionBind(s.UID())
return err
})
return nil
} | |
c28122 | args: args,
gracefulShutdownInterval: gracefulTime,
exitCh: make(chan struct{}),
}
} | |
c28123 |
}()
go func() {
for stdErrScanner.Scan() {
logger.Log.Error(stdErrScanner.Text())
}
}()
err := b.cmd.Start()
go func() {
b.cmd.Wait()
close(b.exitCh)
}()
return err
} | |
c28124 | return nil
case <-timeout:
b.cmd.Process.Kill()
return constants.ErrTimeoutTerminatingBinaryModule
}
} | |
c28125 | return nil, err
}
once.Do(func() {
prometheusReporter = &PrometheusReporter{
serverType: serverType,
game: game,
countReportersMap: make(map[string]*prometheus.CounterVec),
summaryReportersMap: make(map[string]*prometheus.SummaryVec),
gaugeReportersMap: make(map[string]*... | |
c28126 | labels = p.ensureLabels(labels)
sum.With(labels).Observe(value)
return nil
}
return constants.ErrMetricNotKnown
} | |
c28127 | labels = p.ensureLabels(labels)
cnt.With(labels).Add(count)
return nil
}
return constants.ErrMetricNotKnown
} | |
c28128 | labels = p.ensureLabels(labels)
g.With(labels).Set(value)
return nil
}
return constants.ErrMetricNotKnown
} | |
c28129 | _, ok := labels[key]; !ok {
labels[key] = defaultVal
}
}
return labels
} | |
c28130 | err
}
pitaya.RegisterRPCJob(&RPCJob{})
return nil
} | |
c28131 | (serverID string, err error) {
return "", nil
} | |
c28132 | pitaya.RPCTo(ctx, serverID, routeStr, reply, arg)
} | |
c28133 |
return &protos.Arg{}, &protos.Response{}, nil
} | |
c28134 | mock.recorder = &MockModuleMockRecorder{mock}
return mock
} | |
c28135 | "AfterInit", reflect.TypeOf((*MockModule)(nil).AfterInit))
} | |
c28136 | ctrl}
mock.recorder = &MockBindingStorageMockRecorder{mock}
return mock
} | |
c28137 | ret := m.ctrl.Call(m, "GetUserFrontendID", uid, frontendType)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c28138 | reflect.TypeOf((*MockBindingStorage)(nil).GetUserFrontendID), uid, frontendType)
} | |
c28139 | m.ctrl.Call(m, "PutBinding", uid)
ret0, _ := ret[0].(error)
return ret0
} | |
c28140 |
}
protoReflectType := protoReflectTypePointer.Elem()
protoValue := reflect.New(protoReflectType)
descriptorMethod, ok := protoReflectTypePointer.MethodByName("Descriptor")
if !ok {
return nil, constants.ErrProtodescriptor
}
descriptorValue := descriptorMethod.Func.Call([]reflect.Value{protoValue})
protoDes... | |
c28141 |
mock.recorder = &MockPacketDecoderMockRecorder{mock}
return mock
} | |
c28142 | := m.ctrl.Call(m, "Decode", data)
ret0, _ := ret[0].([]*packet.Packet)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c28143 | "Decode", reflect.TypeOf((*MockPacketDecoder)(nil).Decode), data)
} | |
c28144 | mock.recorder = &MockRPCServerMockRecorder{mock}
return mock
} | |
c28145 | protos.PitayaServer) {
m.ctrl.Call(m, "SetPitayaServer", arg0)
} | |
c28146 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPitayaServer", reflect.TypeOf((*MockRPCServer)(nil).SetPitayaServer), arg0)
} | |
c28147 | mock.recorder = &MockRPCClientMockRecorder{mock}
return mock
} | |
c28148 |
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockRPCClient)(nil).Send), route, data)
} | |
c28149 | error {
ret := m.ctrl.Call(m, "SendPush", userID, frontendSv, push)
ret0, _ := ret[0].(error)
return ret0
} | |
c28150 | "SendPush", reflect.TypeOf((*MockRPCClient)(nil).SendPush), userID, frontendSv, push)
} | |
c28151 | error {
ret := m.ctrl.Call(m, "SendKick", userID, serverType, kick)
ret0, _ := ret[0].(error)
return ret0
} | |
c28152 | "SendKick", reflect.TypeOf((*MockRPCClient)(nil).SendKick), userID, serverType, kick)
} | |
c28153 | "BroadcastSessionBind", uid)
ret0, _ := ret[0].(error)
return ret0
} | |
c28154 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BroadcastSessionBind", reflect.TypeOf((*MockRPCClient)(nil).BroadcastSessionBind), uid)
} | |
c28155 | "Call", ctx, rpcType, route, session, msg, server)
ret0, _ := ret[0].(*protos.Response)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c28156 | mock.recorder = &MockSDListenerMockRecorder{mock}
return mock
} | |
c28157 | *cluster.Server) {
m.ctrl.Call(m, "AddServer", arg0)
} | |
c28158 | *cluster.Server) {
m.ctrl.Call(m, "RemoveServer", arg0)
} | |
c28159 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveServer", reflect.TypeOf((*MockSDListener)(nil).RemoveServer), arg0)
} | |
c28160 | {
mock := &MockRemoteBindingListener{ctrl: ctrl}
mock.recorder = &MockRemoteBindingListenerMockRecorder{mock}
return mock
} | |
c28161 | m.ctrl.Call(m, "OnUserBind", uid, fid)
} | |
c28162 | reflect.TypeOf((*MockRemoteBindingListener)(nil).OnUserBind), uid, fid)
} | |
c28163 | %+v\n", arg)
return &protos.Response{Code: 200, Msg: "ok"}, nil
} | |
c28164 | := propagate[key]; ok {
return val
}
return nil
} | |
c28165 | {
return context.WithValue(context.Background(), constants.PropagateCtxKey, val)
} | |
c28166 | return json.Marshal(m)
}
return nil, nil
} | |
c28167 |
err := json.Unmarshal(m, &mp)
if err != nil {
return nil, err
}
return FromMap(mp), nil
} | |
c28168 | 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
}
} | |
c28169 | = append(sd.listeners, listener)
} | |
c28170 | 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, constant... | |
c28171 | ret = append(ret, v.(*Server))
return true
})
return ret
} | |
c28172 | ok := sd.serverMapByID.Load(id); ok {
return sv.(*Server), nil
}
return nil, constants.ErrNoServerWithID
} | |
c28173 |
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
} | |
c28174 | 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())
conti... | |
c28175 |
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
}
} | |
c28176 | mock.recorder = &MockRPCJobMockRecorder{mock}
return mock
} | |
c28177 | _ := ret[1].(proto.Message)
ret2, _ := ret[2].(error)
return ret0, ret1, ret2
} | |
c28178 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetArgReply", reflect.TypeOf((*MockRPCJob)(nil).GetArgReply), arg0)
} | |
c28179 | error {
ret := m.ctrl.Call(m, "RPC", arg0, arg1, arg2, arg3, arg4)
ret0, _ := ret[0].(error)
return ret0
} | |
c28180 | "RPC", reflect.TypeOf((*MockRPCJob)(nil).RPC), arg0, arg1, arg2, arg3, arg4)
} | |
c28181 | ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c28182 | if err := v.validate.Struct(in); err != nil {
return nil, err
}
return in, nil
} | |
c28183 | = serverMode
app.server.Metadata = serverMetadata
app.messageEncoder = message.NewMessagesEncoder(app.config.GetBool("pitaya.handler.messages.compression"))
configureMetrics(serverType)
configureDefaultPipelines(app.config)
app.configured = true
} | |
c28184 | to add an acceptor to a backend server, skipping")
return
}
app.acceptors = append(app.acceptors, ac)
} | |
c28185 | app.serviceDiscovery.GetServer(id)
} | |
c28186 | app.serviceDiscovery.GetServersByType(t)
} | |
c28187 | append(app.metricsReporters, mr)
} | |
c28188 | constants.ErrChangeDictionaryWhileRunning
}
return message.SetDictionary(dict)
} | |
c28189 | errors.NewError(err, code, metadata...)
} | |
c28190 | session, are you calling GetSessionFromCtx from inside a remote?")
return nil
}
return sessionVal.(*session.Session)
} | |
c28191 | {
return ctx.Value(constants.LoggerCtxKey).(logger.Logger)
} | |
c28192 | return pcontext.AddToPropagateCtx(ctx, constants.MetricTagsKey, tags)
} | |
c28193 | return pcontext.GetFromPropagateCtx(ctx, key)
} | |
c28194 | error) {
return tracing.ExtractSpan(ctx)
} | |
c28195 | {
return nil, err
}
return map[string]interface{}{
"handlers": handlerDocs,
"remotes": remoteDocs,
}, nil
} | |
c28196 | externalHost
metadata[constants.GRPCExternalPortKey] = externalPort
metadata[constants.RegionKey] = region
return metadata
} | |
c28197 | err = worker.NewWorker(config)
if err != nil {
return err
}
app.worker.Start()
return nil
} | |
c28198 | app.worker.RegisterRPCJob(rpcJob)
return err
} | |
c28199 | opt(&s.Options)
}
if name := s.Options.name; name != "" {
s.Name = name
} else {
s.Name = reflect.Indirect(s.Receiver).Type().Name()
}
return s
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.