// Replay the batch data from a single source
func (r *replayBatchSource) replayBatchFromData(data io.ReadCloser, batch BatchCollector, recTime bool) {
defer batch.Close()
defer data.Close()
in := bufio.NewScanner(data)
// Find relative times
start := time.Time{}
var diff time.Duration
zero := r.clck.Zero()
for in.Scan() {
var b models.Batch
err := json.Unmarshal(in.Bytes(), &b)
if err != nil {
r.allErrs <- err
return
}
if len(b.Points) == 0 {
// do nothing
continue
}
b.Group = models.TagsToGroupID(models.SortedKeys(b.Tags), b.Tags)
if start.IsZero() {
start = b.Points[0].Time
diff = zero.Sub(start)
}
// Add tags to all points
if len(b.Tags) > 0 {
for i := range b.Points {
if len(b.Points[i].Tags) == 0 {
b.Points[i].Tags = b.Tags
}
}
}
var lastTime time.Time
if !recTime {
for i := range b.Points {
b.Points[i].Time = b.Points[i].Time.Add(diff).UTC()
}
lastTime = b.Points[len(b.Points)-1].Time
} else {
lastTime = b.Points[len(b.Points)-1].Time.Add(diff).UTC()
}
r.clck.Until(lastTime)
b.TMax = b.Points[len(b.Points)-1].Time
batch.CollectBatch(b)
}
r.allErrs <- in.Err()
}
func (e *booleanPointEmitter) EmitBatch() models.Batch {
slice := e.emitter.Emit()
b := models.Batch{
Name: e.name,
TMax: e.time,
Group: e.group,
ByName: e.dimensions.ByName,
Tags: e.tags,
Points: make([]models.BatchPoint, len(slice)),
}
var t time.Time
for i, ap := range slice {
if e.pointTimes {
if ap.Time == influxql.ZeroTime {
t = e.time
} else {
t = time.Unix(0, ap.Time).UTC()
}
} else {
t = e.time
}
var tags models.Tags
if l := len(ap.Tags.KeyValues()); l > 0 {
// Merge batch and point specific tags
tags = make(models.Tags, len(e.tags)+l)
for k, v := range e.tags {
tags[k] = v
}
for k, v := range ap.Tags.KeyValues() {
tags[k] = v
}
} else {
tags = e.tags
}
b.Points[i] = models.BatchPoint{
Time: t,
Tags: tags,
Fields: map[string]interface{}{e.as: ap.Value},
}
if t.After(b.TMax) {
b.TMax = t
}
}
return b
}
// take the result of a reduce operation and convert it to a batch
func reduceResultToBatch(field string, value interface{}, tmax time.Time, usePointTimes bool) models.Batch {
b := models.Batch{}
b.TMax = tmax
switch v := value.(type) {
case tsdb.PositionPoints:
b.Points = make([]models.BatchPoint, len(v))
for i, pp := range v {
if usePointTimes {
b.Points[i].Time = time.Unix(pp.Time, 0).UTC()
} else {
b.Points[i].Time = tmax
}
b.Points[i].Fields = models.Fields{field: pp.Value}
b.Points[i].Fields[field] = pp.Value
b.Points[i].Tags = pp.Tags
}
case tsdb.PositionPoint:
b.Points = make([]models.BatchPoint, 1)
if usePointTimes {
b.Points[0].Time = time.Unix(v.Time, 0).UTC()
} else {
b.Points[0].Time = tmax
}
b.Points[0].Fields = models.Fields{field: v.Value}
b.Points[0].Fields[field] = v.Value
b.Points[0].Tags = v.Tags
case tsdb.InterfaceValues:
b.Points = make([]models.BatchPoint, len(v))
for i, p := range v {
b.Points[i].Time = tmax
b.Points[i].Fields = models.Fields{field: p}
}
default:
b.Points = make([]models.BatchPoint, 1)
b.Points[0].Time = tmax
b.Points[0].Fields = models.Fields{field: v}
}
return b
}