mirror of
https://github.com/XRPLF/clio.git
synced 2025-11-26 14:45:52 +00:00
d11e7bc60e
There was a data race inside `CoroutineGroup` because internal timer was used from multiple threads in the methods `asyncWait()` and `onCoroutineComplete()`. Changing `registerForeign()` to spawn to the same `yield_context` fixes the problem because now the timer is accessed only from the same coroutine which has an internal strand. During debugging I also added websocket support for `request_gun` tool.
110 lines
2.9 KiB
Go
110 lines
2.9 KiB
Go
package trigger
|
|
|
|
import (
|
|
"log"
|
|
"os"
|
|
"os/signal"
|
|
"requests_gun/internal/ammo_provider"
|
|
"requests_gun/internal/parse_args"
|
|
"requests_gun/internal/request_maker"
|
|
"sync"
|
|
"sync/atomic"
|
|
"time"
|
|
)
|
|
|
|
func Fire(ammoProvider *ammo_provider.AmmoProvider, args *parse_args.CliArgs) {
|
|
interrupt := make(chan os.Signal, 1)
|
|
signal.Notify(interrupt, os.Interrupt)
|
|
|
|
wg := sync.WaitGroup{}
|
|
ticker := time.NewTicker(time.Second)
|
|
for {
|
|
select {
|
|
case s := <-interrupt:
|
|
log.Println("Got signal:", s)
|
|
log.Println("Stopping...")
|
|
ticker.Stop()
|
|
return
|
|
case <-ticker.C:
|
|
statistics := statistics{startTime: time.Now(), printErrors: args.PrintErrors}
|
|
doShot := func() {
|
|
defer wg.Done()
|
|
bullet := ammoProvider.GetBullet()
|
|
if args.Ws {
|
|
wsClient, err := request_maker.NewWebSocketClient(args.Host, args.Port)
|
|
if err != nil {
|
|
statistics.add(nil, err)
|
|
return
|
|
}
|
|
responseData, err := wsClient.SendMessage(bullet)
|
|
statistics.add(responseData, err)
|
|
} else {
|
|
requestMaker := request_maker.NewHttp(args.Host, args.Port)
|
|
responseData, err := requestMaker.MakeRequest(bullet)
|
|
statistics.add(responseData, err)
|
|
}
|
|
}
|
|
|
|
secondStart := time.Now()
|
|
requestsNumber := uint(0)
|
|
for requestsNumber < args.TargetLoad && time.Since(secondStart) < time.Second {
|
|
wg.Add(1)
|
|
go doShot()
|
|
requestsNumber++
|
|
}
|
|
wg.Wait()
|
|
if time.Since(secondStart) > time.Second {
|
|
log.Println("Requests took longer than a second, probably need to decrease the load.")
|
|
}
|
|
statistics.print()
|
|
}
|
|
}
|
|
}
|
|
|
|
type counters struct {
|
|
totalRequests atomic.Uint64
|
|
errors atomic.Uint64
|
|
badReply atomic.Uint64
|
|
goodReply atomic.Uint64
|
|
}
|
|
type statistics struct {
|
|
counters counters
|
|
startTime time.Time
|
|
printErrors bool
|
|
}
|
|
|
|
func (s *statistics) add(response *request_maker.ResponseData, err error) {
|
|
s.counters.totalRequests.Add(1)
|
|
if err != nil {
|
|
if s.printErrors {
|
|
log.Println("Error making request:", err)
|
|
}
|
|
s.counters.errors.Add(1)
|
|
return
|
|
}
|
|
if response.StatusCode != 200 || response.Body["error"] != nil {
|
|
if s.printErrors {
|
|
if response.Body["error"] != nil {
|
|
log.Print("Response contains error: ", response.Body["error"])
|
|
} else {
|
|
log.Print("Got bad status: ", response.StatusCode, response.StatusStr)
|
|
}
|
|
}
|
|
s.counters.badReply.Add(1)
|
|
} else {
|
|
s.counters.goodReply.Add(1)
|
|
}
|
|
}
|
|
|
|
func (s *statistics) print() {
|
|
elapsed := time.Since(s.startTime)
|
|
if elapsed < time.Second {
|
|
elapsed = time.Second
|
|
}
|
|
log.Printf("Speed: %.1f rps, Errors: %.1f%%, Bad response: %.1f%%, Good response: %.1f%%\n",
|
|
float64(s.counters.totalRequests.Load())/elapsed.Seconds(),
|
|
float64(s.counters.errors.Load())/float64(s.counters.totalRequests.Load())*100,
|
|
float64(s.counters.badReply.Load())/float64(s.counters.totalRequests.Load())*100,
|
|
float64(s.counters.goodReply.Load())/float64(s.counters.totalRequests.Load())*100)
|
|
}
|