Example #1
0
func (sg *SpdyGun) Ping() {
	if sg.client == nil {
		return
	}
	pingStart := time.Now()

	pinged, err := sg.client.Ping(time.Second * 15)
	if err != nil {
		log.Printf("client: ping: %s\n", err)
	}
	if !pinged {
		log.Printf("client: ping: timed out\n")
	}
	ss := aggregate.AcquireSample(float64(pingStart.UnixNano())/1e9, "PING")
	ss.RT = int(time.Since(pingStart).Seconds() * 1e6)

	if err == nil && pinged {
		ss.ProtoCode = 200
	} else {
		ss.Err = err
		ss.ProtoCode = 500
	}
	sg.results <- ss
	if err != nil {
		sg.Connect()
	}
}
Example #2
0
func (sg *SpdyGun) Connect() error {
	// FIXME: rewrite connection logic, it isn't thread safe right now.
	start := time.Now()
	ss := aggregate.AcquireSample(float64(start.UnixNano())/1e9, "CONNECT")
	defer func() {
		ss.RT = int(time.Since(start).Seconds() * 1e6)
		sg.results <- ss
	}()
	config := tls.Config{
		InsecureSkipVerify: true,
		NextProtos:         []string{"spdy/3.1"},
	}
	conn, err := tls.Dial("tcp", sg.target, &config)
	if err != nil {
		ss.Err = err
		ss.NetCode = 999
		return err
	}
	client, err := spdy.NewClientConn(conn)
	if err != nil {
		ss.Err = err
		ss.NetCode = 999
		return err
	} else {
		ss.ProtoCode = 200
	}
	if sg.client != nil {
		sg.Close()
	}
	sg.client = client

	return nil
}
Example #3
0
// Shoot to target, this method is not thread safe
func (hg *HttpGun) Shoot(ctx context.Context, a ammo.Ammo) error {

	if hg.client == nil {
		hg.Connect()
	}
	start := time.Now()
	ss := aggregate.AcquireSample(float64(start.UnixNano())/1e9, "REQUEST")
	defer func() {
		ss.RT = int(time.Since(start).Seconds() * 1e6)
		hg.results <- ss
	}()
	// now send the request to obtain a http response
	ha, ok := a.(*ammo.Http)
	if !ok {
		panic(fmt.Sprintf("Got '%T' instead of 'HttpAmmo'", a))
	}
	if ha.Tag != "" {
		ss.Tag += "|" + ha.Tag
	}
	var uri string
	if hg.ssl {
		uri = "https://" + ha.Host + ha.Uri
	} else {
		uri = "http://" + ha.Host + ha.Uri
	}
	req, err := http.NewRequest(ha.Method, uri, nil)
	if err != nil {
		log.Printf("Error making HTTP request: %s\n", err)
		ss.Err = err
		ss.NetCode = 999
		return err
	}
	for k, v := range ha.Headers {
		req.Header.Set(k, v)
	}
	req.URL.Host = hg.target
	res, err := hg.client.Do(req)
	if err != nil {
		log.Printf("Error performing a request: %s\n", err)
		ss.Err = err
		ss.NetCode = 999
		return err
	}
	defer res.Body.Close()
	_, err = io.Copy(ioutil.Discard, res.Body)
	if err != nil {
		log.Printf("Error reading response body: %s\n", err)
		ss.Err = err
		ss.NetCode = 999
		return err
	}

	// TODO: make this an optional verbose answ_log output
	//data := make([]byte, int(res.ContentLength))
	// _, err = res.Body.(io.Reader).Read(data)
	// fmt.Println(string(data))
	ss.ProtoCode = res.StatusCode
	return nil
}
Example #4
0
func (l *LogGun) Shoot(ctx context.Context, a ammo.Ammo) error {
	log.Println("Log message: ", a.(*ammo.Log).Message)
	l.results <- aggregate.AcquireSample(float64(time.Now().UnixNano())/1e9, "REQUEST")
	return nil
}