func main() { log.SetFlags(log.Ldate | log.Ltime | log.Lshortfile) flag.Parse() ctx := context.Background() conn, err := client.NewRpcClient(ctx, *connectAddress) if err != nil { log.Fatalf("Error connecting to %s: %s", *connectAddress, err) } defer conn.Close() switch os.Args[1] { case "get": response, err := conn.GetConfig(ctx) if err != nil { log.Fatal(err) } fmt.Println(openinstrument.ProtoText(response)) case "add_loadtest": runAddLoadtest(ctx, conn) case "slow_add_loadtest": runSlowAddLoadtest(ctx) } }
func runSlowAddLoadtest(ctx context.Context) { log.Println("Running ADD load test") var sent, received int go func() { tick := time.Tick(1 * time.Second) for { select { case <-tick: log.Printf("Sent %d, received %d in the last second, latency %0.02fms", sent, received, 1.0/float64(received)*1000.0) received = 0 sent = 0 } } }() for { conn, err := client.NewRpcClient(ctx, *connectAddress) if err != nil { log.Fatalf("Error connecting to %s: %s", *connectAddress, err) } in, out, err := conn.Add(ctx) if err != nil { log.Printf("Error starting Add RPC: %s", err) return } v := variable.NewFromString("/test/var1{host=rage}").AsProto() request := &oproto.AddRequest{ Stream: []*oproto.ValueStream{ { Variable: v, Value: []*oproto.Value{ { Timestamp: openinstrument.NowMs(), DoubleValue: 1.0, }, }, }, }, } in <- request close(in) sent++ <-out received++ conn.Close() } log.Println("Complete") }
func main() { log.SetFlags(log.Ldate | log.Ltime | log.Lshortfile) flag.Parse() if len(flag.Args()) < 1 { log.Fatal("Specify at least one variable to retrieve") } q, err := query.Parse(flag.Arg(0)) if err != nil { log.Fatal("Invalid query:", err) } conn, err := client.NewRpcClient(context.Background(), *connectAddress) if err != nil { log.Fatalf("Error connecting to %s: %s", *connectAddress, err) } defer conn.Close() request := &oproto.GetRequest{ Query: q.AsProto(), MaxValues: uint32(*maxValues), MaxVariables: uint32(*maxVariables), } log.Printf("Sending query: %s", openinstrument.ProtoText(q.AsProto())) c, err := conn.Get(context.Background(), request) if err != nil { log.Fatal(err) } for response := range c { for _, stream := range response.Stream { variable := variable.NewFromProto(stream.Variable).String() for _, value := range stream.Value { fmt.Printf("%s\t%s\t", variable, time.Unix(int64(value.Timestamp/1000), 0)) if value.StringValue == "" { fmt.Printf("%f\n", value.DoubleValue) } else { fmt.Printf("%s\n", value.StringValue) } } } } }
func main() { log.SetFlags(log.Ldate | log.Ltime | log.Lshortfile) flag.Parse() if len(flag.Args()) < 1 { log.Fatal("Specify at least one variable to retrieve") } if *connectAddress == "" { log.Fatal("--connect address:port required") } request := &oproto.ListRequest{ Prefix: variable.NewFromString(flag.Arg(0)).AsProto(), MaxVariables: uint32(*maxVariables), } if *maxAge != "" { d, _ := time.ParseDuration(*maxAge) request.Prefix.MinTimestamp = -d.Nanoseconds() / 1000000 } conn, err := client.NewRpcClient(context.Background(), *connectAddress) if err != nil { log.Fatalf("Error connecting to %s: %s", *connectAddress, err) } defer conn.Close() c, err := conn.List(context.Background(), request) if err != nil { log.Fatal(err) } vars := []string{} for response := range c { for _, v := range response.Variable { vars = append(vars, variable.NewFromProto(v).String()) } } sort.Strings(vars) for _, variable := range vars { fmt.Println(variable) } }
func main() { log.SetFlags(log.Ldate | log.Ltime | log.Lshortfile) flag.Parse() ctx := context.Background() conn, err := client.NewRpcClient(ctx, *connectAddress) if err != nil { log.Fatalf("Error connecting to %s: %s", *connectAddress, err) } defer conn.Close() in, out, err := conn.Add(ctx) if err != nil { log.Fatal(err) } snmp := gosnmp.Default for _, host := range []string{"192.168.1.1"} { snmp.Target = host snmp.Community = "public" if err := snmp.Connect(); err != nil { log.Fatal(err) } defer snmp.Conn.Close() // VDSL-LINE-MIB::vdslPhysCurrLineRate.1 = Gauge32: 20265 kbps // VDSL-LINE-MIB::vdslPhysCurrLineRate.2 = Gauge32: 1315 kbps oids := []string{"1.3.6.1.2.1.10.97.1.1.2.1.10.1", "1.3.6.1.2.1.10.97.1.1.2.1.10.2"} result, err := snmp.Get(oids) if err != nil { log.Fatal(err) } request := &oproto.AddRequest{ Stream: []*oproto.ValueStream{}, } for _, snmpVar := range result.Variables { switch snmpVar.Name { case ".1.3.6.1.2.1.10.97.1.1.2.1.10.1": request.Stream = append(request.Stream, &oproto.ValueStream{ Variable: variable.NewFromString(fmt.Sprintf("/network/adsl/downstream_rate{host=%s,unit=bps}", host)).AsProto(), Value: []*oproto.Value{ { DoubleValue: float64(snmpVar.Value.(uint) * 1000), Timestamp: openinstrument.NowMs(), }, }, }) case ".1.3.6.1.2.1.10.97.1.1.2.1.10.2": request.Stream = append(request.Stream, &oproto.ValueStream{ Variable: variable.NewFromString(fmt.Sprintf("/network/adsl/upstream_rate{host=%s,unit=bps}", host)).AsProto(), Value: []*oproto.Value{ { DoubleValue: float64(snmpVar.Value.(uint) * 1000), Timestamp: openinstrument.NowMs(), }, }, }) } } in <- request } close(in) for response := range out { if !response.Success { fmt.Println(openinstrument.ProtoText(response)) } } }
func main() { log.SetFlags(log.Ldate | log.Ltime | log.Lshortfile) flag.Parse() ctx := context.Background() conn, err := client.NewRpcClient(ctx, *connectAddress) if err != nil { log.Fatalf("Error connecting to %s: %s", *connectAddress, err) } defer conn.Close() re, err := regexp.Compile("^([^\\s]+) (.+)$") if err != nil { log.Fatalf("Error compiling regex: %s", err) } timestamp := openinstrument.NowMs() // Read from stdin c := make(chan *oproto.ValueStream) go func() { defer close(c) scanner := bufio.NewScanner(os.Stdin) for scanner.Scan() { matches := re.FindStringSubmatch(scanner.Text()) if len(matches) != 3 { log.Printf("Invalid input line: %s", scanner.Text()) continue } v := variable.NewFromString(matches[1]) value := &oproto.Value{Timestamp: timestamp} f, err := strconv.ParseFloat(matches[2], 64) if err != nil { value.StringValue = matches[2] } else { value.DoubleValue = f } c <- &oproto.ValueStream{ Variable: v.AsProto(), Value: []*oproto.Value{value}, } } }() if *readTimeout != 0 { ctx, _ = context.WithTimeout(ctx, *readTimeout) } in, out, err := conn.Add(ctx) if err != nil { log.Fatal(err) } func() { defer close(in) interval := time.Tick(1 * time.Second) request := &oproto.AddRequest{} for { select { case stream := <-c: if stream == nil { in <- request return } request.Stream = append(request.Stream, stream) case <-interval: in <- request request = &oproto.AddRequest{} timestamp = openinstrument.NowMs() case response := <-out: if response == nil { return } log.Printf("%s", response) } } in <- request log.Printf("done") }() for response := range out { log.Printf("%s", response) } }