"read tcp xxxxxxx:xxxxx->43.206.244.116:443: use of closed network connection". Why is this?

[KenwayZY]

An error message was reported. After I initialized an order client and a cancel order client, I started a delay test. The test stopped after 3 minutes due to an error message: "read tcp xxxxxxx:xxxxx->43.206.244.116:443: use of closed network connection". Why is this?

[sc0Vu]

@KenwayZY The connection was closed. Could you paste how you did it?

[KenwayZY]

@KenwayZY The connection was closed. Could you paste how you did it?
package main

import (
"fmt"
"os"
"sync"
"time"

"github.com/adshao/go-binance/v2/futures"
"github.com/google/uuid"

)

// Client configuration structure
type ClientConfig struct {
APIKey string
SecretKey string
Name string
}

// Latency measurement structure
type Latency struct {
ClientName string
WSConnectTime time.Duration
OrderPlaceTime time.Duration
OrderCancelTime time.Duration
}

// Test session structure, including reusable WebSocket services
type TestSession struct {
Config ClientConfig
OrderPlaceWsService *futures.OrderPlaceWsService
OrderCancelWsService *futures.OrderCancelWsService
}

// Test results statistics structure
type TestResults struct {
Interval string
AverageLatencies map[string]Latency // Organized by client name
}

func main() {
// Configure 3 different API keys
configs := []ClientConfig{
{
APIKey: "",
SecretKey: "",
Name: "Client1",
},
{
APIKey: "",
SecretKey: "",
Name: "Client2",
},
{
APIKey: "",
SecretKey: "",
Name: "Client3",
},
}

// Initialize test sessions (create and reuse WebSocket clients)
sessions := initTestSessions(configs)
if len(sessions) == 0 {
	fmt.Println("Could not initialize any WebSocket clients, program terminated")
	return
}

// Store all test results
var allResults []TestResults

// 1. Test once every 10 seconds, 50 times in total, calculate average
fmt.Println("Starting test cycle with 10-second intervals...")
tenSecResults := runMultipleTests(sessions, 10*time.Second, 50)
allResults = append(allResults, TestResults{
	Interval: "10 seconds",
	AverageLatencies: tenSecResults,
})

// 2. Test once every 30 seconds, 50 times in total, calculate average
fmt.Println("Starting test cycle with 30-second intervals...")
thirtySecResults := runMultipleTests(sessions, 30*time.Second, 50)
allResults = append(allResults, TestResults{
	Interval: "30 seconds",
	AverageLatencies: thirtySecResults,
})

// 3. Test once every 2 minutes, 50 times in total, calculate average
fmt.Println("Starting test cycle with 2-minute intervals...")
twoMinResults := runMultipleTests(sessions, 2*time.Minute, 50)
allResults = append(allResults, TestResults{
	Interval: "2 minutes",
	AverageLatencies: twoMinResults,
})

// Output and save results
displayResults(allResults)
saveResultsToFile(allResults, "binance_ws_test_results.txt")

fmt.Println("Testing completed, detailed results have been saved to binance_ws_test_results.txt file")

}

// Initialize all test sessions, create reusable WebSocket connections
func initTestSessions(configs []ClientConfig) []*TestSession {
var sessions []*TestSession

for _, cfg := range configs {
	// Create WebSocket order placement service
	orderPlaceWsService, err := futures.NewOrderPlaceWsService(cfg.APIKey, cfg.SecretKey)
	if err != nil {
		fmt.Printf("Client %s failed to create WebSocket order placement service: %v\n", cfg.Name, err)
		continue
	}
	
	// Create WebSocket order cancellation service
	orderCancelWsService, err := futures.NewOrderCancelWsService(cfg.APIKey, cfg.SecretKey)
	if err != nil {
		fmt.Printf("Client %s failed to create WebSocket order cancellation service: %v\n", cfg.Name, err)
		continue
	}
	
	sessions = append(sessions, &TestSession{
		Config: cfg,
		OrderPlaceWsService: orderPlaceWsService,
		OrderCancelWsService: orderCancelWsService,
	})
	
	fmt.Printf("Client %s WebSocket connection has been initialized\n", cfg.Name)
}

return sessions

}

// Perform multiple tests and calculate average
func runMultipleTests(sessions []*TestSession, interval time.Duration, count int) map[string]Latency {
// Cumulative latency organized by client name
cumulativeLatencies := make(map[string]Latency)
// Counter to record the number of tests for each client
testCounts := make(map[string]int)

for i := 0; i < count; i++ {
	fmt.Printf("[Test %d/%d]\n", i+1, count)
	
	// Perform one complete test (all clients test concurrently)
	latencies := runSingleTest(sessions)
	
	// Accumulate latency data
	for clientName, latency := range latencies {
		if _, exists := cumulativeLatencies[clientName]; !exists {
			cumulativeLatencies[clientName] = Latency{
				ClientName: clientName,
			}
		}
		
		current := cumulativeLatencies[clientName]
		current.WSConnectTime += latency.WSConnectTime
		current.OrderPlaceTime += latency.OrderPlaceTime 
		current.OrderCancelTime += latency.OrderCancelTime
		cumulativeLatencies[clientName] = current
		testCounts[clientName]++
	}
	
	// If not the last test, wait for the interval time
	if i < count-1 {
		fmt.Printf("Waiting %v before the next test...\n", interval)
		time.Sleep(interval)
	}
}

// Calculate averages
avgLatencies := make(map[string]Latency)
for clientName, cumulative := range cumulativeLatencies {
	testCount := testCounts[clientName]
	if testCount > 0 {
		avgLatencies[clientName] = Latency{
			ClientName: clientName,
			WSConnectTime: cumulative.WSConnectTime / time.Duration(testCount),
			OrderPlaceTime: cumulative.OrderPlaceTime / time.Duration(testCount),
			OrderCancelTime: cumulative.OrderCancelTime / time.Duration(testCount),
		}
	}
}

return avgLatencies

}

// Run a single test (all clients concurrently)
func runSingleTest(sessions []*TestSession) map[string]Latency {
var wg sync.WaitGroup
results := make(chan Latency, len(sessions))

// Execute operations for all clients concurrently
for _, session := range sessions {
	wg.Add(1)
	go func(sess *TestSession) {
		defer wg.Add(-1)
		
		// Test using reusable WebSocket client
		latency := testClientOrderOperations(sess)
		results <- latency
	}(session)
}

// Wait for all operations to complete in another goroutine and close the results channel
go func() {
	wg.Wait()
	close(results)
}()

// Collect all results
latencies := make(map[string]Latency)
for latency := range results {
	latencies[latency.ClientName] = latency
}

return latencies

}

// Test client operations (reuse WebSocket client)
func testClientOrderOperations(session *TestSession) Latency {
latency := Latency{
ClientName: session.Config.Name,
}

fmt.Printf("Starting test for client: %s\n", session.Config.Name)

// 1. Since WebSocket connection is already initialized, set WebSocket connection time to 0
latency.WSConnectTime = 0 * time.Nanosecond

// 2. Prepare order placement request
requestID := uuid.New().String()
orderRequest := futures.NewOrderPlaceWsRequest().
	Symbol("USDCUSDT").
	Side(futures.SideTypeBuy).
	PositionSide(futures.PositionSideTypeLong).
	Type(futures.OrderTypeLimit).
	TimeInForce(futures.TimeInForceTypeGTC).
	Quantity("6").  // Adjust quantity according to actual situation
	Price("0.97").
	NewOrderResponseType(futures.NewOrderRespTypeRESULT)

// 3. Execute order placement request and measure time
startTime := time.Now()
orderResponse, err := session.OrderPlaceWsService.SyncDo(requestID, orderRequest)
latency.OrderPlaceTime = time.Since(startTime)

if err != nil {
	fmt.Printf("Client %s failed to place order: %v\n", session.Config.Name, err)
	return latency
}

if orderResponse.Error != nil {
	fmt.Printf("Client %s API error when placing order: %v\n", session.Config.Name, orderResponse.Error)
	return latency
}

orderID := orderResponse.Result.OrderID
fmt.Printf("Client %s successfully placed order: OrderID=%v, Time=%v\n", session.Config.Name, orderID, latency.OrderPlaceTime)

// 4. Prepare order cancellation request
cancelRequestID := uuid.New().String()
idNum := int64(orderID)
cancelRequest := futures.NewOrderCancelRequest().
	Symbol("USDCUSDT").
	OrderID(idNum)

// 5. Execute order cancellation request and measure time
startTime = time.Now()
cancelResponse, err := session.OrderCancelWsService.SyncDo(cancelRequestID, cancelRequest)
latency.OrderCancelTime = time.Since(startTime)

if err != nil {
	fmt.Printf("Client %s failed to cancel order: %v\n", session.Config.Name, err)
	return latency
}

if cancelResponse.Error != nil {
	fmt.Printf("Client %s API error when cancelling order: %v\n", session.Config.Name, cancelResponse.Error)
	return latency
}

fmt.Printf("Client %s successfully cancelled order: OrderID=%v, Time=%v\n", session.Config.Name, cancelResponse.Result.OrderID, latency.OrderCancelTime)

return latency

}

// Display test results
func displayResults(results []TestResults) {
fmt.Println("\nTest Results Summary:")

for _, result := range results {
	fmt.Printf("\nInterval: %s (Average of 50 tests)\n", result.Interval)
	fmt.Println("Client\t\tWS Connection Time\t\tOrder Placement Time\t\tOrder Cancellation Time")
	fmt.Println("------------------------------------------------------------")
	
	for _, lat := range result.AverageLatencies {
		fmt.Printf("%s\t\t%v\t\t%v\t\t%v\n", 
			lat.ClientName, 
			lat.WSConnectTime, 
			lat.OrderPlaceTime, 
			lat.OrderCancelTime)
	}
}

}

// Save results to file
func saveResultsToFile(results []TestResults, filename string) error {
file, err := os.Create(filename)
if err != nil {
return err
}
defer file.Close()

// Write title
file.WriteString("Binance WebSocket API Latency Test Results\n")
file.WriteString("Test Time: " + time.Now().Format("2006-01-02 15:04:05") + "\n\n")

// Write each group of test results
for _, result := range results {
	file.WriteString("========================================\n")
	file.WriteString(fmt.Sprintf("Test Interval: %s (Average of 50 tests)\n", result.Interval))
	file.WriteString("----------------------------------------\n")
	file.WriteString("Client\t\tWS Connection Time\t\tOrder Placement Time\t\tOrder Cancellation Time\n")
	
	for _, lat := range result.AverageLatencies {
		file.WriteString(fmt.Sprintf("%s\t\t%v\t\t%v\t\t%v\n", 
			lat.ClientName, 
			lat.WSConnectTime, 
			lat.OrderPlaceTime, 
			lat.OrderCancelTime))
	}
	file.WriteString("\n")
}

return nil

}
apitest.go.txt

[feeeei]

@KenwayZY
I have found the problem, you should be using the old version, updating to the latest version should solve it, here is the PR to fix the issue: #693

[druphliu]

I have updated the new version,but this error still occurred。And this mistake often occurs as well：websocket: close 1001 (going away)