first commit

Author: myzhan

.gitignore

@@ -0,0 +1,25 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
+*.test
+*.prof
+*.pyc

LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 myzhan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,75 @@
+# Boomer
+
+## Links
+
+* Website: <a href="http://locust.io">locust.io</a>
+* Documentation: <a href="http://docs.locust.io">docs.locust.io</a>
+
+## Description
+
+Boomer is a locust slave runner written in golang. Just write your test scenarios in golang functions, and tell Boomer to run them.
+Boomer will report to the locust master automatically, and your test result will be displayed on the master's web UI.
+
+
+## Install
+```bash
+go get github.com/myzhan/boomer
+```
+
+
+## Sample(main.go)
+```go
+package main
+
+
+import "github.com/myzhan/boomer"
+import "time"
+
+
+func foo(){
+	time.Sleep(100 * time.Millisecond)
+	/*
+    Report your test result as a failure, if you write it in python, it will looks like this
+    events.request_success.fire(request_type="http", name="foo", response_time=100.0, response_length=10)
+    */
+    boomer.Events.Publish("request_success", "foo", "http", 100.0, int64(10))
+}
+
+
+func bar(){
+	time.Sleep(100 * time.Millisecond)
+	/*
+    Report your test result as a failure, if you write it in python, it will looks like this
+    events.request_failure.fire(request_type="udp", name="bar", response_time=100.0, exception=Exception("udp error"))
+    */
+    boomer.Events.Publish("request_failure", "bar", "udp", 100.0, "udp error")
+}
+
+
+func main(){
+
+	task1 := &boomer.Task{
+		Weight: 10,
+		Fn: foo,
+	}
+
+	task2 := &boomer.Task{
+		Weight: 20,
+		Fn: bar,
+	}
+
+
+	boomer.Run(task1, task2)
+
+}
+```
+
+## Usage
+```bash
+locust -f dummy.py --master --master-bind-host=127.0.0.1 --master-bind-port=5557
+go run main.go --master-host=127.0.0.1 --master-port=5557
+```
+
+## License
+
+Open source licensed under the MIT license (see _LICENSE_ file for details).

boomer.go

@@ -0,0 +1,47 @@
+package boomer
+
+import (
+	"flag"
+	"os"
+	"os/signal"
+	"syscall"
+	"log"
+	"runtime"
+)
+
+
+func Run(tasks ... *Task) {
+
+
+	// support go version below 1.5
+	runtime.GOMAXPROCS(runtime.NumCPU())
+
+	masterHost := flag.String("master-host", "127.0.0.1", "Host or IP address of locust master for distributed load testing. Defaults to 127.0.0.1.")
+	masterPort := flag.Int("master-port", 5557, "The port to connect to that is used by the locust master for distributed load testing. Defaults to 5557.")
+
+	flag.Parse()
+
+	client := NewSocketClient(*masterHost, *masterPort)
+
+	runner := &Runner{
+		Tasks: tasks,
+		Client: client,
+		NodeId: GetNodeId(),
+	}
+
+	Events.Subscribe("boomer:report_to_master", runner.onReportToMaster)
+	Events.Subscribe("boomer:quit", runner.onQuiting)
+
+	runner.GetReady()
+
+	c := make(chan os.Signal)
+	signal.Notify(c, syscall.SIGINT)
+
+	<- c
+	Events.Publish("boomer:quit")
+
+	// wait for quit message is sent to master
+	<- DisconnectedFromServer
+	log.Println("shut down")
+
+}

client.go

@@ -0,0 +1,96 @@
+package boomer
+
+import (
+	"net"
+	"log"
+	"encoding/binary"
+	"bytes"
+	"fmt"
+)
+
+
+type Client interface {
+	recv()
+	send()
+}
+
+
+var FromServer = make(chan *Message, 100)
+var ToServer = make(chan *Message, 100)
+var DisconnectedFromServer = make(chan bool)
+
+
+type SocketClient struct {
+
+	conn *net.TCPConn
+}
+
+
+func NewSocketClient(masterHost string, masterPort int) *SocketClient{
+	serverAddr := fmt.Sprintf("%s:%d", masterHost, masterPort)
+	tcpAddr, _ := net.ResolveTCPAddr("tcp", serverAddr)
+	conn, err := net.DialTCP("tcp", nil, tcpAddr)
+	if err != nil {
+		log.Fatalf("Failed to connect to the Locust master: %s %s", serverAddr, err)
+	}
+	conn.SetNoDelay(true)
+	newClient := &SocketClient{
+		conn: conn,
+	}
+	go newClient.recv()
+	go newClient.send()
+	return newClient
+}
+
+
+func (this *SocketClient) recvBytes(length int) ([]byte) {
+	buf := make([]byte, length)
+	for length > 0 {
+		n, err := this.conn.Read(buf)
+		if err != nil {
+			log.Fatal(err)
+		}
+		length = length - n
+	}
+	return buf
+}
+
+
+func (this *SocketClient) recv() {
+	for {
+		h := this.recvBytes(4)
+		msgLength := binary.BigEndian.Uint32(h)
+		msg := this.recvBytes(int(msgLength))
+		msgFromMaster := NewMessageFromBytes(msg)
+		FromServer <- msgFromMaster
+	}
+
+}
+
+
+func (this *SocketClient) send() {
+	for {
+		select {
+		case msg := <- ToServer:
+			this.sendMessage(msg)
+			if msg.Type == "quit"{
+				DisconnectedFromServer <- true
+			}
+		}
+	}
+}
+
+
+func (this *SocketClient) sendMessage(msg *Message){
+	packed := msg.Serialize()
+	buf := new(bytes.Buffer)
+	/*
+	use a fixed length header that indicates the length of the body
+	-----------------
+	| length | body |
+	-----------------
+	 */
+	binary.Write(buf, binary.BigEndian, int32(len(packed)))
+	buf.Write(packed)
+	this.conn.Write(buf.Bytes())
+}

dummy.py

@@ -0,0 +1,11 @@
+# coding: utf8
+
+from locust import Locust, TaskSet, task
+
+class MyTaskSet(TaskSet):
+    @task(20)
+    def hello(self):
+        pass
+
+class Dummy(Locust):
+    task_set = MyTaskSet

events.go

@@ -0,0 +1,35 @@
+package boomer
+
+
+import (
+	"github.com/asaskevich/EventBus"
+)
+
+
+var Events = EventBus.New()
+
+
+func requestSuccessHandler(requestType string, name string, responseTime float64, responseLength int64) {
+	RequestSuccessChannel <- &RequestSuccess{
+		requestType: requestType,
+		name: name,
+		responseTime: responseTime,
+		responseLength: responseLength,
+	}
+}
+
+
+func requestFailureHandler(requestType string, name string, responseTime float64, exception string) {
+	RequestFailureChannel <- &RequestFailure{
+		requestType: requestType,
+		name: name,
+		responseTime: responseTime,
+		error: exception,
+	}
+}
+
+
+func init(){
+	Events.Subscribe("request_success", requestSuccessHandler)
+	Events.Subscribe("request_failure", requestFailureHandler)
+}

message.go

@@ -0,0 +1,42 @@
+package boomer
+
+
+import (
+	"github.com/ugorji/go/codec"
+	"log"
+)
+
+
+var (
+	mh codec.MsgpackHandle
+)
+
+
+type Message struct {
+	Type   string	`codec: "type"`
+	Data   map[string] interface{}	`codec: "data"`
+	NodeId string	`codec: "node_id"`
+}
+
+
+func (this *Message) Serialize() (out []byte){
+	mh.StructToArray = true
+	enc := codec.NewEncoderBytes(&out, &mh)
+	err := enc.Encode(this)
+	if err != nil {
+		log.Fatal("[msgpack] encode fail")
+	}
+	return
+}
+
+
+func NewMessageFromBytes(raw []byte) (*Message) {
+	mh.StructToArray = true
+	dec := codec.NewDecoderBytes(raw, &mh)
+	var newMsg = &Message{}
+	err := dec.Decode(newMsg)
+	if err != nil {
+		log.Fatal("[msgpack] decode fail")
+	}
+	return newMsg
+}