func updateDB(dbfile string, step uint) (err error) {
u := rrd.NewUpdater(dbfile)
fmt.Println("Started Before:", time.Now())
for i := 0; i < 10; i++ {
err = u.Update(time.Now(), i, i*i)
time.Sleep(time.Duration(step) * time.Second)
if err != nil {
return
}
}
fmt.Println("Stopped After:", time.Now())
return
}
func updateUsage(u *usage, dbfile string) {
delta := sinceLastUpdate(dbfile)
if delta.Seconds() > 3300 {
logger.Println("Updating RRD with usage...")
up := rrd.NewUpdater(dbfile)
up.SetTemplate("letter-simplex:letter-duplex")
err := up.Update(time.Now(), u.simplex(), u.duplex())
if err != nil {
logger.Fatal(err)
}
} else {
logger.Println("Too soon...")
}
}
func main() {
flag.Parse()
s, err := mgo.Dial(mongo)
if err != nil {
log.Err.Fatal(err)
}
defer s.Close()
var hosts []string
collection := s.DB("af24").C("event")
err = collection.Find(nil).Distinct("host", &hosts)
if err != nil {
log.Err.Fatal(err)
}
for _, host := range hosts {
filename := path.Join(output, host+".rrd")
log.Info.Printf("processing %s", host)
var q bson.M
info, err := rrd.Info(filename)
if err != nil {
q = bson.M{"type": "aflog", "host": host}
} else {
lasti, ok := info["last_update"]
if !ok {
log.Err.Fatal("rrd file exists, but no last update")
}
last, ok := lasti.(uint)
if !ok {
log.Err.Fatalf("last update is of wrong type: %#v", lasti)
}
utime := time.Unix(int64(last), 0)
q = bson.M{"type": "aflog", "host": host, "timestamp": bson.M{"$gt": utime}}
}
it := collection.Find(q).Sort("timestamp").Iter()
if it == nil {
log.Err.Fatal("iterator is nil!")
}
var creator *rrd.Creator
var updater *rrd.Updater
var e event.Event
for it.Next(&e) {
if creator == nil {
start := e["timestamp"].(time.Time)
creator = rrd.NewCreator(filename, start, 10)
creator.DS("rx0", "GAUGE", 60, -120, 0)
creator.DS("rx1", "GAUGE", 60, -120, 0)
creator.DS("cap", "GAUGE", 60, 0, 1e9)
creator.DS("pow", "GAUGE", 60, -50, 50)
creator.RRA("AVERAGE", 0, 1, 6*60*24*365)
err = creator.Create(overwrite)
if err != nil && !os.IsExist(err) {
log.Err.Fatal(err)
}
}
if updater == nil {
updater = rrd.NewUpdater(filename)
}
timestamp := e["timestamp"].(time.Time)
locali, ok := e["local"]
if !ok {
log.Warn.Printf("[%v] no local section", e["uuid"])
continue
}
local, ok := locali.(event.Event)
if !ok {
log.Warn.Printf("[%v] local section has wrong type: %#v", e["uuid"], locali)
continue
}
rx0i, ok := local["rxpower0"]
if !ok {
log.Warn.Printf("[%v] local rxpower0 absent", e["uuid"])
continue
}
rx0, ok := rx0i.(int64)
if !ok {
log.Warn.Printf("[%v] local rxpower0 has wrong type: %#v", e["uuid"], rx0i)
continue
}
rx1i, ok := local["rxpower1"]
if !ok {
log.Warn.Printf("[%v] local rxpower1 absent", e["uuid"])
continue
}
rx1, ok := rx1i.(int64)
if !ok {
log.Warn.Printf("[%v] local rxpower1 has wrong type: %#v", e["uuid"], rx1i)
continue
}
rxcapi, ok := local["rxcapacity"]
if !ok {
log.Warn.Printf("[%v] local rxcapacity absent", e["uuid"])
continue
}
rxcap, ok := rxcapi.(int64)
if !ok {
log.Warn.Printf("[%v] local rxcapacity has wrong type: %#v", e["uuid"], rxcapi)
continue
}
remotei, ok := e["remote"]
if !ok {
log.Warn.Printf("[%v] no remote section", e["uuid"])
continue
}
remote, ok := remotei.(event.Event)
if !ok {
log.Warn.Printf("[%v] remote section has wrong type: %#v", e["uuid"], remotei)
continue
}
poweri, ok := remote["rpowerout"]
if !ok {
log.Warn.Printf("[%v] remote rpowerout is absent", e["uuid"])
continue
}
power, ok := poweri.(int64)
if !ok {
log.Warn.Printf("[%v] remote rpowerout has wrong type: %v", e["uuid"], poweri)
continue
}
err = updater.Update(timestamp.Unix(), rx0, rx1, rxcap, power)
if err != nil {
log.Err.Print(err)
continue
}
}
}
}
func main() {
// Create
const (
dbfile = "/tmp/test.rrd"
step = 1
heartbeat = 2 * step
)
c := rrd.NewCreator(dbfile, time.Now(), step)
c.RRA("AVERAGE", 0.5, 1, 100)
c.RRA("AVERAGE", 0.5, 5, 100)
c.DS("cnt", "COUNTER", heartbeat, 0, 100)
c.DS("g", "GAUGE", heartbeat, 0, 60)
err := c.Create(true)
if err != nil {
panic(err)
}
// Update
u := rrd.NewUpdater(dbfile)
for i := 0; i < 10; i++ {
time.Sleep(step * time.Second)
err := u.Update(time.Now(), i, 1.5*float64(i))
if err != nil {
panic(err)
}
}
// Update with cache
for i := 10; i < 20; i++ {
time.Sleep(step * time.Second)
u.Cache(time.Now(), i, 2*float64(i))
}
err = u.Update()
if err != nil {
panic(err)
}
// Info
inf, err := rrd.Info(dbfile)
if err != nil {
panic(err)
}
for k, v := range inf {
fmt.Printf("%s (%T): %v\n", k, v, v)
}
// Graph
g := rrd.NewGrapher()
g.SetTitle("Test")
g.SetVLabel("some variable")
g.SetSize(800, 300)
g.SetWatermark("some watermark")
g.Def("v1", dbfile, "g", "AVERAGE")
g.Def("v2", dbfile, "cnt", "AVERAGE")
g.VDef("max1", "v1,MAXIMUM")
g.VDef("avg2", "v2,AVERAGE")
g.Line(1, "v1", "ff0000", "var 1")
g.Area("v2", "0000ff", "var 2")
g.GPrintT("max1", "max1 at %c")
g.GPrint("avg2", "avg2=%lf")
g.PrintT("max1", "max1 at %c")
g.Print("avg2", "avg2=%lf")
now := time.Now()
i, err := g.SaveGraph("/tmp/test_rrd1.png", now.Add(-20*time.Second), now)
fmt.Printf("%+v\n", i)
if err != nil {
panic(err)
}
i, buf, err := g.Graph(now.Add(-20*time.Second), now)
fmt.Printf("%+v\n", i)
if err != nil {
panic(err)
}
err = ioutil.WriteFile("/tmp/test_rrd2.png", buf, 0666)
if err != nil {
panic(err)
}
// Fetch
end := time.Unix(int64(inf["last_update"].(uint)), 0)
start := end.Add(-20 * step * time.Second)
fmt.Printf("Fetch Params:\n")
fmt.Printf("Start: %s\n", start)
fmt.Printf("End: %s\n", end)
fmt.Printf("Step: %s\n", step*time.Second)
fetchRes, err := rrd.Fetch(dbfile, "AVERAGE", start, end, step*time.Second)
if err != nil {
panic(err)
}
defer fetchRes.FreeValues()
fmt.Printf("FetchResult:\n")
fmt.Printf("Start: %s\n", fetchRes.Start)
fmt.Printf("End: %s\n", fetchRes.End)
fmt.Printf("Step: %s\n", fetchRes.Step)
for _, dsName := range fetchRes.DsNames {
fmt.Printf("\t%s", dsName)
}
fmt.Printf("\n")
row := 0
for ti := fetchRes.Start.Add(fetchRes.Step); ti.Before(end) || ti.Equal(end); ti = ti.Add(fetchRes.Step) {
fmt.Printf("%s / %d", ti, ti.Unix())
for i := 0; i < len(fetchRes.DsNames); i++ {
v := fetchRes.ValueAt(i, row)
fmt.Printf("\t%e", v)
}
fmt.Printf("\n")
row++
}
// Xport
end = time.Unix(int64(inf["last_update"].(uint)), 0)
start = end.Add(-20 * step * time.Second)
fmt.Printf("Xport Params:\n")
fmt.Printf("Start: %s\n", start)
fmt.Printf("End: %s\n", end)
fmt.Printf("Step: %s\n", step*time.Second)
e := rrd.NewExporter()
e.Def("def1", dbfile, "cnt", "AVERAGE")
e.Def("def2", dbfile, "g", "AVERAGE")
e.CDef("vdef1", "def1,def2,+")
e.XportDef("def1", "cnt")
e.XportDef("def2", "g")
e.XportDef("vdef1", "sum")
xportRes, err := e.Xport(start, end, step*time.Second)
if err != nil {
panic(err)
}
defer xportRes.FreeValues()
fmt.Printf("XportResult:\n")
fmt.Printf("Start: %s\n", xportRes.Start)
fmt.Printf("End: %s\n", xportRes.End)
fmt.Printf("Step: %s\n", xportRes.Step)
for _, legend := range xportRes.Legends {
fmt.Printf("\t%s", legend)
}
fmt.Printf("\n")
row = 0
for ti := xportRes.Start.Add(xportRes.Step); ti.Before(end) || ti.Equal(end); ti = ti.Add(xportRes.Step) {
fmt.Printf("%s / %d", ti, ti.Unix())
for i := 0; i < len(xportRes.Legends); i++ {
v := xportRes.ValueAt(i, row)
fmt.Printf("\t%e", v)
}
fmt.Printf("\n")
row++
}
}