// collect a point from a given parent.
// emit the oldest set if we have collected enough data.
func (g *group) collect(i int, p models.PointInterface) {
t := p.PointTime().Round(g.j.j.Tolerance)
if t.Before(g.oldestTime) || g.oldestTime.IsZero() {
g.oldestTime = t
}
set := g.sets[t]
if set == nil {
set = newJoinset(g.j.j.StreamName, g.j.fill, g.j.fillValue, g.j.j.Names, g.j.j.Tolerance, t, g.j.logger)
g.sets[t] = set
}
set.Add(i, p)
// Update head
g.head[i] = t
// Check if all parents have been read past the oldestTime.
// If so we can emit the set.
emit := true
for _, t := range g.head {
if !t.After(g.oldestTime) {
// Still posible to get more data
// need to wait for more points
emit = false
break
}
}
if emit {
g.emit()
}
}
// collect a point from a given parent.
// emit the oldest set if we have collected enough data.
func (g *group) collect(i int, p models.PointInterface) error {
t := p.PointTime().Round(g.j.j.Tolerance)
if t.Before(g.oldestTime) || g.oldestTime.IsZero() {
g.oldestTime = t
}
var set *joinset
sets := g.sets[t]
if len(sets) == 0 {
set = newJoinset(
g.j.j.StreamName,
g.j.fill,
g.j.fillValue,
g.j.j.Names,
g.j.j.Delimiter,
g.j.j.Tolerance,
t,
g.j.logger,
)
sets = append(sets, set)
g.sets[t] = sets
}
for j := 0; j < len(sets); j++ {
if !sets[j].Has(i) {
set = sets[j]
break
}
}
if set == nil {
set = newJoinset(
g.j.j.StreamName,
g.j.fill,
g.j.fillValue,
g.j.j.Names,
g.j.j.Delimiter,
g.j.j.Tolerance,
t,
g.j.logger,
)
sets = append(sets, set)
g.sets[t] = sets
}
set.Set(i, p)
// Update head
g.head[i] = t
onlyReadySets := false
for _, t := range g.head {
if !t.After(g.oldestTime) {
onlyReadySets = true
break
}
}
err := g.emit(onlyReadySets)
if err != nil {
return err
}
return nil
}
// safely get the group for the point or create one if it doesn't exist.
func (j *JoinNode) getGroup(p models.PointInterface) *group {
group := j.groups[p.PointGroup()]
if group == nil {
group = newGroup(len(j.ins), j)
j.groups[p.PointGroup()] = group
j.runningGroups.Add(1)
go group.run()
}
return group
}
// safely get the group for the point or create one if it doesn't exist.
func (j *JoinNode) getGroup(p models.PointInterface) *group {
j.mu.Lock()
defer j.mu.Unlock()
group := j.groups[p.PointGroup()]
if group == nil {
group = newGroup(len(j.ins), j)
j.groups[p.PointGroup()] = group
j.runningGroups.Add(1)
j.logger.Println("D! group started ")
go group.run()
}
return group
}
// safely get the group for the point or create one if it doesn't exist.
func (j *JoinNode) getGroup(p models.PointInterface, groupErrs chan<- error) *group {
group := j.groups[p.PointGroup()]
if group == nil {
group = newGroup(len(j.ins), j)
j.groups[p.PointGroup()] = group
j.runningGroups.Add(1)
go func() {
err := group.run()
if err != nil {
j.logger.Println("E! join group error:", err)
select {
case groupErrs <- err:
default:
}
}
}()
}
return group
}
// Increment the ollected count of the group for this edge.
func (e *Edge) incCollected(p models.PointInterface) {
e.groupMu.Lock()
defer e.groupMu.Unlock()
if stats, ok := e.groupStats[p.PointGroup()]; ok {
stats.collected += 1
} else {
stats = &edgeStat{
collected: 1,
tags: p.PointTags(),
dims: p.PointDimensions(),
}
e.groupStats[p.PointGroup()] = stats
}
}
