Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "t", "*", "Torrent", ")", "bytesCompleted", "(", ")", "int64", "{", "if", "!", "t", ".", "haveInfo", "(", ")", "{", "return", "0", "\n", "}", "\n", "return", "t", ".", "info", ".", "TotalLength", "(", ")", "-", "t", ".", "bytesLeft", "(", ")", "\n", "}" ]

[ "Don", "t", "call", "this", "before", "the", "info", "is", "available", "." ]

[ "func", "(", "t", "*", "Torrent", ")", "deleteConnection", "(", "c", "*", "connection", ")", "(", "ret", "bool", ")", "{", "if", "!", "c", ".", "closed", ".", "IsSet", "(", ")", "{", "panic", "(", "\"", "\"", ")", "\n", "// There are behaviours prevented by the closed state that will fail", "// if the connection has been deleted.", "}", "\n", "_", ",", "ret", "=", "t", ".", "conns", "[", "c", "]", "\n", "delete", "(", "t", ".", "conns", ",", "c", ")", "\n", "torrent", ".", "Add", "(", "\"", "\"", ",", "1", ")", "\n", "c", ".", "deleteAllRequests", "(", ")", "\n", "if", "len", "(", "t", ".", "conns", ")", "==", "0", "{", "t", ".", "assertNoPendingRequests", "(", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "Returns", "true", "if", "connection", "is", "removed", "from", "torrent", ".", "Conns", "." ]

[ "func", "(", "t", "*", "Torrent", ")", "seeding", "(", ")", "bool", "{", "cl", ":=", "t", ".", "cl", "\n", "if", "t", ".", "closed", ".", "IsSet", "(", ")", "{", "return", "false", "\n", "}", "\n", "if", "cl", ".", "config", ".", "NoUpload", "{", "return", "false", "\n", "}", "\n", "if", "!", "cl", ".", "config", ".", "Seed", "{", "return", "false", "\n", "}", "\n", "if", "cl", ".", "config", ".", "DisableAggressiveUpload", "&&", "t", ".", "needData", "(", ")", "{", "return", "false", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "Returns", "whether", "the", "client", "should", "make", "effort", "to", "seed", "the", "torrent", "." ]

[ "func", "(", "t", "*", "Torrent", ")", "startMissingTrackerScrapers", "(", ")", "{", "if", "t", ".", "cl", ".", "config", ".", "DisableTrackers", "{", "return", "\n", "}", "\n", "t", ".", "startScrapingTracker", "(", "t", ".", "metainfo", ".", "Announce", ")", "\n", "for", "_", ",", "tier", ":=", "range", "t", ".", "metainfo", ".", "AnnounceList", "{", "for", "_", ",", "url", ":=", "range", "tier", "{", "t", ".", "startScrapingTracker", "(", "url", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "Adds", "and", "starts", "tracker", "scrapers", "for", "tracker", "URLs", "that", "aren", "t", "already", "running", "." ]

[ "func", "(", "t", "*", "Torrent", ")", "announceRequest", "(", ")", "tracker", ".", "AnnounceRequest", "{", "// Note that IPAddress is not set. It's set for UDP inside the tracker", "// code, since it's dependent on the network in use.", "return", "tracker", ".", "AnnounceRequest", "{", "Event", ":", "tracker", ".", "None", ",", "NumWant", ":", "-", "1", ",", "Port", ":", "uint16", "(", "t", ".", "cl", ".", "incomingPeerPort", "(", ")", ")", ",", "PeerId", ":", "t", ".", "cl", ".", "peerID", ",", "InfoHash", ":", "t", ".", "infoHash", ",", "Key", ":", "t", ".", "cl", ".", "announceKey", "(", ")", ",", "// The following are vaguely described in BEP 3.", "Left", ":", "t", ".", "bytesLeftAnnounce", "(", ")", ",", "Uploaded", ":", "t", ".", "stats", ".", "BytesWrittenData", ".", "Int64", "(", ")", ",", "// There's no mention of wasted or unwanted download in the BEP.", "Downloaded", ":", "t", ".", "stats", ".", "BytesReadUsefulData", ".", "Int64", "(", ")", ",", "}", "\n", "}" ]

[ "Returns", "an", "AnnounceRequest", "with", "fields", "filled", "out", "to", "defaults", "and", "current", "values", "." ]

[ "func", "(", "t", "*", "Torrent", ")", "consumeDhtAnnouncePeers", "(", "pvs", "<-", "chan", "dht", ".", "PeersValues", ")", "{", "cl", ":=", "t", ".", "cl", "\n", "for", "v", ":=", "range", "pvs", "{", "cl", ".", "lock", "(", ")", "\n", "for", "_", ",", "cp", ":=", "range", "v", ".", "Peers", "{", "if", "cp", ".", "Port", "==", "0", "{", "// Can't do anything with this.", "continue", "\n", "}", "\n", "t", ".", "addPeer", "(", "Peer", "{", "IP", ":", "cp", ".", "IP", "[", ":", "]", ",", "Port", ":", "cp", ".", "Port", ",", "Source", ":", "peerSourceDHTGetPeers", ",", "}", ")", "\n", "}", "\n", "cl", ".", "unlock", "(", ")", "\n", "}", "\n", "}" ]

[ "Adds", "peers", "revealed", "in", "an", "announce", "until", "the", "announce", "ends", "or", "we", "have", "enough", "peers", "." ]

[ "func", "(", "t", "*", "Torrent", ")", "numTotalPeers", "(", ")", "int", "{", "peers", ":=", "make", "(", "map", "[", "string", "]", "struct", "{", "}", ")", "\n", "for", "conn", ":=", "range", "t", ".", "conns", "{", "ra", ":=", "conn", ".", "conn", ".", "RemoteAddr", "(", ")", "\n", "if", "ra", "==", "nil", "{", "// It's been closed and doesn't support RemoteAddr.", "continue", "\n", "}", "\n", "peers", "[", "ra", ".", "String", "(", ")", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n", "for", "addr", ":=", "range", "t", ".", "halfOpen", "{", "peers", "[", "addr", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n", "t", ".", "peers", ".", "Each", "(", "func", "(", "peer", "Peer", ")", "{", "peers", "[", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "peer", ".", "IP", ",", "peer", ".", "Port", ")", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", ")", "\n", "return", "len", "(", "peers", ")", "\n", "}" ]

[ "The", "total", "number", "of", "peers", "in", "the", "torrent", "." ]

[ "func", "(", "t", "*", "Torrent", ")", "reconcileHandshakeStats", "(", "c", "*", "connection", ")", "{", "if", "c", ".", "stats", "!=", "(", "ConnStats", "{", "// Handshakes should only increment these fields:", "BytesWritten", ":", "c", ".", "stats", ".", "BytesWritten", ",", "BytesRead", ":", "c", ".", "stats", ".", "BytesRead", ",", "}", ")", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "c", ".", "postHandshakeStats", "(", "func", "(", "cs", "*", "ConnStats", ")", "{", "cs", ".", "BytesRead", ".", "Add", "(", "c", ".", "stats", ".", "BytesRead", ".", "Int64", "(", ")", ")", "\n", "cs", ".", "BytesWritten", ".", "Add", "(", "c", ".", "stats", ".", "BytesWritten", ".", "Int64", "(", ")", ")", "\n", "}", ")", "\n", "c", ".", "reconciledHandshakeStats", "=", "true", "\n", "}" ]

[ "Reconcile", "bytes", "transferred", "before", "connection", "was", "associated", "with", "a", "torrent", "." ]

[ "func", "(", "t", "*", "Torrent", ")", "addConnection", "(", "c", "*", "connection", ")", "(", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "if", "err", "==", "nil", "{", "torrent", ".", "Add", "(", "\"", "\"", ",", "1", ")", "\n", "}", "\n", "}", "(", ")", "\n", "if", "t", ".", "closed", ".", "IsSet", "(", ")", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "for", "c0", ":=", "range", "t", ".", "conns", "{", "if", "c", ".", "PeerID", "!=", "c0", ".", "PeerID", "{", "continue", "\n", "}", "\n", "if", "!", "t", ".", "cl", ".", "config", ".", "dropDuplicatePeerIds", "{", "continue", "\n", "}", "\n", "if", "left", ",", "ok", ":=", "c", ".", "hasPreferredNetworkOver", "(", "c0", ")", ";", "ok", "&&", "left", "{", "c0", ".", "Close", "(", ")", "\n", "t", ".", "deleteConnection", "(", "c0", ")", "\n", "}", "else", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "if", "len", "(", "t", ".", "conns", ")", ">=", "t", ".", "maxEstablishedConns", "{", "c", ":=", "t", ".", "worstBadConn", "(", ")", "\n", "if", "c", "==", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "c", ".", "Close", "(", ")", "\n", "t", ".", "deleteConnection", "(", "c", ")", "\n", "}", "\n", "if", "len", "(", "t", ".", "conns", ")", ">=", "t", ".", "maxEstablishedConns", "{", "panic", "(", "len", "(", "t", ".", "conns", ")", ")", "\n", "}", "\n", "t", ".", "conns", "[", "c", "]", "=", "struct", "{", "}", "{", "}", "\n", "return", "nil", "\n", "}" ]

[ "Returns", "true", "if", "the", "connection", "is", "added", "." ]

[ "func", "(", "t", "*", "Torrent", ")", "onIncompletePiece", "(", "piece", "pieceIndex", ")", "{", "if", "t", ".", "pieceAllDirty", "(", "piece", ")", "{", "t", ".", "pendAllChunkSpecs", "(", "piece", ")", "\n", "}", "\n", "if", "!", "t", ".", "wantPieceIndex", "(", "piece", ")", "{", "// t.logger.Printf(\"piece %d incomplete and unwanted\", piece)", "return", "\n", "}", "\n", "// We could drop any connections that we told we have a piece that we", "// don't here. But there's a test failure, and it seems clients don't care", "// if you request pieces that you already claim to have. Pruning bad", "// connections might just remove any connections that aren't treating us", "// favourably anyway.", "// for c := range t.conns {", "// \tif c.sentHave(piece) {", "// \t\tc.Drop()", "// \t}", "// }", "for", "conn", ":=", "range", "t", ".", "conns", "{", "if", "conn", ".", "PeerHasPiece", "(", "piece", ")", "{", "conn", ".", "updateRequests", "(", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "Called", "when", "a", "piece", "is", "found", "to", "be", "not", "complete", "." ]

[ "func", "(", "t", "*", "Torrent", ")", "reapPieceTouchers", "(", "piece", "pieceIndex", ")", "(", "ret", "[", "]", "*", "connection", ")", "{", "for", "c", ":=", "range", "t", ".", "pieces", "[", "piece", "]", ".", "dirtiers", "{", "delete", "(", "c", ".", "peerTouchedPieces", ",", "piece", ")", "\n", "ret", "=", "append", "(", "ret", ",", "c", ")", "\n", "}", "\n", "t", ".", "pieces", "[", "piece", "]", ".", "dirtiers", "=", "nil", "\n", "return", "\n", "}" ]

[ "Return", "the", "connections", "that", "touched", "a", "piece", "and", "clear", "the", "entries", "while", "doing", "it", "." ]

[ "func", "(", "t", "*", "Torrent", ")", "queuePieceCheck", "(", "pieceIndex", "pieceIndex", ")", "{", "piece", ":=", "&", "t", ".", "pieces", "[", "pieceIndex", "]", "\n", "if", "piece", ".", "queuedForHash", "(", ")", "{", "return", "\n", "}", "\n", "t", ".", "piecesQueuedForHash", ".", "Add", "(", "bitmap", ".", "BitIndex", "(", "pieceIndex", ")", ")", "\n", "t", ".", "publishPieceChange", "(", "pieceIndex", ")", "\n", "t", ".", "updatePiecePriority", "(", "pieceIndex", ")", "\n", "go", "t", ".", "verifyPiece", "(", "pieceIndex", ")", "\n", "}" ]

[ "Currently", "doesn", "t", "really", "queue", "but", "should", "in", "the", "future", "." ]

[ "func", "(", "t", "*", "Torrent", ")", "initiateConn", "(", "peer", "Peer", ")", "{", "if", "peer", ".", "Id", "==", "t", ".", "cl", ".", "peerID", "{", "return", "\n", "}", "\n", "if", "t", ".", "cl", ".", "badPeerIPPort", "(", "peer", ".", "IP", ",", "peer", ".", "Port", ")", "{", "return", "\n", "}", "\n", "addr", ":=", "IpPort", "{", "peer", ".", "IP", ",", "uint16", "(", "peer", ".", "Port", ")", "}", "\n", "if", "t", ".", "addrActive", "(", "addr", ".", "String", "(", ")", ")", "{", "return", "\n", "}", "\n", "t", ".", "halfOpen", "[", "addr", ".", "String", "(", ")", "]", "=", "peer", "\n", "go", "t", ".", "cl", ".", "outgoingConnection", "(", "t", ",", "addr", ",", "peer", ".", "Source", ")", "\n", "}" ]

[ "Start", "the", "process", "of", "connecting", "to", "the", "given", "peer", "for", "the", "given", "torrent", "if", "appropriate", "." ]

[ "func", "(", "t", "*", "Torrent", ")", "allStats", "(", "f", "func", "(", "*", "ConnStats", ")", ")", "{", "f", "(", "&", "t", ".", "stats", ")", "\n", "f", "(", "&", "t", ".", "cl", ".", "stats", ")", "\n", "}" ]

[ "All", "stats", "that", "include", "this", "Torrent", ".", "Useful", "when", "we", "want", "to", "increment", "ConnStats", "but", "not", "for", "every", "connection", "." ]

[ "func", "(", "info", "*", "Info", ")", "BuildFromFilePath", "(", "root", "string", ")", "(", "err", "error", ")", "{", "info", ".", "Name", "=", "filepath", ".", "Base", "(", "root", ")", "\n", "info", ".", "Files", "=", "nil", "\n", "err", "=", "filepath", ".", "Walk", "(", "root", ",", "func", "(", "path", "string", ",", "fi", "os", ".", "FileInfo", ",", "err", "error", ")", "error", "{", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "fi", ".", "IsDir", "(", ")", "{", "// Directories are implicit in torrent files.", "return", "nil", "\n", "}", "else", "if", "path", "==", "root", "{", "// The root is a file.", "info", ".", "Length", "=", "fi", ".", "Size", "(", ")", "\n", "return", "nil", "\n", "}", "\n", "relPath", ",", "err", ":=", "filepath", ".", "Rel", "(", "root", ",", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "info", ".", "Files", "=", "append", "(", "info", ".", "Files", ",", "FileInfo", "{", "Path", ":", "strings", ".", "Split", "(", "relPath", ",", "string", "(", "filepath", ".", "Separator", ")", ")", ",", "Length", ":", "fi", ".", "Size", "(", ")", ",", "}", ")", "\n", "return", "nil", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "slices", ".", "Sort", "(", "info", ".", "Files", ",", "func", "(", "l", ",", "r", "FileInfo", ")", "bool", "{", "return", "strings", ".", "Join", "(", "l", ".", "Path", ",", "\"", "\"", ")", "<", "strings", ".", "Join", "(", "r", ".", "Path", ",", "\"", "\"", ")", "\n", "}", ")", "\n", "err", "=", "info", ".", "GeneratePieces", "(", "func", "(", "fi", "FileInfo", ")", "(", "io", ".", "ReadCloser", ",", "error", ")", "{", "return", "os", ".", "Open", "(", "filepath", ".", "Join", "(", "root", ",", "strings", ".", "Join", "(", "fi", ".", "Path", ",", "string", "(", "filepath", ".", "Separator", ")", ")", ")", ")", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "This", "is", "a", "helper", "that", "sets", "Files", "and", "Pieces", "from", "a", "root", "path", "and", "its", "children", "." ]

[ "func", "(", "info", "*", "Info", ")", "writeFiles", "(", "w", "io", ".", "Writer", ",", "open", "func", "(", "fi", "FileInfo", ")", "(", "io", ".", "ReadCloser", ",", "error", ")", ")", "error", "{", "for", "_", ",", "fi", ":=", "range", "info", ".", "UpvertedFiles", "(", ")", "{", "r", ",", "err", ":=", "open", "(", "fi", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "fi", ",", "err", ")", "\n", "}", "\n", "wn", ",", "err", ":=", "io", ".", "CopyN", "(", "w", ",", "r", ",", "fi", ".", "Length", ")", "\n", "r", ".", "Close", "(", ")", "\n", "if", "wn", "!=", "fi", ".", "Length", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "fi", ",", "err", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Concatenates", "all", "the", "files", "in", "the", "torrent", "into", "w", ".", "open", "is", "a", "function", "that", "gets", "at", "the", "contents", "of", "the", "given", "file", "." ]

[ "func", "(", "info", "*", "Info", ")", "UpvertedFiles", "(", ")", "[", "]", "FileInfo", "{", "if", "len", "(", "info", ".", "Files", ")", "==", "0", "{", "return", "[", "]", "FileInfo", "{", "{", "Length", ":", "info", ".", "Length", ",", "// Callers should determine that Info.Name is the basename, and", "// thus a regular file.", "Path", ":", "nil", ",", "}", "}", "\n", "}", "\n", "return", "info", ".", "Files", "\n", "}" ]

[ "The", "files", "field", "converted", "up", "from", "the", "old", "single", "-", "file", "in", "the", "parent", "info", "dict", "if", "necessary", ".", "This", "is", "a", "helper", "to", "avoid", "having", "to", "conditionally", "handle", "single", "and", "multi", "-", "file", "torrent", "infos", "." ]

[ "func", "makeStoredLabels", "(", "labels", "[", "]", "string", ")", "map", "[", "string", "]", "string", "{", "storedLabels", ":=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "for", "_", ",", "s", ":=", "range", "labels", "{", "split", ":=", "strings", ".", "SplitN", "(", "s", ",", "\"", "\"", ",", "2", ")", "\n", "if", "len", "(", "split", ")", "==", "1", "{", "storedLabels", "[", "split", "[", "0", "]", "]", "=", "split", "[", "0", "]", "\n", "}", "else", "{", "storedLabels", "[", "split", "[", "1", "]", "]", "=", "split", "[", "0", "]", "\n", "}", "\n", "}", "\n", "return", "storedLabels", "\n", "}" ]

[ "makeStoredLabels", "converts", "labels", "into", "a", "map", "for", "quicker", "retrieval", ".", "Incoming", "labels", "if", "desired", "may", "contain", "mappings", "in", "format", "newName", "=", "oldName" ]

[ "func", "makeIgnoredLabels", "(", "labels", "[", "]", "string", ")", "map", "[", "string", "]", "string", "{", "ignoredLabels", ":=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "for", "_", ",", "s", ":=", "range", "labels", "{", "ignoredLabels", "[", "s", "]", "=", "\"", "\"", "\n", "}", "\n", "return", "ignoredLabels", "\n", "}" ]

[ "makeIgnoredLabels", "converts", "label", "slice", "into", "a", "map", "for", "later", "use", "." ]

[ "func", "NewLabelCopier", "(", "separator", "string", ",", "storedLabels", ",", "ignoredLabels", "[", "]", "string", ")", "(", "*", "LabelCopier", ",", "error", ")", "{", "return", "&", "LabelCopier", "{", "labelSeparator", ":", "separator", ",", "storedLabels", ":", "makeStoredLabels", "(", "storedLabels", ")", ",", "ignoredLabels", ":", "makeIgnoredLabels", "(", "ignoredLabels", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "NewLabelCopier", "creates", "a", "new", "instance", "of", "LabelCopier", "type" ]

[ "func", "getEventValue", "(", "event", "*", "kube_api", ".", "Event", ")", "(", "string", ",", "error", ")", "{", "// TODO: check whether indenting is required.", "bytes", ",", "err", ":=", "json", ".", "MarshalIndent", "(", "event", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "string", "(", "bytes", ")", ",", "nil", "\n", "}" ]

[ "Generate", "point", "value", "for", "event" ]

[ "func", "newSink", "(", "c", "influxdb_common", ".", "InfluxdbConfig", ")", "core", ".", "EventSink", "{", "client", ",", "err", ":=", "influxdb_common", ".", "NewClient", "(", "c", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "&", "influxdbSink", "{", "client", ":", "client", ",", "// can be nil", "c", ":", "c", ",", "}", "\n", "}" ]

[ "Returns", "a", "thread", "-", "safe", "implementation", "of", "core", ".", "EventSink", "for", "InfluxDB", "." ]

[ "func", "(", "tsdbSink", "*", "openTSDBSink", ")", "metricToPoint", "(", "name", "string", ",", "value", "core", ".", "MetricValue", ",", "timestamp", "time", ".", "Time", ",", "labels", "map", "[", "string", "]", "string", ")", "opentsdbclient", ".", "DataPoint", "{", "seriesName", ":=", "strings", ".", "Replace", "(", "toValidOpenTsdbName", "(", "name", ")", ",", "\"", "\"", ",", "\"", "\"", ",", "-", "1", ")", "\n\n", "if", "value", ".", "MetricType", ".", "String", "(", ")", "!=", "\"", "\"", "{", "seriesName", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "seriesName", ",", "value", ".", "MetricType", ".", "String", "(", ")", ")", "\n", "}", "\n\n", "datapoint", ":=", "opentsdbclient", ".", "DataPoint", "{", "Metric", ":", "seriesName", ",", "Tags", ":", "make", "(", "map", "[", "string", "]", "string", ",", "len", "(", "labels", ")", ")", ",", "Timestamp", ":", "timestamp", ".", "Unix", "(", ")", ",", "}", "\n", "if", "value", ".", "ValueType", "==", "core", ".", "ValueInt64", "{", "datapoint", ".", "Value", "=", "value", ".", "IntValue", "\n", "}", "else", "{", "datapoint", ".", "Value", "=", "value", ".", "FloatValue", "\n", "}", "\n\n", "for", "key", ",", "value", ":=", "range", "labels", "{", "key", "=", "toValidOpenTsdbName", "(", "key", ")", "\n", "value", "=", "toValidOpenTsdbName", "(", "value", ")", "\n\n", "if", "value", "!=", "\"", "\"", "{", "datapoint", ".", "Tags", "[", "key", "]", "=", "value", "\n", "}", "\n", "}", "\n\n", "tsdbSink", ".", "putDefaultTags", "(", "&", "datapoint", ")", "\n", "return", "datapoint", "\n", "}" ]

[ "timeSeriesToPoint", "transfers", "the", "contents", "holding", "in", "the", "given", "pointer", "of", "sink_api", ".", "Timeseries", "into", "the", "instance", "of", "opentsdbclient", ".", "DataPoint" ]

[ "func", "(", "tsdbSink", "*", "openTSDBSink", ")", "putDefaultTags", "(", "datapoint", "*", "opentsdbclient", ".", "DataPoint", ")", "{", "datapoint", ".", "Tags", "[", "clusterNameTagName", "]", "=", "tsdbSink", ".", "clusterName", "\n", "}" ]

[ "putDefaultTags", "just", "fills", "in", "the", "default", "key", "-", "value", "pair", "for", "the", "tags", ".", "OpenTSDB", "requires", "at", "least", "one", "non", "-", "empty", "tag", "otherwise", "the", "OpenTSDB", "will", "return", "error", "and", "the", "operation", "of", "putting", "datapoint", "will", "be", "failed", "." ]

[ "func", "NewApi", "(", "runningInKubernetes", "bool", ",", "metricSink", "*", "metricsink", ".", "MetricSink", ",", "historicalSource", "core", ".", "HistoricalSource", ",", "disableMetricExport", "bool", ")", "*", "Api", "{", "gkeMetrics", ":=", "make", "(", "map", "[", "string", "]", "core", ".", "MetricDescriptor", ")", "\n", "gkeLabels", ":=", "make", "(", "map", "[", "string", "]", "core", ".", "LabelDescriptor", ")", "\n", "for", "_", ",", "val", ":=", "range", "core", ".", "StandardMetrics", "{", "gkeMetrics", "[", "val", ".", "Name", "]", "=", "val", ".", "MetricDescriptor", "\n", "}", "\n", "for", "_", ",", "val", ":=", "range", "core", ".", "LabeledMetrics", "{", "gkeMetrics", "[", "val", ".", "Name", "]", "=", "val", ".", "MetricDescriptor", "\n", "}", "\n", "gkeMetrics", "[", "core", ".", "MetricCpuLimit", ".", "Name", "]", "=", "core", ".", "MetricCpuLimit", ".", "MetricDescriptor", "\n", "gkeMetrics", "[", "core", ".", "MetricMemoryLimit", ".", "Name", "]", "=", "core", ".", "MetricMemoryLimit", ".", "MetricDescriptor", "\n\n", "for", "_", ",", "val", ":=", "range", "core", ".", "CommonLabels", "(", ")", "{", "gkeLabels", "[", "val", ".", "Key", "]", "=", "val", "\n", "}", "\n", "for", "_", ",", "val", ":=", "range", "core", ".", "ContainerLabels", "(", ")", "{", "gkeLabels", "[", "val", ".", "Key", "]", "=", "val", "\n", "}", "\n", "for", "_", ",", "val", ":=", "range", "core", ".", "PodLabels", "(", ")", "{", "gkeLabels", "[", "val", ".", "Key", "]", "=", "val", "\n", "}", "\n\n", "return", "&", "Api", "{", "runningInKubernetes", ":", "runningInKubernetes", ",", "metricSink", ":", "metricSink", ",", "historicalSource", ":", "historicalSource", ",", "gkeMetrics", ":", "gkeMetrics", ",", "gkeLabels", ":", "gkeLabels", ",", "disabled", ":", "disableMetricExport", ",", "}", "\n", "}" ]

[ "Create", "a", "new", "Api", "to", "serve", "from", "the", "specified", "cache", "." ]

[ "func", "(", "a", "*", "Api", ")", "Register", "(", "container", "*", "restful", ".", "Container", ")", "{", "ws", ":=", "new", "(", "restful", ".", "WebService", ")", "\n", "ws", ".", "Path", "(", "\"", "\"", ")", ".", "Doc", "(", "\"", "\"", ")", ".", "Produces", "(", "restful", ".", "MIME_JSON", ")", "\n", "ws", ".", "Route", "(", "ws", ".", "GET", "(", "\"", "\"", ")", ".", "To", "(", "a", ".", "exportMetrics", ")", ".", "Doc", "(", "\"", "\"", ")", ".", "Operation", "(", "\"", "\"", ")", ".", "Writes", "(", "[", "]", "*", "types", ".", "Timeseries", "{", "}", ")", ")", "\n", "container", ".", "Add", "(", "ws", ")", "\n", "ws", "=", "new", "(", "restful", ".", "WebService", ")", "\n", "ws", ".", "Path", "(", "\"", "\"", ")", ".", "Doc", "(", "\"", "\"", ")", ".", "Produces", "(", "restful", ".", "MIME_JSON", ")", "\n", "ws", ".", "Route", "(", "ws", ".", "GET", "(", "\"", "\"", ")", ".", "To", "(", "a", ".", "exportMetricsSchema", ")", ".", "Doc", "(", "\"", "\"", ")", ".", "Operation", "(", "\"", "\"", ")", ".", "Writes", "(", "types", ".", "TimeseriesSchema", "{", "}", ")", ")", "\n", "container", ".", "Add", "(", "ws", ")", "\n\n", "if", "a", ".", "metricSink", "!=", "nil", "{", "a", ".", "RegisterModel", "(", "container", ")", "\n", "}", "\n\n", "if", "a", ".", "historicalSource", "!=", "nil", "{", "a", ".", "RegisterHistorical", "(", "container", ")", "\n", "}", "\n", "}" ]

[ "Register", "the", "mainApi", "on", "the", "specified", "endpoint", "." ]

[ "func", "NewHawkularSink", "(", "u", "*", "url", ".", "URL", ")", "(", "core", ".", "DataSink", ",", "error", ")", "{", "sink", ":=", "&", "hawkularSink", "{", "uri", ":", "u", ",", "batchSize", ":", "1000", ",", "}", "\n", "if", "err", ":=", "sink", ".", "init", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "metrics", ":=", "make", "(", "[", "]", "core", ".", "MetricDescriptor", ",", "0", ",", "len", "(", "core", ".", "AllMetrics", ")", ")", "\n", "for", "_", ",", "metric", ":=", "range", "core", ".", "AllMetrics", "{", "metrics", "=", "append", "(", "metrics", ",", "metric", ".", "MetricDescriptor", ")", "\n", "}", "\n", "sink", ".", "Register", "(", "metrics", ")", "\n", "return", "sink", ",", "nil", "\n", "}" ]

[ "NewHawkularSink", "Creates", "and", "returns", "a", "new", "hawkularSink", "instance" ]

[ "func", "(", "esSvc", "*", "ElasticSearchService", ")", "SaveData", "(", "date", "time", ".", "Time", ",", "typeName", "string", ",", "sinkData", "[", "]", "interface", "{", "}", ")", "error", "{", "if", "typeName", "==", "\"", "\"", "||", "len", "(", "sinkData", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n\n", "indexName", ":=", "esSvc", ".", "Index", "(", "date", ")", "\n\n", "// Use the IndexExists service to check if a specified index exists.", "exists", ",", "err", ":=", "esSvc", ".", "EsClient", ".", "IndexExists", "(", "indexName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "!", "exists", "{", "// Create a new index.", "createIndex", ",", "err", ":=", "esSvc", ".", "EsClient", ".", "CreateIndex", "(", "indexName", ",", "mapping", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "ack", ":=", "false", "\n", "switch", "i", ":=", "createIndex", ".", "(", "type", ")", "{", "case", "*", "elastic2", ".", "IndicesCreateResult", ":", "ack", "=", "i", ".", "Acknowledged", "\n", "case", "*", "elastic5", ".", "IndicesCreateResult", ":", "ack", "=", "i", ".", "Acknowledged", "\n", "}", "\n", "if", "!", "ack", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "aliases", ",", "err", ":=", "esSvc", ".", "EsClient", ".", "GetAliases", "(", "indexName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "aliasName", ":=", "esSvc", ".", "IndexAlias", "(", "typeName", ")", "\n\n", "hasAlias", ":=", "false", "\n", "switch", "a", ":=", "aliases", ".", "(", "type", ")", "{", "case", "*", "elastic2", ".", "AliasesResult", ":", "hasAlias", "=", "a", ".", "Indices", "[", "indexName", "]", ".", "HasAlias", "(", "aliasName", ")", "\n", "case", "*", "elastic5", ".", "AliasesResult", ":", "hasAlias", "=", "a", ".", "Indices", "[", "indexName", "]", ".", "HasAlias", "(", "aliasName", ")", "\n", "}", "\n", "if", "!", "hasAlias", "{", "createAlias", ",", "err", ":=", "esSvc", ".", "EsClient", ".", "AddAlias", "(", "indexName", ",", "esSvc", ".", "IndexAlias", "(", "typeName", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "ack", ":=", "false", "\n", "switch", "i", ":=", "createAlias", ".", "(", "type", ")", "{", "case", "*", "elastic2", ".", "AliasResult", ":", "ack", "=", "i", ".", "Acknowledged", "\n", "case", "*", "elastic5", ".", "AliasResult", ":", "ack", "=", "i", ".", "Acknowledged", "\n", "}", "\n", "if", "!", "ack", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "for", "_", ",", "data", ":=", "range", "sinkData", "{", "esSvc", ".", "EsClient", ".", "AddBulkReq", "(", "indexName", ",", "typeName", ",", "data", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "SaveDataIntoES", "save", "metrics", "and", "events", "to", "ES", "by", "using", "ES", "client" ]

[ "func", "newSink", "(", "c", "influxdb_common", ".", "InfluxdbConfig", ")", "core", ".", "DataSink", "{", "client", ",", "err", ":=", "influxdb_common", ".", "NewClient", "(", "c", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "&", "influxdbSink", "{", "client", ":", "client", ",", "// can be nil", "c", ":", "c", ",", "conChan", ":", "make", "(", "chan", "struct", "{", "}", ",", "c", ".", "Concurrency", ")", ",", "}", "\n", "}" ]

[ "Returns", "a", "thread", "-", "compatible", "implementation", "of", "influxdb", "interactions", "." ]

[ "func", "(", "self", "*", "realKubeFramework", ")", "ParseRBAC", "(", "filePath", "string", ")", "(", "*", "rbacv1", ".", "ClusterRoleBinding", ",", "error", ")", "{", "obj", ",", "err", ":=", "self", ".", "loadRBACObject", "(", "filePath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "rbac", ",", "ok", ":=", "obj", ".", "(", "*", "rbacv1", ".", "ClusterRoleBinding", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "obj", ")", "\n", "}", "\n", "return", "rbac", ",", "nil", "\n", "}" ]

[ "Parses", "and", "Returns", "a", "RBAC", "object", "contained", "in", "filePath" ]

[ "func", "(", "self", "*", "realKubeFramework", ")", "CreateRBAC", "(", "rbac", "*", "rbacv1", ".", "ClusterRoleBinding", ")", "error", "{", "_", ",", "err", ":=", "self", ".", "kubeClient", ".", "RbacV1", "(", ")", ".", "ClusterRoleBindings", "(", ")", ".", "Create", "(", "rbac", ")", "\n", "return", "err", "\n", "}" ]

[ "CreateRBAC", "creates", "the", "RBAC", "object" ]

[ "func", "(", "self", "*", "realKubeFramework", ")", "ParseServiceAccount", "(", "filePath", "string", ")", "(", "*", "v1", ".", "ServiceAccount", ",", "error", ")", "{", "obj", ",", "err", ":=", "self", ".", "loadObject", "(", "filePath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "sa", ",", "ok", ":=", "obj", ".", "(", "*", "v1", ".", "ServiceAccount", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "obj", ")", "\n", "}", "\n", "return", "sa", ",", "nil", "\n", "}" ]

[ "Parses", "and", "Returns", "a", "ServiceAccount", "object", "contained", "in", "filePath" ]

[ "func", "(", "self", "*", "realKubeFramework", ")", "CreateServiceAccount", "(", "sa", "*", "v1", ".", "ServiceAccount", ")", "error", "{", "_", ",", "err", ":=", "self", ".", "kubeClient", ".", "CoreV1", "(", ")", ".", "ServiceAccounts", "(", "sa", ".", "Namespace", ")", ".", "Create", "(", "sa", ")", "\n", "return", "err", "\n", "}" ]

[ "CreateServiceAccount", "creates", "the", "ServiceAccount", "object" ]

[ "func", "(", "c", "*", "HoneycombClient", ")", "SendBatch", "(", "batch", "Batch", ")", "error", "{", "if", "len", "(", "batch", ")", "==", "0", "{", "// Nothing to send", "return", "nil", "\n", "}", "\n\n", "errs", ":=", "[", "]", "string", "{", "}", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "batch", ")", ";", "i", "+=", "maxBatchSize", "{", "offset", ":=", "i", "+", "maxBatchSize", "\n", "if", "offset", ">", "len", "(", "batch", ")", "{", "offset", "=", "len", "(", "batch", ")", "\n", "}", "\n", "if", "err", ":=", "c", ".", "sendBatch", "(", "batch", "[", "i", ":", "offset", "]", ")", ";", "err", "!=", "nil", "{", "errs", "=", "append", "(", "errs", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "}", "\n\n", "if", "len", "(", "errs", ")", ">", "0", "{", "return", "errors", ".", "New", "(", "strings", ".", "Join", "(", "errs", ",", "\"", "\\n", "\"", ")", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "SendBatch", "splits", "the", "top", "-", "level", "batch", "into", "sub", "-", "batches", "if", "needed", ".", "Otherwise", "requests", "that", "are", "too", "large", "will", "be", "rejected", "by", "the", "Honeycomb", "API", "." ]

[ "func", "(", "sink", "*", "influxdbSink", ")", "checkSanitizedMetricName", "(", "name", "string", ")", "error", "{", "if", "!", "metricAllowedChars", ".", "MatchString", "(", "name", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "name", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "checkSanitizedMetricName", "errors", "out", "if", "invalid", "characters", "are", "found", "in", "the", "metric", "name", "since", "InfluxDB", "does", "not", "widely", "support", "bound", "parameters", "yet", "and", "we", "need", "to", "sanitize", "our", "inputs", "." ]

[ "func", "(", "sink", "*", "influxdbSink", ")", "checkSanitizedMetricLabels", "(", "labels", "map", "[", "string", "]", "string", ")", "error", "{", "// label names have the same restrictions as metric names, here", "for", "k", ",", "v", ":=", "range", "labels", "{", "if", "!", "metricAllowedChars", ".", "MatchString", "(", "k", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "k", ")", "\n", "}", "\n\n", "// for metric values, we're somewhat more permissive. We allow any", "// Printable unicode character, except quotation marks, which are used", "// to delimit things.", "if", "strings", ".", "ContainsRune", "(", "v", ",", "'\"'", ")", "||", "strings", ".", "ContainsRune", "(", "v", ",", "'\\''", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "v", ")", "\n", "}", "\n\n", "for", "_", ",", "runeVal", ":=", "range", "v", "{", "if", "!", "unicode", ".", "IsPrint", "(", "runeVal", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "v", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "checkSanitizedMetricLabels", "errors", "out", "if", "invalid", "characters", "are", "found", "in", "the", "label", "name", "or", "label", "value", "since", "InfluxDb", "does", "not", "widely", "support", "bound", "parameters", "yet", "and", "we", "need", "to", "sanitize", "our", "inputs", "." ]

[ "func", "(", "sink", "*", "influxdbSink", ")", "aggregationFunc", "(", "aggregationName", "core", ".", "AggregationType", ",", "fieldName", "string", ")", "string", "{", "switch", "aggregationName", "{", "case", "core", ".", "AggregationTypeAverage", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "fieldName", ")", "\n", "case", "core", ".", "AggregationTypeMaximum", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "fieldName", ")", "\n", "case", "core", ".", "AggregationTypeMinimum", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "fieldName", ")", "\n", "case", "core", ".", "AggregationTypeMedian", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "fieldName", ")", "\n", "case", "core", ".", "AggregationTypeCount", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "fieldName", ")", "\n", "case", "core", ".", "AggregationTypePercentile50", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "fieldName", ")", "\n", "case", "core", ".", "AggregationTypePercentile95", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "fieldName", ")", "\n", "case", "core", ".", "AggregationTypePercentile99", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "fieldName", ")", "\n", "}", "\n\n", "// This should have been checked by the API level, so something's seriously wrong here", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "aggregationName", ")", ")", "\n", "}" ]

[ "aggregationFunc", "converts", "an", "aggregation", "name", "into", "the", "equivalent", "call", "to", "an", "InfluxQL", "aggregation", "function" ]

[ "func", "(", "sink", "*", "influxdbSink", ")", "keyToSelector", "(", "key", "core", ".", "HistoricalKey", ")", "string", "{", "typeSel", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "key", ".", "ObjectType", ")", "\n", "switch", "key", ".", "ObjectType", "{", "case", "core", ".", "MetricSetTypeNode", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "typeSel", ",", "core", ".", "LabelNodename", ".", "Key", ",", "key", ".", "NodeName", ")", "\n", "case", "core", ".", "MetricSetTypeSystemContainer", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "typeSel", ",", "core", ".", "LabelContainerName", ".", "Key", ",", "key", ".", "ContainerName", ",", "core", ".", "LabelNodename", ".", "Key", ",", "key", ".", "NodeName", ")", "\n", "case", "core", ".", "MetricSetTypeCluster", ":", "return", "typeSel", "\n", "case", "core", ".", "MetricSetTypeNamespace", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "typeSel", ",", "core", ".", "LabelNamespaceName", ".", "Key", ",", "key", ".", "NamespaceName", ")", "\n", "case", "core", ".", "MetricSetTypePod", ":", "if", "key", ".", "PodId", "!=", "\"", "\"", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "typeSel", ",", "core", ".", "LabelPodId", ".", "Key", ",", "key", ".", "PodId", ")", "\n", "}", "else", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "typeSel", ",", "core", ".", "LabelNamespaceName", ".", "Key", ",", "key", ".", "NamespaceName", ",", "core", ".", "LabelPodName", ".", "Key", ",", "key", ".", "PodName", ")", "\n", "}", "\n", "case", "core", ".", "MetricSetTypePodContainer", ":", "if", "key", ".", "PodId", "!=", "\"", "\"", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "typeSel", ",", "core", ".", "LabelPodId", ".", "Key", ",", "key", ".", "PodId", ",", "core", ".", "LabelContainerName", ".", "Key", ",", "key", ".", "ContainerName", ")", "\n", "}", "else", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "typeSel", ",", "core", ".", "LabelNamespaceName", ".", "Key", ",", "key", ".", "NamespaceName", ",", "core", ".", "LabelPodName", ".", "Key", ",", "key", ".", "PodName", ",", "core", ".", "LabelContainerName", ".", "Key", ",", "key", ".", "ContainerName", ")", "\n", "}", "\n", "}", "\n\n", "// These are assigned by the API, so it shouldn't be possible to reach this unless things are really broken", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "key", ".", "ObjectType", ")", ")", "\n", "}" ]

[ "keyToSelector", "converts", "a", "HistoricalKey", "to", "an", "InfluxQL", "predicate" ]

[ "func", "(", "sink", "*", "influxdbSink", ")", "labelsToPredicate", "(", "labels", "map", "[", "string", "]", "string", ")", "string", "{", "if", "len", "(", "labels", ")", "==", "0", "{", "return", "\"", "\"", "\n", "}", "\n\n", "parts", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "labels", ")", ")", "\n", "for", "k", ",", "v", ":=", "range", "labels", "{", "parts", "=", "append", "(", "parts", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "k", ",", "v", ")", ")", "\n", "}", "\n\n", "return", "strings", ".", "Join", "(", "parts", ",", "\"", "\"", ")", "\n", "}" ]

[ "labelsToPredicate", "composes", "an", "InfluxQL", "predicate", "based", "on", "the", "given", "map", "of", "labels" ]

[ "func", "(", "sink", "*", "influxdbSink", ")", "composeRawQuery", "(", "metricName", "string", ",", "labels", "map", "[", "string", "]", "string", ",", "metricKeys", "[", "]", "core", ".", "HistoricalKey", ",", "start", ",", "end", "time", ".", "Time", ")", "string", "{", "seriesName", ",", "fieldName", ":=", "sink", ".", "metricToSeriesAndField", "(", "metricName", ")", "\n\n", "queries", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "metricKeys", ")", ")", "\n", "for", "i", ",", "key", ":=", "range", "metricKeys", "{", "pred", ":=", "sink", ".", "keyToSelector", "(", "key", ")", "\n", "if", "labels", "!=", "nil", "{", "pred", "+=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "sink", ".", "labelsToPredicate", "(", "labels", ")", ")", "\n", "}", "\n", "if", "!", "start", ".", "IsZero", "(", ")", "{", "pred", "+=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "start", ".", "Format", "(", "time", ".", "RFC3339", ")", ")", "\n", "}", "\n", "if", "!", "end", ".", "IsZero", "(", ")", "{", "pred", "+=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "end", ".", "Format", "(", "time", ".", "RFC3339", ")", ")", "\n", "}", "\n", "queries", "[", "i", "]", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "fieldName", ",", "seriesName", ",", "pred", ")", "\n", "}", "\n\n", "return", "strings", ".", "Join", "(", "queries", ",", "\"", "\"", ")", "\n", "}" ]

[ "composeRawQuery", "creates", "the", "InfluxQL", "query", "to", "fetch", "the", "given", "metric", "values" ]

[ "func", "(", "sink", "*", "influxdbSink", ")", "parseRawQueryRow", "(", "rawRow", "influx_models", ".", "Row", ")", "(", "[", "]", "core", ".", "TimestampedMetricValue", ",", "error", ")", "{", "vals", ":=", "make", "(", "[", "]", "core", ".", "TimestampedMetricValue", ",", "len", "(", "rawRow", ".", "Values", ")", ")", "\n", "wasInt", ":=", "make", "(", "map", "[", "string", "]", "bool", ",", "1", ")", "\n", "for", "i", ",", "rawVal", ":=", "range", "rawRow", ".", "Values", "{", "val", ":=", "core", ".", "TimestampedMetricValue", "{", "}", "\n\n", "if", "ts", ",", "err", ":=", "time", ".", "Parse", "(", "time", ".", "RFC3339", ",", "rawVal", "[", "0", "]", ".", "(", "string", ")", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "rawVal", "[", "0", "]", ".", "(", "string", ")", ",", "rawRow", ".", "Name", ")", "\n", "}", "else", "{", "val", ".", "Timestamp", "=", "ts", "\n", "}", "\n\n", "if", "err", ":=", "tryParseMetricValue", "(", "\"", "\"", ",", "rawVal", ",", "&", "val", ".", "MetricValue", ",", "1", ",", "wasInt", ")", ";", "err", "!=", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\\\"", "\\\"", "\"", ",", "rawRow", ".", "Name", ",", "err", ")", "\n", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "rawRow", ".", "Name", ")", "\n", "}", "\n\n", "vals", "[", "i", "]", "=", "val", "\n", "}", "\n\n", "if", "wasInt", "[", "\"", "\"", "]", "{", "for", "i", ":=", "range", "vals", "{", "vals", "[", "i", "]", ".", "MetricValue", ".", "ValueType", "=", "core", ".", "ValueInt64", "\n", "}", "\n", "}", "else", "{", "for", "i", ":=", "range", "vals", "{", "vals", "[", "i", "]", ".", "MetricValue", ".", "ValueType", "=", "core", ".", "ValueFloat", "\n", "}", "\n", "}", "\n\n", "return", "vals", ",", "nil", "\n", "}" ]

[ "parseRawQueryRow", "parses", "a", "set", "of", "timestamped", "metric", "values", "from", "unstructured", "JSON", "output", "into", "the", "appropriate", "Heapster", "form" ]

[ "func", "(", "sink", "*", "influxdbSink", ")", "composeAggregateQuery", "(", "metricName", "string", ",", "labels", "map", "[", "string", "]", "string", ",", "aggregations", "[", "]", "core", ".", "AggregationType", ",", "metricKeys", "[", "]", "core", ".", "HistoricalKey", ",", "start", ",", "end", "time", ".", "Time", ",", "bucketSize", "time", ".", "Duration", ")", "string", "{", "seriesName", ",", "fieldName", ":=", "sink", ".", "metricToSeriesAndField", "(", "metricName", ")", "\n\n", "var", "bucketSizeNanoSeconds", "int64", "=", "0", "\n", "if", "bucketSize", "!=", "0", "{", "bucketSizeNanoSeconds", "=", "int64", "(", "bucketSize", ".", "Nanoseconds", "(", ")", "/", "int64", "(", "time", ".", "Microsecond", "/", "time", ".", "Nanosecond", ")", ")", "\n", "}", "\n\n", "queries", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "metricKeys", ")", ")", "\n", "for", "i", ",", "key", ":=", "range", "metricKeys", "{", "pred", ":=", "sink", ".", "keyToSelector", "(", "key", ")", "\n", "if", "labels", "!=", "nil", "{", "pred", "+=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "sink", ".", "labelsToPredicate", "(", "labels", ")", ")", "\n", "}", "\n", "if", "!", "start", ".", "IsZero", "(", ")", "{", "pred", "+=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "start", ".", "Format", "(", "time", ".", "RFC3339", ")", ")", "\n", "}", "\n", "if", "!", "end", ".", "IsZero", "(", ")", "{", "pred", "+=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "end", ".", "Format", "(", "time", ".", "RFC3339", ")", ")", "\n", "}", "\n\n", "aggParts", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "aggregations", ")", ")", "\n", "for", "i", ",", "agg", ":=", "range", "aggregations", "{", "aggParts", "[", "i", "]", "=", "sink", ".", "aggregationFunc", "(", "agg", ",", "fieldName", ")", "\n", "}", "\n\n", "queries", "[", "i", "]", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "strings", ".", "Join", "(", "aggParts", ",", "\"", "\"", ")", ",", "seriesName", ",", "pred", ")", "\n\n", "if", "bucketSize", "!=", "0", "{", "// group by time requires we have at least one time bound", "if", "start", ".", "IsZero", "(", ")", "&&", "end", ".", "IsZero", "(", ")", "{", "queries", "[", "i", "]", "+=", "fmt", ".", "Sprintf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// fill(none) makes sure we skip data points will null values (otherwise we'll get a *bunch* of null", "// values when we go back beyond the time where we started collecting data).", "queries", "[", "i", "]", "+=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "bucketSizeNanoSeconds", ")", "\n", "}", "\n", "}", "\n\n", "return", "strings", ".", "Join", "(", "queries", ",", "\"", "\"", ")", "\n", "}" ]

[ "composeAggregateQuery", "creates", "the", "InfluxQL", "query", "to", "fetch", "the", "given", "aggregation", "values" ]

[ "func", "(", "sink", "*", "influxdbSink", ")", "parseAggregateQueryRow", "(", "rawRow", "influx_models", ".", "Row", ",", "aggregationLookup", "map", "[", "core", ".", "AggregationType", "]", "int", ",", "bucketSize", "time", ".", "Duration", ")", "(", "[", "]", "core", ".", "TimestampedAggregationValue", ",", "error", ")", "{", "vals", ":=", "make", "(", "[", "]", "core", ".", "TimestampedAggregationValue", ",", "len", "(", "rawRow", ".", "Values", ")", ")", "\n", "wasInt", ":=", "make", "(", "map", "[", "string", "]", "bool", ",", "len", "(", "aggregationLookup", ")", ")", "\n\n", "for", "i", ",", "rawVal", ":=", "range", "rawRow", ".", "Values", "{", "val", ":=", "core", ".", "TimestampedAggregationValue", "{", "BucketSize", ":", "bucketSize", ",", "AggregationValue", ":", "core", ".", "AggregationValue", "{", "Aggregations", ":", "map", "[", "core", ".", "AggregationType", "]", "core", ".", "MetricValue", "{", "}", ",", "}", ",", "}", "\n\n", "if", "ts", ",", "err", ":=", "time", ".", "Parse", "(", "time", ".", "RFC3339", ",", "rawVal", "[", "0", "]", ".", "(", "string", ")", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "rawVal", "[", "0", "]", ".", "(", "string", ")", ",", "rawRow", ".", "Name", ")", "\n", "}", "else", "{", "val", ".", "Timestamp", "=", "ts", "\n", "}", "\n\n", "// The Influx client decods numeric fields to json.Number (a string), so we have to try decoding to both types of numbers", "// Count is always a uint64", "if", "countIndex", ",", "ok", ":=", "aggregationLookup", "[", "core", ".", "AggregationTypeCount", "]", ";", "ok", "{", "if", "err", ":=", "json", ".", "Unmarshal", "(", "[", "]", "byte", "(", "rawVal", "[", "countIndex", "]", ".", "(", "json", ".", "Number", ")", ".", "String", "(", ")", ")", ",", "&", "val", ".", "Count", ")", ";", "err", "!=", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "rawRow", ".", "Name", ",", "err", ")", "\n", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "rawRow", ".", "Name", ")", "\n", "}", "\n", "}", "\n\n", "// The rest of the aggregation values can be either float or int, so attempt to parse both", "if", "err", ":=", "populateAggregations", "(", "rawRow", ".", "Name", ",", "rawVal", ",", "&", "val", ",", "aggregationLookup", ",", "wasInt", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "vals", "[", "i", "]", "=", "val", "\n", "}", "\n\n", "// figure out whether each aggregation was full of float values, or int values", "setAggregationValueTypes", "(", "vals", ",", "wasInt", ")", "\n\n", "return", "vals", ",", "nil", "\n", "}" ]

[ "parseRawQueryRow", "parses", "a", "set", "of", "timestamped", "aggregation", "values", "from", "unstructured", "JSON", "output", "into", "the", "appropriate", "Heapster", "form" ]

[ "func", "setAggregationValueIfPresent", "(", "aggName", "core", ".", "AggregationType", ",", "rawVal", "[", "]", "interface", "{", "}", ",", "aggregations", "*", "core", ".", "AggregationValue", ",", "indexLookup", "map", "[", "core", ".", "AggregationType", "]", "int", ",", "wasInt", "map", "[", "string", "]", "bool", ")", "error", "{", "if", "fieldIndex", ",", "ok", ":=", "indexLookup", "[", "aggName", "]", ";", "ok", "{", "targetValue", ":=", "&", "core", ".", "MetricValue", "{", "}", "\n", "if", "err", ":=", "tryParseMetricValue", "(", "string", "(", "aggName", ")", ",", "rawVal", ",", "targetValue", ",", "fieldIndex", ",", "wasInt", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "aggregations", ".", "Aggregations", "[", "aggName", "]", "=", "*", "targetValue", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "setAggregationValueIfPresent", "checks", "if", "the", "given", "metric", "value", "is", "present", "in", "the", "list", "of", "raw", "values", "and", "if", "so", "copies", "it", "to", "the", "output", "format" ]

[ "func", "tryParseMetricValue", "(", "aggName", "string", ",", "rawVal", "[", "]", "interface", "{", "}", ",", "targetValue", "*", "core", ".", "MetricValue", ",", "fieldIndex", "int", ",", "wasInt", "map", "[", "string", "]", "bool", ")", "error", "{", "// the Influx client decodes numeric fields to json.Number (a string), so we have to deal with that --", "// assume, starting off, that values may be either float or int. Try int until we fail once, and always", "// try float. At the end, figure out which is which.", "var", "rv", "string", "\n", "if", "rvN", ",", "ok", ":=", "rawVal", "[", "fieldIndex", "]", ".", "(", "json", ".", "Number", ")", ";", "!", "ok", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "rawVal", "[", "fieldIndex", "]", ",", "aggName", ")", "\n", "}", "else", "{", "rv", "=", "rvN", ".", "String", "(", ")", "\n", "}", "\n\n", "tryInt", ":=", "false", "\n", "isInt", ",", "triedBefore", ":=", "wasInt", "[", "aggName", "]", "\n", "tryInt", "=", "isInt", "||", "!", "triedBefore", "\n\n", "if", "tryInt", "{", "if", "err", ":=", "json", ".", "Unmarshal", "(", "[", "]", "byte", "(", "rv", ")", ",", "&", "targetValue", ".", "IntValue", ")", ";", "err", "!=", "nil", "{", "wasInt", "[", "aggName", "]", "=", "false", "\n", "}", "else", "{", "wasInt", "[", "aggName", "]", "=", "true", "\n", "}", "\n", "}", "\n\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "[", "]", "byte", "(", "rv", ")", ",", "&", "targetValue", ".", "FloatValue", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "tryParseMetricValue", "attempts", "to", "parse", "a", "raw", "metric", "value", "into", "the", "appropriate", "go", "type", "." ]

[ "func", "(", "sink", "*", "influxdbSink", ")", "GetMetricNames", "(", "metricKey", "core", ".", "HistoricalKey", ")", "(", "[", "]", "string", ",", "error", ")", "{", "if", "err", ":=", "sink", ".", "checkSanitizedKey", "(", "&", "metricKey", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "sink", ".", "stringListQuery", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "sink", ".", "keyToSelector", "(", "metricKey", ")", ")", ",", "\"", "\"", ")", "\n", "}" ]

[ "GetMetricNames", "retrieves", "the", "available", "metric", "names", "for", "the", "given", "object" ]

[ "func", "(", "sink", "*", "influxdbSink", ")", "GetNodes", "(", ")", "(", "[", "]", "string", ",", "error", ")", "{", "return", "sink", ".", "stringListQuery", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "core", ".", "LabelNodename", ".", "Key", ")", ",", "\"", "\"", ")", "\n", "}" ]

[ "GetNodes", "retrieves", "the", "list", "of", "nodes", "in", "the", "cluster" ]

[ "func", "(", "sink", "*", "influxdbSink", ")", "GetNamespaces", "(", ")", "(", "[", "]", "string", ",", "error", ")", "{", "return", "sink", ".", "stringListQuery", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "core", ".", "LabelNamespaceName", ".", "Key", ")", ",", "\"", "\"", ")", "\n", "}" ]

[ "GetNamespaces", "retrieves", "the", "list", "of", "namespaces", "in", "the", "cluster" ]

[ "func", "(", "sink", "*", "influxdbSink", ")", "GetPodsFromNamespace", "(", "namespace", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "if", "!", "nameAllowedChars", ".", "MatchString", "(", "namespace", ")", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "namespace", ")", "\n", "}", "\n", "// This is a bit difficult for the influx query language, so we cheat a bit here --", "// we just get all series for the uptime measurement for pods which match our namespace", "// (any measurement should work here, though)", "q", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "core", ".", "MetricUptime", ".", "MetricDescriptor", ".", "Name", ",", "core", ".", "LabelNamespaceName", ".", "Key", ",", "namespace", ",", "core", ".", "MetricSetTypePod", ")", "\n", "return", "sink", ".", "stringListQueryCol", "(", "q", ",", "core", ".", "LabelPodName", ".", "Key", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "namespace", ")", ")", "\n", "}" ]

[ "GetPodsFromNamespace", "retrieves", "the", "list", "of", "pods", "in", "a", "given", "namespace" ]

[ "func", "(", "sink", "*", "influxdbSink", ")", "GetSystemContainersFromNode", "(", "node", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "if", "!", "nameAllowedChars", ".", "MatchString", "(", "node", ")", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "node", ")", "\n", "}", "\n", "// This is a bit difficult for the influx query language, so we cheat a bit here --", "// we just get all series for the uptime measurement for system containers on our node", "// (any measurement should work here, though)", "q", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "core", ".", "MetricUptime", ".", "MetricDescriptor", ".", "Name", ",", "core", ".", "LabelNodename", ".", "Key", ",", "node", ",", "core", ".", "MetricSetTypeSystemContainer", ")", "\n", "return", "sink", ".", "stringListQueryCol", "(", "q", ",", "core", ".", "LabelContainerName", ".", "Key", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "node", ")", ")", "\n", "}" ]

[ "GetSystemContainersFromNode", "retrieves", "the", "list", "of", "free", "containers", "for", "a", "given", "node" ]

[ "func", "(", "sink", "*", "influxdbSink", ")", "stringListQueryCol", "(", "q", ",", "colName", "string", ",", "errStr", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "sink", ".", "RLock", "(", ")", "\n", "defer", "sink", ".", "RUnlock", "(", ")", "\n\n", "resp", ",", "err", ":=", "sink", ".", "runQuery", "(", "q", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "errStr", ")", "\n", "}", "\n\n", "if", "len", "(", "resp", "[", "0", "]", ".", "Series", ")", "<", "1", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "errStr", ")", "\n", "}", "\n\n", "colInd", ":=", "-", "1", "\n", "for", "i", ",", "col", ":=", "range", "resp", "[", "0", "]", ".", "Series", "[", "0", "]", ".", "Columns", "{", "if", "col", "==", "colName", "{", "colInd", "=", "i", "\n", "break", "\n", "}", "\n", "}", "\n\n", "if", "colInd", "==", "-", "1", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "errStr", ",", "core", ".", "LabelPodName", ".", "Key", ")", "\n", "return", "nil", ",", "fmt", ".", "Errorf", "(", "errStr", ")", "\n", "}", "\n\n", "res", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "resp", "[", "0", "]", ".", "Series", "[", "0", "]", ".", "Values", ")", ")", "\n", "for", "i", ",", "rv", ":=", "range", "resp", "[", "0", "]", ".", "Series", "[", "0", "]", ".", "Values", "{", "res", "[", "i", "]", "=", "rv", "[", "colInd", "]", ".", "(", "string", ")", "\n", "}", "\n", "return", "res", ",", "nil", "\n", "}" ]

[ "stringListQueryCol", "runs", "the", "given", "query", "and", "returns", "all", "results", "from", "the", "given", "column", "as", "a", "string", "list" ]

[ "func", "(", "sink", "*", "influxdbSink", ")", "stringListQuery", "(", "q", "string", ",", "errStr", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "sink", ".", "RLock", "(", ")", "\n", "defer", "sink", ".", "RUnlock", "(", ")", "\n\n", "resp", ",", "err", ":=", "sink", ".", "runQuery", "(", "q", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "errStr", ")", "\n", "}", "\n\n", "if", "len", "(", "resp", "[", "0", "]", ".", "Series", ")", "<", "1", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "errStr", ")", "\n", "}", "\n\n", "res", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "resp", "[", "0", "]", ".", "Series", "[", "0", "]", ".", "Values", ")", ")", "\n", "for", "i", ",", "rv", ":=", "range", "resp", "[", "0", "]", ".", "Series", "[", "0", "]", ".", "Values", "{", "res", "[", "i", "]", "=", "rv", "[", "0", "]", ".", "(", "string", ")", "\n", "}", "\n", "return", "res", ",", "nil", "\n", "}" ]

[ "stringListQuery", "runs", "the", "given", "query", "and", "returns", "all", "results", "from", "the", "first", "column", "as", "a", "string", "list" ]

[ "func", "populateAggregations", "(", "rawRowName", "string", ",", "rawVal", "[", "]", "interface", "{", "}", ",", "val", "*", "core", ".", "TimestampedAggregationValue", ",", "aggregationLookup", "map", "[", "core", ".", "AggregationType", "]", "int", ",", "wasInt", "map", "[", "string", "]", "bool", ")", "error", "{", "for", "_", ",", "aggregation", ":=", "range", "core", ".", "MultiTypedAggregations", "{", "if", "err", ":=", "setAggregationValueIfPresent", "(", "aggregation", ",", "rawVal", ",", "&", "val", ".", "AggregationValue", ",", "aggregationLookup", ",", "wasInt", ")", ";", "err", "!=", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "aggregation", ",", "rawRowName", ",", "err", ")", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "rawRowName", ")", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "populateAggregations", "extracts", "aggregation", "values", "from", "a", "given", "data", "point" ]

[ "func", "setAggregationValueTypes", "(", "vals", "[", "]", "core", ".", "TimestampedAggregationValue", ",", "wasInt", "map", "[", "string", "]", "bool", ")", "{", "for", "_", ",", "aggregation", ":=", "range", "core", ".", "MultiTypedAggregations", "{", "if", "isInt", ",", "ok", ":=", "wasInt", "[", "string", "(", "aggregation", ")", "]", ";", "ok", "&&", "isInt", "{", "for", "i", ":=", "range", "vals", "{", "val", ":=", "vals", "[", "i", "]", ".", "Aggregations", "[", "aggregation", "]", "\n", "val", ".", "ValueType", "=", "core", ".", "ValueInt64", "\n", "vals", "[", "i", "]", ".", "Aggregations", "[", "aggregation", "]", "=", "val", "\n", "}", "\n", "}", "else", "if", "ok", "{", "for", "i", ":=", "range", "vals", "{", "val", ":=", "vals", "[", "i", "]", ".", "Aggregations", "[", "aggregation", "]", "\n", "val", ".", "ValueType", "=", "core", ".", "ValueFloat", "\n", "vals", "[", "i", "]", ".", "Aggregations", "[", "aggregation", "]", "=", "val", "\n", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "setAggregationValueTypes", "inspects", "a", "set", "of", "aggregation", "values", "and", "figures", "out", "whether", "each", "aggregation", "value", "returned", "as", "a", "float", "column", "or", "an", "int", "column" ]

[ "func", "(", "sink", "*", "gcmSink", ")", "register", "(", "metrics", "[", "]", "core", ".", "Metric", ")", "error", "{", "sink", ".", "Lock", "(", ")", "\n", "defer", "sink", ".", "Unlock", "(", ")", "\n", "if", "sink", ".", "registered", "{", "return", "nil", "\n", "}", "\n\n", "for", "_", ",", "metric", ":=", "range", "metrics", "{", "metricName", ":=", "fullMetricName", "(", "sink", ".", "project", ",", "metric", ".", "MetricDescriptor", ".", "Name", ")", "\n", "metricType", ":=", "fullMetricType", "(", "metric", ".", "MetricDescriptor", ".", "Name", ")", "\n\n", "if", "_", ",", "err", ":=", "sink", ".", "gcmService", ".", "Projects", ".", "MetricDescriptors", ".", "Delete", "(", "metricName", ")", ".", "Do", "(", ")", ";", "err", "!=", "nil", "{", "glog", ".", "Infof", "(", "\"", "\"", ",", "metricName", ",", "err", ")", "\n", "}", "\n", "labels", ":=", "make", "(", "[", "]", "*", "gcm", ".", "LabelDescriptor", ",", "0", ")", "\n\n", "// Node autoscaling metrics have special labels.", "if", "core", ".", "IsNodeAutoscalingMetric", "(", "metric", ".", "MetricDescriptor", ".", "Name", ")", "{", "// All and autoscaling. Do not populate for other filters.", "if", "sink", ".", "metricFilter", "!=", "metricsAll", "&&", "sink", ".", "metricFilter", "!=", "metricsOnlyAutoscaling", "{", "continue", "\n", "}", "\n\n", "for", "_", ",", "l", ":=", "range", "core", ".", "GcmNodeAutoscalingLabels", "(", ")", "{", "labels", "=", "append", "(", "labels", ",", "&", "gcm", ".", "LabelDescriptor", "{", "Key", ":", "l", ".", "Key", ",", "Description", ":", "l", ".", "Description", ",", "}", ")", "\n", "}", "\n", "}", "else", "{", "// Only all.", "if", "sink", ".", "metricFilter", "!=", "metricsAll", "{", "continue", "\n", "}", "\n\n", "for", "_", ",", "l", ":=", "range", "core", ".", "GcmLabels", "(", ")", "{", "labels", "=", "append", "(", "labels", ",", "&", "gcm", ".", "LabelDescriptor", "{", "Key", ":", "l", ".", "Key", ",", "Description", ":", "l", ".", "Description", ",", "}", ")", "\n", "}", "\n", "}", "\n\n", "var", "metricKind", "string", "\n\n", "switch", "metric", ".", "MetricDescriptor", ".", "Type", "{", "case", "core", ".", "MetricCumulative", ":", "metricKind", "=", "\"", "\"", "\n", "case", "core", ".", "MetricGauge", ":", "metricKind", "=", "\"", "\"", "\n", "case", "core", ".", "MetricDelta", ":", "metricKind", "=", "\"", "\"", "\n", "}", "\n\n", "var", "valueType", "string", "\n\n", "switch", "metric", ".", "MetricDescriptor", ".", "ValueType", "{", "case", "core", ".", "ValueInt64", ":", "valueType", "=", "\"", "\"", "\n", "case", "core", ".", "ValueFloat", ":", "valueType", "=", "\"", "\"", "\n", "}", "\n\n", "desc", ":=", "&", "gcm", ".", "MetricDescriptor", "{", "Name", ":", "metricName", ",", "Description", ":", "metric", ".", "MetricDescriptor", ".", "Description", ",", "Labels", ":", "labels", ",", "MetricKind", ":", "metricKind", ",", "ValueType", ":", "valueType", ",", "Type", ":", "metricType", ",", "}", "\n\n", "if", "_", ",", "err", ":=", "sink", ".", "gcmService", ".", "Projects", ".", "MetricDescriptors", ".", "Create", "(", "fullProjectName", "(", "sink", ".", "project", ")", ",", "desc", ")", ".", "Do", "(", ")", ";", "err", "!=", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "desc", ".", "Name", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "}", "\n", "sink", ".", "registered", "=", "true", "\n", "return", "nil", "\n", "}" ]

[ "Adds", "the", "specified", "metrics", "or", "updates", "them", "if", "they", "already", "exist", "." ]

[ "func", "(", "this", "*", "sinkManager", ")", "ExportData", "(", "data", "*", "core", ".", "DataBatch", ")", "{", "var", "wg", "sync", ".", "WaitGroup", "\n", "for", "_", ",", "sh", ":=", "range", "this", ".", "sinkHolders", "{", "wg", ".", "Add", "(", "1", ")", "\n", "go", "func", "(", "sh", "sinkHolder", ",", "wg", "*", "sync", ".", "WaitGroup", ")", "{", "defer", "wg", ".", "Done", "(", ")", "\n", "glog", ".", "V", "(", "2", ")", ".", "Infof", "(", "\"", "\"", ",", "sh", ".", "sink", ".", "Name", "(", ")", ")", "\n", "select", "{", "case", "sh", ".", "dataBatchChannel", "<-", "data", ":", "glog", ".", "V", "(", "2", ")", ".", "Infof", "(", "\"", "\"", ",", "sh", ".", "sink", ".", "Name", "(", ")", ")", "\n", "// everything ok", "case", "<-", "time", ".", "After", "(", "this", ".", "exportDataTimeout", ")", ":", "glog", ".", "Warningf", "(", "\"", "\"", ",", "sh", ".", "sink", ".", "Name", "(", ")", ")", "\n", "}", "\n", "}", "(", "sh", ",", "&", "wg", ")", "\n", "}", "\n", "// Wait for all pushes to complete or timeout.", "wg", ".", "Wait", "(", ")", "\n", "}" ]

[ "Guarantees", "that", "the", "export", "will", "complete", "in", "sinkExportDataTimeout", "." ]

[ "func", "(", "self", "*", "KubeletClient", ")", "GetAllRawContainers", "(", "host", "Host", ",", "start", ",", "end", "time", ".", "Time", ")", "(", "[", "]", "cadvisor", ".", "ContainerInfo", ",", "error", ")", "{", "url", ":=", "self", ".", "getUrl", "(", "host", ",", "\"", "\"", ")", "\n\n", "return", "self", ".", "getAllContainers", "(", "url", ",", "start", ",", "end", ")", "\n", "}" ]

[ "Get", "stats", "for", "all", "non", "-", "Kubernetes", "containers", "." ]

[ "func", "InstrumentRouteFunc", "(", "handlerName", "string", ",", "routeFunc", "restful", ".", "RouteFunction", ")", "restful", ".", "RouteFunction", "{", "opts", ":=", "prometheus", ".", "SummaryOpts", "{", "Subsystem", ":", "\"", "\"", ",", "ConstLabels", ":", "prometheus", ".", "Labels", "{", "\"", "\"", ":", "handlerName", "}", ",", "}", "\n\n", "reqCnt", ":=", "prometheus", ".", "NewCounterVec", "(", "prometheus", ".", "CounterOpts", "{", "Subsystem", ":", "opts", ".", "Subsystem", ",", "Name", ":", "\"", "\"", ",", "Help", ":", "\"", "\"", ",", "ConstLabels", ":", "opts", ".", "ConstLabels", ",", "}", ",", "instLabels", ",", ")", "\n\n", "opts", ".", "Name", "=", "\"", "\"", "\n", "opts", ".", "Help", "=", "\"", "\"", "\n", "reqDur", ":=", "prometheus", ".", "NewSummary", "(", "opts", ")", "\n\n", "opts", ".", "Name", "=", "\"", "\"", "\n", "opts", ".", "Help", "=", "\"", "\"", "\n", "reqSz", ":=", "prometheus", ".", "NewSummary", "(", "opts", ")", "\n\n", "opts", ".", "Name", "=", "\"", "\"", "\n", "opts", ".", "Help", "=", "\"", "\"", "\n", "resSz", ":=", "prometheus", ".", "NewSummary", "(", "opts", ")", "\n\n", "regReqCnt", ":=", "prometheus", ".", "MustRegisterOrGet", "(", "reqCnt", ")", ".", "(", "*", "prometheus", ".", "CounterVec", ")", "\n", "regReqDur", ":=", "prometheus", ".", "MustRegisterOrGet", "(", "reqDur", ")", ".", "(", "prometheus", ".", "Summary", ")", "\n", "regReqSz", ":=", "prometheus", ".", "MustRegisterOrGet", "(", "reqSz", ")", ".", "(", "prometheus", ".", "Summary", ")", "\n", "regResSz", ":=", "prometheus", ".", "MustRegisterOrGet", "(", "resSz", ")", ".", "(", "prometheus", ".", "Summary", ")", "\n\n", "return", "restful", ".", "RouteFunction", "(", "func", "(", "request", "*", "restful", ".", "Request", ",", "response", "*", "restful", ".", "Response", ")", "{", "now", ":=", "time", ".", "Now", "(", ")", "\n\n", "delegate", ":=", "&", "responseWriterDelegator", "{", "ResponseWriter", ":", "response", ".", "ResponseWriter", "}", "\n", "out", ":=", "make", "(", "chan", "int", ")", "\n", "urlLen", ":=", "0", "\n", "if", "request", ".", "Request", ".", "URL", "!=", "nil", "{", "urlLen", "=", "len", "(", "request", ".", "Request", ".", "URL", ".", "String", "(", ")", ")", "\n", "}", "\n", "go", "computeApproximateRequestSize", "(", "request", ".", "Request", ",", "out", ",", "urlLen", ")", "\n\n", "_", ",", "cn", ":=", "response", ".", "ResponseWriter", ".", "(", "http", ".", "CloseNotifier", ")", "\n", "_", ",", "fl", ":=", "response", ".", "ResponseWriter", ".", "(", "http", ".", "Flusher", ")", "\n", "_", ",", "hj", ":=", "response", ".", "ResponseWriter", ".", "(", "http", ".", "Hijacker", ")", "\n", "_", ",", "rf", ":=", "response", ".", "ResponseWriter", ".", "(", "io", ".", "ReaderFrom", ")", "\n", "var", "rw", "http", ".", "ResponseWriter", "\n", "if", "cn", "&&", "fl", "&&", "hj", "&&", "rf", "{", "rw", "=", "&", "fancyResponseWriterDelegator", "{", "delegate", "}", "\n", "}", "else", "{", "rw", "=", "delegate", "\n", "}", "\n", "response", ".", "ResponseWriter", "=", "rw", "\n\n", "routeFunc", "(", "request", ",", "response", ")", "\n\n", "elapsed", ":=", "float64", "(", "time", ".", "Since", "(", "now", ")", ")", "/", "float64", "(", "time", ".", "Microsecond", ")", "\n\n", "method", ":=", "strings", ".", "ToLower", "(", "request", ".", "Request", ".", "Method", ")", "\n", "code", ":=", "strconv", ".", "Itoa", "(", "delegate", ".", "status", ")", "\n", "regReqCnt", ".", "WithLabelValues", "(", "method", ",", "code", ")", ".", "Inc", "(", ")", "\n", "regReqDur", ".", "Observe", "(", "elapsed", ")", "\n", "regResSz", ".", "Observe", "(", "float64", "(", "delegate", ".", "written", ")", ")", "\n", "regReqSz", ".", "Observe", "(", "float64", "(", "<-", "out", ")", ")", "\n", "}", ")", "\n", "}" ]

[ "InstrumentRouteFunc", "works", "like", "Prometheus", "InstrumentHandlerFunc", "but", "wraps", "the", "go", "-", "restful", "RouteFunction", "instead", "of", "a", "HandlerFunc" ]

[ "func", "PodContainerKey", "(", "namespace", ",", "podName", ",", "containerName", "string", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "namespace", ",", "podName", ",", "containerName", ")", "\n", "}" ]

[ "MetricsSet", "keys", "are", "inside", "of", "DataBatch", ".", "The", "structure", "of", "the", "returned", "string", "is", "an", "implementation", "detail", "and", "no", "component", "should", "rely", "on", "it", "as", "it", "may", "change", "anytime", ".", "It", "only", "guaranteed", "that", "it", "is", "unique", "for", "the", "unique", "combination", "of", "passed", "parameters", "." ]

[ "func", "(", "this", "*", "NamespaceBasedEnricher", ")", "addNamespaceInfo", "(", "metricSet", "*", "core", ".", "MetricSet", ")", "{", "metricSetType", ",", "found", ":=", "metricSet", ".", "Labels", "[", "core", ".", "LabelMetricSetType", ".", "Key", "]", "\n", "if", "!", "found", "{", "return", "\n", "}", "\n", "if", "metricSetType", "!=", "core", ".", "MetricSetTypePodContainer", "&&", "metricSetType", "!=", "core", ".", "MetricSetTypePod", "&&", "metricSetType", "!=", "core", ".", "MetricSetTypeNamespace", "{", "return", "\n", "}", "\n\n", "namespaceName", ",", "found", ":=", "metricSet", ".", "Labels", "[", "core", ".", "LabelNamespaceName", ".", "Key", "]", "\n", "if", "!", "found", "{", "return", "\n", "}", "\n\n", "nsObj", ",", "exists", ",", "err", ":=", "this", ".", "store", ".", "GetByKey", "(", "namespaceName", ")", "\n", "if", "exists", "&&", "err", "==", "nil", "{", "namespace", ",", "ok", ":=", "nsObj", ".", "(", "*", "kube_api", ".", "Namespace", ")", "\n", "if", "ok", "{", "metricSet", ".", "Labels", "[", "core", ".", "LabelPodNamespaceUID", ".", "Key", "]", "=", "string", "(", "namespace", ".", "UID", ")", "\n", "}", "else", "{", "glog", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "else", "if", "err", "!=", "nil", "{", "glog", ".", "Warningf", "(", "\"", "\"", ",", "namespaceName", ",", "err", ")", "\n", "}", "else", "if", "!", "exists", "{", "glog", ".", "Warningf", "(", "\"", "\"", ",", "namespaceName", ")", "\n", "}", "\n", "}" ]

[ "Adds", "UID", "to", "all", "namespaced", "elements", "." ]

[ "func", "(", "a", "*", "Api", ")", "availableClusterMetrics", "(", "request", "*", "restful", ".", "Request", ",", "response", "*", "restful", ".", "Response", ")", "{", "a", ".", "processMetricNamesRequest", "(", "core", ".", "ClusterKey", "(", ")", ",", "response", ")", "\n", "}" ]

[ "availableMetrics", "returns", "a", "list", "of", "available", "cluster", "metric", "names", "." ]

[ "func", "(", "a", "*", "Api", ")", "availableNodeMetrics", "(", "request", "*", "restful", ".", "Request", ",", "response", "*", "restful", ".", "Response", ")", "{", "a", ".", "processMetricNamesRequest", "(", "core", ".", "NodeKey", "(", "request", ".", "PathParameter", "(", "\"", "\"", ")", ")", ",", "response", ")", "\n", "}" ]

[ "availableMetrics", "returns", "a", "list", "of", "available", "node", "metric", "names", "." ]

[ "func", "(", "a", "*", "Api", ")", "availableNamespaceMetrics", "(", "request", "*", "restful", ".", "Request", ",", "response", "*", "restful", ".", "Response", ")", "{", "a", ".", "processMetricNamesRequest", "(", "core", ".", "NamespaceKey", "(", "request", ".", "PathParameter", "(", "\"", "\"", ")", ")", ",", "response", ")", "\n", "}" ]

[ "availableMetrics", "returns", "a", "list", "of", "available", "namespace", "metric", "names", "." ]

[ "func", "parseTimeParam", "(", "queryParam", "string", ",", "defaultValue", "time", ".", "Time", ")", "(", "time", ".", "Time", ",", "error", ")", "{", "if", "queryParam", "!=", "\"", "\"", "{", "reqStamp", ",", "err", ":=", "time", ".", "Parse", "(", "time", ".", "RFC3339", ",", "queryParam", ")", "\n", "if", "err", "!=", "nil", "{", "return", "time", ".", "Time", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "reqStamp", ",", "nil", "\n", "}", "\n", "return", "defaultValue", ",", "nil", "\n", "}" ]

[ "parseRequestParam", "parses", "a", "time", ".", "Time", "from", "a", "named", "QueryParam", "using", "the", "RFC3339", "format", "." ]

[ "func", "appendEvent", "(", "events", "[", "]", "riemanngo", ".", "Event", ",", "sink", "*", "RiemannSink", ",", "host", ",", "name", "string", ",", "value", "interface", "{", "}", ",", "labels", "map", "[", "string", "]", "string", ",", "timestamp", "int64", ")", "[", "]", "riemanngo", ".", "Event", "{", "event", ":=", "riemanngo", ".", "Event", "{", "Time", ":", "timestamp", ",", "Service", ":", "name", ",", "Host", ":", "host", ",", "Description", ":", "\"", "\"", ",", "Attributes", ":", "labels", ",", "Metric", ":", "value", ",", "Ttl", ":", "sink", ".", "config", ".", "Ttl", ",", "State", ":", "sink", ".", "config", ".", "State", ",", "Tags", ":", "sink", ".", "config", ".", "Tags", ",", "}", "\n", "// state everywhere", "events", "=", "append", "(", "events", ",", "event", ")", "\n", "if", "len", "(", "events", ")", ">=", "sink", ".", "config", ".", "BatchSize", "{", "err", ":=", "riemannCommon", ".", "SendData", "(", "sink", ".", "client", ",", "events", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "// client will reconnect later", "sink", ".", "client", "=", "nil", "\n", "}", "\n", "events", "=", "nil", "\n", "}", "\n", "return", "events", "\n", "}" ]

[ "Receives", "a", "list", "of", "riemanngo", ".", "Event", "the", "sink", "and", "parameters", ".", "Creates", "a", "new", "event", "using", "the", "parameters", "and", "the", "sink", "config", "and", "add", "it", "into", "the", "Event", "list", ".", "Can", "send", "events", "if", "events", "is", "full", "Return", "the", "list", "." ]

[ "func", "(", "sink", "*", "RiemannSink", ")", "ExportData", "(", "dataBatch", "*", "core", ".", "DataBatch", ")", "{", "sink", ".", "Lock", "(", ")", "\n", "defer", "sink", ".", "Unlock", "(", ")", "\n\n", "if", "sink", ".", "client", "==", "nil", "{", "// the client could be nil here, so we reconnect", "client", ",", "err", ":=", "riemannCommon", ".", "GetRiemannClient", "(", "sink", ".", "config", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n", "sink", ".", "client", "=", "client", "\n", "}", "\n\n", "var", "events", "[", "]", "riemanngo", ".", "Event", "\n\n", "for", "_", ",", "metricSet", ":=", "range", "dataBatch", ".", "MetricSets", "{", "host", ":=", "metricSet", ".", "Labels", "[", "core", ".", "LabelHostname", ".", "Key", "]", "\n", "for", "metricName", ",", "metricValue", ":=", "range", "metricSet", ".", "MetricValues", "{", "if", "value", ":=", "metricValue", ".", "GetValue", "(", ")", ";", "value", "!=", "nil", "{", "timestamp", ":=", "dataBatch", ".", "Timestamp", ".", "Unix", "(", ")", "\n", "// creates an event and add it to dataEvent", "events", "=", "appendEvent", "(", "events", ",", "sink", ",", "host", ",", "metricName", ",", "value", ",", "metricSet", ".", "Labels", ",", "timestamp", ")", "\n", "}", "\n", "}", "\n", "for", "_", ",", "metric", ":=", "range", "metricSet", ".", "LabeledMetrics", "{", "if", "value", ":=", "metric", ".", "GetValue", "(", ")", ";", "value", "!=", "nil", "{", "labels", ":=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "for", "k", ",", "v", ":=", "range", "metricSet", ".", "Labels", "{", "labels", "[", "k", "]", "=", "v", "\n", "}", "\n", "for", "k", ",", "v", ":=", "range", "metric", ".", "Labels", "{", "labels", "[", "k", "]", "=", "v", "\n", "}", "\n", "timestamp", ":=", "dataBatch", ".", "Timestamp", ".", "Unix", "(", ")", "\n", "// creates an event and add it to dataEvent", "events", "=", "appendEvent", "(", "events", ",", "sink", ",", "host", ",", "metric", ".", "Name", ",", "value", ",", "labels", ",", "timestamp", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "// Send events to Riemann if events is not empty", "if", "len", "(", "events", ")", ">", "0", "{", "err", ":=", "riemannCommon", ".", "SendData", "(", "sink", ".", "client", ",", "events", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "// client will reconnect later", "sink", ".", "client", "=", "nil", "\n", "}", "\n", "}", "\n", "}" ]

[ "ExportData", "Send", "a", "collection", "of", "Timeseries", "to", "Riemann" ]

[ "func", "(", "a", "*", "HistoricalApi", ")", "availableClusterMetrics", "(", "request", "*", "restful", ".", "Request", ",", "response", "*", "restful", ".", "Response", ")", "{", "key", ":=", "core", ".", "HistoricalKey", "{", "ObjectType", ":", "core", ".", "MetricSetTypeCluster", "}", "\n", "a", ".", "processMetricNamesRequest", "(", "key", ",", "response", ")", "\n", "}" ]

[ "availableClusterMetrics", "returns", "a", "list", "of", "available", "cluster", "metric", "names", "." ]

[ "func", "(", "a", "*", "HistoricalApi", ")", "availableNodeMetrics", "(", "request", "*", "restful", ".", "Request", ",", "response", "*", "restful", ".", "Response", ")", "{", "key", ":=", "core", ".", "HistoricalKey", "{", "ObjectType", ":", "core", ".", "MetricSetTypeNode", ",", "NodeName", ":", "request", ".", "PathParameter", "(", "\"", "\"", ")", ",", "}", "\n", "a", ".", "processMetricNamesRequest", "(", "key", ",", "response", ")", "\n", "}" ]

[ "availableNodeMetrics", "returns", "a", "list", "of", "available", "node", "metric", "names", "." ]

[ "func", "(", "a", "*", "HistoricalApi", ")", "availableNamespaceMetrics", "(", "request", "*", "restful", ".", "Request", ",", "response", "*", "restful", ".", "Response", ")", "{", "key", ":=", "core", ".", "HistoricalKey", "{", "ObjectType", ":", "core", ".", "MetricSetTypeNamespace", ",", "NamespaceName", ":", "request", ".", "PathParameter", "(", "\"", "\"", ")", ",", "}", "\n", "a", ".", "processMetricNamesRequest", "(", "key", ",", "response", ")", "\n", "}" ]

[ "availableNamespaceMetrics", "returns", "a", "list", "of", "available", "namespace", "metric", "names", "." ]

[ "func", "(", "a", "*", "HistoricalApi", ")", "availablePodMetrics", "(", "request", "*", "restful", ".", "Request", ",", "response", "*", "restful", ".", "Response", ")", "{", "key", ":=", "core", ".", "HistoricalKey", "{", "ObjectType", ":", "core", ".", "MetricSetTypePod", ",", "NamespaceName", ":", "request", ".", "PathParameter", "(", "\"", "\"", ")", ",", "PodName", ":", "request", ".", "PathParameter", "(", "\"", "\"", ")", ",", "}", "\n", "a", ".", "processMetricNamesRequest", "(", "key", ",", "response", ")", "\n", "}" ]

[ "availablePodMetrics", "returns", "a", "list", "of", "available", "pod", "metric", "names", "." ]

[ "func", "(", "a", "*", "HistoricalApi", ")", "availablePodContainerMetrics", "(", "request", "*", "restful", ".", "Request", ",", "response", "*", "restful", ".", "Response", ")", "{", "key", ":=", "core", ".", "HistoricalKey", "{", "ObjectType", ":", "core", ".", "MetricSetTypePodContainer", ",", "NamespaceName", ":", "request", ".", "PathParameter", "(", "\"", "\"", ")", ",", "PodName", ":", "request", ".", "PathParameter", "(", "\"", "\"", ")", ",", "ContainerName", ":", "request", ".", "PathParameter", "(", "\"", "\"", ")", ",", "}", "\n", "a", ".", "processMetricNamesRequest", "(", "key", ",", "response", ")", "\n", "}" ]

[ "availablePodContainerMetrics", "returns", "a", "list", "of", "available", "pod", "container", "metric", "names", "." ]

[ "func", "(", "a", "*", "HistoricalApi", ")", "availableFreeContainerMetrics", "(", "request", "*", "restful", ".", "Request", ",", "response", "*", "restful", ".", "Response", ")", "{", "key", ":=", "core", ".", "HistoricalKey", "{", "ObjectType", ":", "core", ".", "MetricSetTypeSystemContainer", ",", "NodeName", ":", "request", ".", "PathParameter", "(", "\"", "\"", ")", ",", "ContainerName", ":", "request", ".", "PathParameter", "(", "\"", "\"", ")", ",", "}", "\n", "a", ".", "processMetricNamesRequest", "(", "key", ",", "response", ")", "\n", "}" ]

[ "availableFreeContainerMetrics", "returns", "a", "list", "of", "available", "pod", "metric", "names", "." ]

[ "func", "(", "a", "*", "HistoricalApi", ")", "nodeList", "(", "request", "*", "restful", ".", "Request", ",", "response", "*", "restful", ".", "Response", ")", "{", "if", "resp", ",", "err", ":=", "a", ".", "historicalSource", ".", "GetNodes", "(", ")", ";", "err", "!=", "nil", "{", "response", ".", "WriteError", "(", "http", ".", "StatusInternalServerError", ",", "err", ")", "\n", "}", "else", "{", "response", ".", "WriteEntity", "(", "resp", ")", "\n", "}", "\n", "}" ]

[ "nodeList", "lists", "all", "nodes", "for", "which", "we", "have", "metrics" ]

[ "func", "(", "a", "*", "HistoricalApi", ")", "namespaceList", "(", "request", "*", "restful", ".", "Request", ",", "response", "*", "restful", ".", "Response", ")", "{", "if", "resp", ",", "err", ":=", "a", ".", "historicalSource", ".", "GetNamespaces", "(", ")", ";", "err", "!=", "nil", "{", "response", ".", "WriteError", "(", "http", ".", "StatusInternalServerError", ",", "err", ")", "\n", "}", "else", "{", "response", ".", "WriteEntity", "(", "resp", ")", "\n", "}", "\n", "}" ]

[ "namespaceList", "lists", "all", "namespaces", "for", "which", "we", "have", "metrics" ]

[ "func", "(", "a", "*", "HistoricalApi", ")", "namespacePodList", "(", "request", "*", "restful", ".", "Request", ",", "response", "*", "restful", ".", "Response", ")", "{", "if", "resp", ",", "err", ":=", "a", ".", "historicalSource", ".", "GetPodsFromNamespace", "(", "request", ".", "PathParameter", "(", "\"", "\"", ")", ")", ";", "err", "!=", "nil", "{", "response", ".", "WriteError", "(", "http", ".", "StatusInternalServerError", ",", "err", ")", "\n", "}", "else", "{", "response", ".", "WriteEntity", "(", "resp", ")", "\n", "}", "\n", "}" ]

[ "namespacePodList", "lists", "all", "pods", "for", "which", "we", "have", "metrics", "in", "a", "particular", "namespace" ]

[ "func", "(", "a", "*", "HistoricalApi", ")", "freeContainerMetrics", "(", "request", "*", "restful", ".", "Request", ",", "response", "*", "restful", ".", "Response", ")", "{", "key", ":=", "core", ".", "HistoricalKey", "{", "ObjectType", ":", "core", ".", "MetricSetTypeSystemContainer", ",", "NodeName", ":", "request", ".", "PathParameter", "(", "\"", "\"", ")", ",", "ContainerName", ":", "request", ".", "PathParameter", "(", "\"", "\"", ")", ",", "}", "\n", "a", ".", "processMetricRequest", "(", "key", ",", "request", ",", "response", ")", "\n", "}" ]

[ "freeContainerMetrics", "returns", "a", "metric", "timeseries", "for", "a", "metric", "of", "the", "Container", "entity", ".", "freeContainerMetrics", "addresses", "only", "free", "containers", "." ]

[ "func", "(", "a", "*", "HistoricalApi", ")", "podListMetrics", "(", "request", "*", "restful", ".", "Request", ",", "response", "*", "restful", ".", "Response", ")", "{", "start", ",", "end", ",", "err", ":=", "getStartEndTimeHistorical", "(", "request", ")", "\n", "if", "err", "!=", "nil", "{", "response", ".", "WriteError", "(", "http", ".", "StatusBadRequest", ",", "err", ")", "\n", "return", "\n", "}", "\n\n", "keys", ":=", "[", "]", "core", ".", "HistoricalKey", "{", "}", "\n", "if", "request", ".", "PathParameter", "(", "\"", "\"", ")", "!=", "\"", "\"", "{", "for", "_", ",", "podId", ":=", "range", "strings", ".", "Split", "(", "request", ".", "PathParameter", "(", "\"", "\"", ")", ",", "\"", "\"", ")", "{", "key", ":=", "core", ".", "HistoricalKey", "{", "ObjectType", ":", "core", ".", "MetricSetTypePod", ",", "PodId", ":", "podId", ",", "}", "\n", "keys", "=", "append", "(", "keys", ",", "key", ")", "\n", "}", "\n", "}", "else", "{", "for", "_", ",", "podName", ":=", "range", "strings", ".", "Split", "(", "request", ".", "PathParameter", "(", "\"", "\"", ")", ",", "\"", "\"", ")", "{", "key", ":=", "core", ".", "HistoricalKey", "{", "ObjectType", ":", "core", ".", "MetricSetTypePod", ",", "NamespaceName", ":", "request", ".", "PathParameter", "(", "\"", "\"", ")", ",", "PodName", ":", "podName", ",", "}", "\n", "keys", "=", "append", "(", "keys", ",", "key", ")", "\n", "}", "\n", "}", "\n\n", "labels", ",", "err", ":=", "getLabels", "(", "request", ")", "\n", "if", "err", "!=", "nil", "{", "response", ".", "WriteError", "(", "http", ".", "StatusBadRequest", ",", "err", ")", "\n", "return", "\n", "}", "\n\n", "metricName", ":=", "request", ".", "PathParameter", "(", "\"", "\"", ")", "\n", "convertedMetricName", ":=", "convertMetricName", "(", "metricName", ")", "\n\n", "var", "metrics", "map", "[", "core", ".", "HistoricalKey", "]", "[", "]", "core", ".", "TimestampedMetricValue", "\n", "if", "labels", "!=", "nil", "{", "metrics", ",", "err", "=", "a", ".", "historicalSource", ".", "GetLabeledMetric", "(", "convertedMetricName", ",", "labels", ",", "keys", ",", "start", ",", "end", ")", "\n", "}", "else", "{", "metrics", ",", "err", "=", "a", ".", "historicalSource", ".", "GetMetric", "(", "convertedMetricName", ",", "keys", ",", "start", ",", "end", ")", "\n", "}", "\n\n", "if", "err", "!=", "nil", "{", "response", ".", "WriteError", "(", "http", ".", "StatusInternalServerError", ",", "err", ")", "\n", "return", "\n", "}", "\n\n", "result", ":=", "types", ".", "MetricResultList", "{", "Items", ":", "make", "(", "[", "]", "types", ".", "MetricResult", ",", "0", ",", "len", "(", "keys", ")", ")", ",", "}", "\n", "for", "_", ",", "key", ":=", "range", "keys", "{", "result", ".", "Items", "=", "append", "(", "result", ".", "Items", ",", "exportTimestampedMetricValue", "(", "metrics", "[", "key", "]", ")", ")", "\n", "}", "\n", "response", ".", "PrettyPrint", "(", "false", ")", "\n", "response", ".", "WriteEntity", "(", "result", ")", "\n", "}" ]

[ "podListMetrics", "returns", "a", "list", "of", "metric", "timeseries", "for", "each", "for", "the", "listed", "nodes" ]

[ "func", "(", "a", "*", "HistoricalApi", ")", "clusterAggregations", "(", "request", "*", "restful", ".", "Request", ",", "response", "*", "restful", ".", "Response", ")", "{", "key", ":=", "core", ".", "HistoricalKey", "{", "ObjectType", ":", "core", ".", "MetricSetTypeCluster", "}", "\n", "a", ".", "processAggregationRequest", "(", "key", ",", "request", ",", "response", ")", "\n", "}" ]

[ "clusterAggregations", "returns", "a", "metric", "timeseries", "for", "a", "metric", "of", "the", "Cluster", "entity", "." ]

[ "func", "(", "a", "*", "HistoricalApi", ")", "nodeAggregations", "(", "request", "*", "restful", ".", "Request", ",", "response", "*", "restful", ".", "Response", ")", "{", "key", ":=", "core", ".", "HistoricalKey", "{", "ObjectType", ":", "core", ".", "MetricSetTypeNode", ",", "NodeName", ":", "request", ".", "PathParameter", "(", "\"", "\"", ")", ",", "}", "\n", "a", ".", "processAggregationRequest", "(", "key", ",", "request", ",", "response", ")", "\n", "}" ]

[ "nodeAggregations", "returns", "a", "metric", "timeseries", "for", "a", "metric", "of", "the", "Node", "entity", "." ]

[ "func", "(", "a", "*", "HistoricalApi", ")", "namespaceAggregations", "(", "request", "*", "restful", ".", "Request", ",", "response", "*", "restful", ".", "Response", ")", "{", "key", ":=", "core", ".", "HistoricalKey", "{", "ObjectType", ":", "core", ".", "MetricSetTypeNamespace", ",", "NamespaceName", ":", "request", ".", "PathParameter", "(", "\"", "\"", ")", ",", "}", "\n", "a", ".", "processAggregationRequest", "(", "key", ",", "request", ",", "response", ")", "\n", "}" ]

[ "namespaceAggregations", "returns", "a", "metric", "timeseries", "for", "a", "metric", "of", "the", "Namespace", "entity", "." ]

[ "func", "(", "a", "*", "HistoricalApi", ")", "podContainerAggregations", "(", "request", "*", "restful", ".", "Request", ",", "response", "*", "restful", ".", "Response", ")", "{", "var", "key", "core", ".", "HistoricalKey", "\n", "if", "request", ".", "PathParameter", "(", "\"", "\"", ")", "!=", "\"", "\"", "{", "key", "=", "core", ".", "HistoricalKey", "{", "ObjectType", ":", "core", ".", "MetricSetTypePodContainer", ",", "PodId", ":", "request", ".", "PathParameter", "(", "\"", "\"", ")", ",", "ContainerName", ":", "request", ".", "PathParameter", "(", "\"", "\"", ")", ",", "}", "\n", "}", "else", "{", "key", "=", "core", ".", "HistoricalKey", "{", "ObjectType", ":", "core", ".", "MetricSetTypePodContainer", ",", "NamespaceName", ":", "request", ".", "PathParameter", "(", "\"", "\"", ")", ",", "PodName", ":", "request", ".", "PathParameter", "(", "\"", "\"", ")", ",", "ContainerName", ":", "request", ".", "PathParameter", "(", "\"", "\"", ")", ",", "}", "\n", "}", "\n", "a", ".", "processAggregationRequest", "(", "key", ",", "request", ",", "response", ")", "\n", "}" ]

[ "podContainerAggregations", "returns", "a", "metric", "timeseries", "for", "a", "metric", "of", "a", "Pod", "Container", "entity", "." ]

[ "func", "(", "a", "*", "HistoricalApi", ")", "freeContainerAggregations", "(", "request", "*", "restful", ".", "Request", ",", "response", "*", "restful", ".", "Response", ")", "{", "key", ":=", "core", ".", "HistoricalKey", "{", "ObjectType", ":", "core", ".", "MetricSetTypeSystemContainer", ",", "NodeName", ":", "request", ".", "PathParameter", "(", "\"", "\"", ")", ",", "ContainerName", ":", "request", ".", "PathParameter", "(", "\"", "\"", ")", ",", "}", "\n", "a", ".", "processAggregationRequest", "(", "key", ",", "request", ",", "response", ")", "\n", "}" ]

[ "freeContainerAggregations", "returns", "a", "metric", "timeseries", "for", "a", "metric", "of", "the", "Container", "entity", ".", "freeContainerAggregations", "addresses", "only", "free", "containers", "." ]

[ "func", "(", "a", "*", "HistoricalApi", ")", "podListAggregations", "(", "request", "*", "restful", ".", "Request", ",", "response", "*", "restful", ".", "Response", ")", "{", "start", ",", "end", ",", "err", ":=", "getStartEndTimeHistorical", "(", "request", ")", "\n", "if", "err", "!=", "nil", "{", "response", ".", "WriteError", "(", "http", ".", "StatusBadRequest", ",", "err", ")", "\n", "return", "\n", "}", "\n", "bucketSize", ",", "err", ":=", "getBucketSize", "(", "request", ")", "\n", "if", "err", "!=", "nil", "{", "response", ".", "WriteError", "(", "http", ".", "StatusBadRequest", ",", "err", ")", "\n", "return", "\n", "}", "\n", "aggregations", ",", "err", ":=", "getAggregations", "(", "request", ")", "\n", "if", "err", "!=", "nil", "{", "response", ".", "WriteError", "(", "http", ".", "StatusBadRequest", ",", "err", ")", "\n", "return", "\n", "}", "\n", "labels", ",", "err", ":=", "getLabels", "(", "request", ")", "\n", "if", "err", "!=", "nil", "{", "response", ".", "WriteError", "(", "http", ".", "StatusBadRequest", ",", "err", ")", "\n", "return", "\n", "}", "\n", "keys", ":=", "[", "]", "core", ".", "HistoricalKey", "{", "}", "\n", "if", "request", ".", "PathParameter", "(", "\"", "\"", ")", "!=", "\"", "\"", "{", "for", "_", ",", "podId", ":=", "range", "strings", ".", "Split", "(", "request", ".", "PathParameter", "(", "\"", "\"", ")", ",", "\"", "\"", ")", "{", "key", ":=", "core", ".", "HistoricalKey", "{", "ObjectType", ":", "core", ".", "MetricSetTypePod", ",", "PodId", ":", "podId", ",", "}", "\n", "keys", "=", "append", "(", "keys", ",", "key", ")", "\n", "}", "\n", "}", "else", "{", "for", "_", ",", "podName", ":=", "range", "strings", ".", "Split", "(", "request", ".", "PathParameter", "(", "\"", "\"", ")", ",", "\"", "\"", ")", "{", "key", ":=", "core", ".", "HistoricalKey", "{", "ObjectType", ":", "core", ".", "MetricSetTypePod", ",", "NamespaceName", ":", "request", ".", "PathParameter", "(", "\"", "\"", ")", ",", "PodName", ":", "podName", ",", "}", "\n", "keys", "=", "append", "(", "keys", ",", "key", ")", "\n", "}", "\n", "}", "\n", "metricName", ":=", "request", ".", "PathParameter", "(", "\"", "\"", ")", "\n", "convertedMetricName", ":=", "convertMetricName", "(", "metricName", ")", "\n", "var", "metrics", "map", "[", "core", ".", "HistoricalKey", "]", "[", "]", "core", ".", "TimestampedAggregationValue", "\n", "if", "labels", "!=", "nil", "{", "metrics", ",", "err", "=", "a", ".", "historicalSource", ".", "GetLabeledAggregation", "(", "convertedMetricName", ",", "labels", ",", "aggregations", ",", "keys", ",", "start", ",", "end", ",", "bucketSize", ")", "\n", "}", "else", "{", "metrics", ",", "err", "=", "a", ".", "historicalSource", ".", "GetAggregation", "(", "convertedMetricName", ",", "aggregations", ",", "keys", ",", "start", ",", "end", ",", "bucketSize", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "response", ".", "WriteError", "(", "http", ".", "StatusInternalServerError", ",", "err", ")", "\n", "return", "\n", "}", "\n\n", "result", ":=", "types", ".", "MetricAggregationResultList", "{", "Items", ":", "make", "(", "[", "]", "types", ".", "MetricAggregationResult", ",", "0", ",", "len", "(", "keys", ")", ")", ",", "}", "\n", "for", "_", ",", "key", ":=", "range", "keys", "{", "result", ".", "Items", "=", "append", "(", "result", ".", "Items", ",", "exportTimestampedAggregationValue", "(", "metrics", "[", "key", "]", ")", ")", "\n", "}", "\n", "response", ".", "PrettyPrint", "(", "false", ")", "\n", "response", ".", "WriteEntity", "(", "result", ")", "\n", "}" ]

[ "podListAggregations", "returns", "a", "list", "of", "metric", "timeseries", "for", "the", "specified", "pods", "." ]

[ "func", "(", "a", "*", "HistoricalApi", ")", "processMetricRequest", "(", "key", "core", ".", "HistoricalKey", ",", "request", "*", "restful", ".", "Request", ",", "response", "*", "restful", ".", "Response", ")", "{", "start", ",", "end", ",", "err", ":=", "getStartEndTimeHistorical", "(", "request", ")", "\n", "if", "err", "!=", "nil", "{", "response", ".", "WriteError", "(", "http", ".", "StatusBadRequest", ",", "err", ")", "\n", "return", "\n", "}", "\n", "labels", ",", "err", ":=", "getLabels", "(", "request", ")", "\n", "if", "err", "!=", "nil", "{", "response", ".", "WriteError", "(", "http", ".", "StatusBadRequest", ",", "err", ")", "\n", "return", "\n", "}", "\n", "metricName", ":=", "request", ".", "PathParameter", "(", "\"", "\"", ")", "\n", "convertedMetricName", ":=", "convertMetricName", "(", "metricName", ")", "\n\n", "var", "metrics", "map", "[", "core", ".", "HistoricalKey", "]", "[", "]", "core", ".", "TimestampedMetricValue", "\n", "if", "labels", "!=", "nil", "{", "metrics", ",", "err", "=", "a", ".", "historicalSource", ".", "GetLabeledMetric", "(", "convertedMetricName", ",", "labels", ",", "[", "]", "core", ".", "HistoricalKey", "{", "key", "}", ",", "start", ",", "end", ")", "\n", "}", "else", "{", "metrics", ",", "err", "=", "a", ".", "historicalSource", ".", "GetMetric", "(", "convertedMetricName", ",", "[", "]", "core", ".", "HistoricalKey", "{", "key", "}", ",", "start", ",", "end", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "response", ".", "WriteError", "(", "http", ".", "StatusInternalServerError", ",", "err", ")", "\n", "return", "\n", "}", "\n\n", "converted", ":=", "exportTimestampedMetricValue", "(", "metrics", "[", "key", "]", ")", "\n", "response", ".", "WriteEntity", "(", "converted", ")", "\n", "}" ]

[ "processMetricRequest", "retrieves", "a", "metric", "for", "the", "object", "at", "the", "requested", "key", "." ]

[ "func", "(", "a", "*", "HistoricalApi", ")", "processMetricNamesRequest", "(", "key", "core", ".", "HistoricalKey", ",", "response", "*", "restful", ".", "Response", ")", "{", "if", "resp", ",", "err", ":=", "a", ".", "historicalSource", ".", "GetMetricNames", "(", "key", ")", ";", "err", "!=", "nil", "{", "response", ".", "WriteError", "(", "http", ".", "StatusInternalServerError", ",", "err", ")", "\n", "}", "else", "{", "response", ".", "WriteEntity", "(", "resp", ")", "\n", "}", "\n", "}" ]

[ "processMetricNamesRequest", "retrieves", "the", "available", "metrics", "for", "the", "object", "at", "the", "specified", "key", "." ]

[ "func", "getBucketSize", "(", "request", "*", "restful", ".", "Request", ")", "(", "time", ".", "Duration", ",", "error", ")", "{", "rawSize", ":=", "request", ".", "QueryParameter", "(", "\"", "\"", ")", "\n", "if", "rawSize", "==", "\"", "\"", "{", "return", "0", ",", "nil", "\n", "}", "\n\n", "if", "len", "(", "rawSize", ")", "<", "2", "{", "return", "0", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "rawSize", ")", "\n", "}", "\n", "var", "multiplier", "time", ".", "Duration", "\n", "var", "num", "string", "\n\n", "switch", "rawSize", "[", "len", "(", "rawSize", ")", "-", "1", "]", "{", "case", "'s'", ":", "// could be s or ms", "if", "len", "(", "rawSize", ")", "<", "3", "||", "rawSize", "[", "len", "(", "rawSize", ")", "-", "2", "]", "!=", "'m'", "{", "multiplier", "=", "time", ".", "Second", "\n", "num", "=", "rawSize", "[", ":", "len", "(", "rawSize", ")", "-", "1", "]", "\n", "}", "else", "{", "multiplier", "=", "time", ".", "Millisecond", "\n", "num", "=", "rawSize", "[", ":", "len", "(", "rawSize", ")", "-", "2", "]", "\n", "}", "\n", "case", "'h'", ":", "multiplier", "=", "time", ".", "Hour", "\n", "num", "=", "rawSize", "[", ":", "len", "(", "rawSize", ")", "-", "1", "]", "\n", "case", "'d'", ":", "multiplier", "=", "24", "*", "time", ".", "Hour", "\n", "num", "=", "rawSize", "[", ":", "len", "(", "rawSize", ")", "-", "1", "]", "\n", "case", "'m'", ":", "multiplier", "=", "time", ".", "Minute", "\n", "num", "=", "rawSize", "[", ":", "len", "(", "rawSize", ")", "-", "1", "]", "\n", "default", ":", "return", "0", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "rawSize", ")", "\n", "}", "\n\n", "parsedNum", ",", "err", ":=", "strconv", ".", "ParseUint", "(", "num", ",", "10", ",", "64", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "return", "time", ".", "Duration", "(", "parsedNum", ")", "*", "multiplier", ",", "nil", "\n", "}" ]

[ "getBucketSize", "parses", "the", "bucket", "size", "specifier", "into", "a" ]

[ "func", "getAggregations", "(", "request", "*", "restful", ".", "Request", ")", "(", "[", "]", "core", ".", "AggregationType", ",", "error", ")", "{", "aggregationsRaw", ":=", "strings", ".", "Split", "(", "request", ".", "PathParameter", "(", "\"", "\"", ")", ",", "\"", "\"", ")", "\n", "if", "len", "(", "aggregationsRaw", ")", "==", "0", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "aggregations", ":=", "make", "(", "[", "]", "core", ".", "AggregationType", ",", "len", "(", "aggregationsRaw", ")", ")", "\n\n", "for", "ind", ",", "aggNameRaw", ":=", "range", "aggregationsRaw", "{", "aggName", ":=", "core", ".", "AggregationType", "(", "aggNameRaw", ")", "\n", "if", "_", ",", "ok", ":=", "core", ".", "AllAggregations", "[", "aggName", "]", ";", "!", "ok", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "aggName", ")", "\n", "}", "\n", "aggregations", "[", "ind", "]", "=", "aggName", "\n", "}", "\n\n", "return", "aggregations", ",", "nil", "\n", "}" ]

[ "getAggregations", "extracts", "and", "validates", "the", "list", "of", "requested", "aggregations" ]

[ "func", "exportMetricValue", "(", "value", "*", "core", ".", "MetricValue", ")", "*", "types", ".", "MetricValue", "{", "if", "value", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "if", "value", ".", "ValueType", "==", "core", ".", "ValueInt64", "{", "return", "&", "types", ".", "MetricValue", "{", "IntValue", ":", "&", "value", ".", "IntValue", ",", "}", "\n", "}", "else", "{", "floatVal", ":=", "float64", "(", "value", ".", "FloatValue", ")", "\n", "return", "&", "types", ".", "MetricValue", "{", "FloatValue", ":", "&", "floatVal", ",", "}", "\n", "}", "\n", "}" ]

[ "exportMetricValue", "converts", "a", "core", ".", "MetricValue", "into", "an", "API", "MetricValue" ]

[ "func", "extractMetricValue", "(", "aggregations", "*", "core", ".", "AggregationValue", ",", "aggName", "core", ".", "AggregationType", ")", "*", "types", ".", "MetricValue", "{", "if", "inputVal", ",", "ok", ":=", "aggregations", ".", "Aggregations", "[", "aggName", "]", ";", "ok", "{", "return", "exportMetricValue", "(", "&", "inputVal", ")", "\n", "}", "else", "{", "return", "nil", "\n", "}", "\n", "}" ]

[ "extractMetricValue", "checks", "to", "see", "if", "the", "given", "metric", "was", "present", "in", "the", "results", "and", "if", "so", "returns", "it", "in", "API", "form" ]

[ "func", "exportTimestampedAggregationValue", "(", "values", "[", "]", "core", ".", "TimestampedAggregationValue", ")", "types", ".", "MetricAggregationResult", "{", "result", ":=", "types", ".", "MetricAggregationResult", "{", "Buckets", ":", "make", "(", "[", "]", "types", ".", "MetricAggregationBucket", ",", "0", ",", "len", "(", "values", ")", ")", ",", "BucketSize", ":", "0", ",", "}", "\n", "for", "_", ",", "value", ":=", "range", "values", "{", "// just use the largest bucket size, since all bucket sizes should be uniform", "// (except for the last one, which may be smaller)", "if", "result", ".", "BucketSize", "<", "value", ".", "BucketSize", "{", "result", ".", "BucketSize", "=", "value", ".", "BucketSize", "\n", "}", "\n\n", "bucket", ":=", "types", ".", "MetricAggregationBucket", "{", "Timestamp", ":", "value", ".", "Timestamp", ",", "Count", ":", "value", ".", "Count", ",", "Average", ":", "extractMetricValue", "(", "&", "value", ".", "AggregationValue", ",", "core", ".", "AggregationTypeAverage", ")", ",", "Maximum", ":", "extractMetricValue", "(", "&", "value", ".", "AggregationValue", ",", "core", ".", "AggregationTypeMaximum", ")", ",", "Minimum", ":", "extractMetricValue", "(", "&", "value", ".", "AggregationValue", ",", "core", ".", "AggregationTypeMinimum", ")", ",", "Median", ":", "extractMetricValue", "(", "&", "value", ".", "AggregationValue", ",", "core", ".", "AggregationTypeMedian", ")", ",", "Percentiles", ":", "make", "(", "map", "[", "string", "]", "types", ".", "MetricValue", ",", "3", ")", ",", "}", "\n\n", "if", "val", ",", "ok", ":=", "value", ".", "Aggregations", "[", "core", ".", "AggregationTypePercentile50", "]", ";", "ok", "{", "bucket", ".", "Percentiles", "[", "\"", "\"", "]", "=", "*", "exportMetricValue", "(", "&", "val", ")", "\n", "}", "\n", "if", "val", ",", "ok", ":=", "value", ".", "Aggregations", "[", "core", ".", "AggregationTypePercentile95", "]", ";", "ok", "{", "bucket", ".", "Percentiles", "[", "\"", "\"", "]", "=", "*", "exportMetricValue", "(", "&", "val", ")", "\n", "}", "\n", "if", "val", ",", "ok", ":=", "value", ".", "Aggregations", "[", "core", ".", "AggregationTypePercentile99", "]", ";", "ok", "{", "bucket", ".", "Percentiles", "[", "\"", "\"", "]", "=", "*", "exportMetricValue", "(", "&", "val", ")", "\n", "}", "\n\n", "result", ".", "Buckets", "=", "append", "(", "result", ".", "Buckets", ",", "bucket", ")", "\n", "}", "\n", "return", "result", "\n", "}" ]

[ "exportTimestampedAggregationValue", "converts", "a", "core", ".", "TimestampedAggregationValue", "into", "an", "API", "MetricAggregationResult" ]

[ "func", "(", "this", "*", "summaryMetricsSource", ")", "decodeSummary", "(", "summary", "*", "stats", ".", "Summary", ")", "map", "[", "string", "]", "*", "MetricSet", "{", "glog", ".", "V", "(", "9", ")", ".", "Infof", "(", "\"", "\"", ")", "\n", "result", ":=", "map", "[", "string", "]", "*", "MetricSet", "{", "}", "\n\n", "labels", ":=", "map", "[", "string", "]", "string", "{", "LabelNodename", ".", "Key", ":", "this", ".", "node", ".", "NodeName", ",", "LabelHostname", ".", "Key", ":", "this", ".", "node", ".", "HostName", ",", "LabelHostID", ".", "Key", ":", "this", ".", "node", ".", "HostID", ",", "}", "\n\n", "this", ".", "decodeNodeStats", "(", "result", ",", "labels", ",", "&", "summary", ".", "Node", ")", "\n", "for", "_", ",", "pod", ":=", "range", "summary", ".", "Pods", "{", "this", ".", "decodePodStats", "(", "result", ",", "labels", ",", "&", "pod", ")", "\n", "}", "\n\n", "glog", ".", "V", "(", "9", ")", ".", "Infof", "(", "\"", "\"", ")", "\n", "return", "result", "\n", "}" ]

[ "decodeSummary", "translates", "the", "kubelet", "statsSummary", "API", "into", "the", "flattened", "heapster", "MetricSet", "API", "." ]

[ "func", "(", "this", "*", "summaryMetricsSource", ")", "cloneLabels", "(", "labels", "map", "[", "string", "]", "string", ")", "map", "[", "string", "]", "string", "{", "clone", ":=", "make", "(", "map", "[", "string", "]", "string", ",", "len", "(", "labels", ")", ")", "\n", "for", "k", ",", "v", ":=", "range", "labels", "{", "clone", "[", "k", "]", "=", "v", "\n", "}", "\n", "return", "clone", "\n", "}" ]

[ "Convenience", "method", "for", "labels", "deep", "copy", "." ]

[ "func", "(", "this", "*", "summaryMetricsSource", ")", "addIntMetric", "(", "metrics", "*", "MetricSet", ",", "metric", "*", "Metric", ",", "value", "*", "uint64", ")", "{", "if", "value", "==", "nil", "{", "glog", ".", "V", "(", "9", ")", ".", "Infof", "(", "\"", "\"", ",", "metric", ".", "Name", ")", "\n", "return", "\n", "}", "\n", "val", ":=", "MetricValue", "{", "ValueType", ":", "ValueInt64", ",", "MetricType", ":", "metric", ".", "Type", ",", "IntValue", ":", "int64", "(", "*", "value", ")", ",", "}", "\n", "metrics", ".", "MetricValues", "[", "metric", ".", "Name", "]", "=", "val", "\n", "}" ]

[ "addIntMetric", "is", "a", "convenience", "method", "for", "adding", "the", "metric", "and", "value", "to", "the", "metric", "set", "." ]

[ "func", "(", "this", "*", "summaryMetricsSource", ")", "addLabeledIntMetric", "(", "metrics", "*", "MetricSet", ",", "metric", "*", "Metric", ",", "labels", "map", "[", "string", "]", "string", ",", "value", "*", "uint64", ")", "{", "if", "value", "==", "nil", "{", "glog", ".", "V", "(", "9", ")", ".", "Infof", "(", "\"", "\"", ",", "metric", ".", "Name", ",", "labels", ")", "\n", "return", "\n", "}", "\n\n", "val", ":=", "LabeledMetric", "{", "Name", ":", "metric", ".", "Name", ",", "Labels", ":", "labels", ",", "MetricValue", ":", "MetricValue", "{", "ValueType", ":", "ValueInt64", ",", "MetricType", ":", "metric", ".", "Type", ",", "IntValue", ":", "int64", "(", "*", "value", ")", ",", "}", ",", "}", "\n", "metrics", ".", "LabeledMetrics", "=", "append", "(", "metrics", ".", "LabeledMetrics", ",", "val", ")", "\n", "}" ]

[ "addLabeledIntMetric", "is", "a", "convenience", "method", "for", "adding", "the", "labeled", "metric", "and", "value", "to", "the", "metric", "set", "." ]

[ "func", "(", "this", "*", "summaryMetricsSource", ")", "getSystemContainerName", "(", "c", "*", "stats", ".", "ContainerStats", ")", "string", "{", "if", "legacyName", ",", "ok", ":=", "systemNameMap", "[", "c", ".", "Name", "]", ";", "ok", "{", "return", "legacyName", "\n", "}", "\n", "return", "c", ".", "Name", "\n", "}" ]

[ "Translate", "system", "container", "names", "to", "the", "legacy", "names", "for", "backwards", "compatibility", "." ]

[ "func", "GetRiemannClient", "(", "config", "RiemannConfig", ")", "(", "riemanngo", ".", "Client", ",", "error", ")", "{", "glog", ".", "Infof", "(", "\"", "\"", ")", "\n", "client", ":=", "riemanngo", ".", "NewTcpClient", "(", "config", ".", "Host", ")", "\n", "runtime", ".", "SetFinalizer", "(", "client", ",", "func", "(", "c", "riemanngo", ".", "Client", ")", "{", "c", ".", "Close", "(", ")", "}", ")", "\n", "// 5 seconds timeout", "err", ":=", "client", ".", "Connect", "(", "5", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "client", ",", "nil", "\n", "}" ]

[ "Receives", "a", "sink", "connect", "the", "riemann", "client", "." ]

[ "func", "SendData", "(", "client", "riemanngo", ".", "Client", ",", "events", "[", "]", "riemanngo", ".", "Event", ")", "error", "{", "// do nothing if we are not connected", "if", "client", "==", "nil", "{", "glog", ".", "Warningf", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n", "start", ":=", "time", ".", "Now", "(", ")", "\n", "_", ",", "err", ":=", "riemanngo", ".", "SendEvents", "(", "client", ",", "&", "events", ")", "\n", "end", ":=", "time", ".", "Now", "(", ")", "\n", "if", "err", "==", "nil", "{", "glog", ".", "V", "(", "4", ")", ".", "Infof", "(", "\"", "\"", ",", "len", "(", "events", ")", ",", "end", ".", "Sub", "(", "start", ")", ")", "\n", "return", "nil", "\n", "}", "else", "{", "glog", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "}" ]

[ "Send", "Events", "to", "Riemann", "using", "the", "client", "from", "the", "sink", "." ]

[ "func", "(", "this", "*", "sinkManager", ")", "ExportEvents", "(", "data", "*", "core", ".", "EventBatch", ")", "{", "var", "wg", "sync", ".", "WaitGroup", "\n", "for", "_", ",", "sh", ":=", "range", "this", ".", "sinkHolders", "{", "wg", ".", "Add", "(", "1", ")", "\n", "go", "func", "(", "sh", "sinkHolder", ",", "wg", "*", "sync", ".", "WaitGroup", ")", "{", "defer", "wg", ".", "Done", "(", ")", "\n", "glog", ".", "V", "(", "2", ")", ".", "Infof", "(", "\"", "\"", ",", "sh", ".", "sink", ".", "Name", "(", ")", ")", "\n", "select", "{", "case", "sh", ".", "eventBatchChannel", "<-", "data", ":", "glog", ".", "V", "(", "2", ")", ".", "Infof", "(", "\"", "\"", ",", "sh", ".", "sink", ".", "Name", "(", ")", ")", "\n", "// everything ok", "case", "<-", "time", ".", "After", "(", "this", ".", "exportEventsTimeout", ")", ":", "glog", ".", "Warningf", "(", "\"", "\"", ",", "sh", ".", "sink", ".", "Name", "(", ")", ")", "\n", "}", "\n", "}", "(", "sh", ",", "&", "wg", ")", "\n", "}", "\n", "// Wait for all pushes to complete or timeout.", "wg", ".", "Wait", "(", ")", "\n", "}" ]

[ "Guarantees", "that", "the", "export", "will", "complete", "in", "exportEventsTimeout", "." ]

[ "func", "(", "h", "*", "hawkularSink", ")", "cache", "(", "md", "*", "metrics", ".", "MetricDefinition", ")", "{", "h", ".", "pushToCache", "(", "md", ".", "ID", ",", "hashDefinition", "(", "md", ")", ")", "\n", "}" ]

[ "cache", "inserts", "the", "item", "to", "the", "cache" ]

[ "func", "(", "h", "*", "hawkularSink", ")", "pushToCache", "(", "key", "string", ",", "hash", "uint64", ")", "{", "h", ".", "regLock", ".", "Lock", "(", ")", "\n", "h", ".", "expReg", "[", "key", "]", "=", "&", "expiringItem", "{", "hash", ":", "hash", ",", "ttl", ":", "h", ".", "runId", ",", "}", "\n", "h", ".", "regLock", ".", "Unlock", "(", ")", "\n", "}" ]

[ "toCache", "inserts", "the", "item", "and", "updates", "the", "TTL", "in", "the", "cache", "to", "current", "time" ]