How to use call method of concurrent Package

1package call2import (3	"fmt"4	"log"5	"net/http"6	"net/url"7	"reflect"8	"strings"9	"sync"10	"time"11	"github.com/briandowns/spinner"12)13// A Call should know how to execute itself, generating14// a Result from its execution15type Call interface {16	MakeIt() map[int]int17}18// A ConcurrentCall represents the very basic structure to19// start calling some URL out. It carries all data20// needed to call-it operate on.21type ConcurrentCall struct {22	URL                *url.URL // The endpoint to be tested23	config             Config   // configs from file24	Attempts           int      // number of Attempts25	ConcurrentAttempts int      // number of concurrent Attempts26}27// A Result contains the info to be outputted at the end28// of the operation29type Result struct {30	URL            *url.URL                    // Endpoint tested31	status         map[int]StatusCodeBenchmark // status codes32	totalExecution float64                     // total execution time33	avgExecution   float64                     // average execution time34	minExecution   float64                     // min execution time35	maxExecution   float64                     // min execution time36}37// HTTPResponse status code and execution time38type HTTPResponse struct {39	status    int     // status codes40	err       error   // possible error41	execution float64 // total execution time42}43// StatusCodeBenchmark with total of occurrences, execution time44type StatusCodeBenchmark struct {45	total     int     // total46	execution float64 // total execution time47}48// MakeIt executes a call and return its results49func (call *ConcurrentCall) MakeIt() (result Result) {50	result = Result{51		URL:            call.URL,52		status:         make(map[int]StatusCodeBenchmark),53		totalExecution: 0,54		avgExecution:   0,55		minExecution:   0,56		maxExecution:   0}57	beginning := time.Now()58	if call.config.Name != "" {59		fmt.Println("Case: ", call.config.Name)60	}61	s := spinner.New(spinner.CharSets[31], 300*time.Millisecond)62	s.Prefix = "😎 "63	s.Suffix = " " + call.URL.String()64	s.Start()65	totalAttempts := call.Attempts66	for call.Attempts > 0 {67		concurrentAttempts := calcConcurrentAttempts(*call)68		responses := callURL(call.URL, concurrentAttempts, call.config)69		for _, response := range responses {70			statusCodeBenchmark := result.status[response.status]71			statusCodeBenchmark.total++72			statusCodeBenchmark.execution += response.execution73			result.status[response.status] = statusCodeBenchmark74			if result.minExecution == 0 || result.minExecution > response.execution {75				result.minExecution = response.execution76			}77			if result.maxExecution == 0 || result.maxExecution < response.execution {78				result.maxExecution = response.execution79			}80		}81		call.Attempts -= concurrentAttempts82	}83	s.Stop()84	result.totalExecution = time.Since(beginning).Seconds()85	result.avgExecution = result.totalExecution / float64(totalAttempts)86	return87}88// It calculates the amount of concurrent calls to be executed,89// based on the attempts left. It ensures that the next round90// of concurrent calls will respect the attempts left of a given call91func calcConcurrentAttempts(call ConcurrentCall) (numberOfConcurrentAttempts int) {92	numberOfConcurrentAttempts = call.ConcurrentAttempts93	if numberOfConcurrentAttempts > call.Attempts {94		numberOfConcurrentAttempts = call.Attempts95	}96	return97}98// This func calls an URL concurrently99func callURL(callerURL *url.URL, concurrentAttempts int, config Config) (responses []HTTPResponse) {100	urlResponse := make(chan HTTPResponse)101	var wg sync.WaitGroup102	wg.Add(concurrentAttempts)103	for i := 0; i < int(concurrentAttempts); i++ {104		go func() {105			defer wg.Done()106			beginning := time.Now()107			req, err := buildRequest(callerURL.String(), config)108			if err != nil {109				log.Fatalf("Something got wrong: %v", err)110			}111			client := http.DefaultClient112			response, err := client.Do(req)113			executionSecs := time.Since(beginning).Seconds()114			if err != nil {115				urlResponse <- HTTPResponse{116					err:       err,117					execution: executionSecs,118					status:    http.StatusRequestTimeout,119				}120				return121			}...

1package call2import (3	"net/http"4	"net/url"5	"testing"6	"github.com/jarcoal/httpmock"7	"github.com/stretchr/testify/assert"8)9func TestMakeCallsWhenURLExists(test *testing.T) {10	httpmock.Activate()11	defer httpmock.DeactivateAndReset()12	httpmock.RegisterResponder("GET", "http://www.foo.com/bar",13		httpmock.NewStringResponder(200, `[]`))14	params := []string{"http://www.foo.com/bar", "10"}15	call, _ := BuildCall(params, 1, 100)16	result := call.MakeIt()17	assert.Equal(test, 1, len(result.status))18	assert.Equal(test, 10, result.status[200].total)19}20func TestMakeCallsWhenURLDoesntExist(test *testing.T) {21	httpmock.Activate()22	defer httpmock.DeactivateAndReset()23	httpmock.RegisterResponder("GET", "http://www.foo.com/bar",24		httpmock.NewStringResponder(404, `[]`))25	params := []string{"http://www.foo.com/bar", "10"}26	call, _ := BuildCall(params, 1, 100)27	result := call.MakeIt()28	assert.Equal(test, 1, len(result.status))29	assert.Equal(test, 0, result.status[200].total)30	assert.Equal(test, 10, result.status[404].total)31}32func TestMakeCallsReturnTheSameStatusCode(test *testing.T) {33	httpmock.Activate()34	defer httpmock.DeactivateAndReset()35	httpmock.RegisterResponder("GET", "http://www.foo.com/bar",36		httpmock.NewStringResponder(200, `[]`))37	params := []string{"http://www.foo.com/bar", "100"}38	call, _ := BuildCall(params, 1, 10)39	result := call.MakeIt()40	assert.Equal(test, 1, len(result.status))41	assert.Equal(test, 100, result.status[200].total)42}43func TestCalcConcurrentAttemptsWhenThereAreEnoughAttemptsLeft(test *testing.T) {44	urlAddress, _ := url.Parse("http://www.a.com")45	call := ConcurrentCall{URL: urlAddress, Attempts: 100, ConcurrentAttempts: 10}46	assert.Equal(test, 10, calcConcurrentAttempts(call))47}48func TestCalcConcurrentAttemptsWhenThereAreNotEnoughAttemptsLeft(test *testing.T) {49	urlAddress, _ := url.Parse("http://www.a.com")50	call := ConcurrentCall{URL: urlAddress, Attempts: 10, ConcurrentAttempts: 100}51	assert.Equal(test, 10, calcConcurrentAttempts(call))52}53func TestCalcConcurrentAttemptsWhenAttemptsLeftIsEqualToConcurrentAttempts(test *testing.T) {54	urlAddress, _ := url.Parse("http://www.a.com")55	call := ConcurrentCall{URL: urlAddress, Attempts: 10, ConcurrentAttempts: 10}56	assert.Equal(test, 10, calcConcurrentAttempts(call))57}58func TestGetUrl(test *testing.T) {59	urlAddress := "http://www.foo.com/bar"60	httpmock.Activate()61	defer httpmock.DeactivateAndReset()62	httpmock.RegisterResponder("GET", urlAddress,63		httpmock.NewStringResponder(200, `[]`))64	config := Config{}65	parsedURL, _ := url.Parse(urlAddress)66	callResponses := callURL(parsedURL, 50, config)67	for _, response := range callResponses {68		assert.Equal(test, 200, response.status)69	}70	assert.Equal(test, 50, len(callResponses))71}72func Test_buildRequest(t *testing.T) {73	type args struct {74		baseURL string75		config  Config76	}77	tests := []struct {78		name    string79		args    args80		wantErr bool81	}{82		{83			name: "should pass without config",84			args: args{...

1package call2import (3	"errors"4	"fmt"5	"net/url"6	"strconv"7	"github.com/matryer/goscript"8)9var (10	// ErrInvalidArgumentsNumber is an error when the number of arguments are invalid11	ErrInvalidArgumentsNumber = errors.New("invalid number of arguments")12	// ErrMethodNotAllowed is an error with bad config method13	ErrMethodNotAllowed = errors.New("Method not allowed")14	// ErrEmptyName is an error with bad Config method15	ErrEmptyName = errors.New("Request Config name cannot be nil")16)17const (18	// AttemptsPosition in Args19	AttemptsPosition = 120	// ConcurrentAttemptsPosition in Args21	ConcurrentAttemptsPosition = 222)23// BuildCall parses all given arguments and transform them into a ConcurrentCall24func BuildCall(args []string, maxAttempts, maxConcurrentAttempts int) (call ConcurrentCall, err error) {25	var (26		callURL                      *url.URL27		attempts, concurrentAttempts int28	)29	isValid, err := validate(args)30	if !isValid {31		return32	}33	callURL, err = url.Parse(args[0])34	if err != nil {35		return36	}37	attempts, err = ParseIntArgument(args, AttemptsPosition, maxAttempts)38	if err != nil {39		return40	}41	concurrentAttempts, err = ParseIntArgument(args, ConcurrentAttemptsPosition, maxConcurrentAttempts)42	if err != nil {43		return44	}45	call = ConcurrentCall{46		URL:                callURL,47		Attempts:           attempts,48		ConcurrentAttempts: concurrentAttempts,49	}50	return51}52// Checks if the given parameters are valid53func validate(args []string) (result bool, err error) {54	if args == nil || len(args) < 1 {55		return false, ErrInvalidArgumentsNumber56	}57	_, err = url.ParseRequestURI(args[0])58	if err != nil {59		return60	}61	return true, nil62}63// ParseIntArgument tries to parse an int argument. If it wasn't possible, returns64// default value65func ParseIntArgument(args []string, position int, defaultValue int) (val int, err error) {66	if len(args) <= position {67		val = defaultValue68		return69	}70	val, err = strconv.Atoi(args[position])71	if err != nil {72		fmt.Println("Argument invalid. Using default: " + strconv.Itoa(int(defaultValue)))73		val = defaultValue74	}75	return76}77// BuildCallsFromConfig parses a Config file and transforms the instructions into a list of ConcurrentCalls78func BuildCallsFromConfig() (calls []ConcurrentCall, err error) {79	callConfig, err := config()80	if err != nil {81		return82	}83	for _, c := range callConfig {84		if err = c.checkDefaults(); err != nil {85			return86		}87		if c.Func != "" {88			s, errF := getFuncResult(c.Func)89			if errF != nil {90				return calls, errF91			}92			c.Body = fmt.Sprintf(c.Body, s)93		}94		url, errP := url.ParseRequestURI(c.URL)95		if errP != nil {96			return nil, errP97		}98		newCall := ConcurrentCall{99			URL:                url,100			Attempts:           c.Attempts,101			ConcurrentAttempts: c.ConcurrentAttempts,102			config:             c,103		}104		calls = append(calls, newCall)105	}106	return107}108func getFuncResult(fn string) (s string, err error) {109	script := goscript.New(fn)110	defer script.Close()111	ex, err := script.Execute()112	if err != nil {113		return114	}115	return fmt.Sprintf("%v", ex), err116}...

1import (2func main() {3    c := make(chan string)4    go count("sheep", c)5    for msg := range c {6        fmt.Println(msg)7    }8}9func count(thing string, c chan string) {10    for i := 1; ; i++ {

1import (2func main() {3	c.Call()4}5import (6type Concurrent struct {7}8func (c Concurrent) Call() {9	fmt.Println("Hello, World!")10	time.Sleep(2 * time.Second)11}

1import (2func main() {3	fmt.Println("Main method started")4	go longWait()5	go shortWait()6	fmt.Println("Main method ended")7	time.Sleep(10 * 1e9)8}9func longWait() {10	fmt.Println("longWait started")11	time.Sleep(5 * 1e9)12	fmt.Println("longWait ended")13}14func shortWait() {15	fmt.Println("shortWait started")16	time.Sleep(2 * 1e9)17	fmt.Println("shortWait ended")18}

1import (2func main() {3    c.Call()4    fmt.Println("main() finished")5}6import (7func main() {8    c.Call()9    fmt.Println("main() finished")10}11import (12func main() {13    c.Call()14    fmt.Println("main() finished")15}16import (17func main() {18    c.Call()19    fmt.Println("main() finished")20}21import (22func main() {23    c.Call()24    fmt.Println("main() finished")25}26import (27func main() {28    c.Call()29    fmt.Println("main() finished")30}31import (32func main() {33    c.Call()34    fmt.Println("main() finished")35}36import (37func main() {38    c.Call()39    fmt.Println("main() finished")40}41import (42func main() {43    c.Call()44    fmt.Println("main() finished")45}46import (47func main() {

1import (2type concurrent struct {3}4func (c *concurrent) call() {5    fmt.Println("call method")6}7func main() {8    c := concurrent{}9    go c.call()10    time.Sleep(1 * time.Second)11}12import (13type concurrent struct {14}15func (c *concurrent) call(name string) {16    fmt.Println("Hello, " + name)17}18func main() {19    c := concurrent{}20    go c.call("John")21    time.Sleep(1 * time.Second)22}23import (

1import (2func main() {3	c := concurrent{}4	c.call()5}6import (7type concurrent struct {8}9func (c *concurrent) call() {10	c.call1()11}12func (c *concurrent) call1() {13	c.call2()14}15func (c *concurrent) call2() {16	c.call3()17}18func (c *concurrent) call3() {19	c.call4()20}21func (c *concurrent) call4() {22	c.call5()23}24func (c *concurrent) call5() {25	c.call6()26}27func (c *concurrent) call6() {28	c.call7()29}30func (c *concurrent) call7() {31	c.call8()32}33func (c *concurrent) call8() {34	c.call9()35}36func (c *concurrent) call9() {37	c.call10()38}39func (c *concurrent) call10() {40	c.call11()41}42func (c *concurrent) call11() {43	c.call12()44}45func (c *concurrent) call12() {46	c.call13()47}48func (c *concurrent) call13() {49	c.call14()50}51func (c *concurrent) call14() {52	c.call15()53}54func (c *concurrent) call15() {55	c.call16()56}57func (c *concurrent) call16() {58	c.call17()59}60func (c

1import (2func main() {3	fmt.Println("Start Goroutines")4	go func() {5		for count := 0; count < 3; count++ {6			for char := 'a'; char < 'a'+26; char++ {7				fmt.Printf("%c ", char)8			}9		}10	}()11	go func() {12		defer wg.Done()13		for count := 0; count < 3; count++ {14			for char := 'A'; char < 'A'+26; char++ {15				fmt.Printf("%c ", char)16			}17		}18	}()19	fmt.Println("Waiting To Finish")20	wg.Wait()21	fmt.Println("Terminating Program")22}23import (24func main() {25	fmt.Println("Start Goroutines")26	go func() {27		for count := 0; count < 3; count++ {28			for char := 'a'; char < 'a'+26; char++ {

1import (2func main() {3    c := concurrent.New()4    c.Call("hello world")5    time.Sleep(2 * time.Second)6    fmt.Println(c.Result())7}8import (9func main() {10    c := concurrent.New()11    c.Call("hello world")12    time.Sleep(2 * time.Second)13    fmt.Println(c.Result())14}15import (16type Concurrent struct {17}18func New() *Concurrent {19    return &Concurrent{}20}21func (c *Concurrent) Call(s string) {22    go func() {23        for i := 0; i < 5; i++ {24            c.result = fmt.Sprintf("%s %d", s, i)25            time.Sleep(1 * time.Second)26        }27    }()28}29func (c *Concurrent) Result() string {30}31import (32type Concurrent struct {33}34func New() *Concurrent {35    return &Concurrent{}36}37func (c *Concurrent) Call(s string) {38    c.wg.Add(1)39    go func() {40        defer c.wg.Done()41        for i := 0; i < 5; i++ {42            c.result = fmt.Sprintf("%s %d", s, i)43            time.Sleep(1 * time.Second)44        }45    }()46}47func (c *Concurrent) Result() string {

1import (2func main() {3	conc := NewConcurrent()4	call := conc.Call()5	call(func() {6		fmt.Println("Hello World")7	})8	conc.Wait()9}10import (11type Concurrent struct {12}13func NewConcurrent() *Concurrent {14	return &Concurrent{}15}16func (conc *Concurrent) Call() func(func()) {17	conc.wg.Add(1)18	return func(f func()) {19		f()20		conc.wg.Done()21	}22}23func (conc *Concurrent) Wait() {24	conc.wg.Wait()25}26import (27type Concurrent struct {28}29func NewConcurrent() *Concurrent {30	return &Concurrent{31		ch: make(chan bool),32	}33}34func (conc *Concurrent) Call() func(func()) {35	conc.wg.Add(1)36	return func(f func()) {37		f()38		conc.wg.Done()39	}40}41func (conc *Concurrent) Wait() {42	conc.wg.Wait()43	close(conc.ch)44}45import (46type Concurrent struct {