Example #1
0
File: cli.go Project: goadapp/goad
func main() {
	var printVersion bool

	flag.StringVar(&url, "u", "", "URL to load test (required)")
	flag.StringVar(&method, "m", "GET", "HTTP method")
	flag.StringVar(&body, "b", "", "HTTP request body")
	flag.UintVar(&concurrency, "c", 10, "number of concurrent requests")
	flag.UintVar(&requests, "n", 1000, "number of total requests to make")
	flag.UintVar(&timeout, "t", 15, "request timeout in seconds")
	flag.StringVar(&regions, "r", "us-east-1,eu-west-1,ap-northeast-1", "AWS regions to run in (comma separated, no spaces)")
	flag.StringVar(&awsProfile, "p", "", "AWS named profile to use")
	flag.StringVar(&outputFile, "o", "", "Optional path to JSON file for result storage")
	flag.Var(&headers, "H", "List of headers")
	flag.BoolVar(&printVersion, "version", false, "print the current Goad version")
	flag.Parse()

	if printVersion {
		fmt.Println(version.Version)
		os.Exit(0)
	}

	if url == "" {
		flag.Usage()
		os.Exit(0)
	}

	test, testerr := goad.NewTest(&goad.TestConfig{
		URL:            url,
		Concurrency:    concurrency,
		TotalRequests:  requests,
		RequestTimeout: time.Duration(timeout) * time.Second,
		Regions:        strings.Split(regions, ","),
		Method:         method,
		Body:           body,
		Headers:        headers,
		AwsProfile:     awsProfile,
	})
	if testerr != nil {
		fmt.Println(testerr)
		os.Exit(1)
	}

	var finalResult queue.RegionsAggData
	defer printSummary(&finalResult)

	if outputFile != "" {
		defer saveJSONSummary(outputFile, &finalResult)
	}

	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM) // but interrupts from kbd are blocked by termbox

	start(test, &finalResult, sigChan)
}
Example #2
0
func serveResults(w http.ResponseWriter, r *http.Request) {
	if r.URL.Path != "/goad" {
		http.Error(w, "Not found", 404)
		return
	}
	if r.Method != "GET" {
		http.Error(w, "Method not allowed", 405)
		return
	}
	w.Header().Set("Content-Type", "application/json; charset=utf-8")

	url := r.URL.Query().Get("url")
	if len(url) == 0 {
		http.Error(w, "Missing URL", 400)
		return
	}

	// Commented out param handling, we have hard coded limits for the website testing
	//
	// concurrencyStr := r.URL.Query().Get("c")
	// concurrency, cerr := strconv.Atoi(concurrencyStr)
	// if cerr != nil {
	// 	http.Error(w, "Invalid concurrency", 400)
	// 	return
	// }
	//
	// totStr := r.URL.Query().Get("tot")
	// tot, toterr := strconv.Atoi(totStr)
	// if toterr != nil {
	// 	http.Error(w, "Invalid total", 400)
	// 	return
	// }
	//
	// timeoutStr := r.URL.Query().Get("timeout")
	// timeout, timeouterr := strconv.Atoi(timeoutStr)
	// if timeouterr != nil {
	// 	http.Error(w, "Invalid timeout", 400)
	// 	return
	// }

	c, err := upgrader.Upgrade(w, r, nil)
	if err != nil {
		log.Print("Websocket upgrade:", err)
		return
	}
	defer c.Close()

	config := goad.TestConfig{
		URL:            url,
		Concurrency:    5,
		TotalRequests:  1000,
		RequestTimeout: time.Duration(5 * time.Second),
		Regions:        []string{"us-east-1", "eu-west-1"},
		Method:         "GET",
	}

	test, testerr := goad.NewTest(&config)
	if testerr != nil {
		fmt.Println(testerr)
		return
	}
	resultChan := test.Start()

	for result := range resultChan {
		message, jsonerr := jsonFromRegionsAggData(result)
		if jsonerr != nil {
			log.Println(jsonerr)
			break
		}
		go readLoop(c)
		err = c.WriteMessage(websocket.TextMessage, []byte(message))
		if err != nil {
			log.Println("write:", err)
			break
		}
	}
}