_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q28200 | ValidateMessageType | train | 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 | {
"resource": ""
} |
q28201 | Init | train | func (r *Room) Init() {
gsi := groups.NewMemoryGroupService(config.NewConfig())
pitaya.InitGroups(gsi)
pitaya.GroupCreate(context.Background(), "room")
} | go | {
"resource": ""
} |
q28202 | LogError | train | func LogError(span opentracing.Span, message string) {
span.SetTag("error", true)
span.LogFields(
log.String("event", "error"),
log.String("message", message),
)
} | go | {
"resource": ""
} |
q28203 | BroadcastSessionBind | train | 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 | {
"resource": ""
} |
q28204 | Send | train | func (ns *NatsRPCClient) Send(topic string, data []byte) error {
if !ns.running {
return constants.ErrRPCClientNotInitialized
}
return ns.conn.Publish(topic, data)
} | go | {
"resource": ""
} |
q28205 | SendPush | train | 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 | {
"resource": ""
} |
q28206 | SendKick | train | 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 | {
"resource": ""
} |
q28207 | Call | train | 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... | go | {
"resource": ""
} |
q28208 | Init | train | 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 | {
"resource": ""
} |
q28209 | NewRemote | train | 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{})... | go | {
"resource": ""
} |
q28210 | Push | train | 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.Sess... | go | {
"resource": ""
} |
q28211 | ResponseMID | train | 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",... | go | {
"resource": ""
} |
q28212 | CodeFromError | train | 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 | {
"resource": ""
} |
q28213 | NewTimer | train | func NewTimer(interval time.Duration, fn timer.Func) *timer.Timer {
return NewCountTimer(interval, timer.LoopForever, fn)
} | go | {
"resource": ""
} |
q28214 | NewCountTimer | train | 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... | go | {
"resource": ""
} |
q28215 | NewAfterTimer | train | func NewAfterTimer(duration time.Duration, fn timer.Func) *timer.Timer {
return NewCountTimer(duration, 1, fn)
} | go | {
"resource": ""
} |
q28216 | NewCondTimer | train | 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 | {
"resource": ""
} |
q28217 | SetTimerPrecision | train | func SetTimerPrecision(precision time.Duration) {
if precision < time.Millisecond {
panic("time precision can not less than a Millisecond")
}
timer.Precision = precision
} | go | {
"resource": ""
} |
q28218 | NotifySessionData | train | 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 | {
"resource": ""
} |
q28219 | Docs | train | 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 | {
"resource": ""
} |
q28220 | NewTCPAcceptor | train | 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... | go | {
"resource": ""
} |
q28221 | ListenAndServe | train | 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 | {
"resource": ""
} |
q28222 | ListenAndServeTLS | train | 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
... | go | {
"resource": ""
} |
q28223 | NewWSAcceptor | train | 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... | go | {
"resource": ""
} |
q28224 | ListenAndServe | train | 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.a... | go | {
"resource": ""
} |
q28225 | ListenAndServeTLS | train | 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.Cer... | go | {
"resource": ""
} |
q28226 | Stop | train | func (w *WSAcceptor) Stop() {
err := w.listener.Close()
if err != nil {
logger.Log.Errorf("Failed to stop: %s", err.Error())
}
} | go | {
"resource": ""
} |
q28227 | New | train | 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,
pack... | go | {
"resource": ""
} |
q28228 | pendingRequestsReaper | train | 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 {
toDelet... | go | {
"resource": ""
} |
q28229 | Disconnect | train | func (c *Client) Disconnect() {
if c.Connected {
c.Connected = false
close(c.closeChan)
c.conn.Close()
}
} | go | {
"resource": ""
} |
q28230 | sendMsg | train | 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 {
... | go | {
"resource": ""
} |
q28231 | NewMockServiceDiscovery | train | func NewMockServiceDiscovery(ctrl *gomock.Controller) *MockServiceDiscovery {
mock := &MockServiceDiscovery{ctrl: ctrl}
mock.recorder = &MockServiceDiscoveryMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q28232 | GetServersByType | train | 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 | {
"resource": ""
} |
q28233 | GetServersByType | train | func (mr *MockServiceDiscoveryMockRecorder) GetServersByType(serverType interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServersByType", reflect.TypeOf((*MockServiceDiscovery)(nil).GetServersByType), serverType)
} | go | {
"resource": ""
} |
q28234 | GetServer | train | 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 | {
"resource": ""
} |
q28235 | GetServer | train | func (mr *MockServiceDiscoveryMockRecorder) GetServer(id interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServer", reflect.TypeOf((*MockServiceDiscovery)(nil).GetServer), id)
} | go | {
"resource": ""
} |
q28236 | GetServers | train | func (m *MockServiceDiscovery) GetServers() []*cluster.Server {
ret := m.ctrl.Call(m, "GetServers")
ret0, _ := ret[0].([]*cluster.Server)
return ret0
} | go | {
"resource": ""
} |
q28237 | AddListener | train | func (m *MockServiceDiscovery) AddListener(listener cluster.SDListener) {
m.ctrl.Call(m, "AddListener", listener)
} | go | {
"resource": ""
} |
q28238 | AddListener | train | func (mr *MockServiceDiscoveryMockRecorder) AddListener(listener interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddListener", reflect.TypeOf((*MockServiceDiscovery)(nil).AddListener), listener)
} | go | {
"resource": ""
} |
q28239 | NewMockEncoder | train | func NewMockEncoder(ctrl *gomock.Controller) *MockEncoder {
mock := &MockEncoder{ctrl: ctrl}
mock.recorder = &MockEncoderMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q28240 | IsCompressionEnabled | train | func (m *MockEncoder) IsCompressionEnabled() bool {
ret := m.ctrl.Call(m, "IsCompressionEnabled")
ret0, _ := ret[0].(bool)
return ret0
} | go | {
"resource": ""
} |
q28241 | IsCompressionEnabled | train | func (mr *MockEncoderMockRecorder) IsCompressionEnabled() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsCompressionEnabled", reflect.TypeOf((*MockEncoder)(nil).IsCompressionEnabled))
} | go | {
"resource": ""
} |
q28242 | SendPushToUser | train | 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 | {
"resource": ""
} |
q28243 | RemoteFunc | train | 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 | {
"resource": ""
} |
q28244 | GetFreePort | train | 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 | {
"resource": ""
} |
q28245 | GetMapKeys | train | 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(... | go | {
"resource": ""
} |
q28246 | WriteFile | train | 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 | {
"resource": ""
} |
q28247 | ReadFile | train | 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 | {
"resource": ""
} |
q28248 | StartProcess | train | func StartProcess(t testing.TB, program string, args ...string) *exec.Cmd {
t.Helper()
return exec.Command(program, args...)
} | go | {
"resource": ""
} |
q28249 | StartServer | train | 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"... | go | {
"resource": ""
} |
q28250 | FixtureGoldenFileName | train | func FixtureGoldenFileName(t *testing.T, name string) string {
t.Helper()
return filepath.Join("fixtures", name+".golden")
} | go | {
"resource": ""
} |
q28251 | ShouldEventuallyReceive | train | 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(... | go | {
"resource": ""
} |
q28252 | CallLog | train | 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.Info... | go | {
"resource": ""
} |
q28253 | NewMockSerializer | train | func NewMockSerializer(ctrl *gomock.Controller) *MockSerializer {
mock := &MockSerializer{ctrl: ctrl}
mock.recorder = &MockSerializerMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q28254 | GetName | train | func (mr *MockSerializerMockRecorder) GetName() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetName", reflect.TypeOf((*MockSerializer)(nil).GetName))
} | go | {
"resource": ""
} |
q28255 | Marshal | train | func (m *MockSerializer) Marshal(arg0 interface{}) ([]byte, error) {
ret := m.ctrl.Call(m, "Marshal", arg0)
ret0, _ := ret[0].([]byte)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q28256 | Unmarshal | train | func (m *MockSerializer) Unmarshal(arg0 []byte, arg1 interface{}) error {
ret := m.ctrl.Call(m, "Unmarshal", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q28257 | Unmarshal | train | func (mr *MockSerializerMockRecorder) Unmarshal(arg0, arg1 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unmarshal", reflect.TypeOf((*MockSerializer)(nil).Unmarshal), arg0, arg1)
} | go | {
"resource": ""
} |
q28258 | HandlersDocs | train | func HandlersDocs(serverType string, services map[string]*component.Service, getPtrNames bool) (map[string]interface{}, error) {
docs := &docs{
Handlers: map[string]*doc{},
}
for serviceName, service := range services {
for name, handler := range service.Handlers {
routeName := route.NewRoute(serverType, ser... | go | {
"resource": ""
} |
q28259 | RemotesDocs | train | func RemotesDocs(serverType string, services map[string]*component.Service, getPtrNames bool) (map[string]interface{}, error) {
docs := &docs{
Remotes: map[string]*doc{},
}
for serviceName, service := range services {
for name, remote := range service.Remotes {
routeName := route.NewRoute(serverType, service... | go | {
"resource": ""
} |
q28260 | New | train | func New(err ...bool) *Message {
m := &Message{}
if len(err) > 0 {
m.Err = err[0]
}
return m
} | go | {
"resource": ""
} |
q28261 | String | train | func (m *Message) String() string {
return fmt.Sprintf("Type: %s, ID: %d, Route: %s, Compressed: %t, Error: %t, Data: %v, BodyLength: %d",
types[m.Type],
m.ID,
m.Route,
m.compressed,
m.Err,
m.Data,
len(m.Data))
} | go | {
"resource": ""
} |
q28262 | SetDictionary | train | func SetDictionary(dict map[string]uint16) error {
if dict == nil {
return nil
}
for route, code := range dict {
r := strings.TrimSpace(route)
// duplication check
if _, ok := routes[r]; ok {
return fmt.Errorf("duplicated route(route: %s, code: %d)", r, code)
}
if _, ok := codes[code]; ok {
retu... | go | {
"resource": ""
} |
q28263 | String | train | func (p *Packet) String() string {
return fmt.Sprintf("Type: %d, Length: %d, Data: %s", p.Type, p.Length, string(p.Data))
} | go | {
"resource": ""
} |
q28264 | NewMockReporter | train | func NewMockReporter(ctrl *gomock.Controller) *MockReporter {
mock := &MockReporter{ctrl: ctrl}
mock.recorder = &MockReporterMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q28265 | ReportCount | train | func (m *MockReporter) ReportCount(metric string, tags map[string]string, count float64) error {
ret := m.ctrl.Call(m, "ReportCount", metric, tags, count)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q28266 | ReportCount | train | func (mr *MockReporterMockRecorder) ReportCount(metric, tags, count interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportCount", reflect.TypeOf((*MockReporter)(nil).ReportCount), metric, tags, count)
} | go | {
"resource": ""
} |
q28267 | ReportSummary | train | func (m *MockReporter) ReportSummary(metric string, tags map[string]string, value float64) error {
ret := m.ctrl.Call(m, "ReportSummary", metric, tags, value)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q28268 | ReportSummary | train | func (mr *MockReporterMockRecorder) ReportSummary(metric, tags, value interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportSummary", reflect.TypeOf((*MockReporter)(nil).ReportSummary), metric, tags, value)
} | go | {
"resource": ""
} |
q28269 | InjectSpan | train | func InjectSpan(ctx context.Context) (context.Context, error) {
span := opentracing.SpanFromContext(ctx)
if span == nil {
return ctx, nil
}
spanData := opentracing.TextMapCarrier{}
tracer := opentracing.GlobalTracer()
err := tracer.Inject(span.Context(), opentracing.TextMap, spanData)
if err != nil {
return ... | go | {
"resource": ""
} |
q28270 | StartSpan | train | func StartSpan(
parentCtx context.Context,
opName string,
tags opentracing.Tags,
reference ...opentracing.SpanContext,
) context.Context {
var ref opentracing.SpanContext
if len(reference) > 0 {
ref = reference[0]
}
span := opentracing.StartSpan(opName, opentracing.ChildOf(ref), tags)
return opentracing.Cont... | go | {
"resource": ""
} |
q28271 | FinishSpan | train | func FinishSpan(ctx context.Context, err error) {
if ctx == nil {
return
}
span := opentracing.SpanFromContext(ctx)
if span == nil {
return
}
defer span.Finish()
if err != nil {
LogError(span, err.Error())
}
} | go | {
"resource": ""
} |
q28272 | Route | train | func (r *Router) Route(
ctx context.Context,
rpcType protos.RPCType,
svType string,
route *route.Route,
msg *message.Message,
) (*cluster.Server, error) {
if r.serviceDiscovery == nil {
return nil, constants.ErrServiceDiscoveryNotInitialized
}
serversOfType, err := r.serviceDiscovery.GetServersByType(svType)
... | go | {
"resource": ""
} |
q28273 | NewAgent | train | func NewAgent(
conn net.Conn,
packetDecoder codec.PacketDecoder,
packetEncoder codec.PacketEncoder,
serializer serialize.Serializer,
heartbeatTime time.Duration,
messagesBufferSize int,
dieChan chan bool,
messageEncoder message.Encoder,
metricsReporters []metrics.Reporter,
) *Agent {
// initialize heartbeat a... | go | {
"resource": ""
} |
q28274 | Push | train | func (a *Agent) Push(route string, v interface{}) error {
if a.GetStatus() == constants.StatusClosed {
return constants.ErrBrokenPipe
}
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... | go | {
"resource": ""
} |
q28275 | ResponseMID | train | func (a *Agent) ResponseMID(ctx context.Context, mid uint, v interface{}, isError ...bool) error {
err := false
if len(isError) > 0 {
err = isError[0]
}
if a.GetStatus() == constants.StatusClosed {
err := constants.ErrBrokenPipe
tracing.FinishSpan(ctx, err)
metrics.ReportTimingFromCtx(ctx, a.metricsReporter... | go | {
"resource": ""
} |
q28276 | Close | train | func (a *Agent) Close() error {
a.closeMutex.Lock()
defer a.closeMutex.Unlock()
if a.GetStatus() == constants.StatusClosed {
return constants.ErrCloseClosedSession
}
a.SetStatus(constants.StatusClosed)
logger.Log.Debugf("Session closed, ID=%d, UID=%d, IP=%s",
a.Session.ID(), a.Session.UID(), a.conn.RemoteAdd... | go | {
"resource": ""
} |
q28277 | String | train | func (a *Agent) String() string {
return fmt.Sprintf("Remote=%s, LastTime=%d", a.conn.RemoteAddr().String(), a.lastAt)
} | go | {
"resource": ""
} |
q28278 | Kick | train | func (a *Agent) Kick(ctx context.Context) error {
// packet encode
p, err := a.encoder.Encode(packet.Kick, nil)
if err != nil {
return err
}
_, err = a.conn.Write(p)
return err
} | go | {
"resource": ""
} |
q28279 | SetStatus | train | func (a *Agent) SetStatus(state int32) {
atomic.StoreInt32(&a.state, state)
} | go | {
"resource": ""
} |
q28280 | Handle | train | func (a *Agent) Handle() {
defer func() {
a.Close()
logger.Log.Debugf("Session handle goroutine exit, SessionID=%d, UID=%d", a.Session.ID(), a.Session.UID())
}()
go a.write()
go a.heartbeat()
select {
case <-a.chDie: // agent closed signal
return
}
} | go | {
"resource": ""
} |
q28281 | SendHandshakeResponse | train | func (a *Agent) SendHandshakeResponse() error {
_, err := a.conn.Write(hrd)
return err
} | go | {
"resource": ""
} |
q28282 | AnswerWithError | train | func (a *Agent) AnswerWithError(ctx context.Context, mid uint, err error) {
if ctx != nil && err != nil {
s := opentracing.SpanFromContext(ctx)
if s != nil {
tracing.LogError(s, err.Error())
}
}
p, e := util.GetErrorPayload(a.serializer, err)
if e != nil {
logger.Log.Errorf("error answering the user with... | go | {
"resource": ""
} |
q28283 | New | train | func New(entity NetworkEntity, frontend bool, UID ...string) *Session {
s := &Session{
id: sessionIDSvc.sessionID(),
entity: entity,
data: make(map[string]interface{}),
handshakeData: nil,
lastTime: time.Now().Unix(),
OnCloseCallbacks: []func(){},
IsFrontend... | go | {
"resource": ""
} |
q28284 | GetSessionByUID | train | func GetSessionByUID(uid string) *Session {
// TODO: Block this operation in backend servers
if val, ok := sessionsByUID.Load(uid); ok {
return val.(*Session)
}
return nil
} | go | {
"resource": ""
} |
q28285 | GetSessionByID | train | func GetSessionByID(id int64) *Session {
// TODO: Block this operation in backend servers
if val, ok := sessionsByID.Load(id); ok {
return val.(*Session)
}
return nil
} | go | {
"resource": ""
} |
q28286 | OnSessionBind | train | func OnSessionBind(f func(ctx context.Context, s *Session) error) {
// Prevents the same function to be added twice in onSessionBind
sf1 := reflect.ValueOf(f)
for _, fun := range sessionBindCallbacks {
sf2 := reflect.ValueOf(fun)
if sf1.Pointer() == sf2.Pointer() {
return
}
}
sessionBindCallbacks = append... | go | {
"resource": ""
} |
q28287 | OnAfterSessionBind | train | func OnAfterSessionBind(f func(ctx context.Context, s *Session) error) {
// Prevents the same function to be added twice in onSessionBind
sf1 := reflect.ValueOf(f)
for _, fun := range afterBindCallbacks {
sf2 := reflect.ValueOf(fun)
if sf1.Pointer() == sf2.Pointer() {
return
}
}
afterBindCallbacks = appen... | go | {
"resource": ""
} |
q28288 | OnSessionClose | train | func OnSessionClose(f func(s *Session)) {
sf1 := reflect.ValueOf(f)
for _, fun := range SessionCloseCallbacks {
sf2 := reflect.ValueOf(fun)
if sf1.Pointer() == sf2.Pointer() {
return
}
}
SessionCloseCallbacks = append(SessionCloseCallbacks, f)
} | go | {
"resource": ""
} |
q28289 | Push | train | func (s *Session) Push(route string, v interface{}) error {
return s.entity.Push(route, v)
} | go | {
"resource": ""
} |
q28290 | ResponseMID | train | func (s *Session) ResponseMID(ctx context.Context, mid uint, v interface{}, err ...bool) error {
return s.entity.ResponseMID(ctx, mid, v, err...)
} | go | {
"resource": ""
} |
q28291 | GetData | train | func (s *Session) GetData() map[string]interface{} {
s.RLock()
defer s.RUnlock()
return s.data
} | go | {
"resource": ""
} |
q28292 | SetData | train | func (s *Session) SetData(data map[string]interface{}) error {
s.Lock()
defer s.Unlock()
s.data = data
return s.updateEncodedData()
} | go | {
"resource": ""
} |
q28293 | SetDataEncoded | train | func (s *Session) SetDataEncoded(encodedData []byte) error {
if len(encodedData) == 0 {
return nil
}
var data map[string]interface{}
err := json.Unmarshal(encodedData, &data)
if err != nil {
return err
}
return s.SetData(data)
} | go | {
"resource": ""
} |
q28294 | SetFrontendData | train | func (s *Session) SetFrontendData(frontendID string, frontendSessionID int64) {
s.frontendID = frontendID
s.frontendSessionID = frontendSessionID
} | go | {
"resource": ""
} |
q28295 | Bind | train | func (s *Session) Bind(ctx context.Context, uid string) error {
if uid == "" {
return constants.ErrIllegalUID
}
if s.UID() != "" {
return constants.ErrSessionAlreadyBound
}
s.uid = uid
for _, cb := range sessionBindCallbacks {
err := cb(ctx, s)
if err != nil {
s.uid = ""
return err
}
}
for _,... | go | {
"resource": ""
} |
q28296 | OnClose | train | func (s *Session) OnClose(c func()) error {
if !s.IsFrontend {
return constants.ErrOnCloseBackend
}
s.OnCloseCallbacks = append(s.OnCloseCallbacks, c)
return nil
} | go | {
"resource": ""
} |
q28297 | Close | train | func (s *Session) Close() {
atomic.AddInt64(&SessionCount, -1)
sessionsByID.Delete(s.ID())
sessionsByUID.Delete(s.UID())
// TODO: this logic should be moved to nats rpc server
if s.IsFrontend && s.Subscriptions != nil && len(s.Subscriptions) > 0 {
// if the user is bound to an userid and nats rpc server is being... | go | {
"resource": ""
} |
q28298 | Remove | train | func (s *Session) Remove(key string) error {
s.Lock()
defer s.Unlock()
delete(s.data, key)
return s.updateEncodedData()
} | go | {
"resource": ""
} |
q28299 | HasKey | train | func (s *Session) HasKey(key string) bool {
s.RLock()
defer s.RUnlock()
_, has := s.data[key]
return has
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.