Test port reassignment on darwin

main.go

package main

import (
	"flag"
	"fmt"
	"math"
	"net"
	"sort"
	"time"
)

func percentile(p float64, slice []int64) int64 {
	return int64(math.Floor(float64(len(slice)) * p))
}

func incrementErrCount(err error, errs map[error]int) {
	if err != nil {
		_, ok := errs[err]
		if !ok {
			errs[err] = 0
		}
		errs[err]++
	}
}

func main() {
	port := flag.Int("port", 30000, "port to attempt to reuse")
	attempts := flag.Int("attempts", 1000, "number of reuse attempts")
	flag.Parse()

	listenAddr := fmt.Sprintf(":%d", *port)
	dialAddr := fmt.Sprintf("127.0.0.1:%d", *port)
	errs := map[error]int{}

	var (
		start  time.Time
		end    time.Time
		dur    time.Duration
		delays []int64
		done   chan interface{}
	)

	delays = make([]int64, 0, *attempts)

	for i := 0; i < *attempts; i++ {
		start = time.Now()
		done = make(chan interface{})

		listener, err := net.Listen("tcp", listenAddr)
		incrementErrCount(err, errs)
		if err != nil {
			continue
		}

		go func() {
			conn, err := listener.Accept()
			incrementErrCount(err, errs)
			conn.Close()
			close(done)
		}()

		conn, _ := net.Dial("tcp", dialAddr)
		conn.Close()

		<-done

		end = time.Now()
		dur = end.Sub(start)
		delays = append(delays, dur.Nanoseconds())

		listener.Close()
	}

	sort.Slice(delays, func(i int, j int) bool { return delays[i] < delays[j] })

	fmt.Println("errors encountered:")
	for k, v := range errs {
		fmt.Printf("%v: %d\n", k, v)
	}

	fmt.Println("")

	fmt.Println("port re-assignment delay statistics:")
	fmt.Printf("median: %d ms", percentile(.50, delays)/int64(time.Millisecond))
	fmt.Printf("p90: %d ms", percentile(.90, delays)/int64(time.Millisecond))
	fmt.Printf("p99: %d ms", percentile(.99, delays)/int64(time.Millisecond))
}