id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c28300 |
defer s.RUnlock()
v, ok := s.data[key]
if !ok {
return nil
}
return v
} | |
c28301 | ok := s.data[key]
if !ok {
return 0
}
value, ok := v.(int)
if !ok {
return 0
}
return value
} | |
c28302 | ok := v.(int8)
if !ok {
return 0
}
return value
} | |
c28303 | ok := v.(int16)
if !ok {
return 0
}
return value
} | |
c28304 | ok := v.(int32)
if !ok {
return 0
}
return value
} | |
c28305 | ok := v.(int64)
if !ok {
return 0
}
return value
} | |
c28306 | ok := v.(uint)
if !ok {
return 0
}
return value
} | |
c28307 | ok := v.(uint8)
if !ok {
return 0
}
return value
} | |
c28308 | value, ok := v.(uint16)
if !ok {
return 0
}
return value
} | |
c28309 | value, ok := v.(uint32)
if !ok {
return 0
}
return value
} | |
c28310 | value, ok := v.(uint64)
if !ok {
return 0
}
return value
} | |
c28311 | value, ok := v.(float32)
if !ok {
return 0
}
return value
} | |
c28312 | value, ok := v.(float64)
if !ok {
return 0
}
return value
} | |
c28313 | ok := v.(string)
if !ok {
return ""
}
return value
} | |
c28314 | return s.sendRequestToFront(ctx, constants.SessionPushRoute, true)
} | |
c28315 |
s.uid = ""
s.data = map[string]interface{}{}
s.updateEncodedData()
} | |
c28316 | defer s.Unlock()
s.handshakeData = data
} | |
c28317 | nil, constants.ErrWrongValueType
}
return proto.Marshal(pb)
} | |
c28318 | constants.ErrWrongValueType
}
return proto.Unmarshal(data, pb)
} | |
c28319 | int64(interval), // first execution will be after interval
counter: counter,
}
// add to manager
Manager.ChCreatedTimer <- t
return t
} | |
c28320 |
atomic.StoreInt32(&t.closed, 1)
} else {
t.counter = 0 // automatically closed in next Cron
}
} | |
c28321 | error, TimerID=%d, Error=%v", id, err)
}
}()
fn()
} | |
c28322 |
mock.recorder = &MockPacketEncoderMockRecorder{mock}
return mock
} | |
c28323 | json: %s", err.Error())
return ""
}
return string(str)
} | |
c28324 |
return doSendRPC(ctx, "", routeStr, reply, arg)
} | |
c28325 |
return doSendRPC(ctx, serverID, routeStr, reply, arg)
} | |
c28326 | return app.worker.EnqueueRPC(routeStr, metadata, reply, arg)
} | |
c28327 |
return app.worker.EnqueueRPCWithOptions(routeStr, metadata, reply, arg, opts)
} | |
c28328 |
metricsReporters: metricsReporters,
bindingStorage: bindingStorage,
infoRetriever: infoRetriever,
}
gs.configure()
return gs, nil
} | |
c28329 | if err != nil {
return nil, err
}
if c, ok := gs.clientMap.Load(server.ID); ok {
ctxT, done := context.WithTimeout(ctx, gs.reqTimeout)
defer done()
if gs.metricsReporters != nil {
startTime := time.Now()
ctxT = pcontext.AddToPropagateCtx(ctxT, constants.StartTimeKey, startTime.UnixNano())
ctxT = pc... | |
c28330 |
return constants.ErrNotImplemented
} | |
c28331 | ctxT, done := context.WithTimeout(context.Background(), gs.reqTimeout)
defer done()
_, err := c.(protos.PitayaClient).SessionBindRemote(ctxT, msg)
return err
}
}
return nil
} | |
c28332 | := gs.clientMap.Load(svID); ok {
ctxT, done := context.WithTimeout(context.Background(), gs.reqTimeout)
defer done()
_, err := c.(protos.PitayaClient).KickUser(ctxT, kick)
return err
}
return constants.ErrNoConnectionToServer
} | |
c28333 | no %s specified in metadata", sv.ID, portKey)
return
}
address := fmt.Sprintf("%s:%s", host, port)
conn, err := grpc.Dial(address, grpc.WithInsecure())
if err != nil {
logger.Log.Errorf("unable to connect to server %s at %s: %v", sv.ID, address, err)
return
}
c := protos.NewPitayaClient(conn)
gs.clientMa... | |
c28334 | client?
gs.clientMap.Delete(sv.ID)
logger.Log.Debugf("[grpc client] removed server %s", sv.ID)
}
} | |
c28335 |
return json.Unmarshal(data, v)
} | |
c28336 | return &HandlerNoArgResponse{
Msg: "ok",
}, nil
} | |
c28337 | error) {
logger := pitaya.GetDefaultLoggerFromCtx(ctx)
logger.Infof("Simple After exec - response: %v , error: %v", resp, err)
return resp, err
} | |
c28338 | append(handlerComp, regComp{c, options})
} | |
c28339 | append(remoteComp, regComp{c, options})
} | |
c28340 | fmt.Sprintf("pitaya/%s/user/%s/push", svType, uid)
} | |
c28341 | fmt.Sprintf("pitaya/%s/user/%s/kick", svType, uid)
} | |
c28342 | subk, err := ns.subscribeToUserKickChannel(s.UID(), ns.server.Type)
if err != nil {
return err
}
s.Subscriptions = []*nats.Subscription{subu, subk}
}
return nil
} | |
c28343 | i := 0; i < ns.config.GetInt("pitaya.concurrency.remote.service"); i++ {
go ns.processMessages(i)
}
session.OnSessionBind(ns.onSessionBind)
// this should be so fast that we shoudn't need concurrency
go ns.processPushes()
go ns.processSessionBindings()
go ns.processKick()
return nil
} | |
c28344 | &Route{server, service, method}
} | |
c28345 | return fmt.Sprintf("%s.%s.%s", r.SvType, r.Service, r.Method)
}
return r.Short()
} | |
c28346 | return fmt.Sprintf("%s.%s", r.Service, r.Method)
} | |
c28347 | nil
case 2:
return NewRoute("", r[0], r[1]), nil
default:
logger.Log.Errorf("invalid route: " + route)
return nil, ErrInvalidRoute
}
} | |
c28348 | reporter.ReportCount(counterMetricName, map[string]string{
"tag1": arg.Tag1,
"tag2": arg.Tag2,
}, arg.Value)
}
return messages.OKResponse(), nil
} | |
c28349 |
reporter.ReportGauge(counterMetricName, map[string]string{
"tag1": arg.Tag,
}, arg.Value)
}
return messages.OKResponse(), nil
} | |
c28350 |
reporter.ReportSummary(counterMetricName, map[string]string{
"tag1": arg.Tag,
}, arg.Value)
}
return messages.OKResponse(), nil
} | |
c28351 | serviceDiscovery: sd,
serializer: serializer,
router: router,
messageEncoder: messageEncoder,
server: server,
remoteBindingListeners: make([]cluster.RemoteBindingListener, 0),
}
} | |
c28352 | {
r.remoteBindingListeners = append(r.remoteBindingListeners, bindingListener)
} | |
c28353 |
res = processRemoteMessage(c, req, r)
}
if res.Error != nil {
err = errors.New(res.Error.Msg)
}
defer tracing.FinishSpan(c, err)
return res, nil
} | |
c28354 | {
r.OnUserBind(msg.Uid, msg.Fid)
}
return &protos.Response{
Data: []byte("ack"),
}, nil
} | |
c28355 | if err != nil {
return nil, err
}
return &protos.Response{
Data: []byte("ack"),
}, nil
}
return nil, constants.ErrSessionNotFound
} | |
c28356 | err != nil {
return nil, err
}
return &protos.KickAnswer{
Kicked: true,
}, nil
}
return nil, constants.ErrSessionNotFound
} | |
c28357 | if serverID != "" && target == nil {
return nil, constants.ErrServerNotFound
}
return r.remoteCall(ctx, target, protos.RPCType_User, route, nil, msg)
} | |
c28358 | &e.Error{
Code: res.Error.Code,
Message: res.Error.Msg,
Metadata: res.Error.Metadata,
}
}
if reply != nil {
err = proto.Unmarshal(res.GetData(), reply)
if err != nil {
return err
}
}
return nil
} | |
c28359 |
}
return docgenerator.RemotesDocs(r.server.Type, r.services, getPtrNames)
} | |
c28360 | needs two outs: interface{}(that implements proto.Message), error
if mt.NumOut() != 2 {
return false
}
if (mt.Out(0).Kind() != reflect.Ptr) || mt.Out(1) != typeOfError {
return false
}
if o0 := mt.Out(0); !o0.Implements(typeOfProtoMsg) {
return false
}
return true
} | |
c28361 | either no out or two outs: interface{}(or []byte), error
if mt.NumOut() != 0 && mt.NumOut() != 2 {
return false
}
if mt.NumOut() == 2 && (mt.Out(1) != typeOfError || mt.Out(0) != typeOfBytes && mt.Out(0).Kind() != reflect.Ptr) {
return false
}
return true
} | |
c28362 | sessionData.Uid); err != nil {
return nil, err
}
return &protos.Response{Data: []byte("ack")}, nil
} | |
c28363 | return res, constants.ErrSessionNotFound
}
err := sess.Kick(ctx)
if err != nil {
return res, err
}
res.Kicked = true
return res, nil
} | |
c28364 | message: %s\n", message)
return &protos.Response{
Msg: string(message),
}, nil
} | |
c28365 |
return RegisterModuleAfter(module, name)
} | |
c28366 | append(modulesArr, moduleWrapper{
module: module,
name: name,
})
return nil
} | |
c28367 |
return nil, fmt.Errorf("module with name %s not found", name)
} | |
c28368 |
}
for _, modWrapper := range modulesArr {
modWrapper.module.AfterInit()
logger.Log.Infof("module: %s successfully loaded", modWrapper.name)
}
} | |
c28369 | mod.Shutdown(); err != nil {
logger.Log.Warnf("error stopping module: %s", name)
}
logger.Log.Infof("module: %s stopped!", name)
}
} | |
c28370 |
sr.buildDefaultTags(tagsMap)
if len(clientOrNil) > 0 {
sr.client = clientOrNil[0]
} else {
c, err := statsd.New(host)
if err != nil {
return nil, err
}
c.Namespace = prefix
sr.client = c
}
return sr, nil
} | |
c28371 |
fullTags = append(fullTags, fmt.Sprintf("%s:%s", k, v))
}
err := s.client.Count(metric, int64(count), fullTags, s.rate)
if err != nil {
logger.Log.Errorf("failed to report count: %q", err)
}
return err
} | |
c28372 | {
fullTags = append(fullTags, fmt.Sprintf("%s:%s", k, v))
}
err := s.client.Gauge(metric, value, fullTags, s.rate)
if err != nil {
logger.Log.Errorf("failed to report gauge: %q", err)
}
return err
} | |
c28373 | groupServiceInstance.GroupCreate(ctx, groupName)
} | |
c28374 | return groupServiceInstance.GroupCreateWithTTL(ctx, groupName, ttlTime)
} | |
c28375 | GroupMembers(ctx, groupName)
if err != nil {
return err
}
return sendDataToMembers(members, frontendType, route, v)
} | |
c28376 | constants.ErrEmptyUID
}
return groupServiceInstance.GroupContainsMember(ctx, groupName, uid)
} | |
c28377 | groupServiceInstance.GroupRemoveAll(ctx, groupName)
} | |
c28378 | groupServiceInstance.GroupRenewTTL(ctx, groupName)
} | |
c28379 | groupServiceInstance.GroupDelete(ctx, groupName)
} | |
c28380 | uid,
Data: data,
}
if err = app.rpcClient.SendPush(uid, &cluster.Server{Type: frontendType}, push); err != nil {
notPushedUids = append(notPushedUids, uid)
logger.Log.Errorf("RPCClient send message error, UID=%s, SvType=%s, Error=%s", uid, frontendType, err.Error())
}
} else {
notPushedUid... | |
c28381 |
protos.RegisterPitayaServer(gs.grpcSv, gs.pitayaServer)
go gs.grpcSv.Serve(lis)
return nil
} | |
c28382 |
"route": route.(string),
"status": status,
"type": typ,
"code": code,
})
for _, r := range reporters {
r.ReportSummary(ResponseTime, tags, float64(elapsed.Nanoseconds()))
}
}
} | |
c28383 |
route := pcontext.GetFromPropagateCtx(ctx, constants.RouteKey)
tags := getTags(ctx, map[string]string{
"route": route.(string),
"type": typ,
})
for _, r := range reporters {
r.ReportSummary(ProcessDelay, tags, float64(elapsed.Nanoseconds()))
}
}
} | |
c28384 | r.ReportGauge(ConnectedClients, map[string]string{}, float64(number))
}
} | |
c28385 | r.ReportGauge(HeapSize, map[string]string{}, float64(m.Alloc))
r.ReportGauge(HeapObjects, map[string]string{}, float64(m.HeapObjects))
}
time.Sleep(period)
}
} | |
c28386 | {
memoryGroups = make(map[string]*MemoryGroup)
go groupTTLCleanup(conf)
})
return &MemoryGroupService{}
} | |
c28387 | {
return constants.ErrGroupAlreadyExists
}
memoryGroups[groupName] = &MemoryGroup{}
return nil
} | |
c28388 |
if _, ok := memoryGroups[groupName]; ok {
return constants.ErrGroupAlreadyExists
}
memoryGroups[groupName] = &MemoryGroup{LastRefresh: time.Now().UnixNano(), TTL: ttlTime.Nanoseconds()}
return nil
} | |
c28389 |
mg, ok := memoryGroups[groupName]
if !ok {
return nil, constants.ErrGroupNotFound
}
uids := make([]string, len(mg.Uids))
copy(uids, mg.Uids)
return uids, nil
} | |
c28390 | defer memoryGroupsMu.Unlock()
mg, ok := memoryGroups[groupName]
if !ok {
return false, constants.ErrGroupNotFound
}
_, contains := elementIndex(mg.Uids, uid)
return contains, nil
} | |
c28391 | contains {
mg.Uids[index] = mg.Uids[len(mg.Uids)-1]
mg.Uids = mg.Uids[:len(mg.Uids)-1]
memoryGroups[groupName] = mg
return nil
}
return constants.ErrMemberNotFound
} | |
c28392 |
if !ok {
return constants.ErrGroupNotFound
}
mg.Uids = []string{}
return nil
} | |
c28393 | defer memoryGroupsMu.Unlock()
_, ok := memoryGroups[groupName]
if !ok {
return constants.ErrGroupNotFound
}
delete(memoryGroups, groupName)
return nil
} | |
c28394 | {
mg.LastRefresh = time.Now().UnixNano()
memoryGroups[groupName] = mg
return nil
}
return constants.ErrMemoryTTLNotFound
} | |
c28395 |
b := &ETCDBindingStorage{
config: conf,
thisServer: server,
stopChan: make(chan struct{}),
}
b.configure()
return b
} | |
c28396 | getUserBindingKey(uid, b.thisServer.Type), b.thisServer.ID, clientv3.WithLease(b.leaseID))
return err
} | |
c28397 | err = b.bootstrapLease()
if err != nil {
return err
}
if b.thisServer.Frontend {
b.setupOnSessionCloseCB()
b.setupOnAfterSessionBindCB()
}
return nil
} | |
c28398 | *APIDocsGen {
return &APIDocsGen{
basePath: basePath,
services: services,
}
} | |
c28399 | logger.Log.Infof("loaded svc: %s", s.Name)
}
return nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.