id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c28200 | exitOnError = true
case message.Notify:
err = constants.ErrNotifyOnRequest
}
}
return
} | |
c28201 |
pitaya.InitGroups(gsi)
pitaya.GroupCreate(context.Background(), "room")
} | |
c28202 | log.String("event", "error"),
log.String("message", message),
)
} | |
c28203 | ns.server.ID,
}
msgData, err := proto.Marshal(msg)
if err != nil {
return err
}
return ns.Send(GetBindBroadcastTopic(ns.server.Type), msgData)
} | |
c28204 | return constants.ErrRPCClientNotInitialized
}
return ns.conn.Publish(topic, data)
} | |
c28205 | := GetUserMessagesTopic(userID, frontendSv.Type)
msg, err := proto.Marshal(push)
if err != nil {
return err
}
return ns.Send(topic, msg)
} | |
c28206 | proto.Marshal(kick)
if err != nil {
return err
}
return ns.Send(topic, msg)
} | |
c28207 |
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, e... | |
c28208 | ns.appDieChan, nats.MaxReconnects(ns.maxReconnectionRetries))
if err != nil {
return err
}
ns.conn = conn
return nil
} | |
c28209 | 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()... | |
c28210 | 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,
)
} | |
c28211 | 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)
} | |
c28212 | := err.(*Error)
if !ok {
return ErrUnknownCode
}
if pitayaErr == nil {
return ""
}
return pitayaErr.Code
} | |
c28213 | NewCountTimer(interval, timer.LoopForever, fn)
} | |
c28214 |
t := timer.NewTimer(fn, interval, count)
// add to manager
timer.Manager.ChCreatedTimer <- t
return t
} | |
c28215 | return NewCountTimer(duration, 1, fn)
} | |
c28216 | t := NewCountTimer(time.Duration(math.MaxInt64), timer.LoopForever, fn)
t.SetCondition(condition)
return t, nil
} | |
c28217 | {
panic("time precision can not less than a Millisecond")
}
timer.Precision = precision
} | |
c28218 | s.SetData(data.Data)
if err != nil {
fmt.Println("got error on notify", err)
}
} | |
c28219 |
if err != nil {
return nil, err
}
return &protos.Doc{Doc: string(doc)}, nil
} | |
c28220 |
}
return &TCPAcceptor{
addr: addr,
connChan: make(chan net.Conn),
running: false,
certFile: certFile,
keyFile: keyFile,
}
} | |
c28221 | }
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()
} | |
c28222 | := &tls.Config{Certificates: []tls.Certificate{crt}}
listener, err := tls.Listen("tcp", a.addr, tlsCfg)
a.listener = listener
a.running = true
a.serve()
} | |
c28223 |
}
w := &WSAcceptor{
addr: addr,
connChan: make(chan net.Conn),
certFile: certFile,
keyFile: keyFile,
}
return w
} | |
c28224 |
},
}
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)
} | |
c28225 |
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)
} | |
c28226 |
if err != nil {
logger.Log.Errorf("Failed to stop: %s", err.Error())
}
} | |
c28227 | 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 proba... | |
c28228 | 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... | |
c28229 | {
c.Connected = false
close(c.closeChan)
c.conn.Close()
}
} | |
c28230 |
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, er... | |
c28231 | ctrl}
mock.recorder = &MockServiceDiscoveryMockRecorder{mock}
return mock
} | |
c28232 | _ := ret[0].(map[string]*cluster.Server)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c28233 | return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServersByType", reflect.TypeOf((*MockServiceDiscovery)(nil).GetServersByType), serverType)
} | |
c28234 | := m.ctrl.Call(m, "GetServer", id)
ret0, _ := ret[0].(*cluster.Server)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c28235 | "GetServer", reflect.TypeOf((*MockServiceDiscovery)(nil).GetServer), id)
} | |
c28236 | {
ret := m.ctrl.Call(m, "GetServers")
ret0, _ := ret[0].([]*cluster.Server)
return ret0
} | |
c28237 | cluster.SDListener) {
m.ctrl.Call(m, "AddListener", listener)
} | |
c28238 | reflect.TypeOf((*MockServiceDiscovery)(nil).AddListener), listener)
} | |
c28239 | mock.recorder = &MockEncoderMockRecorder{mock}
return mock
} | |
c28240 | "IsCompressionEnabled")
ret0, _ := ret[0].(bool)
return ret0
} | |
c28241 | "IsCompressionEnabled", reflect.TypeOf((*MockEncoder)(nil).IsCompressionEnabled))
} | |
c28242 | msg, []string{"2"}, "connector")
if err != nil {
return nil, err
}
return &Response{
Code: 200,
Msg: "boa",
}, nil
} | |
c28243 | msg)
return &protos.RPCRes{
Msg: fmt.Sprintf("received msg: %s", msg.GetMsg()),
}, nil
} | |
c28244 | err != nil {
t.Fatal(err)
}
defer l.Close()
return l.Addr().(*net.TCPAddr).Port
} | |
c28245 | 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
} | |
c28246 | if err := ioutil.WriteFile(filepath, bytes, 0644); err != nil {
t.Fatalf("failed writing file: %s", err)
}
} | |
c28247 | t.Fatalf("failed reading file: %s", err)
}
return b
} | |
c28248 | t.Helper()
return exec.Command(program, args...)
} | |
c28249 |
)
// 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.NewRe... | |
c28250 |
return filepath.Join("fixtures", name+".golden")
} | |
c28251 | 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
} | |
c28252 | %q", err)
return nil, err
}
logger.Log.Infof("enqueue rpc job: %d", jid)
return &protos.Response{Code: 200, Msg: "ok"}, nil
} | |
c28253 | mock.recorder = &MockSerializerMockRecorder{mock}
return mock
} | |
c28254 | "GetName", reflect.TypeOf((*MockSerializer)(nil).GetName))
} | |
c28255 | := m.ctrl.Call(m, "Marshal", arg0)
ret0, _ := ret[0].([]byte)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c28256 | error {
ret := m.ctrl.Call(m, "Unmarshal", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | |
c28257 | "Unmarshal", reflect.TypeOf((*MockSerializer)(nil).Unmarshal), arg0, arg1)
} | |
c28258 | routeName := route.NewRoute(serverType, serviceName, name)
docs.Handlers[routeName.String()] = docForMethod(handler.Method, getPtrNames)
}
}
return docs.Handlers.toMap()
} | |
c28259 | routeName := route.NewRoute(serverType, serviceName, name)
docs.Remotes[routeName.String()] = docForMethod(remote.Method, getPtrNames)
}
}
return docs.Remotes.toMap()
} | |
c28260 |
if len(err) > 0 {
m.Err = err[0]
}
return m
} | |
c28261 | types[m.Type],
m.ID,
m.Route,
m.compressed,
m.Err,
m.Data,
len(m.Data))
} | |
c28262 |
return fmt.Errorf("duplicated route(route: %s, code: %d)", r, code)
}
if _, ok := codes[code]; ok {
return fmt.Errorf("duplicated route(route: %s, code: %d)", r, code)
}
// update map, using last value when key duplicated
routes[r] = code
codes[code] = r
}
return nil
} | |
c28263 | %s", p.Type, p.Length, string(p.Data))
} | |
c28264 | mock.recorder = &MockReporterMockRecorder{mock}
return mock
} | |
c28265 | float64) error {
ret := m.ctrl.Call(m, "ReportCount", metric, tags, count)
ret0, _ := ret[0].(error)
return ret0
} | |
c28266 | reflect.TypeOf((*MockReporter)(nil).ReportCount), metric, tags, count)
} | |
c28267 | float64) error {
ret := m.ctrl.Call(m, "ReportSummary", metric, tags, value)
ret0, _ := ret[0].(error)
return ret0
} | |
c28268 | reflect.TypeOf((*MockReporter)(nil).ReportSummary), metric, tags, value)
} | |
c28269 | spanData)
if err != nil {
return nil, err
}
return pcontext.AddToPropagateCtx(ctx, constants.SpanPropagateCtxKey, spanData), nil
} | |
c28270 |
span := opentracing.StartSpan(opName, opentracing.ChildOf(ref), tags)
return opentracing.ContextWithSpan(parentCtx, span)
} | |
c28271 |
}
defer span.Finish()
if err != nil {
LogError(span, err.Error())
}
} | |
c28272 |
if !ok {
logger.Log.Debugf("no specific route for svType: %s, using default route", svType)
server := r.defaultRoute(serversOfType)
return server, nil
}
return routeFunc(ctx, route, msg.Data, serversOfType)
} | |
c28273 | conn,
decoder: packetDecoder,
encoder: packetEncoder,
heartbeatTimeout: heartbeatTime,
lastAt: time.Now().Unix(),
serializer: serializer,
state: constants.StatusStart,
messageEncoder: messageEncoder,
metricsReporters: metricsRe... | |
c28274 | 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)
}
return a.send(pendingMessage{typ: message.Push, route: route, payload: v})
} | |
c28275 | ID=%d, UID=%d, MID=%d, Data=%dbytes",
a.Session.ID(), a.Session.UID(), mid, len(d))
default:
logger.Log.Infof("Type=Response, ID=%d, UID=%d, MID=%d, Data=%+v",
a.Session.ID(), a.Session.UID(), mid, v)
}
return a.send(pendingMessage{ctx: ctx, typ: message.Response, mid: mid, payload: v, err: err})
} | |
c28276 | case <-a.chDie:
// expect
default:
close(a.chStopWrite)
close(a.chStopHeartbeat)
close(a.chDie)
onSessionClosed(a.Session)
}
metrics.ReportNumberOfConnectedClients(a.metricsReporters, session.SessionCount)
return a.conn.Close()
} | |
c28277 | LastTime=%d", a.conn.RemoteAddr().String(), a.lastAt)
} | |
c28278 |
return err
}
_, err = a.conn.Write(p)
return err
} | |
c28279 | int32) {
atomic.StoreInt32(&a.state, state)
} | |
c28280 | a.write()
go a.heartbeat()
select {
case <-a.chDie: // agent closed signal
return
}
} | |
c28281 | err := a.conn.Write(hrd)
return err
} | |
c28282 | answering the user with an error: %s", e.Error())
return
}
e = a.Session.ResponseMID(ctx, mid, p, true)
if e != nil {
logger.Log.Errorf("error answering the user with an error: %s", e.Error())
}
} | |
c28283 | handshakeData: nil,
lastTime: time.Now().Unix(),
OnCloseCallbacks: []func(){},
IsFrontend: frontend,
}
if frontend {
sessionsByID.Store(s.id, s)
atomic.AddInt64(&SessionCount, 1)
}
if len(UID) > 0 {
s.uid = UID[0]
}
return s
} | |
c28284 | in backend servers
if val, ok := sessionsByUID.Load(uid); ok {
return val.(*Session)
}
return nil
} | |
c28285 | in backend servers
if val, ok := sessionsByID.Load(id); ok {
return val.(*Session)
}
return nil
} | |
c28286 | sf1.Pointer() == sf2.Pointer() {
return
}
}
sessionBindCallbacks = append(sessionBindCallbacks, f)
} | |
c28287 | if sf1.Pointer() == sf2.Pointer() {
return
}
}
afterBindCallbacks = append(afterBindCallbacks, f)
} | |
c28288 | sf1.Pointer() == sf2.Pointer() {
return
}
}
SessionCloseCallbacks = append(SessionCloseCallbacks, f)
} | |
c28289 | return s.entity.Push(route, v)
} | |
c28290 | v interface{}, err ...bool) error {
return s.entity.ResponseMID(ctx, mid, v, err...)
} | |
c28291 | defer s.RUnlock()
return s.data
} | |
c28292 | {
s.Lock()
defer s.Unlock()
s.data = data
return s.updateEncodedData()
} | |
c28293 | := json.Unmarshal(encodedData, &data)
if err != nil {
return err
}
return s.SetData(data)
} | |
c28294 | = frontendID
s.frontendSessionID = frontendSessionID
} | |
c28295 | := cb(ctx, s)
if err != nil {
s.uid = ""
return err
}
}
// if code running on frontend server
if s.IsFrontend {
sessionsByUID.Store(uid, s)
} else {
// If frontentID is set this means it is a remote call and the current server
// is not the frontend server that received the user request
err := s... | |
c28296 | s.OnCloseCallbacks = append(s.OnCloseCallbacks, c)
return nil
} | |
c28297 |
logger.Log.Errorf("error unsubscribing to user's messages channel: %s, this can cause performance and leak issues", err.Error())
} else {
logger.Log.Debugf("successfully unsubscribed to user's %s messages channel", s.UID())
}
}
}
s.entity.Close()
} | |
c28298 |
delete(s.data, key)
return s.updateEncodedData()
} | |
c28299 |
_, has := s.data[key]
return has
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.