// Record a series of batch queries defined by a batch task
func (r *Service) doRecordBatch(rid uuid.UUID, t *kapacitor.Task, start, stop time.Time) error {
et, err := kapacitor.NewExecutingTask(r.TaskMaster.New(), t)
if err != nil {
return err
}
batches, err := et.BatchQueries(start, stop)
if err != nil {
return err
}
if r.InfluxDBService == nil {
return errors.New("InfluxDB not configured, cannot record batch query")
}
con, err := r.InfluxDBService.NewClient()
if err != nil {
return err
}
archive, err := r.newBatchArchive(rid)
if err != nil {
return err
}
for batchIdx, queries := range batches {
w, err := archive.Create(batchIdx)
if err != nil {
return err
}
for _, q := range queries {
query := client.Query{
Command: q,
}
resp, err := con.Query(query)
if err != nil {
return err
}
if resp.Err != nil {
return resp.Err
}
for _, res := range resp.Results {
batches, err := models.ResultToBatches(res)
if err != nil {
return err
}
for _, b := range batches {
kapacitor.WriteBatchForRecording(w, b)
}
}
}
}
return archive.Close()
}
func (s *Service) startRecordBatch(t *kapacitor.Task, start, stop time.Time) ([]<-chan models.Batch, <-chan error, error) {
// We do not open the task master so it does not need to be closed
et, err := kapacitor.NewExecutingTask(s.TaskMaster.New(""), t)
if err != nil {
return nil, nil, err
}
batches, err := et.BatchQueries(start, stop)
if err != nil {
return nil, nil, err
}
if s.InfluxDBService == nil {
return nil, nil, errors.New("InfluxDB not configured, cannot record batch query")
}
sources := make([]<-chan models.Batch, len(batches))
errors := make(chan error, len(batches))
for batchIndex, batchQueries := range batches {
source := make(chan models.Batch)
sources[batchIndex] = source
go func(cluster string, queries []*kapacitor.Query, groupByName bool) {
defer close(source)
// Connect to the cluster
cli, err := s.InfluxDBService.NewNamedClient(cluster)
if err != nil {
errors <- err
return
}
// Run queries
for _, q := range queries {
query := influxdb.Query{
Command: q.String(),
}
resp, err := cli.Query(query)
if err != nil {
errors <- err
return
}
for _, res := range resp.Results {
batches, err := models.ResultToBatches(res, groupByName)
if err != nil {
errors <- err
return
}
for _, b := range batches {
// Set stop time based off query bounds
if b.TMax.IsZero() || !q.IsGroupedByTime() {
b.TMax = q.StopTime()
}
source <- b
}
}
}
errors <- nil
}(batchQueries.Cluster, batchQueries.Queries, batchQueries.GroupByMeasurement)
}
errC := make(chan error, 1)
go func() {
for i := 0; i < cap(errors); i++ {
err := <-errors
if err != nil {
errC <- err
return
}
}
errC <- nil
}()
return sources, errC, nil
}
