157 lines
4.5 KiB
Go
157 lines
4.5 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"time"
|
|
|
|
"next.orly.dev/app/config"
|
|
"next.orly.dev/pkg/run"
|
|
)
|
|
|
|
// func TestDumbClientWorkaround(t *testing.T) {
|
|
// var relay *run.Relay
|
|
// var err error
|
|
|
|
// // Start local relay for testing
|
|
// if relay, _, err = startWorkaroundTestRelay(); err != nil {
|
|
// t.Fatalf("Failed to start test relay: %v", err)
|
|
// }
|
|
// defer func() {
|
|
// if stopErr := relay.Stop(); stopErr != nil {
|
|
// t.Logf("Error stopping relay: %v", stopErr)
|
|
// }
|
|
// }()
|
|
|
|
// relayURL := "ws://127.0.0.1:3338"
|
|
|
|
// // Wait for relay to be ready
|
|
// if err = waitForRelay(relayURL, 10*time.Second); err != nil {
|
|
// t.Fatalf("Relay not ready after timeout: %v", err)
|
|
// }
|
|
|
|
// t.Logf("Relay is ready at %s", relayURL)
|
|
|
|
// // Test connection with a "dumb" client that doesn't handle ping/pong properly
|
|
// dialer := websocket.Dialer{
|
|
// HandshakeTimeout: 10 * time.Second,
|
|
// }
|
|
|
|
// conn, _, err := dialer.Dial(relayURL, nil)
|
|
// if err != nil {
|
|
// t.Fatalf("Failed to connect: %v", err)
|
|
// }
|
|
// defer conn.Close()
|
|
|
|
// t.Logf("Connection established")
|
|
|
|
// // Simulate a dumb client that sets a short read deadline and doesn't handle ping/pong
|
|
// conn.SetReadDeadline(time.Now().Add(30 * time.Second))
|
|
|
|
// startTime := time.Now()
|
|
// messageCount := 0
|
|
|
|
// // The connection should stay alive despite the short client-side deadline
|
|
// // because our workaround sets a 24-hour server-side deadline
|
|
// connectionFailed := false
|
|
// for time.Since(startTime) < 2*time.Minute && !connectionFailed {
|
|
// // Extend client deadline every 10 seconds (simulating dumb client behavior)
|
|
// if time.Since(startTime).Seconds() > 10 && int(time.Since(startTime).Seconds())%10 == 0 {
|
|
// conn.SetReadDeadline(time.Now().Add(30 * time.Second))
|
|
// t.Logf("Dumb client extended its own deadline")
|
|
// }
|
|
|
|
// // Try to read with a short timeout to avoid blocking
|
|
// conn.SetReadDeadline(time.Now().Add(1 * time.Second))
|
|
|
|
// // Use a function to catch panics from ReadMessage on failed connections
|
|
// func() {
|
|
// defer func() {
|
|
// if r := recover(); r != nil {
|
|
// if panicMsg, ok := r.(string); ok && panicMsg == "repeated read on failed websocket connection" {
|
|
// t.Logf("Connection failed, stopping read loop")
|
|
// connectionFailed = true
|
|
// return
|
|
// }
|
|
// // Re-panic if it's a different panic
|
|
// panic(r)
|
|
// }
|
|
// }()
|
|
|
|
// msgType, data, err := conn.ReadMessage()
|
|
// conn.SetReadDeadline(time.Now().Add(30 * time.Second)) // Reset
|
|
|
|
// if err != nil {
|
|
// if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
|
|
// // Timeout is expected - just continue
|
|
// time.Sleep(100 * time.Millisecond)
|
|
// return
|
|
// }
|
|
// if websocket.IsCloseError(err, websocket.CloseNormalClosure, websocket.CloseGoingAway) {
|
|
// t.Logf("Connection closed normally: %v", err)
|
|
// connectionFailed = true
|
|
// return
|
|
// }
|
|
// t.Errorf("Unexpected error: %v", err)
|
|
// connectionFailed = true
|
|
// return
|
|
// }
|
|
|
|
// messageCount++
|
|
// t.Logf("Received message %d: type=%d, len=%d", messageCount, msgType, len(data))
|
|
// }()
|
|
// }
|
|
|
|
// elapsed := time.Since(startTime)
|
|
// if elapsed < 90*time.Second {
|
|
// t.Errorf("Connection died too early after %v (expected at least 90s)", elapsed)
|
|
// } else {
|
|
// t.Logf("Workaround successful: connection lasted %v with %d messages", elapsed, messageCount)
|
|
// }
|
|
// }
|
|
|
|
// startWorkaroundTestRelay starts a relay for workaround testing
|
|
func startWorkaroundTestRelay() (relay *run.Relay, port int, err error) {
|
|
cfg := &config.C{
|
|
AppName: "ORLY-WORKAROUND-TEST",
|
|
DataDir: "",
|
|
Listen: "127.0.0.1",
|
|
Port: 3338,
|
|
HealthPort: 0,
|
|
EnableShutdown: false,
|
|
LogLevel: "info",
|
|
DBLogLevel: "warn",
|
|
DBBlockCacheMB: 512,
|
|
DBIndexCacheMB: 256,
|
|
LogToStdout: false,
|
|
PprofHTTP: false,
|
|
ACLMode: "none",
|
|
AuthRequired: false,
|
|
AuthToWrite: false,
|
|
SubscriptionEnabled: false,
|
|
MonthlyPriceSats: 6000,
|
|
FollowListFrequency: time.Hour,
|
|
WebDisableEmbedded: false,
|
|
SprocketEnabled: false,
|
|
SpiderMode: "none",
|
|
PolicyEnabled: false,
|
|
}
|
|
|
|
// Set default data dir if not specified
|
|
if cfg.DataDir == "" {
|
|
cfg.DataDir = fmt.Sprintf("/tmp/orly-workaround-test-%d", time.Now().UnixNano())
|
|
}
|
|
|
|
// Create options
|
|
cleanup := true
|
|
opts := &run.Options{
|
|
CleanupDataDir: &cleanup,
|
|
}
|
|
|
|
// Start relay
|
|
if relay, err = run.Start(cfg, opts); err != nil {
|
|
return nil, 0, fmt.Errorf("failed to start relay: %w", err)
|
|
}
|
|
|
|
return relay, cfg.Port, nil
|
|
}
|