Datasets:

---

CM

/

codexglue_code2text_go

like 1

[ "func", "setProducerRequiredAcks", "(", "cfg", "*", "Config", ")", "error", "{", "switch", "cfg", ".", "RequiredAcks", "{", "case", "NoResponse", ":", "cfg", ".", "ProducerConfig", "(", ")", ".", "Producer", ".", "RequiredAcks", "=", "sarama", ".", "NoResponse", "\n", "return", "nil", "\n", "case", "WaitForLocal", ":", "cfg", ".", "ProducerConfig", "(", ")", ".", "Producer", ".", "RequiredAcks", "=", "sarama", ".", "WaitForLocal", "\n", "return", "nil", "\n", "case", "WaitForAll", ":", "cfg", ".", "ProducerConfig", "(", ")", ".", "Producer", ".", "RequiredAcks", "=", "sarama", ".", "WaitForAll", "\n", "return", "nil", "\n", "default", ":", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "setProducerRequiredAcks", "set", "the", "RequiredAcks", "field", "for", "a", "producer" ]

[ "func", "(", "conn", "*", "ProtoConnection", ")", "NewSyncPublisher", "(", "topic", "string", ")", "(", "messaging", ".", "ProtoPublisher", ",", "error", ")", "{", "return", "&", "protoSyncPublisherKafka", "{", "conn", ",", "topic", "}", ",", "nil", "\n", "}" ]

[ "NewSyncPublisher", "creates", "a", "new", "instance", "of", "protoSyncPublisherKafka", "that", "allows", "to", "publish", "sync", "kafka", "messages", "using", "common", "messaging", "API" ]

[ "func", "(", "conn", "*", "ProtoConnection", ")", "NewAsyncPublisher", "(", "topic", "string", ",", "successClb", "func", "(", "messaging", ".", "ProtoMessage", ")", ",", "errorClb", "func", "(", "messaging", ".", "ProtoMessageErr", ")", ")", "(", "messaging", ".", "ProtoPublisher", ",", "error", ")", "{", "return", "&", "protoAsyncPublisherKafka", "{", "conn", ",", "topic", ",", "successClb", ",", "errorClb", "}", ",", "nil", "\n", "}" ]

[ "NewAsyncPublisher", "creates", "a", "new", "instance", "of", "protoAsyncPublisherKafka", "that", "allows", "to", "publish", "sync", "kafka", "messages", "using", "common", "messaging", "API" ]

[ "func", "(", "conn", "*", "ProtoManualConnection", ")", "NewSyncPublisherToPartition", "(", "topic", "string", ",", "partition", "int32", ")", "(", "messaging", ".", "ProtoPublisher", ",", "error", ")", "{", "return", "&", "protoManualSyncPublisherKafka", "{", "conn", ",", "topic", ",", "partition", "}", ",", "nil", "\n", "}" ]

[ "NewSyncPublisherToPartition", "creates", "a", "new", "instance", "of", "protoManualSyncPublisherKafka", "that", "allows", "to", "publish", "sync", "kafka", "messages", "using", "common", "messaging", "API" ]

[ "func", "(", "conn", "*", "ProtoManualConnection", ")", "NewAsyncPublisherToPartition", "(", "topic", "string", ",", "partition", "int32", ",", "successClb", "func", "(", "messaging", ".", "ProtoMessage", ")", ",", "errorClb", "func", "(", "messaging", ".", "ProtoMessageErr", ")", ")", "(", "messaging", ".", "ProtoPublisher", ",", "error", ")", "{", "return", "&", "protoManualAsyncPublisherKafka", "{", "conn", ",", "topic", ",", "partition", ",", "successClb", ",", "errorClb", "}", ",", "nil", "\n", "}" ]

[ "NewAsyncPublisherToPartition", "creates", "a", "new", "instance", "of", "protoManualAsyncPublisherKafka", "that", "allows", "to", "publish", "sync", "kafka", "messages", "using", "common", "messaging", "API", "." ]

[ "func", "(", "conn", "*", "ProtoConnection", ")", "Watch", "(", "msgClb", "func", "(", "messaging", ".", "ProtoMessage", ")", ",", "topics", "...", "string", ")", "error", "{", "return", "conn", ".", "ConsumeTopic", "(", "msgClb", ",", "topics", "...", ")", "\n", "}" ]

[ "Watch", "is", "an", "alias", "for", "ConsumeTopic", "method", ".", "The", "alias", "was", "added", "in", "order", "to", "conform", "to", "messaging", ".", "Mux", "interface", "." ]

[ "func", "(", "conn", "*", "ProtoConnection", ")", "ConsumeTopic", "(", "msgClb", "func", "(", "messaging", ".", "ProtoMessage", ")", ",", "topics", "...", "string", ")", "error", "{", "conn", ".", "multiplexer", ".", "rwlock", ".", "Lock", "(", ")", "\n", "defer", "conn", ".", "multiplexer", ".", "rwlock", ".", "Unlock", "(", ")", "\n\n", "if", "conn", ".", "multiplexer", ".", "started", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "byteClb", ":=", "func", "(", "bm", "*", "client", ".", "ConsumerMessage", ")", "{", "pm", ":=", "client", ".", "NewProtoConsumerMessage", "(", "bm", ",", "conn", ".", "serializer", ")", "\n", "msgClb", "(", "pm", ")", "\n", "}", "\n\n", "for", "_", ",", "topic", ":=", "range", "topics", "{", "// check if we have already consumed the topic", "var", "found", "bool", "\n", "var", "subs", "*", "consumerSubscription", "\n", "LoopSubs", ":", "for", "_", ",", "subscription", ":=", "range", "conn", ".", "multiplexer", ".", "mapping", "{", "if", "subscription", ".", "manual", "==", "true", "{", "// do not mix dynamic and manual mode", "continue", "\n", "}", "\n", "if", "subscription", ".", "topic", "==", "topic", "{", "found", "=", "true", "\n", "subs", "=", "subscription", "\n", "break", "LoopSubs", "\n", "}", "\n", "}", "\n\n", "if", "!", "found", "{", "subs", "=", "&", "consumerSubscription", "{", "manual", ":", "false", ",", "// non-manual example", "topic", ":", "topic", ",", "connectionName", ":", "conn", ".", "name", ",", "byteConsMsg", ":", "byteClb", ",", "}", "\n", "// subscribe new topic", "conn", ".", "multiplexer", ".", "mapping", "=", "append", "(", "conn", ".", "multiplexer", ".", "mapping", ",", "subs", ")", "\n", "}", "\n\n", "// add subscription to consumerList", "subs", ".", "byteConsMsg", "=", "byteClb", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "ConsumeTopic", "is", "called", "to", "start", "consuming", "given", "topics", ".", "Function", "can", "be", "called", "until", "the", "multiplexer", "is", "started", "it", "returns", "an", "error", "otherwise", ".", "The", "provided", "channel", "should", "be", "buffered", "otherwise", "messages", "might", "be", "lost", "." ]

[ "func", "(", "conn", "*", "ProtoManualConnection", ")", "WatchPartition", "(", "msgClb", "func", "(", "messaging", ".", "ProtoMessage", ")", ",", "topic", "string", ",", "partition", "int32", ",", "offset", "int64", ")", "error", "{", "return", "conn", ".", "ConsumePartition", "(", "msgClb", ",", "topic", ",", "partition", ",", "offset", ")", "\n", "}" ]

[ "WatchPartition", "is", "an", "alias", "for", "ConsumePartition", "method", ".", "The", "alias", "was", "added", "in", "order", "to", "conform", "to", "messaging", ".", "Mux", "interface", "." ]

[ "func", "(", "conn", "*", "ProtoConnectionFields", ")", "StopWatchPartition", "(", "topic", "string", ",", "partition", "int32", ",", "offset", "int64", ")", "error", "{", "return", "conn", ".", "StopConsumingPartition", "(", "topic", ",", "partition", ",", "offset", ")", "\n", "}" ]

[ "StopWatchPartition", "is", "an", "alias", "for", "StopConsumingPartition", "method", ".", "The", "alias", "was", "added", "in", "order", "to", "conform", "to", "messaging", ".", "Mux", "interface", "." ]

[ "func", "(", "conn", "*", "ProtoConnectionFields", ")", "StopConsumingPartition", "(", "topic", "string", ",", "partition", "int32", ",", "offset", "int64", ")", "error", "{", "return", "conn", ".", "multiplexer", ".", "stopConsumingPartition", "(", "topic", ",", "partition", ",", "offset", ",", "conn", ".", "name", ")", "\n", "}" ]

[ "StopConsumingPartition", "cancels", "the", "previously", "created", "subscription", "for", "consuming", "the", "topic", "partition", "and", "offset" ]

[ "func", "(", "conn", "*", "ProtoConnectionFields", ")", "sendSyncMessage", "(", "topic", "string", ",", "partition", "int32", ",", "key", "string", ",", "value", "proto", ".", "Message", ",", "manualMode", "bool", ")", "(", "offset", "int64", ",", "err", "error", ")", "{", "data", ",", "err", ":=", "conn", ".", "serializer", ".", "Marshal", "(", "value", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "if", "manualMode", "{", "msg", ",", "err", ":=", "conn", ".", "multiplexer", ".", "manSyncProducer", ".", "SendMsgToPartition", "(", "topic", ",", "partition", ",", "sarama", ".", "StringEncoder", "(", "key", ")", ",", "sarama", ".", "ByteEncoder", "(", "data", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "return", "msg", ".", "Offset", ",", "err", "\n", "}", "\n", "msg", ",", "err", ":=", "conn", ".", "multiplexer", ".", "hashSyncProducer", ".", "SendMsgToPartition", "(", "topic", ",", "partition", ",", "sarama", ".", "StringEncoder", "(", "key", ")", ",", "sarama", ".", "ByteEncoder", "(", "data", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "return", "msg", ".", "Offset", ",", "err", "\n", "}" ]

[ "sendSyncMessage", "sends", "a", "message", "using", "the", "sync", "API", ".", "If", "manual", "mode", "is", "chosen", "the", "appropriate", "producer", "will", "be", "used", "." ]

[ "func", "(", "conn", "*", "ProtoConnectionFields", ")", "sendAsyncMessage", "(", "topic", "string", ",", "partition", "int32", ",", "key", "string", ",", "value", "proto", ".", "Message", ",", "manualMode", "bool", ",", "meta", "interface", "{", "}", ",", "successClb", "func", "(", "messaging", ".", "ProtoMessage", ")", ",", "errClb", "func", "(", "messaging", ".", "ProtoMessageErr", ")", ")", "error", "{", "data", ",", "err", ":=", "conn", ".", "serializer", ".", "Marshal", "(", "value", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "succByteClb", ":=", "func", "(", "msg", "*", "client", ".", "ProducerMessage", ")", "{", "protoMsg", ":=", "&", "client", ".", "ProtoProducerMessage", "{", "ProducerMessage", ":", "msg", ",", "Serializer", ":", "conn", ".", "serializer", ",", "}", "\n", "successClb", "(", "protoMsg", ")", "\n", "}", "\n\n", "errByteClb", ":=", "func", "(", "msg", "*", "client", ".", "ProducerError", ")", "{", "protoMsg", ":=", "&", "client", ".", "ProtoProducerMessageErr", "{", "ProtoProducerMessage", ":", "&", "client", ".", "ProtoProducerMessage", "{", "ProducerMessage", ":", "msg", ".", "ProducerMessage", ",", "Serializer", ":", "conn", ".", "serializer", ",", "}", ",", "Err", ":", "msg", ".", "Err", ",", "}", "\n", "errClb", "(", "protoMsg", ")", "\n", "}", "\n\n", "if", "manualMode", "{", "auxMeta", ":=", "&", "asyncMeta", "{", "successClb", ":", "succByteClb", ",", "errorClb", ":", "errByteClb", ",", "usersMeta", ":", "meta", "}", "\n", "conn", ".", "multiplexer", ".", "manAsyncProducer", ".", "SendMsgToPartition", "(", "topic", ",", "partition", ",", "sarama", ".", "StringEncoder", "(", "key", ")", ",", "sarama", ".", "ByteEncoder", "(", "data", ")", ",", "auxMeta", ")", "\n", "return", "nil", "\n", "}", "\n", "auxMeta", ":=", "&", "asyncMeta", "{", "successClb", ":", "succByteClb", ",", "errorClb", ":", "errByteClb", ",", "usersMeta", ":", "meta", "}", "\n", "conn", ".", "multiplexer", ".", "hashAsyncProducer", ".", "SendMsgToPartition", "(", "topic", ",", "partition", ",", "sarama", ".", "StringEncoder", "(", "key", ")", ",", "sarama", ".", "ByteEncoder", "(", "data", ")", ",", "auxMeta", ")", "\n", "return", "nil", "\n", "}" ]

[ "sendAsyncMessage", "sends", "a", "message", "using", "the", "async", "API", ".", "If", "manual", "mode", "is", "chosen", "the", "appropriate", "producer", "will", "be", "used", "." ]

[ "func", "(", "a", "Authenticator", ")", "Authenticate", "(", "ctx", "context", ".", "Context", ")", "(", "newCtx", "context", ".", "Context", ",", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "if", "err", "==", "nil", "{", "// Store user metadata", "userMD", ":=", "&", "UserMetadata", "{", "ID", ":", "a", ".", "Username", ",", "}", "\n", "newCtx", "=", "context", ".", "WithValue", "(", "newCtx", ",", "userMDKey", "{", "}", ",", "userMD", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "err", "=", "a", ".", "tryTLSAuth", "(", "ctx", ")", "\n", "if", "err", "==", "nil", "{", "return", "ctx", ",", "nil", "\n", "}", "\n\n", "newCtx", ",", "err", "=", "a", ".", "tryTokenAuth", "(", "ctx", ")", "\n", "if", "err", "==", "nil", "{", "return", "newCtx", ",", "nil", "\n", "}", "\n\n", "return", "a", ".", "tryBasicAuth", "(", "ctx", ")", "\n", "}" ]

[ "Authenticate", "checks", "that", "a", "token", "exists", "and", "is", "valid", ".", "It", "stores", "the", "user", "metadata", "in", "the", "returned", "context", "and", "removes", "the", "token", "from", "the", "context", "." ]

[ "func", "GetUserMetadata", "(", "ctx", "context", ".", "Context", ")", "(", "*", "UserMetadata", ",", "bool", ")", "{", "userMD", ":=", "ctx", ".", "Value", "(", "userMDKey", "{", "}", ")", "\n\n", "switch", "md", ":=", "userMD", ".", "(", "type", ")", "{", "case", "*", "UserMetadata", ":", "return", "md", ",", "true", "\n", "default", ":", "return", "nil", ",", "false", "\n", "}", "\n", "}" ]

[ "GetUserMetadata", "can", "be", "used", "to", "extract", "user", "metadata", "stored", "in", "a", "context", "." ]

[ "func", "(", "pdb", "*", "BrokerWatcher", ")", "Put", "(", "key", "string", ",", "data", "[", "]", "byte", ",", "opts", "...", "datasync", ".", "PutOption", ")", "error", "{", "return", "pdb", ".", "Client", ".", "Put", "(", "pdb", ".", "prefixKey", "(", "key", ")", ",", "data", ",", "opts", "...", ")", "\n", "}" ]

[ "Put", "calls", "client", "s", "Put", "method" ]

[ "func", "(", "pdb", "*", "BrokerWatcher", ")", "GetValue", "(", "key", "string", ")", "(", "data", "[", "]", "byte", ",", "found", "bool", ",", "revision", "int64", ",", "err", "error", ")", "{", "return", "pdb", ".", "Client", ".", "GetValue", "(", "pdb", ".", "prefixKey", "(", "key", ")", ")", "\n", "}" ]

[ "GetValue", "calls", "client", "s", "GetValue", "method" ]

[ "func", "(", "pdb", "*", "BrokerWatcher", ")", "Delete", "(", "key", "string", ",", "opts", "...", "datasync", ".", "DelOption", ")", "(", "existed", "bool", ",", "err", "error", ")", "{", "return", "pdb", ".", "Client", ".", "Delete", "(", "pdb", ".", "prefixKey", "(", "key", ")", ",", "opts", "...", ")", "\n", "}" ]

[ "Delete", "calls", "client", "s", "Delete", "method" ]

[ "func", "(", "pdb", "*", "BrokerWatcher", ")", "ListValues", "(", "key", "string", ")", "(", "keyval", ".", "BytesKeyValIterator", ",", "error", ")", "{", "keyValues", ":=", "pdb", ".", "db", ".", "GetDataForPrefix", "(", "pdb", ".", "prefixKey", "(", "key", ")", ")", "\n", "data", ":=", "make", "(", "[", "]", "*", "decoder", ".", "FileDataEntry", ",", "0", ",", "len", "(", "keyValues", ")", ")", "\n", "for", "_", ",", "entry", ":=", "range", "keyValues", "{", "data", "=", "append", "(", "data", ",", "&", "decoder", ".", "FileDataEntry", "{", "Key", ":", "strings", ".", "TrimPrefix", "(", "entry", ".", "Key", ",", "pdb", ".", "prefix", ")", ",", "Value", ":", "entry", ".", "Value", ",", "}", ")", "\n", "}", "\n", "return", "&", "bytesKeyValIterator", "{", "len", ":", "len", "(", "data", ")", ",", "data", ":", "data", "}", ",", "nil", "\n", "}" ]

[ "ListValues", "returns", "a", "list", "of", "all", "database", "values", "for", "given", "key" ]

[ "func", "(", "pdb", "*", "BrokerWatcher", ")", "ListKeys", "(", "prefix", "string", ")", "(", "keyval", ".", "BytesKeyIterator", ",", "error", ")", "{", "entries", ":=", "pdb", ".", "Client", ".", "db", ".", "GetDataForPrefix", "(", "prefix", ")", "\n", "var", "keys", "[", "]", "string", "\n", "for", "_", ",", "entry", ":=", "range", "entries", "{", "keys", "=", "append", "(", "keys", ",", "entry", ".", "Key", ")", "\n", "}", "\n", "return", "&", "bytesKeyIterator", "{", "len", ":", "len", "(", "keys", ")", ",", "keys", ":", "keys", ",", "prefix", ":", "pdb", ".", "prefix", "}", ",", "nil", "\n", "}" ]

[ "ListKeys", "returns", "a", "list", "of", "all", "database", "keys", "for", "given", "prefix" ]

[ "func", "New", "(", ")", "*", "Agent", "{", "hw", ":=", "&", "HelloWorld", "{", "}", "\n", "hu", ":=", "&", "HelloUniverse", "{", "}", "\n\n", "hw", ".", "Universe", "=", "hu", "\n", "hu", ".", "World", "=", "hw", "\n\n", "return", "&", "Agent", "{", "Hu", ":", "hu", ",", "Hw", ":", "hw", ",", "}", "\n", "}" ]

[ "New", "returns", "top", "-", "level", "plugin", "object", "with", "defined", "plugins", "and", "their", "dependencies" ]

[ "func", "(", "p", "*", "Plugin", ")", "Init", "(", ")", "(", "err", "error", ")", "{", "if", "p", ".", "Config", "==", "nil", "{", "p", ".", "Config", "=", "DefaultConfig", "(", ")", "\n", "}", "\n", "if", "err", ":=", "PluginConfig", "(", "p", ".", "Cfg", ",", "p", ".", "Config", ",", "p", ".", "PluginName", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// if there is no injected authenticator and there are credentials defined in the config file", "// instantiate staticAuthenticator otherwise do not use basic Auth", "if", "p", ".", "Authenticator", "==", "nil", "&&", "len", "(", "p", ".", "Config", ".", "ClientBasicAuth", ")", ">", "0", "{", "p", ".", "Authenticator", ",", "err", "=", "newStaticAuthenticator", "(", "p", ".", "Config", ".", "ClientBasicAuth", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "p", ".", "mx", "=", "mux", ".", "NewRouter", "(", ")", "\n", "p", ".", "formatter", "=", "render", ".", "New", "(", "render", ".", "Options", "{", "IndentJSON", ":", "true", ",", "}", ")", "\n\n", "// Enable authentication if defined by config", "if", "p", ".", "EnableTokenAuth", "{", "p", ".", "Log", ".", "Info", "(", "\"", "\"", ")", "\n", "p", ".", "auth", "=", "security", ".", "NewAuthenticator", "(", "p", ".", "mx", ",", "&", "security", ".", "Settings", "{", "Users", ":", "p", ".", "Users", ",", "ExpTime", ":", "p", ".", "TokenExpiration", ",", "Cost", ":", "p", ".", "PasswordHashCost", ",", "Signature", ":", "p", ".", "TokenSignature", ",", "}", ",", "p", ".", "Log", ")", "\n", "}", "\n\n", "return", "err", "\n", "}" ]

[ "Init", "is", "the", "plugin", "entry", "point", "called", "by", "Agent", "Core", "-", "It", "prepares", "Gorilla", "MUX", "HTTP", "Router" ]

[ "func", "(", "p", "*", "Plugin", ")", "AfterInit", "(", ")", "(", "err", "error", ")", "{", "cfgCopy", ":=", "*", "p", ".", "Config", "\n\n", "var", "handler", "http", ".", "Handler", "=", "p", ".", "mx", "\n", "if", "p", ".", "Authenticator", "!=", "nil", "{", "handler", "=", "auth", "(", "handler", ",", "p", ".", "Authenticator", ")", "\n", "}", "\n\n", "p", ".", "server", ",", "err", "=", "ListenAndServe", "(", "cfgCopy", ",", "handler", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "cfgCopy", ".", "UseHTTPS", "(", ")", "{", "p", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "cfgCopy", ".", "Endpoint", ")", "\n", "}", "else", "{", "p", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "cfgCopy", ".", "Endpoint", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "AfterInit", "starts", "the", "HTTP", "server", "." ]

[ "func", "(", "p", "*", "Plugin", ")", "RegisterPermissionGroup", "(", "group", "...", "*", "access", ".", "PermissionGroup", ")", "{", "if", "p", ".", "Config", ".", "EnableTokenAuth", "{", "p", ".", "Log", ".", "Debugf", "(", "\"", "\"", ",", "group", ")", "\n", "p", ".", "auth", ".", "AddPermissionGroup", "(", "group", "...", ")", "\n", "}", "\n", "}" ]

[ "RegisterPermissionGroup", "adds", "new", "permission", "group", "if", "token", "authentication", "is", "enabled" ]

[ "func", "(", "p", "*", "Plugin", ")", "GetPort", "(", ")", "int", "{", "if", "p", ".", "Config", "!=", "nil", "{", "return", "p", ".", "Config", ".", "GetPort", "(", ")", "\n", "}", "\n", "return", "0", "\n", "}" ]

[ "GetPort", "returns", "plugin", "configuration", "port" ]

[ "func", "(", "adapter", "*", "Registry", ")", "Watch", "(", "resyncName", "string", ",", "changeChan", "chan", "datasync", ".", "ChangeEvent", ",", "resyncChan", "chan", "datasync", ".", "ResyncEvent", ",", "keyPrefixes", "...", "string", ")", "(", "datasync", ".", "WatchRegistration", ",", "error", ")", "{", "adapter", ".", "access", ".", "Lock", "(", ")", "\n", "defer", "adapter", ".", "access", ".", "Unlock", "(", ")", "\n\n", "if", "_", ",", "found", ":=", "adapter", ".", "subscriptions", "[", "resyncName", "]", ";", "found", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", "+", "resyncName", ")", "\n", "}", "\n\n", "adapter", ".", "subscriptions", "[", "resyncName", "]", "=", "&", "Subscription", "{", "ResyncName", ":", "resyncName", ",", "ChangeChan", ":", "changeChan", ",", "ResyncChan", ":", "resyncChan", ",", "CloseChan", ":", "make", "(", "chan", "string", ")", ",", "KeyPrefixes", ":", "keyPrefixes", ",", "}", "\n\n", "return", "&", "WatchDataReg", "{", "resyncName", ",", "adapter", "}", ",", "nil", "\n", "}" ]

[ "Watch", "only", "appends", "channels", "." ]

[ "func", "(", "adapter", "*", "Registry", ")", "PropagateChanges", "(", "ctx", "context", ".", "Context", ",", "txData", "map", "[", "string", "]", "datasync", ".", "ChangeValue", ")", "error", "{", "var", "events", "[", "]", "func", "(", "done", "chan", "error", ")", "\n\n", "for", "_", ",", "sub", ":=", "range", "adapter", ".", "subscriptions", "{", "var", "changes", "[", "]", "datasync", ".", "ProtoWatchResp", "\n\n", "for", "_", ",", "prefix", ":=", "range", "sub", ".", "KeyPrefixes", "{", "for", "key", ",", "val", ":=", "range", "txData", "{", "if", "!", "strings", ".", "HasPrefix", "(", "key", ",", "prefix", ")", "{", "continue", "\n", "}", "\n\n", "var", "(", "prev", "datasync", ".", "KeyVal", "\n", "curRev", "int64", "\n", ")", "\n\n", "if", "val", ".", "GetChangeType", "(", ")", "==", "datasync", ".", "Delete", "{", "if", "_", ",", "prev", "=", "adapter", ".", "lastRev", ".", "Del", "(", "key", ")", ";", "prev", "!=", "nil", "{", "curRev", "=", "prev", ".", "GetRevision", "(", ")", "+", "1", "\n", "}", "else", "{", "continue", "\n", "}", "\n", "}", "else", "{", "_", ",", "prev", ",", "curRev", "=", "adapter", ".", "lastRev", ".", "Put", "(", "key", ",", "val", ")", "\n", "}", "\n\n", "changes", "=", "append", "(", "changes", ",", "&", "ChangeResp", "{", "Key", ":", "key", ",", "ChangeType", ":", "val", ".", "GetChangeType", "(", ")", ",", "CurrVal", ":", "val", ",", "CurrRev", ":", "curRev", ",", "PrevVal", ":", "prev", ",", "}", ")", "\n", "}", "\n", "}", "\n\n", "if", "len", "(", "changes", ")", ">", "0", "{", "sendTo", ":=", "func", "(", "sub", "*", "Subscription", ")", "func", "(", "done", "chan", "error", ")", "{", "return", "func", "(", "done", "chan", "error", ")", "{", "sub", ".", "ChangeChan", "<-", "&", "ChangeEvent", "{", "ctx", ":", "ctx", ",", "Changes", ":", "changes", ",", "delegate", ":", "&", "DoneChannel", "{", "done", "}", ",", "}", "\n", "}", "\n", "}", "\n", "events", "=", "append", "(", "events", ",", "sendTo", "(", "sub", ")", ")", "\n", "}", "\n", "}", "\n\n", "done", ":=", "make", "(", "chan", "error", ",", "1", ")", "\n", "go", "AggregateDone", "(", "events", ",", "done", ")", "\n\n", "select", "{", "case", "err", ":=", "<-", "done", ":", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "case", "<-", "time", ".", "After", "(", "PropagateChangesTimeout", ")", ":", "logrus", ".", "DefaultLogger", "(", ")", ".", "Warnf", "(", "\"", "\"", ",", "PropagateChangesTimeout", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "PropagateChanges", "fills", "registered", "channels", "with", "the", "data", "." ]

[ "func", "(", "adapter", "*", "Registry", ")", "PropagateResync", "(", "ctx", "context", ".", "Context", ",", "txData", "map", "[", "string", "]", "datasync", ".", "ChangeValue", ")", "error", "{", "var", "events", "[", "]", "func", "(", "done", "chan", "error", ")", "\n", "adapter", ".", "lastRev", ".", "Cleanup", "(", ")", "\n\n", "for", "_", ",", "sub", ":=", "range", "adapter", ".", "subscriptions", "{", "items", ":=", "map", "[", "string", "]", "datasync", ".", "KeyValIterator", "{", "}", "\n\n", "for", "_", ",", "prefix", ":=", "range", "sub", ".", "KeyPrefixes", "{", "var", "kvs", "[", "]", "datasync", ".", "KeyVal", "\n\n", "for", "key", ",", "val", ":=", "range", "txData", "{", "if", "strings", ".", "HasPrefix", "(", "key", ",", "prefix", ")", "{", "// TODO: call Put only once for each key (different subscriptions)", "adapter", ".", "lastRev", ".", "PutWithRevision", "(", "key", ",", "val", ")", "\n\n", "kvs", "=", "append", "(", "kvs", ",", "&", "KeyVal", "{", "key", ":", "key", ",", "LazyValue", ":", "val", ",", "rev", ":", "val", ".", "GetRevision", "(", ")", ",", "}", ")", "\n", "}", "\n", "}", "\n", "items", "[", "prefix", "]", "=", "NewKVIterator", "(", "kvs", ")", "\n", "}", "\n\n", "sendTo", ":=", "func", "(", "sub", "*", "Subscription", ")", "func", "(", "done", "chan", "error", ")", "{", "return", "func", "(", "done", "chan", "error", ")", "{", "sub", ".", "ResyncChan", "<-", "&", "ResyncEventDB", "{", "ctx", ":", "ctx", ",", "its", ":", "items", ",", "DoneChannel", ":", "NewDoneChannel", "(", "done", ")", ",", "}", "\n", "}", "\n", "}", "\n", "events", "=", "append", "(", "events", ",", "sendTo", "(", "sub", ")", ")", "\n", "}", "\n\n", "done", ":=", "make", "(", "chan", "error", ",", "1", ")", "\n", "go", "AggregateDone", "(", "events", ",", "done", ")", "\n\n", "select", "{", "case", "err", ":=", "<-", "done", ":", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// TODO: maybe higher timeout for resync event?", "case", "<-", "time", ".", "After", "(", "PropagateChangesTimeout", ")", ":", "logrus", ".", "DefaultLogger", "(", ")", ".", "Warnf", "(", "\"", "\"", ",", "PropagateChangesTimeout", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "PropagateResync", "fills", "registered", "channels", "with", "the", "data", "." ]

[ "func", "(", "reg", "*", "WatchDataReg", ")", "Close", "(", ")", "error", "{", "reg", ".", "adapter", ".", "access", ".", "Lock", "(", ")", "\n", "defer", "reg", ".", "adapter", ".", "access", ".", "Unlock", "(", ")", "\n\n", "for", "_", ",", "sub", ":=", "range", "reg", ".", "adapter", ".", "subscriptions", "{", "// subscription should have also change channel, otherwise it is not registered", "// for change events", "if", "sub", ".", "ChangeChan", "!=", "nil", "&&", "sub", ".", "CloseChan", "!=", "nil", "{", "// close the channel with all goroutines under subscription", "safeclose", ".", "Close", "(", "sub", ".", "CloseChan", ")", "\n", "}", "\n", "}", "\n\n", "delete", "(", "reg", ".", "adapter", ".", "subscriptions", ",", "reg", ".", "ResyncName", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "Close", "stops", "watching", "of", "particular", "KeyPrefixes", "." ]

[ "func", "(", "reg", "*", "WatchDataReg", ")", "Register", "(", "resyncName", ",", "keyPrefix", "string", ")", "error", "{", "reg", ".", "adapter", ".", "access", ".", "Lock", "(", ")", "\n", "defer", "reg", ".", "adapter", ".", "access", ".", "Unlock", "(", ")", "\n\n", "for", "resName", ",", "sub", ":=", "range", "reg", ".", "adapter", ".", "subscriptions", "{", "if", "resName", "==", "resyncName", "{", "// Verify that prefix does not exist yet", "for", "_", ",", "regPrefix", ":=", "range", "sub", ".", "KeyPrefixes", "{", "if", "regPrefix", "==", "keyPrefix", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "keyPrefix", ")", "\n", "}", "\n", "}", "\n", "sub", ".", "KeyPrefixes", "=", "append", "(", "sub", ".", "KeyPrefixes", ",", "keyPrefix", ")", "\n", "return", "nil", "\n", "}", "\n", "}", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "keyPrefix", ",", "resyncName", ")", "\n", "}" ]

[ "Register", "starts", "watching", "of", "particular", "key", "prefix", ".", "Method", "returns", "error", "if", "key", "which", "should", "be", "added", "already", "exists" ]

[ "func", "(", "reg", "*", "WatchDataReg", ")", "Unregister", "(", "keyPrefix", "string", ")", "error", "{", "reg", ".", "adapter", ".", "access", ".", "Lock", "(", ")", "\n", "defer", "reg", ".", "adapter", ".", "access", ".", "Unlock", "(", ")", "\n\n", "subs", ":=", "reg", ".", "adapter", ".", "subscriptions", "[", "reg", ".", "ResyncName", "]", "\n", "// verify if key is registered for change events", "if", "subs", ".", "ChangeChan", "==", "nil", "{", "// not an error", "logrus", ".", "DefaultLogger", "(", ")", ".", "Infof", "(", "\"", "\"", ",", "keyPrefix", ")", "\n", "return", "nil", "\n", "}", "\n", "if", "subs", ".", "CloseChan", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "keyPrefix", ")", "\n", "}", "\n\n", "for", "index", ",", "prefix", ":=", "range", "subs", ".", "KeyPrefixes", "{", "if", "prefix", "==", "keyPrefix", "{", "subs", ".", "KeyPrefixes", "=", "append", "(", "subs", ".", "KeyPrefixes", "[", ":", "index", "]", ",", "subs", ".", "KeyPrefixes", "[", "index", "+", "1", ":", "]", "...", ")", "\n", "subs", ".", "CloseChan", "<-", "keyPrefix", "\n", "logrus", ".", "DefaultLogger", "(", ")", ".", "WithField", "(", "\"", "\"", ",", "reg", ".", "ResyncName", ")", ".", "Infof", "(", "\"", "\"", ",", "keyPrefix", ")", "\n", "return", "nil", "\n", "}", "\n", "}", "\n\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "keyPrefix", ")", "\n", "}" ]

[ "Unregister", "stops", "watching", "of", "particular", "key", "prefix", ".", "Method", "returns", "error", "if", "key", "which", "should", "be", "removed", "does", "not", "exist", "or", "in", "case", "the", "channel", "to", "close", "goroutine", "is", "nil" ]

[ "func", "StartTimeout", "(", "timeout", "time", ".", "Duration", ")", "Option", "{", "return", "func", "(", "o", "*", "Options", ")", "{", "o", ".", "StartTimeout", "=", "timeout", "\n", "}", "\n", "}" ]

[ "StartTimeout", "returns", "an", "Option", "that", "sets", "timeout", "for", "the", "start", "of", "Agent", "." ]

[ "func", "StopTimeout", "(", "timeout", "time", ".", "Duration", ")", "Option", "{", "return", "func", "(", "o", "*", "Options", ")", "{", "o", ".", "StopTimeout", "=", "timeout", "\n", "}", "\n", "}" ]

[ "StopTimeout", "returns", "an", "Option", "that", "sets", "timeout", "for", "the", "stop", "of", "Agent", "." ]

[ "func", "Version", "(", "buildVer", ",", "buildDate", ",", "commitHash", "string", ")", "Option", "{", "return", "func", "(", "o", "*", "Options", ")", "{", "BuildVersion", "=", "buildVer", "\n", "BuildDate", "=", "buildDate", "\n", "CommitHash", "=", "commitHash", "\n", "}", "\n", "}" ]

[ "Version", "returns", "an", "Option", "that", "sets", "the", "version", "of", "the", "Agent", "to", "the", "entered", "string" ]

[ "func", "QuitSignals", "(", "sigs", "...", "os", ".", "Signal", ")", "Option", "{", "return", "func", "(", "o", "*", "Options", ")", "{", "o", ".", "QuitSignals", "=", "sigs", "\n", "}", "\n", "}" ]

[ "QuitSignals", "returns", "an", "Option", "that", "will", "set", "signals", "which", "stop", "Agent" ]

[ "func", "Plugins", "(", "plugins", "...", "infra", ".", "Plugin", ")", "Option", "{", "return", "func", "(", "o", "*", "Options", ")", "{", "o", ".", "Plugins", "=", "append", "(", "o", ".", "Plugins", ",", "plugins", "...", ")", "\n", "}", "\n", "}" ]

[ "Plugins", "creates", "an", "Option", "that", "adds", "a", "list", "of", "Plugins", "to", "the", "Agent", "s", "Plugin", "list" ]

[ "func", "AllPlugins", "(", "plugins", "...", "infra", ".", "Plugin", ")", "Option", "{", "return", "func", "(", "o", "*", "Options", ")", "{", "infraLogger", ".", "Debugf", "(", "\"", "\"", ",", "len", "(", "plugins", ")", ")", "\n\n", "for", "_", ",", "plugin", ":=", "range", "plugins", "{", "typ", ":=", "reflect", ".", "TypeOf", "(", "plugin", ")", "\n", "infraLogger", ".", "Debugf", "(", "\"", "\"", ",", "plugin", ",", "typ", ")", "\n\n", "foundPlugins", ",", "err", ":=", "findPlugins", "(", "reflect", ".", "ValueOf", "(", "plugin", ")", ",", "o", ".", "pluginMap", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n\n", "infraLogger", ".", "Debugf", "(", "\"", "\"", ",", "len", "(", "foundPlugins", ")", ",", "plugin", ",", "typ", ")", "\n", "for", "_", ",", "plug", ":=", "range", "foundPlugins", "{", "infraLogger", ".", "Debugf", "(", "\"", "\"", ",", "plug", ",", "reflect", ".", "TypeOf", "(", "plug", ")", ")", "\n\n", "if", "_", ",", "ok", ":=", "o", ".", "pluginNames", "[", "plug", ".", "String", "(", ")", "]", ";", "ok", "{", "infraLogger", ".", "Fatalf", "(", "\"", "\"", ",", "plug", ".", "String", "(", ")", ")", "\n", "}", "\n", "o", ".", "pluginNames", "[", "plug", ".", "String", "(", ")", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n", "o", ".", "Plugins", "=", "append", "(", "o", ".", "Plugins", ",", "foundPlugins", "...", ")", "\n\n", "// TODO: perhaps set plugin name to typ.String() if it's empty", "/*p, ok := plugin.(core.PluginNamed)\n\t\t\tif !ok {\n\t\t\t\tp = core.NamePlugin(typ.String(), plugin)\n\t\t\t}*/", "if", "_", ",", "ok", ":=", "o", ".", "pluginNames", "[", "plugin", ".", "String", "(", ")", "]", ";", "ok", "{", "infraLogger", ".", "Fatalf", "(", "\"", "\"", ",", "plugin", ".", "String", "(", ")", ")", "\n", "}", "\n", "o", ".", "pluginNames", "[", "plugin", ".", "String", "(", ")", "]", "=", "struct", "{", "}", "{", "}", "\n", "o", ".", "Plugins", "=", "append", "(", "o", ".", "Plugins", ",", "plugin", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "AllPlugins", "creates", "an", "Option", "that", "adds", "all", "of", "the", "nested", "plugins", "recursively", "to", "the", "Agent", "s", "plugin", "list", "." ]

[ "func", "(", "tx", "*", "Txn", ")", "Put", "(", "key", "string", ",", "value", "[", "]", "byte", ")", "keyval", ".", "BytesTxn", "{", "if", "tx", ".", "addPrefix", "!=", "nil", "{", "key", "=", "tx", ".", "addPrefix", "(", "key", ")", "\n", "}", "\n", "tx", ".", "ops", "=", "append", "(", "tx", ".", "ops", ",", "op", "{", "key", ",", "value", ",", "false", "}", ")", "\n", "return", "tx", "\n", "}" ]

[ "Put", "adds", "a", "new", "put", "operation", "to", "a", "previously", "created", "transaction", ".", "If", "the", "key", "does", "not", "exist", "in", "the", "data", "store", "a", "new", "key", "-", "value", "item", "will", "be", "added", "to", "the", "data", "store", ".", "If", "the", "key", "exists", "in", "the", "data", "store", "the", "existing", "value", "will", "be", "overwritten", "with", "the", "value", "from", "this", "operation", "." ]

[ "func", "(", "it", "*", "Iterator", ")", "GetNext", "(", ")", "(", "kv", "datasync", ".", "KeyVal", ",", "stop", "bool", ")", "{", "kv", ",", "stop", "=", "it", ".", "delegate", ".", "GetNext", "(", ")", "\n", "if", "stop", "{", "return", "nil", ",", "stop", "\n", "}", "\n", "return", "kv", ",", "stop", "\n", "}" ]

[ "GetNext", "only", "delegates", "the", "call", "to", "internal", "iterator", "." ]

[ "func", "(", "p", "*", "Plugin", ")", "Init", "(", ")", "error", "{", "// write initial status data into ETCD", "p", ".", "agentStat", "=", "&", "status", ".", "AgentStatus", "{", "State", ":", "status", ".", "OperationalState_INIT", ",", "BuildVersion", ":", "agent", ".", "BuildVersion", ",", "BuildDate", ":", "agent", ".", "BuildDate", ",", "CommitHash", ":", "agent", ".", "CommitHash", ",", "StartTime", ":", "time", ".", "Now", "(", ")", ".", "Unix", "(", ")", ",", "LastChange", ":", "time", ".", "Now", "(", ")", ".", "Unix", "(", ")", ",", "}", "\n\n", "// initial empty interface status", "p", ".", "interfaceStat", "=", "&", "status", ".", "InterfaceStats", "{", "}", "\n\n", "// init pluginStat map", "p", ".", "pluginStat", "=", "make", "(", "map", "[", "string", "]", "*", "status", ".", "PluginStatus", ")", "\n\n", "// init map with plugin state probes", "p", ".", "pluginProbe", "=", "make", "(", "map", "[", "string", "]", "PluginStateProbe", ")", "\n\n", "// prepare context for all go routines", "p", ".", "ctx", ",", "p", ".", "cancel", "=", "context", ".", "WithCancel", "(", "context", ".", "Background", "(", ")", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "Init", "prepares", "the", "initial", "status", "data", "." ]

[ "func", "(", "p", "*", "Plugin", ")", "AfterInit", "(", ")", "error", "{", "p", ".", "access", ".", "Lock", "(", ")", "\n", "defer", "p", ".", "access", ".", "Unlock", "(", ")", "\n\n", "// do periodic status probing for plugins that have provided the probe function", "go", "p", ".", "periodicProbing", "(", "p", ".", "ctx", ")", "\n\n", "// do periodic updates of the state data in ETCD", "go", "p", ".", "periodicUpdates", "(", "p", ".", "ctx", ")", "\n\n", "p", ".", "publishAgentData", "(", ")", "\n\n", "// transition to OK state if there are no plugins", "if", "len", "(", "p", ".", "pluginStat", ")", "==", "0", "{", "p", ".", "agentStat", ".", "State", "=", "status", ".", "OperationalState_OK", "\n", "p", ".", "agentStat", ".", "LastChange", "=", "time", ".", "Now", "(", ")", ".", "Unix", "(", ")", "\n", "p", ".", "publishAgentData", "(", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "AfterInit", "starts", "go", "routines", "for", "periodic", "probing", "and", "periodic", "updates", ".", "Initial", "state", "data", "are", "published", "via", "the", "injected", "transport", "." ]

[ "func", "(", "p", "*", "Plugin", ")", "Close", "(", ")", "error", "{", "p", ".", "cancel", "(", ")", "\n", "p", ".", "wg", ".", "Wait", "(", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "Close", "stops", "go", "routines", "for", "periodic", "probing", "and", "periodic", "updates", "." ]

[ "func", "(", "p", "*", "Plugin", ")", "Register", "(", "pluginName", "infra", ".", "PluginName", ",", "probe", "PluginStateProbe", ")", "{", "p", ".", "access", ".", "Lock", "(", ")", "\n", "defer", "p", ".", "access", ".", "Unlock", "(", ")", "\n\n", "stat", ":=", "&", "status", ".", "PluginStatus", "{", "State", ":", "status", ".", "OperationalState_INIT", ",", "LastChange", ":", "time", ".", "Now", "(", ")", ".", "Unix", "(", ")", ",", "}", "\n", "p", ".", "pluginStat", "[", "string", "(", "pluginName", ")", "]", "=", "stat", "\n\n", "if", "probe", "!=", "nil", "{", "p", ".", "pluginProbe", "[", "string", "(", "pluginName", ")", "]", "=", "probe", "\n", "}", "\n\n", "// write initial status data into ETCD", "p", ".", "publishPluginData", "(", "pluginName", ",", "stat", ")", "\n\n", "p", ".", "Log", ".", "Debugf", "(", "\"", "\"", ",", "pluginName", ")", "\n", "}" ]

[ "Register", "a", "plugin", "for", "status", "change", "reporting", "." ]

[ "func", "(", "p", "*", "Plugin", ")", "ReportStateChange", "(", "pluginName", "infra", ".", "PluginName", ",", "state", "PluginState", ",", "lastError", "error", ")", "{", "p", ".", "reportStateChange", "(", "pluginName", ",", "state", ",", "lastError", ")", "\n", "}" ]

[ "ReportStateChange", "can", "be", "used", "to", "report", "a", "change", "in", "the", "status", "of", "a", "previously", "registered", "plugin", "." ]

[ "func", "(", "p", "*", "Plugin", ")", "ReportStateChangeWithMeta", "(", "pluginName", "infra", ".", "PluginName", ",", "state", "PluginState", ",", "lastError", "error", ",", "meta", "proto", ".", "Message", ")", "{", "p", ".", "reportStateChange", "(", "pluginName", ",", "state", ",", "lastError", ")", "\n\n", "switch", "data", ":=", "meta", ".", "(", "type", ")", "{", "case", "*", "status", ".", "InterfaceStats_Interface", ":", "p", ".", "reportInterfaceStateChange", "(", "data", ")", "\n", "default", ":", "p", ".", "Log", ".", "Debug", "(", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "ReportStateChangeWithMeta", "can", "be", "used", "to", "report", "a", "change", "in", "the", "status", "of", "a", "previously", "registered", "plugin", "and", "report", "the", "specific", "metadata", "state" ]

[ "func", "(", "p", "*", "Plugin", ")", "publishAgentData", "(", ")", "error", "{", "p", ".", "agentStat", ".", "LastUpdate", "=", "time", ".", "Now", "(", ")", ".", "Unix", "(", ")", "\n", "if", "p", ".", "Transport", "!=", "nil", "{", "return", "p", ".", "Transport", ".", "Put", "(", "status", ".", "AgentStatusKey", "(", ")", ",", "p", ".", "agentStat", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "publishAgentData", "writes", "the", "current", "global", "agent", "state", "into", "ETCD", "." ]

[ "func", "(", "p", "*", "Plugin", ")", "publishPluginData", "(", "pluginName", "infra", ".", "PluginName", ",", "pluginStat", "*", "status", ".", "PluginStatus", ")", "error", "{", "pluginStat", ".", "LastUpdate", "=", "time", ".", "Now", "(", ")", ".", "Unix", "(", ")", "\n", "if", "p", ".", "Transport", "!=", "nil", "{", "return", "p", ".", "Transport", ".", "Put", "(", "status", ".", "PluginStatusKey", "(", "string", "(", "pluginName", ")", ")", ",", "pluginStat", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "publishPluginData", "writes", "the", "current", "plugin", "state", "into", "ETCD", "." ]

[ "func", "(", "p", "*", "Plugin", ")", "publishAllData", "(", ")", "{", "p", ".", "access", ".", "Lock", "(", ")", "\n", "defer", "p", ".", "access", ".", "Unlock", "(", ")", "\n\n", "p", ".", "publishAgentData", "(", ")", "\n", "for", "name", ",", "s", ":=", "range", "p", ".", "pluginStat", "{", "p", ".", "publishPluginData", "(", "infra", ".", "PluginName", "(", "name", ")", ",", "s", ")", "\n", "}", "\n", "}" ]

[ "publishAllData", "publishes", "global", "agent", "+", "all", "plugins", "state", "data", "into", "ETCD", "." ]

[ "func", "(", "p", "*", "Plugin", ")", "periodicProbing", "(", "ctx", "context", ".", "Context", ")", "{", "p", ".", "wg", ".", "Add", "(", "1", ")", "\n", "defer", "p", ".", "wg", ".", "Done", "(", ")", "\n\n", "for", "{", "select", "{", "case", "<-", "time", ".", "After", "(", "PeriodicProbingTimeout", ")", ":", "for", "pluginName", ",", "probe", ":=", "range", "p", ".", "pluginProbe", "{", "state", ",", "lastErr", ":=", "probe", "(", ")", "\n", "p", ".", "ReportStateChange", "(", "infra", ".", "PluginName", "(", "pluginName", ")", ",", "state", ",", "lastErr", ")", "\n", "// just check in-between probes if the plugin is closing", "select", "{", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "\n", "default", ":", "continue", "\n", "}", "\n", "}", "\n\n", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "\n", "}", "\n", "}", "\n", "}" ]

[ "periodicProbing", "does", "periodic", "status", "probing", "for", "all", "plugins", "that", "have", "registered", "probe", "functions", "." ]

[ "func", "(", "p", "*", "Plugin", ")", "periodicUpdates", "(", "ctx", "context", ".", "Context", ")", "{", "p", ".", "wg", ".", "Add", "(", "1", ")", "\n", "defer", "p", ".", "wg", ".", "Done", "(", ")", "\n\n", "for", "{", "select", "{", "case", "<-", "time", ".", "After", "(", "PeriodicWriteTimeout", ")", ":", "p", ".", "publishAllData", "(", ")", "\n\n", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "\n", "}", "\n", "}", "\n", "}" ]

[ "periodicUpdates", "does", "periodic", "writes", "of", "state", "data", "into", "ETCD", "." ]

[ "func", "(", "p", "*", "Plugin", ")", "getAgentState", "(", ")", "status", ".", "OperationalState", "{", "p", ".", "access", ".", "Lock", "(", ")", "\n", "defer", "p", ".", "access", ".", "Unlock", "(", ")", "\n", "return", "p", ".", "agentStat", ".", "State", "\n", "}" ]

[ "getAgentState", "return", "current", "global", "operational", "state", "of", "the", "agent", "." ]

[ "func", "(", "p", "*", "Plugin", ")", "GetAllPluginStatus", "(", ")", "map", "[", "string", "]", "*", "status", ".", "PluginStatus", "{", "//TODO - used currently, will be removed after incoporating improvements for exposing copy of map", "p", ".", "access", ".", "Lock", "(", ")", "\n", "defer", "p", ".", "access", ".", "Unlock", "(", ")", "\n\n", "return", "p", ".", "pluginStat", "\n", "}" ]

[ "GetAllPluginStatus", "returns", "a", "map", "containing", "pluginname", "and", "its", "status", "for", "all", "plugins" ]

[ "func", "(", "p", "*", "Plugin", ")", "GetInterfaceStats", "(", ")", "status", ".", "InterfaceStats", "{", "p", ".", "access", ".", "Lock", "(", ")", "\n", "defer", "p", ".", "access", ".", "Unlock", "(", ")", "\n\n", "return", "*", "p", ".", "interfaceStat", "\n", "}" ]

[ "GetInterfaceStats", "returns", "current", "global", "operational", "status", "of", "interfaces" ]

[ "func", "(", "p", "*", "Plugin", ")", "GetAgentStatus", "(", ")", "status", ".", "AgentStatus", "{", "p", ".", "access", ".", "Lock", "(", ")", "\n", "defer", "p", ".", "access", ".", "Unlock", "(", ")", "\n", "return", "*", "p", ".", "agentStat", "\n", "}" ]

[ "GetAgentStatus", "return", "current", "global", "operational", "state", "of", "the", "agent", "." ]

[ "func", "stateToProto", "(", "state", "PluginState", ")", "status", ".", "OperationalState", "{", "switch", "state", "{", "case", "Init", ":", "return", "status", ".", "OperationalState_INIT", "\n", "case", "OK", ":", "return", "status", ".", "OperationalState_OK", "\n", "default", ":", "return", "status", ".", "OperationalState_ERROR", "\n", "}", "\n", "}" ]

[ "stateToProto", "converts", "agent", "state", "type", "into", "protobuf", "agent", "state", "type", "." ]

[ "func", "(", "p", "*", "PMExample", ")", "runWatcher", "(", "state", "*", "status", ".", "ProcessStatus", ",", "notifyChan", "chan", "status", ".", "ProcessStatus", ")", "{", "for", "{", "select", "{", "case", "currentState", ",", "ok", ":=", "<-", "notifyChan", ":", "if", "!", "ok", "{", "p", ".", "Log", ".", "Infof", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "*", "state", "=", "currentState", "\n", "p", ".", "Log", ".", "Infof", "(", "\"", "\"", ",", "currentState", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "Starts", "the", "process", "watcher", "using", "provided", "chanel", "." ]

[ "func", "NewConsumer", "(", "config", "*", "Config", ",", "wg", "*", "sync", ".", "WaitGroup", ")", "(", "*", "Consumer", ",", "error", ")", "{", "if", "config", ".", "Debug", "{", "config", ".", "Logger", ".", "SetLevel", "(", "logging", ".", "DebugLevel", ")", "\n", "}", "\n", "config", ".", "Logger", ".", "Debug", "(", "\"", "\"", ")", "\n", "if", "err", ":=", "config", ".", "ValidateConsumerConfig", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "config", ".", "Logger", ".", "Debugf", "(", "\"", "\"", ",", "config", ")", "\n\n", "// set consumer config params", "config", ".", "ConsumerConfig", "(", ")", ".", "Group", ".", "Return", ".", "Notifications", "=", "config", ".", "RecvNotification", "\n", "config", ".", "ProducerConfig", "(", ")", ".", "Consumer", ".", "Return", ".", "Errors", "=", "config", ".", "RecvError", "\n", "config", ".", "ConsumerConfig", "(", ")", ".", "Consumer", ".", "Offsets", ".", "Initial", "=", "config", ".", "InitialOffset", "\n\n", "cClient", ",", "err", ":=", "cluster", ".", "NewClient", "(", "config", ".", "Brokers", ",", "config", ".", "Config", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "config", ".", "Logger", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "consumer", ",", "err", ":=", "cluster", ".", "NewConsumerFromClient", "(", "cClient", ",", "config", ".", "GroupID", ",", "config", ".", "Topics", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "sConsumer", ",", "err", ":=", "sarama", ".", "NewConsumerFromClient", "(", "cClient", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "csmr", ":=", "&", "Consumer", "{", "Logger", ":", "config", ".", "Logger", ",", "Config", ":", "config", ",", "SConsumer", ":", "sConsumer", ",", "Consumer", ":", "consumer", ",", "closed", ":", "false", ",", "closeChannel", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "}", "\n\n", "// if there is a \"waitgroup\" arg then use it", "if", "wg", "!=", "nil", "{", "csmr", ".", "xwg", "=", "wg", "\n", "csmr", ".", "xwg", ".", "Add", "(", "1", ")", "\n", "}", "\n\n", "return", "csmr", ",", "nil", "\n", "}" ]

[ "NewConsumer", "returns", "a", "Consumer", "instance", ".", "If", "startHandlers", "is", "set", "to", "true", "reading", "of", "messages", "errors", "and", "notifications", "is", "started", "using", "new", "consumer", ".", "Otherwise", "only", "instance", "is", "returned" ]

[ "func", "(", "ref", "*", "Consumer", ")", "StartConsumerManualHandlers", "(", "partitionConsumer", "sarama", ".", "PartitionConsumer", ")", "{", "config", ":=", "ref", ".", "Config", "\n", "config", ".", "Logger", ".", "Info", "(", "\"", "\"", ")", "\n\n", "// if required, start reading from the errors channel", "if", "config", ".", "ProducerConfig", "(", ")", ".", "Consumer", ".", "Return", ".", "Errors", "{", "go", "ref", ".", "manualErrorHandler", "(", "partitionConsumer", ".", "Errors", "(", ")", ")", "\n", "}", "\n\n", "// start the message handler", "go", "ref", ".", "messageHandler", "(", "partitionConsumer", ".", "Messages", "(", ")", ")", "\n", "}" ]

[ "StartConsumerManualHandlers", "starts", "required", "handlers", "using", "sarama", "partition", "consumer", ".", "Used", "when", "partitioner", "set", "in", "config", "is", "manual" ]

[ "func", "NewClient", "(", "config", "*", "Config", ",", "partitioner", "string", ")", "(", "sarama", ".", "Client", ",", "error", ")", "{", "config", ".", "Logger", ".", "Debug", "(", "\"", "\"", ")", "\n", "if", "err", ":=", "config", ".", "ValidateAsyncProducerConfig", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "config", ".", "SetSendSuccess", "(", "true", ")", "\n", "config", ".", "SetSuccessChan", "(", "make", "(", "chan", "*", "ProducerMessage", ")", ")", "\n", "config", ".", "SetSendError", "(", "true", ")", "\n", "config", ".", "SetErrorChan", "(", "make", "(", "chan", "*", "ProducerError", ")", ")", "\n", "// Required acks will be set in sync/async producer", "config", ".", "RequiredAcks", "=", "AcksUnset", "\n\n", "// set other Producer config params", "config", ".", "ProducerConfig", "(", ")", ".", "Producer", ".", "Return", ".", "Successes", "=", "config", ".", "SendSuccess", "\n", "config", ".", "ProducerConfig", "(", ")", ".", "Producer", ".", "Return", ".", "Errors", "=", "config", ".", "SendError", "\n\n", "// set partitioner", "switch", "partitioner", "{", "case", "Hash", ":", "config", ".", "ProducerConfig", "(", ")", ".", "Producer", ".", "Partitioner", "=", "sarama", ".", "NewHashPartitioner", "\n", "case", "Random", ":", "config", ".", "ProducerConfig", "(", ")", ".", "Producer", ".", "Partitioner", "=", "sarama", ".", "NewRandomPartitioner", "\n", "case", "Manual", ":", "config", ".", "ProducerConfig", "(", ")", ".", "Producer", ".", "Partitioner", "=", "sarama", ".", "NewManualPartitioner", "\n", "default", ":", "// Hash partitioner is set as default", "config", ".", "ProducerConfig", "(", ")", ".", "Producer", ".", "Partitioner", "=", "sarama", ".", "NewHashPartitioner", "\n", "}", "\n\n", "config", ".", "Logger", ".", "Debugf", "(", "\"", "\"", ",", "config", ")", "\n\n", "sClient", ",", "err", ":=", "sarama", ".", "NewClient", "(", "config", ".", "Brokers", ",", "&", "config", ".", "Config", ".", "Config", ")", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "sClient", ",", "nil", "\n", "}" ]

[ "NewClient", "initializes", "new", "sarama", "client", "instance", "from", "provided", "config", "and", "with", "defined", "partitioner" ]

[ "func", "(", "ref", "*", "Consumer", ")", "Close", "(", ")", "error", "{", "ref", ".", "Debug", "(", "\"", "\"", ")", "\n", "defer", "func", "(", ")", "{", "ref", ".", "Debug", "(", "\"", "\"", ")", "\n", "if", "ref", ".", "closed", "{", "ref", ".", "Debug", "(", "\"", "\"", ")", "\n", "ref", ".", "Unlock", "(", ")", "\n", "return", "\n", "}", "\n", "ref", ".", "Debug", "(", "\"", "\"", ")", "\n", "ref", ".", "closed", "=", "true", "\n", "ref", ".", "Debug", "(", "\"", "\"", ")", "\n", "close", "(", "ref", ".", "closeChannel", ")", "\n\n", "if", "ref", ".", "xwg", "!=", "nil", "{", "ref", ".", "xwg", ".", "Done", "(", ")", "\n", "}", "\n", "ref", ".", "Unlock", "(", ")", "\n", "}", "(", ")", "\n\n", "ref", ".", "Debug", "(", "\"", "\"", ")", "\n", "ref", ".", "Lock", "(", ")", "\n", "ref", ".", "Debug", "(", "\"", "\"", ")", "\n", "if", "ref", ".", "closed", "{", "return", "nil", "\n", "}", "\n\n", "// close consumer", "ref", ".", "Debug", "(", "\"", "\"", ")", "\n", "err", ":=", "ref", ".", "Consumer", ".", "Close", "(", ")", "\n", "if", "err", "!=", "nil", "{", "ref", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "ref", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "Close", "closes", "the", "client", "and", "consumer" ]

[ "func", "(", "ref", "*", "Consumer", ")", "PrintNotification", "(", "note", "map", "[", "string", "]", "[", "]", "int32", ")", "{", "for", "k", ",", "v", ":=", "range", "note", "{", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "k", ")", "\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "v", ")", "\n", "}", "\n", "}" ]

[ "PrintNotification", "print", "the", "topics", "and", "partitions" ]

[ "func", "(", "ref", "*", "Consumer", ")", "messageHandler", "(", "in", "<-", "chan", "*", "sarama", ".", "ConsumerMessage", ")", "{", "ref", ".", "Debug", "(", "\"", "\"", ")", "\n", "var", "prevValue", "[", "]", "byte", "\n\n", "for", "{", "select", "{", "case", "msg", ":=", "<-", "in", ":", "if", "msg", "==", "nil", "{", "continue", "\n", "}", "\n", "consumerMsg", ":=", "&", "ConsumerMessage", "{", "Key", ":", "msg", ".", "Key", ",", "Value", ":", "msg", ".", "Value", ",", "PrevValue", ":", "prevValue", ",", "Topic", ":", "msg", ".", "Topic", ",", "Partition", ":", "msg", ".", "Partition", ",", "Offset", ":", "msg", ".", "Offset", ",", "Timestamp", ":", "msg", ".", "Timestamp", ",", "}", "\n", "// Store value as previous for the next iteration", "prevValue", "=", "consumerMsg", ".", "Value", "\n", "select", "{", "case", "ref", ".", "Config", ".", "RecvMessageChan", "<-", "consumerMsg", ":", "case", "<-", "time", ".", "After", "(", "1", "*", "time", ".", "Second", ")", ":", "ref", ".", "Warn", "(", "\"", "\"", ")", "\n", "}", "\n", "case", "<-", "ref", ".", "closeChannel", ":", "ref", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "}", "\n", "}" ]

[ "messageHandler", "processes", "each", "incoming", "message" ]

[ "func", "(", "ref", "*", "Consumer", ")", "manualErrorHandler", "(", "in", "<-", "chan", "*", "sarama", ".", "ConsumerError", ")", "{", "ref", ".", "Debug", "(", "\"", "\"", ")", "\n", "for", "{", "select", "{", "case", "err", ",", "more", ":=", "<-", "in", ":", "if", "more", "{", "ref", ".", "Errorf", "(", "\"", "\"", ",", "err", ",", "err", ")", "\n", "ref", ".", "Config", ".", "RecvErrorChan", "<-", "err", "\n", "}", "\n", "case", "<-", "ref", ".", "closeChannel", ":", "ref", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "}", "\n", "}" ]

[ "manualErrorHandler", "processes", "each", "error", "message", "for", "partition", "consumer" ]

[ "func", "(", "ref", "*", "Consumer", ")", "errorHandler", "(", "in", "<-", "chan", "error", ")", "{", "ref", ".", "Debug", "(", "\"", "\"", ")", "\n", "for", "{", "select", "{", "case", "err", ",", "more", ":=", "<-", "in", ":", "if", "more", "{", "ref", ".", "Errorf", "(", "\"", "\"", ",", "err", ",", "err", ")", "\n", "ref", ".", "Config", ".", "RecvErrorChan", "<-", "err", "\n", "}", "\n", "case", "<-", "ref", ".", "closeChannel", ":", "ref", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "}", "\n", "}" ]

[ "errorHandler", "processes", "each", "error", "message" ]

[ "func", "(", "ref", "*", "Consumer", ")", "notificationHandler", "(", "in", "<-", "chan", "*", "cluster", ".", "Notification", ")", "{", "ref", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "for", "{", "select", "{", "case", "note", ":=", "<-", "in", ":", "ref", ".", "Config", ".", "RecvNotificationChan", "<-", "note", "\n", "case", "<-", "ref", ".", "closeChannel", ":", "ref", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "}", "\n", "}" ]

[ "NotificationHandler", "processes", "each", "message", "received", "when", "the", "consumer", "is", "rebalanced" ]

[ "func", "NewClient", "(", "cfg", "*", "Config", ")", "(", "client", "*", "Client", ",", "err", "error", ")", "{", "db", ",", "err", ":=", "bolt", ".", "Open", "(", "cfg", ".", "DbPath", ",", "cfg", ".", "FileMode", ",", "&", "bolt", ".", "Options", "{", "Timeout", ":", "cfg", ".", "LockTimeout", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "boltLogger", ".", "Infof", "(", "\"", "\"", ",", "db", ".", "Path", "(", ")", ")", "\n\n", "err", "=", "db", ".", "Update", "(", "func", "(", "tx", "*", "bolt", ".", "Tx", ")", "error", "{", "_", ",", "err", ":=", "tx", ".", "CreateBucketIfNotExists", "(", "rootBucket", ")", "\n", "return", "err", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "c", ":=", "&", "Client", "{", "db", ":", "db", ",", "cfg", ":", "*", "cfg", ",", "quit", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "updateChan", ":", "make", "(", "chan", "*", "updateTx", ",", "UpdatesChannelSize", ")", ",", "}", "\n\n", "c", ".", "wg", ".", "Add", "(", "1", ")", "\n", "go", "c", ".", "startUpdater", "(", ")", "\n\n", "return", "c", ",", "nil", "\n", "}" ]

[ "NewClient", "creates", "new", "client", "for", "Bolt", "using", "given", "config", "." ]

[ "func", "(", "c", "*", "Client", ")", "Close", "(", ")", "error", "{", "close", "(", "c", ".", "quit", ")", "\n", "c", ".", "wg", ".", "Wait", "(", ")", "\n", "return", "c", ".", "db", ".", "Close", "(", ")", "\n", "}" ]

[ "Close", "closes", "Bolt", "database", "." ]

[ "func", "(", "c", "*", "Client", ")", "GetValue", "(", "key", "string", ")", "(", "data", "[", "]", "byte", ",", "found", "bool", ",", "revision", "int64", ",", "err", "error", ")", "{", "boltLogger", ".", "Debugf", "(", "\"", "\"", ",", "key", ")", "\n\n", "err", "=", "c", ".", "db", ".", "View", "(", "func", "(", "tx", "*", "bolt", ".", "Tx", ")", "error", "{", "value", ":=", "tx", ".", "Bucket", "(", "rootBucket", ")", ".", "Get", "(", "[", "]", "byte", "(", "key", ")", ")", "\n", "if", "value", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "key", ")", "\n", "}", "\n\n", "found", "=", "true", "\n", "data", "=", "append", "(", "[", "]", "byte", "(", "nil", ")", ",", "value", "...", ")", "// value needs to be copied", "\n\n", "return", "nil", "\n", "}", ")", "\n", "return", "data", ",", "found", ",", "0", ",", "err", "\n", "}" ]

[ "GetValue", "returns", "data", "for", "the", "given", "key" ]

[ "func", "(", "c", "*", "Client", ")", "Put", "(", "key", "string", ",", "data", "[", "]", "byte", ",", "opts", "...", "datasync", ".", "PutOption", ")", "(", "err", "error", ")", "{", "boltLogger", ".", "Debugf", "(", "\"", "\"", ",", "key", ",", "len", "(", "data", ")", ")", "\n\n", "prevVal", ",", "err", ":=", "c", ".", "safeUpdate", "(", "&", "update", "{", "key", ":", "[", "]", "byte", "(", "key", ")", ",", "value", ":", "data", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "c", ".", "bumpWatchers", "(", "&", "watchEvent", "{", "Key", ":", "key", ",", "Value", ":", "data", ",", "PrevValue", ":", "prevVal", ",", "Type", ":", "datasync", ".", "Put", ",", "}", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "Put", "stores", "given", "data", "for", "the", "key" ]

[ "func", "(", "c", "*", "Client", ")", "Delete", "(", "key", "string", ",", "opts", "...", "datasync", ".", "DelOption", ")", "(", "existed", "bool", ",", "err", "error", ")", "{", "boltLogger", ".", "Debugf", "(", "\"", "\"", ",", "key", ")", "\n\n", "prevVal", ",", "err", ":=", "c", ".", "safeUpdate", "(", "&", "update", "{", "key", ":", "[", "]", "byte", "(", "key", ")", ",", "value", ":", "nil", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "existed", "=", "prevVal", "!=", "nil", "\n\n", "c", ".", "bumpWatchers", "(", "&", "watchEvent", "{", "Key", ":", "key", ",", "PrevValue", ":", "prevVal", ",", "Type", ":", "datasync", ".", "Delete", ",", "}", ")", "\n\n", "return", "existed", ",", "err", "\n", "}" ]

[ "Delete", "deletes", "given", "key" ]

[ "func", "(", "c", "*", "Client", ")", "ListKeys", "(", "keyPrefix", "string", ")", "(", "keyval", ".", "BytesKeyIterator", ",", "error", ")", "{", "boltLogger", ".", "Debugf", "(", "\"", "\"", ",", "keyPrefix", ")", "\n\n", "var", "keys", "[", "]", "string", "\n", "err", ":=", "c", ".", "db", ".", "View", "(", "func", "(", "tx", "*", "bolt", ".", "Tx", ")", "error", "{", "c", ":=", "tx", ".", "Bucket", "(", "rootBucket", ")", ".", "Cursor", "(", ")", "\n", "prefix", ":=", "[", "]", "byte", "(", "keyPrefix", ")", "\n\n", "for", "k", ",", "_", ":=", "c", ".", "Seek", "(", "prefix", ")", ";", "k", "!=", "nil", "&&", "bytes", ".", "HasPrefix", "(", "k", ",", "prefix", ")", ";", "k", ",", "_", "=", "c", ".", "Next", "(", ")", "{", "boltLogger", ".", "Debugf", "(", "\"", "\"", ",", "string", "(", "k", ")", ")", "\n", "keys", "=", "append", "(", "keys", ",", "string", "(", "k", ")", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}", ")", "\n\n", "return", "&", "bytesKeyIterator", "{", "len", ":", "len", "(", "keys", ")", ",", "keys", ":", "keys", "}", ",", "err", "\n", "}" ]

[ "ListKeys", "returns", "iterator", "with", "keys", "for", "given", "key", "prefix" ]

[ "func", "(", "c", "*", "Client", ")", "ListValues", "(", "keyPrefix", "string", ")", "(", "keyval", ".", "BytesKeyValIterator", ",", "error", ")", "{", "boltLogger", ".", "Debugf", "(", "\"", "\"", ",", "keyPrefix", ")", "\n\n", "var", "pairs", "[", "]", "*", "kvPair", "\n", "err", ":=", "c", ".", "db", ".", "View", "(", "func", "(", "tx", "*", "bolt", ".", "Tx", ")", "error", "{", "c", ":=", "tx", ".", "Bucket", "(", "rootBucket", ")", ".", "Cursor", "(", ")", "\n", "prefix", ":=", "[", "]", "byte", "(", "keyPrefix", ")", "\n\n", "for", "k", ",", "v", ":=", "c", ".", "Seek", "(", "prefix", ")", ";", "k", "!=", "nil", "&&", "bytes", ".", "HasPrefix", "(", "k", ",", "prefix", ")", ";", "k", ",", "v", "=", "c", ".", "Next", "(", ")", "{", "boltLogger", ".", "Debugf", "(", "\"", "\"", ",", "string", "(", "k", ")", ",", "len", "(", "v", ")", ")", "\n\n", "pair", ":=", "&", "kvPair", "{", "Key", ":", "string", "(", "k", ")", "}", "\n", "pair", ".", "Value", "=", "append", "(", "[", "]", "byte", "(", "nil", ")", ",", "v", "...", ")", "// value needs to be copied", "\n\n", "pairs", "=", "append", "(", "pairs", ",", "pair", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}", ")", "\n\n", "return", "&", "bytesKeyValIterator", "{", "len", ":", "len", "(", "pairs", ")", ",", "pairs", ":", "pairs", "}", ",", "err", "\n", "}" ]

[ "ListValues", "returns", "iterator", "with", "key", "-", "value", "pairs", "for", "given", "key", "prefix" ]

[ "func", "(", "ref", "*", "AsyncProducer", ")", "SendMsgByte", "(", "topic", "string", ",", "key", "[", "]", "byte", ",", "msg", "[", "]", "byte", ",", "metadata", "interface", "{", "}", ")", "{", "// generate key if none supplied - used by Hash partitioner", "if", "key", "==", "nil", "||", "len", "(", "key", ")", "==", "0", "{", "md5Sum", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "md5", ".", "Sum", "(", "msg", ")", ")", "\n", "ref", ".", "SendMsgToPartition", "(", "topic", ",", "ref", ".", "Partition", ",", "sarama", ".", "ByteEncoder", "(", "[", "]", "byte", "(", "md5Sum", ")", ")", ",", "sarama", ".", "ByteEncoder", "(", "msg", ")", ",", "metadata", ")", "\n", "return", "\n", "}", "\n", "ref", ".", "SendMsgToPartition", "(", "topic", ",", "ref", ".", "Partition", ",", "sarama", ".", "ByteEncoder", "(", "key", ")", ",", "sarama", ".", "ByteEncoder", "(", "msg", ")", ",", "metadata", ")", "\n", "}" ]

[ "SendMsgByte", "sends", "an", "async", "message", "to", "Kafka", "." ]

[ "func", "(", "ref", "*", "AsyncProducer", ")", "SendMsgToPartition", "(", "topic", "string", ",", "partition", "int32", ",", "key", "Encoder", ",", "msg", "Encoder", ",", "metadata", "interface", "{", "}", ")", "{", "if", "msg", "==", "nil", "{", "return", "\n", "}", "\n\n", "message", ":=", "&", "sarama", ".", "ProducerMessage", "{", "Topic", ":", "topic", ",", "Partition", ":", "partition", ",", "Key", ":", "key", ",", "Value", ":", "msg", ",", "Metadata", ":", "metadata", ",", "}", "\n\n", "ref", ".", "Producer", ".", "Input", "(", ")", "<-", "message", "\n\n", "ref", ".", "Debugf", "(", "\"", "\"", ",", "message", ")", "\n\n", "return", "\n", "}" ]

[ "SendMsgToPartition", "sends", "an", "async", "message", "to", "Kafka" ]

[ "func", "(", "ref", "*", "AsyncProducer", ")", "successHandler", "(", "in", "<-", "chan", "*", "sarama", ".", "ProducerMessage", ")", "{", "ref", ".", "Debug", "(", "\"", "\"", ")", "\n", "for", "{", "select", "{", "case", "<-", "ref", ".", "closeChannel", ":", "ref", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "\n", "case", "msg", ":=", "<-", "in", ":", "if", "msg", "==", "nil", "{", "continue", "\n", "}", "\n", "ref", ".", "Debugf", "(", "\"", "\\n", "\"", ",", "msg", ".", "Topic", ",", "msg", ".", "Partition", ",", "msg", ".", "Offset", ")", "\n", "pmsg", ":=", "&", "ProducerMessage", "{", "Topic", ":", "msg", ".", "Topic", ",", "Key", ":", "msg", ".", "Key", ",", "Value", ":", "msg", ".", "Value", ",", "Metadata", ":", "msg", ".", "Metadata", ",", "Offset", ":", "msg", ".", "Offset", ",", "Partition", ":", "msg", ".", "Partition", ",", "}", "\n", "ref", ".", "Config", ".", "SuccessChan", "<-", "pmsg", "\n", "}", "\n", "}", "\n", "}" ]

[ "successHandler", "handles", "success", "messages" ]

[ "func", "(", "ref", "*", "AsyncProducer", ")", "errorHandler", "(", "in", "<-", "chan", "*", "sarama", ".", "ProducerError", ")", "{", "ref", ".", "Debug", "(", "\"", "\"", ")", "\n", "for", "{", "select", "{", "case", "<-", "ref", ".", "closeChannel", ":", "ref", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "\n", "case", "perr", ":=", "<-", "in", ":", "if", "perr", "==", "nil", "{", "continue", "\n", "}", "\n\n", "msg", ":=", "perr", ".", "Msg", "\n", "err", ":=", "perr", ".", "Err", "\n", "pmsg", ":=", "&", "ProducerMessage", "{", "Topic", ":", "msg", ".", "Topic", ",", "Key", ":", "msg", ".", "Key", ",", "Value", ":", "msg", ".", "Value", ",", "Metadata", ":", "msg", ".", "Metadata", ",", "Offset", ":", "msg", ".", "Offset", ",", "Partition", ":", "msg", ".", "Partition", ",", "}", "\n", "perr2", ":=", "&", "ProducerError", "{", "ProducerMessage", ":", "pmsg", ",", "Err", ":", "err", ",", "}", "\n", "val", ",", "_", ":=", "msg", ".", "Value", ".", "Encode", "(", ")", "\n", "ref", ".", "Errorf", "(", "\"", "\\n", "\"", ",", "string", "(", "val", ")", ",", "pmsg", ".", "Topic", ",", "pmsg", ".", "Partition", ",", "pmsg", ".", "Offset", ")", "\n", "ref", ".", "Errorf", "(", "\"", "\"", ",", "perr", ".", "Err", ")", "\n", "ref", ".", "Config", ".", "ErrorChan", "<-", "perr2", "\n", "}", "\n", "}", "\n", "}" ]

[ "errorHandler", "handles", "error", "messages" ]

[ "func", "DefineDirFlag", "(", ")", "{", "if", "flag", ".", "CommandLine", ".", "Lookup", "(", "DirFlag", ")", "==", "nil", "{", "flag", ".", "CommandLine", ".", "String", "(", "DirFlag", ",", "DirDefault", ",", "DirUsage", ")", "\n", "}", "\n", "}" ]

[ "DefineDirFlag", "defines", "flag", "for", "configuration", "directory", "." ]

[ "func", "DefineFlagsFor", "(", "name", "string", ")", "{", "if", "plugSet", ",", "ok", ":=", "pluginFlags", "[", "name", "]", ";", "ok", "{", "plugSet", ".", "VisitAll", "(", "func", "(", "f", "*", "flag", ".", "Flag", ")", "{", "flag", ".", "CommandLine", ".", "Var", "(", "f", ".", "Value", ",", "f", ".", "Name", ",", "f", ".", "Usage", ")", "\n", "}", ")", "\n", "}", "\n", "}" ]

[ "DefineFlagsFor", "registers", "defined", "flags", "for", "plugin", "with", "given", "name", "." ]

[ "func", "WithExtraFlags", "(", "f", "func", "(", "flags", "*", "FlagSet", ")", ")", "Option", "{", "return", "func", "(", "o", "*", "options", ")", "{", "f", "(", "o", ".", "flagSet", ")", "\n", "}", "\n", "}" ]

[ "WithExtraFlags", "is", "an", "option", "to", "define", "additional", "flags", "for", "plugin", "in", "ForPlugin", "." ]

[ "func", "Dir", "(", ")", "(", "dir", "string", ",", "err", "error", ")", "{", "if", "flg", ":=", "flag", ".", "CommandLine", ".", "Lookup", "(", "DirFlag", ")", ";", "flg", "!=", "nil", "{", "val", ":=", "flg", ".", "Value", ".", "String", "(", ")", "\n", "if", "strings", ".", "HasPrefix", "(", "val", ",", "\"", "\"", ")", "{", "cwd", ",", "err", ":=", "os", ".", "Getwd", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "cwd", ",", "err", "\n", "}", "\n", "return", "filepath", ".", "Join", "(", "cwd", ",", "val", ")", ",", "nil", "\n", "}", "\n", "return", "val", ",", "nil", "\n", "}", "\n", "return", "\"", "\"", ",", "nil", "\n", "}" ]

[ "Dir", "returns", "config", "directory", "by", "evaluating", "the", "flag", "DirFlag", ".", "It", "interprets", ".", "as", "current", "working", "directory", "." ]

[ "func", "(", "p", "*", "pluginConfig", ")", "LoadValue", "(", "config", "interface", "{", "}", ")", "(", "found", "bool", ",", "err", "error", ")", "{", "cfgName", ":=", "p", ".", "GetConfigName", "(", ")", "\n", "if", "cfgName", "==", "\"", "\"", "{", "return", "false", ",", "nil", "\n", "}", "\n\n", "// TODO: switch to Viper (possible to have one huge config file)", "err", "=", "ParseConfigFromYamlFile", "(", "cfgName", ",", "config", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n\n", "return", "true", ",", "nil", "\n", "}" ]

[ "LoadValue", "binds", "the", "configuration", "to", "config", "method", "argument", "." ]

[ "func", "NewDecoderMock", "(", ")", "*", "Mock", "{", "return", "&", "Mock", "{", "responses", ":", "make", "(", "[", "]", "*", "WhenResp", ",", "0", ")", ",", "eventChan", ":", "make", "(", "chan", "fsnotify", ".", "Event", ")", ",", "}", "\n", "}" ]

[ "NewDecoderMock", "creates", "new", "instance", "of", "the", "mock", "and", "initializes", "response", "list" ]

[ "func", "(", "mock", "*", "Mock", ")", "When", "(", "methodName", "string", ")", "*", "WhenResp", "{", "resp", ":=", "&", "WhenResp", "{", "methodName", ":", "methodName", ",", "}", "\n", "mock", ".", "responses", "=", "append", "(", "mock", ".", "responses", ",", "resp", ")", "\n", "return", "resp", "\n", "}" ]

[ "When", "defines", "name", "of", "the", "related", "method", ".", "It", "creates", "a", "new", "instance", "of", "WhenResp", "with", "provided", "method", "name", "and", "stores", "it", "to", "the", "mock", "." ]

[ "func", "(", "mock", "*", "Mock", ")", "getReturnValues", "(", "name", "string", ")", "(", "response", "[", "]", "interface", "{", "}", ")", "{", "for", "i", ",", "resp", ":=", "range", "mock", ".", "responses", "{", "if", "resp", ".", "methodName", "==", "name", "{", "// Remove used response but retain order", "mock", ".", "responses", "=", "append", "(", "mock", ".", "responses", "[", ":", "i", "]", ",", "mock", ".", "responses", "[", "i", "+", "1", ":", "]", "...", ")", "\n", "return", "resp", ".", "items", "\n", "}", "\n", "}", "\n", "// Return empty response", "return", "\n", "}" ]

[ "Auxiliary", "method", "returns", "next", "return", "value", "for", "provided", "method", "as", "generic", "type" ]

[ "func", "(", "mock", "*", "Mock", ")", "IsProcessable", "(", "file", "string", ")", "bool", "{", "items", ":=", "mock", ".", "getReturnValues", "(", "\"", "\"", ")", "\n", "return", "items", "[", "0", "]", ".", "(", "bool", ")", "\n", "}" ]

[ "IsProcessable", "mocks", "original", "method" ]

[ "func", "(", "mock", "*", "Mock", ")", "Encode", "(", "data", "[", "]", "*", "FileDataEntry", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "items", ":=", "mock", ".", "getReturnValues", "(", "\"", "\"", ")", "\n", "if", "len", "(", "items", ")", "==", "1", "{", "switch", "typed", ":=", "items", "[", "0", "]", ".", "(", "type", ")", "{", "case", "[", "]", "byte", ":", "return", "typed", ",", "nil", "\n", "case", "error", ":", "return", "[", "]", "byte", "{", "}", ",", "typed", "\n", "}", "\n", "}", "else", "if", "len", "(", "items", ")", "==", "2", "{", "return", "items", "[", "0", "]", ".", "(", "[", "]", "byte", ")", ",", "items", "[", "1", "]", ".", "(", "error", ")", "\n", "}", "\n", "return", "[", "]", "byte", "{", "}", ",", "nil", "\n", "}" ]

[ "Encode", "mocks", "original", "method" ]

[ "func", "(", "mock", "*", "Mock", ")", "Decode", "(", "data", "[", "]", "byte", ")", "(", "[", "]", "*", "FileDataEntry", ",", "error", ")", "{", "items", ":=", "mock", ".", "getReturnValues", "(", "\"", "\"", ")", "\n", "if", "len", "(", "items", ")", "==", "1", "{", "switch", "typed", ":=", "items", "[", "0", "]", ".", "(", "type", ")", "{", "case", "[", "]", "*", "FileDataEntry", ":", "return", "typed", ",", "nil", "\n", "case", "error", ":", "return", "[", "]", "*", "FileDataEntry", "{", "}", ",", "typed", "\n", "}", "\n", "}", "else", "if", "len", "(", "items", ")", "==", "2", "{", "return", "items", "[", "0", "]", ".", "(", "[", "]", "*", "FileDataEntry", ")", ",", "items", "[", "1", "]", ".", "(", "error", ")", "\n", "}", "\n", "return", "[", "]", "*", "FileDataEntry", "{", "}", ",", "nil", "\n", "}" ]

[ "Decode", "mocks", "original", "method" ]

[ "func", "(", "p", "*", "Plugin", ")", "Init", "(", ")", "(", "err", "error", ")", "{", "// Get GRPC configuration file", "if", "p", ".", "Config", "==", "nil", "{", "p", ".", "Config", ",", "err", "=", "p", ".", "getGrpcConfig", "(", ")", "\n", "if", "err", "!=", "nil", "||", "p", ".", "disabled", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "// Prepare GRPC server", "if", "p", ".", "grpcServer", "==", "nil", "{", "opts", ":=", "p", ".", "Config", ".", "getGrpcOptions", "(", ")", "\n", "if", "p", ".", "tlsConfig", "!=", "nil", "{", "opts", "=", "append", "(", "opts", ",", "grpc", ".", "Creds", "(", "credentials", ".", "NewTLS", "(", "p", ".", "tlsConfig", ")", ")", ")", "\n", "}", "\n", "if", "p", ".", "auther", "!=", "nil", "{", "p", ".", "Log", ".", "Info", "(", "\"", "\"", ")", "\n", "opts", "=", "append", "(", "opts", ",", "grpc", ".", "StreamInterceptor", "(", "grpc_auth", ".", "StreamServerInterceptor", "(", "p", ".", "auther", ".", "Authenticate", ")", ")", ")", "\n", "opts", "=", "append", "(", "opts", ",", "grpc", ".", "UnaryInterceptor", "(", "grpc_auth", ".", "UnaryServerInterceptor", "(", "p", ".", "auther", ".", "Authenticate", ")", ")", ")", "\n", "}", "\n", "p", ".", "grpcServer", "=", "grpc", ".", "NewServer", "(", "opts", "...", ")", "\n\n", "//grpclog.SetLogger(p.Log.NewLogger(\"grpc-server\"))", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Init", "prepares", "GRPC", "netListener", "for", "registration", "of", "individual", "service" ]

[ "func", "(", "p", "*", "Plugin", ")", "AfterInit", "(", ")", "(", "err", "error", ")", "{", "if", "p", ".", "disabled", "{", "return", "nil", "\n", "}", "\n\n", "if", "p", ".", "Deps", ".", "HTTP", "!=", "nil", "{", "p", ".", "Log", ".", "Infof", "(", "\"", "\"", ",", "strconv", ".", "Itoa", "(", "p", ".", "Deps", ".", "HTTP", ".", "GetPort", "(", ")", ")", ")", "\n", "p", ".", "Deps", ".", "HTTP", ".", "RegisterHTTPHandler", "(", "\"", "\"", ",", "func", "(", "formatter", "*", "render", ".", "Render", ")", "http", ".", "HandlerFunc", "{", "return", "p", ".", "grpcServer", ".", "ServeHTTP", "\n", "}", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "}", "else", "{", "p", ".", "Log", ".", "Infof", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Start GRPC listener", "p", ".", "netListener", ",", "err", "=", "ListenAndServe", "(", "p", ".", "Config", ",", "p", ".", "grpcServer", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "p", ".", "Log", ".", "Infof", "(", "\"", "\"", ",", "p", ".", "Config", ".", "Endpoint", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "AfterInit", "starts", "the", "HTTP", "netListener", "." ]

[ "func", "(", "p", "*", "Plugin", ")", "Close", "(", ")", "error", "{", "if", "p", ".", "grpcServer", "!=", "nil", "{", "p", ".", "grpcServer", ".", "Stop", "(", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Close", "stops", "the", "HTTP", "netListener", "." ]

[ "func", "ConfigToClient", "(", "config", "interface", "{", "}", ")", "(", "Client", ",", "error", ")", "{", "switch", "cfg", ":=", "config", ".", "(", "type", ")", "{", "case", "NodeConfig", ":", "return", "CreateNodeClient", "(", "cfg", ")", "\n", "case", "ClusterConfig", ":", "return", "CreateClusterClient", "(", "cfg", ")", "\n", "case", "SentinelConfig", ":", "return", "CreateSentinelClient", "(", "cfg", ")", "\n", "case", "nil", ":", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "config", ")", "\n", "}" ]

[ "ConfigToClient", "creates", "an", "appropriate", "client", "according", "to", "the", "configuration", "parameter", "." ]

[ "func", "CreateClusterClient", "(", "config", "ClusterConfig", ")", "(", "Client", ",", "error", ")", "{", "return", "goredis", ".", "NewClusterClient", "(", "&", "goredis", ".", "ClusterOptions", "{", "Addrs", ":", "config", ".", "Endpoints", ",", "// Enables read only queries on slave nodes.", "ReadOnly", ":", "config", ".", "EnableReadQueryOnSlave", ",", "MaxRedirects", ":", "config", ".", "MaxRedirects", ",", "RouteByLatency", ":", "config", ".", "RouteByLatency", ",", "// Optional password. Must match the password specified in the requirepass server configuration option.", "Password", ":", "config", ".", "Password", ",", "// Dial timeout for establishing new connections. Default is 5 seconds.", "DialTimeout", ":", "config", ".", "DialTimeout", ",", "// Timeout for socket reads. If reached, commands will fail with a timeout instead of blocking. Default is 3 seconds.", "ReadTimeout", ":", "config", ".", "ReadTimeout", ",", "// Timeout for socket writes. If reached, commands will fail with a timeout instead of blocking. Default is ReadTimeout.", "WriteTimeout", ":", "config", ".", "WriteTimeout", ",", "// Maximum number of socket connections. Default is 10 connections per every CPU as reported by runtime.NumCPU.", "PoolSize", ":", "config", ".", "Pool", ".", "PoolSize", ",", "// Amount of time a client waits for connection if all connections are busy before returning an error. Default is ReadTimeout + 1 second.", "PoolTimeout", ":", "config", ".", "Pool", ".", "PoolTimeout", ",", "// Amount of time after which a client closes idle connections. Should be less than server's timeout. Default is 5 minutes.", "IdleTimeout", ":", "config", ".", "Pool", ".", "IdleTimeout", ",", "// Frequency of idle checks. Default is 1 minute. When negative value is set, then idle check is disabled.", "IdleCheckFrequency", ":", "config", ".", "Pool", ".", "IdleCheckFrequency", ",", "// Maximum number of retries before giving up. Default is to not retry failed commands.", "MaxRetries", ":", "0", ",", "// Minimum backoff between each retry. Default is 8 milliseconds; -1 disables backoff.", "MinRetryBackoff", ":", "0", ",", "// Maximum backoff between each retry. Default is 512 milliseconds; -1 disables backoff.", "MaxRetryBackoff", ":", "0", ",", "// Hook that is called when new connection is established", "// OnConnect func(*Conn) error", "}", ")", ",", "nil", "\n", "}" ]

[ "CreateClusterClient", "Creates", "a", "client", "that", "will", "connect", "to", "a", "redis", "cluster", "." ]

[ "func", "CreateSentinelClient", "(", "config", "SentinelConfig", ")", "(", "Client", ",", "error", ")", "{", "return", "goredis", ".", "NewFailoverClient", "(", "&", "goredis", ".", "FailoverOptions", "{", "SentinelAddrs", ":", "config", ".", "Endpoints", ",", "DB", ":", "config", ".", "DB", ",", "MasterName", ":", "config", ".", "MasterName", ",", "// Optional password. Must match the password specified in the requirepass server configuration option.", "Password", ":", "config", ".", "Password", ",", "// Dial timeout for establishing new connections. Default is 5 seconds.", "DialTimeout", ":", "config", ".", "DialTimeout", ",", "// Timeout for socket reads. If reached, commands will fail with a timeout instead of blocking. Default is 3 seconds.", "ReadTimeout", ":", "config", ".", "ReadTimeout", ",", "// Timeout for socket writes. If reached, commands will fail with a timeout instead of blocking. Default is ReadTimeout.", "WriteTimeout", ":", "config", ".", "WriteTimeout", ",", "// Maximum number of socket connections. Default is 10 connections per every CPU as reported by runtime.NumCPU.", "PoolSize", ":", "config", ".", "Pool", ".", "PoolSize", ",", "// Amount of time a client waits for connection if all connections are busy before returning an error. Default is ReadTimeout + 1 second.", "PoolTimeout", ":", "config", ".", "Pool", ".", "PoolTimeout", ",", "// Amount of time after which a client closes idle connections. Should be less than server's timeout. Default is 5 minutes.", "IdleTimeout", ":", "config", ".", "Pool", ".", "IdleTimeout", ",", "// Frequency of idle checks. Default is 1 minute. When negative value is set, then idle check is disabled.", "IdleCheckFrequency", ":", "config", ".", "Pool", ".", "IdleCheckFrequency", ",", "// Maximum number of retries before giving up. Default is to not retry failed commands.", "MaxRetries", ":", "0", ",", "// Hook that is called when new connection is established", "// OnConnect func(*Conn) error", "}", ")", ",", "nil", "\n", "}" ]

[ "CreateSentinelClient", "Creates", "a", "failover", "client", "that", "will", "connect", "to", "redis", "sentinels", "." ]

[ "func", "LoadConfig", "(", "configFile", "string", ")", "(", "cfg", "interface", "{", "}", ",", "err", "error", ")", "{", "b", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "configFile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "var", "s", "SentinelConfig", "\n", "err", "=", "yaml", ".", "Unmarshal", "(", "b", ",", "&", "s", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "s", ".", "MasterName", "!=", "\"", "\"", "{", "return", "s", ",", "nil", "\n", "}", "\n\n", "n", ":=", "NodeConfig", "{", "}", "\n", "err", "=", "yaml", ".", "Unmarshal", "(", "b", ",", "&", "n", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "n", ".", "Endpoint", "!=", "\"", "\"", "{", "return", "n", ",", "nil", "\n", "}", "\n\n", "c", ":=", "ClusterConfig", "{", "}", "\n", "err", "=", "yaml", ".", "Unmarshal", "(", "b", ",", "&", "c", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "c", ",", "nil", "\n", "}" ]

[ "LoadConfig", "Loads", "the", "given", "configFile", "and", "returns", "appropriate", "config", "instance", "." ]

[ "func", "(", "p", "*", "Plugin", ")", "Init", "(", ")", "error", "{", "p", ".", "Adapter", "=", "&", "syncbase", ".", "Adapter", "{", "Watcher", ":", "NewAdapter", "(", "p", ".", "GRPC", ".", "GetServer", "(", ")", ")", ",", "}", "\n", "return", "nil", "\n", "}" ]

[ "Init", "registers", "new", "gRPC", "service", "and", "instantiates", "plugin", ".", "Adapter", "." ]

[ "func", "NewPluginStatusMap", "(", "owner", "infra", ".", "PluginName", ")", "PluginStatusIdxMapRW", "{", "return", "&", "pluginStatusMap", "{", "mapping", ":", "mem", ".", "NewNamedMapping", "(", "logrus", ".", "DefaultLogger", "(", ")", ",", "\"", "\"", ",", "IndexPluginStatus", ")", ",", "}", "\n", "}" ]

[ "NewPluginStatusMap", "is", "a", "constructor", "for", "PluginStatusIdxMapRW", "." ]

[ "func", "(", "swi", "*", "pluginStatusMap", ")", "Put", "(", "pluginName", "string", ",", "pluginStatus", "*", "status", ".", "PluginStatus", ")", "{", "swi", ".", "mapping", ".", "Put", "(", "pluginName", ",", "pluginStatus", ")", "\n", "}" ]

[ "RegisterName", "adds", "new", "item", "into", "the", "name", "-", "to", "-", "index", "mapping", "." ]

[ "func", "IndexPluginStatus", "(", "data", "interface", "{", "}", ")", "map", "[", "string", "]", "[", "]", "string", "{", "logrus", ".", "DefaultLogger", "(", ")", ".", "Debug", "(", "\"", "\"", ",", "data", ")", "\n\n", "indexes", ":=", "map", "[", "string", "]", "[", "]", "string", "{", "}", "\n", "pluginStatus", ",", "ok", ":=", "data", ".", "(", "*", "status", ".", "PluginStatus", ")", "\n", "if", "!", "ok", "||", "pluginStatus", "==", "nil", "{", "return", "indexes", "\n", "}", "\n\n", "state", ":=", "pluginStatus", ".", "State", "\n", "if", "state", "!=", "0", "{", "indexes", "[", "stateIndexKey", "]", "=", "[", "]", "string", "{", "state", ".", "String", "(", ")", "}", "\n", "}", "\n", "return", "indexes", "\n", "}" ]

[ "IndexPluginStatus", "creates", "indexes", "for", "plugin", "states", "and", "records", "the", "state", "passed", "as", "untyped", "data", "." ]

[ "func", "(", "swi", "*", "pluginStatusMap", ")", "Delete", "(", "pluginName", "string", ")", "(", "data", "*", "status", ".", "PluginStatus", ",", "exists", "bool", ")", "{", "meta", ",", "exists", ":=", "swi", ".", "mapping", ".", "Delete", "(", "pluginName", ")", "\n", "return", "swi", ".", "castdata", "(", "meta", ")", ",", "exists", "\n", "}" ]

[ "UnregisterName", "removes", "an", "item", "identified", "by", "name", "from", "mapping" ]

[ "func", "(", "swi", "*", "pluginStatusMap", ")", "LookupByState", "(", "state", "status", ".", "OperationalState", ")", "[", "]", "string", "{", "return", "swi", ".", "mapping", ".", "ListNames", "(", "stateIndexKey", ",", "state", ".", "String", "(", ")", ")", "\n", "}" ]

[ "LookupNameByIP", "returns", "names", "of", "items", "that", "contains", "given", "IP", "address", "in", "Value" ]

[ "func", "(", "swi", "*", "pluginStatusMap", ")", "WatchNameToIdx", "(", "subscriber", "infra", ".", "PluginName", ",", "pluginChannel", "chan", "PluginStatusEvent", ")", "{", "swi", ".", "mapping", ".", "Watch", "(", "string", "(", "subscriber", ")", ",", "func", "(", "event", "idxmap", ".", "NamedMappingGenericEvent", ")", "{", "pluginChannel", "<-", "PluginStatusEvent", "{", "NamedMappingEvent", ":", "event", ".", "NamedMappingEvent", ",", "Value", ":", "swi", ".", "castdata", "(", "event", ".", "Value", ")", ",", "}", "\n", "}", ")", "\n", "}" ]

[ "WatchNameToIdx", "allows", "to", "subscribe", "for", "watching", "changes", "in", "pluginStatusMap", "mapping" ]