func (s *MySuite) TestMultiply(c *C) {
for input := range s.store.Reader(context.Background(), variable.NewFromString("/test")) {
output := mutations.Multiply(2, input)
c.Assert(len(output.Value), Equals, len(input.Value))
checkValue(c, output.Value[0], 60*0, 20*1*2)
checkValue(c, output.Value[1], 60*1, 20*2*2)
checkValue(c, output.Value[2], 60*2, 20*3*2)
checkValue(c, output.Value[3], 60*3, 20*4*2)
checkValue(c, output.Value[4], 60*4, 20*5*2)
checkValue(c, output.Value[5], 60*5, 20*6*2)
checkValue(c, output.Value[6], 60*6, 20*7*2)
checkValue(c, output.Value[7], 60*7, 20*8*2)
checkValue(c, output.Value[8], 60*8, 20*9*2)
checkValue(c, output.Value[9], 60*9, 20*10*2)
checkValue(c, output.Value[10], 60*10, 20*11*2)
}
}
func (s *MySuite) TestDivide(c *C) {
for input := range s.store.Reader(context.Background(), variable.NewFromString("/test")) {
output := mutations.Multiply(1.0/2.0, input)
c.Assert(len(output.Value), Equals, len(input.Value))
checkValue(c, output.Value[0], 60*0, (20*1)/2.0)
checkValue(c, output.Value[1], 60*1, (20*2)/2.0)
checkValue(c, output.Value[2], 60*2, (20*3)/2.0)
checkValue(c, output.Value[3], 60*3, (20*4)/2.0)
checkValue(c, output.Value[4], 60*4, (20*5)/2.0)
checkValue(c, output.Value[5], 60*5, (20*6)/2.0)
checkValue(c, output.Value[6], 60*6, (20*7)/2.0)
checkValue(c, output.Value[7], 60*7, (20*8)/2.0)
checkValue(c, output.Value[8], 60*8, (20*9)/2.0)
checkValue(c, output.Value[9], 60*9, (20*10)/2.0)
checkValue(c, output.Value[10], 60*10, (20*11)/2.0)
}
}
func RunQuery(ctx context.Context, query *oproto.Query, store datastore.ReadableStore) (chan *oproto.ValueStream, error) {
log.Printf("Running query %v", query)
output := make(chan *oproto.ValueStream, 100)
go func() {
defer close(output)
for _, v := range query.Variable {
log.Printf("Returning variable %s", variable.ProtoToString(v))
for stream := range store.Reader(ctx, variable.NewFromProto(v)) {
if stream != nil {
outputStream := &oproto.ValueStream{Variable: stream.Variable}
stv := variable.NewFromProto(stream.Variable)
for _, v := range stream.Value {
if stv.TimestampInsideRange(v.Timestamp) {
outputStream.Value = append(outputStream.Value, v)
}
}
output <- outputStream
}
}
}
for _, child := range query.Aggregation {
log.Printf("Running child aggregation")
input := []*oproto.ValueStream{}
for _, q := range child.Query {
o, err := RunQuery(ctx, q, store)
if err != nil {
return
}
for stream := range o {
input = append(input, stream)
}
}
log.Printf("Child aggregation returned output")
o := []*oproto.ValueStream{}
switch child.Type {
case oproto.StreamAggregation_NONE:
o = input
case oproto.StreamAggregation_MEAN:
o = aggregations.Mean(child.Label, input)
case oproto.StreamAggregation_MAX:
o = aggregations.Max(child.Label, input)
case oproto.StreamAggregation_MIN:
o = aggregations.Min(child.Label, input)
case oproto.StreamAggregation_MEDIAN:
o = aggregations.Median(child.Label, input)
case oproto.StreamAggregation_SUM:
o = aggregations.Sum(child.Label, input)
case oproto.StreamAggregation_STDDEV:
o = aggregations.StdDev(child.Label, input)
case oproto.StreamAggregation_PERCENTILE:
o = aggregations.Percentile(child.Label, child.Param, input)
}
for _, stream := range o {
//log.Println(openinstrument.ProtoText(stream))
output <- stream
}
}
for _, child := range query.Mutation {
log.Printf("Running child mutation")
input, err := RunQuery(ctx, child.Query, store)
if err != nil {
log.Printf("Error in child mutation: %s", err)
return
}
for stream := range input {
var outStream *oproto.ValueStream
switch child.Type {
case oproto.StreamMutation_MEAN:
outStream = mutations.Mean(stream)
case oproto.StreamMutation_INTERPOLATE:
outStream = mutations.Interpolate(uint64(child.Param), stream)
case oproto.StreamMutation_MIN:
outStream = mutations.Min(uint64(child.Param), stream)
case oproto.StreamMutation_MAX:
outStream = mutations.Max(uint64(child.Param), stream)
case oproto.StreamMutation_FIRST:
outStream = mutations.First(uint64(child.Param), stream)
case oproto.StreamMutation_LAST:
outStream = mutations.Last(uint64(child.Param), stream)
case oproto.StreamMutation_RATE:
outStream = mutations.Rate(stream)
case oproto.StreamMutation_ROOT:
outStream = mutations.Root(child.Param, stream)
case oproto.StreamMutation_POWER:
outStream = mutations.Power(child.Param, stream)
case oproto.StreamMutation_ADD:
outStream = mutations.Add(child.Param, stream)
case oproto.StreamMutation_MULTIPLY:
outStream = mutations.Multiply(child.Param, stream)
case oproto.StreamMutation_RATE_SIGNED:
outStream = mutations.SignedRate(stream)
case oproto.StreamMutation_MOVING_AVERAGE:
outStream = mutations.MovingAverage(uint64(child.Param), stream)
}
if outStream == nil {
log.Printf("No stream returned from mutation")
continue
}
outStream.Variable = stream.Variable
output <- outStream
}
}
}()
return output, nil
}