golang web benchmark (by: HaoLiang Zhang)

web_benchmark.go

package main

import (
        "flag"
        "fmt"
        "io/ioutil"
        "math/rand"
        "net"
        "net/http"
        "time"
)

func substr(str string, start, length int) string {
        rs := []rune(str)
        rl := len(rs)
        end := 0
        if start < 0 {
                start = rl - 1 + start
        }
        end = start + length
        if start > end {
                start, end = end, start
        }
        if start < 0 {
                start = 0
        }
        if start > rl {
                start = rl
        }
        if end < 0 {
                end = 0
        }
        if end > rl {
                end = rl
        }
        return string(rs[start:end])
}

func web(i int, url string, timeout int, connect_sucess_number_channel chan int, connect_timeout_number_channel chan int, connect_number_channel chan int, connect_command_channel chan int) {
        connect_process := i
        //           connect_number :=0
        connect_sucess_number := 0
        connect_timeout_number := 0
loop:
        for {
                select {
                case <-connect_command_channel:
                        connect_timeout_number_channel <- connect_timeout_number
                        connect_sucess_number_channel <- connect_sucess_number
                        connect_number_channel <- connect_sucess_number + connect_timeout_number
                        break loop
                default:
                        r := rand.New(rand.NewSource(time.Now().UnixNano()))
                        n := (r.Intn(10) + 1) * 1000000
                        time.Sleep(time.Duration(n))
                        client := &http.Client{
                                Transport: &http.Transport{
                                        Dial: func(netw, addr string) (net.Conn, error) {
                                                deadline := time.Now().Add(time.Duration(timeout) * 1000000000)
                                                c, err := net.DialTimeout(netw, addr, time.Duration(timeout)*1000000000)
                                                if err != nil {
                                                        return nil, err
                                                }
                                                c.SetDeadline(deadline)
                                                return c, nil
                                        },
                                },
                        }
                        reqest, _ := http.NewRequest("GET", url, nil)
                        now := time.Now()
                        log_id := time.Now().UnixNano()
                        t := time.Unix(time.Now().Unix(), 0).Format("2006-01-02 15:04:05")
                        log_time := substr(t, 0, 19)

                        response, err := client.Do(reqest)
                        if err != nil {

                                end_time := time.Now()
                                connect_timeout_number++
                                var dur_time time.Duration = end_time.Sub(now)
                                fmt.Println("屌丝|", connect_process, "|", connect_timeout_number, "|", log_id, "|", url, "|timeout|", log_time, "|", dur_time, "|timeout")
                                continue
                        }
                        end_time := time.Now()
                        var dur_time time.Duration = end_time.Sub(now)
                        body, _ := ioutil.ReadAll(response.Body)
                        len := len(body)
                        connect_sucess_number++
                        fmt.Println("屌丝|", connect_process, "|", connect_sucess_number, "|", log_id, "|", url, "|", response.StatusCode, "|", log_time, "|", dur_time, "|", len)
                        response.Body.Close()

                }
        }
}

func main() {
        connect_sucess_number_channel := make(chan int, 10)
        connect_timeout_number_channel := make(chan int, 10)
        connect_number_channel := make(chan int, 10)
        connect_command_channel := make(chan int, 10)
        url := flag.String("url", "http://www.sohu.com", "Input your username")
        runtime := flag.Int("runtime", 2, "run time")
        c := flag.Int("client", 3, "client number")
        timeout := flag.Int("timeout", 2, "net time out")
        flag.Parse()
        for i := 0; i < *c; i++ {
                go web(i, *url, *timeout, connect_sucess_number_channel, connect_timeout_number_channel, connect_number_channel, connect_command_channel)
        }
        time.Sleep(time.Duration(*runtime) * 1000000000)
        fmt.Println(" begin  stop all agent ")
        for i := 0; i < *c; i++ {
                connect_command_channel <- -1
                fmt.Println(" begin  stop  agent ", i)
        }
        time.Sleep(1e9)
        fmt.Println(" stop all agent ")
        close(connect_sucess_number_channel)
        close(connect_timeout_number_channel)
        close(connect_number_channel)
        close(connect_command_channel)
        connect_sucess_number_total := 0
        for i := range connect_sucess_number_channel {
                connect_sucess_number_total += i

        }
        fmt.Println("success number is  total is", connect_sucess_number_total)

        connect_timeout_number_total := 0
        for i := range connect_timeout_number_channel {
                connect_timeout_number_total += i
        }
        fmt.Println("timeout number is  total is", connect_timeout_number_total)

        connect_number_total := 0
        for i := range connect_number_channel {
                connect_number_total += i
        }
        fmt.Println(" number is  total is", connect_number_total)

}