_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q28300 | Get | train | func (s *Session) Get(key string) interface{} {
s.RLock()
defer s.RUnlock()
v, ok := s.data[key]
if !ok {
return nil
}
return v
} | go | {
"resource": ""
} |
q28301 | Int | train | func (s *Session) Int(key string) int {
s.RLock()
defer s.RUnlock()
v, ok := s.data[key]
if !ok {
return 0
}
value, ok := v.(int)
if !ok {
return 0
}
return value
} | go | {
"resource": ""
} |
q28302 | Int8 | train | func (s *Session) Int8(key string) int8 {
s.RLock()
defer s.RUnlock()
v, ok := s.data[key]
if !ok {
return 0
}
value, ok := v.(int8)
if !ok {
return 0
}
return value
} | go | {
"resource": ""
} |
q28303 | Int16 | train | func (s *Session) Int16(key string) int16 {
s.RLock()
defer s.RUnlock()
v, ok := s.data[key]
if !ok {
return 0
}
value, ok := v.(int16)
if !ok {
return 0
}
return value
} | go | {
"resource": ""
} |
q28304 | Int32 | train | func (s *Session) Int32(key string) int32 {
s.RLock()
defer s.RUnlock()
v, ok := s.data[key]
if !ok {
return 0
}
value, ok := v.(int32)
if !ok {
return 0
}
return value
} | go | {
"resource": ""
} |
q28305 | Int64 | train | func (s *Session) Int64(key string) int64 {
s.RLock()
defer s.RUnlock()
v, ok := s.data[key]
if !ok {
return 0
}
value, ok := v.(int64)
if !ok {
return 0
}
return value
} | go | {
"resource": ""
} |
q28306 | Uint | train | func (s *Session) Uint(key string) uint {
s.RLock()
defer s.RUnlock()
v, ok := s.data[key]
if !ok {
return 0
}
value, ok := v.(uint)
if !ok {
return 0
}
return value
} | go | {
"resource": ""
} |
q28307 | Uint8 | train | func (s *Session) Uint8(key string) uint8 {
s.RLock()
defer s.RUnlock()
v, ok := s.data[key]
if !ok {
return 0
}
value, ok := v.(uint8)
if !ok {
return 0
}
return value
} | go | {
"resource": ""
} |
q28308 | Uint16 | train | func (s *Session) Uint16(key string) uint16 {
s.RLock()
defer s.RUnlock()
v, ok := s.data[key]
if !ok {
return 0
}
value, ok := v.(uint16)
if !ok {
return 0
}
return value
} | go | {
"resource": ""
} |
q28309 | Uint32 | train | func (s *Session) Uint32(key string) uint32 {
s.RLock()
defer s.RUnlock()
v, ok := s.data[key]
if !ok {
return 0
}
value, ok := v.(uint32)
if !ok {
return 0
}
return value
} | go | {
"resource": ""
} |
q28310 | Uint64 | train | func (s *Session) Uint64(key string) uint64 {
s.RLock()
defer s.RUnlock()
v, ok := s.data[key]
if !ok {
return 0
}
value, ok := v.(uint64)
if !ok {
return 0
}
return value
} | go | {
"resource": ""
} |
q28311 | Float32 | train | func (s *Session) Float32(key string) float32 {
s.RLock()
defer s.RUnlock()
v, ok := s.data[key]
if !ok {
return 0
}
value, ok := v.(float32)
if !ok {
return 0
}
return value
} | go | {
"resource": ""
} |
q28312 | Float64 | train | func (s *Session) Float64(key string) float64 {
s.RLock()
defer s.RUnlock()
v, ok := s.data[key]
if !ok {
return 0
}
value, ok := v.(float64)
if !ok {
return 0
}
return value
} | go | {
"resource": ""
} |
q28313 | String | train | func (s *Session) String(key string) string {
s.RLock()
defer s.RUnlock()
v, ok := s.data[key]
if !ok {
return ""
}
value, ok := v.(string)
if !ok {
return ""
}
return value
} | go | {
"resource": ""
} |
q28314 | PushToFront | train | func (s *Session) PushToFront(ctx context.Context) error {
if s.IsFrontend {
return constants.ErrFrontSessionCantPushToFront
}
return s.sendRequestToFront(ctx, constants.SessionPushRoute, true)
} | go | {
"resource": ""
} |
q28315 | Clear | train | func (s *Session) Clear() {
s.Lock()
defer s.Unlock()
s.uid = ""
s.data = map[string]interface{}{}
s.updateEncodedData()
} | go | {
"resource": ""
} |
q28316 | SetHandshakeData | train | func (s *Session) SetHandshakeData(data *HandshakeData) {
s.Lock()
defer s.Unlock()
s.handshakeData = data
} | go | {
"resource": ""
} |
q28317 | Marshal | train | func (s *Serializer) Marshal(v interface{}) ([]byte, error) {
pb, ok := v.(proto.Message)
if !ok {
return nil, constants.ErrWrongValueType
}
return proto.Marshal(pb)
} | go | {
"resource": ""
} |
q28318 | Unmarshal | train | func (s *Serializer) Unmarshal(data []byte, v interface{}) error {
pb, ok := v.(proto.Message)
if !ok {
return constants.ErrWrongValueType
}
return proto.Unmarshal(data, pb)
} | go | {
"resource": ""
} |
q28319 | NewTimer | train | func NewTimer(fn Func, interval time.Duration, counter int) *Timer {
id := atomic.AddInt64(&Manager.incrementID, 1)
t := &Timer{
ID: id,
fn: fn,
createAt: time.Now().UnixNano(),
interval: interval,
elapse: int64(interval), // first execution will be after interval
counter: counter,
}
// ... | go | {
"resource": ""
} |
q28320 | Stop | train | func (t *Timer) Stop() {
if atomic.LoadInt32(&t.closed) > 0 {
return
}
// guarantee that logic is not blocked
if len(Manager.ChClosingTimer) < timerBacklog {
Manager.ChClosingTimer <- t.ID
atomic.StoreInt32(&t.closed, 1)
} else {
t.counter = 0 // automatically closed in next Cron
}
} | go | {
"resource": ""
} |
q28321 | pexec | train | func pexec(id int64, fn Func) {
defer func() {
if err := recover(); err != nil {
logger.Log.Errorf("Call timer function error, TimerID=%d, Error=%v", id, err)
}
}()
fn()
} | go | {
"resource": ""
} |
q28322 | NewMockPacketEncoder | train | func NewMockPacketEncoder(ctrl *gomock.Controller) *MockPacketEncoder {
mock := &MockPacketEncoder{ctrl: ctrl}
mock.recorder = &MockPacketEncoderMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q28323 | AsJSONString | train | func (s *Server) AsJSONString() string {
str, err := json.Marshal(s)
if err != nil {
logger.Log.Errorf("error getting server as json: %s", err.Error())
return ""
}
return string(str)
} | go | {
"resource": ""
} |
q28324 | RPC | train | func RPC(ctx context.Context, routeStr string, reply proto.Message, arg proto.Message) error {
return doSendRPC(ctx, "", routeStr, reply, arg)
} | go | {
"resource": ""
} |
q28325 | RPCTo | train | func RPCTo(ctx context.Context, serverID, routeStr string, reply proto.Message, arg proto.Message) error {
return doSendRPC(ctx, serverID, routeStr, reply, arg)
} | go | {
"resource": ""
} |
q28326 | ReliableRPC | train | func ReliableRPC(
routeStr string,
metadata map[string]interface{},
reply, arg proto.Message,
) (jid string, err error) {
return app.worker.EnqueueRPC(routeStr, metadata, reply, arg)
} | go | {
"resource": ""
} |
q28327 | ReliableRPCWithOptions | train | func ReliableRPCWithOptions(
routeStr string,
metadata map[string]interface{},
reply, arg proto.Message,
opts *worker.EnqueueOpts,
) (jid string, err error) {
return app.worker.EnqueueRPCWithOptions(routeStr, metadata, reply, arg, opts)
} | go | {
"resource": ""
} |
q28328 | NewGRPCClient | train | func NewGRPCClient(
config *config.Config,
server *Server,
metricsReporters []metrics.Reporter,
bindingStorage interfaces.BindingStorage,
infoRetriever InfoRetriever,
) (*GRPCClient, error) {
gs := &GRPCClient{
config: config,
server: server,
metricsReporters: metricsReporters,
binding... | go | {
"resource": ""
} |
q28329 | Call | train | func (gs *GRPCClient) 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())
}
tags... | go | {
"resource": ""
} |
q28330 | Send | train | func (gs *GRPCClient) Send(uid string, d []byte) error {
return constants.ErrNotImplemented
} | go | {
"resource": ""
} |
q28331 | BroadcastSessionBind | train | func (gs *GRPCClient) BroadcastSessionBind(uid string) error {
if gs.bindingStorage == nil {
return constants.ErrNoBindingStorageModule
}
fid, _ := gs.bindingStorage.GetUserFrontendID(uid, gs.server.Type)
if fid != "" {
if c, ok := gs.clientMap.Load(fid); ok {
msg := &protos.BindMsg{
Uid: uid,
Fid: g... | go | {
"resource": ""
} |
q28332 | SendKick | train | func (gs *GRPCClient) SendKick(userID string, serverType string, kick *protos.KickMsg) error {
var svID string
var err error
if gs.bindingStorage == nil {
return constants.ErrNoBindingStorageModule
}
svID, err = gs.bindingStorage.GetUserFrontendID(userID, serverType)
if err != nil {
return err
}
if c, ok... | go | {
"resource": ""
} |
q28333 | AddServer | train | func (gs *GRPCClient) AddServer(sv *Server) {
var host, port, portKey string
var ok bool
host, portKey = gs.getServerHost(sv)
if host == "" {
logger.Log.Errorf("server %s has no grpcHost specified in metadata", sv.ID)
return
}
if port, ok = sv.Metadata[portKey]; !ok {
logger.Log.Errorf("server %s has no %... | go | {
"resource": ""
} |
q28334 | RemoveServer | train | func (gs *GRPCClient) RemoveServer(sv *Server) {
if _, ok := gs.clientMap.Load(sv.ID); ok {
// TODO: do I need to disconnect client?
gs.clientMap.Delete(sv.ID)
logger.Log.Debugf("[grpc client] removed server %s", sv.ID)
}
} | go | {
"resource": ""
} |
q28335 | Unmarshal | train | func (s *Serializer) Unmarshal(data []byte, v interface{}) error {
return json.Unmarshal(data, v)
} | go | {
"resource": ""
} |
q28336 | HandlerNoArg | train | func (g *MetagameServer) HandlerNoArg(ctx context.Context) (*HandlerNoArgResponse, error) {
return &HandlerNoArgResponse{
Msg: "ok",
}, nil
} | go | {
"resource": ""
} |
q28337 | simpleAfter | train | func (g *MetagameServer) simpleAfter(ctx context.Context, resp interface{}, err error) (interface{}, error) {
logger := pitaya.GetDefaultLoggerFromCtx(ctx)
logger.Infof("Simple After exec - response: %v , error: %v", resp, err)
return resp, err
} | go | {
"resource": ""
} |
q28338 | Register | train | func Register(c component.Component, options ...component.Option) {
handlerComp = append(handlerComp, regComp{c, options})
} | go | {
"resource": ""
} |
q28339 | RegisterRemote | train | func RegisterRemote(c component.Component, options ...component.Option) {
remoteComp = append(remoteComp, regComp{c, options})
} | go | {
"resource": ""
} |
q28340 | GetUserMessagesTopic | train | func GetUserMessagesTopic(uid string, svType string) string {
return fmt.Sprintf("pitaya/%s/user/%s/push", svType, uid)
} | go | {
"resource": ""
} |
q28341 | GetUserKickTopic | train | func GetUserKickTopic(uid string, svType string) string {
return fmt.Sprintf("pitaya/%s/user/%s/kick", svType, uid)
} | go | {
"resource": ""
} |
q28342 | onSessionBind | train | func (ns *NatsRPCServer) onSessionBind(ctx context.Context, s *session.Session) error {
if ns.server.Frontend {
subu, err := ns.subscribeToUserMessages(s.UID(), ns.server.Type)
if err != nil {
return err
}
subk, err := ns.subscribeToUserKickChannel(s.UID(), ns.server.Type)
if err != nil {
return err
... | go | {
"resource": ""
} |
q28343 | Init | train | func (ns *NatsRPCServer) Init() error {
// TODO should we have concurrency here? it feels like we should
go ns.handleMessages()
conn, err := setupNatsConn(ns.connString, ns.appDieChan, nats.MaxReconnects(ns.maxReconnectionRetries))
if err != nil {
return err
}
ns.conn = conn
if ns.sub, err = ns.subscribe(getCh... | go | {
"resource": ""
} |
q28344 | NewRoute | train | func NewRoute(server, service, method string) *Route {
return &Route{server, service, method}
} | go | {
"resource": ""
} |
q28345 | String | train | func (r *Route) String() string {
if r.SvType != "" {
return fmt.Sprintf("%s.%s.%s", r.SvType, r.Service, r.Method)
}
return r.Short()
} | go | {
"resource": ""
} |
q28346 | Short | train | func (r *Route) Short() string {
return fmt.Sprintf("%s.%s", r.Service, r.Method)
} | go | {
"resource": ""
} |
q28347 | Decode | train | func Decode(route string) (*Route, error) {
r := strings.Split(route, ".")
for _, s := range r {
if strings.TrimSpace(s) == "" {
return nil, ErrRouteFieldCantEmpty
}
}
switch len(r) {
case 3:
return NewRoute(r[0], r[1], r[2]), nil
case 2:
return NewRoute("", r[0], r[1]), nil
default:
logger.Log.Erro... | go | {
"resource": ""
} |
q28348 | SetCounter | train | func (*Room) SetCounter(
ctx context.Context,
arg *messages.SetCounterArg,
) (*messages.Response, error) {
counterMetricName := "my_counter"
for _, reporter := range pitaya.GetMetricsReporters() {
reporter.ReportCount(counterMetricName, map[string]string{
"tag1": arg.Tag1,
"tag2": arg.Tag2,
}, arg.Value)... | go | {
"resource": ""
} |
q28349 | SetGauge1 | train | func (*Room) SetGauge1(
ctx context.Context,
arg *messages.SetGaugeArg,
) (*messages.Response, error) {
counterMetricName := "my_gauge_1"
for _, reporter := range pitaya.GetMetricsReporters() {
reporter.ReportGauge(counterMetricName, map[string]string{
"tag1": arg.Tag,
}, arg.Value)
}
return messages.OKR... | go | {
"resource": ""
} |
q28350 | SetSummary | train | func (*Room) SetSummary(
ctx context.Context,
arg *messages.SetSummaryArg,
) (*messages.Response, error) {
counterMetricName := "my_summary"
for _, reporter := range pitaya.GetMetricsReporters() {
reporter.ReportSummary(counterMetricName, map[string]string{
"tag1": arg.Tag,
}, arg.Value)
}
return message... | go | {
"resource": ""
} |
q28351 | NewRemoteService | train | func NewRemoteService(
rpcClient cluster.RPCClient,
rpcServer cluster.RPCServer,
sd cluster.ServiceDiscovery,
encoder codec.PacketEncoder,
serializer serialize.Serializer,
router *router.Router,
messageEncoder message.Encoder,
server *cluster.Server,
) *RemoteService {
return &RemoteService{
services: ... | go | {
"resource": ""
} |
q28352 | AddRemoteBindingListener | train | func (r *RemoteService) AddRemoteBindingListener(bindingListener cluster.RemoteBindingListener) {
r.remoteBindingListeners = append(r.remoteBindingListeners, bindingListener)
} | go | {
"resource": ""
} |
q28353 | Call | train | func (r *RemoteService) Call(ctx context.Context, req *protos.Request) (*protos.Response, error) {
c, err := util.GetContextFromRequest(req, r.server.ID)
var res *protos.Response
if err != nil {
res = &protos.Response{
Error: &protos.Error{
Code: e.ErrInternalCode,
Msg: err.Error(),
},
}
} else {... | go | {
"resource": ""
} |
q28354 | SessionBindRemote | train | func (r *RemoteService) SessionBindRemote(ctx context.Context, msg *protos.BindMsg) (*protos.Response, error) {
for _, r := range r.remoteBindingListeners {
r.OnUserBind(msg.Uid, msg.Fid)
}
return &protos.Response{
Data: []byte("ack"),
}, nil
} | go | {
"resource": ""
} |
q28355 | PushToUser | train | func (r *RemoteService) PushToUser(ctx context.Context, push *protos.Push) (*protos.Response, error) {
logger.Log.Debugf("sending push to user %s: %v", push.GetUid(), string(push.Data))
s := session.GetSessionByUID(push.GetUid())
if s != nil {
err := s.Push(push.Route, push.Data)
if err != nil {
return nil, e... | go | {
"resource": ""
} |
q28356 | KickUser | train | func (r *RemoteService) KickUser(ctx context.Context, kick *protos.KickMsg) (*protos.KickAnswer, error) {
logger.Log.Debugf("sending kick to user %s", kick.GetUserId())
s := session.GetSessionByUID(kick.GetUserId())
if s != nil {
err := s.Kick(ctx)
if err != nil {
return nil, err
}
return &protos.KickAnsw... | go | {
"resource": ""
} |
q28357 | DoRPC | train | func (r *RemoteService) DoRPC(ctx context.Context, serverID string, route *route.Route, protoData []byte) (*protos.Response, error) {
msg := &message.Message{
Type: message.Request,
Route: route.Short(),
Data: protoData,
}
target, _ := r.serviceDiscovery.GetServer(serverID)
if serverID != "" && target == n... | go | {
"resource": ""
} |
q28358 | RPC | train | func (r *RemoteService) RPC(ctx context.Context, serverID string, route *route.Route, reply proto.Message, arg proto.Message) error {
var data []byte
var err error
if arg != nil {
data, err = proto.Marshal(arg)
if err != nil {
return err
}
}
res, err := r.DoRPC(ctx, serverID, route, data)
if err != nil {... | go | {
"resource": ""
} |
q28359 | Docs | train | func (r *RemoteService) Docs(getPtrNames bool) (map[string]interface{}, error) {
if r == nil {
return map[string]interface{}{}, nil
}
return docgenerator.RemotesDocs(r.server.Type, r.services, getPtrNames)
} | go | {
"resource": ""
} |
q28360 | isRemoteMethod | train | func isRemoteMethod(method reflect.Method) bool {
mt := method.Type
// Method must be exported.
if method.PkgPath != "" {
return false
}
// Method needs at least two ins: receiver and context.Context
if mt.NumIn() != 2 && mt.NumIn() != 3 {
return false
}
if t1 := mt.In(1); !t1.Implements(typeOfContext) {
... | go | {
"resource": ""
} |
q28361 | isHandlerMethod | train | func isHandlerMethod(method reflect.Method) bool {
mt := method.Type
// Method must be exported.
if method.PkgPath != "" {
return false
}
// Method needs two or three ins: receiver, context.Context and optional []byte or pointer.
if mt.NumIn() != 2 && mt.NumIn() != 3 {
return false
}
if t1 := mt.In(1); !t... | go | {
"resource": ""
} |
q28362 | BindSession | train | func (s *Sys) BindSession(ctx context.Context, sessionData *protos.Session) (*protos.Response, error) {
sess := session.GetSessionByID(sessionData.Id)
if sess == nil {
return nil, constants.ErrSessionNotFound
}
if err := sess.Bind(ctx, sessionData.Uid); err != nil {
return nil, err
}
return &protos.Response{D... | go | {
"resource": ""
} |
q28363 | Kick | train | func (s *Sys) Kick(ctx context.Context, msg *protos.KickMsg) (*protos.KickAnswer, error) {
res := &protos.KickAnswer{
Kicked: false,
}
sess := session.GetSessionByUID(msg.GetUserId())
if sess == nil {
return res, constants.ErrSessionNotFound
}
err := sess.Kick(ctx)
if err != nil {
return res, err
}
res.K... | go | {
"resource": ""
} |
q28364 | RemoteFunc | train | func (c *ConnectorRemote) RemoteFunc(ctx context.Context, message []byte) (*protos.Response, error) {
fmt.Printf("received a remote call with this message: %s\n", message)
return &protos.Response{
Msg: string(message),
}, nil
} | go | {
"resource": ""
} |
q28365 | RegisterModule | train | func RegisterModule(module interfaces.Module, name string) error {
return RegisterModuleAfter(module, name)
} | go | {
"resource": ""
} |
q28366 | RegisterModuleAfter | train | func RegisterModuleAfter(module interfaces.Module, name string) error {
if err := alreadyRegistered(name); err != nil {
return err
}
modulesMap[name] = module
modulesArr = append(modulesArr, moduleWrapper{
module: module,
name: name,
})
return nil
} | go | {
"resource": ""
} |
q28367 | GetModule | train | func GetModule(name string) (interfaces.Module, error) {
if m, ok := modulesMap[name]; ok {
return m, nil
}
return nil, fmt.Errorf("module with name %s not found", name)
} | go | {
"resource": ""
} |
q28368 | startModules | train | func startModules() {
logger.Log.Debug("initializing all modules")
for _, modWrapper := range modulesArr {
logger.Log.Debugf("initializing module: %s", modWrapper.name)
if err := modWrapper.module.Init(); err != nil {
logger.Log.Fatalf("error starting module %s, error: %s", modWrapper.name, err.Error())
}
}... | go | {
"resource": ""
} |
q28369 | shutdownModules | train | func shutdownModules() {
for i := len(modulesArr) - 1; i >= 0; i-- {
modulesArr[i].module.BeforeShutdown()
}
for i := len(modulesArr) - 1; i >= 0; i-- {
name := modulesArr[i].name
mod := modulesArr[i].module
logger.Log.Debugf("stopping module: %s", name)
if err := mod.Shutdown(); err != nil {
logger.L... | go | {
"resource": ""
} |
q28370 | NewStatsdReporter | train | func NewStatsdReporter(
config *config.Config,
serverType string,
tagsMap map[string]string,
clientOrNil ...Client,
) (*StatsdReporter, error) {
host := config.GetString("pitaya.metrics.statsd.host")
prefix := config.GetString("pitaya.metrics.statsd.prefix")
rate, err := strconv.ParseFloat(config.GetString("pita... | go | {
"resource": ""
} |
q28371 | ReportCount | train | func (s *StatsdReporter) ReportCount(metric string, tagsMap map[string]string, count float64) error {
fullTags := s.defaultTags
for k, v := range tagsMap {
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... | go | {
"resource": ""
} |
q28372 | ReportGauge | train | func (s *StatsdReporter) ReportGauge(metric string, tagsMap map[string]string, value float64) error {
fullTags := s.defaultTags
for k, v := range tagsMap {
fullTags = append(fullTags, fmt.Sprintf("%s:%s", k, v))
}
err := s.client.Gauge(metric, value, fullTags, s.rate)
if err != nil {
logger.Log.Errorf("faile... | go | {
"resource": ""
} |
q28373 | GroupCreate | train | func GroupCreate(ctx context.Context, groupName string) error {
return groupServiceInstance.GroupCreate(ctx, groupName)
} | go | {
"resource": ""
} |
q28374 | GroupCreateWithTTL | train | func GroupCreateWithTTL(ctx context.Context, groupName string, ttlTime time.Duration) error {
return groupServiceInstance.GroupCreateWithTTL(ctx, groupName, ttlTime)
} | go | {
"resource": ""
} |
q28375 | GroupBroadcast | train | func GroupBroadcast(ctx context.Context, frontendType, groupName, route string, v interface{}) error {
logger.Log.Debugf("Type=Broadcast Route=%s, Data=%+v", route, v)
members, err := GroupMembers(ctx, groupName)
if err != nil {
return err
}
return sendDataToMembers(members, frontendType, route, v)
} | go | {
"resource": ""
} |
q28376 | GroupContainsMember | train | func GroupContainsMember(ctx context.Context, groupName, uid string) (bool, error) {
if uid == "" {
return false, constants.ErrEmptyUID
}
return groupServiceInstance.GroupContainsMember(ctx, groupName, uid)
} | go | {
"resource": ""
} |
q28377 | GroupRemoveAll | train | func GroupRemoveAll(ctx context.Context, groupName string) error {
return groupServiceInstance.GroupRemoveAll(ctx, groupName)
} | go | {
"resource": ""
} |
q28378 | GroupRenewTTL | train | func GroupRenewTTL(ctx context.Context, groupName string) error {
return groupServiceInstance.GroupRenewTTL(ctx, groupName)
} | go | {
"resource": ""
} |
q28379 | GroupDelete | train | func GroupDelete(ctx context.Context, groupName string) error {
return groupServiceInstance.GroupDelete(ctx, groupName)
} | go | {
"resource": ""
} |
q28380 | SendPushToUsers | train | func SendPushToUsers(route string, v interface{}, uids []string, frontendType string) ([]string, error) {
data, err := util.SerializeOrRaw(app.serializer, v)
if err != nil {
return uids, err
}
if !app.server.Frontend && frontendType == "" {
return uids, constants.ErrFrontendTypeNotSpecified
}
var notPushedU... | go | {
"resource": ""
} |
q28381 | Init | train | func (gs *GRPCServer) Init() error {
port := gs.config.GetInt("pitaya.cluster.rpc.server.grpc.port")
lis, err := net.Listen("tcp", fmt.Sprintf(":%d", port))
if err != nil {
return err
}
gs.grpcSv = grpc.NewServer()
protos.RegisterPitayaServer(gs.grpcSv, gs.pitayaServer)
go gs.grpcSv.Serve(lis)
return nil
} | go | {
"resource": ""
} |
q28382 | ReportTimingFromCtx | train | func ReportTimingFromCtx(ctx context.Context, reporters []Reporter, typ string, err error) {
code := errors.CodeFromError(err)
status := "ok"
if err != nil {
status = "failed"
}
if len(reporters) > 0 {
startTime := pcontext.GetFromPropagateCtx(ctx, constants.StartTimeKey)
route := pcontext.GetFromPropagateCt... | go | {
"resource": ""
} |
q28383 | ReportMessageProcessDelayFromCtx | train | func ReportMessageProcessDelayFromCtx(ctx context.Context, reporters []Reporter, typ string) {
if len(reporters) > 0 {
startTime := pcontext.GetFromPropagateCtx(ctx, constants.StartTimeKey)
elapsed := time.Since(time.Unix(0, startTime.(int64)))
route := pcontext.GetFromPropagateCtx(ctx, constants.RouteKey)
tag... | go | {
"resource": ""
} |
q28384 | ReportNumberOfConnectedClients | train | func ReportNumberOfConnectedClients(reporters []Reporter, number int64) {
for _, r := range reporters {
r.ReportGauge(ConnectedClients, map[string]string{}, float64(number))
}
} | go | {
"resource": ""
} |
q28385 | ReportSysMetrics | train | func ReportSysMetrics(reporters []Reporter, period time.Duration) {
for {
for _, r := range reporters {
num := runtime.NumGoroutine()
m := &runtime.MemStats{}
runtime.ReadMemStats(m)
r.ReportGauge(Goroutines, map[string]string{}, float64(num))
r.ReportGauge(HeapSize, map[string]string{}, float64(m.Al... | go | {
"resource": ""
} |
q28386 | NewMemoryGroupService | train | func NewMemoryGroupService(conf *config.Config) *MemoryGroupService {
memoryOnce.Do(func() {
memoryGroups = make(map[string]*MemoryGroup)
go groupTTLCleanup(conf)
})
return &MemoryGroupService{}
} | go | {
"resource": ""
} |
q28387 | GroupCreate | train | func (c *MemoryGroupService) GroupCreate(ctx context.Context, groupName string) error {
memoryGroupsMu.Lock()
defer memoryGroupsMu.Unlock()
if _, ok := memoryGroups[groupName]; ok {
return constants.ErrGroupAlreadyExists
}
memoryGroups[groupName] = &MemoryGroup{}
return nil
} | go | {
"resource": ""
} |
q28388 | GroupCreateWithTTL | train | func (c *MemoryGroupService) GroupCreateWithTTL(ctx context.Context, groupName string, ttlTime time.Duration) error {
memoryGroupsMu.Lock()
defer memoryGroupsMu.Unlock()
if _, ok := memoryGroups[groupName]; ok {
return constants.ErrGroupAlreadyExists
}
memoryGroups[groupName] = &MemoryGroup{LastRefresh: time.N... | go | {
"resource": ""
} |
q28389 | GroupMembers | train | func (c *MemoryGroupService) GroupMembers(ctx context.Context, groupName string) ([]string, error) {
memoryGroupsMu.Lock()
defer memoryGroupsMu.Unlock()
mg, ok := memoryGroups[groupName]
if !ok {
return nil, constants.ErrGroupNotFound
}
uids := make([]string, len(mg.Uids))
copy(uids, mg.Uids)
return uids, ... | go | {
"resource": ""
} |
q28390 | GroupContainsMember | train | func (c *MemoryGroupService) GroupContainsMember(ctx context.Context, groupName, uid string) (bool, error) {
memoryGroupsMu.Lock()
defer memoryGroupsMu.Unlock()
mg, ok := memoryGroups[groupName]
if !ok {
return false, constants.ErrGroupNotFound
}
_, contains := elementIndex(mg.Uids, uid)
return contains, nil... | go | {
"resource": ""
} |
q28391 | GroupRemoveMember | train | func (c *MemoryGroupService) GroupRemoveMember(ctx context.Context, groupName, uid string) error {
memoryGroupsMu.Lock()
defer memoryGroupsMu.Unlock()
mg, ok := memoryGroups[groupName]
if !ok {
return constants.ErrGroupNotFound
}
index, contains := elementIndex(mg.Uids, uid)
if contains {
mg.Uids[index] = m... | go | {
"resource": ""
} |
q28392 | GroupRemoveAll | train | func (c *MemoryGroupService) GroupRemoveAll(ctx context.Context, groupName string) error {
memoryGroupsMu.Lock()
defer memoryGroupsMu.Unlock()
mg, ok := memoryGroups[groupName]
if !ok {
return constants.ErrGroupNotFound
}
mg.Uids = []string{}
return nil
} | go | {
"resource": ""
} |
q28393 | GroupDelete | train | func (c *MemoryGroupService) GroupDelete(ctx context.Context, groupName string) error {
memoryGroupsMu.Lock()
defer memoryGroupsMu.Unlock()
_, ok := memoryGroups[groupName]
if !ok {
return constants.ErrGroupNotFound
}
delete(memoryGroups, groupName)
return nil
} | go | {
"resource": ""
} |
q28394 | GroupRenewTTL | train | func (c *MemoryGroupService) GroupRenewTTL(ctx context.Context, groupName string) error {
memoryGroupsMu.Lock()
defer memoryGroupsMu.Unlock()
mg, ok := memoryGroups[groupName]
if !ok {
return constants.ErrGroupNotFound
}
if mg.TTL != 0 {
mg.LastRefresh = time.Now().UnixNano()
memoryGroups[groupName] = mg
... | go | {
"resource": ""
} |
q28395 | NewETCDBindingStorage | train | func NewETCDBindingStorage(server *cluster.Server, conf *config.Config) *ETCDBindingStorage {
b := &ETCDBindingStorage{
config: conf,
thisServer: server,
stopChan: make(chan struct{}),
}
b.configure()
return b
} | go | {
"resource": ""
} |
q28396 | PutBinding | train | func (b *ETCDBindingStorage) PutBinding(uid string) error {
_, err := b.cli.Put(context.Background(), getUserBindingKey(uid, b.thisServer.Type), b.thisServer.ID, clientv3.WithLease(b.leaseID))
return err
} | go | {
"resource": ""
} |
q28397 | Init | train | func (b *ETCDBindingStorage) Init() error {
var cli *clientv3.Client
var err error
if b.cli == nil {
cli, err = clientv3.New(clientv3.Config{
Endpoints: b.etcdEndpoints,
DialTimeout: b.etcdDialTimeout,
})
if err != nil {
return err
}
b.cli = cli
}
// namespaced etcd :)
b.cli.KV = namespace.Ne... | go | {
"resource": ""
} |
q28398 | NewAPIDocsGen | train | func NewAPIDocsGen(basePath string, services []*component.Service) *APIDocsGen {
return &APIDocsGen{
basePath: basePath,
services: services,
}
} | go | {
"resource": ""
} |
q28399 | Init | train | func (a *APIDocsGen) Init() error {
for _, s := range a.services {
logger.Log.Infof("loaded svc: %s", s.Name)
}
return nil
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.