FREE SHIPPING for all new email subscribers!{{email}}
96 |
--------------------------------------------------------------------------------
/httputils/test_data/test_basic.html:
--------------------------------------------------------------------------------
1 | //Scripts
2 | //False Match
3 |
4 | //Not correct
5 |
6 | //Spaces and false match
7 |
13 | //correct script
14 |
15 |
16 | //STYLES
17 |
18 |
19 |
20 |
21 |
22 |
23 |
24 | //IMG and background image
25 |
26 |
27 |
30 |
34 |
38 |
42 |
46 |
50 |
54 |
55 |
--------------------------------------------------------------------------------
/perf/perf.go:
--------------------------------------------------------------------------------
1 | package perf
2 |
3 | import (
4 | "encoding/json"
5 | "fmt"
6 | "log"
7 | "net/http"
8 | "strconv"
9 | "time"
10 |
11 | "github.com/gnulnx/color"
12 | "github.com/gnulnx/goperf/request"
13 | )
14 |
15 | type Init struct {
16 | URL string
17 | Threads int
18 | Seconds int
19 | Iterations int
20 | Output int
21 | Index int // Also the channel number
22 | Verbose bool
23 | Results *request.IterateReqRespAll
24 | Cookies string
25 | Headers string
26 | UserAgent string
27 | }
28 |
29 | func (input *Init) Basic() request.IterateReqRespAll {
30 | // Create slice of channels to hold results
31 | // Fire off anonymous go routine using newly created channel
32 | chanslice := []chan request.IterateReqRespAll{}
33 | for i := 0; i < input.Threads; i++ {
34 | chanslice = append(chanslice, make(chan request.IterateReqRespAll))
35 | go func(c chan request.IterateReqRespAll) {
36 |
37 | // Make an initial GET request to get and set cookies so we can accurately simulate a user.
38 | // This effectivly sets up a user session. If this is commented out
39 | // then each request will simulate a new user.
40 | // TODO This should be a parameter the user can set.
41 | resp1, _ := http.Get(input.URL)
42 | if resp1 == nil {
43 | fmt.Println("Error connecting to url: ", input.URL)
44 | return
45 | }
46 | if len(resp1.Header["Set-Cookie"]) > 0 {
47 | input.Cookies = resp1.Header["Set-Cookie"][0]
48 | }
49 | // TODO Just pass the Input in
50 | c <- iterateRequest(input)
51 | }(chanslice[i])
52 | //time.Sleep(time.Duration(1000))
53 | }
54 |
55 | // Wait on all the channels
56 | results := []request.IterateReqRespAll{}
57 | for _, ch := range chanslice {
58 | results = append(results, <-ch)
59 | }
60 |
61 | input.Results = request.Combine(results)
62 | return *input.Results
63 |
64 | }
65 |
66 | func iterateRequest(input *Init) request.IterateReqRespAll {
67 | /*
68 | Continuously fetch 'url' for 'sec' second and return the results.
69 | */
70 | url := input.URL
71 | sec := input.Seconds
72 | cookies := input.Cookies
73 | headers := input.Headers
74 | useragent := input.UserAgent
75 | start := time.Now()
76 | maxTime := time.Duration(sec) * time.Second
77 | elapsedTime := maxTime
78 |
79 | resp := request.IterateReqResp{
80 | URL: url,
81 | }
82 | jsMap := map[string]*request.IterateReqResp{}
83 | cssMap := map[string]*request.IterateReqResp{}
84 | imgMap := map[string]*request.IterateReqResp{}
85 |
86 | var totalRespTimes int64 = 0
87 | var totalLinearRespTimes int64 = 0
88 | var count int64 = 0 // TODO for loop counter instead???
89 | for {
90 | //Fetch the url and all the js, css, and img assets
91 | fetchAllResp := request.FetchAll(request.FetchInput{
92 | BaseURL: url,
93 | Retdat: false,
94 | Cookies: cookies,
95 | Headers: headers,
96 | UserAgent: useragent,
97 | })
98 |
99 | // Set base resp properties
100 | resp.Status = append(resp.Status, fetchAllResp.BaseURL.Status)
101 | resp.RespTimes = append(resp.RespTimes, fetchAllResp.BaseURL.Time)
102 | resp.Bytes = fetchAllResp.TotalBytes
103 |
104 | totalRespTimes += int64(fetchAllResp.TotalTime)
105 | totalLinearRespTimes += int64(fetchAllResp.TotalLinearTime)
106 |
107 | gatherAllStats(fetchAllResp, jsMap, cssMap, imgMap)
108 |
109 | elapsedTime = time.Now().Sub(start)
110 | count += 1
111 | if elapsedTime > maxTime {
112 | break
113 | }
114 | }
115 |
116 | avgTotalRespTimes := time.Duration(totalRespTimes / count)
117 | avgTotalLinearRespTimes := time.Duration(totalLinearRespTimes / count)
118 |
119 | // TODO Clean this up. Perhaps some benchmark tests
120 | // to see if its faster as go routines or not
121 | jsResps := []request.IterateReqResp{}
122 | for _, val := range jsMap {
123 | jsResps = append(jsResps, *val)
124 | }
125 |
126 | cssResps := []request.IterateReqResp{}
127 | for _, val := range cssMap {
128 | cssResps = append(cssResps, *val)
129 | }
130 | imgResps := []request.IterateReqResp{}
131 | for _, val := range imgMap {
132 | imgResps = append(imgResps, *val)
133 | }
134 |
135 | output := request.IterateReqRespAll{
136 | BaseURL: resp,
137 | AvgTotalRespTime: avgTotalRespTimes,
138 | AvgTotalLinearRespTime: avgTotalLinearRespTimes,
139 | JSResps: jsResps,
140 | CSSResps: cssResps,
141 | IMGResps: imgResps,
142 | }
143 | return output
144 | }
145 |
146 | type BaseURL struct {
147 | Url string `json:"base_url"`
148 | Numreqs int `json:"num_reqs"`
149 | TotBytes int `json:"total_bytes"`
150 | AvgPageRespTime time.Duration `json:"avg_page_resp_time"`
151 | AvgTimeToFirsttByte time.Duration `json:"avg_time_to_first_byte"`
152 | Status map[string]int `json:"status"`
153 | }
154 |
155 | type AssetResult struct {
156 | Url string `json:"url"`
157 | AvgRespTime time.Duration `json:"avg_resp_time"`
158 | Status map[string]int `json:"status"`
159 | }
160 |
161 | type Output struct {
162 | BaseURL BaseURL `json:"base_url"`
163 | JSResults []AssetResult `json:"js_assets"`
164 | CSSResults []AssetResult `json:"css_assets"`
165 | IMGResults []AssetResult `json:"img_assets"`
166 | }
167 |
168 | func (input Init) JsonAll() {
169 | /*
170 | Prints out all of the JSON data. Useful mainful for debugging
171 | */
172 | tmp, _ := json.MarshalIndent(input.Results, "", " ")
173 | fmt.Println(string(tmp))
174 | }
175 |
176 | func (input Init) JsonResults() string {
177 | /*
178 | Return only the performance result json.
179 | */
180 | results := input.Results
181 |
182 | avg, statusResults := procResult(&results.BaseURL)
183 | output := Output{
184 | BaseURL: BaseURL{
185 | Url: results.BaseURL.URL,
186 | Numreqs: len(results.BaseURL.Status),
187 | TotBytes: results.BaseURL.Bytes,
188 | AvgPageRespTime: results.AvgTotalRespTime,
189 | AvgTimeToFirsttByte: avg,
190 | Status: statusResults,
191 | },
192 | JSResults: buildAssetSlice(results.JSResps),
193 | CSSResults: buildAssetSlice(results.CSSResps),
194 | IMGResults: buildAssetSlice(results.IMGResps),
195 | }
196 |
197 | output_json, _ := json.MarshalIndent(output, "", " ")
198 | return string(output_json)
199 | }
200 |
201 | func buildAssetSlice(resps []request.IterateReqResp) []AssetResult {
202 | results := []AssetResult{}
203 | for _, resp := range resps {
204 | avg, statusResults := procResult(&resp)
205 | result := AssetResult{
206 | Url: resp.URL,
207 | AvgRespTime: avg,
208 | Status: statusResults,
209 | }
210 | results = append(results, result)
211 | }
212 | return results
213 | }
214 |
215 | func (input Init) Print() {
216 | results := input.Results
217 | yel := color.New(color.FgHiYellow).SprintfFunc()
218 | yellow := color.New(color.FgHiYellow, color.Underline).SprintfFunc()
219 | grey := color.New(color.FgHiBlack).SprintfFunc()
220 | white := color.New(color.FgWhite).SprintfFunc()
221 |
222 | color.Red("Base Url Results")
223 | fmt.Printf(" - %-45s %-25s\n", yel("Url:"), white(results.BaseURL.URL))
224 | fmt.Printf(" - %-45s %-25s\n", yel("Number of Requests:"), white(strconv.Itoa(len(results.BaseURL.Status))))
225 | fmt.Printf(" - %-45s %s\n", yel("Total Bytes:"), white(strconv.Itoa(results.BaseURL.Bytes)))
226 | fmt.Printf(" - %-45s %s\n", yel("Avg Page Resp Time:"), white(results.AvgTotalRespTime.String()))
227 |
228 | // TODO Remove this and associated code
229 | // This shows the total time to do a linear fetch asset by asset.
230 | //fmt.Printf(" - %-45s %s\n", yel("Avg Linear Resp Time:"), white(results.AvgTotalLinearRespTime.String()))
231 |
232 | // This is useful for comparing the decrease in resp time from linear to go routines
233 | // decrease := float64(results.AvgTotalLinearRespTime) - float64(results.AvgTotalRespTime)
234 | // percentDecrease := (float64(decrease) / float64(results.AvgTotalLinearRespTime) * 100.00)
235 | // fmt.Printf(" - %-45s %s\n", yel("percentDecrease:"), white(strconv.FormatFloat(percentDecrease, 'g', 5, 64)))
236 |
237 | avg, statusResults := procResultString(&results.BaseURL)
238 | fmt.Printf(" - %-45s %s\n", yel("Average Time to First Byte:"), white(avg))
239 | fmt.Printf(" - %-45s %s\n", yel("Status:"), white(statusResults))
240 |
241 | printAssets := func(title string, results []request.IterateReqResp) {
242 | color.Red(title)
243 | fmt.Printf(" - %-28s %-30s %-21s %-10s\n", yellow("Average"), yellow("Status"), yellow("Bytes"), yellow("Url"))
244 | for i, resp := range results {
245 | avg, statusResults := procResultString(&resp)
246 | if i%2 == 0 {
247 | fmt.Printf(" - %-26s %-28s %-19s %-10s\n", grey(avg), grey(statusResults), grey(strconv.Itoa(resp.Bytes)), grey(resp.URL))
248 | } else {
249 | fmt.Printf(" - %-26s %-28s %-19s %-10s\n", white(avg), white(statusResults), white(strconv.Itoa(resp.Bytes)), white(resp.URL))
250 | }
251 | }
252 | }
253 | printAssets("JS Results", results.JSResps)
254 | printAssets("CSS Results", results.CSSResps)
255 | printAssets("IMG Results", results.IMGResps)
256 | }
257 |
258 | func procResultString(resp *request.IterateReqResp) (string, string) {
259 | avg, statusResults := procResult(resp)
260 | tmp, err := json.Marshal(statusResults)
261 | if err != nil {
262 | log.Println("Unable to Marshal", statusResults)
263 | log.Fatal(err)
264 | }
265 | status := string(tmp)
266 | return avg.String(), status
267 | }
268 |
269 | func procResult(resp *request.IterateReqResp) (time.Duration, map[string]int) {
270 | totalTime := time.Duration(0)
271 | for _, val := range resp.RespTimes {
272 | totalTime += val
273 | }
274 | avg := time.Duration(int64(totalTime) / int64(len(resp.Status)))
275 |
276 | statusCodes := map[string][]int{}
277 | for _, val := range resp.Status {
278 | status := strconv.Itoa(val)
279 | statusCodes[status] = append(statusCodes[status], val)
280 | }
281 |
282 | statusResults := make(map[string]int)
283 | for key, _ := range statusCodes {
284 | statusResults[key] = len(statusCodes[key])
285 | }
286 |
287 | return avg, statusResults
288 | }
289 |
290 | func gatherAllStats(resp *request.FetchAllResponse, jsMap map[string]*request.IterateReqResp, cssMap map[string]*request.IterateReqResp, imgMap map[string]*request.IterateReqResp) {
291 | /*
292 | Gather all the asset stuff.
293 | NOTE: You benchmarked this and the 3 go routine method was way slower so you removed the method
294 | BenchmarkGatherAllStatsGo-8 500000 2764 ns/op
295 | BenchmarkGatherAllStats-8 2000000 638 ns/op
296 | */
297 | gatherStats(resp.JSResponses, jsMap)
298 | gatherStats(resp.CSSResponses, cssMap)
299 | gatherStats(resp.IMGResponses, imgMap)
300 | }
301 |
302 | func gatherStats(Resps []request.FetchResponse, respMap map[string]*request.IterateReqResp) {
303 | // gather all the responses
304 | for resp := 0; resp < len(Resps); resp++ {
305 | url2 := Resps[resp].URL
306 | bytes := Resps[resp].Bytes
307 | status := Resps[resp].Status
308 | respTime := Resps[resp].Time
309 | _, ok := respMap[url2]
310 | if !ok {
311 | respMap[url2] = &request.IterateReqResp{
312 | URL: url2,
313 | Bytes: bytes,
314 | Status: []int{status},
315 | RespTimes: []time.Duration{respTime},
316 | NumRequests: 1,
317 | }
318 | } else {
319 | respMap[url2].Status = append(respMap[url2].Status, status)
320 | respMap[url2].RespTimes = append(respMap[url2].RespTimes, respTime)
321 | respMap[url2].NumRequests += 1
322 | }
323 | }
324 | }
325 |
--------------------------------------------------------------------------------
/readme_imgs/Fetch.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gnulnx/goperf/d7e65ae890a4d241d7538a3113590b70dbc8577a/readme_imgs/Fetch.png
--------------------------------------------------------------------------------
/readme_imgs/GoPerf.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gnulnx/goperf/d7e65ae890a4d241d7538a3113590b70dbc8577a/readme_imgs/GoPerf.png
--------------------------------------------------------------------------------
/readme_imgs/GoPerfOutput.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gnulnx/goperf/d7e65ae890a4d241d7538a3113590b70dbc8577a/readme_imgs/GoPerfOutput.png
--------------------------------------------------------------------------------
/request/combine.go:
--------------------------------------------------------------------------------
1 | package request
2 |
3 | import (
4 | "time"
5 | )
6 |
7 | // Combine the slice of IterateReqRespAll structs into a single IterateReqRespAll
8 | func Combine(results []IterateReqRespAll) *IterateReqRespAll {
9 |
10 | totalReqs := 0
11 | baseStatus := []int{}
12 | baseRespTimes := []time.Duration{}
13 | baseBytes := 0
14 | jsResps := map[string][]IterateReqResp{}
15 | cssResps := map[string][]IterateReqResp{}
16 | imgResps := map[string][]IterateReqResp{}
17 |
18 | var totalAvglRespTimes int64
19 | var totalAvgLinearlRespTimes int64
20 | var count int64
21 | for _, resp := range results {
22 | totalReqs += len(resp.BaseURL.Status)
23 | baseStatus = append(baseStatus, resp.BaseURL.Status...)
24 | baseRespTimes = append(baseRespTimes, resp.BaseURL.RespTimes...)
25 | baseBytes += resp.BaseURL.Bytes
26 | totalAvglRespTimes += int64(resp.AvgTotalRespTime)
27 | totalAvgLinearlRespTimes += int64(resp.AvgTotalLinearRespTime)
28 | count++
29 |
30 | for _, jsresp := range resp.JSResps {
31 | jsResps[jsresp.URL] = append(jsResps[jsresp.URL], jsresp)
32 | }
33 | for _, cssresp := range resp.CSSResps {
34 | cssResps[cssresp.URL] = append(cssResps[cssresp.URL], cssresp)
35 | }
36 | for _, imgresp := range resp.IMGResps {
37 | imgResps[imgresp.URL] = append(imgResps[imgresp.URL], imgresp)
38 | }
39 | }
40 |
41 | avgTotalRespTimes := time.Duration(totalAvglRespTimes / count)
42 | avgTotalLinearRespTimes := time.Duration(totalAvgLinearlRespTimes / count)
43 |
44 | combine := func(resps map[string][]IterateReqResp) []IterateReqResp {
45 | allResps := []IterateReqResp{}
46 | for k, v := range resps {
47 | status := []int{}
48 | respTimes := []time.Duration{}
49 | bytes := 0
50 | for _, resp := range v {
51 | status = append(status, resp.Status...)
52 | respTimes = append(respTimes, resp.RespTimes...)
53 | bytes += resp.Bytes
54 | }
55 | allResps = append(allResps, IterateReqResp{
56 | URL: k,
57 | Status: status,
58 | RespTimes: respTimes,
59 | NumRequests: len(status),
60 | Bytes: bytes,
61 | })
62 | }
63 | return allResps
64 | }
65 |
66 | return &IterateReqRespAll{
67 | AvgTotalRespTime: avgTotalRespTimes,
68 | AvgTotalLinearRespTime: avgTotalLinearRespTimes,
69 | BaseURL: IterateReqResp{
70 | URL: results[0].BaseURL.URL,
71 | Status: baseStatus,
72 | RespTimes: baseRespTimes,
73 | NumRequests: len(baseStatus),
74 | Bytes: baseBytes,
75 | },
76 | JSResps: combine(jsResps),
77 | CSSResps: combine(cssResps),
78 | IMGResps: combine(imgResps),
79 | }
80 | }
81 |
--------------------------------------------------------------------------------
/request/fetch.go:
--------------------------------------------------------------------------------
1 | package request
2 |
3 | import (
4 | "io/ioutil"
5 | "net/http"
6 | "strings"
7 | "time"
8 | "unicode/utf8"
9 | )
10 |
11 | /*
12 | FetchInput used used as input to the Fetch method.
13 |
14 | Structure Overview
15 | - BaseURL - the url to fetch
16 | - Retdat - if true then the document data is returned
17 | - Cookies - a cookie string to set on each request
18 | - UserAge - default is golang, but can be set to anything.`
19 | */
20 | type FetchInput struct {
21 | BaseURL string
22 | Retdat bool
23 | Cookies string
24 | Headers string
25 | UserAgent string
26 | }
27 |
28 | /*
29 | FetchResponse is the struct returned for Fetch()
30 |
31 | Structure Overview:
32 | - Url - url of the fetched object
33 | - Body - The body of the returned document. Could be anything...html, js, css, etc.
34 | - Headers - The headers for the HttpResp object
35 | - Bytes - The number of bytes returned
36 | - Runes - The number of runes returned
37 | - Time - How long the Resp took.
38 | - Statue - the HttpResp status code.
39 | - Error - Any errors that were returned
40 | */
41 | type FetchResponse struct {
42 | URL string `json:"url"`
43 | Resp *http.Response `json:"resp"`
44 | Body string `json:"body"`
45 | Headers map[string][]string `json:"headers"`
46 | Bytes int `json:"bytes"`
47 | Runes int `json:"runes"`
48 | Time time.Duration `json:"time"`
49 | Status int `json:"status"`
50 | Error string `json:"error"`
51 | }
52 |
53 | /*
54 | Fetch is a document from a url. The document can be almost anything such as html, js, css, xml, etc.
55 | A FetchInput object is used to encapsulate the various properties of the request.
56 | */
57 | func Fetch(input FetchInput) *FetchResponse {
58 | url := input.BaseURL
59 | retdat := input.Retdat
60 | cookies := input.Cookies
61 | headers := strings.Split(input.Headers, "=")
62 |
63 | // Set up the http request
64 | client := &http.Client{}
65 | req, _ := http.NewRequest("GET", url, nil)
66 |
67 | // Set the header
68 | req.Header.Add(headers[0], headers[1])
69 |
70 | // Set the use user-agent. Default is 'goperf'. So most like users will want to change it to something different.
71 | // Example user-agent: "Chrome/61.0.3163.100 Mobile Safari/537.36"
72 | req.Header.Add("user-agent", input.UserAgent)
73 |
74 | // cookies (example): "sessionid_vagrant=5i4bgzvc0vy8xjgf1flfoh89cwsg74hz; csrftoken_vagrant=taZjH9jskTjfbvDDq7OzdtQnTaB72zIk"
75 | req.Header.Add("cookie", cookies)
76 |
77 | //Fetch the url and time the request
78 | start := time.Now()
79 | resp, err := client.Do(req)
80 |
81 | if err != nil {
82 | return &FetchResponse{
83 | URL: err.Error(),
84 | Status: -100,
85 | Error: "There was a problem with you request. Please double check your url",
86 | }
87 | }
88 | defer resp.Body.Close()
89 | responseTime := time.Now().Sub(start)
90 |
91 | // Read the html 'body' content from the response object
92 | body, err := ioutil.ReadAll(resp.Body)
93 | Error := ""
94 | if err != nil {
95 | body = []byte("")
96 | Error = err.Error()
97 | }
98 | // This contains the text of the response. HTML, Json, Exception, etc
99 | responseBody := string(body)
100 |
101 | output := FetchResponse{
102 | URL: url,
103 | Resp: resp,
104 | Body: responseBody,
105 | Headers: resp.Header,
106 | Bytes: len(responseBody),
107 | Runes: utf8.RuneCountInString(responseBody),
108 | Time: responseTime,
109 | Status: resp.StatusCode,
110 | Error: Error,
111 | }
112 |
113 | if !retdat { // we don't want the document data or headers
114 | output.Body = ``
115 | output.Headers = make(map[string][]string)
116 | }
117 | //Close the response body and return the output
118 | return &output
119 | }
120 |
--------------------------------------------------------------------------------
/request/fetchall.go:
--------------------------------------------------------------------------------
1 | package request
2 |
3 | import (
4 | "fmt"
5 | "net/url"
6 | "strconv"
7 | "time"
8 |
9 | "github.com/gnulnx/color"
10 | "github.com/gnulnx/goperf/httputils"
11 | )
12 |
13 | // FetchAllResponse is the return structure from FetchAll
14 | type FetchAllResponse struct {
15 | BaseURL *FetchResponse `json:"BaseURL"`
16 | Time time.Duration `json:"time"`
17 | TotalTime time.Duration `json:"totalTime"`
18 | TotalLinearTime time.Duration `json:totalLinearTime"`
19 | TotalBytes int `json:"totalBytes"`
20 | JSResponses []FetchResponse `json:"jsResponses"`
21 | IMGResponses []FetchResponse `json:"imgResponses"`
22 | CSSResponses []FetchResponse `json:"cssResponses"`
23 |
24 | Body string `json:"body"`
25 | }
26 |
27 | /*
28 | FetchAll takes a FetchInput object and proceeds to fetch
29 | the BaseURL and then fetch all of it's assets.
30 |
31 | Assets currently refer to script, style, and img tags.
32 |
33 | Each asset class is fetched in it's own go routine.
34 | If retdata is False we don't return the Body or Header.
35 | This is useful if you only want the timing data.
36 | For instance you might find it useful to fetch with retdat=true
37 | the first time around to get all the data and write to file.
38 | The subsequet requests could be used as part of a perf test where
39 | you only need the raw timing and size data. In those cases
40 | you can set retdat=false to effectivly cut down on the verbosity
41 | */
42 | func FetchAll(input FetchInput) *FetchAllResponse {
43 | retdat := input.Retdat
44 |
45 | // Fetch initial url
46 | start := time.Now()
47 | input.Retdat = true
48 | output := Fetch(input)
49 |
50 | // Now parse output for js, css, img urls
51 | jsfiles, imgfiles, cssfiles := httputils.GetAssets(output.Body)
52 |
53 | // Now lets create some go routines and fetch all the js, img, css files
54 | c1 := make(chan []FetchResponse)
55 | c2 := make(chan []FetchResponse)
56 | c3 := make(chan []FetchResponse)
57 |
58 | go GoFetchAllAssetArray(jsfiles, input, c1)
59 | go GoFetchAllAssetArray(imgfiles, input, c2)
60 | go GoFetchAllAssetArray(cssfiles, input, c3)
61 |
62 | jsResponses := []FetchResponse{}
63 | imgResponses := []FetchResponse{}
64 | cssResponses := []FetchResponse{}
65 |
66 | for i := 0; i < 3; i++ {
67 | select {
68 | case jsResponses = <-c1:
69 | case imgResponses = <-c2:
70 | case cssResponses = <-c3:
71 | }
72 | }
73 | totalTime2 := time.Now().Sub(start)
74 |
75 | if !retdat {
76 | output.Body = ``
77 | output.Headers = make(map[string][]string)
78 | }
79 |
80 | calcTotal := func(resp []FetchResponse) (time.Duration, int) {
81 | totalTime := time.Duration(0)
82 | totalBytes := 0
83 | for _, val := range resp {
84 | totalTime += val.Time
85 | totalBytes += val.Bytes
86 | }
87 | return totalTime, totalBytes
88 | }
89 |
90 | jsTime, jsBytes := calcTotal(jsResponses)
91 | cssTime, cssBytes := calcTotal(cssResponses)
92 | imgTime, imgBytes := calcTotal(imgResponses)
93 |
94 | totalLinearTime := output.Time + jsTime + cssTime + imgTime
95 | totalBytes := output.Bytes + jsBytes + cssBytes + imgBytes
96 |
97 | resp := FetchAllResponse{
98 | BaseURL: output,
99 | Time: output.Time,
100 | TotalTime: totalTime2,
101 | TotalLinearTime: totalLinearTime,
102 | TotalBytes: totalBytes,
103 | Body: output.Body,
104 | JSResponses: jsResponses,
105 | IMGResponses: imgResponses,
106 | CSSResponses: cssResponses,
107 | }
108 |
109 | return &resp
110 | }
111 |
112 | /*
113 | PrintFetchAllRespnse takes a FetchAllResonse object and prints the results to stdout
114 | */
115 | func PrintFetchAllResponse(resp *FetchAllResponse) {
116 | yel := color.New(color.FgHiYellow).SprintfFunc()
117 | yellow := color.New(color.FgHiYellow, color.Underline).SprintfFunc()
118 | grey := color.New(color.FgHiBlack).SprintfFunc()
119 | white := color.New(color.FgWhite).SprintfFunc()
120 | red := color.New(color.FgRed).SprintfFunc()
121 | green := color.New(color.FgGreen).SprintfFunc()
122 | total := resp.BaseURL.Time
123 |
124 | // Show the resp body.
125 | fmt.Print(resp.Body)
126 |
127 | color.Red("Base Url Results")
128 | if resp.BaseURL.Status == 200 {
129 | fmt.Printf(" - %-34s %-25s\n", yel("Status:"), green(strconv.Itoa(resp.BaseURL.Status)))
130 | } else {
131 | fmt.Printf(" - %-34s %-25s\n", yel("Status:"), red(strconv.Itoa(resp.BaseURL.Status)))
132 | }
133 | fmt.Printf(" - %-34s %-25s\n", yel("Url:"), white(resp.BaseURL.URL))
134 | fmt.Printf(" - %-34s %-25s\n", yel("Time to first byte"), total.String())
135 | fmt.Printf(" - %-34s %-25s\n", yel("Bytes"), strconv.Itoa(resp.BaseURL.Bytes))
136 | fmt.Printf(" - %-34s %-25s\n", yel("Runes"), strconv.Itoa(resp.BaseURL.Runes))
137 | fmt.Printf(" - %-34s %-25s\n", yel("TotalTime"), resp.TotalTime.String())
138 | fmt.Printf(" - %-34s %-25s\n", yel("TotalBytes"), strconv.Itoa(resp.TotalBytes))
139 |
140 | printAssets := func(title string, results []FetchResponse) {
141 | color.Red(title)
142 | fmt.Printf(" - %-24s %-22s %-21s\n", yellow("Time"), yellow("Bytes"), yellow("Url"))
143 | for i, val := range results {
144 | if i%2 == 0 {
145 | fmt.Printf(" - %-22s %-20s %-10s \n", white(val.Time.String()), white(strconv.Itoa(val.Bytes)), white(val.URL))
146 | } else {
147 | fmt.Printf(" - %-22s %-20s %-10s \n", grey(val.Time.String()), grey(strconv.Itoa(val.Bytes)), grey(val.URL))
148 | }
149 | }
150 | }
151 |
152 | printAssets("JS Responses", resp.JSResponses)
153 | printAssets("CSS Responses", resp.CSSResponses)
154 | printAssets("IMG Responses", resp.IMGResponses)
155 | }
156 |
157 | //DefineAssetURL is used to determine if an asset is a local resource
158 | func DefineAssetURL(BaseURL string, asseturl string) string {
159 | /*
160 | If the url starts with a / we know it's a local resource
161 | so we prepend the BaseURL to it
162 | */
163 | if asseturl[:4] == "http" {
164 | return asseturl
165 | }
166 |
167 | u, err := url.Parse(BaseURL)
168 | if err != nil {
169 | panic(err)
170 | }
171 | BaseURL = fmt.Sprintf("%s://%s", u.Scheme, u.Hostname())
172 |
173 | if asseturl[0] == '/' {
174 | asseturl = BaseURL + asseturl
175 | } else {
176 | asseturl = BaseURL + "/" + asseturl
177 | }
178 | return asseturl
179 | }
180 |
181 | func GoFetchAllAssetArray(files []string, input FetchInput, resp chan []FetchResponse) {
182 | BaseURL := input.BaseURL
183 |
184 | chanHolder := []chan FetchResponse{}
185 | for i, assetURL := range files {
186 | chanHolder = append(chanHolder, make(chan FetchResponse))
187 | go func(c chan FetchResponse, assetURL string, input FetchInput) {
188 | input.BaseURL = DefineAssetURL(BaseURL, assetURL)
189 | c <- *Fetch(input)
190 | }(chanHolder[i], assetURL, input)
191 | }
192 |
193 | // Wait on all the channels
194 | responses := []FetchResponse{}
195 | for _, ch := range chanHolder {
196 | responses = append(responses, <-ch)
197 | }
198 |
199 | resp <- responses
200 | }
201 |
--------------------------------------------------------------------------------
/request/structs.go:
--------------------------------------------------------------------------------
1 | package request
2 |
3 | import (
4 | "net/http"
5 | "time"
6 | )
7 |
8 | type IterateReqResp struct {
9 | URL string `json:"url"`
10 | Status []int `json:"status"`
11 | RespTimes []time.Duration `json:"resp_times"`
12 | NumRequests int `json:"num_requests"`
13 | Bytes int `json:"bytes"`
14 | }
15 |
16 | type IterateReqRespAll struct {
17 | AvgTotalRespTime time.Duration `json:"avgTotalRespTime"`
18 | AvgTotalLinearRespTime time.Duration `json:"avgTotalLinearRespTime"`
19 | BaseURL IterateReqResp `json:"baseURL"`
20 | JSResps []IterateReqResp `json:"jsResps"`
21 | CSSResps []IterateReqResp `json:"cssResps"`
22 | IMGResps []IterateReqResp `json:"imgResps"`
23 | }
24 |
25 | /*
26 | Structure used to create web request Channel. This is how we get the results
27 | back from the 'go Run(...) method call
28 | */
29 | type Result struct {
30 | Total time.Duration
31 | Average time.Duration
32 | Channel int
33 | Responses []*http.Response
34 | }
35 |
--------------------------------------------------------------------------------