forked from mtusi2026/mtusi2026lab2
Начало реализации сервиса.
This commit is contained in:
@@ -0,0 +1,69 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"os"
|
||||
"os/signal"
|
||||
"syscall"
|
||||
|
||||
"gitea.privcloud.tech/mtusi2026/internal/adapter/controller/http"
|
||||
inmemory2 "gitea.privcloud.tech/mtusi2026/internal/adapter/repository/cache/inmemory"
|
||||
"gitea.privcloud.tech/mtusi2026/internal/config"
|
||||
)
|
||||
|
||||
func main() {
|
||||
if err := run(); err != nil {
|
||||
slog.Error("application stopped", "error", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
}
|
||||
|
||||
func run() error {
|
||||
cfg, err := config.LoadServer()
|
||||
if err != nil {
|
||||
return fmt.Errorf("load server config: %w", err)
|
||||
}
|
||||
|
||||
router := http.NewRouter()
|
||||
|
||||
userCache := inmemory2.NewUserCache()
|
||||
chatCache := inmemory2.NewChatCache(userCache)
|
||||
messageCache := inmemory2.NewMessageCache(chatCache)
|
||||
|
||||
server := http.New(cfg, router)
|
||||
|
||||
baseHandler := http.NewBaseHandler(router)
|
||||
healthHandler := http.NewHealthHandler(baseHandler, server)
|
||||
chatHandler := http.NewChatHandler(baseHandler, userCache, chatCache, messageCache)
|
||||
userHandler := http.NewUserHandler(baseHandler, userCache)
|
||||
|
||||
registerRoutes(
|
||||
healthHandler,
|
||||
chatHandler,
|
||||
userHandler,
|
||||
)
|
||||
|
||||
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
|
||||
defer stop()
|
||||
|
||||
if err := server.Start(ctx); err != nil {
|
||||
return fmt.Errorf("start HTTP server: %w", err)
|
||||
}
|
||||
slog.Info("HTTP server started", "address", cfg.BindAddress())
|
||||
|
||||
<-ctx.Done()
|
||||
shutdownCtx, cancel := context.WithTimeout(context.Background(), cfg.ShutdownTimeout)
|
||||
defer cancel()
|
||||
if err := server.Stop(shutdownCtx); err != nil {
|
||||
return fmt.Errorf("stop HTTP server: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func registerRoutes(handlers ...http.Handler) {
|
||||
for _, handler := range handlers {
|
||||
handler.RegisterRoutes()
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,386 @@
|
||||
// Command benchmark measures the lab1 HTTP API in fresh, resource-limited containers.
|
||||
package main
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"flag"
|
||||
"fmt"
|
||||
"io"
|
||||
"math"
|
||||
"net/http"
|
||||
"os"
|
||||
"os/exec"
|
||||
"path/filepath"
|
||||
"slices"
|
||||
"strconv"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
const (
|
||||
container = "mtusi-inmemory-benchmark"
|
||||
baseURL = "http://127.0.0.1:18093"
|
||||
)
|
||||
|
||||
type runResult struct {
|
||||
History int `json:"history"`
|
||||
Concurrency int `json:"concurrency"`
|
||||
Repetition int `json:"repetition"`
|
||||
ElapsedSeconds float64 `json:"elapsed_seconds"`
|
||||
ReadSuccess int `json:"read_success"`
|
||||
WriteSuccess int `json:"write_success"`
|
||||
Errors int `json:"errors"`
|
||||
SuccessfulRPS float64 `json:"successful_rps"`
|
||||
LatencyMS map[string]float64 `json:"latency_ms"`
|
||||
RSSBeforeKiB int `json:"rss_kib_before"`
|
||||
RSSPeakKiB int `json:"rss_kib_peak"`
|
||||
}
|
||||
|
||||
type report struct {
|
||||
Image string `json:"image"`
|
||||
Method map[string]any `json:"method"`
|
||||
Runs []runResult `json:"runs"`
|
||||
}
|
||||
|
||||
type workerResult struct {
|
||||
reads int
|
||||
writes int
|
||||
errors int
|
||||
latencies []float64
|
||||
}
|
||||
|
||||
type memoryResult struct {
|
||||
peak int
|
||||
err error
|
||||
}
|
||||
|
||||
func docker(args ...string) (string, error) {
|
||||
command := exec.Command("docker", args...)
|
||||
output, err := command.CombinedOutput()
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("docker %s: %w: %s", strings.Join(args, " "), err, strings.TrimSpace(string(output)))
|
||||
}
|
||||
return strings.TrimSpace(string(output)), nil
|
||||
}
|
||||
|
||||
func rssKiB() (int, error) {
|
||||
status, err := docker("exec", container, "cat", "/proc/1/status")
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
for line := range strings.SplitSeq(status, "\n") {
|
||||
if strings.HasPrefix(line, "VmRSS:") {
|
||||
fields := strings.Fields(line)
|
||||
return strconv.Atoi(fields[1])
|
||||
}
|
||||
}
|
||||
return 0, errors.New("VmRSS is unavailable")
|
||||
}
|
||||
|
||||
func newClient(timeout time.Duration) *http.Client {
|
||||
return &http.Client{
|
||||
Timeout: timeout,
|
||||
Transport: &http.Transport{
|
||||
MaxConnsPerHost: 1,
|
||||
MaxIdleConnsPerHost: 1,
|
||||
IdleConnTimeout: 30 * time.Second,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func request(client *http.Client, method, path, user string, body any) (map[string]any, error) {
|
||||
var data io.Reader
|
||||
if body != nil {
|
||||
encoded, err := json.Marshal(body)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
data = bytes.NewReader(encoded)
|
||||
}
|
||||
req, err := http.NewRequest(method, baseURL+path, data)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req.Header.Set("Accept", "application/json")
|
||||
if user != "" {
|
||||
req.Header.Set("X-User-Id", user)
|
||||
}
|
||||
if body != nil {
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
}
|
||||
response, err := client.Do(req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer response.Body.Close()
|
||||
content, err := io.ReadAll(io.LimitReader(response.Body, 1<<20))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if response.StatusCode != http.StatusOK && response.StatusCode != http.StatusCreated {
|
||||
return nil, fmt.Errorf("%s %s: HTTP %d: %s", method, path, response.StatusCode, content)
|
||||
}
|
||||
var payload map[string]any
|
||||
if err := json.Unmarshal(content, &payload); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return payload, nil
|
||||
}
|
||||
|
||||
func stringField(payload map[string]any, key string) (string, error) {
|
||||
value, ok := payload[key].(string)
|
||||
if !ok || value == "" {
|
||||
return "", fmt.Errorf("missing %s in API response", key)
|
||||
}
|
||||
return value, nil
|
||||
}
|
||||
|
||||
func percentile(sorted []float64, proportion float64) float64 {
|
||||
if len(sorted) == 0 {
|
||||
return 0
|
||||
}
|
||||
index := int(math.Ceil(float64(len(sorted))*proportion)) - 1
|
||||
if index < 0 {
|
||||
index = 0
|
||||
}
|
||||
return round(sorted[index], 3)
|
||||
}
|
||||
|
||||
func round(value float64, places int) float64 {
|
||||
shift := math.Pow10(places)
|
||||
return math.Round(value*shift) / shift
|
||||
}
|
||||
|
||||
func sampleMemory(stop <-chan struct{}, initial int, result chan<- memoryResult) {
|
||||
ticker := time.NewTicker(250 * time.Millisecond)
|
||||
defer ticker.Stop()
|
||||
peak := initial
|
||||
for {
|
||||
select {
|
||||
case <-stop:
|
||||
result <- memoryResult{peak: peak}
|
||||
return
|
||||
case <-ticker.C:
|
||||
rss, err := rssKiB()
|
||||
if err != nil {
|
||||
result <- memoryResult{err: err}
|
||||
return
|
||||
}
|
||||
peak = max(peak, rss)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func runCase(image string, history, concurrency, repetition int, duration time.Duration) (runResult, error) {
|
||||
row := runResult{History: history, Concurrency: concurrency, Repetition: repetition}
|
||||
if _, err := docker("run", "-d", "--name", container, "--cpus=1", "--memory=512m",
|
||||
"-p", "127.0.0.1:18093:8080", image); err != nil {
|
||||
return row, err
|
||||
}
|
||||
defer func() { _, _ = docker("rm", "-f", container) }()
|
||||
|
||||
setup := newClient(2 * time.Second)
|
||||
defer setup.CloseIdleConnections()
|
||||
readyDeadline := time.Now().Add(20 * time.Second)
|
||||
for {
|
||||
if _, err := request(setup, http.MethodGet, "/health/ready", "", nil); err == nil {
|
||||
break
|
||||
} else if time.Now().After(readyDeadline) {
|
||||
return row, fmt.Errorf("server did not become ready: %w", err)
|
||||
}
|
||||
time.Sleep(100 * time.Millisecond)
|
||||
}
|
||||
userResponse, err := request(setup, http.MethodPost, "/api/v1/users", "", map[string]any{
|
||||
"username": fmt.Sprintf("bench_%d_%d_%d", time.Now().UnixNano(), history, repetition),
|
||||
"display_name": "Benchmark",
|
||||
})
|
||||
if err != nil {
|
||||
return row, err
|
||||
}
|
||||
user, err := stringField(userResponse, "id")
|
||||
if err != nil {
|
||||
return row, err
|
||||
}
|
||||
chatResponse, err := request(setup, http.MethodPost, "/api/v1/chats", user, map[string]any{
|
||||
"title": "Benchmark", "member_ids": []string{user},
|
||||
})
|
||||
if err != nil {
|
||||
return row, err
|
||||
}
|
||||
chat, err := stringField(chatResponse, "id")
|
||||
if err != nil {
|
||||
return row, err
|
||||
}
|
||||
path := "/api/v1/chats/" + chat + "/messages"
|
||||
for index := range history {
|
||||
if _, err := request(setup, http.MethodPost, path, user, map[string]string{
|
||||
"text": fmt.Sprintf("seed-%d", index),
|
||||
}); err != nil {
|
||||
return row, fmt.Errorf("seed message %d: %w", index, err)
|
||||
}
|
||||
}
|
||||
row.RSSBeforeKiB, err = rssKiB()
|
||||
if err != nil {
|
||||
return row, err
|
||||
}
|
||||
|
||||
start := make(chan struct{})
|
||||
results := make(chan workerResult, concurrency)
|
||||
stopSampling := make(chan struct{})
|
||||
memory := make(chan memoryResult, 1)
|
||||
go sampleMemory(stopSampling, row.RSSBeforeKiB, memory)
|
||||
var group sync.WaitGroup
|
||||
group.Add(concurrency)
|
||||
deadline := time.Now().Add(duration)
|
||||
started := time.Now()
|
||||
for workerID := range concurrency {
|
||||
go func() {
|
||||
defer group.Done()
|
||||
local := newClient(5 * time.Second)
|
||||
defer local.CloseIdleConnections()
|
||||
result := workerResult{}
|
||||
<-start
|
||||
for index := 0; time.Now().Before(deadline); index++ {
|
||||
began := time.Now()
|
||||
var err error
|
||||
if index%10 == 0 {
|
||||
_, err = request(local, http.MethodPost, path, user, map[string]string{
|
||||
"text": fmt.Sprintf("load-%d-%d-%d", repetition, workerID, index),
|
||||
})
|
||||
if err == nil {
|
||||
result.writes++
|
||||
}
|
||||
} else {
|
||||
var page map[string]any
|
||||
page, err = request(local, http.MethodGet, path+"?limit=50", user, nil)
|
||||
if err == nil {
|
||||
items, ok := page["items"].([]any)
|
||||
if !ok || len(items) != 50 {
|
||||
err = errors.New("short first page")
|
||||
} else {
|
||||
result.reads++
|
||||
}
|
||||
}
|
||||
}
|
||||
if err != nil {
|
||||
result.errors++
|
||||
} else {
|
||||
result.latencies = append(result.latencies, float64(time.Since(began).Microseconds())/1000)
|
||||
}
|
||||
}
|
||||
results <- result
|
||||
}()
|
||||
}
|
||||
close(start)
|
||||
group.Wait()
|
||||
row.ElapsedSeconds = round(time.Since(started).Seconds(), 3)
|
||||
close(stopSampling)
|
||||
memorySample := <-memory
|
||||
if memorySample.err != nil {
|
||||
return row, memorySample.err
|
||||
}
|
||||
row.RSSPeakKiB = memorySample.peak
|
||||
if finalRSS, err := rssKiB(); err == nil {
|
||||
row.RSSPeakKiB = max(row.RSSPeakKiB, finalRSS)
|
||||
} else {
|
||||
return row, err
|
||||
}
|
||||
latencies := make([]float64, 0)
|
||||
for range concurrency {
|
||||
result := <-results
|
||||
row.ReadSuccess += result.reads
|
||||
row.WriteSuccess += result.writes
|
||||
row.Errors += result.errors
|
||||
latencies = append(latencies, result.latencies...)
|
||||
}
|
||||
if len(latencies) == 0 {
|
||||
return row, errors.New("no successful requests")
|
||||
}
|
||||
slices.Sort(latencies)
|
||||
row.SuccessfulRPS = round(float64(len(latencies))/row.ElapsedSeconds, 2)
|
||||
row.LatencyMS = map[string]float64{
|
||||
"p95": percentile(latencies, 0.95),
|
||||
"p99": percentile(latencies, 0.99),
|
||||
}
|
||||
return row, nil
|
||||
}
|
||||
|
||||
func parseValues(raw string, minimum int) ([]int, error) {
|
||||
values := make([]int, 0)
|
||||
for part := range strings.SplitSeq(raw, ",") {
|
||||
value, err := strconv.Atoi(strings.TrimSpace(part))
|
||||
if err != nil || value < minimum {
|
||||
return nil, fmt.Errorf("invalid value %q", part)
|
||||
}
|
||||
values = append(values, value)
|
||||
}
|
||||
return values, nil
|
||||
}
|
||||
|
||||
func save(path string, data report) error {
|
||||
encoded, err := json.MarshalIndent(data, "", " ")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
|
||||
return err
|
||||
}
|
||||
return os.WriteFile(path, append(encoded, '\n'), 0o644)
|
||||
}
|
||||
|
||||
func main() {
|
||||
image := flag.String("image", "", "Docker image to benchmark")
|
||||
output := flag.String("output", "", "JSON output path")
|
||||
historiesArg := flag.String("histories", "100,500,1500", "Comma-separated history sizes")
|
||||
concurrenciesArg := flag.String("concurrencies", "1,4,10", "Comma-separated client counts")
|
||||
repeats := flag.Int("repeats", 3, "Runs per combination")
|
||||
duration := flag.Duration("duration", 5*time.Second, "Measured duration per run")
|
||||
flag.Parse()
|
||||
if *image == "" || *output == "" || *repeats < 1 || *duration <= 0 {
|
||||
fmt.Fprintln(os.Stderr, "image, output, positive repeats and duration are required")
|
||||
os.Exit(2)
|
||||
}
|
||||
histories, err := parseValues(*historiesArg, 50)
|
||||
if err != nil {
|
||||
fmt.Fprintln(os.Stderr, err)
|
||||
os.Exit(2)
|
||||
}
|
||||
concurrencies, err := parseValues(*concurrenciesArg, 1)
|
||||
if err != nil {
|
||||
fmt.Fprintln(os.Stderr, err)
|
||||
os.Exit(2)
|
||||
}
|
||||
data := report{
|
||||
Image: *image,
|
||||
Method: map[string]any{
|
||||
"histories": histories, "concurrencies": concurrencies,
|
||||
"repeats": *repeats, "duration_seconds": duration.Seconds(),
|
||||
"mix": "90% first-page GET, 10% POST per client; persistent HTTP connections",
|
||||
"limits": "1 CPU, 512 MiB; fresh container and history per case",
|
||||
"rss": "VmRSS from /proc/1/status every 250 ms (sampled peak)",
|
||||
"latency": "successful requests only; errors counted separately; closed-loop workload",
|
||||
},
|
||||
Runs: make([]runResult, 0, len(histories)*len(concurrencies)*(*repeats)),
|
||||
}
|
||||
for _, history := range histories {
|
||||
for _, concurrency := range concurrencies {
|
||||
for repetition := 1; repetition <= *repeats; repetition++ {
|
||||
row, err := runCase(*image, history, concurrency, repetition, *duration)
|
||||
if err != nil {
|
||||
fmt.Fprintln(os.Stderr, err)
|
||||
os.Exit(1)
|
||||
}
|
||||
data.Runs = append(data.Runs, row)
|
||||
if err := save(*output, data); err != nil {
|
||||
fmt.Fprintln(os.Stderr, err)
|
||||
os.Exit(1)
|
||||
}
|
||||
encoded, _ := json.Marshal(row)
|
||||
fmt.Println(string(encoded))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user