Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "Stats", "*", "Stats", ")", "Outbound", "(", "ctx", "context", ".", "Context", ",", "in", "[", "]", "byte", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "Stats", ".", "outboundBytes", "+=", "len", "(", "in", ")", "\n", "return", "in", ",", "nil", "\n", "}" ]

[ "Outbound", "gets", "the", "outbound", "status" ]

[ "func", "(", "Stats", "*", "Stats", ")", "Inbound", "(", "ctx", "context", ".", "Context", ",", "in", "[", "]", "byte", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "Stats", ".", "inboundBytes", "+=", "len", "(", "in", ")", "\n", "return", "in", ",", "nil", "\n", "}" ]

[ "Inbound", "gets", "the", "inbound", "status" ]

[ "func", "(", "r", "*", "Room", ")", "MessageRemote", "(", "ctx", "context", ".", "Context", ",", "msg", "*", "UserMessage", ",", "b", "bool", ",", "s", "string", ")", "(", "*", "UserMessage", ",", "error", ")", "{", "return", "msg", ",", "nil", "\n", "}" ]

[ "MessageRemote", "just", "echoes", "the", "given", "message" ]

[ "func", "NewMockNetworkEntity", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockNetworkEntity", "{", "mock", ":=", "&", "MockNetworkEntity", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockNetworkEntityMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

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

[ "func", "(", "m", "*", "MockNetworkEntity", ")", "Push", "(", "route", "string", ",", "v", "interface", "{", "}", ")", "error", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "route", ",", "v", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "error", ")", "\n", "return", "ret0", "\n", "}" ]

[ "Push", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockNetworkEntityMockRecorder", ")", "Push", "(", "route", ",", "v", "interface", "{", "}", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockNetworkEntity", ")", "(", "nil", ")", ".", "Push", ")", ",", "route", ",", "v", ")", "\n", "}" ]

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

[ "func", "(", "m", "*", "MockNetworkEntity", ")", "ResponseMID", "(", "ctx", "context", ".", "Context", ",", "mid", "uint", ",", "v", "interface", "{", "}", ",", "isError", "...", "bool", ")", "error", "{", "varargs", ":=", "[", "]", "interface", "{", "}", "{", "ctx", ",", "mid", ",", "v", "}", "\n", "for", "_", ",", "a", ":=", "range", "isError", "{", "varargs", "=", "append", "(", "varargs", ",", "a", ")", "\n", "}", "\n", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "varargs", "...", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "error", ")", "\n", "return", "ret0", "\n", "}" ]

[ "ResponseMID", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockNetworkEntityMockRecorder", ")", "ResponseMID", "(", "ctx", ",", "mid", ",", "v", "interface", "{", "}", ",", "isError", "...", "interface", "{", "}", ")", "*", "gomock", ".", "Call", "{", "varargs", ":=", "append", "(", "[", "]", "interface", "{", "}", "{", "ctx", ",", "mid", ",", "v", "}", ",", "isError", "...", ")", "\n", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockNetworkEntity", ")", "(", "nil", ")", ".", "ResponseMID", ")", ",", "varargs", "...", ")", "\n", "}" ]

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

[ "func", "(", "m", "*", "MockNetworkEntity", ")", "Kick", "(", "ctx", "context", ".", "Context", ")", "error", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "ctx", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "error", ")", "\n", "return", "ret0", "\n", "}" ]

[ "Kick", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockNetworkEntityMockRecorder", ")", "Kick", "(", "ctx", "interface", "{", "}", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockNetworkEntity", ")", "(", "nil", ")", ".", "Kick", ")", ",", "ctx", ")", "\n", "}" ]

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

[ "func", "(", "mr", "*", "MockNetworkEntityMockRecorder", ")", "RemoteAddr", "(", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockNetworkEntity", ")", "(", "nil", ")", ".", "RemoteAddr", ")", ")", "\n", "}" ]

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

[ "func", "(", "m", "*", "MockNetworkEntity", ")", "SendRequest", "(", "ctx", "context", ".", "Context", ",", "serverID", ",", "route", "string", ",", "v", "interface", "{", "}", ")", "(", "*", "protos", ".", "Response", ",", "error", ")", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "ctx", ",", "serverID", ",", "route", ",", "v", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "*", "protos", ".", "Response", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "SendRequest", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockNetworkEntityMockRecorder", ")", "SendRequest", "(", "ctx", ",", "serverID", ",", "route", ",", "v", "interface", "{", "}", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockNetworkEntity", ")", "(", "nil", ")", ".", "SendRequest", ")", ",", "ctx", ",", "serverID", ",", "route", ",", "v", ")", "\n", "}" ]

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

[ "func", "NewHandlerService", "(", "dieChan", "chan", "bool", ",", "packetDecoder", "codec", ".", "PacketDecoder", ",", "packetEncoder", "codec", ".", "PacketEncoder", ",", "serializer", "serialize", ".", "Serializer", ",", "heartbeatTime", "time", ".", "Duration", ",", "messagesBufferSize", ",", "localProcessBufferSize", ",", "remoteProcessBufferSize", "int", ",", "server", "*", "cluster", ".", "Server", ",", "remoteService", "*", "RemoteService", ",", "messageEncoder", "message", ".", "Encoder", ",", "metricsReporters", "[", "]", "metrics", ".", "Reporter", ",", ")", "*", "HandlerService", "{", "h", ":=", "&", "HandlerService", "{", "services", ":", "make", "(", "map", "[", "string", "]", "*", "component", ".", "Service", ")", ",", "chLocalProcess", ":", "make", "(", "chan", "unhandledMessage", ",", "localProcessBufferSize", ")", ",", "chRemoteProcess", ":", "make", "(", "chan", "unhandledMessage", ",", "remoteProcessBufferSize", ")", ",", "decoder", ":", "packetDecoder", ",", "encoder", ":", "packetEncoder", ",", "messagesBufferSize", ":", "messagesBufferSize", ",", "serializer", ":", "serializer", ",", "heartbeatTimeout", ":", "heartbeatTime", ",", "appDieChan", ":", "dieChan", ",", "server", ":", "server", ",", "remoteService", ":", "remoteService", ",", "messageEncoder", ":", "messageEncoder", ",", "metricsReporters", ":", "metricsReporters", ",", "}", "\n\n", "return", "h", "\n", "}" ]

[ "NewHandlerService", "creates", "and", "returns", "a", "new", "handler", "service" ]

[ "func", "(", "h", "*", "HandlerService", ")", "Dispatch", "(", "thread", "int", ")", "{", "// TODO: This timer is being stopped multiple times, it probably doesn't need to be stopped here", "defer", "timer", ".", "GlobalTicker", ".", "Stop", "(", ")", "\n\n", "for", "{", "// Calls to remote servers block calls to local server", "select", "{", "case", "lm", ":=", "<-", "h", ".", "chLocalProcess", ":", "metrics", ".", "ReportMessageProcessDelayFromCtx", "(", "lm", ".", "ctx", ",", "h", ".", "metricsReporters", ",", "\"", "\"", ")", "\n", "h", ".", "localProcess", "(", "lm", ".", "ctx", ",", "lm", ".", "agent", ",", "lm", ".", "route", ",", "lm", ".", "msg", ")", "\n\n", "case", "rm", ":=", "<-", "h", ".", "chRemoteProcess", ":", "metrics", ".", "ReportMessageProcessDelayFromCtx", "(", "rm", ".", "ctx", ",", "h", ".", "metricsReporters", ",", "\"", "\"", ")", "\n", "h", ".", "remoteService", ".", "remoteProcess", "(", "rm", ".", "ctx", ",", "nil", ",", "rm", ".", "agent", ",", "rm", ".", "route", ",", "rm", ".", "msg", ")", "\n\n", "case", "<-", "timer", ".", "GlobalTicker", ".", "C", ":", "// execute cron task", "timer", ".", "Cron", "(", ")", "\n\n", "case", "t", ":=", "<-", "timer", ".", "Manager", ".", "ChCreatedTimer", ":", "// new Timers", "timer", ".", "AddTimer", "(", "t", ")", "\n\n", "case", "id", ":=", "<-", "timer", ".", "Manager", ".", "ChClosingTimer", ":", "// closing Timers", "timer", ".", "RemoveTimer", "(", "id", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "Dispatch", "message", "to", "corresponding", "logic", "handler" ]

[ "func", "(", "h", "*", "HandlerService", ")", "Handle", "(", "conn", "net", ".", "Conn", ")", "{", "// create a client agent and startup write goroutine", "a", ":=", "agent", ".", "NewAgent", "(", "conn", ",", "h", ".", "decoder", ",", "h", ".", "encoder", ",", "h", ".", "serializer", ",", "h", ".", "heartbeatTimeout", ",", "h", ".", "messagesBufferSize", ",", "h", ".", "appDieChan", ",", "h", ".", "messageEncoder", ",", "h", ".", "metricsReporters", ")", "\n\n", "// startup agent goroutine", "go", "a", ".", "Handle", "(", ")", "\n\n", "logger", ".", "Log", ".", "Debugf", "(", "\"", "\"", ",", "a", ".", "String", "(", ")", ")", "\n\n", "// guarantee agent related resource is destroyed", "defer", "func", "(", ")", "{", "a", ".", "Session", ".", "Close", "(", ")", "\n", "logger", ".", "Log", ".", "Debugf", "(", "\"", "\"", ",", "a", ".", "Session", ".", "ID", "(", ")", ",", "a", ".", "Session", ".", "UID", "(", ")", ")", "\n", "}", "(", ")", "\n\n", "// read loop", "buf", ":=", "make", "(", "[", "]", "byte", ",", "2048", ")", "\n", "for", "{", "n", ",", "err", ":=", "conn", ".", "Read", "(", "buf", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Log", ".", "Debugf", "(", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "return", "\n", "}", "\n\n", "logger", ".", "Log", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "// (warning): decoder uses slice for performance, packet data should be copied before next Decode", "packets", ",", "err", ":=", "h", ".", "decoder", ".", "Decode", "(", "buf", "[", ":", "n", "]", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Log", ".", "Errorf", "(", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "return", "\n", "}", "\n\n", "if", "len", "(", "packets", ")", "<", "1", "{", "logger", ".", "Log", ".", "Warnf", "(", "\"", "\"", ",", "buf", "[", ":", "n", "]", ")", "\n", "continue", "\n", "}", "\n\n", "// process all packet", "for", "i", ":=", "range", "packets", "{", "if", "err", ":=", "h", ".", "processPacket", "(", "a", ",", "packets", "[", "i", "]", ")", ";", "err", "!=", "nil", "{", "logger", ".", "Log", ".", "Errorf", "(", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "return", "\n", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "Handle", "handles", "messages", "from", "a", "conn" ]

[ "func", "(", "h", "*", "HandlerService", ")", "DumpServices", "(", ")", "{", "for", "name", ":=", "range", "handlers", "{", "logger", ".", "Log", ".", "Infof", "(", "\"", "\"", ",", "name", ",", "handlers", "[", "name", "]", ".", "IsRawArg", ")", "\n", "}", "\n", "}" ]

[ "DumpServices", "outputs", "all", "registered", "services" ]

[ "func", "(", "h", "*", "HandlerService", ")", "Docs", "(", "getPtrNames", "bool", ")", "(", "map", "[", "string", "]", "interface", "{", "}", ",", "error", ")", "{", "if", "h", "==", "nil", "{", "return", "map", "[", "string", "]", "interface", "{", "}", "{", "}", ",", "nil", "\n", "}", "\n", "return", "docgenerator", ".", "HandlersDocs", "(", "h", ".", "server", ".", "Type", ",", "h", ".", "services", ",", "getPtrNames", ")", "\n", "}" ]

[ "Docs", "returns", "documentation", "for", "handlers" ]

[ "func", "(", "w", "*", "Worker", ")", "EnqueueRPC", "(", "routeStr", "string", ",", "metadata", "map", "[", "string", "]", "interface", "{", "}", ",", "reply", ",", "arg", "proto", ".", "Message", ",", ")", "(", "jid", "string", ",", "err", "error", ")", "{", "opts", ":=", "w", ".", "enqueueOptions", "(", "w", ".", "opts", ")", "\n", "return", "workers", ".", "EnqueueWithOptions", "(", "rpcQueue", ",", "class", ",", "&", "rpcInfo", "{", "Route", ":", "routeStr", ",", "Metadata", ":", "metadata", ",", "Arg", ":", "arg", ",", "Reply", ":", "reply", ",", "}", ",", "opts", ")", "\n", "}" ]

[ "EnqueueRPC", "enqueues", "rpc", "job", "to", "worker" ]

[ "func", "(", "w", "*", "Worker", ")", "RegisterRPCJob", "(", "rpcJob", "RPCJob", ")", "error", "{", "if", "w", ".", "registered", "{", "return", "constants", ".", "ErrRPCJobAlreadyRegistered", "\n", "}", "\n\n", "job", ":=", "w", ".", "parsedRPCJob", "(", "rpcJob", ")", "\n", "workers", ".", "Process", "(", "rpcQueue", ",", "job", ",", "w", ".", "concurrency", ")", "\n", "w", ".", "registered", "=", "true", "\n", "return", "nil", "\n", "}" ]

[ "RegisterRPCJob", "registers", "a", "RPC", "job" ]

[ "func", "SendKickToUsers", "(", "uids", "[", "]", "string", ",", "frontendType", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "if", "!", "app", ".", "server", ".", "Frontend", "&&", "frontendType", "==", "\"", "\"", "{", "return", "uids", ",", "constants", ".", "ErrFrontendTypeNotSpecified", "\n", "}", "\n\n", "var", "notKickedUids", "[", "]", "string", "\n\n", "for", "_", ",", "uid", ":=", "range", "uids", "{", "if", "s", ":=", "session", ".", "GetSessionByUID", "(", "uid", ")", ";", "s", "!=", "nil", "{", "if", "err", ":=", "s", ".", "Kick", "(", "context", ".", "Background", "(", ")", ")", ";", "err", "!=", "nil", "{", "notKickedUids", "=", "append", "(", "notKickedUids", ",", "uid", ")", "\n", "logger", ".", "Log", ".", "Errorf", "(", "\"", "\"", ",", "s", ".", "ID", "(", ")", ",", "s", ".", "UID", "(", ")", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "}", "else", "if", "app", ".", "rpcClient", "!=", "nil", "{", "kick", ":=", "&", "protos", ".", "KickMsg", "{", "UserId", ":", "uid", "}", "\n", "if", "err", ":=", "app", ".", "rpcClient", ".", "SendKick", "(", "uid", ",", "frontendType", ",", "kick", ")", ";", "err", "!=", "nil", "{", "notKickedUids", "=", "append", "(", "notKickedUids", ",", "uid", ")", "\n", "logger", ".", "Log", ".", "Errorf", "(", "\"", "\"", ",", "uid", ",", "frontendType", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "}", "else", "{", "notKickedUids", "=", "append", "(", "notKickedUids", ",", "uid", ")", "\n", "}", "\n\n", "}", "\n\n", "if", "len", "(", "notKickedUids", ")", "!=", "0", "{", "return", "notKickedUids", ",", "constants", ".", "ErrKickingUsers", "\n", "}", "\n\n", "return", "nil", ",", "nil", "\n", "}" ]

[ "SendKickToUsers", "sends", "kick", "to", "an", "user", "array" ]

[ "func", "unpackDescriptor", "(", "compressedDescriptor", "[", "]", "byte", ")", "(", "*", "protobuf", ".", "FileDescriptorProto", ",", "error", ")", "{", "r", ",", "err", ":=", "gzip", ".", "NewReader", "(", "bytes", ".", "NewReader", "(", "compressedDescriptor", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "r", ".", "Close", "(", ")", "\n\n", "b", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "var", "fileDescriptorProto", "protobuf", ".", "FileDescriptorProto", "\n\n", "if", "err", "=", "proto", ".", "Unmarshal", "(", "b", ",", "&", "fileDescriptorProto", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "fileDescriptorProto", ",", "nil", "\n", "}" ]

[ "Receive", "a", "compressed", "byte", "slice", "and", "unpack", "it", "to", "a", "FileDescriptorProto" ]

[ "func", "(", "pc", "*", "ProtoClient", ")", "buildProtosFromDescriptor", "(", "descriptorArray", "[", "]", "*", "protobuf", ".", "FileDescriptorProto", ")", "error", "{", "descriptorsMap", ":=", "make", "(", "map", "[", "string", "]", "*", "desc", ".", "MessageDescriptor", ")", "\n\n", "descriptors", ",", "err", ":=", "desc", ".", "CreateFileDescriptors", "(", "descriptorArray", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "for", "name", ":=", "range", "pc", ".", "descriptorsNames", "{", "for", "_", ",", "v", ":=", "range", "descriptors", "{", "message", ":=", "v", ".", "FindMessage", "(", "name", ")", "\n", "if", "message", "!=", "nil", "{", "descriptorsMap", "[", "name", "]", "=", "message", "\n", "}", "\n", "}", "\n", "}", "\n\n", "for", "name", ",", "cmd", ":=", "range", "pc", ".", "info", ".", "Commands", "{", "if", "msg", ",", "ok", ":=", "descriptorsMap", "[", "cmd", ".", "input", "]", ";", "ok", "{", "pc", ".", "info", ".", "Commands", "[", "name", "]", ".", "inputMsgDescriptor", "=", "msg", "\n", "}", "\n", "if", "msg", ",", "ok", ":=", "descriptorsMap", "[", "cmd", ".", "output", "]", ";", "ok", "{", "pc", ".", "info", ".", "Commands", "[", "name", "]", ".", "outputMsgDescriptor", "=", "msg", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Receive", "an", "array", "of", "descriptors", "in", "binary", "format", ".", "The", "function", "creates", "the", "protobuffer", "from", "this", "data", "and", "associates", "it", "to", "the", "message", "." ]

[ "func", "getOutputInputNames", "(", "command", "map", "[", "string", "]", "interface", "{", "}", ")", "(", "string", ",", "string", ",", "error", ")", "{", "outputName", ":=", "\"", "\"", "\n", "inputName", ":=", "\"", "\"", "\n\n", "in", ":=", "command", "[", "\"", "\"", "]", "\n", "inputDocs", ",", "ok", ":=", "in", ".", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "if", "ok", "{", "for", "k", ":=", "range", "inputDocs", "{", "if", "strings", ".", "Contains", "(", "k", ",", "\"", "\"", ")", "{", "inputName", "=", "strings", ".", "Replace", "(", "k", ",", "\"", "\"", ",", "\"", "\"", ",", "1", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "out", ":=", "command", "[", "\"", "\"", "]", "\n", "outputDocsArr", ":=", "out", ".", "(", "[", "]", "interface", "{", "}", ")", "\n", "outputDocs", ",", "ok", ":=", "outputDocsArr", "[", "0", "]", ".", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "if", "ok", "{", "for", "k", ":=", "range", "outputDocs", "{", "if", "strings", ".", "Contains", "(", "k", ",", "\"", "\"", ")", "{", "outputName", "=", "strings", ".", "Replace", "(", "k", ",", "\"", "\"", ",", "\"", "\"", ",", "1", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "inputName", ",", "outputName", ",", "nil", "\n", "}" ]

[ "Receives", "each", "entry", "from", "the", "Unmarshal", "json", "from", "the", "Docs", "and", "read", "the", "inputs", "and", "outputs", "associated", "with", "it", ".", "Return", "the", "output", "type", "the", "input", "and", "the", "error", "." ]

[ "func", "getKeys", "(", "info", "map", "[", "string", "]", "interface", "{", "}", ",", "keysSet", "map", "[", "string", "]", "bool", ")", "{", "for", "k", ",", "v", ":=", "range", "info", "{", "if", "strings", ".", "Contains", "(", "k", ",", "\"", "\"", ")", "{", "kew", ":=", "strings", ".", "Replace", "(", "k", ",", "\"", "\"", ",", "\"", "\"", ",", "1", ")", "\n", "keysSet", "[", "kew", "]", "=", "true", "\n", "}", "\n\n", "listofouts", ",", "ok", ":=", "v", ".", "(", "[", "]", "interface", "{", "}", ")", "\n", "if", "ok", "{", "for", "i", ":=", "range", "listofouts", "{", "aux", ",", "ok", ":=", "listofouts", "[", "i", "]", ".", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "if", "!", "ok", "{", "continue", "\n", "}", "\n", "getKeys", "(", "aux", ",", "keysSet", ")", "\n", "}", "\n", "}", "\n\n", "if", "aux", ",", "ok", ":=", "v", ".", "(", "map", "[", "string", "]", "interface", "{", "}", ")", ";", "ok", "{", "getKeys", "(", "aux", ",", "keysSet", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "Get", "recursively", "all", "protos", "needed", "in", "a", "Unmarshal", "json", "." ]

[ "func", "newProto", "(", "docslogLevel", "logrus", ".", "Level", ",", "requestTimeout", "...", "time", ".", "Duration", ")", "*", "ProtoClient", "{", "return", "&", "ProtoClient", "{", "Client", ":", "*", "New", "(", "docslogLevel", ",", "requestTimeout", "...", ")", ",", "descriptorsNames", ":", "make", "(", "map", "[", "string", "]", "bool", ")", ",", "info", ":", "ProtoBufferInfo", "{", "Commands", ":", "make", "(", "map", "[", "string", "]", "*", "Command", ")", ",", "}", ",", "docsRoute", ":", "\"", "\"", ",", "descriptorsRoute", ":", "\"", "\"", ",", "IncomingMsgChan", ":", "make", "(", "chan", "*", "message", ".", "Message", ",", "10", ")", ",", "closeChan", ":", "make", "(", "chan", "bool", ")", ",", "}", "\n", "}" ]

[ "Return", "the", "basic", "structure", "for", "the", "ProtoClient", "struct", "." ]

[ "func", "NewProto", "(", "docsRoute", "string", ",", "docslogLevel", "logrus", ".", "Level", ",", "requestTimeout", "...", "time", ".", "Duration", ")", "*", "ProtoClient", "{", "newclient", ":=", "newProto", "(", "docslogLevel", ",", "requestTimeout", "...", ")", "\n", "newclient", ".", "docsRoute", "=", "docsRoute", "\n", "return", "newclient", "\n", "}" ]

[ "NewProto", "returns", "a", "new", "protoclient", "with", "the", "auto", "documentation", "route", "." ]

[ "func", "NewWithDescriptor", "(", "descriptorsRoute", "string", ",", "docsRoute", "string", ",", "docslogLevel", "logrus", ".", "Level", ",", "requestTimeout", "...", "time", ".", "Duration", ")", "*", "ProtoClient", "{", "newclient", ":=", "newProto", "(", "docslogLevel", ",", "requestTimeout", "...", ")", "\n", "newclient", ".", "docsRoute", "=", "docsRoute", "\n", "newclient", ".", "descriptorsRoute", "=", "descriptorsRoute", "\n", "return", "newclient", "\n", "}" ]

[ "NewWithDescriptor", "returns", "a", "new", "protoclient", "with", "the", "descriptors", "route", "and", "auto", "documentation", "route", "." ]

[ "func", "(", "pc", "*", "ProtoClient", ")", "LoadServerInfo", "(", "addr", "string", ")", "error", "{", "pc", ".", "ready", "=", "false", "\n\n", "if", "err", ":=", "pc", ".", "Client", ".", "ConnectToTLS", "(", "addr", ",", "true", ")", ";", "err", "!=", "nil", "{", "if", "err", ".", "Error", "(", ")", "==", "\"", "\"", "{", "if", "err", ":=", "pc", ".", "Client", ".", "ConnectTo", "(", "addr", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "else", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "// request doc info", "_", ",", "err", ":=", "pc", ".", "SendRequest", "(", "pc", ".", "docsRoute", ",", "make", "(", "[", "]", "byte", ",", "0", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "response", ":=", "<-", "pc", ".", "Client", ".", "IncomingMsgChan", "\n\n", "docs", ":=", "&", "protos", ".", "Doc", "{", "}", "\n", "if", "err", ":=", "proto", ".", "Unmarshal", "(", "response", ".", "Data", ",", "docs", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "pc", ".", "getDescriptors", "(", "docs", ".", "Doc", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "pc", ".", "Disconnect", "(", ")", "\n", "pc", ".", "ready", "=", "true", "\n\n", "return", "nil", "\n", "}" ]

[ "LoadServerInfo", "load", "commands", "information", "from", "the", "server", ".", "Addr", "is", "the", "server", "address", "." ]

[ "func", "(", "pc", "*", "ProtoClient", ")", "Disconnect", "(", ")", "{", "pc", ".", "Client", ".", "Disconnect", "(", ")", "\n", "if", "pc", ".", "ready", "{", "pc", ".", "closeChan", "<-", "true", "\n", "}", "\n", "}" ]

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

[ "func", "(", "pc", "*", "ProtoClient", ")", "waitForData", "(", ")", "{", "for", "{", "select", "{", "case", "response", ":=", "<-", "pc", ".", "Client", ".", "IncomingMsgChan", ":", "inputMsg", ":=", "dynamic", ".", "NewMessage", "(", "pc", ".", "expectedInputDescriptor", ")", "\n\n", "msg", ",", "ok", ":=", "pc", ".", "info", ".", "Commands", "[", "response", ".", "Route", "]", "\n", "if", "ok", "{", "inputMsg", "=", "dynamic", ".", "NewMessage", "(", "msg", ".", "outputMsgDescriptor", ")", "\n", "}", "else", "{", "pc", ".", "expectedInputDescriptor", "=", "nil", "\n", "}", "\n\n", "if", "response", ".", "Err", "{", "errMsg", ":=", "&", "protos", ".", "Error", "{", "}", "\n", "err", ":=", "proto", ".", "Unmarshal", "(", "response", ".", "Data", ",", "errMsg", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Log", ".", "Errorf", "(", "\"", "\"", ",", "string", "(", "response", ".", "Data", ")", ")", "\n", "continue", "\n", "}", "\n", "response", ".", "Data", ",", "err", "=", "json", ".", "Marshal", "(", "errMsg", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Log", ".", "Errorf", "(", "\"", "\"", ",", "string", "(", "response", ".", "Data", ")", ")", "\n", "continue", "\n", "}", "\n", "pc", ".", "IncomingMsgChan", "<-", "response", "\n", "continue", "\n", "}", "\n\n", "if", "inputMsg", "==", "nil", "{", "logger", ".", "Log", ".", "Errorf", "(", "\"", "\"", ",", "string", "(", "response", ".", "Data", ")", ")", "\n", "continue", "\n", "}", "\n\n", "err", ":=", "inputMsg", ".", "Unmarshal", "(", "response", ".", "Data", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Log", ".", "Errorf", "(", "\"", "\"", ",", "string", "(", "response", ".", "Data", ")", ")", "\n", "continue", "\n", "}", "\n\n", "data", ",", "err2", ":=", "inputMsg", ".", "MarshalJSON", "(", ")", "\n", "if", "err2", "!=", "nil", "{", "logger", ".", "Log", ".", "Errorf", "(", "\"", "\"", ",", "string", "(", "response", ".", "Data", ")", ")", "\n", "continue", "\n", "}", "\n\n", "response", ".", "Data", "=", "data", "\n", "pc", ".", "IncomingMsgChan", "<-", "response", "\n", "case", "<-", "pc", ".", "closeChan", ":", "return", "\n", "}", "\n", "}", "\n", "}" ]

[ "Wait", "for", "new", "messages", "from", "the", "server", "or", "the", "connection", "end", ".", "If", "the", "menssage", "has", "a", "response", ".", "Route", "it", "decodes", "based", "on", "it", ".", "If", "not", "it", "will", "try", "to", "decode", "the", "menssage", "using", "the", "last", "expected", "response", "." ]

[ "func", "(", "pc", "*", "ProtoClient", ")", "LoadInfo", "(", "info", "*", "ProtoBufferInfo", ")", "error", "{", "if", "info", "==", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "pc", ".", "info", "=", "*", "info", "\n", "pc", ".", "ready", "=", "true", "\n", "return", "nil", "\n", "}" ]

[ "LoadInfo", "load", "commands", "information", "form", "ProtoBufferInfo" ]

[ "func", "(", "pc", "*", "ProtoClient", ")", "AddPushResponse", "(", "route", "string", ",", "protoName", "string", ")", "{", "if", "route", "!=", "\"", "\"", "&&", "protoName", "!=", "\"", "\"", "{", "var", "command", "Command", "\n", "command", ".", "input", "=", "\"", "\"", "\n", "command", ".", "output", "=", "protoName", "\n\n", "pc", ".", "info", ".", "Commands", "[", "route", "]", "=", "&", "command", "\n", "}", "\n", "}" ]

[ "AddPushResponse", "add", "a", "push", "response", ".", "Must", "be", "ladded", "before", "LoadInfo", "." ]

[ "func", "NewMockAddr", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockAddr", "{", "mock", ":=", "&", "MockAddr", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockAddrMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

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

[ "func", "NewMockConn", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockConn", "{", "mock", ":=", "&", "MockConn", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockConnMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

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

[ "func", "(", "mr", "*", "MockConnMockRecorder", ")", "Read", "(", "b", "interface", "{", "}", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockConn", ")", "(", "nil", ")", ".", "Read", ")", ",", "b", ")", "\n", "}" ]

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

[ "func", "(", "m", "*", "MockConn", ")", "LocalAddr", "(", ")", "net", ".", "Addr", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "net", ".", "Addr", ")", "\n", "return", "ret0", "\n", "}" ]

[ "LocalAddr", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockConnMockRecorder", ")", "SetReadDeadline", "(", "t", "interface", "{", "}", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockConn", ")", "(", "nil", ")", ".", "SetReadDeadline", ")", ",", "t", ")", "\n", "}" ]

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

[ "func", "(", "m", "*", "MockConn", ")", "SetWriteDeadline", "(", "t", "time", ".", "Time", ")", "error", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "t", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "error", ")", "\n", "return", "ret0", "\n", "}" ]

[ "SetWriteDeadline", "mocks", "base", "method" ]

[ "func", "NewMockPitayaClient", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockPitayaClient", "{", "mock", ":=", "&", "MockPitayaClient", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockPitayaClientMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

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

[ "func", "(", "mr", "*", "MockPitayaClientMockRecorder", ")", "PushToUser", "(", "ctx", ",", "in", "interface", "{", "}", ",", "opts", "...", "interface", "{", "}", ")", "*", "gomock", ".", "Call", "{", "varargs", ":=", "append", "(", "[", "]", "interface", "{", "}", "{", "ctx", ",", "in", "}", ",", "opts", "...", ")", "\n", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockPitayaClient", ")", "(", "nil", ")", ".", "PushToUser", ")", ",", "varargs", "...", ")", "\n", "}" ]

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

[ "func", "NewMockPitayaServer", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockPitayaServer", "{", "mock", ":=", "&", "MockPitayaServer", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockPitayaServerMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

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

[ "func", "(", "m", "*", "MockPitayaServer", ")", "PushToUser", "(", "arg0", "context", ".", "Context", ",", "arg1", "*", "protos", ".", "Push", ")", "(", "*", "protos", ".", "Response", ",", "error", ")", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ",", "arg1", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "*", "protos", ".", "Response", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "PushToUser", "mocks", "base", "method" ]

[ "func", "NewUniqueSession", "(", "server", "*", "cluster", ".", "Server", ",", "rpcServer", "cluster", ".", "RPCServer", ",", "rpcClient", "cluster", ".", "RPCClient", ")", "*", "UniqueSession", "{", "return", "&", "UniqueSession", "{", "server", ":", "server", ",", "rpcClient", ":", "rpcClient", ",", "}", "\n", "}" ]

[ "NewUniqueSession", "creates", "a", "new", "unique", "session", "module" ]

[ "func", "(", "u", "*", "UniqueSession", ")", "OnUserBind", "(", "uid", ",", "fid", "string", ")", "{", "if", "u", ".", "server", ".", "ID", "==", "fid", "{", "return", "\n", "}", "\n", "oldSession", ":=", "session", ".", "GetSessionByUID", "(", "uid", ")", "\n", "if", "oldSession", "!=", "nil", "{", "// TODO: it would be nice to set this correctly", "oldSession", ".", "Kick", "(", "context", ".", "Background", "(", ")", ")", "\n", "}", "\n", "}" ]

[ "OnUserBind", "method", "should", "be", "called", "when", "a", "user", "binds", "a", "session", "in", "remote", "servers" ]

[ "func", "(", "u", "*", "UniqueSession", ")", "Init", "(", ")", "error", "{", "session", ".", "OnSessionBind", "(", "func", "(", "ctx", "context", ".", "Context", ",", "s", "*", "session", ".", "Session", ")", "error", "{", "oldSession", ":=", "session", ".", "GetSessionByUID", "(", "s", ".", "UID", "(", ")", ")", "\n", "if", "oldSession", "!=", "nil", "{", "return", "oldSession", ".", "Kick", "(", "ctx", ")", "\n", "}", "\n", "err", ":=", "u", ".", "rpcClient", ".", "BroadcastSessionBind", "(", "s", ".", "UID", "(", ")", ")", "\n", "return", "err", "\n", "}", ")", "\n", "return", "nil", "\n", "}" ]

[ "Init", "initializes", "the", "module" ]

[ "func", "NewBinary", "(", "binPath", "string", ",", "args", "[", "]", "string", ",", "gracefulShutdownInterval", "...", "time", ".", "Duration", ")", "*", "Binary", "{", "gracefulTime", ":=", "15", "*", "time", ".", "Second", "\n", "if", "len", "(", "gracefulShutdownInterval", ")", ">", "0", "{", "gracefulTime", "=", "gracefulShutdownInterval", "[", "0", "]", "\n", "}", "\n", "return", "&", "Binary", "{", "binPath", ":", "binPath", ",", "args", ":", "args", ",", "gracefulShutdownInterval", ":", "gracefulTime", ",", "exitCh", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "}", "\n", "}" ]

[ "NewBinary", "creates", "a", "new", "binary", "module", "with", "the", "given", "path" ]

[ "func", "(", "b", "*", "Binary", ")", "Init", "(", ")", "error", "{", "b", ".", "cmd", "=", "exec", ".", "Command", "(", "b", ".", "binPath", ",", "b", ".", "args", "...", ")", "\n", "stdout", ",", "_", ":=", "b", ".", "cmd", ".", "StdoutPipe", "(", ")", "\n", "stdOutScanner", ":=", "bufio", ".", "NewScanner", "(", "stdout", ")", "\n", "stderr", ",", "_", ":=", "b", ".", "cmd", ".", "StderrPipe", "(", ")", "\n", "stdErrScanner", ":=", "bufio", ".", "NewScanner", "(", "stderr", ")", "\n", "go", "func", "(", ")", "{", "for", "stdOutScanner", ".", "Scan", "(", ")", "{", "logger", ".", "Log", ".", "Info", "(", "stdOutScanner", ".", "Text", "(", ")", ")", "\n", "}", "\n", "}", "(", ")", "\n", "go", "func", "(", ")", "{", "for", "stdErrScanner", ".", "Scan", "(", ")", "{", "logger", ".", "Log", ".", "Error", "(", "stdErrScanner", ".", "Text", "(", ")", ")", "\n", "}", "\n", "}", "(", ")", "\n", "err", ":=", "b", ".", "cmd", ".", "Start", "(", ")", "\n", "go", "func", "(", ")", "{", "b", ".", "cmd", ".", "Wait", "(", ")", "\n", "close", "(", "b", ".", "exitCh", ")", "\n", "}", "(", ")", "\n", "return", "err", "\n", "}" ]

[ "Init", "initializes", "the", "binary" ]

[ "func", "(", "b", "*", "Binary", ")", "Shutdown", "(", ")", "error", "{", "err", ":=", "b", ".", "cmd", ".", "Process", ".", "Signal", "(", "syscall", ".", "SIGTERM", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "timeout", ":=", "time", ".", "After", "(", "b", ".", "gracefulShutdownInterval", ")", "\n", "select", "{", "case", "<-", "b", ".", "exitCh", ":", "return", "nil", "\n", "case", "<-", "timeout", ":", "b", ".", "cmd", ".", "Process", ".", "Kill", "(", ")", "\n", "return", "constants", ".", "ErrTimeoutTerminatingBinaryModule", "\n", "}", "\n", "}" ]

[ "Shutdown", "shutdowns", "the", "binary", "module" ]

[ "func", "GetPrometheusReporter", "(", "serverType", "string", ",", "config", "*", "config", ".", "Config", ",", "constLabels", "map", "[", "string", "]", "string", ",", ")", "(", "*", "PrometheusReporter", ",", "error", ")", "{", "var", "(", "port", "=", "config", ".", "GetInt", "(", "\"", "\"", ")", "\n", "game", "=", "config", ".", "GetString", "(", "\"", "\"", ")", "\n", "additionalLabels", "=", "config", ".", "GetStringMapString", "(", "\"", "\"", ")", "\n", ")", "\n\n", "spec", ",", "err", ":=", "NewCustomMetricsSpec", "(", "config", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "once", ".", "Do", "(", "func", "(", ")", "{", "prometheusReporter", "=", "&", "PrometheusReporter", "{", "serverType", ":", "serverType", ",", "game", ":", "game", ",", "countReportersMap", ":", "make", "(", "map", "[", "string", "]", "*", "prometheus", ".", "CounterVec", ")", ",", "summaryReportersMap", ":", "make", "(", "map", "[", "string", "]", "*", "prometheus", ".", "SummaryVec", ")", ",", "gaugeReportersMap", ":", "make", "(", "map", "[", "string", "]", "*", "prometheus", ".", "GaugeVec", ")", ",", "}", "\n", "prometheusReporter", ".", "registerMetrics", "(", "constLabels", ",", "additionalLabels", ",", "spec", ")", "\n", "http", ".", "Handle", "(", "\"", "\"", ",", "prometheus", ".", "Handler", "(", ")", ")", "\n", "go", "(", "func", "(", ")", "{", "log", ".", "Fatal", "(", "http", ".", "ListenAndServe", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "port", ")", ",", "nil", ")", ")", "\n", "}", ")", "(", ")", "\n", "}", ")", "\n\n", "return", "prometheusReporter", ",", "nil", "\n", "}" ]

[ "GetPrometheusReporter", "gets", "the", "prometheus", "reporter", "singleton" ]

[ "func", "(", "p", "*", "PrometheusReporter", ")", "ReportSummary", "(", "metric", "string", ",", "labels", "map", "[", "string", "]", "string", ",", "value", "float64", ")", "error", "{", "sum", ":=", "p", ".", "summaryReportersMap", "[", "metric", "]", "\n", "if", "sum", "!=", "nil", "{", "labels", "=", "p", ".", "ensureLabels", "(", "labels", ")", "\n", "sum", ".", "With", "(", "labels", ")", ".", "Observe", "(", "value", ")", "\n", "return", "nil", "\n", "}", "\n", "return", "constants", ".", "ErrMetricNotKnown", "\n", "}" ]

[ "ReportSummary", "reports", "a", "summary", "metric" ]

[ "func", "(", "p", "*", "PrometheusReporter", ")", "ReportCount", "(", "metric", "string", ",", "labels", "map", "[", "string", "]", "string", ",", "count", "float64", ")", "error", "{", "cnt", ":=", "p", ".", "countReportersMap", "[", "metric", "]", "\n", "if", "cnt", "!=", "nil", "{", "labels", "=", "p", ".", "ensureLabels", "(", "labels", ")", "\n", "cnt", ".", "With", "(", "labels", ")", ".", "Add", "(", "count", ")", "\n", "return", "nil", "\n", "}", "\n", "return", "constants", ".", "ErrMetricNotKnown", "\n", "}" ]

[ "ReportCount", "reports", "a", "summary", "metric" ]

[ "func", "(", "p", "*", "PrometheusReporter", ")", "ReportGauge", "(", "metric", "string", ",", "labels", "map", "[", "string", "]", "string", ",", "value", "float64", ")", "error", "{", "g", ":=", "p", ".", "gaugeReportersMap", "[", "metric", "]", "\n", "if", "g", "!=", "nil", "{", "labels", "=", "p", ".", "ensureLabels", "(", "labels", ")", "\n", "g", ".", "With", "(", "labels", ")", ".", "Set", "(", "value", ")", "\n", "return", "nil", "\n", "}", "\n", "return", "constants", ".", "ErrMetricNotKnown", "\n", "}" ]

[ "ReportGauge", "reports", "a", "gauge", "metric" ]

[ "func", "(", "p", "*", "PrometheusReporter", ")", "ensureLabels", "(", "labels", "map", "[", "string", "]", "string", ")", "map", "[", "string", "]", "string", "{", "for", "key", ",", "defaultVal", ":=", "range", "p", ".", "additionalLabels", "{", "if", "_", ",", "ok", ":=", "labels", "[", "key", "]", ";", "!", "ok", "{", "labels", "[", "key", "]", "=", "defaultVal", "\n", "}", "\n", "}", "\n\n", "return", "labels", "\n", "}" ]

[ "ensureLabels", "checks", "if", "labels", "contains", "the", "additionalLabels", "values", "otherwise", "adds", "them", "with", "the", "default", "values" ]

[ "func", "(", "w", "*", "Worker", ")", "Configure", "(", ")", "error", "{", "err", ":=", "pitaya", ".", "StartWorker", "(", "pitaya", ".", "GetConfig", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "pitaya", ".", "RegisterRPCJob", "(", "&", "RPCJob", "{", "}", ")", "\n", "return", "nil", "\n", "}" ]

[ "Configure", "starts", "workers", "and", "register", "rpc", "job" ]

[ "func", "(", "r", "*", "RPCJob", ")", "ServerDiscovery", "(", "route", "string", ",", "rpcMetadata", "map", "[", "string", "]", "interface", "{", "}", ",", ")", "(", "serverID", "string", ",", "err", "error", ")", "{", "return", "\"", "\"", ",", "nil", "\n", "}" ]

[ "ServerDiscovery", "returns", "a", "serverID", "=", "meaning", "any", "server", "is", "ok" ]

[ "func", "(", "r", "*", "RPCJob", ")", "RPC", "(", "ctx", "context", ".", "Context", ",", "serverID", ",", "routeStr", "string", ",", "reply", ",", "arg", "proto", ".", "Message", ",", ")", "error", "{", "return", "pitaya", ".", "RPCTo", "(", "ctx", ",", "serverID", ",", "routeStr", ",", "reply", ",", "arg", ")", "\n", "}" ]

[ "RPC", "calls", "pitaya", "s", "rpc" ]

[ "func", "(", "r", "*", "RPCJob", ")", "GetArgReply", "(", "route", "string", ",", ")", "(", "arg", ",", "reply", "proto", ".", "Message", ",", "err", "error", ")", "{", "return", "&", "protos", ".", "Arg", "{", "}", ",", "&", "protos", ".", "Response", "{", "}", ",", "nil", "\n", "}" ]

[ "GetArgReply", "returns", "reply", "and", "arg", "of", "LogRemote", "since", "we", "have", "no", "other", "methods", "in", "this", "example" ]

[ "func", "NewMockModule", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockModule", "{", "mock", ":=", "&", "MockModule", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockModuleMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

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

[ "func", "(", "mr", "*", "MockModuleMockRecorder", ")", "AfterInit", "(", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockModule", ")", "(", "nil", ")", ".", "AfterInit", ")", ")", "\n", "}" ]

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

[ "func", "NewMockBindingStorage", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockBindingStorage", "{", "mock", ":=", "&", "MockBindingStorage", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockBindingStorageMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

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

[ "func", "(", "m", "*", "MockBindingStorage", ")", "GetUserFrontendID", "(", "uid", ",", "frontendType", "string", ")", "(", "string", ",", "error", ")", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "uid", ",", "frontendType", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "string", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "GetUserFrontendID", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockBindingStorageMockRecorder", ")", "GetUserFrontendID", "(", "uid", ",", "frontendType", "interface", "{", "}", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockBindingStorage", ")", "(", "nil", ")", ".", "GetUserFrontendID", ")", ",", "uid", ",", "frontendType", ")", "\n", "}" ]

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

[ "func", "(", "m", "*", "MockBindingStorage", ")", "PutBinding", "(", "uid", "string", ")", "error", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "uid", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "error", ")", "\n", "return", "ret0", "\n", "}" ]

[ "PutBinding", "mocks", "base", "method" ]

[ "func", "ProtoDescriptors", "(", "protoName", "string", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "strings", ".", "HasSuffix", "(", "protoName", ",", "\"", "\"", ")", "{", "descriptor", ":=", "proto", ".", "FileDescriptor", "(", "protoName", ")", "\n", "if", "descriptor", "==", "nil", "{", "return", "nil", ",", "constants", ".", "ErrProtodescriptor", "\n", "}", "\n", "return", "descriptor", ",", "nil", "\n", "}", "\n\n", "if", "strings", ".", "HasPrefix", "(", "protoName", ",", "\"", "\"", ")", "{", "protoName", "=", "strings", ".", "Replace", "(", "protoName", ",", "\"", "\"", ",", "\"", "\"", ",", "1", ")", "\n", "}", "\n", "protoReflectTypePointer", ":=", "proto", ".", "MessageType", "(", "protoName", ")", "\n", "if", "protoReflectTypePointer", "==", "nil", "{", "return", "nil", ",", "constants", ".", "ErrProtodescriptor", "\n", "}", "\n\n", "protoReflectType", ":=", "protoReflectTypePointer", ".", "Elem", "(", ")", "\n", "protoValue", ":=", "reflect", ".", "New", "(", "protoReflectType", ")", "\n", "descriptorMethod", ",", "ok", ":=", "protoReflectTypePointer", ".", "MethodByName", "(", "\"", "\"", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "constants", ".", "ErrProtodescriptor", "\n", "}", "\n\n", "descriptorValue", ":=", "descriptorMethod", ".", "Func", ".", "Call", "(", "[", "]", "reflect", ".", "Value", "{", "protoValue", "}", ")", "\n", "protoDescriptor", ":=", "descriptorValue", "[", "0", "]", ".", "Bytes", "(", ")", "\n\n", "return", "protoDescriptor", ",", "nil", "\n", "}" ]

[ "ProtoDescriptors", "returns", "the", "descriptor", "for", "a", "given", "message", "name", "or", ".", "proto", "file" ]

[ "func", "NewMockPacketDecoder", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockPacketDecoder", "{", "mock", ":=", "&", "MockPacketDecoder", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockPacketDecoderMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

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

[ "func", "(", "m", "*", "MockPacketDecoder", ")", "Decode", "(", "data", "[", "]", "byte", ")", "(", "[", "]", "*", "packet", ".", "Packet", ",", "error", ")", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "data", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "[", "]", "*", "packet", ".", "Packet", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "Decode", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockPacketDecoderMockRecorder", ")", "Decode", "(", "data", "interface", "{", "}", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockPacketDecoder", ")", "(", "nil", ")", ".", "Decode", ")", ",", "data", ")", "\n", "}" ]

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

[ "func", "NewMockRPCServer", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockRPCServer", "{", "mock", ":=", "&", "MockRPCServer", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockRPCServerMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

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

[ "func", "(", "m", "*", "MockRPCServer", ")", "SetPitayaServer", "(", "arg0", "protos", ".", "PitayaServer", ")", "{", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ")", "\n", "}" ]

[ "SetPitayaServer", "mocks", "base", "method" ]

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

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

[ "func", "NewMockRPCClient", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockRPCClient", "{", "mock", ":=", "&", "MockRPCClient", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockRPCClientMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

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

[ "func", "(", "mr", "*", "MockRPCClientMockRecorder", ")", "Send", "(", "route", ",", "data", "interface", "{", "}", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockRPCClient", ")", "(", "nil", ")", ".", "Send", ")", ",", "route", ",", "data", ")", "\n", "}" ]

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

[ "func", "(", "m", "*", "MockRPCClient", ")", "SendPush", "(", "userID", "string", ",", "frontendSv", "*", "cluster", ".", "Server", ",", "push", "*", "protos", ".", "Push", ")", "error", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "userID", ",", "frontendSv", ",", "push", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "error", ")", "\n", "return", "ret0", "\n", "}" ]

[ "SendPush", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockRPCClientMockRecorder", ")", "SendPush", "(", "userID", ",", "frontendSv", ",", "push", "interface", "{", "}", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockRPCClient", ")", "(", "nil", ")", ".", "SendPush", ")", ",", "userID", ",", "frontendSv", ",", "push", ")", "\n", "}" ]

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

[ "func", "(", "m", "*", "MockRPCClient", ")", "SendKick", "(", "userID", ",", "serverType", "string", ",", "kick", "*", "protos", ".", "KickMsg", ")", "error", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "userID", ",", "serverType", ",", "kick", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "error", ")", "\n", "return", "ret0", "\n", "}" ]

[ "SendKick", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockRPCClientMockRecorder", ")", "SendKick", "(", "userID", ",", "serverType", ",", "kick", "interface", "{", "}", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockRPCClient", ")", "(", "nil", ")", ".", "SendKick", ")", ",", "userID", ",", "serverType", ",", "kick", ")", "\n", "}" ]

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

[ "func", "(", "m", "*", "MockRPCClient", ")", "BroadcastSessionBind", "(", "uid", "string", ")", "error", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "uid", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "error", ")", "\n", "return", "ret0", "\n", "}" ]

[ "BroadcastSessionBind", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockRPCClientMockRecorder", ")", "BroadcastSessionBind", "(", "uid", "interface", "{", "}", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockRPCClient", ")", "(", "nil", ")", ".", "BroadcastSessionBind", ")", ",", "uid", ")", "\n", "}" ]

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

[ "func", "(", "m", "*", "MockRPCClient", ")", "Call", "(", "ctx", "context", ".", "Context", ",", "rpcType", "protos", ".", "RPCType", ",", "route", "*", "route", ".", "Route", ",", "session", "*", "session", ".", "Session", ",", "msg", "*", "message", ".", "Message", ",", "server", "*", "cluster", ".", "Server", ")", "(", "*", "protos", ".", "Response", ",", "error", ")", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "ctx", ",", "rpcType", ",", "route", ",", "session", ",", "msg", ",", "server", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "*", "protos", ".", "Response", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "Call", "mocks", "base", "method" ]

[ "func", "NewMockSDListener", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockSDListener", "{", "mock", ":=", "&", "MockSDListener", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockSDListenerMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

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

[ "func", "(", "m", "*", "MockSDListener", ")", "AddServer", "(", "arg0", "*", "cluster", ".", "Server", ")", "{", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ")", "\n", "}" ]

[ "AddServer", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockSDListener", ")", "RemoveServer", "(", "arg0", "*", "cluster", ".", "Server", ")", "{", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ")", "\n", "}" ]

[ "RemoveServer", "mocks", "base", "method" ]

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

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

[ "func", "NewMockRemoteBindingListener", "(", "ctrl", "*", "gomock", ".", "Controller", ")", "*", "MockRemoteBindingListener", "{", "mock", ":=", "&", "MockRemoteBindingListener", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockRemoteBindingListenerMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

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

[ "func", "(", "m", "*", "MockRemoteBindingListener", ")", "OnUserBind", "(", "uid", ",", "fid", "string", ")", "{", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "uid", ",", "fid", ")", "\n", "}" ]

[ "OnUserBind", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockRemoteBindingListenerMockRecorder", ")", "OnUserBind", "(", "uid", ",", "fid", "interface", "{", "}", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockRemoteBindingListener", ")", "(", "nil", ")", ".", "OnUserBind", ")", ",", "uid", ",", "fid", ")", "\n", "}" ]

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

[ "func", "(", "m", "*", "Metagame", ")", "LogRemote", "(", "ctx", "context", ".", "Context", ",", "arg", "*", "protos", ".", "Arg", ")", "(", "*", "protos", ".", "Response", ",", "error", ")", "{", "logger", ".", "Log", ".", "Infof", "(", "\"", "\\n", "\"", ",", "arg", ")", "\n", "return", "&", "protos", ".", "Response", "{", "Code", ":", "200", ",", "Msg", ":", "\"", "\"", "}", ",", "nil", "\n", "}" ]

[ "LogRemote", "logs", "argument", "when", "called" ]

[ "func", "GetFromPropagateCtx", "(", "ctx", "context", ".", "Context", ",", "key", "string", ")", "interface", "{", "}", "{", "propagate", ":=", "ToMap", "(", "ctx", ")", "\n", "if", "val", ",", "ok", ":=", "propagate", "[", "key", "]", ";", "ok", "{", "return", "val", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "GetFromPropagateCtx", "get", "a", "value", "from", "the", "propagate" ]

[ "func", "FromMap", "(", "val", "map", "[", "string", "]", "interface", "{", "}", ")", "context", ".", "Context", "{", "return", "context", ".", "WithValue", "(", "context", ".", "Background", "(", ")", ",", "constants", ".", "PropagateCtxKey", ",", "val", ")", "\n", "}" ]

[ "FromMap", "creates", "a", "new", "context", "from", "a", "map", "with", "propagated", "values" ]

[ "func", "Encode", "(", "ctx", "context", ".", "Context", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "m", ":=", "ToMap", "(", "ctx", ")", "\n", "if", "len", "(", "m", ")", ">", "0", "{", "return", "json", ".", "Marshal", "(", "m", ")", "\n", "}", "\n", "return", "nil", ",", "nil", "\n", "}" ]

[ "Encode", "returns", "the", "given", "propagatable", "context", "encoded", "in", "binary", "format" ]

[ "func", "Decode", "(", "m", "[", "]", "byte", ")", "(", "context", ".", "Context", ",", "error", ")", "{", "if", "len", "(", "m", ")", "==", "0", "{", "// TODO maybe return an error", "return", "nil", ",", "nil", "\n", "}", "\n", "mp", ":=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ",", "0", ")", "\n", "err", ":=", "json", ".", "Unmarshal", "(", "m", ",", "&", "mp", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "FromMap", "(", "mp", ")", ",", "nil", "\n", "}" ]

[ "Decode", "returns", "a", "context", "given", "a", "binary", "encoded", "message" ]

[ "func", "(", "sd", "*", "etcdServiceDiscovery", ")", "renewLease", "(", ")", "error", "{", "c", ":=", "make", "(", "chan", "error", ")", "\n", "go", "func", "(", ")", "{", "defer", "close", "(", "c", ")", "\n", "logger", ".", "Log", ".", "Infof", "(", "\"", "\"", ")", "\n", "err", ":=", "sd", ".", "grantLease", "(", ")", "\n", "if", "err", "!=", "nil", "{", "c", "<-", "err", "\n", "return", "\n", "}", "\n", "err", "=", "sd", ".", "bootstrapServer", "(", "sd", ".", "server", ")", "\n", "c", "<-", "err", "\n", "}", "(", ")", "\n", "select", "{", "case", "err", ":=", "<-", "c", ":", "return", "err", "\n", "case", "<-", "time", ".", "After", "(", "sd", ".", "grantLeaseTimeout", ")", ":", "return", "constants", ".", "ErrEtcdGrantLeaseTimeout", "\n", "}", "\n", "}" ]

[ "renewLease", "reestablishes", "connection", "with", "etcd" ]

[ "func", "(", "sd", "*", "etcdServiceDiscovery", ")", "AddListener", "(", "listener", "SDListener", ")", "{", "sd", ".", "listeners", "=", "append", "(", "sd", ".", "listeners", ",", "listener", ")", "\n", "}" ]

[ "AddListener", "adds", "a", "listener", "to", "etcd", "service", "discovery" ]

[ "func", "(", "sd", "*", "etcdServiceDiscovery", ")", "GetServersByType", "(", "serverType", "string", ")", "(", "map", "[", "string", "]", "*", "Server", ",", "error", ")", "{", "sd", ".", "mapByTypeLock", ".", "RLock", "(", ")", "\n", "defer", "sd", ".", "mapByTypeLock", ".", "RUnlock", "(", ")", "\n", "if", "m", ",", "ok", ":=", "sd", ".", "serverMapByType", "[", "serverType", "]", ";", "ok", "&&", "len", "(", "m", ")", ">", "0", "{", "// Create a new map to avoid concurrent read and write access to the", "// map, this also prevents accidental changes to the list of servers", "// kept by the service discovery.", "ret", ":=", "make", "(", "map", "[", "string", "]", "*", "Server", ",", "len", "(", "sd", ".", "serverMapByType", ")", ")", "\n", "for", "k", ",", "v", ":=", "range", "sd", ".", "serverMapByType", "[", "serverType", "]", "{", "ret", "[", "k", "]", "=", "v", "\n", "}", "\n", "return", "ret", ",", "nil", "\n", "}", "\n", "return", "nil", ",", "constants", ".", "ErrNoServersAvailableOfType", "\n", "}" ]

[ "GetServersByType", "returns", "a", "slice", "with", "all", "the", "servers", "of", "a", "certain", "type" ]

[ "func", "(", "sd", "*", "etcdServiceDiscovery", ")", "GetServers", "(", ")", "[", "]", "*", "Server", "{", "ret", ":=", "make", "(", "[", "]", "*", "Server", ",", "0", ")", "\n", "sd", ".", "serverMapByID", ".", "Range", "(", "func", "(", "k", ",", "v", "interface", "{", "}", ")", "bool", "{", "ret", "=", "append", "(", "ret", ",", "v", ".", "(", "*", "Server", ")", ")", "\n", "return", "true", "\n", "}", ")", "\n", "return", "ret", "\n", "}" ]

[ "GetServers", "returns", "a", "slice", "with", "all", "the", "servers" ]

[ "func", "(", "sd", "*", "etcdServiceDiscovery", ")", "GetServer", "(", "id", "string", ")", "(", "*", "Server", ",", "error", ")", "{", "if", "sv", ",", "ok", ":=", "sd", ".", "serverMapByID", ".", "Load", "(", "id", ")", ";", "ok", "{", "return", "sv", ".", "(", "*", "Server", ")", ",", "nil", "\n", "}", "\n", "return", "nil", ",", "constants", ".", "ErrNoServerWithID", "\n", "}" ]

[ "GetServer", "returns", "a", "server", "given", "it", "s", "id" ]

[ "func", "(", "sd", "*", "etcdServiceDiscovery", ")", "Init", "(", ")", "error", "{", "sd", ".", "running", "=", "true", "\n", "var", "cli", "*", "clientv3", ".", "Client", "\n", "var", "err", "error", "\n", "if", "sd", ".", "cli", "==", "nil", "{", "cli", ",", "err", "=", "clientv3", ".", "New", "(", "clientv3", ".", "Config", "{", "Endpoints", ":", "sd", ".", "etcdEndpoints", ",", "DialTimeout", ":", "sd", ".", "etcdDialTimeout", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "sd", ".", "cli", "=", "cli", "\n", "}", "\n\n", "// namespaced etcd :)", "sd", ".", "cli", ".", "KV", "=", "namespace", ".", "NewKV", "(", "sd", ".", "cli", ".", "KV", ",", "sd", ".", "etcdPrefix", ")", "\n", "sd", ".", "cli", ".", "Watcher", "=", "namespace", ".", "NewWatcher", "(", "sd", ".", "cli", ".", "Watcher", ",", "sd", ".", "etcdPrefix", ")", "\n", "sd", ".", "cli", ".", "Lease", "=", "namespace", ".", "NewLease", "(", "sd", ".", "cli", ".", "Lease", ",", "sd", ".", "etcdPrefix", ")", "\n\n", "err", "=", "sd", ".", "bootstrap", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// update servers", "syncServersTicker", ":=", "time", ".", "NewTicker", "(", "sd", ".", "syncServersInterval", ")", "\n", "go", "func", "(", ")", "{", "for", "sd", ".", "running", "{", "select", "{", "case", "<-", "syncServersTicker", ".", "C", ":", "err", ":=", "sd", ".", "SyncServers", "(", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Log", ".", "Errorf", "(", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "case", "<-", "sd", ".", "stopChan", ":", "return", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n\n", "go", "sd", ".", "watchEtcdChanges", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "Init", "starts", "the", "service", "discovery", "client" ]

[ "func", "(", "sd", "*", "etcdServiceDiscovery", ")", "SyncServers", "(", ")", "error", "{", "keys", ",", "err", ":=", "sd", ".", "cli", ".", "Get", "(", "context", ".", "TODO", "(", ")", ",", "\"", "\"", ",", "clientv3", ".", "WithPrefix", "(", ")", ",", "clientv3", ".", "WithKeysOnly", "(", ")", ",", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// delete invalid servers (local ones that are not in etcd)", "allIds", ":=", "make", "(", "[", "]", "string", ",", "0", ")", "\n\n", "// filter servers I need to grab info", "for", "_", ",", "kv", ":=", "range", "keys", ".", "Kvs", "{", "svType", ",", "svID", ",", "err", ":=", "parseEtcdKey", "(", "string", "(", "kv", ".", "Key", ")", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Log", ".", "Warnf", "(", "\"", "\"", ",", "kv", ".", "Key", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "allIds", "=", "append", "(", "allIds", ",", "svID", ")", "\n", "// TODO is this slow? if so we can paralellize", "if", "_", ",", "ok", ":=", "sd", ".", "serverMapByID", ".", "Load", "(", "svID", ")", ";", "!", "ok", "{", "logger", ".", "Log", ".", "Debugf", "(", "\"", "\"", ",", "svType", ",", "svID", ")", "\n", "sv", ",", "err", ":=", "sd", ".", "getServerFromEtcd", "(", "svType", ",", "svID", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Log", ".", "Errorf", "(", "\"", "\"", ",", "svID", ",", "err", ".", "Error", "(", ")", ")", "\n", "continue", "\n", "}", "\n", "sd", ".", "addServer", "(", "sv", ")", "\n", "}", "\n", "}", "\n", "sd", ".", "deleteLocalInvalidServers", "(", "allIds", ")", "\n\n", "sd", ".", "printServers", "(", ")", "\n", "sd", ".", "lastSyncTime", "=", "time", ".", "Now", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "SyncServers", "gets", "all", "servers", "from", "etcd" ]

[ "func", "(", "sd", "*", "etcdServiceDiscovery", ")", "revoke", "(", ")", "error", "{", "close", "(", "sd", ".", "stopLeaseChan", ")", "\n", "c", ":=", "make", "(", "chan", "error", ")", "\n", "defer", "close", "(", "c", ")", "\n", "go", "func", "(", ")", "{", "logger", ".", "Log", ".", "Debug", "(", "\"", "\"", ")", "\n", "_", ",", "err", ":=", "sd", ".", "cli", ".", "Revoke", "(", "context", ".", "TODO", "(", ")", ",", "sd", ".", "leaseID", ")", "\n", "c", "<-", "err", "\n", "logger", ".", "Log", ".", "Debug", "(", "\"", "\"", ")", "\n", "}", "(", ")", "\n", "select", "{", "case", "err", ":=", "<-", "c", ":", "return", "err", "// completed normally", "\n", "case", "<-", "time", ".", "After", "(", "sd", ".", "revokeTimeout", ")", ":", "logger", ".", "Log", ".", "Warn", "(", "\"", "\"", ")", "\n", "return", "nil", "// timed out", "\n", "}", "\n", "}" ]

[ "revoke", "prevents", "Pitaya", "from", "crashing", "when", "etcd", "is", "not", "available" ]