Datasets:

---

CM

/

codexglue_code2text_go

like 1

[ "func", "cqlExportedWithFieldName", "(", "field", "*", "r", ".", "StructField", ")", "(", "fieldName", "string", ",", "exported", "bool", ")", "{", "cql", ":=", "field", ".", "Tag", ".", "Get", "(", "\"", "\"", ")", "\n", "if", "len", "(", "cql", ")", ">", "0", "{", "if", "cql", "==", "\"", "\"", "{", "return", "cql", ",", "false", "\n", "}", "\n", "return", "cql", ",", "true", "\n", "}", "\n", "return", "field", ".", "Name", ",", "true", "\n", "}" ]

[ "cqlExportedWithFieldName", "checks", "the", "cql", "tag", "in", "StructField", "and", "parses", "the", "field", "name" ]

[ "func", "isFieldPK", "(", "field", "*", "r", ".", "StructField", ")", "(", "isPK", "bool", ")", "{", "result", ":=", "false", "\n", "pk", ":=", "field", ".", "Tag", ".", "Get", "(", "\"", "\"", ")", "\n", "if", "len", "(", "pk", ")", ">", "0", "{", "result", "=", "true", "\n", "}", "\n", "return", "result", "\n", "}" ]

[ "isFieldPK", "checks", "the", "pk", "tag", "in", "StructField", "and", "parses", "the", "field", "name" ]

[ "func", "selectFields", "(", "val", "interface", "{", "}", "/*, opts Options*/", ")", "(", "statement", "string", ")", "{", "fields", ":=", "structs", ".", "ListExportedFields", "(", "val", ",", "cqlExported", ")", "\n", "ret", ":=", "bytes", ".", "Buffer", "{", "}", "\n", "first", ":=", "true", "\n", "for", "_", ",", "field", ":=", "range", "fields", "{", "fieldName", ",", "exported", ":=", "fieldName", "(", "field", ")", "\n", "if", "exported", "{", "if", "first", "{", "first", "=", "false", "\n", "}", "else", "{", "ret", ".", "WriteString", "(", "\"", "\"", ")", "\n", "}", "\n\n", "ret", ".", "WriteString", "(", "fieldName", ")", "\n", "}", "\n", "}", "\n\n", "return", "ret", ".", "String", "(", ")", "\n", "}" ]

[ "selectFields", "generates", "comma", "separated", "field", "names", "string" ]

[ "func", "updateSetExpToString", "(", "cfName", "string", ",", "val", "interface", "{", "}", "/*, opts Options*/", ")", "(", "statement", "string", ",", "fields", "[", "]", "string", ",", "err", "error", ")", "{", "fields", "=", "sliceOfFieldNames", "(", "val", ")", "\n\n", "statement", "=", "updateStatement", "(", "cfName", ",", "fields", ")", "\n", "return", "statement", ",", "fields", ",", "nil", "\n", "}" ]

[ "updateSetExpToString", "generates", "UPDATE", "+", "SET", "part", "of", "SQL", "statement", "for", "fields", "of", "an", "entity" ]

[ "func", "updateStatement", "(", "cfName", "string", ",", "fields", "[", "]", "string", "/*, opts Options*/", ")", "(", "statement", "string", ")", "{", "buf", ":=", "new", "(", "bytes", ".", "Buffer", ")", "\n", "buf", ".", "WriteString", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "cfName", ")", ")", "\n\n", "/*\n\t\t// Apply options\n\t\tif opts.TTL != 0 {\n\t\t\tbuf.WriteString(\"USING TTL \")\n\t\t\tbuf.WriteString(strconv.FormatFloat(opts.TTL.Seconds(), 'f', 0, 64))\n\t\t\tbuf.WriteRune(' ')\n\t\t}*/", "buf", ".", "WriteString", "(", "\"", "\"", ")", "\n", "first", ":=", "true", "\n", "for", "_", ",", "fieldName", ":=", "range", "fields", "{", "if", "!", "first", "{", "buf", ".", "WriteString", "(", "\"", "\"", ")", "\n", "}", "else", "{", "first", "=", "false", "\n", "}", "\n", "buf", ".", "WriteString", "(", "fieldName", ")", "\n", "buf", ".", "WriteString", "(", "` = ?`", ")", "\n", "}", "\n\n", "return", "buf", ".", "String", "(", ")", "\n", "}" ]

[ "UPDATE", "keyspace", ".", "Movies", "SET", "col1", "=", "val1", "col2", "=", "val2" ]

[ "func", "(", "visitor", "*", "findEntityVisitor", ")", "VisitPrefixedExp", "(", "exp", "*", "sql", ".", "PrefixedExp", ")", "{", "if", "exp", ".", "Prefix", "==", "\"", "\"", "{", "if", "len", "(", "exp", ".", "Binding", ")", "==", "1", "&&", "r", ".", "Indirect", "(", "r", ".", "ValueOf", "(", "exp", ".", "Binding", "[", "0", "]", ")", ")", ".", "Kind", "(", ")", "==", "r", ".", "Struct", "{", "visitor", ".", "entity", "=", "exp", ".", "Binding", "[", "0", "]", "\n", "}", "\n", "}", "else", "if", "exp", ".", "AfterPrefix", "!=", "nil", "{", "for", "_", ",", "exp", ":=", "range", "exp", ".", "AfterPrefix", "{", "exp", ".", "Accept", "(", "visitor", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "VisitPrefixedExp", "checks", "for", "FROM", "expression", "to", "find", "out", "the", "entity" ]

[ "func", "(", "visitor", "*", "findEntityVisitor", ")", "VisitFieldExpression", "(", "exp", "*", "sql", ".", "FieldExpression", ")", "{", "if", "exp", ".", "AfterField", "!=", "nil", "{", "exp", ".", "AfterField", ".", "Accept", "(", "visitor", ")", "\n", "}", "\n", "}" ]

[ "VisitFieldExpression", "just", "propagates", "to", "AfterFieldExpression" ]

[ "func", "(", "w", "*", "Wrapper01", ")", "MarshalCQL", "(", "info", "gocql", ".", "TypeInfo", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "w", ".", "ip", "==", "nil", "{", "return", "[", "]", "byte", "{", "}", ",", "nil", "\n", "}", "\n\n", "return", "[", "]", "byte", "(", "w", ".", "ip", ".", "String", "(", ")", ")", ",", "nil", "\n", "}" ]

[ "MarshalCQL", "serializes", "the", "string", "representation", "of", "net", ".", "IPNet" ]

[ "func", "(", "w", "*", "Wrapper01", ")", "UnmarshalCQL", "(", "info", "gocql", ".", "TypeInfo", ",", "data", "[", "]", "byte", ")", "error", "{", "if", "len", "(", "data", ")", ">", "0", "{", "_", ",", "ipPrefix", ",", "err", ":=", "net", ".", "ParseCIDR", "(", "string", "(", "data", ")", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "w", ".", "ip", "=", "ipPrefix", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "UnmarshalCQL", "deserializes", "the", "string", "representation", "of", "net", ".", "IPNet" ]

[ "func", "NewEtcdConnectionWithBytes", "(", "config", "ClientConfig", ",", "log", "logging", ".", "Logger", ")", "(", "*", "BytesConnectionEtcd", ",", "error", ")", "{", "t", ":=", "time", ".", "Now", "(", ")", "\n\n", "l", ":=", "log", ".", "WithField", "(", "\"", "\"", ",", "config", ".", "Endpoints", ")", "\n", "l", ".", "Debugf", "(", "\"", "\"", ")", "\n\n", "etcdClient", ",", "err", ":=", "clientv3", ".", "New", "(", "*", "config", ".", "Config", ")", "\n", "if", "err", "!=", "nil", "{", "l", ".", "Warnf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "l", ".", "Infof", "(", "\"", "\"", ",", "time", ".", "Since", "(", "t", ")", ")", "\n\n", "conn", ",", "err", ":=", "NewEtcdConnectionUsingClient", "(", "etcdClient", ",", "log", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "conn", ".", "opTimeout", "=", "config", ".", "OpTimeout", "\n\n", "return", "conn", ",", "nil", "\n", "}" ]

[ "NewEtcdConnectionWithBytes", "creates", "new", "connection", "to", "etcd", "based", "on", "the", "given", "config", "file", "." ]

[ "func", "NewEtcdConnectionUsingClient", "(", "etcdClient", "*", "clientv3", ".", "Client", ",", "log", "logging", ".", "Logger", ")", "(", "*", "BytesConnectionEtcd", ",", "error", ")", "{", "conn", ":=", "BytesConnectionEtcd", "{", "Logger", ":", "log", ",", "etcdClient", ":", "etcdClient", ",", "lessor", ":", "clientv3", ".", "NewLease", "(", "etcdClient", ")", ",", "opTimeout", ":", "defaultOpTimeout", ",", "}", "\n", "return", "&", "conn", ",", "nil", "\n", "}" ]

[ "NewEtcdConnectionUsingClient", "creates", "a", "new", "instance", "of", "BytesConnectionEtcd", "using", "the", "provided", "etcd", "client", ".", "This", "constructor", "is", "used", "primarily", "for", "testing", "." ]

[ "func", "(", "db", "*", "BytesConnectionEtcd", ")", "Close", "(", ")", "error", "{", "if", "db", ".", "etcdClient", "!=", "nil", "{", "return", "db", ".", "etcdClient", ".", "Close", "(", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Close", "closes", "the", "connection", "to", "ETCD", "." ]

[ "func", "(", "pdb", "*", "BytesBrokerWatcherEtcd", ")", "Put", "(", "key", "string", ",", "data", "[", "]", "byte", ",", "opts", "...", "datasync", ".", "PutOption", ")", "error", "{", "return", "putInternal", "(", "pdb", ".", "Logger", ",", "pdb", ".", "kv", ",", "pdb", ".", "lessor", ",", "pdb", ".", "opTimeout", ",", "key", ",", "data", ",", "opts", "...", ")", "\n", "}" ]

[ "Put", "calls", "Put", "function", "of", "the", "underlying", "BytesConnectionEtcd", ".", "KeyPrefix", "defined", "in", "constructor", "is", "prepended", "to", "the", "key", "argument", "." ]

[ "func", "(", "pdb", "*", "BytesBrokerWatcherEtcd", ")", "GetValue", "(", "key", "string", ")", "(", "data", "[", "]", "byte", ",", "found", "bool", ",", "revision", "int64", ",", "err", "error", ")", "{", "return", "getValueInternal", "(", "pdb", ".", "Logger", ",", "pdb", ".", "kv", ",", "pdb", ".", "opTimeout", ",", "key", ")", "\n", "}" ]

[ "GetValue", "calls", "GetValue", "function", "of", "the", "underlying", "BytesConnectionEtcd", ".", "KeyPrefix", "defined", "in", "constructor", "is", "prepended", "to", "the", "key", "argument", "." ]

[ "func", "(", "pdb", "*", "BytesBrokerWatcherEtcd", ")", "Delete", "(", "key", "string", ",", "opts", "...", "datasync", ".", "DelOption", ")", "(", "existed", "bool", ",", "err", "error", ")", "{", "return", "deleteInternal", "(", "pdb", ".", "Logger", ",", "pdb", ".", "kv", ",", "pdb", ".", "opTimeout", ",", "key", ",", "opts", "...", ")", "\n", "}" ]

[ "Delete", "calls", "Delete", "function", "of", "the", "underlying", "BytesConnectionEtcd", ".", "KeyPrefix", "defined", "in", "constructor", "is", "prepended", "to", "the", "key", "argument", "." ]

[ "func", "watchInternal", "(", "log", "logging", ".", "Logger", ",", "watcher", "clientv3", ".", "Watcher", ",", "closeCh", "chan", "string", ",", "prefix", "string", ",", "resp", "func", "(", "keyval", ".", "BytesWatchResp", ")", ")", "error", "{", "ctx", ",", "cancel", ":=", "context", ".", "WithCancel", "(", "context", ".", "Background", "(", ")", ")", "\n", "recvChan", ":=", "watcher", ".", "Watch", "(", "ctx", ",", "prefix", ",", "clientv3", ".", "WithPrefix", "(", ")", ",", "clientv3", ".", "WithPrevKV", "(", ")", ")", "\n\n", "go", "func", "(", "registeredKey", "string", ")", "{", "var", "compactRev", "int64", "\n", "for", "{", "select", "{", "case", "wresp", ",", "ok", ":=", "<-", "recvChan", ":", "if", "!", "ok", "{", "log", ".", "WithField", "(", "\"", "\"", ",", "prefix", ")", ".", "Warn", "(", "\"", "\"", ")", "\n", "if", "compactRev", "!=", "0", "{", "recvChan", "=", "watcher", ".", "Watch", "(", "context", ".", "Background", "(", ")", ",", "prefix", ",", "clientv3", ".", "WithPrefix", "(", ")", ",", "clientv3", ".", "WithPrevKV", "(", ")", ",", "clientv3", ".", "WithRev", "(", "compactRev", ")", ")", "\n", "log", ".", "WithFields", "(", "logging", ".", "Fields", "{", "\"", "\"", ":", "prefix", ",", "\"", "\"", ":", "compactRev", ",", "}", ")", ".", "Warn", "(", "\"", "\"", ")", "\n", "compactRev", "=", "0", "\n", "continue", "\n", "}", "\n", "return", "\n", "}", "\n", "if", "wresp", ".", "Canceled", "{", "log", ".", "WithField", "(", "\"", "\"", ",", "prefix", ")", ".", "Warn", "(", "\"", "\"", ")", "\n", "}", "\n", "err", ":=", "wresp", ".", "Err", "(", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "WithFields", "(", "logging", ".", "Fields", "{", "\"", "\"", ":", "prefix", ",", "\"", "\"", ":", "err", ",", "}", ")", ".", "Warn", "(", "\"", "\"", ")", "\n", "}", "\n", "compactRev", "=", "wresp", ".", "CompactRevision", "\n", "if", "compactRev", "!=", "0", "{", "log", ".", "WithFields", "(", "logging", ".", "Fields", "{", "\"", "\"", ":", "prefix", ",", "\"", "\"", ":", "compactRev", ",", "}", ")", ".", "Warn", "(", "\"", "\"", ")", "\n", "}", "\n", "for", "_", ",", "ev", ":=", "range", "wresp", ".", "Events", "{", "handleWatchEvent", "(", "log", ",", "resp", ",", "ev", ")", "\n", "}", "\n\n", "case", "closeVal", ",", "ok", ":=", "<-", "closeCh", ":", "if", "!", "ok", "||", "closeVal", "==", "registeredKey", "{", "cancel", "(", ")", "\n", "log", ".", "WithField", "(", "\"", "\"", ",", "prefix", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "(", "prefix", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "watchInternal", "starts", "the", "watch", "subscription", "for", "the", "key", "." ]

[ "func", "(", "db", "*", "BytesConnectionEtcd", ")", "Put", "(", "key", "string", ",", "binData", "[", "]", "byte", ",", "opts", "...", "datasync", ".", "PutOption", ")", "error", "{", "return", "putInternal", "(", "db", ".", "Logger", ",", "db", ".", "etcdClient", ",", "db", ".", "lessor", ",", "db", ".", "opTimeout", ",", "key", ",", "binData", ",", "opts", "...", ")", "\n", "}" ]

[ "Put", "writes", "the", "provided", "key", "-", "value", "item", "into", "the", "data", "store", ".", "Returns", "an", "error", "if", "the", "item", "could", "not", "be", "written", "nil", "otherwise", "." ]

[ "func", "(", "db", "*", "BytesConnectionEtcd", ")", "ListValuesRange", "(", "fromPrefix", "string", ",", "toPrefix", "string", ")", "(", "keyval", ".", "BytesKeyValIterator", ",", "error", ")", "{", "return", "listValuesRangeInternal", "(", "db", ".", "Logger", ",", "db", ".", "etcdClient", ",", "db", ".", "opTimeout", ",", "fromPrefix", ",", "toPrefix", ")", "\n", "}" ]

[ "ListValuesRange", "returns", "an", "iterator", "that", "enables", "traversing", "values", "stored", "under", "the", "keys", "from", "a", "given", "range", "." ]

[ "func", "(", "db", "*", "BytesConnectionEtcd", ")", "Compact", "(", "rev", "...", "int64", ")", "(", "int64", ",", "error", ")", "{", "return", "compactInternal", "(", "db", ".", "Logger", ",", "db", ".", "etcdClient", ",", "db", ".", "opTimeout", ",", "rev", "...", ")", "\n", "}" ]

[ "Compact", "compacts", "the", "ETCD", "database", "to", "specific", "revision" ]

[ "func", "(", "db", "*", "BytesConnectionEtcd", ")", "GetRevision", "(", ")", "(", "revision", "int64", ",", "err", "error", ")", "{", "return", "getRevisionInternal", "(", "db", ".", "Logger", ",", "db", ".", "etcdClient", ",", "db", ".", "opTimeout", ")", "\n", "}" ]

[ "GetRevision", "returns", "current", "revision", "of", "ETCD", "database" ]

[ "func", "(", "ev", "*", "DoneChannel", ")", "Done", "(", "err", "error", ")", "{", "if", "ev", ".", "DoneChan", "!=", "nil", "{", "select", "{", "case", "ev", ".", "DoneChan", "<-", "err", ":", "// sent successfully", "default", ":", "logrus", ".", "DefaultLogger", "(", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "else", "if", "err", "!=", "nil", "{", "logrus", ".", "DefaultLogger", "(", ")", ".", "Error", "(", "err", ")", "\n", "}", "\n", "}" ]

[ "Done", "propagates", "error", "to", "the", "channel", "." ]

[ "func", "(", "ev", "*", "DoneCallback", ")", "Done", "(", "err", "error", ")", "{", "if", "ev", ".", "Callback", "!=", "nil", "{", "ev", ".", "Callback", "(", "err", ")", "\n", "}", "else", "if", "err", "!=", "nil", "{", "logrus", ".", "DefaultLogger", "(", ")", ".", "Error", "(", "err", ")", "\n", "}", "\n", "}" ]

[ "Done", "propagates", "error", "to", "the", "callback", "." ]

[ "func", "AggregateDone", "(", "events", "[", "]", "func", "(", "chan", "error", ")", ",", "done", "chan", "error", ")", "{", "partialDone", ":=", "make", "(", "chan", "error", ",", "5", ")", "\n\n", "go", "collectDoneEvents", "(", "partialDone", ",", "done", ",", "len", "(", "events", ")", ")", "\n\n", "for", "_", ",", "event", ":=", "range", "events", "{", "event", "(", "partialDone", ")", "// fire event", "\n", "}", "\n", "}" ]

[ "AggregateDone", "can", "be", "reused", "to", "avoid", "repetitive", "code", "that", "triggers", "a", "slice", "of", "events", "and", "waits", "until", "it", "is", "finished", "." ]

[ "func", "NewBytesWatchPutResp", "(", "key", "string", ",", "value", "[", "]", "byte", ",", "prevValue", "[", "]", "byte", ",", "revision", "int64", ")", "*", "BytesWatchPutResp", "{", "return", "&", "BytesWatchPutResp", "{", "key", ":", "key", ",", "value", ":", "value", ",", "prevValue", ":", "prevValue", ",", "rev", ":", "revision", "}", "\n", "}" ]

[ "NewBytesWatchPutResp", "creates", "an", "instance", "of", "BytesWatchPutResp", "." ]

[ "func", "(", "db", "*", "BytesConnectionRedis", ")", "Watch", "(", "resp", "func", "(", "keyval", ".", "BytesWatchResp", ")", ",", "closeChan", "chan", "string", ",", "keys", "...", "string", ")", "error", "{", "if", "db", ".", "closed", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "keys", ")", "\n", "}", "\n", "db", ".", "closeCh", "=", "closeChan", "\n\n", "return", "watch", "(", "db", ",", "resp", ",", "db", ".", "closeCh", ",", "nil", ",", "nil", ",", "keys", "...", ")", "\n", "}" ]

[ "Watch", "starts", "subscription", "for", "changes", "associated", "with", "the", "selected", "key", ".", "Watch", "events", "will", "be", "delivered", "to", "respChan", ".", "Subscription", "can", "be", "canceled", "by", "StopWatch", "call", "." ]

[ "func", "(", "pdb", "*", "BytesBrokerWatcherRedis", ")", "Watch", "(", "resp", "func", "(", "keyval", ".", "BytesWatchResp", ")", ",", "closeChan", "chan", "string", ",", "keys", "...", "string", ")", "error", "{", "if", "pdb", ".", "delegate", ".", "closed", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "keys", ")", "\n", "}", "\n", "return", "watch", "(", "pdb", ".", "delegate", ",", "resp", ",", "closeChan", ",", "pdb", ".", "addPrefix", ",", "pdb", ".", "trimPrefix", ",", "keys", "...", ")", "\n", "}" ]

[ "Watch", "starts", "subscription", "for", "changes", "associated", "with", "the", "selected", "key", ".", "Watch", "events", "will", "be", "delivered", "to", "respChan", "." ]

[ "func", "UseMessaging", "(", "m", "messaging", ".", "Mux", ")", "Option", "{", "return", "func", "(", "p", "*", "Plugin", ")", "{", "p", ".", "Deps", ".", "Messaging", "=", "m", "\n", "}", "\n", "}" ]

[ "UseMessaging", "returns", "Option", "that", "sets", "Messaging", "." ]

[ "func", "(", "arr", "SortedIPs", ")", "Swap", "(", "i", ",", "j", "int", ")", "{", "arr", "[", "i", "]", ",", "arr", "[", "j", "]", "=", "arr", "[", "j", "]", ",", "arr", "[", "i", "]", "\n", "}" ]

[ "Swap", "swaps", "two", "items", "in", "slice", "identified", "by", "indexes", "Implements", "sort", ".", "Interface" ]

[ "func", "(", "arr", "SortedIPs", ")", "Less", "(", "i", ",", "j", "int", ")", "bool", "{", "return", "lessAdrr", "(", "arr", "[", "i", "]", ",", "arr", "[", "j", "]", ")", "\n", "}" ]

[ "Less", "returns", "true", "if", "the", "item", "in", "slice", "at", "index", "i", "in", "slice", "should", "be", "sorted", "before", "the", "element", "with", "index", "j", "Implements", "sort", ".", "Interface" ]

[ "func", "DiffAddr", "(", "newConfig", "[", "]", "*", "net", ".", "IPNet", ",", "oldConfig", "[", "]", "*", "net", ".", "IPNet", ")", "(", "toBeDeleted", "[", "]", "*", "net", ".", "IPNet", ",", "toBeAdded", "[", "]", "*", "net", ".", "IPNet", ")", "{", "var", "add", "[", "]", "*", "net", ".", "IPNet", "\n", "var", "del", "[", "]", "*", "net", ".", "IPNet", "\n", "//sort", "n", ":=", "SortedIPs", "(", "newConfig", ")", "\n", "sort", ".", "Sort", "(", "&", "n", ")", "\n", "o", ":=", "SortedIPs", "(", "oldConfig", ")", "\n", "sort", ".", "Sort", "(", "&", "o", ")", "\n\n", "//compare", "i", ":=", "0", "\n", "j", ":=", "0", "\n", "for", "i", "<", "len", "(", "n", ")", "&&", "j", "<", "len", "(", "o", ")", "{", "if", "eqAddr", "(", "n", "[", "i", "]", ",", "o", "[", "j", "]", ")", "{", "i", "++", "\n", "j", "++", "\n", "}", "else", "{", "if", "lessAdrr", "(", "n", "[", "i", "]", ",", "o", "[", "j", "]", ")", "{", "add", "=", "append", "(", "add", ",", "n", "[", "i", "]", ")", "\n", "i", "++", "\n", "}", "else", "{", "del", "=", "append", "(", "del", ",", "o", "[", "j", "]", ")", "\n", "j", "++", "\n", "}", "\n", "}", "\n", "}", "\n\n", "for", ";", "i", "<", "len", "(", "n", ")", ";", "i", "++", "{", "add", "=", "append", "(", "add", ",", "n", "[", "i", "]", ")", "\n", "}", "\n\n", "for", ";", "j", "<", "len", "(", "o", ")", ";", "j", "++", "{", "del", "=", "append", "(", "del", ",", "o", "[", "j", "]", ")", "\n", "}", "\n", "return", "del", ",", "add", "\n", "}" ]

[ "DiffAddr", "calculates", "the", "difference", "between", "two", "slices", "of", "AddrWithPrefix", "configuration", ".", "Returns", "a", "list", "of", "addresses", "that", "should", "be", "deleted", "and", "added", "to", "the", "current", "configuration", "to", "match", "newConfig", "." ]

[ "func", "StrAddrsToStruct", "(", "addrs", "[", "]", "string", ")", "(", "[", "]", "*", "net", ".", "IPNet", ",", "error", ")", "{", "var", "result", "[", "]", "*", "net", ".", "IPNet", "\n", "for", "_", ",", "addressWithPrefix", ":=", "range", "addrs", "{", "if", "addressWithPrefix", "==", "\"", "\"", "{", "continue", "\n", "}", "\n", "parsedIPWithPrefix", ",", "_", ",", "err", ":=", "ParseIPWithPrefix", "(", "addressWithPrefix", ")", "\n", "if", "err", "!=", "nil", "{", "return", "result", ",", "err", "\n", "}", "\n", "result", "=", "append", "(", "result", ",", "parsedIPWithPrefix", ")", "\n", "}", "\n\n", "return", "result", ",", "nil", "\n", "}" ]

[ "StrAddrsToStruct", "converts", "slice", "of", "strings", "representing", "ipv4", "addresses", "to", "IPNet", "structures" ]

[ "func", "IsIPv6", "(", "addr", "string", ")", "(", "bool", ",", "error", ")", "{", "ip", ":=", "net", ".", "ParseIP", "(", "addr", ")", "\n", "if", "ip", "==", "nil", "{", "return", "false", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "addr", ")", "\n", "}", "\n", "return", "ip", ".", "To4", "(", ")", "==", "nil", ",", "nil", "\n", "}" ]

[ "IsIPv6", "returns", "true", "if", "provided", "IP", "address", "is", "IPv6", "false", "otherwise" ]

[ "func", "GetCommand", "(", ")", "*", "Command", "{", "var", "command", "*", "Command", "\n", "loop", ":", "for", "{", "cmd", ":=", "prompter", ".", "Choose", "(", "\"", "\\n", "\"", ",", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", "}", ",", "\"", "\"", ")", "\n", "command", "=", "new", "(", "Command", ")", "\n", "switch", "cmd", "{", "case", "\"", "\"", ":", "command", ".", "Cmd", "=", "\"", "\"", "\n", "fin", ":=", "prompter", ".", "YN", "(", "\"", "\"", ",", "true", ")", "\n", "if", "fin", "{", "break", "loop", "\n", "}", "\n", "case", "\"", "\"", ":", "command", ".", "Cmd", "=", "\"", "\"", "\n", "var", "(", "topic", "string", "\n", "text", "string", "\n", ")", "\n", "for", "{", "topic", "=", "prompter", ".", "Prompt", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "if", "topic", "==", "\"", "\"", "{", "fmt", ".", "Println", "(", "\"", "\"", ")", "\n", "}", "else", "{", "break", "\n", "}", "\n", "}", "\n", "for", "{", "text", "=", "prompter", ".", "Prompt", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "if", "text", "==", "\"", "\"", "{", "fmt", ".", "Println", "(", "\"", "\"", ")", "\n", "}", "else", "{", "break", "\n", "}", "\n", "}", "\n", "command", ".", "Topic", "=", "topic", "\n", "command", ".", "Text", "=", "text", "\n", "key", ":=", "prompter", ".", "Prompt", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "command", ".", "Key", "=", "key", "\n", "metadata", ":=", "prompter", ".", "Prompt", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "command", ".", "Metadata", "=", "metadata", "\n", "send", ":=", "prompter", ".", "YN", "(", "\"", "\"", ",", "true", ")", "\n", "if", "send", "{", "break", "loop", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "command", "\n", "}" ]

[ "GetCommand", "allows", "user", "to", "select", "a", "command", "and", "reads", "the", "input", "arguments", "." ]

[ "func", "(", "yd", "*", "YAMLDecoder", ")", "Encode", "(", "data", "[", "]", "*", "FileDataEntry", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "// Convert to json-specific structure", "var", "yamlFileEntries", "[", "]", "yamlFileEntry", "\n", "for", "_", ",", "dataEntry", ":=", "range", "data", "{", "yamlFileEntries", "=", "append", "(", "yamlFileEntries", ",", "yamlFileEntry", "{", "Key", ":", "dataEntry", ".", "Key", ",", "Value", ":", "dataEntry", ".", "Value", ",", "}", ")", "\n", "}", "\n", "// Encode to type specific structure", "yamlFile", ":=", "&", "yamlFile", "{", "Data", ":", "yamlFileEntries", "}", "\n", "return", "yaml", ".", "Marshal", "(", "yamlFile", ")", "\n", "}" ]

[ "Encode", "provided", "file", "entries", "into", "json", "byte", "set" ]

[ "func", "(", "yd", "*", "YAMLDecoder", ")", "Decode", "(", "byteSet", "[", "]", "byte", ")", "(", "[", "]", "*", "FileDataEntry", ",", "error", ")", "{", "if", "len", "(", "byteSet", ")", "==", "0", "{", "return", "[", "]", "*", "FileDataEntry", "{", "}", ",", "nil", "\n", "}", "\n", "// Decode to type-specific structure", "yamlFile", ":=", "yamlFile", "{", "}", "\n", "err", ":=", "yaml", ".", "Unmarshal", "(", "byteSet", ",", "&", "yamlFile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "// Convert to common file data entry list structure", "var", "dataEntries", "[", "]", "*", "FileDataEntry", "\n", "for", "_", ",", "dataEntry", ":=", "range", "yamlFile", ".", "Data", "{", "dataEntries", "=", "append", "(", "dataEntries", ",", "&", "FileDataEntry", "{", "Key", ":", "dataEntry", ".", "Key", ",", "Value", ":", "dataEntry", ".", "Value", "}", ")", "\n", "}", "\n", "return", "dataEntries", ",", "nil", "\n", "}" ]

[ "Decode", "provided", "YAML", "file" ]

[ "func", "NewKvProtoPluginWrapper", "(", "kvp", "keyval", ".", "KvProtoPlugin", ",", "decrypter", "ArbitraryDecrypter", ",", "decryptFunc", "DecryptFunc", ")", "*", "KvProtoPluginWrapper", "{", "return", "&", "KvProtoPluginWrapper", "{", "KvProtoPlugin", ":", "kvp", ",", "decryptData", ":", "decryptData", "{", "decryptFunc", ":", "decryptFunc", ",", "decrypter", ":", "decrypter", ",", "}", ",", "}", "\n", "}" ]

[ "NewKvProtoPluginWrapper", "creates", "wrapper", "for", "provided", "KvProtoPlugin", "adding", "support", "for", "decrypting", "encrypted", "data" ]

[ "func", "NewProtoBrokerWrapper", "(", "pb", "keyval", ".", "ProtoBroker", ",", "decrypter", "ArbitraryDecrypter", ",", "decryptFunc", "DecryptFunc", ")", "*", "ProtoBrokerWrapper", "{", "return", "&", "ProtoBrokerWrapper", "{", "ProtoBroker", ":", "pb", ",", "decryptData", ":", "decryptData", "{", "decryptFunc", ":", "decryptFunc", ",", "decrypter", ":", "decrypter", ",", "}", ",", "}", "\n", "}" ]

[ "NewProtoBrokerWrapper", "creates", "wrapper", "for", "provided", "ProtoBroker", "adding", "support", "for", "decrypting", "encrypted", "data" ]

[ "func", "NewProtoWatcherWrapper", "(", "pb", "keyval", ".", "ProtoWatcher", ",", "decrypter", "ArbitraryDecrypter", ",", "decryptFunc", "DecryptFunc", ")", "*", "ProtoWatcherWrapper", "{", "return", "&", "ProtoWatcherWrapper", "{", "ProtoWatcher", ":", "pb", ",", "decryptData", ":", "decryptData", "{", "decryptFunc", ":", "decryptFunc", ",", "decrypter", ":", "decrypter", ",", "}", ",", "}", "\n", "}" ]

[ "NewProtoWatcherWrapper", "creates", "wrapper", "for", "provided", "ProtoWatcher", "adding", "support", "for", "decrypting", "encrypted", "data" ]

[ "func", "(", "f", "*", "CustomFormatter", ")", "Format", "(", "entry", "*", "log", ".", "Entry", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "buffer", ":=", "&", "bytes", ".", "Buffer", "{", "}", "\n", "compulsoryFields", ":=", "map", "[", "string", "]", "interface", "{", "}", "{", "}", "\n\n", "compulsoryFields", "[", "fieldKeyTime", "]", "=", "entry", ".", "Time", ".", "Format", "(", "time", ".", "RFC3339", ")", "\n", "compulsoryFields", "[", "fieldKeyMsg", "]", "=", "entry", ".", "Message", "\n", "compulsoryFields", "[", "fieldKeyLevel", "]", "=", "f", ".", "logLevelToString", "(", "entry", ".", "Level", ")", "\n", "if", "comp", ",", "found", ":=", "entry", ".", "Data", "[", "fieldKeyComponent", "]", ";", "found", "{", "compulsoryFields", "[", "fieldKeyComponent", "]", "=", "fmt", ".", "Sprint", "(", "comp", ")", "\n", "}", "else", "{", "compulsoryFields", "[", "fieldKeyComponent", "]", "=", "\"", "\"", "\n", "}", "\n\n", "compulsoryFields", "[", "fieldKeyProcess", "]", "=", "os", ".", "Getpid", "(", ")", "\n\n", "// Print header (timestamp can be turned off)", "if", "f", ".", "ShowTimestamp", "{", "fmt", ".", "Fprint", "(", "buffer", ",", "compulsoryFields", "[", "fieldKeyTime", "]", ")", "\n", "buffer", ".", "WriteByte", "(", "' '", ")", "\n", "}", "\n", "for", "_", ",", "key", ":=", "range", "compulsoryKeys", "[", "1", ":", "]", "{", "fmt", ".", "Fprint", "(", "buffer", ",", "compulsoryFields", "[", "key", "]", ")", "\n", "buffer", ".", "WriteByte", "(", "' '", ")", "\n", "}", "\n\n", "// Print explicit key-value pairs", "for", "k", ",", "v", ":=", "range", "entry", ".", "Data", "{", "if", "!", "f", ".", "ignoredKey", "(", "k", ")", "{", "f", ".", "appendKeyValue", "(", "buffer", ",", "k", ",", "v", ")", "\n", "}", "\n", "}", "\n\n", "buffer", ".", "WriteString", "(", "\"", "\"", ")", "\n", "buffer", ".", "WriteByte", "(", "'\"'", ")", "\n", "fmt", ".", "Fprint", "(", "buffer", ",", "compulsoryFields", "[", "fieldKeyMsg", "]", ")", "\n", "buffer", ".", "WriteByte", "(", "'\"'", ")", "\n", "buffer", ".", "WriteByte", "(", "'\\n'", ")", "\n\n", "return", "buffer", ".", "Bytes", "(", ")", ",", "nil", "\n", "}" ]

[ "Format", "formats", "the", "given", "log", "entry", "." ]

[ "func", "(", "p", "*", "Plugin", ")", "AfterInit", "(", ")", "error", "{", "if", "p", ".", "StatusCheck", "==", "nil", "{", "p", ".", "Log", ".", "Warnf", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n\n", "if", "p", ".", "HTTP", "!=", "nil", "{", "p", ".", "Log", ".", "Infof", "(", "\"", "\"", ",", "p", ".", "HTTP", ".", "GetPort", "(", ")", ")", "\n", "p", ".", "HTTP", ".", "RegisterHTTPHandler", "(", "livenessProbePath", ",", "p", ".", "livenessProbeHandler", ",", "\"", "\"", ")", "\n", "p", ".", "HTTP", ".", "RegisterHTTPHandler", "(", "readinessProbePath", ",", "p", ".", "readinessProbeHandler", ",", "\"", "\"", ")", "\n", "}", "else", "{", "p", ".", "Log", ".", "Info", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "p", ".", "Prometheus", "!=", "nil", "{", "if", "err", ":=", "p", ".", "registerPrometheusProbe", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "else", "{", "p", ".", "Log", ".", "Info", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "AfterInit", "registers", "HTTP", "handlers", "for", "liveness", "and", "readiness", "probes", "." ]

[ "func", "(", "p", "*", "Plugin", ")", "readinessProbeHandler", "(", "formatter", "*", "render", ".", "Render", ")", "http", ".", "HandlerFunc", "{", "return", "func", "(", "w", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "{", "ifStat", ":=", "p", ".", "StatusCheck", ".", "GetInterfaceStats", "(", ")", "\n", "agentStat", ":=", "p", ".", "getAgentStatus", "(", ")", "\n", "agentStat", ".", "InterfaceStats", "=", "&", "ifStat", "\n", "agentStatJSON", ",", "_", ":=", "json", ".", "Marshal", "(", "agentStat", ")", "\n", "if", "agentStat", ".", "State", "==", "status", ".", "OperationalState_OK", "{", "w", ".", "WriteHeader", "(", "http", ".", "StatusOK", ")", "\n", "}", "else", "{", "w", ".", "WriteHeader", "(", "http", ".", "StatusInternalServerError", ")", "\n", "}", "\n", "w", ".", "Write", "(", "agentStatJSON", ")", "\n", "}", "\n", "}" ]

[ "readinessProbeHandler", "handles", "k8s", "readiness", "probe", "." ]

[ "func", "(", "p", "*", "Plugin", ")", "livenessProbeHandler", "(", "formatter", "*", "render", ".", "Render", ")", "http", ".", "HandlerFunc", "{", "return", "func", "(", "w", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "{", "stat", ":=", "p", ".", "getAgentStatus", "(", ")", "\n", "statJSON", ",", "_", ":=", "json", ".", "Marshal", "(", "stat", ")", "\n\n", "if", "stat", ".", "State", "==", "status", ".", "OperationalState_INIT", "||", "stat", ".", "State", "==", "status", ".", "OperationalState_OK", "{", "w", ".", "WriteHeader", "(", "http", ".", "StatusOK", ")", "\n", "w", ".", "Write", "(", "statJSON", ")", "\n", "}", "else", "{", "w", ".", "WriteHeader", "(", "http", ".", "StatusInternalServerError", ")", "\n", "w", ".", "Write", "(", "statJSON", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "livenessProbeHandler", "handles", "k8s", "liveness", "probe", "." ]

[ "func", "(", "p", "*", "Plugin", ")", "getAgentStatus", "(", ")", "ExposedStatus", "{", "exposedStatus", ":=", "ExposedStatus", "{", "AgentStatus", ":", "p", ".", "StatusCheck", ".", "GetAgentStatus", "(", ")", ",", "PluginStatus", ":", "p", ".", "StatusCheck", ".", "GetAllPluginStatus", "(", ")", ",", "NonFatalPlugins", ":", "p", ".", "NonFatalPlugins", ",", "}", "\n\n", "// check whether error is caused by one of the plugins in NonFatalPlugin list", "if", "exposedStatus", ".", "AgentStatus", ".", "State", "==", "status", ".", "OperationalState_ERROR", "&&", "len", "(", "p", ".", "NonFatalPlugins", ")", ">", "0", "{", "for", "k", ",", "v", ":=", "range", "exposedStatus", ".", "PluginStatus", "{", "if", "v", ".", "State", "==", "status", ".", "OperationalState_ERROR", "{", "if", "isInSlice", "(", "p", ".", "NonFatalPlugins", ",", "k", ")", "{", "// treat error reported by this plugin as non fatal", "exposedStatus", ".", "AgentStatus", ".", "State", "=", "status", ".", "OperationalState_OK", "\n", "}", "else", "{", "exposedStatus", ".", "AgentStatus", ".", "State", "=", "status", ".", "OperationalState_ERROR", "\n", "break", "\n", "}", "\n", "}", "\n\n", "}", "\n", "}", "\n\n", "return", "exposedStatus", "\n", "}" ]

[ "getAgentStatus", "return", "overall", "agent", "status", "+", "status", "of", "the", "plugins", "the", "method", "takes", "into", "account", "non", "-", "fatal", "plugin", "settings" ]

[ "func", "generateLogs", "(", ")", "{", "myLogger", ":=", "logRegistry", ".", "NewLogger", "(", "\"", "\"", ")", "\n\n", "for", "range", "time", ".", "NewTicker", "(", "10", "*", "time", ".", "Second", ")", ".", "C", "{", "myLogger", ".", "Debug", "(", "\"", "\"", ")", "\n", "myLogger", ".", "Info", "(", "\"", "\"", ")", "\n", "myLogger", ".", "Error", "(", "\"", "\"", ")", "\n\n", "defaultLogger", ".", "Debug", "(", "\"", "\"", ")", "\n", "defaultLogger", ".", "Info", "(", "\"", "\"", ")", "\n", "defaultLogger", ".", "Error", "(", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "Every", "10", "seconds", "prints", "a", "set", "of", "logs", "using", "default", "and", "custom", "logger" ]

[ "func", "UseHTTP", "(", "h", "rest", ".", "HTTPHandlers", ")", "Option", "{", "return", "func", "(", "p", "*", "Plugin", ")", "{", "p", ".", "Deps", ".", "HTTP", "=", "h", "\n", "}", "\n", "}" ]

[ "UseHTTP", "returns", "Option", "that", "sets", "HTTP", "handlers", "." ]

[ "func", "UseTLS", "(", "c", "*", "tls", ".", "Config", ")", "Option", "{", "return", "func", "(", "p", "*", "Plugin", ")", "{", "p", ".", "tlsConfig", "=", "c", "\n", "}", "\n", "}" ]

[ "UseTLS", "return", "Option", "that", "sets", "TLS", "config", "." ]

[ "func", "newStaticAuthenticator", "(", "users", "[", "]", "string", ")", "(", "*", "staticAuthenticator", ",", "error", ")", "{", "sa", ":=", "&", "staticAuthenticator", "{", "credentials", ":", "make", "(", "map", "[", "string", "]", "string", ")", ",", "}", "\n", "for", "_", ",", "u", ":=", "range", "users", "{", "fields", ":=", "strings", ".", "Split", "(", "u", ",", "\"", "\"", ")", "\n", "if", "len", "(", "fields", ")", "!=", "2", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "u", ")", "\n", "}", "\n", "sa", ".", "credentials", "[", "fields", "[", "0", "]", "]", "=", "fields", "[", "1", "]", "\n", "}", "\n", "return", "sa", ",", "nil", "\n", "}" ]

[ "newStaticAuthenticator", "creates", "new", "instance", "of", "static", "authenticator", ".", "Argument", "users", "is", "a", "slice", "of", "colon", "-", "separated", "username", "and", "password", "couples", "." ]

[ "func", "(", "sa", "*", "staticAuthenticator", ")", "Authenticate", "(", "user", "string", ",", "pass", "string", ")", "bool", "{", "password", ",", "found", ":=", "sa", ".", "credentials", "[", "user", "]", "\n", "if", "!", "found", "{", "return", "false", "\n", "}", "\n", "return", "pass", "==", "password", "\n", "}" ]

[ "Authenticate", "looks", "up", "the", "given", "user", "name", "and", "password", "in", "the", "internal", "map", ".", "If", "match", "is", "found", "returns", "true", "false", "otherwise", "." ]

[ "func", "NewAgent", "(", "opts", "...", "Option", ")", "Agent", "{", "options", ":=", "newOptions", "(", "opts", "...", ")", "\n\n", "if", "!", "flag", ".", "Parsed", "(", ")", "{", "config", ".", "DefineDirFlag", "(", ")", "\n", "for", "_", ",", "p", ":=", "range", "options", ".", "Plugins", "{", "name", ":=", "p", ".", "String", "(", ")", "\n", "infraLogger", ".", "Debugf", "(", "\"", "\"", ",", "name", ")", "\n", "config", ".", "DefineFlagsFor", "(", "name", ")", "\n", "}", "\n", "flag", ".", "Parse", "(", ")", "\n", "}", "\n\n", "return", "&", "agent", "{", "opts", ":", "options", ",", "tracer", ":", "measure", ".", "NewTracer", "(", "\"", "\"", ")", ",", "}", "\n", "}" ]

[ "NewAgent", "creates", "a", "new", "agent", "using", "given", "options", "and", "registers", "all", "flags", "defined", "for", "plugins", "via", "config", ".", "ForPlugin", "." ]

[ "func", "(", "a", "*", "agent", ")", "Run", "(", ")", "error", "{", "if", "err", ":=", "a", ".", "Start", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "a", ".", "Wait", "(", ")", "\n", "}" ]

[ "Run", "runs", "the", "agent", ".", "Run", "will", "not", "return", "until", "a", "SIGINT", "SIGTERM", "or", "SIGKILL", "is", "received" ]

[ "func", "(", "plugin", "*", "ExamplePlugin", ")", "asyncEventHandler", "(", ")", "{", "plugin", ".", "Log", ".", "Info", "(", "\"", "\"", ")", "\n", "asyncSuccessCounter", ":=", "0", "\n", "if", "messageCountNum", "==", "0", "{", "plugin", ".", "asyncSuccess", "=", "true", "\n", "}", "\n\n", "for", "{", "select", "{", "// Channel subscribed with watcher", "case", "message", ":=", "<-", "plugin", ".", "asyncSubscription", ":", "plugin", ".", "Log", ".", "Infof", "(", "\"", "\"", ",", "message", ".", "GetTopic", "(", ")", ",", "message", ".", "GetPartition", "(", ")", ",", "message", ".", "GetOffset", "(", ")", ",", "message", ".", "GetKey", "(", ")", ")", "\n", "// Note: mark the offset if required", "if", "message", ".", "GetPartition", "(", ")", "!=", "asyncMessagePartition", "{", "plugin", ".", "Log", ".", "Errorf", "(", "\"", "\"", ",", "message", ".", "GetOffset", "(", ")", ")", "\n", "}", "\n", "if", "message", ".", "GetOffset", "(", ")", "<", "messageOffset", "{", "plugin", ".", "Log", ".", "Errorf", "(", "\"", "\"", ",", "message", ".", "GetOffset", "(", ")", ")", "\n", "}", "\n", "// Success callback channel", "case", "message", ":=", "<-", "plugin", ".", "asyncSuccessChannel", ":", "plugin", ".", "Log", ".", "Infof", "(", "\"", "\"", ",", "message", ".", "GetTopic", "(", ")", ",", "message", ".", "GetPartition", "(", ")", ",", "message", ".", "GetOffset", "(", ")", ",", "message", ".", "GetKey", "(", ")", ")", "\n", "// Note: mark the offset if required", "asyncSuccessCounter", "++", "\n", "if", "asyncSuccessCounter", "==", "messageCountNum", "{", "plugin", ".", "asyncSuccess", "=", "true", "\n", "}", "\n", "// Error callback channel", "case", "err", ":=", "<-", "plugin", ".", "asyncErrorChannel", ":", "plugin", ".", "Log", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "asyncEventHandler", "is", "a", "Kafka", "consumer", "asynchronously", "processing", "events", "from", "a", "channel", "associated", "with", "a", "specific", "topic", "partition", "and", "a", "starting", "offset", ".", "If", "a", "producer", "sends", "a", "message", "matching", "this", "destination", "criteria", "the", "consumer", "will", "receive", "it", "." ]

[ "func", "(", "p", "*", "HelloWorld", ")", "SetPlace", "(", "world", ",", "place", "string", ")", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "world", ",", "place", ")", "\n", "}" ]

[ "SetPlace", "is", "an", "exported", "method", "that", "allows", "other", "plugins", "to", "set", "some", "internal", "parameters" ]

[ "func", "RegisterFlags", "(", ")", "{", "fmt", ".", "Println", "(", "\"", "\"", ")", "\n", "flag", ".", "StringVar", "(", "&", "testFlagString", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flag", ".", "IntVar", "(", "&", "testFlagInt", ",", "\"", "\"", ",", "1122", ",", "\"", "\"", ")", "\n", "flag", ".", "Int64Var", "(", "&", "testFlagInt64", ",", "\"", "\"", ",", "-", "3344", ",", "\"", "\"", ")", "\n", "flag", ".", "UintVar", "(", "&", "testFlagUint", ",", "\"", "\"", ",", "5566", ",", "\"", "\"", ")", "\n", "flag", ".", "Uint64Var", "(", "&", "testFlagUint64", ",", "\"", "\"", ",", "7788", ",", "\"", "\"", ")", "\n", "flag", ".", "BoolVar", "(", "&", "testFlagBool", ",", "\"", "\"", ",", "true", ",", "\"", "\"", ")", "\n", "flag", ".", "DurationVar", "(", "&", "testFlagDur", ",", "\"", "\"", ",", "time", ".", "Second", "*", "5", ",", "\"", "\"", ")", "\n", "}" ]

[ "RegisterFlags", "contains", "examples", "of", "how", "to", "register", "flags", "of", "various", "types", "." ]

[ "func", "PrintFlags", "(", ")", "{", "fmt", ".", "Println", "(", "\"", "\"", ")", "\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "testFlagString", ")", "\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "testFlagInt", ")", "\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "testFlagInt64", ")", "\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "testFlagUint", ")", "\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "testFlagUint64", ")", "\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "testFlagBool", ")", "\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "testFlagDur", ")", "\n", "}" ]

[ "PrintFlags", "shows", "the", "runtime", "values", "of", "CLI", "flags", "." ]

[ "func", "(", "adapter", "*", "Adapter", ")", "Watch", "(", "resyncName", "string", ",", "changeChan", "chan", "datasync", ".", "ChangeEvent", ",", "resyncChan", "chan", "datasync", ".", "ResyncEvent", ",", "keyPrefixes", "...", "string", ")", "(", "datasync", ".", "WatchRegistration", ",", "error", ")", "{", "if", "adapter", ".", "Watcher", "!=", "nil", "{", "return", "adapter", ".", "Watcher", ".", "Watch", "(", "resyncName", ",", "changeChan", ",", "resyncChan", ",", "keyPrefixes", "...", ")", "\n", "}", "\n", "logrus", ".", "DefaultLogger", "(", ")", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "return", "nil", ",", "nil", "\n", "}" ]

[ "Watch", "uses", "Kafka", "KeyValProtoWatcher", "Topic", "KeyValProtoWatcher", "." ]

[ "func", "(", "adapter", "*", "Adapter", ")", "Put", "(", "key", "string", ",", "data", "proto", ".", "Message", ")", "error", "{", "if", "adapter", ".", "Publisher", "!=", "nil", "{", "return", "adapter", ".", "Publisher", ".", "Put", "(", "key", ",", "data", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Put", "uses", "Kafka", "KeyValProtoWatcher", "Topic", "KeyProtoValWriter", "." ]

[ "func", "(", "p", "*", "ExamplePlugin", ")", "AfterInit", "(", ")", "error", "{", "resync", ".", "DefaultPlugin", ".", "DoResync", "(", ")", "\n\n", "go", "p", ".", "etcdPublisher", "(", ")", "\n\n", "go", "p", ".", "closeExample", "(", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "AfterInit", "starts", "the", "publisher", "and", "prepares", "for", "the", "shutdown", "." ]

[ "func", "(", "p", "*", "ExamplePlugin", ")", "Close", "(", ")", "error", "{", "p", ".", "Log", ".", "Info", "(", "\"", "\"", ")", "\n", "// Close the watcher", "p", ".", "cancel", "(", ")", "\n", "p", ".", "wg", ".", "Wait", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "Close", "shutdowns", "both", "the", "publisher", "and", "the", "consumer", ".", "Channels", "used", "to", "propagate", "data", "resync", "and", "data", "change", "events", "are", "closed", "as", "well", "." ]

[ "func", "(", "p", "*", "ExamplePlugin", ")", "subscribeWatcher", "(", ")", "(", "err", "error", ")", "{", "prefix", ":=", "etcdKeyPrefix", "(", "p", ".", "ServiceLabel", ".", "GetAgentLabel", "(", ")", ")", "\n", "p", ".", "Log", ".", "Infof", "(", "\"", "\"", ",", "prefix", ")", "\n\n", "p", ".", "watchDataReg", ",", "err", "=", "p", ".", "Watcher", ".", "Watch", "(", "\"", "\"", ",", "p", ".", "changeChannel", ",", "p", ".", "resyncChannel", ",", "prefix", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "p", ".", "Log", ".", "Info", "(", "\"", "\"", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "subscribeWatcher", "subscribes", "for", "data", "change", "and", "data", "resync", "events", ".", "Events", "are", "delivered", "to", "the", "consumer", "via", "the", "selected", "channels", ".", "ETCD", "watcher", "adapter", "is", "used", "to", "perform", "the", "registration", "behind", "the", "scenes", "." ]

[ "func", "(", "p", "*", "ExamplePlugin", ")", "etcdPublisher", "(", ")", "{", "// Wait for the consumer to initialize", "time", ".", "Sleep", "(", "1", "*", "time", ".", "Second", ")", "\n\n", "p", ".", "Log", ".", "Print", "(", "\"", "\"", ")", "\n\n", "// Convert data into the proto format.", "exampleData", ":=", "p", ".", "buildData", "(", "\"", "\"", ",", "0", ",", "true", ")", "\n\n", "// PUT: demonstrate how to use the Data Broker Put() API to store", "// a simple data structure into ETCD.", "label", ":=", "etcdKeyPrefixLabel", "(", "p", ".", "ServiceLabel", ".", "GetAgentLabel", "(", ")", ",", "\"", "\"", ")", "\n", "p", ".", "Log", ".", "Infof", "(", "\"", "\"", ",", "label", ")", "\n", "if", "err", ":=", "p", ".", "Publisher", ".", "Put", "(", "label", ",", "exampleData", ")", ";", "err", "!=", "nil", "{", "p", ".", "Log", ".", "Fatal", "(", "err", ")", "\n", "}", "\n\n", "// Prepare different set of data.", "p", ".", "Log", ".", "Infof", "(", "\"", "\"", ",", "label", ")", "\n", "exampleData", "=", "p", ".", "buildData", "(", "\"", "\"", ",", "1", ",", "false", ")", "\n\n", "// UPDATE: demonstrate how use the Data Broker Put() API to change", "// an already stored data in ETCD.", "if", "err", ":=", "p", ".", "Publisher", ".", "Put", "(", "label", ",", "exampleData", ")", ";", "err", "!=", "nil", "{", "p", ".", "Log", ".", "Fatal", "(", "err", ")", "\n", "}", "\n\n", "// Prepare another different set of data.", "p", ".", "Log", ".", "Infof", "(", "\"", "\"", ",", "label", ")", "\n", "exampleData", "=", "p", ".", "buildData", "(", "\"", "\"", ",", "2", ",", "false", ")", "\n\n", "// UPDATE: only to demonstrate Unregister functionality", "if", "err", ":=", "p", ".", "Publisher", ".", "Put", "(", "label", ",", "exampleData", ")", ";", "err", "!=", "nil", "{", "p", ".", "Log", ".", "Fatal", "(", "err", ")", "\n", "}", "\n\n", "// Wait for the consumer (change should not be passed to listener)", "time", ".", "Sleep", "(", "2", "*", "time", ".", "Second", ")", "\n", "p", ".", "publisherDone", "=", "true", "\n", "}" ]

[ "etcdPublisher", "creates", "a", "simple", "data", "then", "demonstrates", "CREATE", "and", "UPDATE", "operations", "with", "ETCD", "." ]

[ "func", "(", "p", "*", "ExamplePlugin", ")", "buildData", "(", "stringVal", "string", ",", "uint32Val", "uint32", ",", "boolVal", "bool", ")", "*", "etcdexample", ".", "EtcdExample", "{", "return", "&", "etcdexample", ".", "EtcdExample", "{", "StringVal", ":", "stringVal", ",", "Uint32Val", ":", "uint32Val", ",", "BoolVal", ":", "boolVal", ",", "}", "\n", "}" ]

[ "Create", "simple", "ETCD", "data", "structure", "with", "provided", "data", "values", "." ]

[ "func", "(", "p", "*", "Plugin", ")", "Init", "(", ")", "error", "{", "if", "p", ".", "Cfg", "!=", "nil", "{", "if", "p", ".", "Config", "==", "nil", "{", "p", ".", "Config", "=", "NewConf", "(", ")", "\n", "}", "\n\n", "_", ",", "err", ":=", "p", ".", "Cfg", ".", "LoadValue", "(", "p", ".", "Config", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "p", ".", "Log", ".", "Debugf", "(", "\"", "\"", ",", "p", ".", "Config", ")", "\n\n", "// Handle default log level. Prefer value from environmental variable", "defaultLogLvl", ":=", "os", ".", "Getenv", "(", "\"", "\"", ")", "\n", "if", "defaultLogLvl", "==", "\"", "\"", "{", "defaultLogLvl", "=", "p", ".", "Config", ".", "DefaultLevel", "\n", "}", "\n", "if", "defaultLogLvl", "!=", "\"", "\"", "{", "if", "err", ":=", "p", ".", "LogRegistry", ".", "SetLevel", "(", "\"", "\"", ",", "defaultLogLvl", ")", ";", "err", "!=", "nil", "{", "p", ".", "Log", ".", "Warnf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "else", "{", "// All loggers created up to this point were created with initial log level set (defined", "// via INITIAL_LOGLVL env. variable with value 'info' by default), so at first, let's set default", "// log level for all of them.", "for", "loggerName", ":=", "range", "p", ".", "LogRegistry", ".", "ListLoggers", "(", ")", "{", "logger", ",", "exists", ":=", "p", ".", "LogRegistry", ".", "Lookup", "(", "loggerName", ")", "\n", "if", "!", "exists", "{", "continue", "\n", "}", "\n", "logger", ".", "SetLevel", "(", "logging", ".", "ParseLogLevel", "(", "defaultLogLvl", ")", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "// Handle config file log levels", "for", "_", ",", "logCfgEntry", ":=", "range", "p", ".", "Config", ".", "Loggers", "{", "// Put log/level entries from configuration file to the registry.", "if", "err", ":=", "p", ".", "LogRegistry", ".", "SetLevel", "(", "logCfgEntry", ".", "Name", ",", "logCfgEntry", ".", "Level", ")", ";", "err", "!=", "nil", "{", "// Intentionally just log warn & not propagate the error (it is minor thing to interrupt startup)", "p", ".", "Log", ".", "Warnf", "(", "\"", "\"", ",", "logCfgEntry", ".", "Level", ",", "logCfgEntry", ".", "Name", ",", "err", ")", "\n", "}", "\n", "}", "\n", "if", "len", "(", "p", ".", "Config", ".", "Hooks", ")", ">", "0", "{", "p", ".", "Log", ".", "Info", "(", "\"", "\"", ")", "\n", "for", "hookName", ",", "hookConfig", ":=", "range", "p", ".", "Config", ".", "Hooks", "{", "if", "err", ":=", "p", ".", "addHook", "(", "hookName", ",", "hookConfig", ")", ";", "err", "!=", "nil", "{", "p", ".", "Log", ".", "Warnf", "(", "\"", "\"", ",", "hookName", ",", "err", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Init", "does", "nothing" ]

[ "func", "(", "p", "*", "Plugin", ")", "listLoggers", "(", ")", "(", "loggers", "[", "]", "LoggerData", ")", "{", "for", "logger", ",", "lvl", ":=", "range", "p", ".", "LogRegistry", ".", "ListLoggers", "(", ")", "{", "loggers", "=", "append", "(", "loggers", ",", "LoggerData", "{", "Logger", ":", "logger", ",", "Level", ":", "lvl", ",", "}", ")", "\n", "}", "\n", "return", "loggers", "\n", "}" ]

[ "ListLoggers", "lists", "all", "registered", "loggers", "." ]

[ "func", "(", "p", "*", "Plugin", ")", "setLoggerLogLevel", "(", "name", "string", ",", "level", "string", ")", "error", "{", "p", ".", "Log", ".", "Debugf", "(", "\"", "\"", ",", "name", ",", "level", ")", "\n\n", "return", "p", ".", "LogRegistry", ".", "SetLevel", "(", "name", ",", "level", ")", "\n", "}" ]

[ "setLoggerLogLevel", "modifies", "the", "log", "level", "of", "the", "all", "loggers", "in", "a", "plugin" ]

[ "func", "(", "p", "*", "Plugin", ")", "logLevelHandler", "(", "formatter", "*", "render", ".", "Render", ")", "http", ".", "HandlerFunc", "{", "return", "func", "(", "w", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "{", "p", ".", "Log", ".", "Infof", "(", "\"", "\"", ",", "req", ".", "URL", ".", "Path", ")", "\n\n", "vars", ":=", "mux", ".", "Vars", "(", "req", ")", "\n", "if", "vars", "==", "nil", "{", "formatter", ".", "JSON", "(", "w", ",", "http", ".", "StatusNotFound", ",", "struct", "{", "}", "{", "}", ")", "\n", "return", "\n", "}", "\n", "err", ":=", "p", ".", "setLoggerLogLevel", "(", "vars", "[", "loggerVarName", "]", ",", "vars", "[", "levelVarName", "]", ")", "\n", "if", "err", "!=", "nil", "{", "formatter", ".", "JSON", "(", "w", ",", "http", ".", "StatusNotFound", ",", "struct", "{", "Error", "string", "}", "{", "err", ".", "Error", "(", ")", "}", ")", "\n", "return", "\n", "}", "\n\n", "formatter", ".", "JSON", "(", "w", ",", "http", ".", "StatusOK", ",", "LoggerData", "{", "Logger", ":", "vars", "[", "loggerVarName", "]", ",", "Level", ":", "vars", "[", "levelVarName", "]", ",", "}", ")", "\n", "}", "\n", "}" ]

[ "logLevelHandler", "processes", "requests", "to", "set", "log", "level", "on", "loggers", "in", "a", "plugin" ]

[ "func", "(", "p", "*", "Plugin", ")", "listLoggersHandler", "(", "formatter", "*", "render", ".", "Render", ")", "http", ".", "HandlerFunc", "{", "return", "func", "(", "w", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "{", "formatter", ".", "JSON", "(", "w", ",", "http", ".", "StatusOK", ",", "p", ".", "listLoggers", "(", ")", ")", "\n", "}", "\n", "}" ]

[ "listLoggersHandler", "processes", "requests", "to", "list", "all", "registered", "loggers" ]

[ "func", "(", "mem", "*", "memNamedMapping", ")", "Clear", "(", ")", "{", "names", ":=", "mem", ".", "ListAllNames", "(", ")", "\n", "for", "_", ",", "item", ":=", "range", "names", "{", "mem", ".", "removeNameIdxSync", "(", "item", ")", "\n", "}", "\n", "}" ]

[ "Clear", "removes", "all", "entries", "from", "name", "-", "to", "-", "index", "mapping" ]

[ "func", "(", "mem", "*", "memNamedMapping", ")", "ListAllNames", "(", ")", "(", "names", "[", "]", "string", ")", "{", "mem", ".", "access", ".", "RLock", "(", ")", "\n", "defer", "mem", ".", "access", ".", "RUnlock", "(", ")", "\n\n", "var", "ret", "[", "]", "string", "\n\n", "for", "name", ":=", "range", "mem", ".", "nameToIdx", "{", "ret", "=", "append", "(", "ret", ",", "name", ")", "\n", "}", "\n\n", "return", "ret", "\n", "}" ]

[ "ListAllNames", "returns", "all", "names", "in", "the", "mapping", "." ]

[ "func", "(", "mem", "*", "memNamedMapping", ")", "ListNames", "(", "field", "string", ",", "value", "string", ")", "[", "]", "string", "{", "mem", ".", "access", ".", "RLock", "(", ")", "\n", "defer", "mem", ".", "access", ".", "RUnlock", "(", ")", "\n\n", "ix", ",", "found", ":=", "mem", ".", "indexes", "[", "field", "]", "\n", "if", "!", "found", "{", "return", "nil", "\n", "}", "\n", "set", ",", "found", ":=", "ix", "[", "value", "]", "\n\n", "if", "!", "found", "{", "return", "nil", "\n", "}", "\n\n", "return", "set", ".", "content", "(", ")", "\n", "}" ]

[ "ListNames", "looks", "up", "the", "items", "by", "secondary", "indexes", ".", "It", "returns", "all", "names", "matching", "the", "selection", "." ]

[ "func", "ListExportedFields", "(", "val", "interface", "{", "}", ",", "predicates", "...", "ExportedPredicate", ")", "[", "]", "*", "reflect", ".", "StructField", "{", "valType", ":=", "reflect", ".", "Indirect", "(", "reflect", ".", "ValueOf", "(", "val", ")", ")", ".", "Type", "(", ")", "\n", "len", ":=", "valType", ".", "NumField", "(", ")", "\n", "ret", ":=", "[", "]", "*", "reflect", ".", "StructField", "{", "}", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", ";", "i", "++", "{", "structField", ":=", "valType", ".", "Field", "(", "i", ")", "\n\n", "if", "FieldExported", "(", "&", "structField", ",", "predicates", "...", ")", "{", "ret", "=", "append", "(", "ret", ",", "&", "structField", ")", "\n", "}", "\n", "}", "\n\n", "return", "ret", "\n", "}" ]

[ "ListExportedFields", "returns", "all", "fields", "of", "a", "structure", "that", "starts", "wit", "uppercase", "letter" ]

[ "func", "FieldExported", "(", "field", "*", "reflect", ".", "StructField", ",", "predicates", "...", "ExportedPredicate", ")", "(", "exported", "bool", ")", "{", "if", "field", ".", "Name", "[", "0", "]", "==", "strings", ".", "ToUpper", "(", "string", "(", "field", ".", "Name", "[", "0", "]", ")", ")", "[", "0", "]", "{", "expPredic", ":=", "true", "\n", "for", "_", ",", "predicate", ":=", "range", "predicates", "{", "if", "!", "predicate", "(", "field", ")", "{", "expPredic", "=", "false", "\n", "break", "\n", "}", "\n", "}", "\n\n", "return", "expPredic", "\n", "}", "\n\n", "return", "false", "\n", "}" ]

[ "FieldExported", "returns", "true", "if", "field", "name", "starts", "with", "uppercase" ]

[ "func", "ListExportedFieldsPtrs", "(", "val", "interface", "{", "}", ",", "predicates", "...", "ExportedPredicate", ")", "(", "fields", "[", "]", "*", "reflect", ".", "StructField", ",", "valPtrs", "[", "]", "interface", "{", "}", ")", "{", "rVal", ":=", "reflect", ".", "Indirect", "(", "reflect", ".", "ValueOf", "(", "val", ")", ")", "\n", "valPtrs", "=", "[", "]", "interface", "{", "}", "{", "}", "\n", "fields", "=", "[", "]", "*", "reflect", ".", "StructField", "{", "}", "\n\n", "for", "i", ":=", "0", ";", "i", "<", "rVal", ".", "NumField", "(", ")", ";", "i", "++", "{", "field", ":=", "rVal", ".", "Field", "(", "i", ")", "\n", "structField", ":=", "rVal", ".", "Type", "(", ")", ".", "Field", "(", "i", ")", "\n", "if", "!", "FieldExported", "(", "&", "structField", ",", "predicates", "...", ")", "{", "continue", "\n", "}", "\n\n", "switch", "field", ".", "Kind", "(", ")", "{", "case", "reflect", ".", "Ptr", ",", "reflect", ".", "Interface", ":", "if", "field", ".", "IsNil", "(", ")", "{", "p", ":=", "reflect", ".", "New", "(", "field", ".", "Type", "(", ")", ".", "Elem", "(", ")", ")", "\n", "field", ".", "Set", "(", "p", ")", "\n", "valPtrs", "=", "append", "(", "valPtrs", ",", "p", ".", "Interface", "(", ")", ")", "\n", "}", "else", "{", "valPtrs", "=", "append", "(", "valPtrs", ",", "field", ".", "Interface", "(", ")", ")", "\n", "}", "\n", "case", "reflect", ".", "Slice", ",", "reflect", ".", "Chan", ",", "reflect", ".", "Map", ":", "if", "field", ".", "IsNil", "(", ")", "{", "p", ":=", "reflect", ".", "New", "(", "field", ".", "Type", "(", ")", ")", "\n", "field", ".", "Set", "(", "p", ".", "Elem", "(", ")", ")", "\n", "valPtrs", "=", "append", "(", "valPtrs", ",", "field", ".", "Addr", "(", ")", ".", "Interface", "(", ")", ")", "\n", "}", "else", "{", "valPtrs", "=", "append", "(", "valPtrs", ",", "field", ".", "Interface", "(", ")", ")", "\n", "}", "\n", "default", ":", "if", "field", ".", "CanAddr", "(", ")", "{", "valPtrs", "=", "append", "(", "valPtrs", ",", "field", ".", "Addr", "(", ")", ".", "Interface", "(", ")", ")", "\n", "}", "else", "if", "field", ".", "IsValid", "(", ")", "{", "valPtrs", "=", "append", "(", "valPtrs", ",", "field", ".", "Interface", "(", ")", ")", "\n", "}", "else", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "fields", "=", "append", "(", "fields", ",", "&", "structField", ")", "\n", "}", "\n\n", "return", "fields", ",", "valPtrs", "\n", "}" ]

[ "ListExportedFieldsPtrs", "iterates", "struct", "fields", "and", "return", "slice", "of", "pointers", "to", "field", "values" ]

[ "func", "(", "logger", "*", "Logger", ")", "InitTag", "(", "tag", "...", "string", ")", "{", "var", "t", "string", "\n", "var", "index", "uint64", "// first index", "\n", "if", "len", "(", "tag", ")", ">", "0", "{", "t", "=", "tag", "[", "0", "]", "\n", "}", "else", "{", "id", ",", "err", ":=", "uuid", ".", "NewV4", "(", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "fmt", ".", "Errorf", "(", "\"", "\"", "+", "err", ".", "Error", "(", ")", ")", ")", "\n", "}", "\n", "t", "=", "id", ".", "String", "(", ")", "[", "0", ":", "8", "]", "\n", "}", "\n", "logger", ".", "tagMap", ".", "Store", "(", "index", ",", "t", ")", "\n", "}" ]

[ "InitTag", "sets", "the", "tag", "for", "the", "main", "thread", "." ]

[ "func", "(", "logger", "*", "Logger", ")", "GetTag", "(", ")", "string", "{", "goID", ":=", "logger", ".", "curGoroutineID", "(", ")", "\n", "if", "tagVal", ",", "found", ":=", "logger", ".", "tagMap", ".", "Load", "(", "goID", ")", ";", "!", "found", "{", "return", "\"", "\"", "\n", "}", "else", "if", "tag", ",", "ok", ":=", "tagVal", ".", "(", "string", ")", ";", "ok", "{", "return", "tag", "\n", "}", "\n", "panic", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ")", ")", "\n", "}" ]

[ "GetTag", "returns", "the", "tag", "identifying", "the", "caller", "s", "go", "routine", "." ]

[ "func", "(", "logger", "*", "Logger", ")", "SetTag", "(", "tag", "...", "string", ")", "{", "goID", ":=", "logger", ".", "curGoroutineID", "(", ")", "\n", "var", "t", "string", "\n", "if", "len", "(", "tag", ")", ">", "0", "{", "t", "=", "tag", "[", "0", "]", "\n", "}", "else", "{", "id", ",", "err", ":=", "uuid", ".", "NewV4", "(", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "fmt", ".", "Errorf", "(", "\"", "\"", "+", "err", ".", "Error", "(", ")", ")", ")", "\n", "}", "\n", "t", "=", "id", ".", "String", "(", ")", "[", "0", ":", "8", "]", "\n", "}", "\n", "logger", ".", "tagMap", ".", "Store", "(", "goID", ",", "t", ")", "\n", "}" ]

[ "SetTag", "allows", "to", "define", "a", "string", "tag", "for", "the", "current", "go", "routine", ".", "Otherwise", "numeric", "identification", "is", "used", "." ]

[ "func", "(", "logger", "*", "Logger", ")", "ClearTag", "(", ")", "{", "goID", ":=", "logger", ".", "curGoroutineID", "(", ")", "\n", "logger", ".", "tagMap", ".", "Delete", "(", "goID", ")", "\n", "}" ]

[ "ClearTag", "removes", "the", "previously", "set", "string", "tag", "for", "the", "current", "go", "routine", "." ]

[ "func", "(", "logger", "*", "Logger", ")", "SetStaticFields", "(", "fields", "map", "[", "string", "]", "interface", "{", "}", ")", "{", "for", "key", ",", "val", ":=", "range", "fields", "{", "logger", ".", "staticFields", ".", "Store", "(", "key", ",", "val", ")", "\n", "}", "\n", "}" ]

[ "SetStaticFields", "sets", "a", "map", "of", "fields", "that", "will", "be", "part", "of", "the", "each", "subsequent", "log", "entry", "of", "the", "logger" ]

[ "func", "(", "logger", "*", "Logger", ")", "GetStaticFields", "(", ")", "map", "[", "string", "]", "interface", "{", "}", "{", "var", "wasErr", "error", "\n", "staticFieldsMap", ":=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n\n", "logger", ".", "staticFields", ".", "Range", "(", "func", "(", "k", ",", "v", "interface", "{", "}", ")", "bool", "{", "key", ",", "ok", ":=", "k", ".", "(", "string", ")", "\n", "if", "!", "ok", "{", "wasErr", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "// false stops the iteration", "return", "false", "\n", "}", "\n", "staticFieldsMap", "[", "key", "]", "=", "v", "\n", "return", "true", "\n", "}", ")", "\n\n", "// throw panic outside of logger.Range()", "if", "wasErr", "!=", "nil", "{", "panic", "(", "wasErr", ")", "\n", "}", "\n\n", "return", "staticFieldsMap", "\n", "}" ]

[ "GetStaticFields", "returns", "currently", "set", "map", "of", "static", "fields", "-", "key", "-", "value", "pairs", "that", "are", "automatically", "added", "into", "log", "entry" ]

[ "func", "(", "logger", "*", "Logger", ")", "SetOutput", "(", "out", "io", ".", "Writer", ")", "{", "unsafeStd", ":=", "(", "*", "unsafe", ".", "Pointer", ")", "(", "unsafe", ".", "Pointer", "(", "&", "logger", ".", "std", ")", ")", "\n", "old", ":=", "logger", ".", "std", "\n", "logger", ".", "std", ".", "Out", "=", "out", "\n", "atomic", ".", "CompareAndSwapPointer", "(", "unsafeStd", ",", "unsafe", ".", "Pointer", "(", "old", ")", ",", "unsafe", ".", "Pointer", "(", "logger", ".", "std", ")", ")", "\n\n", "}" ]

[ "SetOutput", "sets", "the", "standard", "logger", "output", "." ]

[ "func", "(", "logger", "*", "Logger", ")", "SetFormatter", "(", "formatter", "lg", ".", "Formatter", ")", "{", "unsafeStd", ":=", "(", "*", "unsafe", ".", "Pointer", ")", "(", "unsafe", ".", "Pointer", "(", "&", "logger", ".", "std", ")", ")", "\n", "old", ":=", "logger", ".", "std", "\n", "logger", ".", "std", ".", "Formatter", "=", "formatter", "\n", "atomic", ".", "CompareAndSwapPointer", "(", "unsafeStd", ",", "unsafe", ".", "Pointer", "(", "old", ")", ",", "unsafe", ".", "Pointer", "(", "logger", ".", "std", ")", ")", "\n", "}" ]

[ "SetFormatter", "sets", "the", "standard", "logger", "formatter", "." ]

[ "func", "(", "logger", "*", "Logger", ")", "SetLevel", "(", "level", "logging", ".", "LogLevel", ")", "{", "switch", "level", "{", "case", "logging", ".", "PanicLevel", ":", "logger", ".", "std", ".", "Level", "=", "lg", ".", "PanicLevel", "\n", "case", "logging", ".", "FatalLevel", ":", "logger", ".", "std", ".", "Level", "=", "lg", ".", "FatalLevel", "\n", "case", "logging", ".", "ErrorLevel", ":", "logger", ".", "std", ".", "Level", "=", "lg", ".", "ErrorLevel", "\n", "case", "logging", ".", "WarnLevel", ":", "logger", ".", "std", ".", "Level", "=", "lg", ".", "WarnLevel", "\n", "case", "logging", ".", "InfoLevel", ":", "logger", ".", "std", ".", "Level", "=", "lg", ".", "InfoLevel", "\n", "case", "logging", ".", "DebugLevel", ":", "logger", ".", "std", ".", "Level", "=", "lg", ".", "DebugLevel", "\n", "}", "\n", "}" ]

[ "SetLevel", "sets", "the", "standard", "logger", "level", "." ]

[ "func", "(", "logger", "*", "Logger", ")", "GetLevel", "(", ")", "logging", ".", "LogLevel", "{", "unsafeStd", ":=", "(", "*", "unsafe", ".", "Pointer", ")", "(", "unsafe", ".", "Pointer", "(", "&", "logger", ".", "std", ")", ")", "\n", "stdVal", ":=", "(", "*", "lg", ".", "Logger", ")", "(", "atomic", ".", "LoadPointer", "(", "unsafeStd", ")", ")", "\n", "l", ":=", "stdVal", ".", "Level", "\n", "switch", "l", "{", "case", "lg", ".", "PanicLevel", ":", "return", "logging", ".", "PanicLevel", "\n", "case", "lg", ".", "FatalLevel", ":", "return", "logging", ".", "FatalLevel", "\n", "case", "lg", ".", "ErrorLevel", ":", "return", "logging", ".", "ErrorLevel", "\n", "case", "lg", ".", "WarnLevel", ":", "return", "logging", ".", "WarnLevel", "\n", "case", "lg", ".", "InfoLevel", ":", "return", "logging", ".", "InfoLevel", "\n", "case", "lg", ".", "DebugLevel", ":", "return", "logging", ".", "DebugLevel", "\n", "default", ":", "return", "logging", ".", "DebugLevel", "\n", "}", "\n", "}" ]

[ "GetLevel", "returns", "the", "standard", "logger", "level", "." ]

[ "func", "(", "logger", "*", "Logger", ")", "AddHook", "(", "hook", "lg", ".", "Hook", ")", "{", "mux", ":=", "&", "sync", ".", "Mutex", "{", "}", "\n\n", "unsafeStd", ":=", "(", "*", "unsafe", ".", "Pointer", ")", "(", "unsafe", ".", "Pointer", "(", "&", "logger", ".", "std", ")", ")", "\n", "stdVal", ":=", "(", "*", "lg", ".", "Logger", ")", "(", "atomic", ".", "LoadPointer", "(", "unsafeStd", ")", ")", "\n", "old", ":=", "logger", ".", "std", "\n", "mux", ".", "Lock", "(", ")", "\n", "stdVal", ".", "Hooks", ".", "Add", "(", "hook", ")", "\n", "mux", ".", "Unlock", "(", ")", "\n", "atomic", ".", "CompareAndSwapPointer", "(", "unsafeStd", ",", "unsafe", ".", "Pointer", "(", "old", ")", ",", "unsafe", ".", "Pointer", "(", "logger", ".", "std", ")", ")", "\n", "}" ]

[ "AddHook", "adds", "a", "hook", "to", "the", "standard", "logger", "hooks", "." ]

[ "func", "(", "logger", "*", "Logger", ")", "WithField", "(", "key", "string", ",", "value", "interface", "{", "}", ")", "logging", ".", "LogWithLevel", "{", "return", "logger", ".", "withFields", "(", "logging", ".", "Fields", "{", "key", ":", "value", "}", ",", "1", ")", "\n", "}" ]

[ "WithField", "creates", "an", "entry", "from", "the", "standard", "logger", "and", "adds", "a", "field", "to", "it", ".", "If", "you", "want", "multiple", "fields", "use", "WithFields", ".", "Note", "that", "it", "doesn", "t", "log", "until", "you", "call", "Debug", "Print", "Info", "Warn", "Fatal", "or", "Panic", "on", "the", "LogMsg", "it", "returns", "." ]

[ "func", "(", "logger", "*", "Logger", ")", "WithFields", "(", "fields", "logging", ".", "Fields", ")", "logging", ".", "LogWithLevel", "{", "return", "logger", ".", "withFields", "(", "fields", ",", "1", ")", "\n", "}" ]

[ "WithFields", "creates", "an", "entry", "from", "the", "standard", "logger", "and", "adds", "multiple", "fields", "to", "it", ".", "This", "is", "simply", "a", "helper", "for", "WithField", "invoking", "it", "once", "for", "each", "field", ".", "Note", "that", "it", "doesn", "t", "log", "until", "you", "call", "Debug", "Print", "Info", "Warn", "Fatal", "or", "Panic", "on", "the", "LogMsg", "it", "returns", "." ]

[ "func", "(", "logger", "*", "Logger", ")", "Infoln", "(", "args", "...", "interface", "{", "}", ")", "{", "if", "logger", ".", "std", ".", "Level", ">=", "lg", ".", "InfoLevel", "{", "logger", ".", "header", "(", "1", ")", ".", "Infoln", "(", "args", "...", ")", "\n", "}", "\n", "}" ]

[ "Infoln", "logs", "a", "message", "at", "level", "Info", "on", "the", "standard", "logger", "." ]

[ "func", "NewTemplateReader", "(", "path", "string", ",", "log", "logging", ".", "Logger", ")", "(", "*", "Reader", ",", "error", ")", "{", "reader", ":=", "&", "Reader", "{", "log", ":", "log", ",", "path", ":", "path", ",", "}", "\n\n", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "path", ")", ";", "os", ".", "IsNotExist", "(", "err", ")", "{", "if", "err", ":=", "os", ".", "MkdirAll", "(", "path", ",", "DefaultMode", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "return", "reader", ",", "nil", "\n", "}" ]

[ "NewTemplateReader", "returns", "a", "new", "instance", "of", "template", "reader", "with", "given", "path", ".", "The", "path", "is", "also", "verified", "and", "crated", "if", "not", "existed" ]

[ "func", "(", "r", "*", "Reader", ")", "GetAllTemplates", "(", ")", "(", "[", "]", "*", "process", ".", "Template", ",", "error", ")", "{", "var", "templates", "[", "]", "*", "process", ".", "Template", "\n", "entries", ",", "err", ":=", "ioutil", ".", "ReadDir", "(", "r", ".", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "templates", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "r", ".", "path", ",", "err", ")", "\n", "}", "\n", "// From this point, log all errors bot continue reading", "for", "_", ",", "entry", ":=", "range", "entries", "{", "if", "entry", ".", "IsDir", "(", ")", "{", "continue", "\n", "}", "\n", "if", "filepath", ".", "Ext", "(", "entry", ".", "Name", "(", ")", ")", "!=", "JSONExt", "{", "continue", "\n", "}", "\n", "filePath", ":=", "filepath", ".", "Join", "(", "r", ".", "path", ",", "entry", ".", "Name", "(", ")", ")", "\n", "file", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "filePath", ")", "\n", "if", "err", "!=", "nil", "{", "r", ".", "log", ".", "Errorf", "(", "\"", "\"", ",", "filePath", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "template", ":=", "&", "process", ".", "Template", "{", "}", "\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "file", ",", "template", ")", ";", "err", "!=", "nil", "{", "r", ".", "log", ".", "Errorf", "(", "\"", "\"", ",", "filePath", ",", "err", ")", "\n", "continue", "\n", "}", "\n\n", "templates", "=", "append", "(", "templates", ",", "template", ")", "\n", "}", "\n\n", "r", ".", "log", ".", "Debugf", "(", "\"", "\"", ",", "len", "(", "templates", ")", ")", "\n\n", "return", "templates", ",", "nil", "\n", "}" ]

[ "GetAllTemplates", "reads", "all", "templates", "from", "reader", "s", "path", ".", "Error", "is", "returned", "if", "path", "is", "not", "a", "directory", ".", "All", "JSON", "file", "are", "read", "and", "un", "-", "marshaled", "as", "template", "objects" ]

[ "func", "(", "jd", "*", "JSONDecoder", ")", "Encode", "(", "data", "[", "]", "*", "FileDataEntry", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "// Convert to json-specific structure", "var", "jsonFileEntries", "[", "]", "jsonFileEntry", "\n", "for", "_", ",", "dataEntry", ":=", "range", "data", "{", "jsonFileEntries", "=", "append", "(", "jsonFileEntries", ",", "jsonFileEntry", "{", "Key", ":", "dataEntry", ".", "Key", ",", "Value", ":", "dataEntry", ".", "Value", ",", "}", ")", "\n", "}", "\n", "// Encode to type specific structure", "jsonFile", ":=", "&", "jsonFile", "{", "Data", ":", "jsonFileEntries", "}", "\n", "return", "json", ".", "Marshal", "(", "jsonFile", ")", "\n", "}" ]

[ "Encode", "provided", "file", "entries", "into", "JSON", "byte", "set" ]

[ "func", "(", "jd", "*", "JSONDecoder", ")", "Decode", "(", "byteSet", "[", "]", "byte", ")", "(", "[", "]", "*", "FileDataEntry", ",", "error", ")", "{", "if", "len", "(", "byteSet", ")", "==", "0", "{", "return", "[", "]", "*", "FileDataEntry", "{", "}", ",", "nil", "\n", "}", "\n", "// Decode to type-specific structure", "jsonFile", ":=", "jsonFile", "{", "}", "\n", "err", ":=", "json", ".", "Unmarshal", "(", "byteSet", ",", "&", "jsonFile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "// Convert to common file data entry list structure", "var", "dataEntries", "[", "]", "*", "FileDataEntry", "\n", "for", "_", ",", "dataEntry", ":=", "range", "jsonFile", ".", "Data", "{", "dataEntries", "=", "append", "(", "dataEntries", ",", "&", "FileDataEntry", "{", "Key", ":", "dataEntry", ".", "Key", ",", "Value", ":", "dataEntry", ".", "Value", "}", ")", "\n", "}", "\n", "return", "dataEntries", ",", "nil", "\n", "}" ]

[ "Decode", "provided", "byte", "set", "of", "json", "file", "and", "returns", "set", "of", "file", "data", "entries" ]

[ "func", "ConfigFromFile", "(", "fpath", "string", ")", "(", "*", "Config", ",", "error", ")", "{", "cfg", ":=", "&", "Config", "{", "}", "\n", "err", ":=", "config", ".", "ParseConfigFromYamlFile", "(", "fpath", ",", "cfg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "cfg", ",", "err", "\n", "}" ]

[ "ConfigFromFile", "loads", "the", "Kafka", "multiplexer", "configuration", "from", "the", "specified", "file", ".", "If", "the", "specified", "file", "is", "valid", "and", "contains", "valid", "configuration", "the", "parsed", "configuration", "is", "returned", ";", "otherwise", "an", "error", "is", "returned", "." ]

[ "func", "InitMultiplexer", "(", "configFile", "string", ",", "name", "string", ",", "log", "logging", ".", "Logger", ")", "(", "*", "Multiplexer", ",", "error", ")", "{", "var", "err", "error", "\n", "var", "tls", "clienttls", ".", "TLS", "\n", "cfg", ":=", "&", "Config", "{", "[", "]", "string", "{", "DefAddress", "}", ",", "\"", "\"", ",", "tls", "}", "\n", "if", "configFile", "!=", "\"", "\"", "{", "cfg", ",", "err", "=", "ConfigFromFile", "(", "configFile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "// prepare client config", "clientCfg", ":=", "client", ".", "NewConfig", "(", "log", ")", "\n", "clientCfg", ".", "SetSendSuccess", "(", "true", ")", "\n", "clientCfg", ".", "SetSuccessChan", "(", "make", "(", "chan", "*", "client", ".", "ProducerMessage", ")", ")", "\n", "clientCfg", ".", "SetSendError", "(", "true", ")", "\n", "clientCfg", ".", "SetErrorChan", "(", "make", "(", "chan", "*", "client", ".", "ProducerError", ")", ")", "\n", "clientCfg", ".", "SetBrokers", "(", "cfg", ".", "Addrs", "...", ")", "\n", "if", "cfg", ".", "TLS", ".", "Enabled", "{", "tlsConfig", ",", "err", ":=", "clienttls", ".", "CreateTLSConfig", "(", "cfg", ".", "TLS", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "clientCfg", ".", "SetTLS", "(", "tlsConfig", ")", "\n", "}", "\n\n", "// create hash client", "sClientHash", ",", "err", ":=", "client", ".", "NewClient", "(", "clientCfg", ",", "client", ".", "Hash", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// create manual client", "sClientManual", ",", "err", ":=", "client", ".", "NewClient", "(", "clientCfg", ",", "client", ".", "Manual", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// todo client is currently set always as hash", "return", "InitMultiplexerWithConfig", "(", "clientCfg", ",", "sClientHash", ",", "sClientManual", ",", "name", ",", "log", ")", "\n", "}" ]

[ "InitMultiplexer", "initialize", "and", "returns", "new", "kafka", "multiplexer", "based", "on", "the", "supplied", "config", "file", ".", "Name", "is", "used", "as", "groupId", "identification", "of", "consumer", ".", "Kafka", "allows", "to", "store", "last", "read", "offset", "for", "a", "groupId", ".", "This", "is", "leveraged", "to", "deliver", "unread", "messages", "after", "restart", "." ]

[ "func", "InitMultiplexerWithConfig", "(", "clientCfg", "*", "client", ".", "Config", ",", "hsClient", "sarama", ".", "Client", ",", "manClient", "sarama", ".", "Client", ",", "name", "string", ",", "log", "logging", ".", "Logger", ")", "(", "*", "Multiplexer", ",", "error", ")", "{", "const", "errorFmt", "=", "\"", "\"", "\n\n", "log", ".", "WithField", "(", "\"", "\"", ",", "hsClient", ".", "Brokers", "(", ")", ")", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "startTime", ":=", "time", ".", "Now", "(", ")", "\n", "producers", ":=", "multiplexerProducers", "{", "}", "\n\n", "// Prepare sync/async producer", "if", "hsClient", "!=", "nil", "{", "hashSyncProducer", ",", "err", ":=", "client", ".", "NewSyncProducer", "(", "clientCfg", ",", "hsClient", ",", "client", ".", "Hash", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "errorFmt", ",", "\"", "\"", ",", "clientCfg", ".", "Brokers", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "hashAsyncProducer", ",", "err", ":=", "client", ".", "NewAsyncProducer", "(", "clientCfg", ",", "hsClient", ",", "client", ".", "Hash", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "errorFmt", ",", "\"", "\"", ",", "clientCfg", ".", "Brokers", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "producers", ".", "hashSyncProducer", "=", "hashSyncProducer", "\n", "producers", ".", "hashAsyncProducer", "=", "hashAsyncProducer", "\n", "}", "\n", "// Prepare manual sync/async producer", "if", "manClient", "!=", "nil", "{", "manualSyncProducer", ",", "err", ":=", "client", ".", "NewSyncProducer", "(", "clientCfg", ",", "manClient", ",", "client", ".", "Manual", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "errorFmt", ",", "\"", "\"", ",", "clientCfg", ".", "Brokers", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "manualAsyncProducer", ",", "err", ":=", "client", ".", "NewAsyncProducer", "(", "clientCfg", ",", "manClient", ",", "client", ".", "Manual", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "errorFmt", ",", "\"", "\"", ",", "clientCfg", ".", "Brokers", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "producers", ".", "manSyncProducer", "=", "manualSyncProducer", "\n", "producers", ".", "manAsyncProducer", "=", "manualAsyncProducer", "\n", "}", "\n\n", "kafkaConnect", ":=", "time", ".", "Since", "(", "startTime", ")", "\n", "log", ".", "WithField", "(", "\"", "\"", ",", "kafkaConnect", ".", "Nanoseconds", "(", ")", ")", ".", "Info", "(", "\"", "\"", ",", "kafkaConnect", ")", "\n\n", "return", "NewMultiplexer", "(", "getConsumerFactory", "(", "clientCfg", ")", ",", "producers", ",", "clientCfg", ",", "name", ",", "log", ")", ",", "nil", "\n", "}" ]

[ "InitMultiplexerWithConfig", "initialize", "and", "returns", "new", "kafka", "multiplexer", "based", "on", "the", "supplied", "mux", "configuration", ".", "Name", "is", "used", "as", "groupId", "identification", "of", "consumer", ".", "Kafka", "allows", "to", "store", "last", "read", "offset", "for", "a", "groupId", ".", "This", "is", "leveraged", "to", "deliver", "unread", "messages", "after", "restart", "." ]

[ "func", "listKeys", "(", "db", "keyval", ".", "ProtoBroker", ")", "{", "resp", ",", "err", ":=", "db", ".", "ListKeys", "(", "phonebook", ".", "EtcdPath", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Fatal", "(", "err", ")", "\n", "}", "\n\n", "fmt", ".", "Println", "(", "\"", "\"", ")", "\n", "for", "{", "key", ",", "_", ",", "stop", ":=", "resp", ".", "GetNext", "(", ")", "\n", "if", "stop", "{", "break", "\n", "}", "\n\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "key", ")", "\n\n", "}", "\n", "}" ]

[ "listKeys", "lists", "keys" ]

[ "func", "list", "(", "db", "keyval", ".", "ProtoBroker", ")", "{", "resp", ",", "err", ":=", "db", ".", "ListValues", "(", "phonebook", ".", "EtcdPath", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Fatal", "(", "err", ")", "\n", "}", "\n\n", "var", "revision", "int64", "\n", "fmt", ".", "Println", "(", "\"", "\"", ")", "\n", "for", "{", "c", ":=", "&", "phonebook", ".", "Contact", "{", "}", "\n", "kv", ",", "stop", ":=", "resp", ".", "GetNext", "(", ")", "\n", "if", "stop", "{", "break", "\n", "}", "\n", "if", "kv", ".", "GetRevision", "(", ")", ">", "revision", "{", "revision", "=", "kv", ".", "GetRevision", "(", ")", "\n", "}", "\n", "err", "=", "kv", ".", "GetValue", "(", "c", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Fatal", "(", "err", ")", "\n", "}", "\n\n", "fmt", ".", "Printf", "(", "\"", "\\t", "\\n", "\\t", "\\t", "\\n", "\\t", "\\t", "\\n", "\"", ",", "c", ".", "Name", ",", "c", ".", "Company", ",", "c", ".", "Phonenumber", ")", "\n\n", "}", "\n", "fmt", ".", "Println", "(", "\"", "\"", ",", "revision", ")", "\n", "}" ]

[ "list", "lists", "keys", "with", "values" ]

[ "func", "put", "(", "db", "keyval", ".", "ProtoBroker", ",", "data", "[", "]", "string", ")", "{", "c", ":=", "&", "phonebook", ".", "Contact", "{", "Name", ":", "data", "[", "0", "]", ",", "Company", ":", "data", "[", "1", "]", ",", "Phonenumber", ":", "data", "[", "2", "]", "}", "\n\n", "key", ":=", "phonebook", ".", "EtcdContactPath", "(", "c", ")", "\n\n", "err", ":=", "db", ".", "Put", "(", "key", ",", "c", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Fatal", "(", "err", ")", "\n", "}", "\n\n", "fmt", ".", "Println", "(", "\"", "\"", ",", "key", ")", "\n", "}" ]

[ "put", "saves", "single", "entry" ]

[ "func", "get", "(", "db", "keyval", ".", "ProtoBroker", ",", "data", "string", ")", "{", "c", ":=", "&", "phonebook", ".", "Contact", "{", "Name", ":", "data", "}", "\n\n", "key", ":=", "phonebook", ".", "EtcdContactPath", "(", "c", ")", "\n\n", "found", ",", "_", ",", "err", ":=", "db", ".", "GetValue", "(", "key", ",", "c", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Fatal", "(", "err", ")", "\n", "}", "else", "if", "!", "found", "{", "fmt", ".", "Println", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n\n", "fmt", ".", "Println", "(", "\"", "\"", ",", "key", ",", "c", ")", "\n", "}" ]

[ "get", "retrieves", "single", "entry" ]

[ "func", "del", "(", "db", "keyval", ".", "ProtoBroker", ",", "data", "string", ")", "{", "c", ":=", "&", "phonebook", ".", "Contact", "{", "Name", ":", "data", "}", "\n\n", "key", ":=", "phonebook", ".", "EtcdContactPath", "(", "c", ")", "\n\n", "existed", ",", "err", ":=", "db", ".", "Delete", "(", "key", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Fatal", "(", "err", ")", "\n", "}", "else", "if", "!", "existed", "{", "fmt", ".", "Println", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n\n", "fmt", ".", "Println", "(", "\"", "\"", ",", "key", ")", "\n", "}" ]

[ "del", "deletes", "single", "entry" ]

[ "func", "(", "ref", "*", "SyncProducer", ")", "SendMsgByte", "(", "topic", "string", ",", "key", "[", "]", "byte", ",", "msg", "[", "]", "byte", ")", "(", "*", "ProducerMessage", ",", "error", ")", "{", "// generate a key if none supplied (used by hash partitioner)", "ref", ".", "WithFields", "(", "logging", ".", "Fields", "{", "\"", "\"", ":", "key", ",", "\"", "\"", ":", "msg", "}", ")", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "if", "key", "==", "nil", "||", "len", "(", "key", ")", "==", "0", "{", "md5Sum", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "md5", ".", "Sum", "(", "msg", ")", ")", "\n", "return", "ref", ".", "SendMsgToPartition", "(", "topic", ",", "ref", ".", "Partition", ",", "sarama", ".", "ByteEncoder", "(", "md5Sum", ")", ",", "sarama", ".", "ByteEncoder", "(", "msg", ")", ")", "\n", "}", "\n", "return", "ref", ".", "SendMsgToPartition", "(", "topic", ",", "ref", ".", "Partition", ",", "sarama", ".", "ByteEncoder", "(", "key", ")", ",", "sarama", ".", "ByteEncoder", "(", "msg", ")", ")", "\n", "}" ]

[ "SendMsgByte", "sends", "a", "message", "to", "Kafka" ]

[ "func", "(", "ref", "*", "SyncProducer", ")", "SendMsgToPartition", "(", "topic", "string", ",", "partition", "int32", ",", "key", "sarama", ".", "Encoder", ",", "msg", "sarama", ".", "Encoder", ")", "(", "*", "ProducerMessage", ",", "error", ")", "{", "if", "msg", "==", "nil", "{", "err", ":=", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "ref", ".", "Error", "(", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "message", ":=", "&", "sarama", ".", "ProducerMessage", "{", "Topic", ":", "topic", ",", "Partition", ":", "partition", ",", "Value", ":", "msg", ",", "Key", ":", "key", ",", "}", "\n\n", "partition", ",", "offset", ",", "err", ":=", "ref", ".", "Producer", ".", "SendMessage", "(", "message", ")", "\n", "pmsg", ":=", "&", "ProducerMessage", "{", "Topic", ":", "message", ".", "Topic", ",", "Key", ":", "message", ".", "Key", ",", "Value", ":", "message", ".", "Value", ",", "Metadata", ":", "message", ".", "Metadata", ",", "Offset", ":", "offset", ",", "Partition", ":", "partition", ",", "}", "\n", "if", "err", "!=", "nil", "{", "return", "pmsg", ",", "err", "\n", "}", "\n\n", "ref", ".", "Debugf", "(", "\"", "\"", ",", "pmsg", ")", "\n", "return", "pmsg", ",", "nil", "\n", "}" ]

[ "SendMsgToPartition", "sends", "a", "message", "to", "Kafka" ]