func main() {
JSONStruct := &JSONData{}
err := JSONStruct.FromJSON("/etc/conf.json")
if err != nil {
panic(err)
}
inf, err := rrd.Info(JSONStruct.Dbfile)
if err != nil {
log.Fatal(err)
}
end := time.Unix(int64(inf["last_update"].(uint)), 0)
start := end.Add(-288 * step * time.Second)
fetchRes, err := rrd.Fetch(JSONStruct.Dbfile, "AVERAGE", start, end, step*time.Second)
if err != nil {
log.Fatal(err)
}
defer fetchRes.FreeValues()
num := start.Format("2006-01-02_15:04:05")
fileName := JSONStruct.Devicename + "_" + num + ".csv"
buf := new(bytes.Buffer)
r2 := csv.NewWriter(buf)
for i := 0; i <= 288; i++ {
v1 := fetchRes.ValueAt(0, i) * 8 / 1024 / 1024
v2 := fetchRes.ValueAt(1, i) * 8 / 1024 / 1024
t1 := FloatToString(v1) + "Mbps"
t2 := FloatToString(v2) + "Mbps"
s := make([]string, 3)
num := (i + 1) * step
t22 := start.Add(time.Duration(num) * time.Second)
t11 := (t22.String())
s[0] = t11
s[1] = t1
s[2] = t2
r2.Write(s)
r2.Flush()
}
fout, err := os.Create(fileName)
defer fout.Close()
if err != nil {
fmt.Println(fileName, err)
return
}
fout.WriteString(buf.String())
fmt.Printf("\n")
}
func (c Api) DataTsv(path, cf, duration, end string, step int) revel.Result {
dataDir, found := revel.Config.String("rrd.data_dir")
if !found {
return c.RenderError(errors.New("config rrd.data_dir not found"))
}
rrdpath := fmt.Sprintf("%s/%s", dataDir, path)
if cf == "" {
cf = "AVERAGE"
}
var endTime time.Time
revel.TRACE.Printf("DataTsv end=%s", end)
if end == "" {
endTime = time.Now()
} else {
endInt, err := strconv.ParseInt(end, 10, 64)
if err != nil {
return c.RenderError(err)
}
endTime = time.Unix(endInt, 0)
}
revel.TRACE.Printf("DataTsv endTime=%s", endTime)
if duration == "" {
duration = "1h"
}
graphDuration, err := Ti.ParseDuration(duration)
if err != nil {
return c.RenderError(err)
}
revel.TRACE.Printf("DataTsv graphDuration=%s", graphDuration)
startTime := endTime.Add(-graphDuration)
revel.TRACE.Printf("DataTsv startTime=%s", startTime)
if step == 0 {
step = 60
revel.TRACE.Printf("DataTsv step was zero, now %d", step)
}
stepDuration := time.Duration(step) * time.Second
data, err := rrd.Fetch(rrdpath, cf, startTime, endTime, stepDuration)
if err != nil {
revel.TRACE.Printf("Fetch fails %s", err)
return c.RenderError(err)
}
defer data.FreeValues()
return RrdFetchTsvResult{data, step}
}
func fetchDB(dbfile string, step uint) (err error) {
inf, err := rrd.Info(dbfile)
if err != nil {
return
}
end := time.Unix(int64(inf["last_update"].(uint)), 0)
start := end.Add(-20 * time.Duration(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", time.Duration(step)*time.Second)
fetchRes, err := rrd.Fetch(dbfile, "AVERAGE", start, end, time.Duration(step)*time.Second)
if err != nil {
return
}
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++
}
return
}
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++
}
}
