repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
list | docstring
stringlengths 6
2.61k
| docstring_tokens
list | sha
stringlengths 40
40
| url
stringlengths 85
252
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
anacrolix/torrent
|
torrent.go
|
bytesCompleted
|
func (t *Torrent) bytesCompleted() int64 {
if !t.haveInfo() {
return 0
}
return t.info.TotalLength() - t.bytesLeft()
}
|
go
|
func (t *Torrent) bytesCompleted() int64 {
if !t.haveInfo() {
return 0
}
return t.info.TotalLength() - t.bytesLeft()
}
|
[
"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.
|
[
"Don",
"t",
"call",
"this",
"before",
"the",
"info",
"is",
"available",
"."
] |
d2400968fc54c3d8a6482d4ca5ff16cc5e5139cb
|
https://github.com/anacrolix/torrent/blob/d2400968fc54c3d8a6482d4ca5ff16cc5e5139cb/torrent.go#L1162-L1167
|
train
|
anacrolix/torrent
|
torrent.go
|
deleteConnection
|
func (t *Torrent) deleteConnection(c *connection) (ret bool) {
if !c.closed.IsSet() {
panic("connection is not closed")
// There are behaviours prevented by the closed state that will fail
// if the connection has been deleted.
}
_, ret = t.conns[c]
delete(t.conns, c)
torrent.Add("deleted connections", 1)
c.deleteAllRequests()
if len(t.conns) == 0 {
t.assertNoPendingRequests()
}
return
}
|
go
|
func (t *Torrent) deleteConnection(c *connection) (ret bool) {
if !c.closed.IsSet() {
panic("connection is not closed")
// There are behaviours prevented by the closed state that will fail
// if the connection has been deleted.
}
_, ret = t.conns[c]
delete(t.conns, c)
torrent.Add("deleted connections", 1)
c.deleteAllRequests()
if len(t.conns) == 0 {
t.assertNoPendingRequests()
}
return
}
|
[
"func",
"(",
"t",
"*",
"Torrent",
")",
"deleteConnection",
"(",
"c",
"*",
"connection",
")",
"(",
"ret",
"bool",
")",
"{",
"if",
"!",
"c",
".",
"closed",
".",
"IsSet",
"(",
")",
"{",
"panic",
"(",
"\"connection is not closed\"",
")",
"\n",
"}",
"\n",
"_",
",",
"ret",
"=",
"t",
".",
"conns",
"[",
"c",
"]",
"\n",
"delete",
"(",
"t",
".",
"conns",
",",
"c",
")",
"\n",
"torrent",
".",
"Add",
"(",
"\"deleted connections\"",
",",
"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.
|
[
"Returns",
"true",
"if",
"connection",
"is",
"removed",
"from",
"torrent",
".",
"Conns",
"."
] |
d2400968fc54c3d8a6482d4ca5ff16cc5e5139cb
|
https://github.com/anacrolix/torrent/blob/d2400968fc54c3d8a6482d4ca5ff16cc5e5139cb/torrent.go#L1176-L1190
|
train
|
anacrolix/torrent
|
torrent.go
|
seeding
|
func (t *Torrent) seeding() bool {
cl := t.cl
if t.closed.IsSet() {
return false
}
if cl.config.NoUpload {
return false
}
if !cl.config.Seed {
return false
}
if cl.config.DisableAggressiveUpload && t.needData() {
return false
}
return true
}
|
go
|
func (t *Torrent) seeding() bool {
cl := t.cl
if t.closed.IsSet() {
return false
}
if cl.config.NoUpload {
return false
}
if !cl.config.Seed {
return false
}
if cl.config.DisableAggressiveUpload && t.needData() {
return false
}
return true
}
|
[
"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.
|
[
"Returns",
"whether",
"the",
"client",
"should",
"make",
"effort",
"to",
"seed",
"the",
"torrent",
"."
] |
d2400968fc54c3d8a6482d4ca5ff16cc5e5139cb
|
https://github.com/anacrolix/torrent/blob/d2400968fc54c3d8a6482d4ca5ff16cc5e5139cb/torrent.go#L1228-L1243
|
train
|
anacrolix/torrent
|
torrent.go
|
startMissingTrackerScrapers
|
func (t *Torrent) startMissingTrackerScrapers() {
if t.cl.config.DisableTrackers {
return
}
t.startScrapingTracker(t.metainfo.Announce)
for _, tier := range t.metainfo.AnnounceList {
for _, url := range tier {
t.startScrapingTracker(url)
}
}
}
|
go
|
func (t *Torrent) startMissingTrackerScrapers() {
if t.cl.config.DisableTrackers {
return
}
t.startScrapingTracker(t.metainfo.Announce)
for _, tier := range t.metainfo.AnnounceList {
for _, url := range tier {
t.startScrapingTracker(url)
}
}
}
|
[
"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.
|
[
"Adds",
"and",
"starts",
"tracker",
"scrapers",
"for",
"tracker",
"URLs",
"that",
"aren",
"t",
"already",
"running",
"."
] |
d2400968fc54c3d8a6482d4ca5ff16cc5e5139cb
|
https://github.com/anacrolix/torrent/blob/d2400968fc54c3d8a6482d4ca5ff16cc5e5139cb/torrent.go#L1287-L1297
|
train
|
anacrolix/torrent
|
torrent.go
|
announceRequest
|
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(),
}
}
|
go
|
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(),
}
}
|
[
"func",
"(",
"t",
"*",
"Torrent",
")",
"announceRequest",
"(",
")",
"tracker",
".",
"AnnounceRequest",
"{",
"return",
"tracker",
".",
"AnnounceRequest",
"{",
"Event",
":",
"tracker",
".",
"None",
",",
"NumWant",
":",
"-",
"1",
",",
"Port",
":",
"uint16",
"(",
"t",
".",
"cl",
".",
"incomingPeerPort",
"(",
")",
")",
",",
"PeerId",
":",
"t",
".",
"cl",
".",
"peerID",
",",
"InfoHash",
":",
"t",
".",
"infoHash",
",",
"Key",
":",
"t",
".",
"cl",
".",
"announceKey",
"(",
")",
",",
"Left",
":",
"t",
".",
"bytesLeftAnnounce",
"(",
")",
",",
"Uploaded",
":",
"t",
".",
"stats",
".",
"BytesWrittenData",
".",
"Int64",
"(",
")",
",",
"Downloaded",
":",
"t",
".",
"stats",
".",
"BytesReadUsefulData",
".",
"Int64",
"(",
")",
",",
"}",
"\n",
"}"
] |
// Returns an AnnounceRequest with fields filled out to defaults and current
// values.
|
[
"Returns",
"an",
"AnnounceRequest",
"with",
"fields",
"filled",
"out",
"to",
"defaults",
"and",
"current",
"values",
"."
] |
d2400968fc54c3d8a6482d4ca5ff16cc5e5139cb
|
https://github.com/anacrolix/torrent/blob/d2400968fc54c3d8a6482d4ca5ff16cc5e5139cb/torrent.go#L1301-L1319
|
train
|
anacrolix/torrent
|
torrent.go
|
consumeDhtAnnouncePeers
|
func (t *Torrent) consumeDhtAnnouncePeers(pvs <-chan dht.PeersValues) {
cl := t.cl
for v := range pvs {
cl.lock()
for _, cp := range v.Peers {
if cp.Port == 0 {
// Can't do anything with this.
continue
}
t.addPeer(Peer{
IP: cp.IP[:],
Port: cp.Port,
Source: peerSourceDHTGetPeers,
})
}
cl.unlock()
}
}
|
go
|
func (t *Torrent) consumeDhtAnnouncePeers(pvs <-chan dht.PeersValues) {
cl := t.cl
for v := range pvs {
cl.lock()
for _, cp := range v.Peers {
if cp.Port == 0 {
// Can't do anything with this.
continue
}
t.addPeer(Peer{
IP: cp.IP[:],
Port: cp.Port,
Source: peerSourceDHTGetPeers,
})
}
cl.unlock()
}
}
|
[
"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",
"{",
"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.
|
[
"Adds",
"peers",
"revealed",
"in",
"an",
"announce",
"until",
"the",
"announce",
"ends",
"or",
"we",
"have",
"enough",
"peers",
"."
] |
d2400968fc54c3d8a6482d4ca5ff16cc5e5139cb
|
https://github.com/anacrolix/torrent/blob/d2400968fc54c3d8a6482d4ca5ff16cc5e5139cb/torrent.go#L1323-L1340
|
train
|
anacrolix/torrent
|
torrent.go
|
numTotalPeers
|
func (t *Torrent) numTotalPeers() int {
peers := make(map[string]struct{})
for conn := range t.conns {
ra := conn.conn.RemoteAddr()
if ra == nil {
// It's been closed and doesn't support RemoteAddr.
continue
}
peers[ra.String()] = struct{}{}
}
for addr := range t.halfOpen {
peers[addr] = struct{}{}
}
t.peers.Each(func(peer Peer) {
peers[fmt.Sprintf("%s:%d", peer.IP, peer.Port)] = struct{}{}
})
return len(peers)
}
|
go
|
func (t *Torrent) numTotalPeers() int {
peers := make(map[string]struct{})
for conn := range t.conns {
ra := conn.conn.RemoteAddr()
if ra == nil {
// It's been closed and doesn't support RemoteAddr.
continue
}
peers[ra.String()] = struct{}{}
}
for addr := range t.halfOpen {
peers[addr] = struct{}{}
}
t.peers.Each(func(peer Peer) {
peers[fmt.Sprintf("%s:%d", peer.IP, peer.Port)] = struct{}{}
})
return len(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",
"{",
"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",
"(",
"\"%s:%d\"",
",",
"peer",
".",
"IP",
",",
"peer",
".",
"Port",
")",
"]",
"=",
"struct",
"{",
"}",
"{",
"}",
"\n",
"}",
")",
"\n",
"return",
"len",
"(",
"peers",
")",
"\n",
"}"
] |
// The total number of peers in the torrent.
|
[
"The",
"total",
"number",
"of",
"peers",
"in",
"the",
"torrent",
"."
] |
d2400968fc54c3d8a6482d4ca5ff16cc5e5139cb
|
https://github.com/anacrolix/torrent/blob/d2400968fc54c3d8a6482d4ca5ff16cc5e5139cb/torrent.go#L1402-L1419
|
train
|
anacrolix/torrent
|
torrent.go
|
reconcileHandshakeStats
|
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("bad stats")
}
c.postHandshakeStats(func(cs *ConnStats) {
cs.BytesRead.Add(c.stats.BytesRead.Int64())
cs.BytesWritten.Add(c.stats.BytesWritten.Int64())
})
c.reconciledHandshakeStats = true
}
|
go
|
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("bad stats")
}
c.postHandshakeStats(func(cs *ConnStats) {
cs.BytesRead.Add(c.stats.BytesRead.Int64())
cs.BytesWritten.Add(c.stats.BytesWritten.Int64())
})
c.reconciledHandshakeStats = true
}
|
[
"func",
"(",
"t",
"*",
"Torrent",
")",
"reconcileHandshakeStats",
"(",
"c",
"*",
"connection",
")",
"{",
"if",
"c",
".",
"stats",
"!=",
"(",
"ConnStats",
"{",
"BytesWritten",
":",
"c",
".",
"stats",
".",
"BytesWritten",
",",
"BytesRead",
":",
"c",
".",
"stats",
".",
"BytesRead",
",",
"}",
")",
"{",
"panic",
"(",
"\"bad stats\"",
")",
"\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.
|
[
"Reconcile",
"bytes",
"transferred",
"before",
"connection",
"was",
"associated",
"with",
"a",
"torrent",
"."
] |
d2400968fc54c3d8a6482d4ca5ff16cc5e5139cb
|
https://github.com/anacrolix/torrent/blob/d2400968fc54c3d8a6482d4ca5ff16cc5e5139cb/torrent.go#L1423-L1436
|
train
|
anacrolix/torrent
|
torrent.go
|
addConnection
|
func (t *Torrent) addConnection(c *connection) (err error) {
defer func() {
if err == nil {
torrent.Add("added connections", 1)
}
}()
if t.closed.IsSet() {
return errors.New("torrent closed")
}
for c0 := range t.conns {
if c.PeerID != c0.PeerID {
continue
}
if !t.cl.config.dropDuplicatePeerIds {
continue
}
if left, ok := c.hasPreferredNetworkOver(c0); ok && left {
c0.Close()
t.deleteConnection(c0)
} else {
return errors.New("existing connection preferred")
}
}
if len(t.conns) >= t.maxEstablishedConns {
c := t.worstBadConn()
if c == nil {
return errors.New("don't want conns")
}
c.Close()
t.deleteConnection(c)
}
if len(t.conns) >= t.maxEstablishedConns {
panic(len(t.conns))
}
t.conns[c] = struct{}{}
return nil
}
|
go
|
func (t *Torrent) addConnection(c *connection) (err error) {
defer func() {
if err == nil {
torrent.Add("added connections", 1)
}
}()
if t.closed.IsSet() {
return errors.New("torrent closed")
}
for c0 := range t.conns {
if c.PeerID != c0.PeerID {
continue
}
if !t.cl.config.dropDuplicatePeerIds {
continue
}
if left, ok := c.hasPreferredNetworkOver(c0); ok && left {
c0.Close()
t.deleteConnection(c0)
} else {
return errors.New("existing connection preferred")
}
}
if len(t.conns) >= t.maxEstablishedConns {
c := t.worstBadConn()
if c == nil {
return errors.New("don't want conns")
}
c.Close()
t.deleteConnection(c)
}
if len(t.conns) >= t.maxEstablishedConns {
panic(len(t.conns))
}
t.conns[c] = struct{}{}
return nil
}
|
[
"func",
"(",
"t",
"*",
"Torrent",
")",
"addConnection",
"(",
"c",
"*",
"connection",
")",
"(",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"err",
"==",
"nil",
"{",
"torrent",
".",
"Add",
"(",
"\"added connections\"",
",",
"1",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"if",
"t",
".",
"closed",
".",
"IsSet",
"(",
")",
"{",
"return",
"errors",
".",
"New",
"(",
"\"torrent closed\"",
")",
"\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",
"(",
"\"existing connection preferred\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"t",
".",
"conns",
")",
">=",
"t",
".",
"maxEstablishedConns",
"{",
"c",
":=",
"t",
".",
"worstBadConn",
"(",
")",
"\n",
"if",
"c",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"don't want conns\"",
")",
"\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.
|
[
"Returns",
"true",
"if",
"the",
"connection",
"is",
"added",
"."
] |
d2400968fc54c3d8a6482d4ca5ff16cc5e5139cb
|
https://github.com/anacrolix/torrent/blob/d2400968fc54c3d8a6482d4ca5ff16cc5e5139cb/torrent.go#L1439-L1475
|
train
|
anacrolix/torrent
|
torrent.go
|
onIncompletePiece
|
func (t *Torrent) onIncompletePiece(piece pieceIndex) {
if t.pieceAllDirty(piece) {
t.pendAllChunkSpecs(piece)
}
if !t.wantPieceIndex(piece) {
// t.logger.Printf("piece %d incomplete and unwanted", piece)
return
}
// 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 {
// if c.sentHave(piece) {
// c.Drop()
// }
// }
for conn := range t.conns {
if conn.PeerHasPiece(piece) {
conn.updateRequests()
}
}
}
|
go
|
func (t *Torrent) onIncompletePiece(piece pieceIndex) {
if t.pieceAllDirty(piece) {
t.pendAllChunkSpecs(piece)
}
if !t.wantPieceIndex(piece) {
// t.logger.Printf("piece %d incomplete and unwanted", piece)
return
}
// 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 {
// if c.sentHave(piece) {
// c.Drop()
// }
// }
for conn := range t.conns {
if conn.PeerHasPiece(piece) {
conn.updateRequests()
}
}
}
|
[
"func",
"(",
"t",
"*",
"Torrent",
")",
"onIncompletePiece",
"(",
"piece",
"pieceIndex",
")",
"{",
"if",
"t",
".",
"pieceAllDirty",
"(",
"piece",
")",
"{",
"t",
".",
"pendAllChunkSpecs",
"(",
"piece",
")",
"\n",
"}",
"\n",
"if",
"!",
"t",
".",
"wantPieceIndex",
"(",
"piece",
")",
"{",
"return",
"\n",
"}",
"\n",
"for",
"conn",
":=",
"range",
"t",
".",
"conns",
"{",
"if",
"conn",
".",
"PeerHasPiece",
"(",
"piece",
")",
"{",
"conn",
".",
"updateRequests",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Called when a piece is found to be not complete.
|
[
"Called",
"when",
"a",
"piece",
"is",
"found",
"to",
"be",
"not",
"complete",
"."
] |
d2400968fc54c3d8a6482d4ca5ff16cc5e5139cb
|
https://github.com/anacrolix/torrent/blob/d2400968fc54c3d8a6482d4ca5ff16cc5e5139cb/torrent.go#L1580-L1604
|
train
|
anacrolix/torrent
|
torrent.go
|
reapPieceTouchers
|
func (t *Torrent) reapPieceTouchers(piece pieceIndex) (ret []*connection) {
for c := range t.pieces[piece].dirtiers {
delete(c.peerTouchedPieces, piece)
ret = append(ret, c)
}
t.pieces[piece].dirtiers = nil
return
}
|
go
|
func (t *Torrent) reapPieceTouchers(piece pieceIndex) (ret []*connection) {
for c := range t.pieces[piece].dirtiers {
delete(c.peerTouchedPieces, piece)
ret = append(ret, c)
}
t.pieces[piece].dirtiers = nil
return
}
|
[
"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.
|
[
"Return",
"the",
"connections",
"that",
"touched",
"a",
"piece",
"and",
"clear",
"the",
"entries",
"while",
"doing",
"it",
"."
] |
d2400968fc54c3d8a6482d4ca5ff16cc5e5139cb
|
https://github.com/anacrolix/torrent/blob/d2400968fc54c3d8a6482d4ca5ff16cc5e5139cb/torrent.go#L1641-L1648
|
train
|
anacrolix/torrent
|
torrent.go
|
queuePieceCheck
|
func (t *Torrent) queuePieceCheck(pieceIndex pieceIndex) {
piece := &t.pieces[pieceIndex]
if piece.queuedForHash() {
return
}
t.piecesQueuedForHash.Add(bitmap.BitIndex(pieceIndex))
t.publishPieceChange(pieceIndex)
t.updatePiecePriority(pieceIndex)
go t.verifyPiece(pieceIndex)
}
|
go
|
func (t *Torrent) queuePieceCheck(pieceIndex pieceIndex) {
piece := &t.pieces[pieceIndex]
if piece.queuedForHash() {
return
}
t.piecesQueuedForHash.Add(bitmap.BitIndex(pieceIndex))
t.publishPieceChange(pieceIndex)
t.updatePiecePriority(pieceIndex)
go t.verifyPiece(pieceIndex)
}
|
[
"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.
|
[
"Currently",
"doesn",
"t",
"really",
"queue",
"but",
"should",
"in",
"the",
"future",
"."
] |
d2400968fc54c3d8a6482d4ca5ff16cc5e5139cb
|
https://github.com/anacrolix/torrent/blob/d2400968fc54c3d8a6482d4ca5ff16cc5e5139cb/torrent.go#L1658-L1667
|
train
|
anacrolix/torrent
|
torrent.go
|
initiateConn
|
func (t *Torrent) initiateConn(peer Peer) {
if peer.Id == t.cl.peerID {
return
}
if t.cl.badPeerIPPort(peer.IP, peer.Port) {
return
}
addr := IpPort{peer.IP, uint16(peer.Port)}
if t.addrActive(addr.String()) {
return
}
t.halfOpen[addr.String()] = peer
go t.cl.outgoingConnection(t, addr, peer.Source)
}
|
go
|
func (t *Torrent) initiateConn(peer Peer) {
if peer.Id == t.cl.peerID {
return
}
if t.cl.badPeerIPPort(peer.IP, peer.Port) {
return
}
addr := IpPort{peer.IP, uint16(peer.Port)}
if t.addrActive(addr.String()) {
return
}
t.halfOpen[addr.String()] = peer
go t.cl.outgoingConnection(t, addr, peer.Source)
}
|
[
"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.
|
[
"Start",
"the",
"process",
"of",
"connecting",
"to",
"the",
"given",
"peer",
"for",
"the",
"given",
"torrent",
"if",
"appropriate",
"."
] |
d2400968fc54c3d8a6482d4ca5ff16cc5e5139cb
|
https://github.com/anacrolix/torrent/blob/d2400968fc54c3d8a6482d4ca5ff16cc5e5139cb/torrent.go#L1677-L1690
|
train
|
anacrolix/torrent
|
torrent.go
|
allStats
|
func (t *Torrent) allStats(f func(*ConnStats)) {
f(&t.stats)
f(&t.cl.stats)
}
|
go
|
func (t *Torrent) allStats(f func(*ConnStats)) {
f(&t.stats)
f(&t.cl.stats)
}
|
[
"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.
|
[
"All",
"stats",
"that",
"include",
"this",
"Torrent",
".",
"Useful",
"when",
"we",
"want",
"to",
"increment",
"ConnStats",
"but",
"not",
"for",
"every",
"connection",
"."
] |
d2400968fc54c3d8a6482d4ca5ff16cc5e5139cb
|
https://github.com/anacrolix/torrent/blob/d2400968fc54c3d8a6482d4ca5ff16cc5e5139cb/torrent.go#L1706-L1709
|
train
|
anacrolix/torrent
|
metainfo/info.go
|
BuildFromFilePath
|
func (info *Info) BuildFromFilePath(root string) (err error) {
info.Name = filepath.Base(root)
info.Files = nil
err = filepath.Walk(root, func(path string, fi os.FileInfo, err error) error {
if err != nil {
return err
}
if fi.IsDir() {
// Directories are implicit in torrent files.
return nil
} else if path == root {
// The root is a file.
info.Length = fi.Size()
return nil
}
relPath, err := filepath.Rel(root, path)
if err != nil {
return fmt.Errorf("error getting relative path: %s", err)
}
info.Files = append(info.Files, FileInfo{
Path: strings.Split(relPath, string(filepath.Separator)),
Length: fi.Size(),
})
return nil
})
if err != nil {
return
}
slices.Sort(info.Files, func(l, r FileInfo) bool {
return strings.Join(l.Path, "/") < strings.Join(r.Path, "/")
})
err = info.GeneratePieces(func(fi FileInfo) (io.ReadCloser, error) {
return os.Open(filepath.Join(root, strings.Join(fi.Path, string(filepath.Separator))))
})
if err != nil {
err = fmt.Errorf("error generating pieces: %s", err)
}
return
}
|
go
|
func (info *Info) BuildFromFilePath(root string) (err error) {
info.Name = filepath.Base(root)
info.Files = nil
err = filepath.Walk(root, func(path string, fi os.FileInfo, err error) error {
if err != nil {
return err
}
if fi.IsDir() {
// Directories are implicit in torrent files.
return nil
} else if path == root {
// The root is a file.
info.Length = fi.Size()
return nil
}
relPath, err := filepath.Rel(root, path)
if err != nil {
return fmt.Errorf("error getting relative path: %s", err)
}
info.Files = append(info.Files, FileInfo{
Path: strings.Split(relPath, string(filepath.Separator)),
Length: fi.Size(),
})
return nil
})
if err != nil {
return
}
slices.Sort(info.Files, func(l, r FileInfo) bool {
return strings.Join(l.Path, "/") < strings.Join(r.Path, "/")
})
err = info.GeneratePieces(func(fi FileInfo) (io.ReadCloser, error) {
return os.Open(filepath.Join(root, strings.Join(fi.Path, string(filepath.Separator))))
})
if err != nil {
err = fmt.Errorf("error generating pieces: %s", err)
}
return
}
|
[
"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",
"(",
")",
"{",
"return",
"nil",
"\n",
"}",
"else",
"if",
"path",
"==",
"root",
"{",
"info",
".",
"Length",
"=",
"fi",
".",
"Size",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"relPath",
",",
"err",
":=",
"filepath",
".",
"Rel",
"(",
"root",
",",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"error getting relative path: %s\"",
",",
"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",
"(",
"\"error generating pieces: %s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// This is a helper that sets Files and Pieces from a root path and its
// children.
|
[
"This",
"is",
"a",
"helper",
"that",
"sets",
"Files",
"and",
"Pieces",
"from",
"a",
"root",
"path",
"and",
"its",
"children",
"."
] |
d2400968fc54c3d8a6482d4ca5ff16cc5e5139cb
|
https://github.com/anacrolix/torrent/blob/d2400968fc54c3d8a6482d4ca5ff16cc5e5139cb/metainfo/info.go#L29-L67
|
train
|
anacrolix/torrent
|
metainfo/info.go
|
writeFiles
|
func (info *Info) writeFiles(w io.Writer, open func(fi FileInfo) (io.ReadCloser, error)) error {
for _, fi := range info.UpvertedFiles() {
r, err := open(fi)
if err != nil {
return fmt.Errorf("error opening %v: %s", fi, err)
}
wn, err := io.CopyN(w, r, fi.Length)
r.Close()
if wn != fi.Length {
return fmt.Errorf("error copying %v: %s", fi, err)
}
}
return nil
}
|
go
|
func (info *Info) writeFiles(w io.Writer, open func(fi FileInfo) (io.ReadCloser, error)) error {
for _, fi := range info.UpvertedFiles() {
r, err := open(fi)
if err != nil {
return fmt.Errorf("error opening %v: %s", fi, err)
}
wn, err := io.CopyN(w, r, fi.Length)
r.Close()
if wn != fi.Length {
return fmt.Errorf("error copying %v: %s", fi, err)
}
}
return nil
}
|
[
"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",
"(",
"\"error opening %v: %s\"",
",",
"fi",
",",
"err",
")",
"\n",
"}",
"\n",
"wn",
",",
"err",
":=",
"io",
".",
"CopyN",
"(",
"w",
",",
"r",
",",
"fi",
".",
"Length",
")",
"\n",
"r",
".",
"Close",
"(",
")",
"\n",
"if",
"wn",
"!=",
"fi",
".",
"Length",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"error copying %v: %s\"",
",",
"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.
|
[
"Concatenates",
"all",
"the",
"files",
"in",
"the",
"torrent",
"into",
"w",
".",
"open",
"is",
"a",
"function",
"that",
"gets",
"at",
"the",
"contents",
"of",
"the",
"given",
"file",
"."
] |
d2400968fc54c3d8a6482d4ca5ff16cc5e5139cb
|
https://github.com/anacrolix/torrent/blob/d2400968fc54c3d8a6482d4ca5ff16cc5e5139cb/metainfo/info.go#L71-L84
|
train
|
anacrolix/torrent
|
metainfo/info.go
|
UpvertedFiles
|
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,
}}
}
return info.Files
}
|
go
|
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,
}}
}
return info.Files
}
|
[
"func",
"(",
"info",
"*",
"Info",
")",
"UpvertedFiles",
"(",
")",
"[",
"]",
"FileInfo",
"{",
"if",
"len",
"(",
"info",
".",
"Files",
")",
"==",
"0",
"{",
"return",
"[",
"]",
"FileInfo",
"{",
"{",
"Length",
":",
"info",
".",
"Length",
",",
"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.
|
[
"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",
"."
] |
d2400968fc54c3d8a6482d4ca5ff16cc5e5139cb
|
https://github.com/anacrolix/torrent/blob/d2400968fc54c3d8a6482d4ca5ff16cc5e5139cb/metainfo/info.go#L142-L152
|
train
|
kubernetes-retired/heapster
|
metrics/util/label_copier.go
|
makeStoredLabels
|
func makeStoredLabels(labels []string) map[string]string {
storedLabels := make(map[string]string)
for _, s := range labels {
split := strings.SplitN(s, "=", 2)
if len(split) == 1 {
storedLabels[split[0]] = split[0]
} else {
storedLabels[split[1]] = split[0]
}
}
return storedLabels
}
|
go
|
func makeStoredLabels(labels []string) map[string]string {
storedLabels := make(map[string]string)
for _, s := range labels {
split := strings.SplitN(s, "=", 2)
if len(split) == 1 {
storedLabels[split[0]] = split[0]
} else {
storedLabels[split[1]] = split[0]
}
}
return storedLabels
}
|
[
"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"
|
[
"makeStoredLabels",
"converts",
"labels",
"into",
"a",
"map",
"for",
"quicker",
"retrieval",
".",
"Incoming",
"labels",
"if",
"desired",
"may",
"contain",
"mappings",
"in",
"format",
"newName",
"=",
"oldName"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/util/label_copier.go#L56-L67
|
train
|
kubernetes-retired/heapster
|
metrics/util/label_copier.go
|
makeIgnoredLabels
|
func makeIgnoredLabels(labels []string) map[string]string {
ignoredLabels := make(map[string]string)
for _, s := range labels {
ignoredLabels[s] = ""
}
return ignoredLabels
}
|
go
|
func makeIgnoredLabels(labels []string) map[string]string {
ignoredLabels := make(map[string]string)
for _, s := range labels {
ignoredLabels[s] = ""
}
return ignoredLabels
}
|
[
"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.
|
[
"makeIgnoredLabels",
"converts",
"label",
"slice",
"into",
"a",
"map",
"for",
"later",
"use",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/util/label_copier.go#L70-L76
|
train
|
kubernetes-retired/heapster
|
metrics/util/label_copier.go
|
NewLabelCopier
|
func NewLabelCopier(separator string, storedLabels, ignoredLabels []string) (*LabelCopier, error) {
return &LabelCopier{
labelSeparator: separator,
storedLabels: makeStoredLabels(storedLabels),
ignoredLabels: makeIgnoredLabels(ignoredLabels),
}, nil
}
|
go
|
func NewLabelCopier(separator string, storedLabels, ignoredLabels []string) (*LabelCopier, error) {
return &LabelCopier{
labelSeparator: separator,
storedLabels: makeStoredLabels(storedLabels),
ignoredLabels: makeIgnoredLabels(ignoredLabels),
}, nil
}
|
[
"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
|
[
"NewLabelCopier",
"creates",
"a",
"new",
"instance",
"of",
"LabelCopier",
"type"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/util/label_copier.go#L79-L85
|
train
|
kubernetes-retired/heapster
|
events/sinks/influxdb/influxdb.go
|
getEventValue
|
func getEventValue(event *kube_api.Event) (string, error) {
// TODO: check whether indenting is required.
bytes, err := json.MarshalIndent(event, "", " ")
if err != nil {
return "", err
}
return string(bytes), nil
}
|
go
|
func getEventValue(event *kube_api.Event) (string, error) {
// TODO: check whether indenting is required.
bytes, err := json.MarshalIndent(event, "", " ")
if err != nil {
return "", err
}
return string(bytes), nil
}
|
[
"func",
"getEventValue",
"(",
"event",
"*",
"kube_api",
".",
"Event",
")",
"(",
"string",
",",
"error",
")",
"{",
"bytes",
",",
"err",
":=",
"json",
".",
"MarshalIndent",
"(",
"event",
",",
"\"\"",
",",
"\" \"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"string",
"(",
"bytes",
")",
",",
"nil",
"\n",
"}"
] |
// Generate point value for event
|
[
"Generate",
"point",
"value",
"for",
"event"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/events/sinks/influxdb/influxdb.go#L61-L68
|
train
|
kubernetes-retired/heapster
|
events/sinks/influxdb/influxdb.go
|
newSink
|
func newSink(c influxdb_common.InfluxdbConfig) core.EventSink {
client, err := influxdb_common.NewClient(c)
if err != nil {
glog.Errorf("issues while creating an InfluxDB sink: %v, will retry on use", err)
}
return &influxdbSink{
client: client, // can be nil
c: c,
}
}
|
go
|
func newSink(c influxdb_common.InfluxdbConfig) core.EventSink {
client, err := influxdb_common.NewClient(c)
if err != nil {
glog.Errorf("issues while creating an InfluxDB sink: %v, will retry on use", err)
}
return &influxdbSink{
client: client, // can be nil
c: c,
}
}
|
[
"func",
"newSink",
"(",
"c",
"influxdb_common",
".",
"InfluxdbConfig",
")",
"core",
".",
"EventSink",
"{",
"client",
",",
"err",
":=",
"influxdb_common",
".",
"NewClient",
"(",
"c",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"glog",
".",
"Errorf",
"(",
"\"issues while creating an InfluxDB sink: %v, will retry on use\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"influxdbSink",
"{",
"client",
":",
"client",
",",
"c",
":",
"c",
",",
"}",
"\n",
"}"
] |
// Returns a thread-safe implementation of core.EventSink for InfluxDB.
|
[
"Returns",
"a",
"thread",
"-",
"safe",
"implementation",
"of",
"core",
".",
"EventSink",
"for",
"InfluxDB",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/events/sinks/influxdb/influxdb.go#L230-L239
|
train
|
kubernetes-retired/heapster
|
metrics/sinks/opentsdb/driver.go
|
metricToPoint
|
func (tsdbSink *openTSDBSink) metricToPoint(name string, value core.MetricValue, timestamp time.Time, labels map[string]string) opentsdbclient.DataPoint {
seriesName := strings.Replace(toValidOpenTsdbName(name), "/", "_", -1)
if value.MetricType.String() != "" {
seriesName = fmt.Sprintf("%s_%s", seriesName, value.MetricType.String())
}
datapoint := opentsdbclient.DataPoint{
Metric: seriesName,
Tags: make(map[string]string, len(labels)),
Timestamp: timestamp.Unix(),
}
if value.ValueType == core.ValueInt64 {
datapoint.Value = value.IntValue
} else {
datapoint.Value = value.FloatValue
}
for key, value := range labels {
key = toValidOpenTsdbName(key)
value = toValidOpenTsdbName(value)
if value != "" {
datapoint.Tags[key] = value
}
}
tsdbSink.putDefaultTags(&datapoint)
return datapoint
}
|
go
|
func (tsdbSink *openTSDBSink) metricToPoint(name string, value core.MetricValue, timestamp time.Time, labels map[string]string) opentsdbclient.DataPoint {
seriesName := strings.Replace(toValidOpenTsdbName(name), "/", "_", -1)
if value.MetricType.String() != "" {
seriesName = fmt.Sprintf("%s_%s", seriesName, value.MetricType.String())
}
datapoint := opentsdbclient.DataPoint{
Metric: seriesName,
Tags: make(map[string]string, len(labels)),
Timestamp: timestamp.Unix(),
}
if value.ValueType == core.ValueInt64 {
datapoint.Value = value.IntValue
} else {
datapoint.Value = value.FloatValue
}
for key, value := range labels {
key = toValidOpenTsdbName(key)
value = toValidOpenTsdbName(value)
if value != "" {
datapoint.Tags[key] = value
}
}
tsdbSink.putDefaultTags(&datapoint)
return datapoint
}
|
[
"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",
"if",
"value",
".",
"MetricType",
".",
"String",
"(",
")",
"!=",
"\"\"",
"{",
"seriesName",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"%s_%s\"",
",",
"seriesName",
",",
"value",
".",
"MetricType",
".",
"String",
"(",
")",
")",
"\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",
"for",
"key",
",",
"value",
":=",
"range",
"labels",
"{",
"key",
"=",
"toValidOpenTsdbName",
"(",
"key",
")",
"\n",
"value",
"=",
"toValidOpenTsdbName",
"(",
"value",
")",
"\n",
"if",
"value",
"!=",
"\"\"",
"{",
"datapoint",
".",
"Tags",
"[",
"key",
"]",
"=",
"value",
"\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
|
[
"timeSeriesToPoint",
"transfers",
"the",
"contents",
"holding",
"in",
"the",
"given",
"pointer",
"of",
"sink_api",
".",
"Timeseries",
"into",
"the",
"instance",
"of",
"opentsdbclient",
".",
"DataPoint"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sinks/opentsdb/driver.go#L117-L146
|
train
|
kubernetes-retired/heapster
|
metrics/sinks/opentsdb/driver.go
|
putDefaultTags
|
func (tsdbSink *openTSDBSink) putDefaultTags(datapoint *opentsdbclient.DataPoint) {
datapoint.Tags[clusterNameTagName] = tsdbSink.clusterName
}
|
go
|
func (tsdbSink *openTSDBSink) putDefaultTags(datapoint *opentsdbclient.DataPoint) {
datapoint.Tags[clusterNameTagName] = tsdbSink.clusterName
}
|
[
"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.
|
[
"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",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sinks/opentsdb/driver.go#L151-L153
|
train
|
kubernetes-retired/heapster
|
metrics/api/v1/api.go
|
NewApi
|
func NewApi(runningInKubernetes bool, metricSink *metricsink.MetricSink, historicalSource core.HistoricalSource, disableMetricExport bool) *Api {
gkeMetrics := make(map[string]core.MetricDescriptor)
gkeLabels := make(map[string]core.LabelDescriptor)
for _, val := range core.StandardMetrics {
gkeMetrics[val.Name] = val.MetricDescriptor
}
for _, val := range core.LabeledMetrics {
gkeMetrics[val.Name] = val.MetricDescriptor
}
gkeMetrics[core.MetricCpuLimit.Name] = core.MetricCpuLimit.MetricDescriptor
gkeMetrics[core.MetricMemoryLimit.Name] = core.MetricMemoryLimit.MetricDescriptor
for _, val := range core.CommonLabels() {
gkeLabels[val.Key] = val
}
for _, val := range core.ContainerLabels() {
gkeLabels[val.Key] = val
}
for _, val := range core.PodLabels() {
gkeLabels[val.Key] = val
}
return &Api{
runningInKubernetes: runningInKubernetes,
metricSink: metricSink,
historicalSource: historicalSource,
gkeMetrics: gkeMetrics,
gkeLabels: gkeLabels,
disabled: disableMetricExport,
}
}
|
go
|
func NewApi(runningInKubernetes bool, metricSink *metricsink.MetricSink, historicalSource core.HistoricalSource, disableMetricExport bool) *Api {
gkeMetrics := make(map[string]core.MetricDescriptor)
gkeLabels := make(map[string]core.LabelDescriptor)
for _, val := range core.StandardMetrics {
gkeMetrics[val.Name] = val.MetricDescriptor
}
for _, val := range core.LabeledMetrics {
gkeMetrics[val.Name] = val.MetricDescriptor
}
gkeMetrics[core.MetricCpuLimit.Name] = core.MetricCpuLimit.MetricDescriptor
gkeMetrics[core.MetricMemoryLimit.Name] = core.MetricMemoryLimit.MetricDescriptor
for _, val := range core.CommonLabels() {
gkeLabels[val.Key] = val
}
for _, val := range core.ContainerLabels() {
gkeLabels[val.Key] = val
}
for _, val := range core.PodLabels() {
gkeLabels[val.Key] = val
}
return &Api{
runningInKubernetes: runningInKubernetes,
metricSink: metricSink,
historicalSource: historicalSource,
gkeMetrics: gkeMetrics,
gkeLabels: gkeLabels,
disabled: disableMetricExport,
}
}
|
[
"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",
"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",
"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.
|
[
"Create",
"a",
"new",
"Api",
"to",
"serve",
"from",
"the",
"specified",
"cache",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/api/v1/api.go#L42-L72
|
train
|
kubernetes-retired/heapster
|
metrics/api/v1/api.go
|
Register
|
func (a *Api) Register(container *restful.Container) {
ws := new(restful.WebService)
ws.Path("/api/v1/metric-export").
Doc("Exports the latest point for all Heapster metrics").
Produces(restful.MIME_JSON)
ws.Route(ws.GET("").
To(a.exportMetrics).
Doc("export the latest data point for all metrics").
Operation("exportMetrics").
Writes([]*types.Timeseries{}))
container.Add(ws)
ws = new(restful.WebService)
ws.Path("/api/v1/metric-export-schema").
Doc("Schema for metrics exported by heapster").
Produces(restful.MIME_JSON)
ws.Route(ws.GET("").
To(a.exportMetricsSchema).
Doc("export the schema for all metrics").
Operation("exportmetricsSchema").
Writes(types.TimeseriesSchema{}))
container.Add(ws)
if a.metricSink != nil {
a.RegisterModel(container)
}
if a.historicalSource != nil {
a.RegisterHistorical(container)
}
}
|
go
|
func (a *Api) Register(container *restful.Container) {
ws := new(restful.WebService)
ws.Path("/api/v1/metric-export").
Doc("Exports the latest point for all Heapster metrics").
Produces(restful.MIME_JSON)
ws.Route(ws.GET("").
To(a.exportMetrics).
Doc("export the latest data point for all metrics").
Operation("exportMetrics").
Writes([]*types.Timeseries{}))
container.Add(ws)
ws = new(restful.WebService)
ws.Path("/api/v1/metric-export-schema").
Doc("Schema for metrics exported by heapster").
Produces(restful.MIME_JSON)
ws.Route(ws.GET("").
To(a.exportMetricsSchema).
Doc("export the schema for all metrics").
Operation("exportmetricsSchema").
Writes(types.TimeseriesSchema{}))
container.Add(ws)
if a.metricSink != nil {
a.RegisterModel(container)
}
if a.historicalSource != nil {
a.RegisterHistorical(container)
}
}
|
[
"func",
"(",
"a",
"*",
"Api",
")",
"Register",
"(",
"container",
"*",
"restful",
".",
"Container",
")",
"{",
"ws",
":=",
"new",
"(",
"restful",
".",
"WebService",
")",
"\n",
"ws",
".",
"Path",
"(",
"\"/api/v1/metric-export\"",
")",
".",
"Doc",
"(",
"\"Exports the latest point for all Heapster metrics\"",
")",
".",
"Produces",
"(",
"restful",
".",
"MIME_JSON",
")",
"\n",
"ws",
".",
"Route",
"(",
"ws",
".",
"GET",
"(",
"\"\"",
")",
".",
"To",
"(",
"a",
".",
"exportMetrics",
")",
".",
"Doc",
"(",
"\"export the latest data point for all metrics\"",
")",
".",
"Operation",
"(",
"\"exportMetrics\"",
")",
".",
"Writes",
"(",
"[",
"]",
"*",
"types",
".",
"Timeseries",
"{",
"}",
")",
")",
"\n",
"container",
".",
"Add",
"(",
"ws",
")",
"\n",
"ws",
"=",
"new",
"(",
"restful",
".",
"WebService",
")",
"\n",
"ws",
".",
"Path",
"(",
"\"/api/v1/metric-export-schema\"",
")",
".",
"Doc",
"(",
"\"Schema for metrics exported by heapster\"",
")",
".",
"Produces",
"(",
"restful",
".",
"MIME_JSON",
")",
"\n",
"ws",
".",
"Route",
"(",
"ws",
".",
"GET",
"(",
"\"\"",
")",
".",
"To",
"(",
"a",
".",
"exportMetricsSchema",
")",
".",
"Doc",
"(",
"\"export the schema for all metrics\"",
")",
".",
"Operation",
"(",
"\"exportmetricsSchema\"",
")",
".",
"Writes",
"(",
"types",
".",
"TimeseriesSchema",
"{",
"}",
")",
")",
"\n",
"container",
".",
"Add",
"(",
"ws",
")",
"\n",
"if",
"a",
".",
"metricSink",
"!=",
"nil",
"{",
"a",
".",
"RegisterModel",
"(",
"container",
")",
"\n",
"}",
"\n",
"if",
"a",
".",
"historicalSource",
"!=",
"nil",
"{",
"a",
".",
"RegisterHistorical",
"(",
"container",
")",
"\n",
"}",
"\n",
"}"
] |
// Register the mainApi on the specified endpoint.
|
[
"Register",
"the",
"mainApi",
"on",
"the",
"specified",
"endpoint",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/api/v1/api.go#L75-L104
|
train
|
kubernetes-retired/heapster
|
metrics/sinks/hawkular/driver.go
|
NewHawkularSink
|
func NewHawkularSink(u *url.URL) (core.DataSink, error) {
sink := &hawkularSink{
uri: u,
batchSize: 1000,
}
if err := sink.init(); err != nil {
return nil, err
}
metrics := make([]core.MetricDescriptor, 0, len(core.AllMetrics))
for _, metric := range core.AllMetrics {
metrics = append(metrics, metric.MetricDescriptor)
}
sink.Register(metrics)
return sink, nil
}
|
go
|
func NewHawkularSink(u *url.URL) (core.DataSink, error) {
sink := &hawkularSink{
uri: u,
batchSize: 1000,
}
if err := sink.init(); err != nil {
return nil, err
}
metrics := make([]core.MetricDescriptor, 0, len(core.AllMetrics))
for _, metric := range core.AllMetrics {
metrics = append(metrics, metric.MetricDescriptor)
}
sink.Register(metrics)
return sink, nil
}
|
[
"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",
"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
|
[
"NewHawkularSink",
"Creates",
"and",
"returns",
"a",
"new",
"hawkularSink",
"instance"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sinks/hawkular/driver.go#L178-L193
|
train
|
kubernetes-retired/heapster
|
common/elasticsearch/elasticsearch.go
|
SaveData
|
func (esSvc *ElasticSearchService) SaveData(date time.Time, typeName string, sinkData []interface{}) error {
if typeName == "" || len(sinkData) == 0 {
return nil
}
indexName := esSvc.Index(date)
// Use the IndexExists service to check if a specified index exists.
exists, err := esSvc.EsClient.IndexExists(indexName)
if err != nil {
return err
}
if !exists {
// Create a new index.
createIndex, err := esSvc.EsClient.CreateIndex(indexName, mapping)
if err != nil {
return err
}
ack := false
switch i := createIndex.(type) {
case *elastic2.IndicesCreateResult:
ack = i.Acknowledged
case *elastic5.IndicesCreateResult:
ack = i.Acknowledged
}
if !ack {
return errors.New("Failed to acknoledge index creation")
}
}
aliases, err := esSvc.EsClient.GetAliases(indexName)
if err != nil {
return err
}
aliasName := esSvc.IndexAlias(typeName)
hasAlias := false
switch a := aliases.(type) {
case *elastic2.AliasesResult:
hasAlias = a.Indices[indexName].HasAlias(aliasName)
case *elastic5.AliasesResult:
hasAlias = a.Indices[indexName].HasAlias(aliasName)
}
if !hasAlias {
createAlias, err := esSvc.EsClient.AddAlias(indexName, esSvc.IndexAlias(typeName))
if err != nil {
return err
}
ack := false
switch i := createAlias.(type) {
case *elastic2.AliasResult:
ack = i.Acknowledged
case *elastic5.AliasResult:
ack = i.Acknowledged
}
if !ack {
return errors.New("Failed to acknoledge index alias creation")
}
}
for _, data := range sinkData {
esSvc.EsClient.AddBulkReq(indexName, typeName, data)
}
return nil
}
|
go
|
func (esSvc *ElasticSearchService) SaveData(date time.Time, typeName string, sinkData []interface{}) error {
if typeName == "" || len(sinkData) == 0 {
return nil
}
indexName := esSvc.Index(date)
// Use the IndexExists service to check if a specified index exists.
exists, err := esSvc.EsClient.IndexExists(indexName)
if err != nil {
return err
}
if !exists {
// Create a new index.
createIndex, err := esSvc.EsClient.CreateIndex(indexName, mapping)
if err != nil {
return err
}
ack := false
switch i := createIndex.(type) {
case *elastic2.IndicesCreateResult:
ack = i.Acknowledged
case *elastic5.IndicesCreateResult:
ack = i.Acknowledged
}
if !ack {
return errors.New("Failed to acknoledge index creation")
}
}
aliases, err := esSvc.EsClient.GetAliases(indexName)
if err != nil {
return err
}
aliasName := esSvc.IndexAlias(typeName)
hasAlias := false
switch a := aliases.(type) {
case *elastic2.AliasesResult:
hasAlias = a.Indices[indexName].HasAlias(aliasName)
case *elastic5.AliasesResult:
hasAlias = a.Indices[indexName].HasAlias(aliasName)
}
if !hasAlias {
createAlias, err := esSvc.EsClient.AddAlias(indexName, esSvc.IndexAlias(typeName))
if err != nil {
return err
}
ack := false
switch i := createAlias.(type) {
case *elastic2.AliasResult:
ack = i.Acknowledged
case *elastic5.AliasResult:
ack = i.Acknowledged
}
if !ack {
return errors.New("Failed to acknoledge index alias creation")
}
}
for _, data := range sinkData {
esSvc.EsClient.AddBulkReq(indexName, typeName, data)
}
return nil
}
|
[
"func",
"(",
"esSvc",
"*",
"ElasticSearchService",
")",
"SaveData",
"(",
"date",
"time",
".",
"Time",
",",
"typeName",
"string",
",",
"sinkData",
"[",
"]",
"interface",
"{",
"}",
")",
"error",
"{",
"if",
"typeName",
"==",
"\"\"",
"||",
"len",
"(",
"sinkData",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"indexName",
":=",
"esSvc",
".",
"Index",
"(",
"date",
")",
"\n",
"exists",
",",
"err",
":=",
"esSvc",
".",
"EsClient",
".",
"IndexExists",
"(",
"indexName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"!",
"exists",
"{",
"createIndex",
",",
"err",
":=",
"esSvc",
".",
"EsClient",
".",
"CreateIndex",
"(",
"indexName",
",",
"mapping",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\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",
"(",
"\"Failed to acknoledge index creation\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"aliases",
",",
"err",
":=",
"esSvc",
".",
"EsClient",
".",
"GetAliases",
"(",
"indexName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"aliasName",
":=",
"esSvc",
".",
"IndexAlias",
"(",
"typeName",
")",
"\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",
"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",
"(",
"\"Failed to acknoledge index alias creation\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"for",
"_",
",",
"data",
":=",
"range",
"sinkData",
"{",
"esSvc",
".",
"EsClient",
".",
"AddBulkReq",
"(",
"indexName",
",",
"typeName",
",",
"data",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// SaveDataIntoES save metrics and events to ES by using ES client
|
[
"SaveDataIntoES",
"save",
"metrics",
"and",
"events",
"to",
"ES",
"by",
"using",
"ES",
"client"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/common/elasticsearch/elasticsearch.go#L54-L122
|
train
|
kubernetes-retired/heapster
|
metrics/sinks/influxdb/influxdb.go
|
newSink
|
func newSink(c influxdb_common.InfluxdbConfig) core.DataSink {
client, err := influxdb_common.NewClient(c)
if err != nil {
glog.Errorf("issues while creating an InfluxDB sink: %v, will retry on use", err)
}
return &influxdbSink{
client: client, // can be nil
c: c,
conChan: make(chan struct{}, c.Concurrency),
}
}
|
go
|
func newSink(c influxdb_common.InfluxdbConfig) core.DataSink {
client, err := influxdb_common.NewClient(c)
if err != nil {
glog.Errorf("issues while creating an InfluxDB sink: %v, will retry on use", err)
}
return &influxdbSink{
client: client, // can be nil
c: c,
conChan: make(chan struct{}, c.Concurrency),
}
}
|
[
"func",
"newSink",
"(",
"c",
"influxdb_common",
".",
"InfluxdbConfig",
")",
"core",
".",
"DataSink",
"{",
"client",
",",
"err",
":=",
"influxdb_common",
".",
"NewClient",
"(",
"c",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"glog",
".",
"Errorf",
"(",
"\"issues while creating an InfluxDB sink: %v, will retry on use\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"influxdbSink",
"{",
"client",
":",
"client",
",",
"c",
":",
"c",
",",
"conChan",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
",",
"c",
".",
"Concurrency",
")",
",",
"}",
"\n",
"}"
] |
// Returns a thread-compatible implementation of influxdb interactions.
|
[
"Returns",
"a",
"thread",
"-",
"compatible",
"implementation",
"of",
"influxdb",
"interactions",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sinks/influxdb/influxdb.go#L294-L304
|
train
|
kubernetes-retired/heapster
|
integration/framework.go
|
ParseRBAC
|
func (self *realKubeFramework) ParseRBAC(filePath string) (*rbacv1.ClusterRoleBinding, error) {
obj, err := self.loadRBACObject(filePath)
if err != nil {
return nil, err
}
rbac, ok := obj.(*rbacv1.ClusterRoleBinding)
if !ok {
return nil, fmt.Errorf("Failed to cast clusterrolebinding: %v", obj)
}
return rbac, nil
}
|
go
|
func (self *realKubeFramework) ParseRBAC(filePath string) (*rbacv1.ClusterRoleBinding, error) {
obj, err := self.loadRBACObject(filePath)
if err != nil {
return nil, err
}
rbac, ok := obj.(*rbacv1.ClusterRoleBinding)
if !ok {
return nil, fmt.Errorf("Failed to cast clusterrolebinding: %v", obj)
}
return rbac, nil
}
|
[
"func",
"(",
"self",
"*",
"realKubeFramework",
")",
"ParseRBAC",
"(",
"filePath",
"string",
")",
"(",
"*",
"rbacv1",
".",
"ClusterRoleBinding",
",",
"error",
")",
"{",
"obj",
",",
"err",
":=",
"self",
".",
"loadRBACObject",
"(",
"filePath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"rbac",
",",
"ok",
":=",
"obj",
".",
"(",
"*",
"rbacv1",
".",
"ClusterRoleBinding",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"Failed to cast clusterrolebinding: %v\"",
",",
"obj",
")",
"\n",
"}",
"\n",
"return",
"rbac",
",",
"nil",
"\n",
"}"
] |
// Parses and Returns a RBAC object contained in 'filePath'
|
[
"Parses",
"and",
"Returns",
"a",
"RBAC",
"object",
"contained",
"in",
"filePath"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/integration/framework.go#L402-L413
|
train
|
kubernetes-retired/heapster
|
integration/framework.go
|
CreateRBAC
|
func (self *realKubeFramework) CreateRBAC(rbac *rbacv1.ClusterRoleBinding) error {
_, err := self.kubeClient.RbacV1().ClusterRoleBindings().Create(rbac)
return err
}
|
go
|
func (self *realKubeFramework) CreateRBAC(rbac *rbacv1.ClusterRoleBinding) error {
_, err := self.kubeClient.RbacV1().ClusterRoleBindings().Create(rbac)
return err
}
|
[
"func",
"(",
"self",
"*",
"realKubeFramework",
")",
"CreateRBAC",
"(",
"rbac",
"*",
"rbacv1",
".",
"ClusterRoleBinding",
")",
"error",
"{",
"_",
",",
"err",
":=",
"self",
".",
"kubeClient",
".",
"RbacV1",
"(",
")",
".",
"ClusterRoleBindings",
"(",
")",
".",
"Create",
"(",
"rbac",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// CreateRBAC creates the RBAC object
|
[
"CreateRBAC",
"creates",
"the",
"RBAC",
"object"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/integration/framework.go#L416-L419
|
train
|
kubernetes-retired/heapster
|
integration/framework.go
|
ParseServiceAccount
|
func (self *realKubeFramework) ParseServiceAccount(filePath string) (*v1.ServiceAccount, error) {
obj, err := self.loadObject(filePath)
if err != nil {
return nil, err
}
sa, ok := obj.(*v1.ServiceAccount)
if !ok {
return nil, fmt.Errorf("Failed to cast serviceaccount: %v", obj)
}
return sa, nil
}
|
go
|
func (self *realKubeFramework) ParseServiceAccount(filePath string) (*v1.ServiceAccount, error) {
obj, err := self.loadObject(filePath)
if err != nil {
return nil, err
}
sa, ok := obj.(*v1.ServiceAccount)
if !ok {
return nil, fmt.Errorf("Failed to cast serviceaccount: %v", obj)
}
return sa, nil
}
|
[
"func",
"(",
"self",
"*",
"realKubeFramework",
")",
"ParseServiceAccount",
"(",
"filePath",
"string",
")",
"(",
"*",
"v1",
".",
"ServiceAccount",
",",
"error",
")",
"{",
"obj",
",",
"err",
":=",
"self",
".",
"loadObject",
"(",
"filePath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"sa",
",",
"ok",
":=",
"obj",
".",
"(",
"*",
"v1",
".",
"ServiceAccount",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"Failed to cast serviceaccount: %v\"",
",",
"obj",
")",
"\n",
"}",
"\n",
"return",
"sa",
",",
"nil",
"\n",
"}"
] |
// Parses and Returns a ServiceAccount object contained in 'filePath'
|
[
"Parses",
"and",
"Returns",
"a",
"ServiceAccount",
"object",
"contained",
"in",
"filePath"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/integration/framework.go#L422-L433
|
train
|
kubernetes-retired/heapster
|
integration/framework.go
|
CreateServiceAccount
|
func (self *realKubeFramework) CreateServiceAccount(sa *v1.ServiceAccount) error {
_, err := self.kubeClient.CoreV1().ServiceAccounts(sa.Namespace).Create(sa)
return err
}
|
go
|
func (self *realKubeFramework) CreateServiceAccount(sa *v1.ServiceAccount) error {
_, err := self.kubeClient.CoreV1().ServiceAccounts(sa.Namespace).Create(sa)
return err
}
|
[
"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
|
[
"CreateServiceAccount",
"creates",
"the",
"ServiceAccount",
"object"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/integration/framework.go#L436-L439
|
train
|
kubernetes-retired/heapster
|
common/honeycomb/honeycomb.go
|
SendBatch
|
func (c *HoneycombClient) SendBatch(batch Batch) error {
if len(batch) == 0 {
// Nothing to send
return nil
}
errs := []string{}
for i := 0; i < len(batch); i += maxBatchSize {
offset := i + maxBatchSize
if offset > len(batch) {
offset = len(batch)
}
if err := c.sendBatch(batch[i:offset]); err != nil {
errs = append(errs, err.Error())
}
}
if len(errs) > 0 {
return errors.New(strings.Join(errs, "\n"))
}
return nil
}
|
go
|
func (c *HoneycombClient) SendBatch(batch Batch) error {
if len(batch) == 0 {
// Nothing to send
return nil
}
errs := []string{}
for i := 0; i < len(batch); i += maxBatchSize {
offset := i + maxBatchSize
if offset > len(batch) {
offset = len(batch)
}
if err := c.sendBatch(batch[i:offset]); err != nil {
errs = append(errs, err.Error())
}
}
if len(errs) > 0 {
return errors.New(strings.Join(errs, "\n"))
}
return nil
}
|
[
"func",
"(",
"c",
"*",
"HoneycombClient",
")",
"SendBatch",
"(",
"batch",
"Batch",
")",
"error",
"{",
"if",
"len",
"(",
"batch",
")",
"==",
"0",
"{",
"return",
"nil",
"\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",
"if",
"len",
"(",
"errs",
")",
">",
"0",
"{",
"return",
"errors",
".",
"New",
"(",
"strings",
".",
"Join",
"(",
"errs",
",",
"\"\\n\"",
")",
")",
"\n",
"}",
"\n",
"\\n",
"\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.
|
[
"SendBatch",
"splits",
"the",
"top",
"-",
"level",
"batch",
"into",
"sub",
"-",
"batches",
"if",
"needed",
".",
"Otherwise",
"requests",
"that",
"are",
"too",
"large",
"will",
"be",
"rejected",
"by",
"the",
"Honeycomb",
"API",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/common/honeycomb/honeycomb.go#L108-L130
|
train
|
kubernetes-retired/heapster
|
metrics/sinks/influxdb/influxdb_historical.go
|
checkSanitizedMetricName
|
func (sink *influxdbSink) checkSanitizedMetricName(name string) error {
if !metricAllowedChars.MatchString(name) {
return fmt.Errorf("Invalid metric name %q", name)
}
return nil
}
|
go
|
func (sink *influxdbSink) checkSanitizedMetricName(name string) error {
if !metricAllowedChars.MatchString(name) {
return fmt.Errorf("Invalid metric name %q", name)
}
return nil
}
|
[
"func",
"(",
"sink",
"*",
"influxdbSink",
")",
"checkSanitizedMetricName",
"(",
"name",
"string",
")",
"error",
"{",
"if",
"!",
"metricAllowedChars",
".",
"MatchString",
"(",
"name",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"Invalid metric name %q\"",
",",
"name",
")",
"\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.
|
[
"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",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sinks/influxdb/influxdb_historical.go#L78-L84
|
train
|
kubernetes-retired/heapster
|
metrics/sinks/influxdb/influxdb_historical.go
|
checkSanitizedMetricLabels
|
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("Invalid label name %q", k)
}
// 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("Invalid label value %q", v)
}
for _, runeVal := range v {
if !unicode.IsPrint(runeVal) {
return fmt.Errorf("Invalid label value %q", v)
}
}
}
return nil
}
|
go
|
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("Invalid label name %q", k)
}
// 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("Invalid label value %q", v)
}
for _, runeVal := range v {
if !unicode.IsPrint(runeVal) {
return fmt.Errorf("Invalid label value %q", v)
}
}
}
return nil
}
|
[
"func",
"(",
"sink",
"*",
"influxdbSink",
")",
"checkSanitizedMetricLabels",
"(",
"labels",
"map",
"[",
"string",
"]",
"string",
")",
"error",
"{",
"for",
"k",
",",
"v",
":=",
"range",
"labels",
"{",
"if",
"!",
"metricAllowedChars",
".",
"MatchString",
"(",
"k",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"Invalid label name %q\"",
",",
"k",
")",
"\n",
"}",
"\n",
"if",
"strings",
".",
"ContainsRune",
"(",
"v",
",",
"'\"'",
")",
"||",
"strings",
".",
"ContainsRune",
"(",
"v",
",",
"'\\''",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"Invalid label value %q\"",
",",
"v",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"runeVal",
":=",
"range",
"v",
"{",
"if",
"!",
"unicode",
".",
"IsPrint",
"(",
"runeVal",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"Invalid label value %q\"",
",",
"v",
")",
"\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.
|
[
"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",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sinks/influxdb/influxdb_historical.go#L88-L110
|
train
|
kubernetes-retired/heapster
|
metrics/sinks/influxdb/influxdb_historical.go
|
aggregationFunc
|
func (sink *influxdbSink) aggregationFunc(aggregationName core.AggregationType, fieldName string) string {
switch aggregationName {
case core.AggregationTypeAverage:
return fmt.Sprintf("MEAN(%q)", fieldName)
case core.AggregationTypeMaximum:
return fmt.Sprintf("MAX(%q)", fieldName)
case core.AggregationTypeMinimum:
return fmt.Sprintf("MIN(%q)", fieldName)
case core.AggregationTypeMedian:
return fmt.Sprintf("MEDIAN(%q)", fieldName)
case core.AggregationTypeCount:
return fmt.Sprintf("COUNT(%q)", fieldName)
case core.AggregationTypePercentile50:
return fmt.Sprintf("PERCENTILE(%q, 50)", fieldName)
case core.AggregationTypePercentile95:
return fmt.Sprintf("PERCENTILE(%q, 95)", fieldName)
case core.AggregationTypePercentile99:
return fmt.Sprintf("PERCENTILE(%q, 99)", fieldName)
}
// This should have been checked by the API level, so something's seriously wrong here
panic(fmt.Sprintf("Unknown aggregation type %q", aggregationName))
}
|
go
|
func (sink *influxdbSink) aggregationFunc(aggregationName core.AggregationType, fieldName string) string {
switch aggregationName {
case core.AggregationTypeAverage:
return fmt.Sprintf("MEAN(%q)", fieldName)
case core.AggregationTypeMaximum:
return fmt.Sprintf("MAX(%q)", fieldName)
case core.AggregationTypeMinimum:
return fmt.Sprintf("MIN(%q)", fieldName)
case core.AggregationTypeMedian:
return fmt.Sprintf("MEDIAN(%q)", fieldName)
case core.AggregationTypeCount:
return fmt.Sprintf("COUNT(%q)", fieldName)
case core.AggregationTypePercentile50:
return fmt.Sprintf("PERCENTILE(%q, 50)", fieldName)
case core.AggregationTypePercentile95:
return fmt.Sprintf("PERCENTILE(%q, 95)", fieldName)
case core.AggregationTypePercentile99:
return fmt.Sprintf("PERCENTILE(%q, 99)", fieldName)
}
// This should have been checked by the API level, so something's seriously wrong here
panic(fmt.Sprintf("Unknown aggregation type %q", aggregationName))
}
|
[
"func",
"(",
"sink",
"*",
"influxdbSink",
")",
"aggregationFunc",
"(",
"aggregationName",
"core",
".",
"AggregationType",
",",
"fieldName",
"string",
")",
"string",
"{",
"switch",
"aggregationName",
"{",
"case",
"core",
".",
"AggregationTypeAverage",
":",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"MEAN(%q)\"",
",",
"fieldName",
")",
"\n",
"case",
"core",
".",
"AggregationTypeMaximum",
":",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"MAX(%q)\"",
",",
"fieldName",
")",
"\n",
"case",
"core",
".",
"AggregationTypeMinimum",
":",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"MIN(%q)\"",
",",
"fieldName",
")",
"\n",
"case",
"core",
".",
"AggregationTypeMedian",
":",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"MEDIAN(%q)\"",
",",
"fieldName",
")",
"\n",
"case",
"core",
".",
"AggregationTypeCount",
":",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"COUNT(%q)\"",
",",
"fieldName",
")",
"\n",
"case",
"core",
".",
"AggregationTypePercentile50",
":",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"PERCENTILE(%q, 50)\"",
",",
"fieldName",
")",
"\n",
"case",
"core",
".",
"AggregationTypePercentile95",
":",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"PERCENTILE(%q, 95)\"",
",",
"fieldName",
")",
"\n",
"case",
"core",
".",
"AggregationTypePercentile99",
":",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"PERCENTILE(%q, 99)\"",
",",
"fieldName",
")",
"\n",
"}",
"\n",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"Unknown aggregation type %q\"",
",",
"aggregationName",
")",
")",
"\n",
"}"
] |
// aggregationFunc converts an aggregation name into the equivalent call to an InfluxQL
// aggregation function
|
[
"aggregationFunc",
"converts",
"an",
"aggregation",
"name",
"into",
"the",
"equivalent",
"call",
"to",
"an",
"InfluxQL",
"aggregation",
"function"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sinks/influxdb/influxdb_historical.go#L114-L136
|
train
|
kubernetes-retired/heapster
|
metrics/sinks/influxdb/influxdb_historical.go
|
keyToSelector
|
func (sink *influxdbSink) keyToSelector(key core.HistoricalKey) string {
typeSel := fmt.Sprintf("type = '%s'", key.ObjectType)
switch key.ObjectType {
case core.MetricSetTypeNode:
return fmt.Sprintf("%s AND %s = '%s'", typeSel, core.LabelNodename.Key, key.NodeName)
case core.MetricSetTypeSystemContainer:
return fmt.Sprintf("%s AND %s = '%s' AND %s = '%s'", typeSel, core.LabelContainerName.Key, key.ContainerName, core.LabelNodename.Key, key.NodeName)
case core.MetricSetTypeCluster:
return typeSel
case core.MetricSetTypeNamespace:
return fmt.Sprintf("%s AND %s = '%s'", typeSel, core.LabelNamespaceName.Key, key.NamespaceName)
case core.MetricSetTypePod:
if key.PodId != "" {
return fmt.Sprintf("%s AND %s = '%s'", typeSel, core.LabelPodId.Key, key.PodId)
} else {
return fmt.Sprintf("%s AND %s = '%s' AND %s = '%s'", typeSel, core.LabelNamespaceName.Key, key.NamespaceName, core.LabelPodName.Key, key.PodName)
}
case core.MetricSetTypePodContainer:
if key.PodId != "" {
return fmt.Sprintf("%s AND %s = '%s' AND %s = '%s'", typeSel, core.LabelPodId.Key, key.PodId, core.LabelContainerName.Key, key.ContainerName)
} else {
return fmt.Sprintf("%s AND %s = '%s' AND %s = '%s' AND %s = '%s'", typeSel, core.LabelNamespaceName.Key, key.NamespaceName, core.LabelPodName.Key, key.PodName, core.LabelContainerName.Key, key.ContainerName)
}
}
// These are assigned by the API, so it shouldn't be possible to reach this unless things are really broken
panic(fmt.Sprintf("Unknown metric type %q", key.ObjectType))
}
|
go
|
func (sink *influxdbSink) keyToSelector(key core.HistoricalKey) string {
typeSel := fmt.Sprintf("type = '%s'", key.ObjectType)
switch key.ObjectType {
case core.MetricSetTypeNode:
return fmt.Sprintf("%s AND %s = '%s'", typeSel, core.LabelNodename.Key, key.NodeName)
case core.MetricSetTypeSystemContainer:
return fmt.Sprintf("%s AND %s = '%s' AND %s = '%s'", typeSel, core.LabelContainerName.Key, key.ContainerName, core.LabelNodename.Key, key.NodeName)
case core.MetricSetTypeCluster:
return typeSel
case core.MetricSetTypeNamespace:
return fmt.Sprintf("%s AND %s = '%s'", typeSel, core.LabelNamespaceName.Key, key.NamespaceName)
case core.MetricSetTypePod:
if key.PodId != "" {
return fmt.Sprintf("%s AND %s = '%s'", typeSel, core.LabelPodId.Key, key.PodId)
} else {
return fmt.Sprintf("%s AND %s = '%s' AND %s = '%s'", typeSel, core.LabelNamespaceName.Key, key.NamespaceName, core.LabelPodName.Key, key.PodName)
}
case core.MetricSetTypePodContainer:
if key.PodId != "" {
return fmt.Sprintf("%s AND %s = '%s' AND %s = '%s'", typeSel, core.LabelPodId.Key, key.PodId, core.LabelContainerName.Key, key.ContainerName)
} else {
return fmt.Sprintf("%s AND %s = '%s' AND %s = '%s' AND %s = '%s'", typeSel, core.LabelNamespaceName.Key, key.NamespaceName, core.LabelPodName.Key, key.PodName, core.LabelContainerName.Key, key.ContainerName)
}
}
// These are assigned by the API, so it shouldn't be possible to reach this unless things are really broken
panic(fmt.Sprintf("Unknown metric type %q", key.ObjectType))
}
|
[
"func",
"(",
"sink",
"*",
"influxdbSink",
")",
"keyToSelector",
"(",
"key",
"core",
".",
"HistoricalKey",
")",
"string",
"{",
"typeSel",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"type = '%s'\"",
",",
"key",
".",
"ObjectType",
")",
"\n",
"switch",
"key",
".",
"ObjectType",
"{",
"case",
"core",
".",
"MetricSetTypeNode",
":",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"%s AND %s = '%s'\"",
",",
"typeSel",
",",
"core",
".",
"LabelNodename",
".",
"Key",
",",
"key",
".",
"NodeName",
")",
"\n",
"case",
"core",
".",
"MetricSetTypeSystemContainer",
":",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"%s AND %s = '%s' AND %s = '%s'\"",
",",
"typeSel",
",",
"core",
".",
"LabelContainerName",
".",
"Key",
",",
"key",
".",
"ContainerName",
",",
"core",
".",
"LabelNodename",
".",
"Key",
",",
"key",
".",
"NodeName",
")",
"\n",
"case",
"core",
".",
"MetricSetTypeCluster",
":",
"return",
"typeSel",
"\n",
"case",
"core",
".",
"MetricSetTypeNamespace",
":",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"%s AND %s = '%s'\"",
",",
"typeSel",
",",
"core",
".",
"LabelNamespaceName",
".",
"Key",
",",
"key",
".",
"NamespaceName",
")",
"\n",
"case",
"core",
".",
"MetricSetTypePod",
":",
"if",
"key",
".",
"PodId",
"!=",
"\"\"",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"%s AND %s = '%s'\"",
",",
"typeSel",
",",
"core",
".",
"LabelPodId",
".",
"Key",
",",
"key",
".",
"PodId",
")",
"\n",
"}",
"else",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"%s AND %s = '%s' AND %s = '%s'\"",
",",
"typeSel",
",",
"core",
".",
"LabelNamespaceName",
".",
"Key",
",",
"key",
".",
"NamespaceName",
",",
"core",
".",
"LabelPodName",
".",
"Key",
",",
"key",
".",
"PodName",
")",
"\n",
"}",
"\n",
"case",
"core",
".",
"MetricSetTypePodContainer",
":",
"if",
"key",
".",
"PodId",
"!=",
"\"\"",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"%s AND %s = '%s' AND %s = '%s'\"",
",",
"typeSel",
",",
"core",
".",
"LabelPodId",
".",
"Key",
",",
"key",
".",
"PodId",
",",
"core",
".",
"LabelContainerName",
".",
"Key",
",",
"key",
".",
"ContainerName",
")",
"\n",
"}",
"else",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"%s AND %s = '%s' AND %s = '%s' AND %s = '%s'\"",
",",
"typeSel",
",",
"core",
".",
"LabelNamespaceName",
".",
"Key",
",",
"key",
".",
"NamespaceName",
",",
"core",
".",
"LabelPodName",
".",
"Key",
",",
"key",
".",
"PodName",
",",
"core",
".",
"LabelContainerName",
".",
"Key",
",",
"key",
".",
"ContainerName",
")",
"\n",
"}",
"\n",
"}",
"\n",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"Unknown metric type %q\"",
",",
"key",
".",
"ObjectType",
")",
")",
"\n",
"}"
] |
// keyToSelector converts a HistoricalKey to an InfluxQL predicate
|
[
"keyToSelector",
"converts",
"a",
"HistoricalKey",
"to",
"an",
"InfluxQL",
"predicate"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sinks/influxdb/influxdb_historical.go#L139-L166
|
train
|
kubernetes-retired/heapster
|
metrics/sinks/influxdb/influxdb_historical.go
|
labelsToPredicate
|
func (sink *influxdbSink) labelsToPredicate(labels map[string]string) string {
if len(labels) == 0 {
return ""
}
parts := make([]string, 0, len(labels))
for k, v := range labels {
parts = append(parts, fmt.Sprintf("%q = '%s'", k, v))
}
return strings.Join(parts, " AND ")
}
|
go
|
func (sink *influxdbSink) labelsToPredicate(labels map[string]string) string {
if len(labels) == 0 {
return ""
}
parts := make([]string, 0, len(labels))
for k, v := range labels {
parts = append(parts, fmt.Sprintf("%q = '%s'", k, v))
}
return strings.Join(parts, " AND ")
}
|
[
"func",
"(",
"sink",
"*",
"influxdbSink",
")",
"labelsToPredicate",
"(",
"labels",
"map",
"[",
"string",
"]",
"string",
")",
"string",
"{",
"if",
"len",
"(",
"labels",
")",
"==",
"0",
"{",
"return",
"\"\"",
"\n",
"}",
"\n",
"parts",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"labels",
")",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"labels",
"{",
"parts",
"=",
"append",
"(",
"parts",
",",
"fmt",
".",
"Sprintf",
"(",
"\"%q = '%s'\"",
",",
"k",
",",
"v",
")",
")",
"\n",
"}",
"\n",
"return",
"strings",
".",
"Join",
"(",
"parts",
",",
"\" AND \"",
")",
"\n",
"}"
] |
// labelsToPredicate composes an InfluxQL predicate based on the given map of labels
|
[
"labelsToPredicate",
"composes",
"an",
"InfluxQL",
"predicate",
"based",
"on",
"the",
"given",
"map",
"of",
"labels"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sinks/influxdb/influxdb_historical.go#L169-L180
|
train
|
kubernetes-retired/heapster
|
metrics/sinks/influxdb/influxdb_historical.go
|
composeRawQuery
|
func (sink *influxdbSink) composeRawQuery(metricName string, labels map[string]string, metricKeys []core.HistoricalKey, start, end time.Time) string {
seriesName, fieldName := sink.metricToSeriesAndField(metricName)
queries := make([]string, len(metricKeys))
for i, key := range metricKeys {
pred := sink.keyToSelector(key)
if labels != nil {
pred += fmt.Sprintf(" AND %s", sink.labelsToPredicate(labels))
}
if !start.IsZero() {
pred += fmt.Sprintf(" AND time > '%s'", start.Format(time.RFC3339))
}
if !end.IsZero() {
pred += fmt.Sprintf(" AND time < '%s'", end.Format(time.RFC3339))
}
queries[i] = fmt.Sprintf("SELECT time, %q FROM %q WHERE %s", fieldName, seriesName, pred)
}
return strings.Join(queries, "; ")
}
|
go
|
func (sink *influxdbSink) composeRawQuery(metricName string, labels map[string]string, metricKeys []core.HistoricalKey, start, end time.Time) string {
seriesName, fieldName := sink.metricToSeriesAndField(metricName)
queries := make([]string, len(metricKeys))
for i, key := range metricKeys {
pred := sink.keyToSelector(key)
if labels != nil {
pred += fmt.Sprintf(" AND %s", sink.labelsToPredicate(labels))
}
if !start.IsZero() {
pred += fmt.Sprintf(" AND time > '%s'", start.Format(time.RFC3339))
}
if !end.IsZero() {
pred += fmt.Sprintf(" AND time < '%s'", end.Format(time.RFC3339))
}
queries[i] = fmt.Sprintf("SELECT time, %q FROM %q WHERE %s", fieldName, seriesName, pred)
}
return strings.Join(queries, "; ")
}
|
[
"func",
"(",
"sink",
"*",
"influxdbSink",
")",
"composeRawQuery",
"(",
"metricName",
"string",
",",
"labels",
"map",
"[",
"string",
"]",
"string",
",",
"metricKeys",
"[",
"]",
"core",
".",
"HistoricalKey",
",",
"start",
",",
"end",
"time",
".",
"Time",
")",
"string",
"{",
"seriesName",
",",
"fieldName",
":=",
"sink",
".",
"metricToSeriesAndField",
"(",
"metricName",
")",
"\n",
"queries",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"metricKeys",
")",
")",
"\n",
"for",
"i",
",",
"key",
":=",
"range",
"metricKeys",
"{",
"pred",
":=",
"sink",
".",
"keyToSelector",
"(",
"key",
")",
"\n",
"if",
"labels",
"!=",
"nil",
"{",
"pred",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\" AND %s\"",
",",
"sink",
".",
"labelsToPredicate",
"(",
"labels",
")",
")",
"\n",
"}",
"\n",
"if",
"!",
"start",
".",
"IsZero",
"(",
")",
"{",
"pred",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\" AND time > '%s'\"",
",",
"start",
".",
"Format",
"(",
"time",
".",
"RFC3339",
")",
")",
"\n",
"}",
"\n",
"if",
"!",
"end",
".",
"IsZero",
"(",
")",
"{",
"pred",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\" AND time < '%s'\"",
",",
"end",
".",
"Format",
"(",
"time",
".",
"RFC3339",
")",
")",
"\n",
"}",
"\n",
"queries",
"[",
"i",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"SELECT time, %q FROM %q WHERE %s\"",
",",
"fieldName",
",",
"seriesName",
",",
"pred",
")",
"\n",
"}",
"\n",
"return",
"strings",
".",
"Join",
"(",
"queries",
",",
"\"; \"",
")",
"\n",
"}"
] |
// composeRawQuery creates the InfluxQL query to fetch the given metric values
|
[
"composeRawQuery",
"creates",
"the",
"InfluxQL",
"query",
"to",
"fetch",
"the",
"given",
"metric",
"values"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sinks/influxdb/influxdb_historical.go#L198-L217
|
train
|
kubernetes-retired/heapster
|
metrics/sinks/influxdb/influxdb_historical.go
|
parseRawQueryRow
|
func (sink *influxdbSink) parseRawQueryRow(rawRow influx_models.Row) ([]core.TimestampedMetricValue, error) {
vals := make([]core.TimestampedMetricValue, len(rawRow.Values))
wasInt := make(map[string]bool, 1)
for i, rawVal := range rawRow.Values {
val := core.TimestampedMetricValue{}
if ts, err := time.Parse(time.RFC3339, rawVal[0].(string)); err != nil {
return nil, fmt.Errorf("Unable to parse timestamp %q in series %q", rawVal[0].(string), rawRow.Name)
} else {
val.Timestamp = ts
}
if err := tryParseMetricValue("value", rawVal, &val.MetricValue, 1, wasInt); err != nil {
glog.Errorf("Unable to parse field \"value\" in series %q: %v", rawRow.Name, err)
return nil, fmt.Errorf("Unable to parse values in series %q", rawRow.Name)
}
vals[i] = val
}
if wasInt["value"] {
for i := range vals {
vals[i].MetricValue.ValueType = core.ValueInt64
}
} else {
for i := range vals {
vals[i].MetricValue.ValueType = core.ValueFloat
}
}
return vals, nil
}
|
go
|
func (sink *influxdbSink) parseRawQueryRow(rawRow influx_models.Row) ([]core.TimestampedMetricValue, error) {
vals := make([]core.TimestampedMetricValue, len(rawRow.Values))
wasInt := make(map[string]bool, 1)
for i, rawVal := range rawRow.Values {
val := core.TimestampedMetricValue{}
if ts, err := time.Parse(time.RFC3339, rawVal[0].(string)); err != nil {
return nil, fmt.Errorf("Unable to parse timestamp %q in series %q", rawVal[0].(string), rawRow.Name)
} else {
val.Timestamp = ts
}
if err := tryParseMetricValue("value", rawVal, &val.MetricValue, 1, wasInt); err != nil {
glog.Errorf("Unable to parse field \"value\" in series %q: %v", rawRow.Name, err)
return nil, fmt.Errorf("Unable to parse values in series %q", rawRow.Name)
}
vals[i] = val
}
if wasInt["value"] {
for i := range vals {
vals[i].MetricValue.ValueType = core.ValueInt64
}
} else {
for i := range vals {
vals[i].MetricValue.ValueType = core.ValueFloat
}
}
return vals, nil
}
|
[
"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",
"if",
"ts",
",",
"err",
":=",
"time",
".",
"Parse",
"(",
"time",
".",
"RFC3339",
",",
"rawVal",
"[",
"0",
"]",
".",
"(",
"string",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"Unable to parse timestamp %q in series %q\"",
",",
"rawVal",
"[",
"0",
"]",
".",
"(",
"string",
")",
",",
"rawRow",
".",
"Name",
")",
"\n",
"}",
"else",
"{",
"val",
".",
"Timestamp",
"=",
"ts",
"\n",
"}",
"\n",
"if",
"err",
":=",
"tryParseMetricValue",
"(",
"\"value\"",
",",
"rawVal",
",",
"&",
"val",
".",
"MetricValue",
",",
"1",
",",
"wasInt",
")",
";",
"err",
"!=",
"nil",
"{",
"glog",
".",
"Errorf",
"(",
"\"Unable to parse field \\\"value\\\" in series %q: %v\"",
",",
"\\\"",
",",
"\\\"",
")",
"\n",
"rawRow",
".",
"Name",
"\n",
"}",
"\n",
"err",
"\n",
"}",
"\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"Unable to parse values in series %q\"",
",",
"rawRow",
".",
"Name",
")",
"\n",
"vals",
"[",
"i",
"]",
"=",
"val",
"\n",
"}"
] |
// parseRawQueryRow parses a set of timestamped metric values from unstructured JSON output into the
// appropriate Heapster form
|
[
"parseRawQueryRow",
"parses",
"a",
"set",
"of",
"timestamped",
"metric",
"values",
"from",
"unstructured",
"JSON",
"output",
"into",
"the",
"appropriate",
"Heapster",
"form"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sinks/influxdb/influxdb_historical.go#L221-L252
|
train
|
kubernetes-retired/heapster
|
metrics/sinks/influxdb/influxdb_historical.go
|
composeAggregateQuery
|
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)
var bucketSizeNanoSeconds int64 = 0
if bucketSize != 0 {
bucketSizeNanoSeconds = int64(bucketSize.Nanoseconds() / int64(time.Microsecond/time.Nanosecond))
}
queries := make([]string, len(metricKeys))
for i, key := range metricKeys {
pred := sink.keyToSelector(key)
if labels != nil {
pred += fmt.Sprintf(" AND %s", sink.labelsToPredicate(labels))
}
if !start.IsZero() {
pred += fmt.Sprintf(" AND time > '%s'", start.Format(time.RFC3339))
}
if !end.IsZero() {
pred += fmt.Sprintf(" AND time < '%s'", end.Format(time.RFC3339))
}
aggParts := make([]string, len(aggregations))
for i, agg := range aggregations {
aggParts[i] = sink.aggregationFunc(agg, fieldName)
}
queries[i] = fmt.Sprintf("SELECT %s FROM %q WHERE %s", strings.Join(aggParts, ", "), seriesName, pred)
if bucketSize != 0 {
// group by time requires we have at least one time bound
if start.IsZero() && end.IsZero() {
queries[i] += fmt.Sprintf(" AND time < now()")
}
// 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(" GROUP BY time(%vu) fill(none)", bucketSizeNanoSeconds)
}
}
return strings.Join(queries, "; ")
}
|
go
|
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)
var bucketSizeNanoSeconds int64 = 0
if bucketSize != 0 {
bucketSizeNanoSeconds = int64(bucketSize.Nanoseconds() / int64(time.Microsecond/time.Nanosecond))
}
queries := make([]string, len(metricKeys))
for i, key := range metricKeys {
pred := sink.keyToSelector(key)
if labels != nil {
pred += fmt.Sprintf(" AND %s", sink.labelsToPredicate(labels))
}
if !start.IsZero() {
pred += fmt.Sprintf(" AND time > '%s'", start.Format(time.RFC3339))
}
if !end.IsZero() {
pred += fmt.Sprintf(" AND time < '%s'", end.Format(time.RFC3339))
}
aggParts := make([]string, len(aggregations))
for i, agg := range aggregations {
aggParts[i] = sink.aggregationFunc(agg, fieldName)
}
queries[i] = fmt.Sprintf("SELECT %s FROM %q WHERE %s", strings.Join(aggParts, ", "), seriesName, pred)
if bucketSize != 0 {
// group by time requires we have at least one time bound
if start.IsZero() && end.IsZero() {
queries[i] += fmt.Sprintf(" AND time < now()")
}
// 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(" GROUP BY time(%vu) fill(none)", bucketSizeNanoSeconds)
}
}
return strings.Join(queries, "; ")
}
|
[
"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",
"var",
"bucketSizeNanoSeconds",
"int64",
"=",
"0",
"\n",
"if",
"bucketSize",
"!=",
"0",
"{",
"bucketSizeNanoSeconds",
"=",
"int64",
"(",
"bucketSize",
".",
"Nanoseconds",
"(",
")",
"/",
"int64",
"(",
"time",
".",
"Microsecond",
"/",
"time",
".",
"Nanosecond",
")",
")",
"\n",
"}",
"\n",
"queries",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"metricKeys",
")",
")",
"\n",
"for",
"i",
",",
"key",
":=",
"range",
"metricKeys",
"{",
"pred",
":=",
"sink",
".",
"keyToSelector",
"(",
"key",
")",
"\n",
"if",
"labels",
"!=",
"nil",
"{",
"pred",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\" AND %s\"",
",",
"sink",
".",
"labelsToPredicate",
"(",
"labels",
")",
")",
"\n",
"}",
"\n",
"if",
"!",
"start",
".",
"IsZero",
"(",
")",
"{",
"pred",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\" AND time > '%s'\"",
",",
"start",
".",
"Format",
"(",
"time",
".",
"RFC3339",
")",
")",
"\n",
"}",
"\n",
"if",
"!",
"end",
".",
"IsZero",
"(",
")",
"{",
"pred",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\" AND time < '%s'\"",
",",
"end",
".",
"Format",
"(",
"time",
".",
"RFC3339",
")",
")",
"\n",
"}",
"\n",
"aggParts",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"aggregations",
")",
")",
"\n",
"for",
"i",
",",
"agg",
":=",
"range",
"aggregations",
"{",
"aggParts",
"[",
"i",
"]",
"=",
"sink",
".",
"aggregationFunc",
"(",
"agg",
",",
"fieldName",
")",
"\n",
"}",
"\n",
"queries",
"[",
"i",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"SELECT %s FROM %q WHERE %s\"",
",",
"strings",
".",
"Join",
"(",
"aggParts",
",",
"\", \"",
")",
",",
"seriesName",
",",
"pred",
")",
"\n",
"if",
"bucketSize",
"!=",
"0",
"{",
"if",
"start",
".",
"IsZero",
"(",
")",
"&&",
"end",
".",
"IsZero",
"(",
")",
"{",
"queries",
"[",
"i",
"]",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\" AND time < now()\"",
")",
"\n",
"}",
"\n",
"queries",
"[",
"i",
"]",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\" GROUP BY time(%vu) fill(none)\"",
",",
"bucketSizeNanoSeconds",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"strings",
".",
"Join",
"(",
"queries",
",",
"\"; \"",
")",
"\n",
"}"
] |
// composeAggregateQuery creates the InfluxQL query to fetch the given aggregation values
|
[
"composeAggregateQuery",
"creates",
"the",
"InfluxQL",
"query",
"to",
"fetch",
"the",
"given",
"aggregation",
"values"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sinks/influxdb/influxdb_historical.go#L337-L378
|
train
|
kubernetes-retired/heapster
|
metrics/sinks/influxdb/influxdb_historical.go
|
parseAggregateQueryRow
|
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))
wasInt := make(map[string]bool, len(aggregationLookup))
for i, rawVal := range rawRow.Values {
val := core.TimestampedAggregationValue{
BucketSize: bucketSize,
AggregationValue: core.AggregationValue{
Aggregations: map[core.AggregationType]core.MetricValue{},
},
}
if ts, err := time.Parse(time.RFC3339, rawVal[0].(string)); err != nil {
return nil, fmt.Errorf("Unable to parse timestamp %q in series %q", rawVal[0].(string), rawRow.Name)
} else {
val.Timestamp = ts
}
// 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("Unable to parse count value in series %q: %v", rawRow.Name, err)
return nil, fmt.Errorf("Unable to parse values in series %q", rawRow.Name)
}
}
// 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
}
vals[i] = val
}
// figure out whether each aggregation was full of float values, or int values
setAggregationValueTypes(vals, wasInt)
return vals, nil
}
|
go
|
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))
wasInt := make(map[string]bool, len(aggregationLookup))
for i, rawVal := range rawRow.Values {
val := core.TimestampedAggregationValue{
BucketSize: bucketSize,
AggregationValue: core.AggregationValue{
Aggregations: map[core.AggregationType]core.MetricValue{},
},
}
if ts, err := time.Parse(time.RFC3339, rawVal[0].(string)); err != nil {
return nil, fmt.Errorf("Unable to parse timestamp %q in series %q", rawVal[0].(string), rawRow.Name)
} else {
val.Timestamp = ts
}
// 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("Unable to parse count value in series %q: %v", rawRow.Name, err)
return nil, fmt.Errorf("Unable to parse values in series %q", rawRow.Name)
}
}
// 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
}
vals[i] = val
}
// figure out whether each aggregation was full of float values, or int values
setAggregationValueTypes(vals, wasInt)
return vals, nil
}
|
[
"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",
"for",
"i",
",",
"rawVal",
":=",
"range",
"rawRow",
".",
"Values",
"{",
"val",
":=",
"core",
".",
"TimestampedAggregationValue",
"{",
"BucketSize",
":",
"bucketSize",
",",
"AggregationValue",
":",
"core",
".",
"AggregationValue",
"{",
"Aggregations",
":",
"map",
"[",
"core",
".",
"AggregationType",
"]",
"core",
".",
"MetricValue",
"{",
"}",
",",
"}",
",",
"}",
"\n",
"if",
"ts",
",",
"err",
":=",
"time",
".",
"Parse",
"(",
"time",
".",
"RFC3339",
",",
"rawVal",
"[",
"0",
"]",
".",
"(",
"string",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"Unable to parse timestamp %q in series %q\"",
",",
"rawVal",
"[",
"0",
"]",
".",
"(",
"string",
")",
",",
"rawRow",
".",
"Name",
")",
"\n",
"}",
"else",
"{",
"val",
".",
"Timestamp",
"=",
"ts",
"\n",
"}",
"\n",
"if",
"countIndex",
",",
"ok",
":=",
"aggregationLookup",
"[",
"core",
".",
"AggregationTypeCount",
"]",
";",
"ok",
"{",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"[",
"]",
"byte",
"(",
"rawVal",
"[",
"countIndex",
"]",
".",
"(",
"json",
".",
"Number",
")",
".",
"String",
"(",
")",
")",
",",
"&",
"val",
".",
"Count",
")",
";",
"err",
"!=",
"nil",
"{",
"glog",
".",
"Errorf",
"(",
"\"Unable to parse count value in series %q: %v\"",
",",
"rawRow",
".",
"Name",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"Unable to parse values in series %q\"",
",",
"rawRow",
".",
"Name",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
":=",
"populateAggregations",
"(",
"rawRow",
".",
"Name",
",",
"rawVal",
",",
"&",
"val",
",",
"aggregationLookup",
",",
"wasInt",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"vals",
"[",
"i",
"]",
"=",
"val",
"\n",
"}",
"\n",
"setAggregationValueTypes",
"(",
"vals",
",",
"wasInt",
")",
"\n",
"return",
"vals",
",",
"nil",
"\n",
"}"
] |
// parseRawQueryRow parses a set of timestamped aggregation values from unstructured JSON output into the
// appropriate Heapster form
|
[
"parseRawQueryRow",
"parses",
"a",
"set",
"of",
"timestamped",
"aggregation",
"values",
"from",
"unstructured",
"JSON",
"output",
"into",
"the",
"appropriate",
"Heapster",
"form"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sinks/influxdb/influxdb_historical.go#L382-L422
|
train
|
kubernetes-retired/heapster
|
metrics/sinks/influxdb/influxdb_historical.go
|
setAggregationValueIfPresent
|
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{}
if err := tryParseMetricValue(string(aggName), rawVal, targetValue, fieldIndex, wasInt); err != nil {
return err
}
aggregations.Aggregations[aggName] = *targetValue
}
return nil
}
|
go
|
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{}
if err := tryParseMetricValue(string(aggName), rawVal, targetValue, fieldIndex, wasInt); err != nil {
return err
}
aggregations.Aggregations[aggName] = *targetValue
}
return nil
}
|
[
"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",
"aggregations",
".",
"Aggregations",
"[",
"aggName",
"]",
"=",
"*",
"targetValue",
"\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
|
[
"setAggregationValueIfPresent",
"checks",
"if",
"the",
"given",
"metric",
"value",
"is",
"present",
"in",
"the",
"list",
"of",
"raw",
"values",
"and",
"if",
"so",
"copies",
"it",
"to",
"the",
"output",
"format"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sinks/influxdb/influxdb_historical.go#L524-L535
|
train
|
kubernetes-retired/heapster
|
metrics/sinks/influxdb/influxdb_historical.go
|
tryParseMetricValue
|
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
if rvN, ok := rawVal[fieldIndex].(json.Number); !ok {
return fmt.Errorf("Value %q of metric %q was not a json.Number", rawVal[fieldIndex], aggName)
} else {
rv = rvN.String()
}
tryInt := false
isInt, triedBefore := wasInt[aggName]
tryInt = isInt || !triedBefore
if tryInt {
if err := json.Unmarshal([]byte(rv), &targetValue.IntValue); err != nil {
wasInt[aggName] = false
} else {
wasInt[aggName] = true
}
}
if err := json.Unmarshal([]byte(rv), &targetValue.FloatValue); err != nil {
return err
}
return nil
}
|
go
|
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
if rvN, ok := rawVal[fieldIndex].(json.Number); !ok {
return fmt.Errorf("Value %q of metric %q was not a json.Number", rawVal[fieldIndex], aggName)
} else {
rv = rvN.String()
}
tryInt := false
isInt, triedBefore := wasInt[aggName]
tryInt = isInt || !triedBefore
if tryInt {
if err := json.Unmarshal([]byte(rv), &targetValue.IntValue); err != nil {
wasInt[aggName] = false
} else {
wasInt[aggName] = true
}
}
if err := json.Unmarshal([]byte(rv), &targetValue.FloatValue); err != nil {
return err
}
return nil
}
|
[
"func",
"tryParseMetricValue",
"(",
"aggName",
"string",
",",
"rawVal",
"[",
"]",
"interface",
"{",
"}",
",",
"targetValue",
"*",
"core",
".",
"MetricValue",
",",
"fieldIndex",
"int",
",",
"wasInt",
"map",
"[",
"string",
"]",
"bool",
")",
"error",
"{",
"var",
"rv",
"string",
"\n",
"if",
"rvN",
",",
"ok",
":=",
"rawVal",
"[",
"fieldIndex",
"]",
".",
"(",
"json",
".",
"Number",
")",
";",
"!",
"ok",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"Value %q of metric %q was not a json.Number\"",
",",
"rawVal",
"[",
"fieldIndex",
"]",
",",
"aggName",
")",
"\n",
"}",
"else",
"{",
"rv",
"=",
"rvN",
".",
"String",
"(",
")",
"\n",
"}",
"\n",
"tryInt",
":=",
"false",
"\n",
"isInt",
",",
"triedBefore",
":=",
"wasInt",
"[",
"aggName",
"]",
"\n",
"tryInt",
"=",
"isInt",
"||",
"!",
"triedBefore",
"\n",
"if",
"tryInt",
"{",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"[",
"]",
"byte",
"(",
"rv",
")",
",",
"&",
"targetValue",
".",
"IntValue",
")",
";",
"err",
"!=",
"nil",
"{",
"wasInt",
"[",
"aggName",
"]",
"=",
"false",
"\n",
"}",
"else",
"{",
"wasInt",
"[",
"aggName",
"]",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"[",
"]",
"byte",
"(",
"rv",
")",
",",
"&",
"targetValue",
".",
"FloatValue",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// tryParseMetricValue attempts to parse a raw metric value into the appropriate go type.
|
[
"tryParseMetricValue",
"attempts",
"to",
"parse",
"a",
"raw",
"metric",
"value",
"into",
"the",
"appropriate",
"go",
"type",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sinks/influxdb/influxdb_historical.go#L538-L567
|
train
|
kubernetes-retired/heapster
|
metrics/sinks/influxdb/influxdb_historical.go
|
GetMetricNames
|
func (sink *influxdbSink) GetMetricNames(metricKey core.HistoricalKey) ([]string, error) {
if err := sink.checkSanitizedKey(&metricKey); err != nil {
return nil, err
}
return sink.stringListQuery(fmt.Sprintf("SHOW MEASUREMENTS WHERE %s", sink.keyToSelector(metricKey)), "Unable to list available metrics")
}
|
go
|
func (sink *influxdbSink) GetMetricNames(metricKey core.HistoricalKey) ([]string, error) {
if err := sink.checkSanitizedKey(&metricKey); err != nil {
return nil, err
}
return sink.stringListQuery(fmt.Sprintf("SHOW MEASUREMENTS WHERE %s", sink.keyToSelector(metricKey)), "Unable to list available metrics")
}
|
[
"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",
"(",
"\"SHOW MEASUREMENTS WHERE %s\"",
",",
"sink",
".",
"keyToSelector",
"(",
"metricKey",
")",
")",
",",
"\"Unable to list available metrics\"",
")",
"\n",
"}"
] |
// GetMetricNames retrieves the available metric names for the given object
|
[
"GetMetricNames",
"retrieves",
"the",
"available",
"metric",
"names",
"for",
"the",
"given",
"object"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sinks/influxdb/influxdb_historical.go#L570-L575
|
train
|
kubernetes-retired/heapster
|
metrics/sinks/influxdb/influxdb_historical.go
|
GetNodes
|
func (sink *influxdbSink) GetNodes() ([]string, error) {
return sink.stringListQuery(fmt.Sprintf("SHOW TAG VALUES WITH KEY = %s", core.LabelNodename.Key), "Unable to list all nodes")
}
|
go
|
func (sink *influxdbSink) GetNodes() ([]string, error) {
return sink.stringListQuery(fmt.Sprintf("SHOW TAG VALUES WITH KEY = %s", core.LabelNodename.Key), "Unable to list all nodes")
}
|
[
"func",
"(",
"sink",
"*",
"influxdbSink",
")",
"GetNodes",
"(",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"return",
"sink",
".",
"stringListQuery",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"SHOW TAG VALUES WITH KEY = %s\"",
",",
"core",
".",
"LabelNodename",
".",
"Key",
")",
",",
"\"Unable to list all nodes\"",
")",
"\n",
"}"
] |
// GetNodes retrieves the list of nodes in the cluster
|
[
"GetNodes",
"retrieves",
"the",
"list",
"of",
"nodes",
"in",
"the",
"cluster"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sinks/influxdb/influxdb_historical.go#L578-L580
|
train
|
kubernetes-retired/heapster
|
metrics/sinks/influxdb/influxdb_historical.go
|
GetNamespaces
|
func (sink *influxdbSink) GetNamespaces() ([]string, error) {
return sink.stringListQuery(fmt.Sprintf("SHOW TAG VALUES WITH KEY = %s", core.LabelNamespaceName.Key), "Unable to list all namespaces")
}
|
go
|
func (sink *influxdbSink) GetNamespaces() ([]string, error) {
return sink.stringListQuery(fmt.Sprintf("SHOW TAG VALUES WITH KEY = %s", core.LabelNamespaceName.Key), "Unable to list all namespaces")
}
|
[
"func",
"(",
"sink",
"*",
"influxdbSink",
")",
"GetNamespaces",
"(",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"return",
"sink",
".",
"stringListQuery",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"SHOW TAG VALUES WITH KEY = %s\"",
",",
"core",
".",
"LabelNamespaceName",
".",
"Key",
")",
",",
"\"Unable to list all namespaces\"",
")",
"\n",
"}"
] |
// GetNamespaces retrieves the list of namespaces in the cluster
|
[
"GetNamespaces",
"retrieves",
"the",
"list",
"of",
"namespaces",
"in",
"the",
"cluster"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sinks/influxdb/influxdb_historical.go#L583-L585
|
train
|
kubernetes-retired/heapster
|
metrics/sinks/influxdb/influxdb_historical.go
|
GetPodsFromNamespace
|
func (sink *influxdbSink) GetPodsFromNamespace(namespace string) ([]string, error) {
if !nameAllowedChars.MatchString(namespace) {
return nil, fmt.Errorf("Invalid namespace name %q", namespace)
}
// 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("SHOW SERIES FROM %q WHERE %s = '%s' AND type = '%s'", core.MetricUptime.MetricDescriptor.Name, core.LabelNamespaceName.Key, namespace, core.MetricSetTypePod)
return sink.stringListQueryCol(q, core.LabelPodName.Key, fmt.Sprintf("Unable to list pods in namespace %q", namespace))
}
|
go
|
func (sink *influxdbSink) GetPodsFromNamespace(namespace string) ([]string, error) {
if !nameAllowedChars.MatchString(namespace) {
return nil, fmt.Errorf("Invalid namespace name %q", namespace)
}
// 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("SHOW SERIES FROM %q WHERE %s = '%s' AND type = '%s'", core.MetricUptime.MetricDescriptor.Name, core.LabelNamespaceName.Key, namespace, core.MetricSetTypePod)
return sink.stringListQueryCol(q, core.LabelPodName.Key, fmt.Sprintf("Unable to list pods in namespace %q", namespace))
}
|
[
"func",
"(",
"sink",
"*",
"influxdbSink",
")",
"GetPodsFromNamespace",
"(",
"namespace",
"string",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"if",
"!",
"nameAllowedChars",
".",
"MatchString",
"(",
"namespace",
")",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"Invalid namespace name %q\"",
",",
"namespace",
")",
"\n",
"}",
"\n",
"q",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"SHOW SERIES FROM %q WHERE %s = '%s' AND type = '%s'\"",
",",
"core",
".",
"MetricUptime",
".",
"MetricDescriptor",
".",
"Name",
",",
"core",
".",
"LabelNamespaceName",
".",
"Key",
",",
"namespace",
",",
"core",
".",
"MetricSetTypePod",
")",
"\n",
"return",
"sink",
".",
"stringListQueryCol",
"(",
"q",
",",
"core",
".",
"LabelPodName",
".",
"Key",
",",
"fmt",
".",
"Sprintf",
"(",
"\"Unable to list pods in namespace %q\"",
",",
"namespace",
")",
")",
"\n",
"}"
] |
// GetPodsFromNamespace retrieves the list of pods in a given namespace
|
[
"GetPodsFromNamespace",
"retrieves",
"the",
"list",
"of",
"pods",
"in",
"a",
"given",
"namespace"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sinks/influxdb/influxdb_historical.go#L588-L597
|
train
|
kubernetes-retired/heapster
|
metrics/sinks/influxdb/influxdb_historical.go
|
GetSystemContainersFromNode
|
func (sink *influxdbSink) GetSystemContainersFromNode(node string) ([]string, error) {
if !nameAllowedChars.MatchString(node) {
return nil, fmt.Errorf("Invalid node name %q", node)
}
// 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("SHOW SERIES FROM %q WHERE %s = '%s' AND type = '%s'", core.MetricUptime.MetricDescriptor.Name, core.LabelNodename.Key, node, core.MetricSetTypeSystemContainer)
return sink.stringListQueryCol(q, core.LabelContainerName.Key, fmt.Sprintf("Unable to list system containers on node %q", node))
}
|
go
|
func (sink *influxdbSink) GetSystemContainersFromNode(node string) ([]string, error) {
if !nameAllowedChars.MatchString(node) {
return nil, fmt.Errorf("Invalid node name %q", node)
}
// 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("SHOW SERIES FROM %q WHERE %s = '%s' AND type = '%s'", core.MetricUptime.MetricDescriptor.Name, core.LabelNodename.Key, node, core.MetricSetTypeSystemContainer)
return sink.stringListQueryCol(q, core.LabelContainerName.Key, fmt.Sprintf("Unable to list system containers on node %q", node))
}
|
[
"func",
"(",
"sink",
"*",
"influxdbSink",
")",
"GetSystemContainersFromNode",
"(",
"node",
"string",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"if",
"!",
"nameAllowedChars",
".",
"MatchString",
"(",
"node",
")",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"Invalid node name %q\"",
",",
"node",
")",
"\n",
"}",
"\n",
"q",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"SHOW SERIES FROM %q WHERE %s = '%s' AND type = '%s'\"",
",",
"core",
".",
"MetricUptime",
".",
"MetricDescriptor",
".",
"Name",
",",
"core",
".",
"LabelNodename",
".",
"Key",
",",
"node",
",",
"core",
".",
"MetricSetTypeSystemContainer",
")",
"\n",
"return",
"sink",
".",
"stringListQueryCol",
"(",
"q",
",",
"core",
".",
"LabelContainerName",
".",
"Key",
",",
"fmt",
".",
"Sprintf",
"(",
"\"Unable to list system containers on node %q\"",
",",
"node",
")",
")",
"\n",
"}"
] |
// GetSystemContainersFromNode retrieves the list of free containers for a given node
|
[
"GetSystemContainersFromNode",
"retrieves",
"the",
"list",
"of",
"free",
"containers",
"for",
"a",
"given",
"node"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sinks/influxdb/influxdb_historical.go#L600-L609
|
train
|
kubernetes-retired/heapster
|
metrics/sinks/influxdb/influxdb_historical.go
|
stringListQueryCol
|
func (sink *influxdbSink) stringListQueryCol(q, colName string, errStr string) ([]string, error) {
sink.RLock()
defer sink.RUnlock()
resp, err := sink.runQuery(q)
if err != nil {
return nil, fmt.Errorf(errStr)
}
if len(resp[0].Series) < 1 {
return nil, fmt.Errorf(errStr)
}
colInd := -1
for i, col := range resp[0].Series[0].Columns {
if col == colName {
colInd = i
break
}
}
if colInd == -1 {
glog.Errorf("%s: results did not contain the %q column", errStr, core.LabelPodName.Key)
return nil, fmt.Errorf(errStr)
}
res := make([]string, len(resp[0].Series[0].Values))
for i, rv := range resp[0].Series[0].Values {
res[i] = rv[colInd].(string)
}
return res, nil
}
|
go
|
func (sink *influxdbSink) stringListQueryCol(q, colName string, errStr string) ([]string, error) {
sink.RLock()
defer sink.RUnlock()
resp, err := sink.runQuery(q)
if err != nil {
return nil, fmt.Errorf(errStr)
}
if len(resp[0].Series) < 1 {
return nil, fmt.Errorf(errStr)
}
colInd := -1
for i, col := range resp[0].Series[0].Columns {
if col == colName {
colInd = i
break
}
}
if colInd == -1 {
glog.Errorf("%s: results did not contain the %q column", errStr, core.LabelPodName.Key)
return nil, fmt.Errorf(errStr)
}
res := make([]string, len(resp[0].Series[0].Values))
for i, rv := range resp[0].Series[0].Values {
res[i] = rv[colInd].(string)
}
return res, nil
}
|
[
"func",
"(",
"sink",
"*",
"influxdbSink",
")",
"stringListQueryCol",
"(",
"q",
",",
"colName",
"string",
",",
"errStr",
"string",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"sink",
".",
"RLock",
"(",
")",
"\n",
"defer",
"sink",
".",
"RUnlock",
"(",
")",
"\n",
"resp",
",",
"err",
":=",
"sink",
".",
"runQuery",
"(",
"q",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"errStr",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"resp",
"[",
"0",
"]",
".",
"Series",
")",
"<",
"1",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"errStr",
")",
"\n",
"}",
"\n",
"colInd",
":=",
"-",
"1",
"\n",
"for",
"i",
",",
"col",
":=",
"range",
"resp",
"[",
"0",
"]",
".",
"Series",
"[",
"0",
"]",
".",
"Columns",
"{",
"if",
"col",
"==",
"colName",
"{",
"colInd",
"=",
"i",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"colInd",
"==",
"-",
"1",
"{",
"glog",
".",
"Errorf",
"(",
"\"%s: results did not contain the %q column\"",
",",
"errStr",
",",
"core",
".",
"LabelPodName",
".",
"Key",
")",
"\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"errStr",
")",
"\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
|
[
"stringListQueryCol",
"runs",
"the",
"given",
"query",
"and",
"returns",
"all",
"results",
"from",
"the",
"given",
"column",
"as",
"a",
"string",
"list"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sinks/influxdb/influxdb_historical.go#L612-L643
|
train
|
kubernetes-retired/heapster
|
metrics/sinks/influxdb/influxdb_historical.go
|
stringListQuery
|
func (sink *influxdbSink) stringListQuery(q string, errStr string) ([]string, error) {
sink.RLock()
defer sink.RUnlock()
resp, err := sink.runQuery(q)
if err != nil {
return nil, fmt.Errorf(errStr)
}
if len(resp[0].Series) < 1 {
return nil, fmt.Errorf(errStr)
}
res := make([]string, len(resp[0].Series[0].Values))
for i, rv := range resp[0].Series[0].Values {
res[i] = rv[0].(string)
}
return res, nil
}
|
go
|
func (sink *influxdbSink) stringListQuery(q string, errStr string) ([]string, error) {
sink.RLock()
defer sink.RUnlock()
resp, err := sink.runQuery(q)
if err != nil {
return nil, fmt.Errorf(errStr)
}
if len(resp[0].Series) < 1 {
return nil, fmt.Errorf(errStr)
}
res := make([]string, len(resp[0].Series[0].Values))
for i, rv := range resp[0].Series[0].Values {
res[i] = rv[0].(string)
}
return res, nil
}
|
[
"func",
"(",
"sink",
"*",
"influxdbSink",
")",
"stringListQuery",
"(",
"q",
"string",
",",
"errStr",
"string",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"sink",
".",
"RLock",
"(",
")",
"\n",
"defer",
"sink",
".",
"RUnlock",
"(",
")",
"\n",
"resp",
",",
"err",
":=",
"sink",
".",
"runQuery",
"(",
"q",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"errStr",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"resp",
"[",
"0",
"]",
".",
"Series",
")",
"<",
"1",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"errStr",
")",
"\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
|
[
"stringListQuery",
"runs",
"the",
"given",
"query",
"and",
"returns",
"all",
"results",
"from",
"the",
"first",
"column",
"as",
"a",
"string",
"list"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sinks/influxdb/influxdb_historical.go#L646-L664
|
train
|
kubernetes-retired/heapster
|
metrics/sinks/influxdb/influxdb_historical.go
|
populateAggregations
|
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("Unable to parse field %q in series %q: %v", aggregation, rawRowName, err)
return fmt.Errorf("Unable to parse values in series %q", rawRowName)
}
}
return nil
}
|
go
|
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("Unable to parse field %q in series %q: %v", aggregation, rawRowName, err)
return fmt.Errorf("Unable to parse values in series %q", rawRowName)
}
}
return nil
}
|
[
"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",
"(",
"\"Unable to parse field %q in series %q: %v\"",
",",
"aggregation",
",",
"rawRowName",
",",
"err",
")",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"Unable to parse values in series %q\"",
",",
"rawRowName",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// populateAggregations extracts aggregation values from a given data point
|
[
"populateAggregations",
"extracts",
"aggregation",
"values",
"from",
"a",
"given",
"data",
"point"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sinks/influxdb/influxdb_historical.go#L700-L709
|
train
|
kubernetes-retired/heapster
|
metrics/sinks/influxdb/influxdb_historical.go
|
setAggregationValueTypes
|
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]
val.ValueType = core.ValueInt64
vals[i].Aggregations[aggregation] = val
}
} else if ok {
for i := range vals {
val := vals[i].Aggregations[aggregation]
val.ValueType = core.ValueFloat
vals[i].Aggregations[aggregation] = val
}
}
}
}
|
go
|
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]
val.ValueType = core.ValueInt64
vals[i].Aggregations[aggregation] = val
}
} else if ok {
for i := range vals {
val := vals[i].Aggregations[aggregation]
val.ValueType = core.ValueFloat
vals[i].Aggregations[aggregation] = val
}
}
}
}
|
[
"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
|
[
"setAggregationValueTypes",
"inspects",
"a",
"set",
"of",
"aggregation",
"values",
"and",
"figures",
"out",
"whether",
"each",
"aggregation",
"value",
"returned",
"as",
"a",
"float",
"column",
"or",
"an",
"int",
"column"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sinks/influxdb/influxdb_historical.go#L713-L729
|
train
|
kubernetes-retired/heapster
|
metrics/sinks/gcm/gcm.go
|
register
|
func (sink *gcmSink) register(metrics []core.Metric) error {
sink.Lock()
defer sink.Unlock()
if sink.registered {
return nil
}
for _, metric := range metrics {
metricName := fullMetricName(sink.project, metric.MetricDescriptor.Name)
metricType := fullMetricType(metric.MetricDescriptor.Name)
if _, err := sink.gcmService.Projects.MetricDescriptors.Delete(metricName).Do(); err != nil {
glog.Infof("[GCM] Deleting metric %v failed: %v", metricName, err)
}
labels := make([]*gcm.LabelDescriptor, 0)
// 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
}
for _, l := range core.GcmNodeAutoscalingLabels() {
labels = append(labels, &gcm.LabelDescriptor{
Key: l.Key,
Description: l.Description,
})
}
} else {
// Only all.
if sink.metricFilter != metricsAll {
continue
}
for _, l := range core.GcmLabels() {
labels = append(labels, &gcm.LabelDescriptor{
Key: l.Key,
Description: l.Description,
})
}
}
var metricKind string
switch metric.MetricDescriptor.Type {
case core.MetricCumulative:
metricKind = "CUMULATIVE"
case core.MetricGauge:
metricKind = "GAUGE"
case core.MetricDelta:
metricKind = "DELTA"
}
var valueType string
switch metric.MetricDescriptor.ValueType {
case core.ValueInt64:
valueType = "INT64"
case core.ValueFloat:
valueType = "DOUBLE"
}
desc := &gcm.MetricDescriptor{
Name: metricName,
Description: metric.MetricDescriptor.Description,
Labels: labels,
MetricKind: metricKind,
ValueType: valueType,
Type: metricType,
}
if _, err := sink.gcmService.Projects.MetricDescriptors.Create(fullProjectName(sink.project), desc).Do(); err != nil {
glog.Errorf("Metric registration of %v failed: %v", desc.Name, err)
return err
}
}
sink.registered = true
return nil
}
|
go
|
func (sink *gcmSink) register(metrics []core.Metric) error {
sink.Lock()
defer sink.Unlock()
if sink.registered {
return nil
}
for _, metric := range metrics {
metricName := fullMetricName(sink.project, metric.MetricDescriptor.Name)
metricType := fullMetricType(metric.MetricDescriptor.Name)
if _, err := sink.gcmService.Projects.MetricDescriptors.Delete(metricName).Do(); err != nil {
glog.Infof("[GCM] Deleting metric %v failed: %v", metricName, err)
}
labels := make([]*gcm.LabelDescriptor, 0)
// 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
}
for _, l := range core.GcmNodeAutoscalingLabels() {
labels = append(labels, &gcm.LabelDescriptor{
Key: l.Key,
Description: l.Description,
})
}
} else {
// Only all.
if sink.metricFilter != metricsAll {
continue
}
for _, l := range core.GcmLabels() {
labels = append(labels, &gcm.LabelDescriptor{
Key: l.Key,
Description: l.Description,
})
}
}
var metricKind string
switch metric.MetricDescriptor.Type {
case core.MetricCumulative:
metricKind = "CUMULATIVE"
case core.MetricGauge:
metricKind = "GAUGE"
case core.MetricDelta:
metricKind = "DELTA"
}
var valueType string
switch metric.MetricDescriptor.ValueType {
case core.ValueInt64:
valueType = "INT64"
case core.ValueFloat:
valueType = "DOUBLE"
}
desc := &gcm.MetricDescriptor{
Name: metricName,
Description: metric.MetricDescriptor.Description,
Labels: labels,
MetricKind: metricKind,
ValueType: valueType,
Type: metricType,
}
if _, err := sink.gcmService.Projects.MetricDescriptors.Create(fullProjectName(sink.project), desc).Do(); err != nil {
glog.Errorf("Metric registration of %v failed: %v", desc.Name, err)
return err
}
}
sink.registered = true
return nil
}
|
[
"func",
"(",
"sink",
"*",
"gcmSink",
")",
"register",
"(",
"metrics",
"[",
"]",
"core",
".",
"Metric",
")",
"error",
"{",
"sink",
".",
"Lock",
"(",
")",
"\n",
"defer",
"sink",
".",
"Unlock",
"(",
")",
"\n",
"if",
"sink",
".",
"registered",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"for",
"_",
",",
"metric",
":=",
"range",
"metrics",
"{",
"metricName",
":=",
"fullMetricName",
"(",
"sink",
".",
"project",
",",
"metric",
".",
"MetricDescriptor",
".",
"Name",
")",
"\n",
"metricType",
":=",
"fullMetricType",
"(",
"metric",
".",
"MetricDescriptor",
".",
"Name",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"sink",
".",
"gcmService",
".",
"Projects",
".",
"MetricDescriptors",
".",
"Delete",
"(",
"metricName",
")",
".",
"Do",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"glog",
".",
"Infof",
"(",
"\"[GCM] Deleting metric %v failed: %v\"",
",",
"metricName",
",",
"err",
")",
"\n",
"}",
"\n",
"labels",
":=",
"make",
"(",
"[",
"]",
"*",
"gcm",
".",
"LabelDescriptor",
",",
"0",
")",
"\n",
"if",
"core",
".",
"IsNodeAutoscalingMetric",
"(",
"metric",
".",
"MetricDescriptor",
".",
"Name",
")",
"{",
"if",
"sink",
".",
"metricFilter",
"!=",
"metricsAll",
"&&",
"sink",
".",
"metricFilter",
"!=",
"metricsOnlyAutoscaling",
"{",
"continue",
"\n",
"}",
"\n",
"for",
"_",
",",
"l",
":=",
"range",
"core",
".",
"GcmNodeAutoscalingLabels",
"(",
")",
"{",
"labels",
"=",
"append",
"(",
"labels",
",",
"&",
"gcm",
".",
"LabelDescriptor",
"{",
"Key",
":",
"l",
".",
"Key",
",",
"Description",
":",
"l",
".",
"Description",
",",
"}",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"if",
"sink",
".",
"metricFilter",
"!=",
"metricsAll",
"{",
"continue",
"\n",
"}",
"\n",
"for",
"_",
",",
"l",
":=",
"range",
"core",
".",
"GcmLabels",
"(",
")",
"{",
"labels",
"=",
"append",
"(",
"labels",
",",
"&",
"gcm",
".",
"LabelDescriptor",
"{",
"Key",
":",
"l",
".",
"Key",
",",
"Description",
":",
"l",
".",
"Description",
",",
"}",
")",
"\n",
"}",
"\n",
"}",
"\n",
"var",
"metricKind",
"string",
"\n",
"switch",
"metric",
".",
"MetricDescriptor",
".",
"Type",
"{",
"case",
"core",
".",
"MetricCumulative",
":",
"metricKind",
"=",
"\"CUMULATIVE\"",
"\n",
"case",
"core",
".",
"MetricGauge",
":",
"metricKind",
"=",
"\"GAUGE\"",
"\n",
"case",
"core",
".",
"MetricDelta",
":",
"metricKind",
"=",
"\"DELTA\"",
"\n",
"}",
"\n",
"var",
"valueType",
"string",
"\n",
"switch",
"metric",
".",
"MetricDescriptor",
".",
"ValueType",
"{",
"case",
"core",
".",
"ValueInt64",
":",
"valueType",
"=",
"\"INT64\"",
"\n",
"case",
"core",
".",
"ValueFloat",
":",
"valueType",
"=",
"\"DOUBLE\"",
"\n",
"}",
"\n",
"desc",
":=",
"&",
"gcm",
".",
"MetricDescriptor",
"{",
"Name",
":",
"metricName",
",",
"Description",
":",
"metric",
".",
"MetricDescriptor",
".",
"Description",
",",
"Labels",
":",
"labels",
",",
"MetricKind",
":",
"metricKind",
",",
"ValueType",
":",
"valueType",
",",
"Type",
":",
"metricType",
",",
"}",
"\n",
"if",
"_",
",",
"err",
":=",
"sink",
".",
"gcmService",
".",
"Projects",
".",
"MetricDescriptors",
".",
"Create",
"(",
"fullProjectName",
"(",
"sink",
".",
"project",
")",
",",
"desc",
")",
".",
"Do",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"glog",
".",
"Errorf",
"(",
"\"Metric registration of %v failed: %v\"",
",",
"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.
|
[
"Adds",
"the",
"specified",
"metrics",
"or",
"updates",
"them",
"if",
"they",
"already",
"exist",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sinks/gcm/gcm.go#L217-L297
|
train
|
kubernetes-retired/heapster
|
metrics/sinks/manager.go
|
ExportData
|
func (this *sinkManager) ExportData(data *core.DataBatch) {
var wg sync.WaitGroup
for _, sh := range this.sinkHolders {
wg.Add(1)
go func(sh sinkHolder, wg *sync.WaitGroup) {
defer wg.Done()
glog.V(2).Infof("Pushing data to: %s", sh.sink.Name())
select {
case sh.dataBatchChannel <- data:
glog.V(2).Infof("Data push completed: %s", sh.sink.Name())
// everything ok
case <-time.After(this.exportDataTimeout):
glog.Warningf("Failed to push data to sink: %s", sh.sink.Name())
}
}(sh, &wg)
}
// Wait for all pushes to complete or timeout.
wg.Wait()
}
|
go
|
func (this *sinkManager) ExportData(data *core.DataBatch) {
var wg sync.WaitGroup
for _, sh := range this.sinkHolders {
wg.Add(1)
go func(sh sinkHolder, wg *sync.WaitGroup) {
defer wg.Done()
glog.V(2).Infof("Pushing data to: %s", sh.sink.Name())
select {
case sh.dataBatchChannel <- data:
glog.V(2).Infof("Data push completed: %s", sh.sink.Name())
// everything ok
case <-time.After(this.exportDataTimeout):
glog.Warningf("Failed to push data to sink: %s", sh.sink.Name())
}
}(sh, &wg)
}
// Wait for all pushes to complete or timeout.
wg.Wait()
}
|
[
"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",
"(",
"\"Pushing data to: %s\"",
",",
"sh",
".",
"sink",
".",
"Name",
"(",
")",
")",
"\n",
"select",
"{",
"case",
"sh",
".",
"dataBatchChannel",
"<-",
"data",
":",
"glog",
".",
"V",
"(",
"2",
")",
".",
"Infof",
"(",
"\"Data push completed: %s\"",
",",
"sh",
".",
"sink",
".",
"Name",
"(",
")",
")",
"\n",
"case",
"<-",
"time",
".",
"After",
"(",
"this",
".",
"exportDataTimeout",
")",
":",
"glog",
".",
"Warningf",
"(",
"\"Failed to push data to sink: %s\"",
",",
"sh",
".",
"sink",
".",
"Name",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"(",
"sh",
",",
"&",
"wg",
")",
"\n",
"}",
"\n",
"wg",
".",
"Wait",
"(",
")",
"\n",
"}"
] |
// Guarantees that the export will complete in sinkExportDataTimeout.
|
[
"Guarantees",
"that",
"the",
"export",
"will",
"complete",
"in",
"sinkExportDataTimeout",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sinks/manager.go#L106-L124
|
train
|
kubernetes-retired/heapster
|
metrics/sources/kubelet/kubelet_client.go
|
GetAllRawContainers
|
func (self *KubeletClient) GetAllRawContainers(host Host, start, end time.Time) ([]cadvisor.ContainerInfo, error) {
url := self.getUrl(host, "/stats/container/")
return self.getAllContainers(url, start, end)
}
|
go
|
func (self *KubeletClient) GetAllRawContainers(host Host, start, end time.Time) ([]cadvisor.ContainerInfo, error) {
url := self.getUrl(host, "/stats/container/")
return self.getAllContainers(url, start, end)
}
|
[
"func",
"(",
"self",
"*",
"KubeletClient",
")",
"GetAllRawContainers",
"(",
"host",
"Host",
",",
"start",
",",
"end",
"time",
".",
"Time",
")",
"(",
"[",
"]",
"cadvisor",
".",
"ContainerInfo",
",",
"error",
")",
"{",
"url",
":=",
"self",
".",
"getUrl",
"(",
"host",
",",
"\"/stats/container/\"",
")",
"\n",
"return",
"self",
".",
"getAllContainers",
"(",
"url",
",",
"start",
",",
"end",
")",
"\n",
"}"
] |
// Get stats for all non-Kubernetes containers.
|
[
"Get",
"stats",
"for",
"all",
"non",
"-",
"Kubernetes",
"containers",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sources/kubelet/kubelet_client.go#L152-L156
|
train
|
kubernetes-retired/heapster
|
metrics/util/metrics/http.go
|
InstrumentRouteFunc
|
func InstrumentRouteFunc(handlerName string, routeFunc restful.RouteFunction) restful.RouteFunction {
opts := prometheus.SummaryOpts{
Subsystem: "http",
ConstLabels: prometheus.Labels{"handler": handlerName},
}
reqCnt := prometheus.NewCounterVec(
prometheus.CounterOpts{
Subsystem: opts.Subsystem,
Name: "requests_total",
Help: "Total number of HTTP requests made.",
ConstLabels: opts.ConstLabels,
},
instLabels,
)
opts.Name = "request_duration_microseconds"
opts.Help = "The HTTP request latencies in microseconds."
reqDur := prometheus.NewSummary(opts)
opts.Name = "request_size_bytes"
opts.Help = "The HTTP request sizes in bytes."
reqSz := prometheus.NewSummary(opts)
opts.Name = "response_size_bytes"
opts.Help = "The HTTP response sizes in bytes."
resSz := prometheus.NewSummary(opts)
regReqCnt := prometheus.MustRegisterOrGet(reqCnt).(*prometheus.CounterVec)
regReqDur := prometheus.MustRegisterOrGet(reqDur).(prometheus.Summary)
regReqSz := prometheus.MustRegisterOrGet(reqSz).(prometheus.Summary)
regResSz := prometheus.MustRegisterOrGet(resSz).(prometheus.Summary)
return restful.RouteFunction(func(request *restful.Request, response *restful.Response) {
now := time.Now()
delegate := &responseWriterDelegator{ResponseWriter: response.ResponseWriter}
out := make(chan int)
urlLen := 0
if request.Request.URL != nil {
urlLen = len(request.Request.URL.String())
}
go computeApproximateRequestSize(request.Request, out, urlLen)
_, cn := response.ResponseWriter.(http.CloseNotifier)
_, fl := response.ResponseWriter.(http.Flusher)
_, hj := response.ResponseWriter.(http.Hijacker)
_, rf := response.ResponseWriter.(io.ReaderFrom)
var rw http.ResponseWriter
if cn && fl && hj && rf {
rw = &fancyResponseWriterDelegator{delegate}
} else {
rw = delegate
}
response.ResponseWriter = rw
routeFunc(request, response)
elapsed := float64(time.Since(now)) / float64(time.Microsecond)
method := strings.ToLower(request.Request.Method)
code := strconv.Itoa(delegate.status)
regReqCnt.WithLabelValues(method, code).Inc()
regReqDur.Observe(elapsed)
regResSz.Observe(float64(delegate.written))
regReqSz.Observe(float64(<-out))
})
}
|
go
|
func InstrumentRouteFunc(handlerName string, routeFunc restful.RouteFunction) restful.RouteFunction {
opts := prometheus.SummaryOpts{
Subsystem: "http",
ConstLabels: prometheus.Labels{"handler": handlerName},
}
reqCnt := prometheus.NewCounterVec(
prometheus.CounterOpts{
Subsystem: opts.Subsystem,
Name: "requests_total",
Help: "Total number of HTTP requests made.",
ConstLabels: opts.ConstLabels,
},
instLabels,
)
opts.Name = "request_duration_microseconds"
opts.Help = "The HTTP request latencies in microseconds."
reqDur := prometheus.NewSummary(opts)
opts.Name = "request_size_bytes"
opts.Help = "The HTTP request sizes in bytes."
reqSz := prometheus.NewSummary(opts)
opts.Name = "response_size_bytes"
opts.Help = "The HTTP response sizes in bytes."
resSz := prometheus.NewSummary(opts)
regReqCnt := prometheus.MustRegisterOrGet(reqCnt).(*prometheus.CounterVec)
regReqDur := prometheus.MustRegisterOrGet(reqDur).(prometheus.Summary)
regReqSz := prometheus.MustRegisterOrGet(reqSz).(prometheus.Summary)
regResSz := prometheus.MustRegisterOrGet(resSz).(prometheus.Summary)
return restful.RouteFunction(func(request *restful.Request, response *restful.Response) {
now := time.Now()
delegate := &responseWriterDelegator{ResponseWriter: response.ResponseWriter}
out := make(chan int)
urlLen := 0
if request.Request.URL != nil {
urlLen = len(request.Request.URL.String())
}
go computeApproximateRequestSize(request.Request, out, urlLen)
_, cn := response.ResponseWriter.(http.CloseNotifier)
_, fl := response.ResponseWriter.(http.Flusher)
_, hj := response.ResponseWriter.(http.Hijacker)
_, rf := response.ResponseWriter.(io.ReaderFrom)
var rw http.ResponseWriter
if cn && fl && hj && rf {
rw = &fancyResponseWriterDelegator{delegate}
} else {
rw = delegate
}
response.ResponseWriter = rw
routeFunc(request, response)
elapsed := float64(time.Since(now)) / float64(time.Microsecond)
method := strings.ToLower(request.Request.Method)
code := strconv.Itoa(delegate.status)
regReqCnt.WithLabelValues(method, code).Inc()
regReqDur.Observe(elapsed)
regResSz.Observe(float64(delegate.written))
regReqSz.Observe(float64(<-out))
})
}
|
[
"func",
"InstrumentRouteFunc",
"(",
"handlerName",
"string",
",",
"routeFunc",
"restful",
".",
"RouteFunction",
")",
"restful",
".",
"RouteFunction",
"{",
"opts",
":=",
"prometheus",
".",
"SummaryOpts",
"{",
"Subsystem",
":",
"\"http\"",
",",
"ConstLabels",
":",
"prometheus",
".",
"Labels",
"{",
"\"handler\"",
":",
"handlerName",
"}",
",",
"}",
"\n",
"reqCnt",
":=",
"prometheus",
".",
"NewCounterVec",
"(",
"prometheus",
".",
"CounterOpts",
"{",
"Subsystem",
":",
"opts",
".",
"Subsystem",
",",
"Name",
":",
"\"requests_total\"",
",",
"Help",
":",
"\"Total number of HTTP requests made.\"",
",",
"ConstLabels",
":",
"opts",
".",
"ConstLabels",
",",
"}",
",",
"instLabels",
",",
")",
"\n",
"opts",
".",
"Name",
"=",
"\"request_duration_microseconds\"",
"\n",
"opts",
".",
"Help",
"=",
"\"The HTTP request latencies in microseconds.\"",
"\n",
"reqDur",
":=",
"prometheus",
".",
"NewSummary",
"(",
"opts",
")",
"\n",
"opts",
".",
"Name",
"=",
"\"request_size_bytes\"",
"\n",
"opts",
".",
"Help",
"=",
"\"The HTTP request sizes in bytes.\"",
"\n",
"reqSz",
":=",
"prometheus",
".",
"NewSummary",
"(",
"opts",
")",
"\n",
"opts",
".",
"Name",
"=",
"\"response_size_bytes\"",
"\n",
"opts",
".",
"Help",
"=",
"\"The HTTP response sizes in bytes.\"",
"\n",
"resSz",
":=",
"prometheus",
".",
"NewSummary",
"(",
"opts",
")",
"\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",
"return",
"restful",
".",
"RouteFunction",
"(",
"func",
"(",
"request",
"*",
"restful",
".",
"Request",
",",
"response",
"*",
"restful",
".",
"Response",
")",
"{",
"now",
":=",
"time",
".",
"Now",
"(",
")",
"\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",
"_",
",",
"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",
"routeFunc",
"(",
"request",
",",
"response",
")",
"\n",
"elapsed",
":=",
"float64",
"(",
"time",
".",
"Since",
"(",
"now",
")",
")",
"/",
"float64",
"(",
"time",
".",
"Microsecond",
")",
"\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
|
[
"InstrumentRouteFunc",
"works",
"like",
"Prometheus",
"InstrumentHandlerFunc",
"but",
"wraps",
"the",
"go",
"-",
"restful",
"RouteFunction",
"instead",
"of",
"a",
"HandlerFunc"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/util/metrics/http.go#L36-L103
|
train
|
kubernetes-retired/heapster
|
metrics/core/ms_keys.go
|
PodContainerKey
|
func PodContainerKey(namespace, podName, containerName string) string {
return fmt.Sprintf("namespace:%s/pod:%s/container:%s", namespace, podName, containerName)
}
|
go
|
func PodContainerKey(namespace, podName, containerName string) string {
return fmt.Sprintf("namespace:%s/pod:%s/container:%s", namespace, podName, containerName)
}
|
[
"func",
"PodContainerKey",
"(",
"namespace",
",",
"podName",
",",
"containerName",
"string",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"namespace:%s/pod:%s/container:%s\"",
",",
"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.
|
[
"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",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/core/ms_keys.go#L26-L28
|
train
|
kubernetes-retired/heapster
|
metrics/processors/namespace_based_enricher.go
|
addNamespaceInfo
|
func (this *NamespaceBasedEnricher) addNamespaceInfo(metricSet *core.MetricSet) {
metricSetType, found := metricSet.Labels[core.LabelMetricSetType.Key]
if !found {
return
}
if metricSetType != core.MetricSetTypePodContainer &&
metricSetType != core.MetricSetTypePod &&
metricSetType != core.MetricSetTypeNamespace {
return
}
namespaceName, found := metricSet.Labels[core.LabelNamespaceName.Key]
if !found {
return
}
nsObj, exists, err := this.store.GetByKey(namespaceName)
if exists && err == nil {
namespace, ok := nsObj.(*kube_api.Namespace)
if ok {
metricSet.Labels[core.LabelPodNamespaceUID.Key] = string(namespace.UID)
} else {
glog.Errorf("Wrong namespace store content")
}
} else if err != nil {
glog.Warningf("Failed to get namespace %s: %v", namespaceName, err)
} else if !exists {
glog.Warningf("Namespace doesn't exist: %s", namespaceName)
}
}
|
go
|
func (this *NamespaceBasedEnricher) addNamespaceInfo(metricSet *core.MetricSet) {
metricSetType, found := metricSet.Labels[core.LabelMetricSetType.Key]
if !found {
return
}
if metricSetType != core.MetricSetTypePodContainer &&
metricSetType != core.MetricSetTypePod &&
metricSetType != core.MetricSetTypeNamespace {
return
}
namespaceName, found := metricSet.Labels[core.LabelNamespaceName.Key]
if !found {
return
}
nsObj, exists, err := this.store.GetByKey(namespaceName)
if exists && err == nil {
namespace, ok := nsObj.(*kube_api.Namespace)
if ok {
metricSet.Labels[core.LabelPodNamespaceUID.Key] = string(namespace.UID)
} else {
glog.Errorf("Wrong namespace store content")
}
} else if err != nil {
glog.Warningf("Failed to get namespace %s: %v", namespaceName, err)
} else if !exists {
glog.Warningf("Namespace doesn't exist: %s", namespaceName)
}
}
|
[
"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",
"namespaceName",
",",
"found",
":=",
"metricSet",
".",
"Labels",
"[",
"core",
".",
"LabelNamespaceName",
".",
"Key",
"]",
"\n",
"if",
"!",
"found",
"{",
"return",
"\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",
"(",
"\"Wrong namespace store content\"",
")",
"\n",
"}",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"glog",
".",
"Warningf",
"(",
"\"Failed to get namespace %s: %v\"",
",",
"namespaceName",
",",
"err",
")",
"\n",
"}",
"else",
"if",
"!",
"exists",
"{",
"glog",
".",
"Warningf",
"(",
"\"Namespace doesn't exist: %s\"",
",",
"namespaceName",
")",
"\n",
"}",
"\n",
"}"
] |
// Adds UID to all namespaced elements.
|
[
"Adds",
"UID",
"to",
"all",
"namespaced",
"elements",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/processors/namespace_based_enricher.go#L49-L78
|
train
|
kubernetes-retired/heapster
|
metrics/api/v1/model_handlers.go
|
availableClusterMetrics
|
func (a *Api) availableClusterMetrics(request *restful.Request, response *restful.Response) {
a.processMetricNamesRequest(core.ClusterKey(), response)
}
|
go
|
func (a *Api) availableClusterMetrics(request *restful.Request, response *restful.Response) {
a.processMetricNamesRequest(core.ClusterKey(), response)
}
|
[
"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.
|
[
"availableMetrics",
"returns",
"a",
"list",
"of",
"available",
"cluster",
"metric",
"names",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/api/v1/model_handlers.go#L283-L285
|
train
|
kubernetes-retired/heapster
|
metrics/api/v1/model_handlers.go
|
availableNodeMetrics
|
func (a *Api) availableNodeMetrics(request *restful.Request, response *restful.Response) {
a.processMetricNamesRequest(core.NodeKey(request.PathParameter("node-name")), response)
}
|
go
|
func (a *Api) availableNodeMetrics(request *restful.Request, response *restful.Response) {
a.processMetricNamesRequest(core.NodeKey(request.PathParameter("node-name")), response)
}
|
[
"func",
"(",
"a",
"*",
"Api",
")",
"availableNodeMetrics",
"(",
"request",
"*",
"restful",
".",
"Request",
",",
"response",
"*",
"restful",
".",
"Response",
")",
"{",
"a",
".",
"processMetricNamesRequest",
"(",
"core",
".",
"NodeKey",
"(",
"request",
".",
"PathParameter",
"(",
"\"node-name\"",
")",
")",
",",
"response",
")",
"\n",
"}"
] |
// availableMetrics returns a list of available node metric names.
|
[
"availableMetrics",
"returns",
"a",
"list",
"of",
"available",
"node",
"metric",
"names",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/api/v1/model_handlers.go#L288-L290
|
train
|
kubernetes-retired/heapster
|
metrics/api/v1/model_handlers.go
|
availableNamespaceMetrics
|
func (a *Api) availableNamespaceMetrics(request *restful.Request, response *restful.Response) {
a.processMetricNamesRequest(core.NamespaceKey(request.PathParameter("namespace-name")), response)
}
|
go
|
func (a *Api) availableNamespaceMetrics(request *restful.Request, response *restful.Response) {
a.processMetricNamesRequest(core.NamespaceKey(request.PathParameter("namespace-name")), response)
}
|
[
"func",
"(",
"a",
"*",
"Api",
")",
"availableNamespaceMetrics",
"(",
"request",
"*",
"restful",
".",
"Request",
",",
"response",
"*",
"restful",
".",
"Response",
")",
"{",
"a",
".",
"processMetricNamesRequest",
"(",
"core",
".",
"NamespaceKey",
"(",
"request",
".",
"PathParameter",
"(",
"\"namespace-name\"",
")",
")",
",",
"response",
")",
"\n",
"}"
] |
// availableMetrics returns a list of available namespace metric names.
|
[
"availableMetrics",
"returns",
"a",
"list",
"of",
"available",
"namespace",
"metric",
"names",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/api/v1/model_handlers.go#L293-L295
|
train
|
kubernetes-retired/heapster
|
metrics/api/v1/model_handlers.go
|
parseTimeParam
|
func parseTimeParam(queryParam string, defaultValue time.Time) (time.Time, error) {
if queryParam != "" {
reqStamp, err := time.Parse(time.RFC3339, queryParam)
if err != nil {
return time.Time{}, fmt.Errorf("timestamp argument cannot be parsed: %s", err)
}
return reqStamp, nil
}
return defaultValue, nil
}
|
go
|
func parseTimeParam(queryParam string, defaultValue time.Time) (time.Time, error) {
if queryParam != "" {
reqStamp, err := time.Parse(time.RFC3339, queryParam)
if err != nil {
return time.Time{}, fmt.Errorf("timestamp argument cannot be parsed: %s", err)
}
return reqStamp, nil
}
return defaultValue, nil
}
|
[
"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",
"(",
"\"timestamp argument cannot be parsed: %s\"",
",",
"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.
|
[
"parseRequestParam",
"parses",
"a",
"time",
".",
"Time",
"from",
"a",
"named",
"QueryParam",
"using",
"the",
"RFC3339",
"format",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/api/v1/model_handlers.go#L429-L438
|
train
|
kubernetes-retired/heapster
|
metrics/sinks/riemann/driver.go
|
appendEvent
|
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,
}
// state everywhere
events = append(events, event)
if len(events) >= sink.config.BatchSize {
err := riemannCommon.SendData(sink.client, events)
if err != nil {
glog.Warningf("Error sending events to Riemann: %v", err)
// client will reconnect later
sink.client = nil
}
events = nil
}
return events
}
|
go
|
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,
}
// state everywhere
events = append(events, event)
if len(events) >= sink.config.BatchSize {
err := riemannCommon.SendData(sink.client, events)
if err != nil {
glog.Warningf("Error sending events to Riemann: %v", err)
// client will reconnect later
sink.client = nil
}
events = nil
}
return events
}
|
[
"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",
"events",
"=",
"append",
"(",
"events",
",",
"event",
")",
"\n",
"if",
"len",
"(",
"events",
")",
">=",
"sink",
".",
"config",
".",
"BatchSize",
"{",
"err",
":=",
"riemannCommon",
".",
"SendData",
"(",
"sink",
".",
"client",
",",
"events",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"glog",
".",
"Warningf",
"(",
"\"Error sending events to Riemann: %v\"",
",",
"err",
")",
"\n",
"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.
|
[
"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",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sinks/riemann/driver.go#L61-L85
|
train
|
kubernetes-retired/heapster
|
metrics/sinks/riemann/driver.go
|
ExportData
|
func (sink *RiemannSink) ExportData(dataBatch *core.DataBatch) {
sink.Lock()
defer sink.Unlock()
if sink.client == nil {
// the client could be nil here, so we reconnect
client, err := riemannCommon.GetRiemannClient(sink.config)
if err != nil {
glog.Warningf("Riemann sink not connected: %v", err)
return
}
sink.client = client
}
var events []riemanngo.Event
for _, metricSet := range dataBatch.MetricSets {
host := metricSet.Labels[core.LabelHostname.Key]
for metricName, metricValue := range metricSet.MetricValues {
if value := metricValue.GetValue(); value != nil {
timestamp := dataBatch.Timestamp.Unix()
// creates an event and add it to dataEvent
events = appendEvent(events, sink, host, metricName, value, metricSet.Labels, timestamp)
}
}
for _, metric := range metricSet.LabeledMetrics {
if value := metric.GetValue(); value != nil {
labels := make(map[string]string)
for k, v := range metricSet.Labels {
labels[k] = v
}
for k, v := range metric.Labels {
labels[k] = v
}
timestamp := dataBatch.Timestamp.Unix()
// creates an event and add it to dataEvent
events = appendEvent(events, sink, host, metric.Name, value, labels, timestamp)
}
}
}
// Send events to Riemann if events is not empty
if len(events) > 0 {
err := riemannCommon.SendData(sink.client, events)
if err != nil {
glog.Warningf("Error sending events to Riemann: %v", err)
// client will reconnect later
sink.client = nil
}
}
}
|
go
|
func (sink *RiemannSink) ExportData(dataBatch *core.DataBatch) {
sink.Lock()
defer sink.Unlock()
if sink.client == nil {
// the client could be nil here, so we reconnect
client, err := riemannCommon.GetRiemannClient(sink.config)
if err != nil {
glog.Warningf("Riemann sink not connected: %v", err)
return
}
sink.client = client
}
var events []riemanngo.Event
for _, metricSet := range dataBatch.MetricSets {
host := metricSet.Labels[core.LabelHostname.Key]
for metricName, metricValue := range metricSet.MetricValues {
if value := metricValue.GetValue(); value != nil {
timestamp := dataBatch.Timestamp.Unix()
// creates an event and add it to dataEvent
events = appendEvent(events, sink, host, metricName, value, metricSet.Labels, timestamp)
}
}
for _, metric := range metricSet.LabeledMetrics {
if value := metric.GetValue(); value != nil {
labels := make(map[string]string)
for k, v := range metricSet.Labels {
labels[k] = v
}
for k, v := range metric.Labels {
labels[k] = v
}
timestamp := dataBatch.Timestamp.Unix()
// creates an event and add it to dataEvent
events = appendEvent(events, sink, host, metric.Name, value, labels, timestamp)
}
}
}
// Send events to Riemann if events is not empty
if len(events) > 0 {
err := riemannCommon.SendData(sink.client, events)
if err != nil {
glog.Warningf("Error sending events to Riemann: %v", err)
// client will reconnect later
sink.client = nil
}
}
}
|
[
"func",
"(",
"sink",
"*",
"RiemannSink",
")",
"ExportData",
"(",
"dataBatch",
"*",
"core",
".",
"DataBatch",
")",
"{",
"sink",
".",
"Lock",
"(",
")",
"\n",
"defer",
"sink",
".",
"Unlock",
"(",
")",
"\n",
"if",
"sink",
".",
"client",
"==",
"nil",
"{",
"client",
",",
"err",
":=",
"riemannCommon",
".",
"GetRiemannClient",
"(",
"sink",
".",
"config",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"glog",
".",
"Warningf",
"(",
"\"Riemann sink not connected: %v\"",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"sink",
".",
"client",
"=",
"client",
"\n",
"}",
"\n",
"var",
"events",
"[",
"]",
"riemanngo",
".",
"Event",
"\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",
"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",
"events",
"=",
"appendEvent",
"(",
"events",
",",
"sink",
",",
"host",
",",
"metric",
".",
"Name",
",",
"value",
",",
"labels",
",",
"timestamp",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"events",
")",
">",
"0",
"{",
"err",
":=",
"riemannCommon",
".",
"SendData",
"(",
"sink",
".",
"client",
",",
"events",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"glog",
".",
"Warningf",
"(",
"\"Error sending events to Riemann: %v\"",
",",
"err",
")",
"\n",
"sink",
".",
"client",
"=",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// ExportData Send a collection of Timeseries to Riemann
|
[
"ExportData",
"Send",
"a",
"collection",
"of",
"Timeseries",
"to",
"Riemann"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sinks/riemann/driver.go#L88-L137
|
train
|
kubernetes-retired/heapster
|
metrics/api/v1/historical_handlers.go
|
availableClusterMetrics
|
func (a *HistoricalApi) availableClusterMetrics(request *restful.Request, response *restful.Response) {
key := core.HistoricalKey{ObjectType: core.MetricSetTypeCluster}
a.processMetricNamesRequest(key, response)
}
|
go
|
func (a *HistoricalApi) availableClusterMetrics(request *restful.Request, response *restful.Response) {
key := core.HistoricalKey{ObjectType: core.MetricSetTypeCluster}
a.processMetricNamesRequest(key, response)
}
|
[
"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.
|
[
"availableClusterMetrics",
"returns",
"a",
"list",
"of",
"available",
"cluster",
"metric",
"names",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/api/v1/historical_handlers.go#L259-L262
|
train
|
kubernetes-retired/heapster
|
metrics/api/v1/historical_handlers.go
|
availableNodeMetrics
|
func (a *HistoricalApi) availableNodeMetrics(request *restful.Request, response *restful.Response) {
key := core.HistoricalKey{
ObjectType: core.MetricSetTypeNode,
NodeName: request.PathParameter("node-name"),
}
a.processMetricNamesRequest(key, response)
}
|
go
|
func (a *HistoricalApi) availableNodeMetrics(request *restful.Request, response *restful.Response) {
key := core.HistoricalKey{
ObjectType: core.MetricSetTypeNode,
NodeName: request.PathParameter("node-name"),
}
a.processMetricNamesRequest(key, response)
}
|
[
"func",
"(",
"a",
"*",
"HistoricalApi",
")",
"availableNodeMetrics",
"(",
"request",
"*",
"restful",
".",
"Request",
",",
"response",
"*",
"restful",
".",
"Response",
")",
"{",
"key",
":=",
"core",
".",
"HistoricalKey",
"{",
"ObjectType",
":",
"core",
".",
"MetricSetTypeNode",
",",
"NodeName",
":",
"request",
".",
"PathParameter",
"(",
"\"node-name\"",
")",
",",
"}",
"\n",
"a",
".",
"processMetricNamesRequest",
"(",
"key",
",",
"response",
")",
"\n",
"}"
] |
// availableNodeMetrics returns a list of available node metric names.
|
[
"availableNodeMetrics",
"returns",
"a",
"list",
"of",
"available",
"node",
"metric",
"names",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/api/v1/historical_handlers.go#L265-L271
|
train
|
kubernetes-retired/heapster
|
metrics/api/v1/historical_handlers.go
|
availableNamespaceMetrics
|
func (a *HistoricalApi) availableNamespaceMetrics(request *restful.Request, response *restful.Response) {
key := core.HistoricalKey{
ObjectType: core.MetricSetTypeNamespace,
NamespaceName: request.PathParameter("namespace-name"),
}
a.processMetricNamesRequest(key, response)
}
|
go
|
func (a *HistoricalApi) availableNamespaceMetrics(request *restful.Request, response *restful.Response) {
key := core.HistoricalKey{
ObjectType: core.MetricSetTypeNamespace,
NamespaceName: request.PathParameter("namespace-name"),
}
a.processMetricNamesRequest(key, response)
}
|
[
"func",
"(",
"a",
"*",
"HistoricalApi",
")",
"availableNamespaceMetrics",
"(",
"request",
"*",
"restful",
".",
"Request",
",",
"response",
"*",
"restful",
".",
"Response",
")",
"{",
"key",
":=",
"core",
".",
"HistoricalKey",
"{",
"ObjectType",
":",
"core",
".",
"MetricSetTypeNamespace",
",",
"NamespaceName",
":",
"request",
".",
"PathParameter",
"(",
"\"namespace-name\"",
")",
",",
"}",
"\n",
"a",
".",
"processMetricNamesRequest",
"(",
"key",
",",
"response",
")",
"\n",
"}"
] |
// availableNamespaceMetrics returns a list of available namespace metric names.
|
[
"availableNamespaceMetrics",
"returns",
"a",
"list",
"of",
"available",
"namespace",
"metric",
"names",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/api/v1/historical_handlers.go#L274-L280
|
train
|
kubernetes-retired/heapster
|
metrics/api/v1/historical_handlers.go
|
availablePodMetrics
|
func (a *HistoricalApi) availablePodMetrics(request *restful.Request, response *restful.Response) {
key := core.HistoricalKey{
ObjectType: core.MetricSetTypePod,
NamespaceName: request.PathParameter("namespace-name"),
PodName: request.PathParameter("pod-name"),
}
a.processMetricNamesRequest(key, response)
}
|
go
|
func (a *HistoricalApi) availablePodMetrics(request *restful.Request, response *restful.Response) {
key := core.HistoricalKey{
ObjectType: core.MetricSetTypePod,
NamespaceName: request.PathParameter("namespace-name"),
PodName: request.PathParameter("pod-name"),
}
a.processMetricNamesRequest(key, response)
}
|
[
"func",
"(",
"a",
"*",
"HistoricalApi",
")",
"availablePodMetrics",
"(",
"request",
"*",
"restful",
".",
"Request",
",",
"response",
"*",
"restful",
".",
"Response",
")",
"{",
"key",
":=",
"core",
".",
"HistoricalKey",
"{",
"ObjectType",
":",
"core",
".",
"MetricSetTypePod",
",",
"NamespaceName",
":",
"request",
".",
"PathParameter",
"(",
"\"namespace-name\"",
")",
",",
"PodName",
":",
"request",
".",
"PathParameter",
"(",
"\"pod-name\"",
")",
",",
"}",
"\n",
"a",
".",
"processMetricNamesRequest",
"(",
"key",
",",
"response",
")",
"\n",
"}"
] |
// availablePodMetrics returns a list of available pod metric names.
|
[
"availablePodMetrics",
"returns",
"a",
"list",
"of",
"available",
"pod",
"metric",
"names",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/api/v1/historical_handlers.go#L283-L290
|
train
|
kubernetes-retired/heapster
|
metrics/api/v1/historical_handlers.go
|
availablePodContainerMetrics
|
func (a *HistoricalApi) availablePodContainerMetrics(request *restful.Request, response *restful.Response) {
key := core.HistoricalKey{
ObjectType: core.MetricSetTypePodContainer,
NamespaceName: request.PathParameter("namespace-name"),
PodName: request.PathParameter("pod-name"),
ContainerName: request.PathParameter("container-name"),
}
a.processMetricNamesRequest(key, response)
}
|
go
|
func (a *HistoricalApi) availablePodContainerMetrics(request *restful.Request, response *restful.Response) {
key := core.HistoricalKey{
ObjectType: core.MetricSetTypePodContainer,
NamespaceName: request.PathParameter("namespace-name"),
PodName: request.PathParameter("pod-name"),
ContainerName: request.PathParameter("container-name"),
}
a.processMetricNamesRequest(key, response)
}
|
[
"func",
"(",
"a",
"*",
"HistoricalApi",
")",
"availablePodContainerMetrics",
"(",
"request",
"*",
"restful",
".",
"Request",
",",
"response",
"*",
"restful",
".",
"Response",
")",
"{",
"key",
":=",
"core",
".",
"HistoricalKey",
"{",
"ObjectType",
":",
"core",
".",
"MetricSetTypePodContainer",
",",
"NamespaceName",
":",
"request",
".",
"PathParameter",
"(",
"\"namespace-name\"",
")",
",",
"PodName",
":",
"request",
".",
"PathParameter",
"(",
"\"pod-name\"",
")",
",",
"ContainerName",
":",
"request",
".",
"PathParameter",
"(",
"\"container-name\"",
")",
",",
"}",
"\n",
"a",
".",
"processMetricNamesRequest",
"(",
"key",
",",
"response",
")",
"\n",
"}"
] |
// availablePodContainerMetrics returns a list of available pod container metric names.
|
[
"availablePodContainerMetrics",
"returns",
"a",
"list",
"of",
"available",
"pod",
"container",
"metric",
"names",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/api/v1/historical_handlers.go#L293-L301
|
train
|
kubernetes-retired/heapster
|
metrics/api/v1/historical_handlers.go
|
availableFreeContainerMetrics
|
func (a *HistoricalApi) availableFreeContainerMetrics(request *restful.Request, response *restful.Response) {
key := core.HistoricalKey{
ObjectType: core.MetricSetTypeSystemContainer,
NodeName: request.PathParameter("node-name"),
ContainerName: request.PathParameter("container-name"),
}
a.processMetricNamesRequest(key, response)
}
|
go
|
func (a *HistoricalApi) availableFreeContainerMetrics(request *restful.Request, response *restful.Response) {
key := core.HistoricalKey{
ObjectType: core.MetricSetTypeSystemContainer,
NodeName: request.PathParameter("node-name"),
ContainerName: request.PathParameter("container-name"),
}
a.processMetricNamesRequest(key, response)
}
|
[
"func",
"(",
"a",
"*",
"HistoricalApi",
")",
"availableFreeContainerMetrics",
"(",
"request",
"*",
"restful",
".",
"Request",
",",
"response",
"*",
"restful",
".",
"Response",
")",
"{",
"key",
":=",
"core",
".",
"HistoricalKey",
"{",
"ObjectType",
":",
"core",
".",
"MetricSetTypeSystemContainer",
",",
"NodeName",
":",
"request",
".",
"PathParameter",
"(",
"\"node-name\"",
")",
",",
"ContainerName",
":",
"request",
".",
"PathParameter",
"(",
"\"container-name\"",
")",
",",
"}",
"\n",
"a",
".",
"processMetricNamesRequest",
"(",
"key",
",",
"response",
")",
"\n",
"}"
] |
// availableFreeContainerMetrics returns a list of available pod metric names.
|
[
"availableFreeContainerMetrics",
"returns",
"a",
"list",
"of",
"available",
"pod",
"metric",
"names",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/api/v1/historical_handlers.go#L304-L311
|
train
|
kubernetes-retired/heapster
|
metrics/api/v1/historical_handlers.go
|
nodeList
|
func (a *HistoricalApi) nodeList(request *restful.Request, response *restful.Response) {
if resp, err := a.historicalSource.GetNodes(); err != nil {
response.WriteError(http.StatusInternalServerError, err)
} else {
response.WriteEntity(resp)
}
}
|
go
|
func (a *HistoricalApi) nodeList(request *restful.Request, response *restful.Response) {
if resp, err := a.historicalSource.GetNodes(); err != nil {
response.WriteError(http.StatusInternalServerError, err)
} else {
response.WriteEntity(resp)
}
}
|
[
"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
|
[
"nodeList",
"lists",
"all",
"nodes",
"for",
"which",
"we",
"have",
"metrics"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/api/v1/historical_handlers.go#L314-L320
|
train
|
kubernetes-retired/heapster
|
metrics/api/v1/historical_handlers.go
|
namespaceList
|
func (a *HistoricalApi) namespaceList(request *restful.Request, response *restful.Response) {
if resp, err := a.historicalSource.GetNamespaces(); err != nil {
response.WriteError(http.StatusInternalServerError, err)
} else {
response.WriteEntity(resp)
}
}
|
go
|
func (a *HistoricalApi) namespaceList(request *restful.Request, response *restful.Response) {
if resp, err := a.historicalSource.GetNamespaces(); err != nil {
response.WriteError(http.StatusInternalServerError, err)
} else {
response.WriteEntity(resp)
}
}
|
[
"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
|
[
"namespaceList",
"lists",
"all",
"namespaces",
"for",
"which",
"we",
"have",
"metrics"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/api/v1/historical_handlers.go#L323-L329
|
train
|
kubernetes-retired/heapster
|
metrics/api/v1/historical_handlers.go
|
namespacePodList
|
func (a *HistoricalApi) namespacePodList(request *restful.Request, response *restful.Response) {
if resp, err := a.historicalSource.GetPodsFromNamespace(request.PathParameter("namespace-name")); err != nil {
response.WriteError(http.StatusInternalServerError, err)
} else {
response.WriteEntity(resp)
}
}
|
go
|
func (a *HistoricalApi) namespacePodList(request *restful.Request, response *restful.Response) {
if resp, err := a.historicalSource.GetPodsFromNamespace(request.PathParameter("namespace-name")); err != nil {
response.WriteError(http.StatusInternalServerError, err)
} else {
response.WriteEntity(resp)
}
}
|
[
"func",
"(",
"a",
"*",
"HistoricalApi",
")",
"namespacePodList",
"(",
"request",
"*",
"restful",
".",
"Request",
",",
"response",
"*",
"restful",
".",
"Response",
")",
"{",
"if",
"resp",
",",
"err",
":=",
"a",
".",
"historicalSource",
".",
"GetPodsFromNamespace",
"(",
"request",
".",
"PathParameter",
"(",
"\"namespace-name\"",
")",
")",
";",
"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
|
[
"namespacePodList",
"lists",
"all",
"pods",
"for",
"which",
"we",
"have",
"metrics",
"in",
"a",
"particular",
"namespace"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/api/v1/historical_handlers.go#L332-L338
|
train
|
kubernetes-retired/heapster
|
metrics/api/v1/historical_handlers.go
|
freeContainerMetrics
|
func (a *HistoricalApi) freeContainerMetrics(request *restful.Request, response *restful.Response) {
key := core.HistoricalKey{
ObjectType: core.MetricSetTypeSystemContainer,
NodeName: request.PathParameter("node-name"),
ContainerName: request.PathParameter("container-name"),
}
a.processMetricRequest(key, request, response)
}
|
go
|
func (a *HistoricalApi) freeContainerMetrics(request *restful.Request, response *restful.Response) {
key := core.HistoricalKey{
ObjectType: core.MetricSetTypeSystemContainer,
NodeName: request.PathParameter("node-name"),
ContainerName: request.PathParameter("container-name"),
}
a.processMetricRequest(key, request, response)
}
|
[
"func",
"(",
"a",
"*",
"HistoricalApi",
")",
"freeContainerMetrics",
"(",
"request",
"*",
"restful",
".",
"Request",
",",
"response",
"*",
"restful",
".",
"Response",
")",
"{",
"key",
":=",
"core",
".",
"HistoricalKey",
"{",
"ObjectType",
":",
"core",
".",
"MetricSetTypeSystemContainer",
",",
"NodeName",
":",
"request",
".",
"PathParameter",
"(",
"\"node-name\"",
")",
",",
"ContainerName",
":",
"request",
".",
"PathParameter",
"(",
"\"container-name\"",
")",
",",
"}",
"\n",
"a",
".",
"processMetricRequest",
"(",
"key",
",",
"request",
",",
"response",
")",
"\n",
"}"
] |
// freeContainerMetrics returns a metric timeseries for a metric of the Container entity.
// freeContainerMetrics addresses only free containers.
|
[
"freeContainerMetrics",
"returns",
"a",
"metric",
"timeseries",
"for",
"a",
"metric",
"of",
"the",
"Container",
"entity",
".",
"freeContainerMetrics",
"addresses",
"only",
"free",
"containers",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/api/v1/historical_handlers.go#L393-L400
|
train
|
kubernetes-retired/heapster
|
metrics/api/v1/historical_handlers.go
|
podListMetrics
|
func (a *HistoricalApi) podListMetrics(request *restful.Request, response *restful.Response) {
start, end, err := getStartEndTimeHistorical(request)
if err != nil {
response.WriteError(http.StatusBadRequest, err)
return
}
keys := []core.HistoricalKey{}
if request.PathParameter("pod-id-list") != "" {
for _, podId := range strings.Split(request.PathParameter("pod-id-list"), ",") {
key := core.HistoricalKey{
ObjectType: core.MetricSetTypePod,
PodId: podId,
}
keys = append(keys, key)
}
} else {
for _, podName := range strings.Split(request.PathParameter("pod-list"), ",") {
key := core.HistoricalKey{
ObjectType: core.MetricSetTypePod,
NamespaceName: request.PathParameter("namespace-name"),
PodName: podName,
}
keys = append(keys, key)
}
}
labels, err := getLabels(request)
if err != nil {
response.WriteError(http.StatusBadRequest, err)
return
}
metricName := request.PathParameter("metric-name")
convertedMetricName := convertMetricName(metricName)
var metrics map[core.HistoricalKey][]core.TimestampedMetricValue
if labels != nil {
metrics, err = a.historicalSource.GetLabeledMetric(convertedMetricName, labels, keys, start, end)
} else {
metrics, err = a.historicalSource.GetMetric(convertedMetricName, keys, start, end)
}
if err != nil {
response.WriteError(http.StatusInternalServerError, err)
return
}
result := types.MetricResultList{
Items: make([]types.MetricResult, 0, len(keys)),
}
for _, key := range keys {
result.Items = append(result.Items, exportTimestampedMetricValue(metrics[key]))
}
response.PrettyPrint(false)
response.WriteEntity(result)
}
|
go
|
func (a *HistoricalApi) podListMetrics(request *restful.Request, response *restful.Response) {
start, end, err := getStartEndTimeHistorical(request)
if err != nil {
response.WriteError(http.StatusBadRequest, err)
return
}
keys := []core.HistoricalKey{}
if request.PathParameter("pod-id-list") != "" {
for _, podId := range strings.Split(request.PathParameter("pod-id-list"), ",") {
key := core.HistoricalKey{
ObjectType: core.MetricSetTypePod,
PodId: podId,
}
keys = append(keys, key)
}
} else {
for _, podName := range strings.Split(request.PathParameter("pod-list"), ",") {
key := core.HistoricalKey{
ObjectType: core.MetricSetTypePod,
NamespaceName: request.PathParameter("namespace-name"),
PodName: podName,
}
keys = append(keys, key)
}
}
labels, err := getLabels(request)
if err != nil {
response.WriteError(http.StatusBadRequest, err)
return
}
metricName := request.PathParameter("metric-name")
convertedMetricName := convertMetricName(metricName)
var metrics map[core.HistoricalKey][]core.TimestampedMetricValue
if labels != nil {
metrics, err = a.historicalSource.GetLabeledMetric(convertedMetricName, labels, keys, start, end)
} else {
metrics, err = a.historicalSource.GetMetric(convertedMetricName, keys, start, end)
}
if err != nil {
response.WriteError(http.StatusInternalServerError, err)
return
}
result := types.MetricResultList{
Items: make([]types.MetricResult, 0, len(keys)),
}
for _, key := range keys {
result.Items = append(result.Items, exportTimestampedMetricValue(metrics[key]))
}
response.PrettyPrint(false)
response.WriteEntity(result)
}
|
[
"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",
"keys",
":=",
"[",
"]",
"core",
".",
"HistoricalKey",
"{",
"}",
"\n",
"if",
"request",
".",
"PathParameter",
"(",
"\"pod-id-list\"",
")",
"!=",
"\"\"",
"{",
"for",
"_",
",",
"podId",
":=",
"range",
"strings",
".",
"Split",
"(",
"request",
".",
"PathParameter",
"(",
"\"pod-id-list\"",
")",
",",
"\",\"",
")",
"{",
"key",
":=",
"core",
".",
"HistoricalKey",
"{",
"ObjectType",
":",
"core",
".",
"MetricSetTypePod",
",",
"PodId",
":",
"podId",
",",
"}",
"\n",
"keys",
"=",
"append",
"(",
"keys",
",",
"key",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"for",
"_",
",",
"podName",
":=",
"range",
"strings",
".",
"Split",
"(",
"request",
".",
"PathParameter",
"(",
"\"pod-list\"",
")",
",",
"\",\"",
")",
"{",
"key",
":=",
"core",
".",
"HistoricalKey",
"{",
"ObjectType",
":",
"core",
".",
"MetricSetTypePod",
",",
"NamespaceName",
":",
"request",
".",
"PathParameter",
"(",
"\"namespace-name\"",
")",
",",
"PodName",
":",
"podName",
",",
"}",
"\n",
"keys",
"=",
"append",
"(",
"keys",
",",
"key",
")",
"\n",
"}",
"\n",
"}",
"\n",
"labels",
",",
"err",
":=",
"getLabels",
"(",
"request",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"response",
".",
"WriteError",
"(",
"http",
".",
"StatusBadRequest",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"metricName",
":=",
"request",
".",
"PathParameter",
"(",
"\"metric-name\"",
")",
"\n",
"convertedMetricName",
":=",
"convertMetricName",
"(",
"metricName",
")",
"\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",
"if",
"err",
"!=",
"nil",
"{",
"response",
".",
"WriteError",
"(",
"http",
".",
"StatusInternalServerError",
",",
"err",
")",
"\n",
"return",
"\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
|
[
"podListMetrics",
"returns",
"a",
"list",
"of",
"metric",
"timeseries",
"for",
"each",
"for",
"the",
"listed",
"nodes"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/api/v1/historical_handlers.go#L403-L459
|
train
|
kubernetes-retired/heapster
|
metrics/api/v1/historical_handlers.go
|
clusterAggregations
|
func (a *HistoricalApi) clusterAggregations(request *restful.Request, response *restful.Response) {
key := core.HistoricalKey{ObjectType: core.MetricSetTypeCluster}
a.processAggregationRequest(key, request, response)
}
|
go
|
func (a *HistoricalApi) clusterAggregations(request *restful.Request, response *restful.Response) {
key := core.HistoricalKey{ObjectType: core.MetricSetTypeCluster}
a.processAggregationRequest(key, request, response)
}
|
[
"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.
|
[
"clusterAggregations",
"returns",
"a",
"metric",
"timeseries",
"for",
"a",
"metric",
"of",
"the",
"Cluster",
"entity",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/api/v1/historical_handlers.go#L482-L485
|
train
|
kubernetes-retired/heapster
|
metrics/api/v1/historical_handlers.go
|
nodeAggregations
|
func (a *HistoricalApi) nodeAggregations(request *restful.Request, response *restful.Response) {
key := core.HistoricalKey{
ObjectType: core.MetricSetTypeNode,
NodeName: request.PathParameter("node-name"),
}
a.processAggregationRequest(key, request, response)
}
|
go
|
func (a *HistoricalApi) nodeAggregations(request *restful.Request, response *restful.Response) {
key := core.HistoricalKey{
ObjectType: core.MetricSetTypeNode,
NodeName: request.PathParameter("node-name"),
}
a.processAggregationRequest(key, request, response)
}
|
[
"func",
"(",
"a",
"*",
"HistoricalApi",
")",
"nodeAggregations",
"(",
"request",
"*",
"restful",
".",
"Request",
",",
"response",
"*",
"restful",
".",
"Response",
")",
"{",
"key",
":=",
"core",
".",
"HistoricalKey",
"{",
"ObjectType",
":",
"core",
".",
"MetricSetTypeNode",
",",
"NodeName",
":",
"request",
".",
"PathParameter",
"(",
"\"node-name\"",
")",
",",
"}",
"\n",
"a",
".",
"processAggregationRequest",
"(",
"key",
",",
"request",
",",
"response",
")",
"\n",
"}"
] |
// nodeAggregations returns a metric timeseries for a metric of the Node entity.
|
[
"nodeAggregations",
"returns",
"a",
"metric",
"timeseries",
"for",
"a",
"metric",
"of",
"the",
"Node",
"entity",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/api/v1/historical_handlers.go#L488-L494
|
train
|
kubernetes-retired/heapster
|
metrics/api/v1/historical_handlers.go
|
namespaceAggregations
|
func (a *HistoricalApi) namespaceAggregations(request *restful.Request, response *restful.Response) {
key := core.HistoricalKey{
ObjectType: core.MetricSetTypeNamespace,
NamespaceName: request.PathParameter("namespace-name"),
}
a.processAggregationRequest(key, request, response)
}
|
go
|
func (a *HistoricalApi) namespaceAggregations(request *restful.Request, response *restful.Response) {
key := core.HistoricalKey{
ObjectType: core.MetricSetTypeNamespace,
NamespaceName: request.PathParameter("namespace-name"),
}
a.processAggregationRequest(key, request, response)
}
|
[
"func",
"(",
"a",
"*",
"HistoricalApi",
")",
"namespaceAggregations",
"(",
"request",
"*",
"restful",
".",
"Request",
",",
"response",
"*",
"restful",
".",
"Response",
")",
"{",
"key",
":=",
"core",
".",
"HistoricalKey",
"{",
"ObjectType",
":",
"core",
".",
"MetricSetTypeNamespace",
",",
"NamespaceName",
":",
"request",
".",
"PathParameter",
"(",
"\"namespace-name\"",
")",
",",
"}",
"\n",
"a",
".",
"processAggregationRequest",
"(",
"key",
",",
"request",
",",
"response",
")",
"\n",
"}"
] |
// namespaceAggregations returns a metric timeseries for a metric of the Namespace entity.
|
[
"namespaceAggregations",
"returns",
"a",
"metric",
"timeseries",
"for",
"a",
"metric",
"of",
"the",
"Namespace",
"entity",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/api/v1/historical_handlers.go#L497-L503
|
train
|
kubernetes-retired/heapster
|
metrics/api/v1/historical_handlers.go
|
podContainerAggregations
|
func (a *HistoricalApi) podContainerAggregations(request *restful.Request, response *restful.Response) {
var key core.HistoricalKey
if request.PathParameter("pod-id") != "" {
key = core.HistoricalKey{
ObjectType: core.MetricSetTypePodContainer,
PodId: request.PathParameter("pod-id"),
ContainerName: request.PathParameter("container-name"),
}
} else {
key = core.HistoricalKey{
ObjectType: core.MetricSetTypePodContainer,
NamespaceName: request.PathParameter("namespace-name"),
PodName: request.PathParameter("pod-name"),
ContainerName: request.PathParameter("container-name"),
}
}
a.processAggregationRequest(key, request, response)
}
|
go
|
func (a *HistoricalApi) podContainerAggregations(request *restful.Request, response *restful.Response) {
var key core.HistoricalKey
if request.PathParameter("pod-id") != "" {
key = core.HistoricalKey{
ObjectType: core.MetricSetTypePodContainer,
PodId: request.PathParameter("pod-id"),
ContainerName: request.PathParameter("container-name"),
}
} else {
key = core.HistoricalKey{
ObjectType: core.MetricSetTypePodContainer,
NamespaceName: request.PathParameter("namespace-name"),
PodName: request.PathParameter("pod-name"),
ContainerName: request.PathParameter("container-name"),
}
}
a.processAggregationRequest(key, request, response)
}
|
[
"func",
"(",
"a",
"*",
"HistoricalApi",
")",
"podContainerAggregations",
"(",
"request",
"*",
"restful",
".",
"Request",
",",
"response",
"*",
"restful",
".",
"Response",
")",
"{",
"var",
"key",
"core",
".",
"HistoricalKey",
"\n",
"if",
"request",
".",
"PathParameter",
"(",
"\"pod-id\"",
")",
"!=",
"\"\"",
"{",
"key",
"=",
"core",
".",
"HistoricalKey",
"{",
"ObjectType",
":",
"core",
".",
"MetricSetTypePodContainer",
",",
"PodId",
":",
"request",
".",
"PathParameter",
"(",
"\"pod-id\"",
")",
",",
"ContainerName",
":",
"request",
".",
"PathParameter",
"(",
"\"container-name\"",
")",
",",
"}",
"\n",
"}",
"else",
"{",
"key",
"=",
"core",
".",
"HistoricalKey",
"{",
"ObjectType",
":",
"core",
".",
"MetricSetTypePodContainer",
",",
"NamespaceName",
":",
"request",
".",
"PathParameter",
"(",
"\"namespace-name\"",
")",
",",
"PodName",
":",
"request",
".",
"PathParameter",
"(",
"\"pod-name\"",
")",
",",
"ContainerName",
":",
"request",
".",
"PathParameter",
"(",
"\"container-name\"",
")",
",",
"}",
"\n",
"}",
"\n",
"a",
".",
"processAggregationRequest",
"(",
"key",
",",
"request",
",",
"response",
")",
"\n",
"}"
] |
// podContainerAggregations returns a metric timeseries for a metric of a Pod Container entity.
|
[
"podContainerAggregations",
"returns",
"a",
"metric",
"timeseries",
"for",
"a",
"metric",
"of",
"a",
"Pod",
"Container",
"entity",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/api/v1/historical_handlers.go#L524-L541
|
train
|
kubernetes-retired/heapster
|
metrics/api/v1/historical_handlers.go
|
freeContainerAggregations
|
func (a *HistoricalApi) freeContainerAggregations(request *restful.Request, response *restful.Response) {
key := core.HistoricalKey{
ObjectType: core.MetricSetTypeSystemContainer,
NodeName: request.PathParameter("node-name"),
ContainerName: request.PathParameter("container-name"),
}
a.processAggregationRequest(key, request, response)
}
|
go
|
func (a *HistoricalApi) freeContainerAggregations(request *restful.Request, response *restful.Response) {
key := core.HistoricalKey{
ObjectType: core.MetricSetTypeSystemContainer,
NodeName: request.PathParameter("node-name"),
ContainerName: request.PathParameter("container-name"),
}
a.processAggregationRequest(key, request, response)
}
|
[
"func",
"(",
"a",
"*",
"HistoricalApi",
")",
"freeContainerAggregations",
"(",
"request",
"*",
"restful",
".",
"Request",
",",
"response",
"*",
"restful",
".",
"Response",
")",
"{",
"key",
":=",
"core",
".",
"HistoricalKey",
"{",
"ObjectType",
":",
"core",
".",
"MetricSetTypeSystemContainer",
",",
"NodeName",
":",
"request",
".",
"PathParameter",
"(",
"\"node-name\"",
")",
",",
"ContainerName",
":",
"request",
".",
"PathParameter",
"(",
"\"container-name\"",
")",
",",
"}",
"\n",
"a",
".",
"processAggregationRequest",
"(",
"key",
",",
"request",
",",
"response",
")",
"\n",
"}"
] |
// freeContainerAggregations returns a metric timeseries for a metric of the Container entity.
// freeContainerAggregations addresses only free containers.
|
[
"freeContainerAggregations",
"returns",
"a",
"metric",
"timeseries",
"for",
"a",
"metric",
"of",
"the",
"Container",
"entity",
".",
"freeContainerAggregations",
"addresses",
"only",
"free",
"containers",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/api/v1/historical_handlers.go#L545-L552
|
train
|
kubernetes-retired/heapster
|
metrics/api/v1/historical_handlers.go
|
podListAggregations
|
func (a *HistoricalApi) podListAggregations(request *restful.Request, response *restful.Response) {
start, end, err := getStartEndTimeHistorical(request)
if err != nil {
response.WriteError(http.StatusBadRequest, err)
return
}
bucketSize, err := getBucketSize(request)
if err != nil {
response.WriteError(http.StatusBadRequest, err)
return
}
aggregations, err := getAggregations(request)
if err != nil {
response.WriteError(http.StatusBadRequest, err)
return
}
labels, err := getLabels(request)
if err != nil {
response.WriteError(http.StatusBadRequest, err)
return
}
keys := []core.HistoricalKey{}
if request.PathParameter("pod-id-list") != "" {
for _, podId := range strings.Split(request.PathParameter("pod-id-list"), ",") {
key := core.HistoricalKey{
ObjectType: core.MetricSetTypePod,
PodId: podId,
}
keys = append(keys, key)
}
} else {
for _, podName := range strings.Split(request.PathParameter("pod-list"), ",") {
key := core.HistoricalKey{
ObjectType: core.MetricSetTypePod,
NamespaceName: request.PathParameter("namespace-name"),
PodName: podName,
}
keys = append(keys, key)
}
}
metricName := request.PathParameter("metric-name")
convertedMetricName := convertMetricName(metricName)
var metrics map[core.HistoricalKey][]core.TimestampedAggregationValue
if labels != nil {
metrics, err = a.historicalSource.GetLabeledAggregation(convertedMetricName, labels, aggregations, keys, start, end, bucketSize)
} else {
metrics, err = a.historicalSource.GetAggregation(convertedMetricName, aggregations, keys, start, end, bucketSize)
}
if err != nil {
response.WriteError(http.StatusInternalServerError, err)
return
}
result := types.MetricAggregationResultList{
Items: make([]types.MetricAggregationResult, 0, len(keys)),
}
for _, key := range keys {
result.Items = append(result.Items, exportTimestampedAggregationValue(metrics[key]))
}
response.PrettyPrint(false)
response.WriteEntity(result)
}
|
go
|
func (a *HistoricalApi) podListAggregations(request *restful.Request, response *restful.Response) {
start, end, err := getStartEndTimeHistorical(request)
if err != nil {
response.WriteError(http.StatusBadRequest, err)
return
}
bucketSize, err := getBucketSize(request)
if err != nil {
response.WriteError(http.StatusBadRequest, err)
return
}
aggregations, err := getAggregations(request)
if err != nil {
response.WriteError(http.StatusBadRequest, err)
return
}
labels, err := getLabels(request)
if err != nil {
response.WriteError(http.StatusBadRequest, err)
return
}
keys := []core.HistoricalKey{}
if request.PathParameter("pod-id-list") != "" {
for _, podId := range strings.Split(request.PathParameter("pod-id-list"), ",") {
key := core.HistoricalKey{
ObjectType: core.MetricSetTypePod,
PodId: podId,
}
keys = append(keys, key)
}
} else {
for _, podName := range strings.Split(request.PathParameter("pod-list"), ",") {
key := core.HistoricalKey{
ObjectType: core.MetricSetTypePod,
NamespaceName: request.PathParameter("namespace-name"),
PodName: podName,
}
keys = append(keys, key)
}
}
metricName := request.PathParameter("metric-name")
convertedMetricName := convertMetricName(metricName)
var metrics map[core.HistoricalKey][]core.TimestampedAggregationValue
if labels != nil {
metrics, err = a.historicalSource.GetLabeledAggregation(convertedMetricName, labels, aggregations, keys, start, end, bucketSize)
} else {
metrics, err = a.historicalSource.GetAggregation(convertedMetricName, aggregations, keys, start, end, bucketSize)
}
if err != nil {
response.WriteError(http.StatusInternalServerError, err)
return
}
result := types.MetricAggregationResultList{
Items: make([]types.MetricAggregationResult, 0, len(keys)),
}
for _, key := range keys {
result.Items = append(result.Items, exportTimestampedAggregationValue(metrics[key]))
}
response.PrettyPrint(false)
response.WriteEntity(result)
}
|
[
"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",
"(",
"\"pod-id-list\"",
")",
"!=",
"\"\"",
"{",
"for",
"_",
",",
"podId",
":=",
"range",
"strings",
".",
"Split",
"(",
"request",
".",
"PathParameter",
"(",
"\"pod-id-list\"",
")",
",",
"\",\"",
")",
"{",
"key",
":=",
"core",
".",
"HistoricalKey",
"{",
"ObjectType",
":",
"core",
".",
"MetricSetTypePod",
",",
"PodId",
":",
"podId",
",",
"}",
"\n",
"keys",
"=",
"append",
"(",
"keys",
",",
"key",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"for",
"_",
",",
"podName",
":=",
"range",
"strings",
".",
"Split",
"(",
"request",
".",
"PathParameter",
"(",
"\"pod-list\"",
")",
",",
"\",\"",
")",
"{",
"key",
":=",
"core",
".",
"HistoricalKey",
"{",
"ObjectType",
":",
"core",
".",
"MetricSetTypePod",
",",
"NamespaceName",
":",
"request",
".",
"PathParameter",
"(",
"\"namespace-name\"",
")",
",",
"PodName",
":",
"podName",
",",
"}",
"\n",
"keys",
"=",
"append",
"(",
"keys",
",",
"key",
")",
"\n",
"}",
"\n",
"}",
"\n",
"metricName",
":=",
"request",
".",
"PathParameter",
"(",
"\"metric-name\"",
")",
"\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",
"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.
|
[
"podListAggregations",
"returns",
"a",
"list",
"of",
"metric",
"timeseries",
"for",
"the",
"specified",
"pods",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/api/v1/historical_handlers.go#L555-L616
|
train
|
kubernetes-retired/heapster
|
metrics/api/v1/historical_handlers.go
|
processMetricRequest
|
func (a *HistoricalApi) processMetricRequest(key core.HistoricalKey, request *restful.Request, response *restful.Response) {
start, end, err := getStartEndTimeHistorical(request)
if err != nil {
response.WriteError(http.StatusBadRequest, err)
return
}
labels, err := getLabels(request)
if err != nil {
response.WriteError(http.StatusBadRequest, err)
return
}
metricName := request.PathParameter("metric-name")
convertedMetricName := convertMetricName(metricName)
var metrics map[core.HistoricalKey][]core.TimestampedMetricValue
if labels != nil {
metrics, err = a.historicalSource.GetLabeledMetric(convertedMetricName, labels, []core.HistoricalKey{key}, start, end)
} else {
metrics, err = a.historicalSource.GetMetric(convertedMetricName, []core.HistoricalKey{key}, start, end)
}
if err != nil {
response.WriteError(http.StatusInternalServerError, err)
return
}
converted := exportTimestampedMetricValue(metrics[key])
response.WriteEntity(converted)
}
|
go
|
func (a *HistoricalApi) processMetricRequest(key core.HistoricalKey, request *restful.Request, response *restful.Response) {
start, end, err := getStartEndTimeHistorical(request)
if err != nil {
response.WriteError(http.StatusBadRequest, err)
return
}
labels, err := getLabels(request)
if err != nil {
response.WriteError(http.StatusBadRequest, err)
return
}
metricName := request.PathParameter("metric-name")
convertedMetricName := convertMetricName(metricName)
var metrics map[core.HistoricalKey][]core.TimestampedMetricValue
if labels != nil {
metrics, err = a.historicalSource.GetLabeledMetric(convertedMetricName, labels, []core.HistoricalKey{key}, start, end)
} else {
metrics, err = a.historicalSource.GetMetric(convertedMetricName, []core.HistoricalKey{key}, start, end)
}
if err != nil {
response.WriteError(http.StatusInternalServerError, err)
return
}
converted := exportTimestampedMetricValue(metrics[key])
response.WriteEntity(converted)
}
|
[
"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",
"(",
"\"metric-name\"",
")",
"\n",
"convertedMetricName",
":=",
"convertMetricName",
"(",
"metricName",
")",
"\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",
"converted",
":=",
"exportTimestampedMetricValue",
"(",
"metrics",
"[",
"key",
"]",
")",
"\n",
"response",
".",
"WriteEntity",
"(",
"converted",
")",
"\n",
"}"
] |
// processMetricRequest retrieves a metric for the object at the requested key.
|
[
"processMetricRequest",
"retrieves",
"a",
"metric",
"for",
"the",
"object",
"at",
"the",
"requested",
"key",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/api/v1/historical_handlers.go#L619-L646
|
train
|
kubernetes-retired/heapster
|
metrics/api/v1/historical_handlers.go
|
processMetricNamesRequest
|
func (a *HistoricalApi) processMetricNamesRequest(key core.HistoricalKey, response *restful.Response) {
if resp, err := a.historicalSource.GetMetricNames(key); err != nil {
response.WriteError(http.StatusInternalServerError, err)
} else {
response.WriteEntity(resp)
}
}
|
go
|
func (a *HistoricalApi) processMetricNamesRequest(key core.HistoricalKey, response *restful.Response) {
if resp, err := a.historicalSource.GetMetricNames(key); err != nil {
response.WriteError(http.StatusInternalServerError, err)
} else {
response.WriteEntity(resp)
}
}
|
[
"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.
|
[
"processMetricNamesRequest",
"retrieves",
"the",
"available",
"metrics",
"for",
"the",
"object",
"at",
"the",
"specified",
"key",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/api/v1/historical_handlers.go#L649-L655
|
train
|
kubernetes-retired/heapster
|
metrics/api/v1/historical_handlers.go
|
getBucketSize
|
func getBucketSize(request *restful.Request) (time.Duration, error) {
rawSize := request.QueryParameter("bucket")
if rawSize == "" {
return 0, nil
}
if len(rawSize) < 2 {
return 0, fmt.Errorf("unable to parse bucket size: %q is too short to be a duration", rawSize)
}
var multiplier time.Duration
var num string
switch rawSize[len(rawSize)-1] {
case 's':
// could be s or ms
if len(rawSize) < 3 || rawSize[len(rawSize)-2] != 'm' {
multiplier = time.Second
num = rawSize[:len(rawSize)-1]
} else {
multiplier = time.Millisecond
num = rawSize[:len(rawSize)-2]
}
case 'h':
multiplier = time.Hour
num = rawSize[:len(rawSize)-1]
case 'd':
multiplier = 24 * time.Hour
num = rawSize[:len(rawSize)-1]
case 'm':
multiplier = time.Minute
num = rawSize[:len(rawSize)-1]
default:
return 0, fmt.Errorf("unable to parse bucket size: %q has no known duration suffix", rawSize)
}
parsedNum, err := strconv.ParseUint(num, 10, 64)
if err != nil {
return 0, err
}
return time.Duration(parsedNum) * multiplier, nil
}
|
go
|
func getBucketSize(request *restful.Request) (time.Duration, error) {
rawSize := request.QueryParameter("bucket")
if rawSize == "" {
return 0, nil
}
if len(rawSize) < 2 {
return 0, fmt.Errorf("unable to parse bucket size: %q is too short to be a duration", rawSize)
}
var multiplier time.Duration
var num string
switch rawSize[len(rawSize)-1] {
case 's':
// could be s or ms
if len(rawSize) < 3 || rawSize[len(rawSize)-2] != 'm' {
multiplier = time.Second
num = rawSize[:len(rawSize)-1]
} else {
multiplier = time.Millisecond
num = rawSize[:len(rawSize)-2]
}
case 'h':
multiplier = time.Hour
num = rawSize[:len(rawSize)-1]
case 'd':
multiplier = 24 * time.Hour
num = rawSize[:len(rawSize)-1]
case 'm':
multiplier = time.Minute
num = rawSize[:len(rawSize)-1]
default:
return 0, fmt.Errorf("unable to parse bucket size: %q has no known duration suffix", rawSize)
}
parsedNum, err := strconv.ParseUint(num, 10, 64)
if err != nil {
return 0, err
}
return time.Duration(parsedNum) * multiplier, nil
}
|
[
"func",
"getBucketSize",
"(",
"request",
"*",
"restful",
".",
"Request",
")",
"(",
"time",
".",
"Duration",
",",
"error",
")",
"{",
"rawSize",
":=",
"request",
".",
"QueryParameter",
"(",
"\"bucket\"",
")",
"\n",
"if",
"rawSize",
"==",
"\"\"",
"{",
"return",
"0",
",",
"nil",
"\n",
"}",
"\n",
"if",
"len",
"(",
"rawSize",
")",
"<",
"2",
"{",
"return",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"unable to parse bucket size: %q is too short to be a duration\"",
",",
"rawSize",
")",
"\n",
"}",
"\n",
"var",
"multiplier",
"time",
".",
"Duration",
"\n",
"var",
"num",
"string",
"\n",
"switch",
"rawSize",
"[",
"len",
"(",
"rawSize",
")",
"-",
"1",
"]",
"{",
"case",
"'s'",
":",
"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",
"(",
"\"unable to parse bucket size: %q has no known duration suffix\"",
",",
"rawSize",
")",
"\n",
"}",
"\n",
"parsedNum",
",",
"err",
":=",
"strconv",
".",
"ParseUint",
"(",
"num",
",",
"10",
",",
"64",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"return",
"time",
".",
"Duration",
"(",
"parsedNum",
")",
"*",
"multiplier",
",",
"nil",
"\n",
"}"
] |
// getBucketSize parses the bucket size specifier into a
|
[
"getBucketSize",
"parses",
"the",
"bucket",
"size",
"specifier",
"into",
"a"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/api/v1/historical_handlers.go#L698-L739
|
train
|
kubernetes-retired/heapster
|
metrics/api/v1/historical_handlers.go
|
getAggregations
|
func getAggregations(request *restful.Request) ([]core.AggregationType, error) {
aggregationsRaw := strings.Split(request.PathParameter("aggregations"), ",")
if len(aggregationsRaw) == 0 {
return nil, fmt.Errorf("No aggregations specified")
}
aggregations := make([]core.AggregationType, len(aggregationsRaw))
for ind, aggNameRaw := range aggregationsRaw {
aggName := core.AggregationType(aggNameRaw)
if _, ok := core.AllAggregations[aggName]; !ok {
return nil, fmt.Errorf("Unknown aggregation %q", aggName)
}
aggregations[ind] = aggName
}
return aggregations, nil
}
|
go
|
func getAggregations(request *restful.Request) ([]core.AggregationType, error) {
aggregationsRaw := strings.Split(request.PathParameter("aggregations"), ",")
if len(aggregationsRaw) == 0 {
return nil, fmt.Errorf("No aggregations specified")
}
aggregations := make([]core.AggregationType, len(aggregationsRaw))
for ind, aggNameRaw := range aggregationsRaw {
aggName := core.AggregationType(aggNameRaw)
if _, ok := core.AllAggregations[aggName]; !ok {
return nil, fmt.Errorf("Unknown aggregation %q", aggName)
}
aggregations[ind] = aggName
}
return aggregations, nil
}
|
[
"func",
"getAggregations",
"(",
"request",
"*",
"restful",
".",
"Request",
")",
"(",
"[",
"]",
"core",
".",
"AggregationType",
",",
"error",
")",
"{",
"aggregationsRaw",
":=",
"strings",
".",
"Split",
"(",
"request",
".",
"PathParameter",
"(",
"\"aggregations\"",
")",
",",
"\",\"",
")",
"\n",
"if",
"len",
"(",
"aggregationsRaw",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"No aggregations specified\"",
")",
"\n",
"}",
"\n",
"aggregations",
":=",
"make",
"(",
"[",
"]",
"core",
".",
"AggregationType",
",",
"len",
"(",
"aggregationsRaw",
")",
")",
"\n",
"for",
"ind",
",",
"aggNameRaw",
":=",
"range",
"aggregationsRaw",
"{",
"aggName",
":=",
"core",
".",
"AggregationType",
"(",
"aggNameRaw",
")",
"\n",
"if",
"_",
",",
"ok",
":=",
"core",
".",
"AllAggregations",
"[",
"aggName",
"]",
";",
"!",
"ok",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"Unknown aggregation %q\"",
",",
"aggName",
")",
"\n",
"}",
"\n",
"aggregations",
"[",
"ind",
"]",
"=",
"aggName",
"\n",
"}",
"\n",
"return",
"aggregations",
",",
"nil",
"\n",
"}"
] |
// getAggregations extracts and validates the list of requested aggregations
|
[
"getAggregations",
"extracts",
"and",
"validates",
"the",
"list",
"of",
"requested",
"aggregations"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/api/v1/historical_handlers.go#L742-L759
|
train
|
kubernetes-retired/heapster
|
metrics/api/v1/historical_handlers.go
|
exportMetricValue
|
func exportMetricValue(value *core.MetricValue) *types.MetricValue {
if value == nil {
return nil
}
if value.ValueType == core.ValueInt64 {
return &types.MetricValue{
IntValue: &value.IntValue,
}
} else {
floatVal := float64(value.FloatValue)
return &types.MetricValue{
FloatValue: &floatVal,
}
}
}
|
go
|
func exportMetricValue(value *core.MetricValue) *types.MetricValue {
if value == nil {
return nil
}
if value.ValueType == core.ValueInt64 {
return &types.MetricValue{
IntValue: &value.IntValue,
}
} else {
floatVal := float64(value.FloatValue)
return &types.MetricValue{
FloatValue: &floatVal,
}
}
}
|
[
"func",
"exportMetricValue",
"(",
"value",
"*",
"core",
".",
"MetricValue",
")",
"*",
"types",
".",
"MetricValue",
"{",
"if",
"value",
"==",
"nil",
"{",
"return",
"nil",
"\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
|
[
"exportMetricValue",
"converts",
"a",
"core",
".",
"MetricValue",
"into",
"an",
"API",
"MetricValue"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/api/v1/historical_handlers.go#L762-L777
|
train
|
kubernetes-retired/heapster
|
metrics/api/v1/historical_handlers.go
|
extractMetricValue
|
func extractMetricValue(aggregations *core.AggregationValue, aggName core.AggregationType) *types.MetricValue {
if inputVal, ok := aggregations.Aggregations[aggName]; ok {
return exportMetricValue(&inputVal)
} else {
return nil
}
}
|
go
|
func extractMetricValue(aggregations *core.AggregationValue, aggName core.AggregationType) *types.MetricValue {
if inputVal, ok := aggregations.Aggregations[aggName]; ok {
return exportMetricValue(&inputVal)
} else {
return nil
}
}
|
[
"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
|
[
"extractMetricValue",
"checks",
"to",
"see",
"if",
"the",
"given",
"metric",
"was",
"present",
"in",
"the",
"results",
"and",
"if",
"so",
"returns",
"it",
"in",
"API",
"form"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/api/v1/historical_handlers.go#L781-L787
|
train
|
kubernetes-retired/heapster
|
metrics/api/v1/historical_handlers.go
|
exportTimestampedAggregationValue
|
func exportTimestampedAggregationValue(values []core.TimestampedAggregationValue) types.MetricAggregationResult {
result := types.MetricAggregationResult{
Buckets: make([]types.MetricAggregationBucket, 0, len(values)),
BucketSize: 0,
}
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
}
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),
}
if val, ok := value.Aggregations[core.AggregationTypePercentile50]; ok {
bucket.Percentiles["50"] = *exportMetricValue(&val)
}
if val, ok := value.Aggregations[core.AggregationTypePercentile95]; ok {
bucket.Percentiles["95"] = *exportMetricValue(&val)
}
if val, ok := value.Aggregations[core.AggregationTypePercentile99]; ok {
bucket.Percentiles["99"] = *exportMetricValue(&val)
}
result.Buckets = append(result.Buckets, bucket)
}
return result
}
|
go
|
func exportTimestampedAggregationValue(values []core.TimestampedAggregationValue) types.MetricAggregationResult {
result := types.MetricAggregationResult{
Buckets: make([]types.MetricAggregationBucket, 0, len(values)),
BucketSize: 0,
}
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
}
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),
}
if val, ok := value.Aggregations[core.AggregationTypePercentile50]; ok {
bucket.Percentiles["50"] = *exportMetricValue(&val)
}
if val, ok := value.Aggregations[core.AggregationTypePercentile95]; ok {
bucket.Percentiles["95"] = *exportMetricValue(&val)
}
if val, ok := value.Aggregations[core.AggregationTypePercentile99]; ok {
bucket.Percentiles["99"] = *exportMetricValue(&val)
}
result.Buckets = append(result.Buckets, bucket)
}
return result
}
|
[
"func",
"exportTimestampedAggregationValue",
"(",
"values",
"[",
"]",
"core",
".",
"TimestampedAggregationValue",
")",
"types",
".",
"MetricAggregationResult",
"{",
"result",
":=",
"types",
".",
"MetricAggregationResult",
"{",
"Buckets",
":",
"make",
"(",
"[",
"]",
"types",
".",
"MetricAggregationBucket",
",",
"0",
",",
"len",
"(",
"values",
")",
")",
",",
"BucketSize",
":",
"0",
",",
"}",
"\n",
"for",
"_",
",",
"value",
":=",
"range",
"values",
"{",
"if",
"result",
".",
"BucketSize",
"<",
"value",
".",
"BucketSize",
"{",
"result",
".",
"BucketSize",
"=",
"value",
".",
"BucketSize",
"\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",
"if",
"val",
",",
"ok",
":=",
"value",
".",
"Aggregations",
"[",
"core",
".",
"AggregationTypePercentile50",
"]",
";",
"ok",
"{",
"bucket",
".",
"Percentiles",
"[",
"\"50\"",
"]",
"=",
"*",
"exportMetricValue",
"(",
"&",
"val",
")",
"\n",
"}",
"\n",
"if",
"val",
",",
"ok",
":=",
"value",
".",
"Aggregations",
"[",
"core",
".",
"AggregationTypePercentile95",
"]",
";",
"ok",
"{",
"bucket",
".",
"Percentiles",
"[",
"\"95\"",
"]",
"=",
"*",
"exportMetricValue",
"(",
"&",
"val",
")",
"\n",
"}",
"\n",
"if",
"val",
",",
"ok",
":=",
"value",
".",
"Aggregations",
"[",
"core",
".",
"AggregationTypePercentile99",
"]",
";",
"ok",
"{",
"bucket",
".",
"Percentiles",
"[",
"\"99\"",
"]",
"=",
"*",
"exportMetricValue",
"(",
"&",
"val",
")",
"\n",
"}",
"\n",
"result",
".",
"Buckets",
"=",
"append",
"(",
"result",
".",
"Buckets",
",",
"bucket",
")",
"\n",
"}",
"\n",
"return",
"result",
"\n",
"}"
] |
// exportTimestampedAggregationValue converts a core.TimestampedAggregationValue into an API MetricAggregationResult
|
[
"exportTimestampedAggregationValue",
"converts",
"a",
"core",
".",
"TimestampedAggregationValue",
"into",
"an",
"API",
"MetricAggregationResult"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/api/v1/historical_handlers.go#L790-L828
|
train
|
kubernetes-retired/heapster
|
metrics/sources/summary/summary.go
|
decodeSummary
|
func (this *summaryMetricsSource) decodeSummary(summary *stats.Summary) map[string]*MetricSet {
glog.V(9).Infof("Begin summary decode")
result := map[string]*MetricSet{}
labels := map[string]string{
LabelNodename.Key: this.node.NodeName,
LabelHostname.Key: this.node.HostName,
LabelHostID.Key: this.node.HostID,
}
this.decodeNodeStats(result, labels, &summary.Node)
for _, pod := range summary.Pods {
this.decodePodStats(result, labels, &pod)
}
glog.V(9).Infof("End summary decode")
return result
}
|
go
|
func (this *summaryMetricsSource) decodeSummary(summary *stats.Summary) map[string]*MetricSet {
glog.V(9).Infof("Begin summary decode")
result := map[string]*MetricSet{}
labels := map[string]string{
LabelNodename.Key: this.node.NodeName,
LabelHostname.Key: this.node.HostName,
LabelHostID.Key: this.node.HostID,
}
this.decodeNodeStats(result, labels, &summary.Node)
for _, pod := range summary.Pods {
this.decodePodStats(result, labels, &pod)
}
glog.V(9).Infof("End summary decode")
return result
}
|
[
"func",
"(",
"this",
"*",
"summaryMetricsSource",
")",
"decodeSummary",
"(",
"summary",
"*",
"stats",
".",
"Summary",
")",
"map",
"[",
"string",
"]",
"*",
"MetricSet",
"{",
"glog",
".",
"V",
"(",
"9",
")",
".",
"Infof",
"(",
"\"Begin summary decode\"",
")",
"\n",
"result",
":=",
"map",
"[",
"string",
"]",
"*",
"MetricSet",
"{",
"}",
"\n",
"labels",
":=",
"map",
"[",
"string",
"]",
"string",
"{",
"LabelNodename",
".",
"Key",
":",
"this",
".",
"node",
".",
"NodeName",
",",
"LabelHostname",
".",
"Key",
":",
"this",
".",
"node",
".",
"HostName",
",",
"LabelHostID",
".",
"Key",
":",
"this",
".",
"node",
".",
"HostID",
",",
"}",
"\n",
"this",
".",
"decodeNodeStats",
"(",
"result",
",",
"labels",
",",
"&",
"summary",
".",
"Node",
")",
"\n",
"for",
"_",
",",
"pod",
":=",
"range",
"summary",
".",
"Pods",
"{",
"this",
".",
"decodePodStats",
"(",
"result",
",",
"labels",
",",
"&",
"pod",
")",
"\n",
"}",
"\n",
"glog",
".",
"V",
"(",
"9",
")",
".",
"Infof",
"(",
"\"End summary decode\"",
")",
"\n",
"return",
"result",
"\n",
"}"
] |
// decodeSummary translates the kubelet statsSummary API into the flattened heapster MetricSet API.
|
[
"decodeSummary",
"translates",
"the",
"kubelet",
"statsSummary",
"API",
"into",
"the",
"flattened",
"heapster",
"MetricSet",
"API",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sources/summary/summary.go#L120-L137
|
train
|
kubernetes-retired/heapster
|
metrics/sources/summary/summary.go
|
cloneLabels
|
func (this *summaryMetricsSource) cloneLabels(labels map[string]string) map[string]string {
clone := make(map[string]string, len(labels))
for k, v := range labels {
clone[k] = v
}
return clone
}
|
go
|
func (this *summaryMetricsSource) cloneLabels(labels map[string]string) map[string]string {
clone := make(map[string]string, len(labels))
for k, v := range labels {
clone[k] = v
}
return clone
}
|
[
"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.
|
[
"Convenience",
"method",
"for",
"labels",
"deep",
"copy",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sources/summary/summary.go#L140-L146
|
train
|
kubernetes-retired/heapster
|
metrics/sources/summary/summary.go
|
addIntMetric
|
func (this *summaryMetricsSource) addIntMetric(metrics *MetricSet, metric *Metric, value *uint64) {
if value == nil {
glog.V(9).Infof("skipping metric %s because the value was nil", metric.Name)
return
}
val := MetricValue{
ValueType: ValueInt64,
MetricType: metric.Type,
IntValue: int64(*value),
}
metrics.MetricValues[metric.Name] = val
}
|
go
|
func (this *summaryMetricsSource) addIntMetric(metrics *MetricSet, metric *Metric, value *uint64) {
if value == nil {
glog.V(9).Infof("skipping metric %s because the value was nil", metric.Name)
return
}
val := MetricValue{
ValueType: ValueInt64,
MetricType: metric.Type,
IntValue: int64(*value),
}
metrics.MetricValues[metric.Name] = val
}
|
[
"func",
"(",
"this",
"*",
"summaryMetricsSource",
")",
"addIntMetric",
"(",
"metrics",
"*",
"MetricSet",
",",
"metric",
"*",
"Metric",
",",
"value",
"*",
"uint64",
")",
"{",
"if",
"value",
"==",
"nil",
"{",
"glog",
".",
"V",
"(",
"9",
")",
".",
"Infof",
"(",
"\"skipping metric %s because the value was nil\"",
",",
"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.
|
[
"addIntMetric",
"is",
"a",
"convenience",
"method",
"for",
"adding",
"the",
"metric",
"and",
"value",
"to",
"the",
"metric",
"set",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sources/summary/summary.go#L370-L381
|
train
|
kubernetes-retired/heapster
|
metrics/sources/summary/summary.go
|
addLabeledIntMetric
|
func (this *summaryMetricsSource) addLabeledIntMetric(metrics *MetricSet, metric *Metric, labels map[string]string, value *uint64) {
if value == nil {
glog.V(9).Infof("skipping labeled metric %s (%v) because the value was nil", metric.Name, labels)
return
}
val := LabeledMetric{
Name: metric.Name,
Labels: labels,
MetricValue: MetricValue{
ValueType: ValueInt64,
MetricType: metric.Type,
IntValue: int64(*value),
},
}
metrics.LabeledMetrics = append(metrics.LabeledMetrics, val)
}
|
go
|
func (this *summaryMetricsSource) addLabeledIntMetric(metrics *MetricSet, metric *Metric, labels map[string]string, value *uint64) {
if value == nil {
glog.V(9).Infof("skipping labeled metric %s (%v) because the value was nil", metric.Name, labels)
return
}
val := LabeledMetric{
Name: metric.Name,
Labels: labels,
MetricValue: MetricValue{
ValueType: ValueInt64,
MetricType: metric.Type,
IntValue: int64(*value),
},
}
metrics.LabeledMetrics = append(metrics.LabeledMetrics, val)
}
|
[
"func",
"(",
"this",
"*",
"summaryMetricsSource",
")",
"addLabeledIntMetric",
"(",
"metrics",
"*",
"MetricSet",
",",
"metric",
"*",
"Metric",
",",
"labels",
"map",
"[",
"string",
"]",
"string",
",",
"value",
"*",
"uint64",
")",
"{",
"if",
"value",
"==",
"nil",
"{",
"glog",
".",
"V",
"(",
"9",
")",
".",
"Infof",
"(",
"\"skipping labeled metric %s (%v) because the value was nil\"",
",",
"metric",
".",
"Name",
",",
"labels",
")",
"\n",
"return",
"\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.
|
[
"addLabeledIntMetric",
"is",
"a",
"convenience",
"method",
"for",
"adding",
"the",
"labeled",
"metric",
"and",
"value",
"to",
"the",
"metric",
"set",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sources/summary/summary.go#L384-L400
|
train
|
kubernetes-retired/heapster
|
metrics/sources/summary/summary.go
|
getSystemContainerName
|
func (this *summaryMetricsSource) getSystemContainerName(c *stats.ContainerStats) string {
if legacyName, ok := systemNameMap[c.Name]; ok {
return legacyName
}
return c.Name
}
|
go
|
func (this *summaryMetricsSource) getSystemContainerName(c *stats.ContainerStats) string {
if legacyName, ok := systemNameMap[c.Name]; ok {
return legacyName
}
return c.Name
}
|
[
"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.
|
[
"Translate",
"system",
"container",
"names",
"to",
"the",
"legacy",
"names",
"for",
"backwards",
"compatibility",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sources/summary/summary.go#L403-L408
|
train
|
kubernetes-retired/heapster
|
common/riemann/riemann.go
|
GetRiemannClient
|
func GetRiemannClient(config RiemannConfig) (riemanngo.Client, error) {
glog.Infof("Connect Riemann client...")
client := riemanngo.NewTcpClient(config.Host)
runtime.SetFinalizer(client, func(c riemanngo.Client) { c.Close() })
// 5 seconds timeout
err := client.Connect(5)
if err != nil {
return nil, err
}
return client, nil
}
|
go
|
func GetRiemannClient(config RiemannConfig) (riemanngo.Client, error) {
glog.Infof("Connect Riemann client...")
client := riemanngo.NewTcpClient(config.Host)
runtime.SetFinalizer(client, func(c riemanngo.Client) { c.Close() })
// 5 seconds timeout
err := client.Connect(5)
if err != nil {
return nil, err
}
return client, nil
}
|
[
"func",
"GetRiemannClient",
"(",
"config",
"RiemannConfig",
")",
"(",
"riemanngo",
".",
"Client",
",",
"error",
")",
"{",
"glog",
".",
"Infof",
"(",
"\"Connect Riemann client...\"",
")",
"\n",
"client",
":=",
"riemanngo",
".",
"NewTcpClient",
"(",
"config",
".",
"Host",
")",
"\n",
"runtime",
".",
"SetFinalizer",
"(",
"client",
",",
"func",
"(",
"c",
"riemanngo",
".",
"Client",
")",
"{",
"c",
".",
"Close",
"(",
")",
"}",
")",
"\n",
"err",
":=",
"client",
".",
"Connect",
"(",
"5",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"client",
",",
"nil",
"\n",
"}"
] |
// Receives a sink, connect the riemann client.
|
[
"Receives",
"a",
"sink",
"connect",
"the",
"riemann",
"client",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/common/riemann/riemann.go#L102-L112
|
train
|
kubernetes-retired/heapster
|
common/riemann/riemann.go
|
SendData
|
func SendData(client riemanngo.Client, events []riemanngo.Event) error {
// do nothing if we are not connected
if client == nil {
glog.Warningf("Riemann sink not connected")
return nil
}
start := time.Now()
_, err := riemanngo.SendEvents(client, &events)
end := time.Now()
if err == nil {
glog.V(4).Infof("Exported %d events to riemann in %s", len(events), end.Sub(start))
return nil
} else {
glog.Warningf("There were errors sending events to Riemman, forcing reconnection. Error : %+v", err)
return err
}
}
|
go
|
func SendData(client riemanngo.Client, events []riemanngo.Event) error {
// do nothing if we are not connected
if client == nil {
glog.Warningf("Riemann sink not connected")
return nil
}
start := time.Now()
_, err := riemanngo.SendEvents(client, &events)
end := time.Now()
if err == nil {
glog.V(4).Infof("Exported %d events to riemann in %s", len(events), end.Sub(start))
return nil
} else {
glog.Warningf("There were errors sending events to Riemman, forcing reconnection. Error : %+v", err)
return err
}
}
|
[
"func",
"SendData",
"(",
"client",
"riemanngo",
".",
"Client",
",",
"events",
"[",
"]",
"riemanngo",
".",
"Event",
")",
"error",
"{",
"if",
"client",
"==",
"nil",
"{",
"glog",
".",
"Warningf",
"(",
"\"Riemann sink not connected\"",
")",
"\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",
"(",
"\"Exported %d events to riemann in %s\"",
",",
"len",
"(",
"events",
")",
",",
"end",
".",
"Sub",
"(",
"start",
")",
")",
"\n",
"return",
"nil",
"\n",
"}",
"else",
"{",
"glog",
".",
"Warningf",
"(",
"\"There were errors sending events to Riemman, forcing reconnection. Error : %+v\"",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"}"
] |
// Send Events to Riemann using the client from the sink.
|
[
"Send",
"Events",
"to",
"Riemann",
"using",
"the",
"client",
"from",
"the",
"sink",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/common/riemann/riemann.go#L115-L131
|
train
|
kubernetes-retired/heapster
|
events/sinks/manager.go
|
ExportEvents
|
func (this *sinkManager) ExportEvents(data *core.EventBatch) {
var wg sync.WaitGroup
for _, sh := range this.sinkHolders {
wg.Add(1)
go func(sh sinkHolder, wg *sync.WaitGroup) {
defer wg.Done()
glog.V(2).Infof("Pushing events to: %s", sh.sink.Name())
select {
case sh.eventBatchChannel <- data:
glog.V(2).Infof("Data events completed: %s", sh.sink.Name())
// everything ok
case <-time.After(this.exportEventsTimeout):
glog.Warningf("Failed to events data to sink: %s", sh.sink.Name())
}
}(sh, &wg)
}
// Wait for all pushes to complete or timeout.
wg.Wait()
}
|
go
|
func (this *sinkManager) ExportEvents(data *core.EventBatch) {
var wg sync.WaitGroup
for _, sh := range this.sinkHolders {
wg.Add(1)
go func(sh sinkHolder, wg *sync.WaitGroup) {
defer wg.Done()
glog.V(2).Infof("Pushing events to: %s", sh.sink.Name())
select {
case sh.eventBatchChannel <- data:
glog.V(2).Infof("Data events completed: %s", sh.sink.Name())
// everything ok
case <-time.After(this.exportEventsTimeout):
glog.Warningf("Failed to events data to sink: %s", sh.sink.Name())
}
}(sh, &wg)
}
// Wait for all pushes to complete or timeout.
wg.Wait()
}
|
[
"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",
"(",
"\"Pushing events to: %s\"",
",",
"sh",
".",
"sink",
".",
"Name",
"(",
")",
")",
"\n",
"select",
"{",
"case",
"sh",
".",
"eventBatchChannel",
"<-",
"data",
":",
"glog",
".",
"V",
"(",
"2",
")",
".",
"Infof",
"(",
"\"Data events completed: %s\"",
",",
"sh",
".",
"sink",
".",
"Name",
"(",
")",
")",
"\n",
"case",
"<-",
"time",
".",
"After",
"(",
"this",
".",
"exportEventsTimeout",
")",
":",
"glog",
".",
"Warningf",
"(",
"\"Failed to events data to sink: %s\"",
",",
"sh",
".",
"sink",
".",
"Name",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"(",
"sh",
",",
"&",
"wg",
")",
"\n",
"}",
"\n",
"wg",
".",
"Wait",
"(",
")",
"\n",
"}"
] |
// Guarantees that the export will complete in exportEventsTimeout.
|
[
"Guarantees",
"that",
"the",
"export",
"will",
"complete",
"in",
"exportEventsTimeout",
"."
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/events/sinks/manager.go#L96-L114
|
train
|
kubernetes-retired/heapster
|
metrics/sinks/hawkular/client.go
|
cache
|
func (h *hawkularSink) cache(md *metrics.MetricDefinition) {
h.pushToCache(md.ID, hashDefinition(md))
}
|
go
|
func (h *hawkularSink) cache(md *metrics.MetricDefinition) {
h.pushToCache(md.ID, hashDefinition(md))
}
|
[
"func",
"(",
"h",
"*",
"hawkularSink",
")",
"cache",
"(",
"md",
"*",
"metrics",
".",
"MetricDefinition",
")",
"{",
"h",
".",
"pushToCache",
"(",
"md",
".",
"ID",
",",
"hashDefinition",
"(",
"md",
")",
")",
"\n",
"}"
] |
// cache inserts the item to the cache
|
[
"cache",
"inserts",
"the",
"item",
"to",
"the",
"cache"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sinks/hawkular/client.go#L50-L52
|
train
|
kubernetes-retired/heapster
|
metrics/sinks/hawkular/client.go
|
pushToCache
|
func (h *hawkularSink) pushToCache(key string, hash uint64) {
h.regLock.Lock()
h.expReg[key] = &expiringItem{
hash: hash,
ttl: h.runId,
}
h.regLock.Unlock()
}
|
go
|
func (h *hawkularSink) pushToCache(key string, hash uint64) {
h.regLock.Lock()
h.expReg[key] = &expiringItem{
hash: hash,
ttl: h.runId,
}
h.regLock.Unlock()
}
|
[
"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
|
[
"toCache",
"inserts",
"the",
"item",
"and",
"updates",
"the",
"TTL",
"in",
"the",
"cache",
"to",
"current",
"time"
] |
e1e83412787b60d8a70088f09a2cb12339b305c3
|
https://github.com/kubernetes-retired/heapster/blob/e1e83412787b60d8a70088f09a2cb12339b305c3/metrics/sinks/hawkular/client.go#L55-L62
|
train
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.