96 lines
2.4 KiB
Go
96 lines
2.4 KiB
Go
package native_test
|
|
|
|
import (
|
|
"context"
|
|
"io"
|
|
"net"
|
|
"net/http"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
|
|
omni "git.yuntuo.hk/k2safe/go-omni"
|
|
"git.yuntuo.hk/k2safe/go-omni/transport/native"
|
|
netrouter "git.yuntuo.hk/k2safe/go-omni/transport/nethttp"
|
|
)
|
|
|
|
// BenchmarkNativeApplicationRequest measures the real TCP path with a reused
|
|
// client connection. It is intentionally separate from the in-process router
|
|
// benchmarks in transport/benchmark_test.go.
|
|
func BenchmarkNativeApplicationRequest(b *testing.B) {
|
|
application := omni.NewWithRouter(netrouter.New())
|
|
application.GET("/health", func(ctx *omni.Context) error {
|
|
return ctx.OK(map[string]string{"status": "ok"})
|
|
})
|
|
server := native.New(application)
|
|
server.MaxConnections = 1024
|
|
server.MaxConcurrentRequests = 1024
|
|
listener, err := net.Listen("tcp", "127.0.0.1:0")
|
|
if err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
done := make(chan error, 1)
|
|
go func() { done <- server.Serve(context.Background(), listener) }()
|
|
waitForBenchmarkServer(b, listener.Addr().String())
|
|
|
|
client := &http.Client{Transport: &http.Transport{
|
|
MaxIdleConns: 1024,
|
|
MaxIdleConnsPerHost: 1024,
|
|
IdleConnTimeout: time.Minute,
|
|
}}
|
|
endpoint := "http://" + listener.Addr().String() + "/health"
|
|
response, err := client.Get(endpoint)
|
|
if err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
_, _ = io.Copy(io.Discard, response.Body)
|
|
response.Body.Close()
|
|
|
|
var failed atomic.Bool
|
|
var failure atomic.Value
|
|
b.ReportAllocs()
|
|
b.ResetTimer()
|
|
b.RunParallel(func(pb *testing.PB) {
|
|
for pb.Next() {
|
|
response, err := client.Get(endpoint)
|
|
if err != nil {
|
|
if failed.CompareAndSwap(false, true) {
|
|
failure.Store(err.Error())
|
|
}
|
|
continue
|
|
}
|
|
_, _ = io.Copy(io.Discard, response.Body)
|
|
response.Body.Close()
|
|
}
|
|
})
|
|
b.StopTimer()
|
|
client.CloseIdleConnections()
|
|
shutdownContext, cancel := context.WithTimeout(context.Background(), time.Second)
|
|
defer cancel()
|
|
if err := server.Shutdown(shutdownContext); err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
if err := <-done; err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
if failed.Load() {
|
|
b.Fatalf("native request failed: %s", failure.Load().(string))
|
|
}
|
|
}
|
|
|
|
func waitForBenchmarkServer(b *testing.B, address string) {
|
|
b.Helper()
|
|
deadline := time.Now().Add(2 * time.Second)
|
|
for {
|
|
conn, err := net.DialTimeout("tcp", address, 50*time.Millisecond)
|
|
if err == nil {
|
|
conn.Close()
|
|
return
|
|
}
|
|
if time.Now().After(deadline) {
|
|
b.Fatalf("server did not start: %v", err)
|
|
}
|
|
time.Sleep(10 * time.Millisecond)
|
|
}
|
|
}
|