Decouple Reporters from Attack function

This changeset breaks the API of Attack in order to decouple Reporters
and the Attack function. Attack now returns a slice with
non-deterministic order of Results which one can use on the calling code
with or without Reporters, hence making it much more useful on a library
usage setting.
These developments could be of interest to issue #11 which was closed in
the past.

README.md

@@ -97,17 +97,23 @@ import (
   vegeta "github.com/tsenart/vegeta/lib"
   "time"
   "os"
+  "fmt"
 )
 
 func main() {
   targets, _ := vegeta.NewTargets([]string{"GET http://localhost:9100/"})
   rate := uint64(100) // per second
   duration := 4 * time.Second
-  reporter := vegeta.NewTextReporter()
 
-  vegeta.Attack(targets, rate, duration, reporter)
+  results := vegeta.Attack(targets, rate, duration)
 
-  reporter.Report(os.Stdout)
+  totalTime := time.Duration(0)
+  for _, result := range results {
+    totalTime += result.Timing
+  }
+  meanTime := time.Duration(float64(totalTime) / float64(len(results)))
+
+  fmt.Printf("Average timing: %s", meanTime)
 }
 ```
 

lib/attack.go

@@ -9,20 +9,25 @@ import (
 
 // Attack hits the passed Targets (http.Requests) at the rate specified for
 // duration time and then waits for all the requests to come back.
-// The results of the attack are put into the rep Reporter.
-func Attack(targets Targets, rate uint64, duration time.Duration, rep Reporter) {
-	hits := make(chan *http.Request, rate*uint64((duration).Seconds()))
-	defer close(hits)
-	results := make(chan *Result, cap(hits))
-	defer close(results)
-	go drill(rate, hits, results) // Attack!
+// The results of the attack are put into a slice which is returned.
+func Attack(targets Targets, rate uint64, duration time.Duration) []Result {
+	total := rate * uint64(duration.Seconds())
+	hits := make(chan *http.Request, total)
+	res := make(chan Result, total)
+	results := make([]Result, total)
+	// Scatter
+	go drill(rate, hits, res)
 	for i := 0; i < cap(hits); i++ {
 		hits <- targets[i%len(targets)]
 	}
-	// Wait for all requests to finish
-	for i := 0; i < cap(results); i++ {
-		rep.add(<-results)
+	close(hits)
+	// Gather
+	for i := 0; i < cap(res); i++ {
+		results[i] = <-res
 	}
+	close(res)
+
+	return results
 }
 
 // Result represents the metrics we want out of an http.Response
@@ -37,7 +42,7 @@ type Result struct {
 
 // drill loops over the passed reqs channel and executes each request.
 // It is throttled to the rate specified.
-func drill(rate uint64, reqs chan *http.Request, res chan *Result) {
+func drill(rate uint64, reqs chan *http.Request, res chan Result) {
 	throttle := time.Tick(time.Duration(1e9 / rate))
 	for req := range reqs {
 		<-throttle
@@ -45,13 +50,13 @@ func drill(rate uint64, reqs chan *http.Request, res chan *Result) {
 	}
 }
 
-// hit executes the passed http.Request and puts a generated *result into res.
+// hit executes the passed http.Request and puts the result into results.
 // Both transport errors and unsucessfull requests (non {2xx,3xx}) are
-// considered errors which are set in the Response.
-func hit(req *http.Request, res chan *Result) {
+// considered errors.
+func hit(req *http.Request, res chan Result) {
 	began := time.Now()
 	r, err := http.DefaultClient.Do(req)
-	result := &Result{
+	result := Result{
 		Timestamp: began,
 		Timing:    time.Since(began),
 		BytesOut:  uint64(req.ContentLength),
@@ -63,6 +68,5 @@ func hit(req *http.Request, res chan *Result) {
 			result.Error = errors.New(string(body))
 		}
 	}
-
 	res <- result
 }

lib/attack_test.go

@@ -3,7 +3,6 @@ package vegeta
 import (
 	"net/http"
 	"net/http/httptest"
-	"os"
 	"sync/atomic"
 	"testing"
 	"time"
@@ -18,10 +17,8 @@ func TestAttackRate(t *testing.T) {
 	)
 	request, _ := http.NewRequest("GET", server.URL, nil)
 	rate := uint64(5000)
-	rep := NewTextReporter()
-	Attack(Targets{request}, rate, 1*time.Second, rep)
+	Attack(Targets{request}, rate, 1*time.Second)
 	if hits := atomic.LoadUint64(&hitCount); hits != rate {
-		rep.Report(os.Stdout)
 		t.Fatalf("Wrong number of hits: want %d, got %d\n", rate, hits)
 	}
 }

lib/reporter.go

@@ -7,5 +7,5 @@ import (
 // Reporter represents any reporter of the results of the test
 type Reporter interface {
 	Report(io.Writer) error
-	add(res *Result)
+	Add(res *Result)
 }

lib/text_reporter.go

@@ -69,8 +69,8 @@ func (r *TextReporter) Report(out io.Writer) error {
 	return w.Flush()
 }
 
-// add adds a response to be used in the report
+// Add adds a response to be used in the report
 // Order of arrival is not relevant for this reporter
-func (r *TextReporter) add(res *Result) {
+func (r *TextReporter) Add(res *Result) {
 	r.results = append(r.results, res)
 }

lib/timings_plot_reporter.go

@@ -20,8 +20,8 @@ func NewTimingsPlotReporter() *TimingsPlotReporter {
 	return &TimingsPlotReporter{results: list.New()}
 }
 
-// add inserts response to be used in the report, sorted by timestamp.
-func (r *TimingsPlotReporter) add(res *Result) {
+// Add inserts response to be used in the report, sorted by timestamp.
+func (r *TimingsPlotReporter) Add(res *Result) {
 	// Empty list
 	if r.results.Len() == 0 {
 		r.results.PushFront(res)

main.go

@@ -94,9 +94,10 @@ func run(rate uint64, duration time.Duration, targetsf, ordering, reporter, outp
 	}
 
 	log.Printf("Vegeta is attacking %d targets in %s order for %s...\n", len(targets), ordering, duration)
-	vegeta.Attack(targets, rate, duration, rep)
+	for _, result := range vegeta.Attack(targets, rate, duration) {
+		rep.Add(&result)
+	}
 	log.Println("Done!")
-
 	log.Printf("Writing report to '%s'...", output)
 	if err = rep.Report(out); err != nil {
 		return fmt.Errorf(errReportingPrefix+"%s", err)