132 lines
2.9 KiB
Go
132 lines
2.9 KiB
Go
package main
|
|
|
|
import (
|
|
"flag"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
|
|
stdn "github.com/traetox/speedtest/speedtestdotnet"
|
|
)
|
|
|
|
const (
|
|
maxFailureCount = 3
|
|
initialTestCount = 5
|
|
basePingCount = 5
|
|
fullTestCount = 50
|
|
)
|
|
|
|
var (
|
|
speedtestDuration = flag.Int("t", 3, "Target duration for speedtests (in seconds)")
|
|
)
|
|
|
|
func init() {
|
|
flag.Parse()
|
|
if *speedtestDuration <= 0 {
|
|
fmt.Fprintf(os.Stderr, "Invalid test duration\n")
|
|
os.Exit(-1)
|
|
}
|
|
}
|
|
|
|
func main() {
|
|
cfg, err := stdn.GetConfig()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "error: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
if len(cfg.Servers) <= 0 {
|
|
fmt.Fprintf(os.Stderr, "No acceptable servers found\n")
|
|
os.Exit(1)
|
|
}
|
|
|
|
var testServers []stdn.Testserver
|
|
|
|
if testServers, err = autoGetTestServers(cfg); err != nil {
|
|
fmt.Fprintf(os.Stderr, "%s\n", err)
|
|
os.Exit(-1)
|
|
}
|
|
|
|
if len(testServers) == 0 {
|
|
fmt.Fprintf(os.Stderr, "insufficient test servers found\n")
|
|
os.Exit(1)
|
|
}
|
|
server := testServers[0]
|
|
if err = fullTest(server); err != nil {
|
|
if err == io.EOF {
|
|
fmt.Fprintf(os.Stderr, "Error, the remote server kicked us.\n")
|
|
fmt.Fprintf(os.Stderr, "Maximum request size may have changed\n")
|
|
} else {
|
|
fmt.Fprintf(os.Stderr, "Test failed with unknown error: %v\n", err)
|
|
}
|
|
os.Exit(-1)
|
|
}
|
|
}
|
|
|
|
func latency(server stdn.Testserver) (string, error) {
|
|
//perform a full latency test
|
|
durs, err := server.Ping(fullTestCount)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
var avg, max, min uint64
|
|
var latencies []float64
|
|
for i := range durs {
|
|
ms := uint64(durs[i].Nanoseconds() / 1000000)
|
|
latencies = append(latencies, float64(ms))
|
|
avg += ms
|
|
if ms > max {
|
|
max = ms
|
|
}
|
|
if ms < min || min == 0 {
|
|
min = ms
|
|
}
|
|
}
|
|
avg = avg / uint64(len(durs))
|
|
return fmt.Sprintf("min/avg/max = %d/%d/%d (ms)", min, avg, max), nil
|
|
}
|
|
|
|
func fullTest(server stdn.Testserver) error {
|
|
var err error
|
|
var lat string
|
|
if lat, err = latency(server); err != nil {
|
|
return err
|
|
}
|
|
fmt.Printf("latency: %s\n", lat)
|
|
|
|
up, err := server.Upstream(*speedtestDuration)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
down, err := server.Downstream(*speedtestDuration)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
fmt.Printf("bandwidth: up/down = %s/%s\n", stdn.HumanSpeed(up), stdn.HumanSpeed(down))
|
|
return nil
|
|
}
|
|
|
|
func autoGetTestServers(cfg *stdn.Config) ([]stdn.Testserver, error) {
|
|
//get the first 5 closest servers
|
|
testServers := []stdn.Testserver{}
|
|
failures := 0
|
|
for i := range cfg.Servers {
|
|
if failures >= maxFailureCount {
|
|
if len(testServers) > 0 {
|
|
return testServers, nil
|
|
}
|
|
return nil, fmt.Errorf("Failed to perform latency test on closest servers\n")
|
|
}
|
|
if len(testServers) >= initialTestCount {
|
|
return testServers, nil
|
|
}
|
|
//get a latency from the server, the last latency will also be store in the
|
|
//server structure
|
|
if _, err := cfg.Servers[i].MedianPing(basePingCount); err != nil {
|
|
failures++
|
|
continue
|
|
}
|
|
testServers = append(testServers, cfg.Servers[i])
|
|
}
|
|
return testServers, nil
|
|
}
|