Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "NewMockRPCJob", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockRPCJob", "{", "mock", ":=", "&", "MockRPCJob", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockRPCJobMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

[ "NewMockRPCJob", "creates", "a", "new", "mock", "instance" ]

[ "func", "(", "m", "*", "MockRPCJob", ")", "GetArgReply", "(", "arg0", "string", ")", "(", "proto", ".", "Message", ",", "proto", ".", "Message", ",", "error", ")", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "proto", ".", "Message", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "proto", ".", "Message", ")", "\n", "ret2", ",", "_", ":=", "ret", "[", "2", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", ",", "ret2", "\n", "}" ]

[ "GetArgReply", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockRPCJobMockRecorder", ")", "GetArgReply", "(", "arg0", "interface", "{", "}", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockRPCJob", ")", "(", "nil", ")", ".", "GetArgReply", ")", ",", "arg0", ")", "\n", "}" ]

[ "GetArgReply", "indicates", "an", "expected", "call", "of", "GetArgReply" ]

[ "func", "(", "m", "*", "MockRPCJob", ")", "RPC", "(", "arg0", "context", ".", "Context", ",", "arg1", ",", "arg2", "string", ",", "arg3", ",", "arg4", "proto", ".", "Message", ")", "error", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ",", "arg1", ",", "arg2", ",", "arg3", ",", "arg4", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "error", ")", "\n", "return", "ret0", "\n", "}" ]

[ "RPC", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockRPCJobMockRecorder", ")", "RPC", "(", "arg0", ",", "arg1", ",", "arg2", ",", "arg3", ",", "arg4", "interface", "{", "}", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockRPCJob", ")", "(", "nil", ")", ".", "RPC", ")", ",", "arg0", ",", "arg1", ",", "arg2", ",", "arg3", ",", "arg4", ")", "\n", "}" ]

[ "RPC", "indicates", "an", "expected", "call", "of", "RPC" ]

[ "func", "(", "m", "*", "MockRPCJob", ")", "ServerDiscovery", "(", "arg0", "string", ",", "arg1", "map", "[", "string", "]", "interface", "{", "}", ")", "(", "string", ",", "error", ")", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ",", "arg1", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "string", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "ServerDiscovery", "mocks", "base", "method" ]

[ "func", "(", "v", "*", "DefaultValidator", ")", "Validate", "(", "ctx", "context", ".", "Context", ",", "in", "interface", "{", "}", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "if", "in", "==", "nil", "{", "return", "in", ",", "nil", "\n", "}", "\n\n", "v", ".", "lazyinit", "(", ")", "\n", "if", "err", ":=", "v", ".", "validate", ".", "Struct", "(", "in", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "in", ",", "nil", "\n", "}" ]

[ "Validate", "is", "the", "the", "function", "responsible", "for", "validating", "the", "in", "parameter", "based", "on", "the", "struct", "tags", "the", "parameter", "has", ".", "This", "function", "has", "the", "pipeline", ".", "Handler", "signature", "so", "it", "is", "possible", "to", "use", "it", "as", "a", "pipeline", "function" ]

[ "func", "Configure", "(", "isFrontend", "bool", ",", "serverType", "string", ",", "serverMode", "ServerMode", ",", "serverMetadata", "map", "[", "string", "]", "string", ",", "cfgs", "...", "*", "viper", ".", "Viper", ",", ")", "{", "if", "app", ".", "configured", "{", "logger", ".", "Log", ".", "Warn", "(", "\"", "\"", ")", "\n", "}", "\n", "app", ".", "config", "=", "config", ".", "NewConfig", "(", "cfgs", "...", ")", "\n", "if", "app", ".", "heartbeat", "==", "time", ".", "Duration", "(", "0", ")", "{", "app", ".", "heartbeat", "=", "app", ".", "config", ".", "GetDuration", "(", "\"", "\"", ")", "\n", "}", "\n", "app", ".", "server", ".", "Frontend", "=", "isFrontend", "\n", "app", ".", "server", ".", "Type", "=", "serverType", "\n", "app", ".", "serverMode", "=", "serverMode", "\n", "app", ".", "server", ".", "Metadata", "=", "serverMetadata", "\n", "app", ".", "messageEncoder", "=", "message", ".", "NewMessagesEncoder", "(", "app", ".", "config", ".", "GetBool", "(", "\"", "\"", ")", ")", "\n", "configureMetrics", "(", "serverType", ")", "\n", "configureDefaultPipelines", "(", "app", ".", "config", ")", "\n", "app", ".", "configured", "=", "true", "\n", "}" ]

[ "Configure", "configures", "the", "app" ]

[ "func", "AddAcceptor", "(", "ac", "acceptor", ".", "Acceptor", ")", "{", "if", "!", "app", ".", "server", ".", "Frontend", "{", "logger", ".", "Log", ".", "Error", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "app", ".", "acceptors", "=", "append", "(", "app", ".", "acceptors", ",", "ac", ")", "\n", "}" ]

[ "AddAcceptor", "adds", "a", "new", "acceptor", "to", "app" ]

[ "func", "GetServerByID", "(", "id", "string", ")", "(", "*", "cluster", ".", "Server", ",", "error", ")", "{", "return", "app", ".", "serviceDiscovery", ".", "GetServer", "(", "id", ")", "\n", "}" ]

[ "GetServerByID", "returns", "the", "server", "with", "the", "specified", "id" ]

[ "func", "GetServersByType", "(", "t", "string", ")", "(", "map", "[", "string", "]", "*", "cluster", ".", "Server", ",", "error", ")", "{", "return", "app", ".", "serviceDiscovery", ".", "GetServersByType", "(", "t", ")", "\n", "}" ]

[ "GetServersByType", "get", "all", "servers", "of", "type" ]

[ "func", "AddMetricsReporter", "(", "mr", "metrics", ".", "Reporter", ")", "{", "app", ".", "metricsReporters", "=", "append", "(", "app", ".", "metricsReporters", ",", "mr", ")", "\n", "}" ]

[ "AddMetricsReporter", "to", "be", "used" ]

[ "func", "SetDictionary", "(", "dict", "map", "[", "string", "]", "uint16", ")", "error", "{", "if", "app", ".", "running", "{", "return", "constants", ".", "ErrChangeDictionaryWhileRunning", "\n", "}", "\n", "return", "message", ".", "SetDictionary", "(", "dict", ")", "\n", "}" ]

[ "SetDictionary", "sets", "routes", "map" ]

[ "func", "Error", "(", "err", "error", ",", "code", "string", ",", "metadata", "...", "map", "[", "string", "]", "string", ")", "*", "errors", ".", "Error", "{", "return", "errors", ".", "NewError", "(", "err", ",", "code", ",", "metadata", "...", ")", "\n", "}" ]

[ "Error", "creates", "a", "new", "error", "with", "a", "code", "message", "and", "metadata" ]

[ "func", "GetSessionFromCtx", "(", "ctx", "context", ".", "Context", ")", "*", "session", ".", "Session", "{", "sessionVal", ":=", "ctx", ".", "Value", "(", "constants", ".", "SessionCtxKey", ")", "\n", "if", "sessionVal", "==", "nil", "{", "logger", ".", "Log", ".", "Warn", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n", "return", "sessionVal", ".", "(", "*", "session", ".", "Session", ")", "\n", "}" ]

[ "GetSessionFromCtx", "retrieves", "a", "session", "from", "a", "given", "context" ]

[ "func", "GetDefaultLoggerFromCtx", "(", "ctx", "context", ".", "Context", ")", "logger", ".", "Logger", "{", "return", "ctx", ".", "Value", "(", "constants", ".", "LoggerCtxKey", ")", ".", "(", "logger", ".", "Logger", ")", "\n", "}" ]

[ "GetDefaultLoggerFromCtx", "returns", "the", "default", "logger", "from", "the", "given", "context" ]

[ "func", "AddMetricTagsToPropagateCtx", "(", "ctx", "context", ".", "Context", ",", "tags", "map", "[", "string", "]", "string", ",", ")", "context", ".", "Context", "{", "return", "pcontext", ".", "AddToPropagateCtx", "(", "ctx", ",", "constants", ".", "MetricTagsKey", ",", "tags", ")", "\n", "}" ]

[ "AddMetricTagsToPropagateCtx", "adds", "a", "key", "and", "metric", "tags", "that", "will", "be", "propagated", "through", "RPC", "calls", ".", "Use", "the", "same", "tags", "that", "are", "at", "pitaya", ".", "metrics", ".", "additionalTags", "config" ]

[ "func", "GetFromPropagateCtx", "(", "ctx", "context", ".", "Context", ",", "key", "string", ")", "interface", "{", "}", "{", "return", "pcontext", ".", "GetFromPropagateCtx", "(", "ctx", ",", "key", ")", "\n", "}" ]

[ "GetFromPropagateCtx", "adds", "a", "key", "and", "value", "that", "came", "through", "RPC", "calls" ]

[ "func", "ExtractSpan", "(", "ctx", "context", ".", "Context", ")", "(", "opentracing", ".", "SpanContext", ",", "error", ")", "{", "return", "tracing", ".", "ExtractSpan", "(", "ctx", ")", "\n", "}" ]

[ "ExtractSpan", "retrieves", "an", "opentracing", "span", "context", "from", "the", "given", "context", "The", "span", "context", "can", "be", "received", "directly", "or", "via", "an", "RPC", "call" ]

[ "func", "Documentation", "(", "getPtrNames", "bool", ")", "(", "map", "[", "string", "]", "interface", "{", "}", ",", "error", ")", "{", "handlerDocs", ",", "err", ":=", "handlerService", ".", "Docs", "(", "getPtrNames", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "remoteDocs", ",", "err", ":=", "remoteService", ".", "Docs", "(", "getPtrNames", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "handlerDocs", ",", "\"", "\"", ":", "remoteDocs", ",", "}", ",", "nil", "\n", "}" ]

[ "Documentation", "returns", "handler", "and", "remotes", "documentacion" ]

[ "func", "AddGRPCInfoToMetadata", "(", "metadata", "map", "[", "string", "]", "string", ",", "region", "string", ",", "host", ",", "port", "string", ",", "externalHost", ",", "externalPort", "string", ",", ")", "map", "[", "string", "]", "string", "{", "metadata", "[", "constants", ".", "GRPCHostKey", "]", "=", "host", "\n", "metadata", "[", "constants", ".", "GRPCPortKey", "]", "=", "port", "\n", "metadata", "[", "constants", ".", "GRPCExternalHostKey", "]", "=", "externalHost", "\n", "metadata", "[", "constants", ".", "GRPCExternalPortKey", "]", "=", "externalPort", "\n", "metadata", "[", "constants", ".", "RegionKey", "]", "=", "region", "\n", "return", "metadata", "\n", "}" ]

[ "AddGRPCInfoToMetadata", "adds", "host", "external", "host", "and", "port", "into", "metadata" ]

[ "func", "StartWorker", "(", "config", "*", "config", ".", "Config", ")", "error", "{", "var", "err", "error", "\n", "app", ".", "worker", ",", "err", "=", "worker", ".", "NewWorker", "(", "config", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "app", ".", "worker", ".", "Start", "(", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "StartWorker", "configures", "starts", "and", "returns", "pitaya", "worker" ]

[ "func", "RegisterRPCJob", "(", "rpcJob", "worker", ".", "RPCJob", ")", "error", "{", "err", ":=", "app", ".", "worker", ".", "RegisterRPCJob", "(", "rpcJob", ")", "\n", "return", "err", "\n", "}" ]

[ "RegisterRPCJob", "registers", "rpc", "job", "to", "execute", "jobs", "with", "retries" ]

[ "func", "NewService", "(", "comp", "Component", ",", "opts", "[", "]", "Option", ")", "*", "Service", "{", "s", ":=", "&", "Service", "{", "Type", ":", "reflect", ".", "TypeOf", "(", "comp", ")", ",", "Receiver", ":", "reflect", ".", "ValueOf", "(", "comp", ")", ",", "}", "\n\n", "// apply options", "for", "i", ":=", "range", "opts", "{", "opt", ":=", "opts", "[", "i", "]", "\n", "opt", "(", "&", "s", ".", "Options", ")", "\n", "}", "\n", "if", "name", ":=", "s", ".", "Options", ".", "name", ";", "name", "!=", "\"", "\"", "{", "s", ".", "Name", "=", "name", "\n", "}", "else", "{", "s", ".", "Name", "=", "reflect", ".", "Indirect", "(", "s", ".", "Receiver", ")", ".", "Type", "(", ")", ".", "Name", "(", ")", "\n", "}", "\n\n", "return", "s", "\n", "}" ]

[ "NewService", "creates", "a", "new", "service" ]

[ "func", "(", "h", "*", "Handler", ")", "ValidateMessageType", "(", "msgType", "message", ".", "Type", ")", "(", "exitOnError", "bool", ",", "err", "error", ")", "{", "if", "h", ".", "MessageType", "!=", "msgType", "{", "switch", "msgType", "{", "case", "message", ".", "Request", ":", "err", "=", "constants", ".", "ErrRequestOnNotify", "\n", "exitOnError", "=", "true", "\n\n", "case", "message", ".", "Notify", ":", "err", "=", "constants", ".", "ErrNotifyOnRequest", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "ValidateMessageType", "validates", "a", "given", "message", "type", "against", "the", "handler", "s", "one", "and", "returns", "an", "error", "if", "it", "is", "a", "mismatch", "and", "a", "boolean", "indicating", "if", "the", "caller", "should", "exit", "in", "the", "presence", "of", "this", "error", "or", "not", "." ]

[ "func", "(", "r", "*", "Room", ")", "Init", "(", ")", "{", "gsi", ":=", "groups", ".", "NewMemoryGroupService", "(", "config", ".", "NewConfig", "(", ")", ")", "\n", "pitaya", ".", "InitGroups", "(", "gsi", ")", "\n", "pitaya", ".", "GroupCreate", "(", "context", ".", "Background", "(", ")", ",", "\"", "\"", ")", "\n", "}" ]

[ "Init", "runs", "on", "service", "initialization" ]

[ "func", "LogError", "(", "span", "opentracing", ".", "Span", ",", "message", "string", ")", "{", "span", ".", "SetTag", "(", "\"", "\"", ",", "true", ")", "\n", "span", ".", "LogFields", "(", "log", ".", "String", "(", "\"", "\"", ",", "\"", "\"", ")", ",", "log", ".", "String", "(", "\"", "\"", ",", "message", ")", ",", ")", "\n", "}" ]

[ "LogError", "logs", "an", "error", "to", "an", "opentracing", "span" ]

[ "func", "(", "ns", "*", "NatsRPCClient", ")", "BroadcastSessionBind", "(", "uid", "string", ")", "error", "{", "msg", ":=", "&", "protos", ".", "BindMsg", "{", "Uid", ":", "uid", ",", "Fid", ":", "ns", ".", "server", ".", "ID", ",", "}", "\n", "msgData", ",", "err", ":=", "proto", ".", "Marshal", "(", "msg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "ns", ".", "Send", "(", "GetBindBroadcastTopic", "(", "ns", ".", "server", ".", "Type", ")", ",", "msgData", ")", "\n", "}" ]

[ "BroadcastSessionBind", "sends", "the", "binding", "information", "to", "other", "servers", "that", "may", "br", "interested", "in", "this", "info" ]

[ "func", "(", "ns", "*", "NatsRPCClient", ")", "Send", "(", "topic", "string", ",", "data", "[", "]", "byte", ")", "error", "{", "if", "!", "ns", ".", "running", "{", "return", "constants", ".", "ErrRPCClientNotInitialized", "\n", "}", "\n", "return", "ns", ".", "conn", ".", "Publish", "(", "topic", ",", "data", ")", "\n", "}" ]

[ "Send", "publishes", "a", "message", "in", "a", "given", "topic" ]

[ "func", "(", "ns", "*", "NatsRPCClient", ")", "SendPush", "(", "userID", "string", ",", "frontendSv", "*", "Server", ",", "push", "*", "protos", ".", "Push", ")", "error", "{", "topic", ":=", "GetUserMessagesTopic", "(", "userID", ",", "frontendSv", ".", "Type", ")", "\n", "msg", ",", "err", ":=", "proto", ".", "Marshal", "(", "push", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "ns", ".", "Send", "(", "topic", ",", "msg", ")", "\n", "}" ]

[ "SendPush", "sends", "a", "message", "to", "a", "user" ]

[ "func", "(", "ns", "*", "NatsRPCClient", ")", "SendKick", "(", "userID", "string", ",", "serverType", "string", ",", "kick", "*", "protos", ".", "KickMsg", ")", "error", "{", "topic", ":=", "GetUserKickTopic", "(", "userID", ",", "serverType", ")", "\n", "msg", ",", "err", ":=", "proto", ".", "Marshal", "(", "kick", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "ns", ".", "Send", "(", "topic", ",", "msg", ")", "\n", "}" ]

[ "SendKick", "kicks", "an", "user" ]

[ "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", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Log", ".", "Warnf", "(", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "tags", ":=", "opentracing", ".", "Tags", "{", "\"", "\"", ":", "\"", "\"", ",", "\"", "\"", ":", "ns", ".", "server", ".", "ID", ",", "\"", "\"", ":", "server", ".", "Type", ",", "\"", "\"", ":", "server", ".", "ID", ",", "}", "\n", "ctx", "=", "tracing", ".", "StartSpan", "(", "ctx", ",", "\"", "\"", ",", "tags", ",", "parent", ")", "\n", "defer", "tracing", ".", "FinishSpan", "(", "ctx", ",", "err", ")", "\n\n", "if", "!", "ns", ".", "running", "{", "err", "=", "constants", ".", "ErrRPCClientNotInitialized", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "req", ",", "err", ":=", "buildRequest", "(", "ctx", ",", "rpcType", ",", "route", ",", "session", ",", "msg", ",", "ns", ".", "server", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "marshalledData", ",", "err", ":=", "proto", ".", "Marshal", "(", "&", "req", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "var", "m", "*", "nats", ".", "Msg", "\n\n", "if", "ns", ".", "metricsReporters", "!=", "nil", "{", "startTime", ":=", "time", ".", "Now", "(", ")", "\n", "ctx", "=", "pcontext", ".", "AddToPropagateCtx", "(", "ctx", ",", "constants", ".", "StartTimeKey", ",", "startTime", ".", "UnixNano", "(", ")", ")", "\n", "ctx", "=", "pcontext", ".", "AddToPropagateCtx", "(", "ctx", ",", "constants", ".", "RouteKey", ",", "route", ".", "String", "(", ")", ")", "\n", "defer", "func", "(", ")", "{", "typ", ":=", "\"", "\"", "\n", "metrics", ".", "ReportTimingFromCtx", "(", "ctx", ",", "ns", ".", "metricsReporters", ",", "typ", ",", "err", ")", "\n", "}", "(", ")", "\n", "}", "\n", "m", ",", "err", "=", "ns", ".", "conn", ".", "Request", "(", "getChannel", "(", "server", ".", "Type", ",", "server", ".", "ID", ")", ",", "marshalledData", ",", "ns", ".", "reqTimeout", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "res", ":=", "&", "protos", ".", "Response", "{", "}", "\n", "err", "=", "proto", ".", "Unmarshal", "(", "m", ".", "Data", ",", "res", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "res", ".", "Error", "!=", "nil", "{", "if", "res", ".", "Error", ".", "Code", "==", "\"", "\"", "{", "res", ".", "Error", ".", "Code", "=", "errors", ".", "ErrUnknownCode", "\n", "}", "\n", "err", "=", "&", "errors", ".", "Error", "{", "Code", ":", "res", ".", "Error", ".", "Code", ",", "Message", ":", "res", ".", "Error", ".", "Msg", ",", "Metadata", ":", "res", ".", "Error", ".", "Metadata", ",", "}", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "return", "res", ",", "nil", "\n", "}" ]

[ "Call", "calls", "a", "method", "remotelly" ]

[ "func", "(", "ns", "*", "NatsRPCClient", ")", "Init", "(", ")", "error", "{", "ns", ".", "running", "=", "true", "\n", "conn", ",", "err", ":=", "setupNatsConn", "(", "ns", ".", "connString", ",", "ns", ".", "appDieChan", ",", "nats", ".", "MaxReconnects", "(", "ns", ".", "maxReconnectionRetries", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "ns", ".", "conn", "=", "conn", "\n", "return", "nil", "\n", "}" ]

[ "Init", "inits", "nats", "rpc", "client" ]

[ "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", "{", "}", ")", ",", "reply", ":", "reply", ",", "// TODO this is totally coupled with NATS", "serializer", ":", "serializer", ",", "encoder", ":", "encoder", ",", "rpcClient", ":", "rpcClient", ",", "serviceDiscovery", ":", "serviceDiscovery", ",", "frontendID", ":", "frontendID", ",", "messageEncoder", ":", "messageEncoder", ",", "}", "\n\n", "// binding session", "s", ":=", "session", ".", "New", "(", "a", ",", "false", ",", "sess", ".", "GetUid", "(", ")", ")", "\n", "s", ".", "SetFrontendData", "(", "frontendID", ",", "sess", ".", "GetId", "(", ")", ")", "\n", "err", ":=", "s", ".", "SetDataEncoded", "(", "sess", ".", "GetData", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "a", ".", "Session", "=", "s", "\n\n", "return", "a", ",", "nil", "\n", "}" ]

[ "NewRemote", "create", "new", "Remote", "instance" ]

[ "func", "(", "a", "*", "Remote", ")", "Push", "(", "route", "string", ",", "v", "interface", "{", "}", ")", "error", "{", "if", "(", "reflect", ".", "TypeOf", "(", "a", ".", "rpcClient", ")", "==", "reflect", ".", "TypeOf", "(", "&", "cluster", ".", "NatsRPCClient", "{", "}", ")", "&&", "a", ".", "Session", ".", "UID", "(", ")", "==", "\"", "\"", ")", "{", "return", "constants", ".", "ErrNoUIDBind", "\n", "}", "\n", "switch", "d", ":=", "v", ".", "(", "type", ")", "{", "case", "[", "]", "byte", ":", "logger", ".", "Log", ".", "Debugf", "(", "\"", "\"", ",", "a", ".", "Session", ".", "ID", "(", ")", ",", "a", ".", "Session", ".", "UID", "(", ")", ",", "route", ",", "len", "(", "d", ")", ")", "\n", "default", ":", "logger", ".", "Log", ".", "Debugf", "(", "\"", "\"", ",", "a", ".", "Session", ".", "ID", "(", ")", ",", "a", ".", "Session", ".", "UID", "(", ")", ",", "route", ",", "v", ")", "\n", "}", "\n\n", "sv", ",", "err", ":=", "a", ".", "serviceDiscovery", ".", "GetServer", "(", "a", ".", "frontendID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "a", ".", "sendPush", "(", "pendingMessage", "{", "typ", ":", "message", ".", "Push", ",", "route", ":", "route", ",", "payload", ":", "v", "}", ",", "a", ".", "Session", ".", "UID", "(", ")", ",", "sv", ",", ")", "\n", "}" ]

[ "Push", "pushes", "the", "message", "to", "the", "user" ]

[ "func", "(", "a", "*", "Remote", ")", "ResponseMID", "(", "ctx", "context", ".", "Context", ",", "mid", "uint", ",", "v", "interface", "{", "}", ",", "isError", "...", "bool", ")", "error", "{", "err", ":=", "false", "\n", "if", "len", "(", "isError", ")", ">", "0", "{", "err", "=", "isError", "[", "0", "]", "\n", "}", "\n\n", "if", "mid", "<=", "0", "{", "return", "constants", ".", "ErrSessionOnNotify", "\n", "}", "\n\n", "switch", "d", ":=", "v", ".", "(", "type", ")", "{", "case", "[", "]", "byte", ":", "logger", ".", "Log", ".", "Debugf", "(", "\"", "\"", ",", "a", ".", "Session", ".", "ID", "(", ")", ",", "mid", ",", "len", "(", "d", ")", ")", "\n", "default", ":", "logger", ".", "Log", ".", "Infof", "(", "\"", "\"", ",", "a", ".", "Session", ".", "ID", "(", ")", ",", "mid", ",", "v", ")", "\n", "}", "\n\n", "return", "a", ".", "send", "(", "pendingMessage", "{", "ctx", ":", "ctx", ",", "typ", ":", "message", ".", "Response", ",", "mid", ":", "mid", ",", "payload", ":", "v", ",", "err", ":", "err", "}", ",", "a", ".", "reply", ")", "\n", "}" ]

[ "ResponseMID", "reponds", "the", "message", "with", "mid", "to", "the", "user" ]

[ "func", "CodeFromError", "(", "err", "error", ")", "string", "{", "if", "err", "==", "nil", "{", "return", "\"", "\"", "\n", "}", "\n\n", "pitayaErr", ",", "ok", ":=", "err", ".", "(", "*", "Error", ")", "\n", "if", "!", "ok", "{", "return", "ErrUnknownCode", "\n", "}", "\n\n", "if", "pitayaErr", "==", "nil", "{", "return", "\"", "\"", "\n", "}", "\n\n", "return", "pitayaErr", ".", "Code", "\n", "}" ]

[ "CodeFromError", "returns", "the", "code", "of", "error", ".", "If", "error", "is", "nil", "return", "empty", "string", ".", "If", "error", "is", "not", "a", "pitaya", "error", "returns", "unkown", "code" ]

[ "func", "NewTimer", "(", "interval", "time", ".", "Duration", ",", "fn", "timer", ".", "Func", ")", "*", "timer", ".", "Timer", "{", "return", "NewCountTimer", "(", "interval", ",", "timer", ".", "LoopForever", ",", "fn", ")", "\n", "}" ]

[ "NewTimer", "returns", "a", "new", "Timer", "containing", "a", "function", "that", "will", "be", "called", "with", "a", "period", "specified", "by", "the", "duration", "argument", ".", "It", "adjusts", "the", "intervals", "for", "slow", "receivers", ".", "The", "duration", "d", "must", "be", "greater", "than", "zero", ";", "if", "not", "NewTimer", "will", "panic", ".", "Stop", "the", "timer", "to", "release", "associated", "resources", "." ]

[ "func", "NewCountTimer", "(", "interval", "time", ".", "Duration", ",", "count", "int", ",", "fn", "timer", ".", "Func", ")", "*", "timer", ".", "Timer", "{", "if", "fn", "==", "nil", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "interval", "<=", "0", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "t", ":=", "timer", ".", "NewTimer", "(", "fn", ",", "interval", ",", "count", ")", "\n", "// add to manager", "timer", ".", "Manager", ".", "ChCreatedTimer", "<-", "t", "\n", "return", "t", "\n", "}" ]

[ "NewCountTimer", "returns", "a", "new", "Timer", "containing", "a", "function", "that", "will", "be", "called", "with", "a", "period", "specified", "by", "the", "duration", "argument", ".", "After", "count", "times", "timer", "will", "be", "stopped", "automatically", "It", "adjusts", "the", "intervals", "for", "slow", "receivers", ".", "The", "duration", "d", "must", "be", "greater", "than", "zero", ";", "if", "not", "NewCountTimer", "will", "panic", ".", "Stop", "the", "timer", "to", "release", "associated", "resources", "." ]

[ "func", "NewAfterTimer", "(", "duration", "time", ".", "Duration", ",", "fn", "timer", ".", "Func", ")", "*", "timer", ".", "Timer", "{", "return", "NewCountTimer", "(", "duration", ",", "1", ",", "fn", ")", "\n", "}" ]

[ "NewAfterTimer", "returns", "a", "new", "Timer", "containing", "a", "function", "that", "will", "be", "called", "after", "duration", "that", "specified", "by", "the", "duration", "argument", ".", "The", "duration", "d", "must", "be", "greater", "than", "zero", ";", "if", "not", "NewAfterTimer", "will", "panic", ".", "Stop", "the", "timer", "to", "release", "associated", "resources", "." ]

[ "func", "NewCondTimer", "(", "condition", "timer", ".", "Condition", ",", "fn", "timer", ".", "Func", ")", "(", "*", "timer", ".", "Timer", ",", "error", ")", "{", "if", "condition", "==", "nil", "{", "return", "nil", ",", "constants", ".", "ErrNilCondition", "\n", "}", "\n\n", "t", ":=", "NewCountTimer", "(", "time", ".", "Duration", "(", "math", ".", "MaxInt64", ")", ",", "timer", ".", "LoopForever", ",", "fn", ")", "\n", "t", ".", "SetCondition", "(", "condition", ")", "\n", "return", "t", ",", "nil", "\n", "}" ]

[ "NewCondTimer", "returns", "a", "new", "Timer", "containing", "a", "function", "that", "will", "be", "called", "when", "condition", "satisfied", "that", "specified", "by", "the", "condition", "argument", ".", "The", "duration", "d", "must", "be", "greater", "than", "zero", ";", "if", "not", "NewCondTimer", "will", "panic", ".", "Stop", "the", "timer", "to", "release", "associated", "resources", "." ]

[ "func", "SetTimerPrecision", "(", "precision", "time", ".", "Duration", ")", "{", "if", "precision", "<", "time", ".", "Millisecond", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "timer", ".", "Precision", "=", "precision", "\n", "}" ]

[ "SetTimerPrecision", "set", "the", "ticker", "precision", "and", "time", "precision", "can", "not", "less", "than", "a", "Millisecond", "and", "can", "not", "change", "after", "application", "running", ".", "The", "default", "precision", "is", "time", ".", "Second" ]

[ "func", "(", "c", "*", "Connector", ")", "NotifySessionData", "(", "ctx", "context", ".", "Context", ",", "data", "*", "SessionData", ")", "{", "s", ":=", "pitaya", ".", "GetSessionFromCtx", "(", "ctx", ")", "\n", "err", ":=", "s", ".", "SetData", "(", "data", ".", "Data", ")", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Println", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}" ]

[ "NotifySessionData", "sets", "the", "session", "data" ]

[ "func", "(", "c", "*", "ConnectorRemote", ")", "Docs", "(", "ctx", "context", ".", "Context", ",", "ddd", "*", "protos", ".", "Doc", ")", "(", "*", "protos", ".", "Doc", ",", "error", ")", "{", "d", ",", "err", ":=", "pitaya", ".", "Documentation", "(", "true", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "doc", ",", "err", ":=", "json", ".", "Marshal", "(", "d", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "protos", ".", "Doc", "{", "Doc", ":", "string", "(", "doc", ")", "}", ",", "nil", "\n", "}" ]

[ "Docs", "returns", "documentation" ]

[ "func", "NewTCPAcceptor", "(", "addr", "string", ",", "certs", "...", "string", ")", "*", "TCPAcceptor", "{", "keyFile", ":=", "\"", "\"", "\n", "certFile", ":=", "\"", "\"", "\n", "if", "len", "(", "certs", ")", "!=", "2", "&&", "len", "(", "certs", ")", "!=", "0", "{", "panic", "(", "constants", ".", "ErrInvalidCertificates", ")", "\n", "}", "else", "if", "len", "(", "certs", ")", "==", "2", "{", "certFile", "=", "certs", "[", "0", "]", "\n", "keyFile", "=", "certs", "[", "1", "]", "\n", "}", "\n\n", "return", "&", "TCPAcceptor", "{", "addr", ":", "addr", ",", "connChan", ":", "make", "(", "chan", "net", ".", "Conn", ")", ",", "running", ":", "false", ",", "certFile", ":", "certFile", ",", "keyFile", ":", "keyFile", ",", "}", "\n", "}" ]

[ "NewTCPAcceptor", "creates", "a", "new", "instance", "of", "tcp", "acceptor" ]

[ "func", "(", "a", "*", "TCPAcceptor", ")", "ListenAndServe", "(", ")", "{", "if", "a", ".", "hasTLSCertificates", "(", ")", "{", "a", ".", "ListenAndServeTLS", "(", "a", ".", "certFile", ",", "a", ".", "keyFile", ")", "\n", "return", "\n", "}", "\n\n", "listener", ",", "err", ":=", "net", ".", "Listen", "(", "\"", "\"", ",", "a", ".", "addr", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Log", ".", "Fatalf", "(", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "a", ".", "listener", "=", "listener", "\n", "a", ".", "running", "=", "true", "\n", "a", ".", "serve", "(", ")", "\n", "}" ]

[ "ListenAndServe", "using", "tcp", "acceptor" ]

[ "func", "(", "a", "*", "TCPAcceptor", ")", "ListenAndServeTLS", "(", "cert", ",", "key", "string", ")", "{", "crt", ",", "err", ":=", "tls", ".", "LoadX509KeyPair", "(", "cert", ",", "key", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Log", ".", "Fatalf", "(", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n\n", "tlsCfg", ":=", "&", "tls", ".", "Config", "{", "Certificates", ":", "[", "]", "tls", ".", "Certificate", "{", "crt", "}", "}", "\n\n", "listener", ",", "err", ":=", "tls", ".", "Listen", "(", "\"", "\"", ",", "a", ".", "addr", ",", "tlsCfg", ")", "\n", "a", ".", "listener", "=", "listener", "\n", "a", ".", "running", "=", "true", "\n", "a", ".", "serve", "(", ")", "\n", "}" ]

[ "ListenAndServeTLS", "listens", "using", "tls" ]

[ "func", "NewWSAcceptor", "(", "addr", "string", ",", "certs", "...", "string", ")", "*", "WSAcceptor", "{", "keyFile", ":=", "\"", "\"", "\n", "certFile", ":=", "\"", "\"", "\n", "if", "len", "(", "certs", ")", "!=", "2", "&&", "len", "(", "certs", ")", "!=", "0", "{", "panic", "(", "constants", ".", "ErrInvalidCertificates", ")", "\n", "}", "else", "if", "len", "(", "certs", ")", "==", "2", "{", "certFile", "=", "certs", "[", "0", "]", "\n", "keyFile", "=", "certs", "[", "1", "]", "\n", "}", "\n\n", "w", ":=", "&", "WSAcceptor", "{", "addr", ":", "addr", ",", "connChan", ":", "make", "(", "chan", "net", ".", "Conn", ")", ",", "certFile", ":", "certFile", ",", "keyFile", ":", "keyFile", ",", "}", "\n", "return", "w", "\n", "}" ]

[ "NewWSAcceptor", "returns", "a", "new", "instance", "of", "WSAcceptor" ]

[ "func", "(", "w", "*", "WSAcceptor", ")", "ListenAndServe", "(", ")", "{", "if", "w", ".", "hasTLSCertificates", "(", ")", "{", "w", ".", "ListenAndServeTLS", "(", "w", ".", "certFile", ",", "w", ".", "keyFile", ")", "\n", "return", "\n", "}", "\n\n", "var", "upgrader", "=", "websocket", ".", "Upgrader", "{", "ReadBufferSize", ":", "1024", ",", "WriteBufferSize", ":", "1024", ",", "CheckOrigin", ":", "func", "(", "r", "*", "http", ".", "Request", ")", "bool", "{", "return", "true", "\n", "}", ",", "}", "\n\n", "listener", ",", "err", ":=", "net", ".", "Listen", "(", "\"", "\"", ",", "w", ".", "addr", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Log", ".", "Fatalf", "(", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "w", ".", "listener", "=", "listener", "\n\n", "w", ".", "serve", "(", "&", "upgrader", ")", "\n", "}" ]

[ "ListenAndServe", "listens", "and", "serve", "in", "the", "specified", "addr" ]

[ "func", "(", "w", "*", "WSAcceptor", ")", "ListenAndServeTLS", "(", "cert", ",", "key", "string", ")", "{", "var", "upgrader", "=", "websocket", ".", "Upgrader", "{", "ReadBufferSize", ":", "1024", ",", "WriteBufferSize", ":", "1024", ",", "}", "\n\n", "crt", ",", "err", ":=", "tls", ".", "LoadX509KeyPair", "(", "cert", ",", "key", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Log", ".", "Fatalf", "(", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n\n", "tlsCfg", ":=", "&", "tls", ".", "Config", "{", "Certificates", ":", "[", "]", "tls", ".", "Certificate", "{", "crt", "}", "}", "\n", "listener", ",", "err", ":=", "tls", ".", "Listen", "(", "\"", "\"", ",", "w", ".", "addr", ",", "tlsCfg", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Log", ".", "Fatalf", "(", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "w", ".", "listener", "=", "listener", "\n", "w", ".", "serve", "(", "&", "upgrader", ")", "\n", "}" ]

[ "ListenAndServeTLS", "listens", "and", "serve", "in", "the", "specified", "addr", "using", "tls" ]

[ "func", "(", "w", "*", "WSAcceptor", ")", "Stop", "(", ")", "{", "err", ":=", "w", ".", "listener", ".", "Close", "(", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Log", ".", "Errorf", "(", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "}" ]

[ "Stop", "stops", "the", "acceptor" ]

[ "func", "New", "(", "logLevel", "logrus", ".", "Level", ",", "requestTimeout", "...", "time", ".", "Duration", ")", "*", "Client", "{", "l", ":=", "logrus", ".", "New", "(", ")", "\n", "l", ".", "Formatter", "=", "&", "logrus", ".", "TextFormatter", "{", "}", "\n", "l", ".", "SetLevel", "(", "logLevel", ")", "\n\n", "logger", ".", "Log", "=", "l", "\n\n", "reqTimeout", ":=", "5", "*", "time", ".", "Second", "\n", "if", "len", "(", "requestTimeout", ")", ">", "0", "{", "reqTimeout", "=", "requestTimeout", "[", "0", "]", "\n", "}", "\n\n", "return", "&", "Client", "{", "Connected", ":", "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 probably be configurable", "pendingChan", ":", "make", "(", "chan", "bool", ",", "30", ")", ",", "messageEncoder", ":", "message", ".", "NewMessagesEncoder", "(", "true", ")", ",", "}", "\n", "}" ]

[ "New", "returns", "a", "new", "client" ]

[ "func", "(", "c", "*", "Client", ")", "pendingRequestsReaper", "(", ")", "{", "ticker", ":=", "time", ".", "NewTicker", "(", "1", "*", "time", ".", "Second", ")", "\n", "defer", "ticker", ".", "Stop", "(", ")", "\n", "for", "{", "select", "{", "case", "<-", "ticker", ".", "C", ":", "toDelete", ":=", "make", "(", "[", "]", "*", "pendingRequest", ",", "0", ")", "\n", "c", ".", "pendingReqMutex", ".", "Lock", "(", ")", "\n", "for", "_", ",", "v", ":=", "range", "c", ".", "pendingRequests", "{", "if", "time", ".", "Now", "(", ")", ".", "Sub", "(", "v", ".", "sentAt", ")", ">", "c", ".", "requestTimeout", "{", "toDelete", "=", "append", "(", "toDelete", ",", "v", ")", "\n", "}", "\n", "}", "\n", "for", "_", ",", "pendingReq", ":=", "range", "toDelete", "{", "err", ":=", "pitaya", ".", "Error", "(", "errors", ".", "New", "(", "\"", "\"", ")", ",", "\"", "\"", ")", "\n", "errMarshalled", ",", "_", ":=", "json", ".", "Marshal", "(", "err", ")", "\n", "// send a timeout to incoming msg chan", "m", ":=", "&", "message", ".", "Message", "{", "Type", ":", "message", ".", "Response", ",", "ID", ":", "pendingReq", ".", "msg", ".", "ID", ",", "Route", ":", "pendingReq", ".", "msg", ".", "Route", ",", "Data", ":", "errMarshalled", ",", "Err", ":", "true", ",", "}", "\n", "delete", "(", "c", ".", "pendingRequests", ",", "pendingReq", ".", "msg", ".", "ID", ")", "\n", "<-", "c", ".", "pendingChan", "\n", "c", ".", "IncomingMsgChan", "<-", "m", "\n", "}", "\n", "c", ".", "pendingReqMutex", ".", "Unlock", "(", ")", "\n", "case", "<-", "c", ".", "closeChan", ":", "return", "\n", "}", "\n", "}", "\n", "}" ]

[ "pendingRequestsReaper", "delete", "timedout", "requests" ]

[ "func", "(", "c", "*", "Client", ")", "Disconnect", "(", ")", "{", "if", "c", ".", "Connected", "{", "c", ".", "Connected", "=", "false", "\n", "close", "(", "c", ".", "closeChan", ")", "\n", "c", ".", "conn", ".", "Close", "(", ")", "\n", "}", "\n", "}" ]

[ "Disconnect", "disconnects", "the", "client" ]

[ "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", ",", "}", "\n", "p", ",", "err", ":=", "c", ".", "buildPacket", "(", "m", ")", "\n", "if", "msgType", "==", "message", ".", "Request", "{", "c", ".", "pendingChan", "<-", "true", "\n", "c", ".", "pendingReqMutex", ".", "Lock", "(", ")", "\n", "if", "_", ",", "ok", ":=", "c", ".", "pendingRequests", "[", "m", ".", "ID", "]", ";", "!", "ok", "{", "c", ".", "pendingRequests", "[", "m", ".", "ID", "]", "=", "&", "pendingRequest", "{", "msg", ":", "&", "m", ",", "sentAt", ":", "time", ".", "Now", "(", ")", ",", "}", "\n", "}", "\n", "c", ".", "pendingReqMutex", ".", "Unlock", "(", ")", "\n", "}", "\n\n", "if", "err", "!=", "nil", "{", "return", "m", ".", "ID", ",", "err", "\n", "}", "\n", "_", ",", "err", "=", "c", ".", "conn", ".", "Write", "(", "p", ")", "\n", "return", "m", ".", "ID", ",", "err", "\n", "}" ]

[ "sendMsg", "sends", "the", "request", "to", "the", "server" ]

[ "func", "NewMockServiceDiscovery", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockServiceDiscovery", "{", "mock", ":=", "&", "MockServiceDiscovery", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockServiceDiscoveryMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

[ "NewMockServiceDiscovery", "creates", "a", "new", "mock", "instance" ]

[ "func", "(", "m", "*", "MockServiceDiscovery", ")", "GetServersByType", "(", "serverType", "string", ")", "(", "map", "[", "string", "]", "*", "cluster", ".", "Server", ",", "error", ")", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "serverType", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "map", "[", "string", "]", "*", "cluster", ".", "Server", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "GetServersByType", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockServiceDiscoveryMockRecorder", ")", "GetServersByType", "(", "serverType", "interface", "{", "}", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockServiceDiscovery", ")", "(", "nil", ")", ".", "GetServersByType", ")", ",", "serverType", ")", "\n", "}" ]

[ "GetServersByType", "indicates", "an", "expected", "call", "of", "GetServersByType" ]

[ "func", "(", "m", "*", "MockServiceDiscovery", ")", "GetServer", "(", "id", "string", ")", "(", "*", "cluster", ".", "Server", ",", "error", ")", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "id", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "*", "cluster", ".", "Server", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "GetServer", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockServiceDiscoveryMockRecorder", ")", "GetServer", "(", "id", "interface", "{", "}", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockServiceDiscovery", ")", "(", "nil", ")", ".", "GetServer", ")", ",", "id", ")", "\n", "}" ]

[ "GetServer", "indicates", "an", "expected", "call", "of", "GetServer" ]

[ "func", "(", "m", "*", "MockServiceDiscovery", ")", "GetServers", "(", ")", "[", "]", "*", "cluster", ".", "Server", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "[", "]", "*", "cluster", ".", "Server", ")", "\n", "return", "ret0", "\n", "}" ]

[ "GetServers", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockServiceDiscovery", ")", "AddListener", "(", "listener", "cluster", ".", "SDListener", ")", "{", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "listener", ")", "\n", "}" ]

[ "AddListener", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockServiceDiscoveryMockRecorder", ")", "AddListener", "(", "listener", "interface", "{", "}", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockServiceDiscovery", ")", "(", "nil", ")", ".", "AddListener", ")", ",", "listener", ")", "\n", "}" ]

[ "AddListener", "indicates", "an", "expected", "call", "of", "AddListener" ]

[ "func", "NewMockEncoder", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockEncoder", "{", "mock", ":=", "&", "MockEncoder", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockEncoderMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

[ "NewMockEncoder", "creates", "a", "new", "mock", "instance" ]

[ "func", "(", "m", "*", "MockEncoder", ")", "IsCompressionEnabled", "(", ")", "bool", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "bool", ")", "\n", "return", "ret0", "\n", "}" ]

[ "IsCompressionEnabled", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockEncoderMockRecorder", ")", "IsCompressionEnabled", "(", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockEncoder", ")", "(", "nil", ")", ".", "IsCompressionEnabled", ")", ")", "\n", "}" ]

[ "IsCompressionEnabled", "indicates", "an", "expected", "call", "of", "IsCompressionEnabled" ]

[ "func", "(", "c", "*", "Connector", ")", "SendPushToUser", "(", "ctx", "context", ".", "Context", ",", "msg", "*", "UserMessage", ")", "(", "*", "Response", ",", "error", ")", "{", "_", ",", "err", ":=", "pitaya", ".", "SendPushToUsers", "(", "\"", "\"", ",", "msg", ",", "[", "]", "string", "{", "\"", "\"", "}", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "Response", "{", "Code", ":", "200", ",", "Msg", ":", "\"", "\"", ",", "}", ",", "nil", "\n", "}" ]

[ "SendPushToUser", "sends", "a", "push", "to", "a", "user" ]

[ "func", "(", "c", "*", "ConnectorRemote", ")", "RemoteFunc", "(", "ctx", "context", ".", "Context", ",", "msg", "*", "protos", ".", "RPCMsg", ")", "(", "*", "protos", ".", "RPCRes", ",", "error", ")", "{", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "msg", ")", "\n", "return", "&", "protos", ".", "RPCRes", "{", "Msg", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "msg", ".", "GetMsg", "(", ")", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "RemoteFunc", "is", "a", "function", "that", "will", "be", "called", "remotely" ]

[ "func", "GetFreePort", "(", "t", "testing", ".", "TB", ")", "int", "{", "t", ".", "Helper", "(", ")", "\n", "addr", ",", "err", ":=", "net", ".", "ResolveTCPAddr", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "t", ".", "Fatal", "(", "err", ")", "\n", "}", "\n\n", "l", ",", "err", ":=", "net", ".", "ListenTCP", "(", "\"", "\"", ",", "addr", ")", "\n", "if", "err", "!=", "nil", "{", "t", ".", "Fatal", "(", "err", ")", "\n", "}", "\n", "defer", "l", ".", "Close", "(", ")", "\n", "return", "l", ".", "Addr", "(", ")", ".", "(", "*", "net", ".", "TCPAddr", ")", ".", "Port", "\n", "}" ]

[ "GetFreePort", "returns", "a", "free", "port" ]

[ "func", "GetMapKeys", "(", "t", "*", "testing", ".", "T", ",", "m", "interface", "{", "}", ")", "[", "]", "string", "{", "if", "reflect", ".", "ValueOf", "(", "m", ")", ".", "Kind", "(", ")", "!=", "reflect", ".", "Map", "{", "t", ".", "Fatal", "(", "errors", ".", "New", "(", "\"", "\"", ")", ")", "\n", "}", "\n", "if", "reflect", ".", "TypeOf", "(", "m", ")", ".", "Key", "(", ")", "!=", "reflect", ".", "TypeOf", "(", "\"", "\"", ")", "{", "t", ".", "Fatal", "(", "errors", ".", "New", "(", "\"", "\"", ")", ")", "\n", "}", "\n", "t", ".", "Helper", "(", ")", "\n", "res", ":=", "make", "(", "[", "]", "string", ",", "0", ")", "\n", "for", "_", ",", "k", ":=", "range", "reflect", ".", "ValueOf", "(", "m", ")", ".", "MapKeys", "(", ")", "{", "res", "=", "append", "(", "res", ",", "k", ".", "String", "(", ")", ")", "\n", "}", "\n", "return", "res", "\n", "}" ]

[ "GetMapKeys", "returns", "a", "string", "slice", "with", "the", "map", "keys" ]

[ "func", "WriteFile", "(", "t", "*", "testing", ".", "T", ",", "filepath", "string", ",", "bytes", "[", "]", "byte", ")", "{", "t", ".", "Helper", "(", ")", "\n", "if", "err", ":=", "ioutil", ".", "WriteFile", "(", "filepath", ",", "bytes", ",", "0644", ")", ";", "err", "!=", "nil", "{", "t", ".", "Fatalf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}" ]

[ "WriteFile", "test", "helper" ]

[ "func", "ReadFile", "(", "t", "*", "testing", ".", "T", ",", "filepath", "string", ")", "[", "]", "byte", "{", "t", ".", "Helper", "(", ")", "\n", "b", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "filepath", ")", "\n", "if", "err", "!=", "nil", "{", "t", ".", "Fatalf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "b", "\n", "}" ]

[ "ReadFile", "test", "helper" ]

[ "func", "StartProcess", "(", "t", "testing", ".", "TB", ",", "program", "string", ",", "args", "...", "string", ")", "*", "exec", ".", "Cmd", "{", "t", ".", "Helper", "(", ")", "\n", "return", "exec", ".", "Command", "(", "program", ",", "args", "...", ")", "\n", "}" ]

[ "StartProcess", "starts", "a", "process" ]

[ "func", "StartServer", "(", "t", "testing", ".", "TB", ",", "frontend", "bool", ",", "debug", "bool", ",", "svType", "string", ",", "port", "int", ",", "sdPrefix", "string", ",", "grpc", "bool", ")", "func", "(", ")", "{", "grpcPort", ":=", "GetFreePort", "(", "t", ")", "\n", "promPort", ":=", "GetFreePort", "(", "t", ")", "\n", "var", "useGRPC", "string", "\n", "if", "grpc", "{", "useGRPC", "=", "\"", "\"", "\n", "}", "else", "{", "useGRPC", "=", "\"", "\"", "\n", "}", "\n", "t", ".", "Helper", "(", ")", "\n", "args", ":=", "[", "]", "string", "{", "\"", "\"", ",", "svType", ",", "\"", "\"", ",", "strconv", ".", "Itoa", "(", "port", ")", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "strconv", ".", "FormatBool", "(", "frontend", ")", ")", ",", "\"", "\"", ",", "sdPrefix", ",", "\"", "\"", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "grpcPort", ")", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "useGRPC", ")", ",", "}", "\n", "if", "debug", "{", "args", "=", "append", "(", "args", ",", "\"", "\"", ")", "\n", "}", "\n", "cmd", ":=", "StartProcess", "(", "t", ",", "\"", "\"", ",", "args", "...", ",", ")", "\n", "// always use a random port for prometheus, for avoiding e2e conflicts", "cmd", ".", "Env", "=", "[", "]", "string", "{", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "promPort", ")", "}", "\n\n", "outPipe", ",", "err", ":=", "cmd", ".", "StderrPipe", "(", ")", "\n", "if", "err", "!=", "nil", "{", "t", ".", "Fatal", "(", "err", ")", "\n", "}", "\n\n", "err", "=", "cmd", ".", "Start", "(", ")", "\n", "if", "err", "!=", "nil", "{", "t", ".", "Fatal", "(", "err", ")", "\n", "}", "\n\n", "waitForServerToBeReady", "(", "t", ",", "bufio", ".", "NewReader", "(", "outPipe", ")", ")", "\n\n", "return", "func", "(", ")", "{", "err", ":=", "cmd", ".", "Process", ".", "Kill", "(", ")", "\n", "if", "err", "!=", "nil", "{", "t", ".", "Fatal", "(", "err", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "StartServer", "starts", "a", "server" ]

[ "func", "FixtureGoldenFileName", "(", "t", "*", "testing", ".", "T", ",", "name", "string", ")", "string", "{", "t", ".", "Helper", "(", ")", "\n", "return", "filepath", ".", "Join", "(", "\"", "\"", ",", "name", "+", "\"", "\"", ")", "\n", "}" ]

[ "FixtureGoldenFileName", "returns", "the", "golden", "file", "name", "on", "fixtures", "path" ]

[ "func", "ShouldEventuallyReceive", "(", "t", "testing", ".", "TB", ",", "c", "interface", "{", "}", ",", "timeouts", "...", "time", ".", "Duration", ")", "interface", "{", "}", "{", "t", ".", "Helper", "(", ")", "\n", "if", "!", "isChan", "(", "c", ")", "{", "t", ".", "Fatal", "(", "\"", "\"", ")", "\n", "}", "\n", "v", ":=", "reflect", ".", "ValueOf", "(", "c", ")", "\n\n", "timeout", ":=", "time", ".", "After", "(", "500", "*", "time", ".", "Millisecond", ")", "\n\n", "if", "len", "(", "timeouts", ")", ">", "0", "{", "timeout", "=", "time", ".", "After", "(", "timeouts", "[", "0", "]", ")", "\n", "}", "\n\n", "recvChan", ":=", "make", "(", "chan", "reflect", ".", "Value", ")", "\n\n", "go", "func", "(", ")", "{", "v", ",", "ok", ":=", "v", ".", "Recv", "(", ")", "\n", "if", "ok", "{", "recvChan", "<-", "v", "\n", "}", "\n", "}", "(", ")", "\n\n", "select", "{", "case", "<-", "timeout", ":", "t", ".", "Fatal", "(", "errors", ".", "New", "(", "\"", "\"", ")", ")", "\n", "case", "a", ":=", "<-", "recvChan", ":", "return", "a", ".", "Interface", "(", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "ShouldEventuallyReceive", "should", "asserts", "that", "eventually", "channel", "c", "receives", "a", "value" ]

[ "func", "(", "*", "Room", ")", "CallLog", "(", "ctx", "context", ".", "Context", ",", "arg", "*", "protos", ".", "Arg", ")", "(", "*", "protos", ".", "Response", ",", "error", ")", "{", "route", ":=", "\"", "\"", "\n", "reply", ":=", "&", "protos", ".", "Response", "{", "}", "\n", "jid", ",", "err", ":=", "pitaya", ".", "ReliableRPC", "(", "route", ",", "nil", ",", "reply", ",", "arg", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Log", ".", "Infof", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "logger", ".", "Log", ".", "Infof", "(", "\"", "\"", ",", "jid", ")", "\n", "return", "&", "protos", ".", "Response", "{", "Code", ":", "200", ",", "Msg", ":", "\"", "\"", "}", ",", "nil", "\n", "}" ]

[ "CallLog", "makes", "ReliableRPC", "to", "metagame", "LogRemote" ]

[ "func", "NewMockSerializer", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockSerializer", "{", "mock", ":=", "&", "MockSerializer", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockSerializerMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

[ "NewMockSerializer", "creates", "a", "new", "mock", "instance" ]

[ "func", "(", "mr", "*", "MockSerializerMockRecorder", ")", "GetName", "(", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockSerializer", ")", "(", "nil", ")", ".", "GetName", ")", ")", "\n", "}" ]

[ "GetName", "indicates", "an", "expected", "call", "of", "GetName" ]

[ "func", "(", "m", "*", "MockSerializer", ")", "Marshal", "(", "arg0", "interface", "{", "}", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "[", "]", "byte", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "Marshal", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockSerializer", ")", "Unmarshal", "(", "arg0", "[", "]", "byte", ",", "arg1", "interface", "{", "}", ")", "error", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ",", "arg1", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "error", ")", "\n", "return", "ret0", "\n", "}" ]

[ "Unmarshal", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockSerializerMockRecorder", ")", "Unmarshal", "(", "arg0", ",", "arg1", "interface", "{", "}", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockSerializer", ")", "(", "nil", ")", ".", "Unmarshal", ")", ",", "arg0", ",", "arg1", ")", "\n", "}" ]

[ "Unmarshal", "indicates", "an", "expected", "call", "of", "Unmarshal" ]

[ "func", "HandlersDocs", "(", "serverType", "string", ",", "services", "map", "[", "string", "]", "*", "component", ".", "Service", ",", "getPtrNames", "bool", ")", "(", "map", "[", "string", "]", "interface", "{", "}", ",", "error", ")", "{", "docs", ":=", "&", "docs", "{", "Handlers", ":", "map", "[", "string", "]", "*", "doc", "{", "}", ",", "}", "\n\n", "for", "serviceName", ",", "service", ":=", "range", "services", "{", "for", "name", ",", "handler", ":=", "range", "service", ".", "Handlers", "{", "routeName", ":=", "route", ".", "NewRoute", "(", "serverType", ",", "serviceName", ",", "name", ")", "\n", "docs", ".", "Handlers", "[", "routeName", ".", "String", "(", ")", "]", "=", "docForMethod", "(", "handler", ".", "Method", ",", "getPtrNames", ")", "\n", "}", "\n", "}", "\n\n", "return", "docs", ".", "Handlers", ".", "toMap", "(", ")", "\n", "}" ]

[ "HandlersDocs", "returns", "a", "map", "from", "route", "to", "input", "and", "output" ]

[ "func", "RemotesDocs", "(", "serverType", "string", ",", "services", "map", "[", "string", "]", "*", "component", ".", "Service", ",", "getPtrNames", "bool", ")", "(", "map", "[", "string", "]", "interface", "{", "}", ",", "error", ")", "{", "docs", ":=", "&", "docs", "{", "Remotes", ":", "map", "[", "string", "]", "*", "doc", "{", "}", ",", "}", "\n\n", "for", "serviceName", ",", "service", ":=", "range", "services", "{", "for", "name", ",", "remote", ":=", "range", "service", ".", "Remotes", "{", "routeName", ":=", "route", ".", "NewRoute", "(", "serverType", ",", "serviceName", ",", "name", ")", "\n", "docs", ".", "Remotes", "[", "routeName", ".", "String", "(", ")", "]", "=", "docForMethod", "(", "remote", ".", "Method", ",", "getPtrNames", ")", "\n", "}", "\n", "}", "\n\n", "return", "docs", ".", "Remotes", ".", "toMap", "(", ")", "\n", "}" ]

[ "RemotesDocs", "returns", "a", "map", "from", "route", "to", "input", "and", "output" ]

[ "func", "New", "(", "err", "...", "bool", ")", "*", "Message", "{", "m", ":=", "&", "Message", "{", "}", "\n", "if", "len", "(", "err", ")", ">", "0", "{", "m", ".", "Err", "=", "err", "[", "0", "]", "\n", "}", "\n", "return", "m", "\n", "}" ]

[ "New", "returns", "a", "new", "message", "instance" ]

[ "func", "(", "m", "*", "Message", ")", "String", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "types", "[", "m", ".", "Type", "]", ",", "m", ".", "ID", ",", "m", ".", "Route", ",", "m", ".", "compressed", ",", "m", ".", "Err", ",", "m", ".", "Data", ",", "len", "(", "m", ".", "Data", ")", ")", "\n", "}" ]

[ "String", "implementation", "of", "fmt", ".", "Stringer", "interface" ]

[ "func", "SetDictionary", "(", "dict", "map", "[", "string", "]", "uint16", ")", "error", "{", "if", "dict", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "for", "route", ",", "code", ":=", "range", "dict", "{", "r", ":=", "strings", ".", "TrimSpace", "(", "route", ")", "\n\n", "// duplication check", "if", "_", ",", "ok", ":=", "routes", "[", "r", "]", ";", "ok", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "r", ",", "code", ")", "\n", "}", "\n\n", "if", "_", ",", "ok", ":=", "codes", "[", "code", "]", ";", "ok", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "r", ",", "code", ")", "\n", "}", "\n\n", "// update map, using last value when key duplicated", "routes", "[", "r", "]", "=", "code", "\n", "codes", "[", "code", "]", "=", "r", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "SetDictionary", "set", "routes", "map", "which", "be", "used", "to", "compress", "route", "." ]

[ "func", "(", "p", "*", "Packet", ")", "String", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "p", ".", "Type", ",", "p", ".", "Length", ",", "string", "(", "p", ".", "Data", ")", ")", "\n", "}" ]

[ "String", "represents", "the", "Packet", "s", "in", "text", "mode", "." ]

[ "func", "NewMockReporter", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockReporter", "{", "mock", ":=", "&", "MockReporter", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockReporterMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

[ "NewMockReporter", "creates", "a", "new", "mock", "instance" ]

[ "func", "(", "m", "*", "MockReporter", ")", "ReportCount", "(", "metric", "string", ",", "tags", "map", "[", "string", "]", "string", ",", "count", "float64", ")", "error", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "metric", ",", "tags", ",", "count", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "error", ")", "\n", "return", "ret0", "\n", "}" ]

[ "ReportCount", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockReporterMockRecorder", ")", "ReportCount", "(", "metric", ",", "tags", ",", "count", "interface", "{", "}", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockReporter", ")", "(", "nil", ")", ".", "ReportCount", ")", ",", "metric", ",", "tags", ",", "count", ")", "\n", "}" ]

[ "ReportCount", "indicates", "an", "expected", "call", "of", "ReportCount" ]

[ "func", "(", "m", "*", "MockReporter", ")", "ReportSummary", "(", "metric", "string", ",", "tags", "map", "[", "string", "]", "string", ",", "value", "float64", ")", "error", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "metric", ",", "tags", ",", "value", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "error", ")", "\n", "return", "ret0", "\n", "}" ]

[ "ReportSummary", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockReporterMockRecorder", ")", "ReportSummary", "(", "metric", ",", "tags", ",", "value", "interface", "{", "}", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockReporter", ")", "(", "nil", ")", ".", "ReportSummary", ")", ",", "metric", ",", "tags", ",", "value", ")", "\n", "}" ]

[ "ReportSummary", "indicates", "an", "expected", "call", "of", "ReportSummary" ]

[ "func", "InjectSpan", "(", "ctx", "context", ".", "Context", ")", "(", "context", ".", "Context", ",", "error", ")", "{", "span", ":=", "opentracing", ".", "SpanFromContext", "(", "ctx", ")", "\n", "if", "span", "==", "nil", "{", "return", "ctx", ",", "nil", "\n", "}", "\n", "spanData", ":=", "opentracing", ".", "TextMapCarrier", "{", "}", "\n", "tracer", ":=", "opentracing", ".", "GlobalTracer", "(", ")", "\n", "err", ":=", "tracer", ".", "Inject", "(", "span", ".", "Context", "(", ")", ",", "opentracing", ".", "TextMap", ",", "spanData", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "pcontext", ".", "AddToPropagateCtx", "(", "ctx", ",", "constants", ".", "SpanPropagateCtxKey", ",", "spanData", ")", ",", "nil", "\n", "}" ]

[ "InjectSpan", "retrieves", "an", "opentrancing", "span", "from", "the", "current", "context", "and", "creates", "a", "new", "context", "with", "it", "encoded", "in", "binary", "format", "inside", "the", "propagatable", "context", "content" ]

[ "func", "StartSpan", "(", "parentCtx", "context", ".", "Context", ",", "opName", "string", ",", "tags", "opentracing", ".", "Tags", ",", "reference", "...", "opentracing", ".", "SpanContext", ",", ")", "context", ".", "Context", "{", "var", "ref", "opentracing", ".", "SpanContext", "\n", "if", "len", "(", "reference", ")", ">", "0", "{", "ref", "=", "reference", "[", "0", "]", "\n", "}", "\n", "span", ":=", "opentracing", ".", "StartSpan", "(", "opName", ",", "opentracing", ".", "ChildOf", "(", "ref", ")", ",", "tags", ")", "\n", "return", "opentracing", ".", "ContextWithSpan", "(", "parentCtx", ",", "span", ")", "\n", "}" ]

[ "StartSpan", "starts", "a", "new", "span", "with", "a", "given", "parent", "context", "operation", "name", "tags", "and", "optional", "parent", "span", ".", "It", "returns", "a", "context", "with", "the", "created", "span", "." ]

[ "func", "FinishSpan", "(", "ctx", "context", ".", "Context", ",", "err", "error", ")", "{", "if", "ctx", "==", "nil", "{", "return", "\n", "}", "\n", "span", ":=", "opentracing", ".", "SpanFromContext", "(", "ctx", ")", "\n", "if", "span", "==", "nil", "{", "return", "\n", "}", "\n", "defer", "span", ".", "Finish", "(", ")", "\n", "if", "err", "!=", "nil", "{", "LogError", "(", "span", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "}" ]

[ "FinishSpan", "finishes", "a", "span", "retrieved", "from", "the", "given", "context", "and", "logs", "the", "error", "if", "it", "exists" ]

[ "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", "\n", "}", "\n", "serversOfType", ",", "err", ":=", "r", ".", "serviceDiscovery", ".", "GetServersByType", "(", "svType", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "rpcType", "==", "protos", ".", "RPCType_User", "{", "server", ":=", "r", ".", "defaultRoute", "(", "serversOfType", ")", "\n", "return", "server", ",", "nil", "\n", "}", "\n", "routeFunc", ",", "ok", ":=", "r", ".", "routesMap", "[", "svType", "]", "\n", "if", "!", "ok", "{", "logger", ".", "Log", ".", "Debugf", "(", "\"", "\"", ",", "svType", ")", "\n", "server", ":=", "r", ".", "defaultRoute", "(", "serversOfType", ")", "\n", "return", "server", ",", "nil", "\n", "}", "\n", "return", "routeFunc", "(", "ctx", ",", "route", ",", "msg", ".", "Data", ",", "serversOfType", ")", "\n", "}" ]

[ "Route", "gets", "the", "right", "server", "to", "use", "in", "the", "call" ]

[ "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 and handshake data on first user connection", "once", ".", "Do", "(", "func", "(", ")", "{", "hbdEncode", "(", "heartbeatTime", ",", "packetEncoder", ",", "messageEncoder", ".", "IsCompressionEnabled", "(", ")", ",", "serializer", ".", "GetName", "(", ")", ")", "\n", "}", ")", "\n\n", "a", ":=", "&", "Agent", "{", "appDieChan", ":", "dieChan", ",", "chDie", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "chSend", ":", "make", "(", "chan", "pendingMessage", ",", "messagesBufferSize", ")", ",", "chStopHeartbeat", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "chStopWrite", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "messagesBufferSize", ":", "messagesBufferSize", ",", "conn", ":", "conn", ",", "decoder", ":", "packetDecoder", ",", "encoder", ":", "packetEncoder", ",", "heartbeatTimeout", ":", "heartbeatTime", ",", "lastAt", ":", "time", ".", "Now", "(", ")", ".", "Unix", "(", ")", ",", "serializer", ":", "serializer", ",", "state", ":", "constants", ".", "StatusStart", ",", "messageEncoder", ":", "messageEncoder", ",", "metricsReporters", ":", "metricsReporters", ",", "}", "\n\n", "// binding session", "s", ":=", "session", ".", "New", "(", "a", ",", "true", ")", "\n", "metrics", ".", "ReportNumberOfConnectedClients", "(", "metricsReporters", ",", "session", ".", "SessionCount", ")", "\n", "a", ".", "Session", "=", "s", "\n", "return", "a", "\n", "}" ]

[ "NewAgent", "create", "new", "agent", "instance" ]

[ "func", "(", "a", "*", "Agent", ")", "Push", "(", "route", "string", ",", "v", "interface", "{", "}", ")", "error", "{", "if", "a", ".", "GetStatus", "(", ")", "==", "constants", ".", "StatusClosed", "{", "return", "constants", ".", "ErrBrokenPipe", "\n", "}", "\n\n", "switch", "d", ":=", "v", ".", "(", "type", ")", "{", "case", "[", "]", "byte", ":", "logger", ".", "Log", ".", "Debugf", "(", "\"", "\"", ",", "a", ".", "Session", ".", "ID", "(", ")", ",", "a", ".", "Session", ".", "UID", "(", ")", ",", "route", ",", "len", "(", "d", ")", ")", "\n", "default", ":", "logger", ".", "Log", ".", "Debugf", "(", "\"", "\"", ",", "a", ".", "Session", ".", "ID", "(", ")", ",", "a", ".", "Session", ".", "UID", "(", ")", ",", "route", ",", "v", ")", "\n", "}", "\n", "return", "a", ".", "send", "(", "pendingMessage", "{", "typ", ":", "message", ".", "Push", ",", "route", ":", "route", ",", "payload", ":", "v", "}", ")", "\n", "}" ]

[ "Push", "implementation", "for", "session", ".", "NetworkEntity", "interface" ]

[ "func", "(", "a", "*", "Agent", ")", "ResponseMID", "(", "ctx", "context", ".", "Context", ",", "mid", "uint", ",", "v", "interface", "{", "}", ",", "isError", "...", "bool", ")", "error", "{", "err", ":=", "false", "\n", "if", "len", "(", "isError", ")", ">", "0", "{", "err", "=", "isError", "[", "0", "]", "\n", "}", "\n", "if", "a", ".", "GetStatus", "(", ")", "==", "constants", ".", "StatusClosed", "{", "err", ":=", "constants", ".", "ErrBrokenPipe", "\n", "tracing", ".", "FinishSpan", "(", "ctx", ",", "err", ")", "\n", "metrics", ".", "ReportTimingFromCtx", "(", "ctx", ",", "a", ".", "metricsReporters", ",", "handlerType", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n\n", "if", "mid", "<=", "0", "{", "err", ":=", "constants", ".", "ErrSessionOnNotify", "\n", "tracing", ".", "FinishSpan", "(", "ctx", ",", "err", ")", "\n", "metrics", ".", "ReportTimingFromCtx", "(", "ctx", ",", "a", ".", "metricsReporters", ",", "handlerType", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n\n", "switch", "d", ":=", "v", ".", "(", "type", ")", "{", "case", "[", "]", "byte", ":", "logger", ".", "Log", ".", "Debugf", "(", "\"", "\"", ",", "a", ".", "Session", ".", "ID", "(", ")", ",", "a", ".", "Session", ".", "UID", "(", ")", ",", "mid", ",", "len", "(", "d", ")", ")", "\n", "default", ":", "logger", ".", "Log", ".", "Infof", "(", "\"", "\"", ",", "a", ".", "Session", ".", "ID", "(", ")", ",", "a", ".", "Session", ".", "UID", "(", ")", ",", "mid", ",", "v", ")", "\n", "}", "\n\n", "return", "a", ".", "send", "(", "pendingMessage", "{", "ctx", ":", "ctx", ",", "typ", ":", "message", ".", "Response", ",", "mid", ":", "mid", ",", "payload", ":", "v", ",", "err", ":", "err", "}", ")", "\n", "}" ]

[ "ResponseMID", "implementation", "for", "session", ".", "NetworkEntity", "interface", "Respond", "message", "to", "session" ]