forked from mtusi2026/mtusi2026lab3
602 lines
23 KiB
Go
602 lines
23 KiB
Go
// loadgen — closed-loop генератор нагрузки для экспериментов с репликами.
|
|
//
|
|
// Смесь чтения истории и записи сообщений. Неподтверждённая запись повторяется с тем же
|
|
// Idempotency-Key, как у настоящего клиента. После прогона вся история сверяется с
|
|
// подтверждёнными сообщениями. Closed-loop занижает задержки при перегрузке (coordinated
|
|
// omission), поэтому результат показывает пропускную способность, а не задержку при заданной
|
|
// интенсивности. Токены и пароли не печатает.
|
|
//
|
|
// Запуск из корня проекта при поднятом стенде:
|
|
//
|
|
// docker compose --env-file .env --profile bench run --rm -T loadgen -duration 20s -concurrency 16
|
|
//
|
|
// Этапы: подготовка данных, прогрев, замер, сверка истории, запись результата.
|
|
// Код выхода ненулевой, если сверка нашла потери или дубли либо не смогла прочитать историю.
|
|
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"crypto/rand"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"flag"
|
|
"fmt"
|
|
"io"
|
|
mathrand "math/rand/v2"
|
|
"net/http"
|
|
"net/url"
|
|
"os"
|
|
"slices"
|
|
"strconv"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
// options — параметры запуска из флагов командной строки.
|
|
type options struct {
|
|
baseURL string
|
|
duration time.Duration
|
|
warmup time.Duration
|
|
concurrency int
|
|
writeShare float64
|
|
chats int
|
|
seed int
|
|
timeout time.Duration
|
|
label string
|
|
out string
|
|
}
|
|
|
|
// actor — один клиент API: токен его сессии и его чат. Токен хранится только в памяти.
|
|
type actor struct {
|
|
token string
|
|
chatID string
|
|
}
|
|
|
|
// confirmed — запись, на которую сервер ответил 201. После замера она обязана быть в истории:
|
|
// chat — индекс чата, id — ID сообщения, text — уникальный текст для поиска дублей.
|
|
type confirmed struct {
|
|
chat int
|
|
id string
|
|
text string
|
|
}
|
|
|
|
// workerStats заполняется одной горутиной, поэтому без блокировок.
|
|
// Поля: задержки успешных чтений и записей; ошибки по видам (код ответа или net);
|
|
// записи, подтверждённые после повтора; запросы по репликам; успехи и ошибки по секундам;
|
|
// время каждой ошибки; подтверждённые записи.
|
|
type workerStats struct {
|
|
reads, writes []time.Duration
|
|
errors map[string]int
|
|
retried int
|
|
instances map[string]int
|
|
secOK, secErr map[int]int
|
|
errTimes []time.Duration
|
|
confirmed []confirmed
|
|
}
|
|
|
|
// main разбирает флаги и запускает прогон. Значения по умолчанию рассчитаны на запуск в сети Docker.
|
|
func main() {
|
|
var o options
|
|
flag.StringVar(&o.baseURL, "base-url", "http://lb:8080", "адрес балансировщика")
|
|
flag.DurationVar(&o.duration, "duration", 30*time.Second, "длительность замера")
|
|
flag.DurationVar(&o.warmup, "warmup", 5*time.Second, "прогрев, не входит в замер")
|
|
flag.IntVar(&o.concurrency, "concurrency", 16, "число клиентов closed-loop")
|
|
flag.Float64Var(&o.writeShare, "write-share", 0.2, "доля записей")
|
|
flag.IntVar(&o.chats, "chats", 8, "число пар пользователь+чат")
|
|
flag.IntVar(&o.seed, "seed", 100, "начальных сообщений на чат")
|
|
flag.DurationVar(&o.timeout, "timeout", 5*time.Second, "таймаут запроса")
|
|
flag.StringVar(&o.label, "label", "", "метка прогона")
|
|
flag.StringVar(&o.out, "out", "", "файл для JSON-результата")
|
|
flag.Parse()
|
|
|
|
if err := run(o); err != nil {
|
|
fmt.Fprintln(os.Stderr, "loadgen:", err)
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
// run выполняет прогон целиком и возвращает ошибку, если проверка истории не пройдена.
|
|
func run(o options) error {
|
|
// Один общий клиент на всех. Запас простаивающих соединений нужен, чтобы клиенты повторно
|
|
// использовали их: иначе замер включал бы постоянную установку новых соединений.
|
|
client := &http.Client{
|
|
Timeout: o.timeout,
|
|
Transport: &http.Transport{
|
|
MaxIdleConns: o.concurrency * 2,
|
|
MaxIdleConnsPerHost: o.concurrency * 2,
|
|
IdleConnTimeout: 30 * time.Second,
|
|
},
|
|
}
|
|
// Подготовка до начала отсчёта: в замер не входит.
|
|
actors, err := setup(client, o)
|
|
if err != nil {
|
|
return fmt.Errorf("setup: %w", err)
|
|
}
|
|
|
|
// Границы замера. Клиенты работают и в прогреве, но запросы до measureFrom не учитываются.
|
|
start := time.Now()
|
|
measureFrom := start.Add(o.warmup)
|
|
end := measureFrom.Add(o.duration)
|
|
// Скрипты отказов ждут эту строку, чтобы привязать действия ко времени замера.
|
|
go func() {
|
|
time.Sleep(o.warmup)
|
|
fmt.Printf("measure_start unix=%d\n", time.Now().Unix())
|
|
}()
|
|
|
|
// У каждого клиента своя статистика и своя горутина. Общие данные появляются только после wg.Wait.
|
|
stats := make([]*workerStats, o.concurrency)
|
|
var wg sync.WaitGroup
|
|
for i := range o.concurrency {
|
|
stats[i] = newWorkerStats()
|
|
wg.Add(1)
|
|
go func() {
|
|
defer wg.Done()
|
|
work(client, o, i, actors, measureFrom, end, stats[i])
|
|
}()
|
|
}
|
|
wg.Wait()
|
|
|
|
// Сверка идёт уже после нагрузки, поэтому на RPS она не влияет.
|
|
res := summarize(o, stats)
|
|
res.Verify = verify(client, o, actors, stats)
|
|
if err := writeResult(o, res); err != nil {
|
|
return err
|
|
}
|
|
// Результат записан и при неудаче: так можно разобрать, что именно пошло не так.
|
|
if res.Verify.Error != "" || res.Verify.Lost > 0 || res.Verify.DuplicateIDs > 0 || res.Verify.DuplicateTexts > 0 {
|
|
return fmt.Errorf("проверка истории не пройдена: %+v", res.Verify)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// newWorkerStats создаёт пустую статистику клиента.
|
|
func newWorkerStats() *workerStats {
|
|
return &workerStats{
|
|
errors: map[string]int{},
|
|
instances: map[string]int{},
|
|
secOK: map[int]int{},
|
|
secErr: map[int]int{},
|
|
}
|
|
}
|
|
|
|
// work — цикл одного клиента до конца замера (closed-loop): следующий запрос уходит только
|
|
// после ответа на предыдущий. Клиенты равномерно распределены по чатам.
|
|
func work(client *http.Client, o options, worker int, actors []actor, from, end time.Time, st *workerStats) {
|
|
chat := worker % len(actors)
|
|
a := actors[chat]
|
|
path := "/api/v1/chats/" + a.chatID + "/messages"
|
|
// Свой генератор у каждого клиента: общий потребовал бы блокировки.
|
|
rng := mathrand.New(mathrand.NewPCG(uint64(worker), uint64(time.Now().UnixNano())))
|
|
|
|
// observe учитывает результат одного запроса и возвращает true, если он успешен. В замер
|
|
// входит только запрос, начатый после прогрева и завершившийся до конца замера. lat — куда
|
|
// записать задержку успешного запроса, want — ожидаемый код ответа.
|
|
observe := func(began time.Time, status int, instance string, err error, want int, lat *[]time.Duration) bool {
|
|
now := time.Now()
|
|
measured := !began.Before(from) && now.Before(end)
|
|
// Номер секунды замера: из него строится посекундная шкала.
|
|
sec := int(now.Sub(from) / time.Second)
|
|
if err == nil && status == want {
|
|
if measured {
|
|
*lat = append(*lat, now.Sub(began))
|
|
st.instances[instance]++
|
|
st.secOK[sec]++
|
|
}
|
|
return true
|
|
}
|
|
if measured {
|
|
// net — ответа не было вообще (обрыв, таймаут), иначе вид ошибки — код ответа.
|
|
kind := "net"
|
|
if err == nil {
|
|
kind = strconv.Itoa(status)
|
|
}
|
|
st.errors[kind]++
|
|
st.secErr[sec]++
|
|
st.errTimes = append(st.errTimes, now.Sub(from))
|
|
}
|
|
return false
|
|
}
|
|
|
|
for seq := 0; time.Now().Before(end); seq++ {
|
|
// Чтение первой страницы истории. После ошибки короткая пауза, чтобы не долбить сервер в цикле.
|
|
if rng.Float64() >= o.writeShare {
|
|
began := time.Now()
|
|
status, inst, _, err := do(client, o, http.MethodGet, path+"?limit=50", a.token, "", nil)
|
|
if !observe(began, status, inst, err, http.StatusOK, &st.reads) {
|
|
time.Sleep(50 * time.Millisecond)
|
|
}
|
|
continue
|
|
}
|
|
// Запись: новый ключ идемпотентности и уникальный текст, по которому видны дубли.
|
|
key := randomHex(16)
|
|
text := fmt.Sprintf("w-%d-%d-%s", worker, seq, key[:8])
|
|
// Неопределённый результат повторяется с исходным ключом и телом.
|
|
// Цикл повторов. При обрыве клиент не знает, записал ли сервер сообщение, поэтому повторяет
|
|
// с теми же ключом и текстом: сервер должен вернуть то же сообщение, а не создать новое.
|
|
for attempt := 0; time.Now().Before(end); attempt++ {
|
|
began := time.Now()
|
|
status, inst, body, err := do(client, o, http.MethodPost, path, a.token, key, map[string]string{"text": text})
|
|
if observe(began, status, inst, err, http.StatusCreated, &st.writes) {
|
|
var m struct {
|
|
ID string `json:"id"`
|
|
}
|
|
if json.Unmarshal(body, &m) == nil {
|
|
st.confirmed = append(st.confirmed, confirmed{chat: chat, id: m.ID, text: text})
|
|
}
|
|
// Запись подтвердилась только с повтора: это видно в результате.
|
|
if attempt > 0 {
|
|
st.retried++
|
|
}
|
|
break
|
|
}
|
|
time.Sleep(100 * time.Millisecond)
|
|
}
|
|
}
|
|
}
|
|
|
|
// do выполняет один HTTP-запрос с таймаутом и возвращает код, реплику из X-Instance-Id, тело
|
|
// и ошибку сети. payload кодируется в JSON; пустые token и key не добавляют заголовки.
|
|
func do(client *http.Client, o options, method, path, token, key string, payload any) (int, string, []byte, error) {
|
|
var body io.Reader
|
|
if payload != nil {
|
|
b, err := json.Marshal(payload)
|
|
if err != nil {
|
|
return 0, "", nil, err
|
|
}
|
|
body = bytes.NewReader(b)
|
|
}
|
|
ctx, cancel := context.WithTimeout(context.Background(), o.timeout)
|
|
defer cancel()
|
|
req, err := http.NewRequestWithContext(ctx, method, o.baseURL+path, body)
|
|
if err != nil {
|
|
return 0, "", nil, err
|
|
}
|
|
if payload != nil {
|
|
req.Header.Set("Content-Type", "application/json")
|
|
}
|
|
if token != "" {
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
}
|
|
if key != "" {
|
|
req.Header.Set("Idempotency-Key", key)
|
|
}
|
|
resp, err := client.Do(req)
|
|
if err != nil {
|
|
return 0, "", nil, err
|
|
}
|
|
defer resp.Body.Close()
|
|
// Тело читается полностью: иначе соединение нельзя использовать повторно.
|
|
data, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return 0, "", nil, err
|
|
}
|
|
return resp.StatusCode, resp.Header.Get("X-Instance-Id"), data, nil
|
|
}
|
|
|
|
// setup параллельно создаёт пользователей и чаты для всех участников нагрузки.
|
|
func setup(client *http.Client, o options) ([]actor, error) {
|
|
actors := make([]actor, o.chats)
|
|
errs := make([]error, o.chats)
|
|
var wg sync.WaitGroup
|
|
for i := range o.chats {
|
|
wg.Add(1)
|
|
go func() {
|
|
defer wg.Done()
|
|
actors[i], errs[i] = setupActor(client, o)
|
|
}()
|
|
}
|
|
wg.Wait()
|
|
for _, err := range errs {
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return actors, nil
|
|
}
|
|
|
|
// setupActor создаёт одного участника: пользователь, вход, чат и начальные сообщения.
|
|
// Имена и пароли случайные и нигде не печатаются.
|
|
func setupActor(client *http.Client, o options) (actor, error) {
|
|
username, password := "lg_"+randomHex(8), "T3st-"+randomHex(16)
|
|
status, _, body, err := do(client, o, http.MethodPost, "/api/v1/users", "", "",
|
|
map[string]string{"username": username, "display_name": "Load", "password": password})
|
|
if err != nil || status != http.StatusCreated {
|
|
return actor{}, fmt.Errorf("create user: status %d: %v", status, err)
|
|
}
|
|
var user struct {
|
|
ID string `json:"id"`
|
|
}
|
|
if err := json.Unmarshal(body, &user); err != nil {
|
|
return actor{}, err
|
|
}
|
|
|
|
// Вход выполняется через Basic: пользователь получает токен сессии.
|
|
req, err := http.NewRequest(http.MethodPost, o.baseURL+"/api/v1/auth/sessions", nil)
|
|
if err != nil {
|
|
return actor{}, err
|
|
}
|
|
req.SetBasicAuth(username, password)
|
|
resp, err := client.Do(req)
|
|
if err != nil {
|
|
return actor{}, fmt.Errorf("login: %w", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
var session struct {
|
|
Token string `json:"token"`
|
|
}
|
|
if resp.StatusCode != http.StatusCreated {
|
|
return actor{}, fmt.Errorf("login: status %d", resp.StatusCode)
|
|
}
|
|
if err := json.NewDecoder(resp.Body).Decode(&session); err != nil {
|
|
return actor{}, err
|
|
}
|
|
|
|
status, _, body, err = do(client, o, http.MethodPost, "/api/v1/chats", session.Token, "",
|
|
map[string]any{"title": "Load", "member_ids": []string{user.ID}})
|
|
if err != nil || status != http.StatusCreated {
|
|
return actor{}, fmt.Errorf("create chat: status %d: %v", status, err)
|
|
}
|
|
var chat struct {
|
|
ID string `json:"id"`
|
|
}
|
|
if err := json.Unmarshal(body, &chat); err != nil {
|
|
return actor{}, err
|
|
}
|
|
|
|
// Начальные сообщения, чтобы чтение первой страницы возвращало полноценный ответ.
|
|
for i := range o.seed {
|
|
status, _, _, err := do(client, o, http.MethodPost, "/api/v1/chats/"+chat.ID+"/messages", session.Token,
|
|
randomHex(16), map[string]string{"text": fmt.Sprintf("seed-%d", i)})
|
|
if err != nil || status != http.StatusCreated {
|
|
return actor{}, fmt.Errorf("seed: status %d: %v", status, err)
|
|
}
|
|
}
|
|
return actor{token: session.Token, chatID: chat.ID}, nil
|
|
}
|
|
|
|
// verifyResult — итог сверки истории с подтверждёнными записями.
|
|
type verifyResult struct {
|
|
Confirmed int `json:"confirmed"`
|
|
Lost int `json:"lost"`
|
|
DuplicateIDs int `json:"duplicate_ids"`
|
|
DuplicateTexts int `json:"duplicate_texts"`
|
|
Error string `json:"error,omitempty"`
|
|
}
|
|
|
|
// verify читает всю историю каждого чата и сверяет её с подтверждёнными записями.
|
|
// Потеря — подтверждённого ID нет в истории. Дубль — ID или текст встретился дважды.
|
|
func verify(client *http.Client, o options, actors []actor, stats []*workerStats) verifyResult {
|
|
var res verifyResult
|
|
// Какие ID должны быть в каждом чате.
|
|
wanted := make([]map[string]bool, len(actors))
|
|
for i := range wanted {
|
|
wanted[i] = map[string]bool{}
|
|
}
|
|
for _, st := range stats {
|
|
for _, c := range st.confirmed {
|
|
wanted[c.chat][c.id] = true
|
|
res.Confirmed++
|
|
}
|
|
}
|
|
// История читается постранично по курсору, с запасом на временные ошибки.
|
|
for chat, a := range actors {
|
|
ids, texts := map[string]bool{}, map[string]bool{}
|
|
cursor := ""
|
|
for {
|
|
q := "?limit=100"
|
|
if cursor != "" {
|
|
q += "&cursor=" + url.QueryEscape(cursor)
|
|
}
|
|
status, _, body, err := getWithRetry(client, o, "/api/v1/chats/"+a.chatID+"/messages"+q, a.token)
|
|
if err != nil || status != http.StatusOK {
|
|
res.Error = fmt.Sprintf("read history: status %d: %v", status, err)
|
|
return res
|
|
}
|
|
var page struct {
|
|
Items []struct {
|
|
ID string `json:"id"`
|
|
Text string `json:"text"`
|
|
} `json:"items"`
|
|
NextCursor *string `json:"next_cursor"`
|
|
}
|
|
if err := json.Unmarshal(body, &page); err != nil {
|
|
res.Error = "decode history: " + err.Error()
|
|
return res
|
|
}
|
|
for _, m := range page.Items {
|
|
if ids[m.ID] {
|
|
res.DuplicateIDs++
|
|
}
|
|
ids[m.ID] = true
|
|
if texts[m.Text] {
|
|
res.DuplicateTexts++
|
|
}
|
|
texts[m.Text] = true
|
|
}
|
|
if page.NextCursor == nil {
|
|
break
|
|
}
|
|
cursor = *page.NextCursor
|
|
}
|
|
// Всё, что было подтверждено, должно найтись.
|
|
for id := range wanted[chat] {
|
|
if !ids[id] {
|
|
res.Lost++
|
|
}
|
|
}
|
|
}
|
|
return res
|
|
}
|
|
|
|
// getWithRetry повторяет чтение до 5 раз: сразу после отказа реплики сверка не должна падать
|
|
// из-за временной ошибки.
|
|
func getWithRetry(client *http.Client, o options, path, token string) (int, string, []byte, error) {
|
|
var (
|
|
status int
|
|
inst string
|
|
body []byte
|
|
err error
|
|
)
|
|
for range 5 {
|
|
status, inst, body, err = do(client, o, http.MethodGet, path, token, "", nil)
|
|
if err == nil && status == http.StatusOK {
|
|
break
|
|
}
|
|
time.Sleep(500 * time.Millisecond)
|
|
}
|
|
return status, inst, body, err
|
|
}
|
|
|
|
// latency — задержки успешных запросов одного вида, в миллисекундах.
|
|
type latency struct {
|
|
Count int `json:"count"`
|
|
P50 float64 `json:"p50_ms"`
|
|
P95 float64 `json:"p95_ms"`
|
|
P99 float64 `json:"p99_ms"`
|
|
}
|
|
|
|
// incident — эпизод ошибок: начало, длительность и количество.
|
|
type incident struct {
|
|
StartS float64 `json:"start_s"`
|
|
DurationS float64 `json:"duration_s"`
|
|
Errors int `json:"errors"`
|
|
}
|
|
|
|
// second — одна секунда шкалы: успехи и ошибки.
|
|
type second struct {
|
|
T int `json:"t"`
|
|
OK int `json:"ok"`
|
|
Err int `json:"err"`
|
|
}
|
|
|
|
// result — итог прогона. Он записывается в JSON и разбирается скриптами сводок.
|
|
type result struct {
|
|
Label string `json:"label"`
|
|
Concurrency int `json:"concurrency"`
|
|
WriteShare float64 `json:"write_share"`
|
|
Chats int `json:"chats"`
|
|
Seed int `json:"seed_per_chat"`
|
|
DurationS float64 `json:"duration_s"`
|
|
WarmupS float64 `json:"warmup_s"`
|
|
RPS float64 `json:"successful_rps"`
|
|
ReadRPS float64 `json:"read_rps"`
|
|
WriteRPS float64 `json:"write_rps"`
|
|
ErrorShare float64 `json:"error_share"`
|
|
Errors map[string]int `json:"errors"`
|
|
RetriedWrites int `json:"writes_confirmed_after_retry"`
|
|
Read latency `json:"read"`
|
|
Write latency `json:"write"`
|
|
Instances map[string]int `json:"requests_per_instance"`
|
|
Incidents []incident `json:"error_incidents"`
|
|
SecondsNoOK int `json:"seconds_without_success"`
|
|
Verify verifyResult `json:"verify"`
|
|
Timeline []second `json:"timeline,omitempty"`
|
|
}
|
|
|
|
// summarize объединяет статистику всех клиентов и считает показатели замера.
|
|
func summarize(o options, stats []*workerStats) result {
|
|
res := result{
|
|
Label: o.label, Concurrency: o.concurrency, WriteShare: o.writeShare, Chats: o.chats, Seed: o.seed,
|
|
DurationS: o.duration.Seconds(), WarmupS: o.warmup.Seconds(),
|
|
Errors: map[string]int{}, Instances: map[string]int{},
|
|
}
|
|
var reads, writes, errTimes []time.Duration
|
|
secOK, secErr := map[int]int{}, map[int]int{}
|
|
for _, st := range stats {
|
|
reads = append(reads, st.reads...)
|
|
writes = append(writes, st.writes...)
|
|
errTimes = append(errTimes, st.errTimes...)
|
|
res.RetriedWrites += st.retried
|
|
for k, v := range st.errors {
|
|
res.Errors[k] += v
|
|
}
|
|
for k, v := range st.instances {
|
|
res.Instances[k] += v
|
|
}
|
|
for k, v := range st.secOK {
|
|
secOK[k] += v
|
|
}
|
|
for k, v := range st.secErr {
|
|
secErr[k] += v
|
|
}
|
|
}
|
|
res.Read, res.Write = percentiles(reads), percentiles(writes)
|
|
secs := o.duration.Seconds()
|
|
// RPS учитывает только успешные запросы.
|
|
res.ReadRPS = float64(len(reads)) / secs
|
|
res.WriteRPS = float64(len(writes)) / secs
|
|
res.RPS = res.ReadRPS + res.WriteRPS
|
|
if total := len(reads) + len(writes) + len(errTimes); total > 0 {
|
|
res.ErrorShare = float64(len(errTimes)) / float64(total)
|
|
}
|
|
res.Incidents = incidents(errTimes, time.Second)
|
|
// Шкала за все секунды, включая пустые: секунда без успехов — признак полной недоступности.
|
|
for t := range int(secs) {
|
|
res.Timeline = append(res.Timeline, second{T: t, OK: secOK[t], Err: secErr[t]})
|
|
if secOK[t] == 0 {
|
|
res.SecondsNoOK++
|
|
}
|
|
}
|
|
return res
|
|
}
|
|
|
|
// percentiles считает p50, p95, p99 по отсортированным задержкам. Метод ближайшего ранга:
|
|
// значение берётся из данных, без интерполяции.
|
|
func percentiles(d []time.Duration) latency {
|
|
if len(d) == 0 {
|
|
return latency{}
|
|
}
|
|
slices.Sort(d)
|
|
at := func(p float64) float64 {
|
|
i := min(int(float64(len(d))*p), len(d)-1)
|
|
return float64(d[i].Microseconds()) / 1000
|
|
}
|
|
return latency{Count: len(d), P50: at(0.50), P95: at(0.95), P99: at(0.99)}
|
|
}
|
|
|
|
// incidents объединяет ошибки с разрывом меньше gap в один эпизод.
|
|
func incidents(times []time.Duration, gap time.Duration) []incident {
|
|
times = slices.Clone(times)
|
|
slices.Sort(times)
|
|
out := []incident{}
|
|
for i, t := range times {
|
|
if i == 0 || t-times[i-1] >= gap {
|
|
out = append(out, incident{StartS: t.Seconds()})
|
|
}
|
|
last := &out[len(out)-1]
|
|
last.Errors++
|
|
last.DurationS = t.Seconds() - last.StartS
|
|
}
|
|
return out
|
|
}
|
|
|
|
// writeResult пишет полный JSON в файл, а краткую версию без шкалы печатает на экран.
|
|
func writeResult(o options, res result) error {
|
|
full, err := json.MarshalIndent(res, "", " ")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if o.out != "" {
|
|
if err := os.WriteFile(o.out, append(full, '\n'), 0o644); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
res.Timeline = nil
|
|
brief, err := json.Marshal(res)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
fmt.Println(string(brief))
|
|
return nil
|
|
}
|
|
|
|
// randomHex возвращает n случайных байт в hex. Без случайности нет смысла продолжать, поэтому panic.
|
|
func randomHex(n int) string {
|
|
b := make([]byte, n)
|
|
if _, err := rand.Read(b); err != nil {
|
|
panic(err)
|
|
}
|
|
return hex.EncodeToString(b)
|
|
}
|