// Helper test function for streamer
func testStreamer(
t *testing.T,
name,
script string,
) (
clock.Setter,
*kapacitor.ExecutingTask,
<-chan error,
*kapacitor.TaskMaster,
) {
if testing.Verbose() {
wlog.SetLevel(wlog.DEBUG)
} else {
wlog.SetLevel(wlog.OFF)
}
//Create the task
task, err := kapacitor.NewStreamer(name, script, dbrps)
if err != nil {
t.Fatal(err)
}
// Load test data
dir, err := os.Getwd()
if err != nil {
t.Fatal(err)
}
data, err := os.Open(path.Join(dir, "data", name+".srpl"))
if err != nil {
t.Fatal(err)
}
// Use 1971 so that we don't get true negatives on Epoch 0 collisions
c := clock.New(time.Date(1971, 1, 1, 0, 0, 0, 0, time.UTC))
r := kapacitor.NewReplay(c)
// Create a new execution env
tm := kapacitor.NewTaskMaster(logService)
tm.HTTPDService = httpService
tm.Open()
//Start the task
et, err := tm.StartTask(task)
if err != nil {
t.Fatal(err)
}
// Replay test data to executor
stream, err := tm.Stream(name)
if err != nil {
t.Fatal(err)
}
replayErr := r.ReplayStream(data, stream, false, "s")
t.Log(string(et.Task.Dot()))
return r.Setter, et, replayErr, tm
}
// Helper test function for batcher
func testBatcher(t *testing.T, name, script string) (clock.Setter, *kapacitor.ExecutingTask, <-chan error, *kapacitor.TaskMaster) {
if testing.Verbose() {
wlog.SetLevel(wlog.DEBUG)
} else {
wlog.SetLevel(wlog.OFF)
}
// Create a new execution env
tm := kapacitor.NewTaskMaster(logService)
tm.HTTPDService = httpService
tm.TaskStore = taskStore{}
tm.Open()
scope := tm.CreateTICKScope()
// Create task
task, err := kapacitor.NewTask(name, script, kapacitor.BatchTask, dbrps, 0, scope)
if err != nil {
t.Fatal(err)
}
// Load test data
var allData []io.ReadCloser
var data io.ReadCloser
for i := 0; err == nil; {
f := fmt.Sprintf("%s.%d.brpl", name, i)
data, err = os.Open(path.Join("data", f))
if err == nil {
allData = append(allData, data)
i++
}
}
if len(allData) == 0 {
t.Fatal("could not find any data files for", name)
}
// Use 1971 so that we don't get true negatives on Epoch 0 collisions
c := clock.New(time.Date(1971, 1, 1, 0, 0, 0, 0, time.UTC))
r := kapacitor.NewReplay(c)
//Start the task
et, err := tm.StartTask(task)
if err != nil {
t.Fatal(err)
}
// Replay test data to executor
batches := tm.BatchCollectors(name)
replayErr := r.ReplayBatch(allData, batches, false)
t.Log(string(et.Task.Dot()))
return r.Setter, et, replayErr, tm
}
func (r *Service) handleReplay(w http.ResponseWriter, req *http.Request) {
name := req.URL.Query().Get("name")
id := req.URL.Query().Get("id")
clockTyp := req.URL.Query().Get("clock")
recTimeStr := req.URL.Query().Get("rec-time")
var recTime bool
if recTimeStr != "" {
var err error
recTime, err = strconv.ParseBool(recTimeStr)
if err != nil {
httpd.HttpError(w, err.Error(), true, http.StatusBadRequest)
return
}
}
t, err := r.TaskStore.Load(name)
if err != nil {
httpd.HttpError(w, "task load: "+err.Error(), true, http.StatusNotFound)
return
}
var clk clock.Clock
switch clockTyp {
case "", "wall":
clk = clock.Wall()
case "fast":
clk = clock.Fast()
}
// Create new isolated task master
tm := r.TaskMaster.New()
tm.Open()
defer tm.Close()
et, err := tm.StartTask(t)
if err != nil {
httpd.HttpError(w, "task start: "+err.Error(), true, http.StatusBadRequest)
return
}
replay := kapacitor.NewReplay(clk)
var replayC <-chan error
switch t.Type {
case kapacitor.StreamTask:
f, err := r.FindStreamRecording(id)
if err != nil {
httpd.HttpError(w, "replay find: "+err.Error(), true, http.StatusNotFound)
return
}
stream, err := tm.Stream(id)
if err != nil {
httpd.HttpError(w, "stream start: "+err.Error(), true, http.StatusInternalServerError)
return
}
replayC = replay.ReplayStream(f, stream, recTime, precision)
case kapacitor.BatchTask:
fs, err := r.FindBatchRecording(id)
if err != nil {
httpd.HttpError(w, "replay find: "+err.Error(), true, http.StatusNotFound)
return
}
batches := tm.BatchCollectors(name)
replayC = replay.ReplayBatch(fs, batches, recTime)
}
// Check for error on replay
err = <-replayC
if err != nil {
httpd.HttpError(w, "replay: "+err.Error(), true, http.StatusInternalServerError)
return
}
// Drain tm so the task can finish
tm.Drain()
// Check for error on task
err = et.Err()
if err != nil {
httpd.HttpError(w, "task run: "+err.Error(), true, http.StatusInternalServerError)
return
}
// Call close explicity to check for error
err = tm.Close()
if err != nil {
httpd.HttpError(w, "closing: "+err.Error(), true, http.StatusInternalServerError)
return
}
}
