Example #1
0
func (s *MySuite) TestVariableInsideRelativeRange(c *C) {
	v := NewFromString("/test")
	// From 40 to 50 seconds ago
	v.MinTimestamp = -50000
	v.MaxTimestamp = -40000
	c.Check(v.TimestampInsideRange(openinstrument.NowMs()-60000), Equals, false)
	c.Check(v.TimestampInsideRange(openinstrument.NowMs()-45000), Equals, true)
	c.Check(v.TimestampInsideRange(openinstrument.NowMs()-20000), Equals, false)
}
// UpdateThisState makes a change to the state of the current server and broadcasts it to the cluster.
func (s *LocalConfigStore) UpdateThisState(ctx context.Context, state oproto.ClusterMember_State) error {
	m, err := s.GetServer(ctx, s.taskName)
	if err != nil {
		m = oproto.ClusterMember{
			Name:        s.taskName,
			LastUpdated: openinstrument.NowMs(),
		}
	}
	m.State = state
	m.LastUpdated = openinstrument.NowMs()
	return s.UpdateServer(ctx, m)
}
Example #3
0
func (v *Variable) TimestampInsideRange(timestamp uint64) bool {
	minTimestamp := v.MinTimestamp
	if minTimestamp < 0 {
		minTimestamp = int64(openinstrument.NowMs()) + minTimestamp
	}
	maxTimestamp := v.MaxTimestamp
	if maxTimestamp < 0 {
		maxTimestamp = int64(openinstrument.NowMs()) + maxTimestamp
	}
	if maxTimestamp != 0 && int64(timestamp) > maxTimestamp {
		// Too new
		return false
	}
	if int64(timestamp) < minTimestamp {
		// Too old
		return false
	}
	return true
}
Example #4
0
func runAddLoadtest(ctx context.Context, conn client.Client) {
	log.Println("Running ADD load test")
	in, out, err := conn.Add(ctx)
	if err != nil {
		log.Printf("Error starting Add RPC: %s", err)
		return
	}
	defer close(in)

	sem := make(semaphore, 1000)

	var sent, received int

	go func() {
		tick := time.Tick(1 * time.Second)
		for {
			select {
			case <-out:
				received++
				sem.V(1)
			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 {
		select {
		case <-ctx.Done():
			return
		default:
		}
		sem.P(1)
		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
		sent++
	}
	log.Println("Complete")
}
Example #5
0
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")
}
Example #6
0
func (s *MySuite) TestAgeKeepPolicy(c *C) {
	return
	// TODO(dparrish): Re-enable this when it works
	policyTxt := `
			interval: 1
			policy {
				comment: "Throw everything away"
				variable {
					name: "/test/foo*"
					min_timestamp: -91
					max_timestamp: -75
				}
				policy: KEEP
			}
			# Implicit DROP
		`
	policyProto := &oproto.RetentionPolicy{}
	c.Assert(proto.UnmarshalText(policyTxt, policyProto), IsNil)
	policy := New(policyProto)

	input := &oproto.ValueStream{
		Variable: variable.NewFromString("/test/foo/bar").AsProto(),
		Value:    []*oproto.Value{},
	}
	now := openinstrument.NowMs()
	for i := 1; i <= 10; i++ {
		input.Value = append(input.Value, &oproto.Value{
			Timestamp:    now - uint64(98-3*i),
			EndTimestamp: now - uint64(100-3*i),
			DoubleValue:  1.1,
		})
	}

	output := policy.Apply(input)

	count := 0
	for _, value := range output.Value {
		age := now - value.Timestamp
		if age < 75 || age > 91 {
			log.Printf("Got value outside expected age (%d)", age)
			c.Fail()
			continue
		}
		count++
	}
	c.Check(count, Equals, 5)
}
Example #7
0
func findFirstMatchingPolicy(value *oproto.Value, policies []*oproto.RetentionPolicyItem) *oproto.RetentionPolicyItem {
	now := openinstrument.NowMs()
	valueStartAge := now - value.Timestamp
	if value.EndTimestamp == 0 && value.Timestamp != 0 {
		value.EndTimestamp = value.Timestamp
	}
	valueEndAge := now - value.EndTimestamp
	for _, item := range policies {
		if len(item.Variable) == 0 {
			// No variables supplied, this matches everything
			return item
		}
		for _, i := range item.Variable {
			// Look for policies that match the variable age
			v := variable.NewFromProto(i)
			if v.TimestampInsideRange(valueStartAge) || v.TimestampInsideRange(valueEndAge) {
				return item
			}
		}
	}
	return nil
}
func (s *MySuite) TestValueStreamWriterMemoryLeak(c *C) {
	filename := filepath.Join(c.MkDir(), "protofile_testvar.dat")

	vs := &oproto.ValueStream{
		Variable: &oproto.StreamVariable{Name: "/test/bar"},
		Value:    []*oproto.Value{},
	}
	for i := 0; i < 10; i++ {
		vs.Value = append(vs.Value, &oproto.Value{Timestamp: uint64(openinstrument.NowMs()), DoubleValue: 1.1})
	}
	// Write a temporary file containing two value streams
	file, err := Write(filename)
	c.Assert(err, IsNil)
	defer file.Close()
	writer, done := file.ValueStreamWriter(10)

	wroteStreams := 0
	for j := 0; j < 1000; j++ {
		writer <- vs
		wroteStreams++
	}

	close(writer)
	<-done

	file, err = Read(filename)
	c.Assert(err, IsNil)
	defer file.Close()

	reader := file.ValueStreamReader(context.Background(), 10)
	readStreams := 0
	for range reader {
		readStreams++
	}

	c.Assert(readStreams, Equals, wroteStreams)
}
Example #9
0
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))
		}
	}
}
Example #10
0
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)
	}
}