Files
mtusi2026lab6/app/cmd/loadgen/main.go
T

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)
}