support booting PDS on a random port in testing (#193)

This patch makes PDS boot on a random port in the integration tests.
It's a first step towards #165 ("Integration tests need randomly
assigned ports") and request for feedback on its strategy before I apply
it to BDS.

To do this work, we have to teach `pds.Server` how to boot with an
existing net.Listener and teach its Echo instance to do the same. That
required using `Echo#StartServer` instead of `Echo#Start`. Using
`Echo#StartServer` seems to be the accepted pattern for booting from an
existing Listener in Echo and both it and `Start` call the same
`Echo#configureServer` under the hood.

PDS isn't a production service right now, but I believe I've reproduced
the
configuration that echo would have done that there wouldn't be
production
impact. However, if BGS is, we could talk about what feature flagging
we'd
like to prevent problems when this is applied there.

Along the way, we refactor the uses of the `TestPDS.host` field into
more explicit methods on `TestPDS`. I'm not completely sold on those
methods' names, but they seem handy.

Updates #165

pds/server.go

···
 	"encoding/json"
 	"errors"
 	"fmt"
+	"net"
+	"net/http"
 	"net/mail"
 	"net/url"
 	"strings"
···
 
 const UserActorDeclCid = "bafyreid27zk7lbis4zw5fz4podbvbs4fc5ivwji3dmrwa6zggnj4bnd57u"
 const UserActorDeclType = "app.bsky.system.actorUser"
+
+// serverListenerBootTimeout is how long to wait for the requested server socket
+// to become available for use. This is an arbitrary timeout that should be safe
+// on any platform, but there's no great way to weave this timeout without
+// adding another parameter to the (at time of writing) long signature of
+// NewServer.
+const serverListenerBootTimeout = 5 * time.Second
 
 func NewServer(db *gorm.DB, cs *carstore.CarStore, serkey *did.PrivKey, handleSuffix, serviceUrl string, didr plc.PLCClient, jwtkey []byte) (*Server, error) {
 	db.AutoMigrate(&User{})
···
 	return lexutil.CborDecodeValue(blk.RawData())
 }
 
-func (s *Server) RunAPI(listen string) error {
+func (s *Server) RunAPI(addr string) error {
+	var lc net.ListenConfig
+	ctx, cancel := context.WithTimeout(context.Background(), serverListenerBootTimeout)
+	defer cancel()
+
+	li, err := lc.Listen(ctx, "tcp", addr)
+	if err != nil {
+		return err
+	}
+	return s.RunAPIWithListener(li)
+}
+
+func (s *Server) RunAPIWithListener(listen net.Listener) error {
 	e := echo.New()
 	s.echo = e
 	e.HideBanner = true
···
 	e.GET("/xrpc/com.atproto.sync.subscribeRepos", s.EventsHandler)
 	e.GET("/xrpc/_health", s.HandleHealthCheck)
 
-	return e.Start(listen)
+	// In order to support booting on random ports in tests, we need to tell the
+	// Echo instance it's already got a port, and then use its StartServer
+	// method to re-use that listener.
+	e.Listener = listen
+	srv := &http.Server{}
+	return e.StartServer(srv)
 }
 
 type HealthStatus struct {

testing/integ_test.go

···
 	}
 	assert := assert.New(t)
 	didr := TestPLC(t)
-	p1 := MustSetupPDS(t, "localhost:5155", ".tpds", didr)
+	p1 := MustSetupPDS(t, ".tpds", didr)
 	p1.Run(t)
 
 	b1 := MustSetupBGS(t, "localhost:8231", didr)
···
 	assert := assert.New(t)
 	_ = assert
 	didr := TestPLC(t)
-	p1 := MustSetupPDS(t, "localhost:5185", ".pdsuno", didr)
+	p1 := MustSetupPDS(t, ".pdsuno", didr)
 	p1.Run(t)
 
-	p2 := MustSetupPDS(t, "localhost:5186", ".pdsdos", didr)
+	p2 := MustSetupPDS(t, ".pdsdos", didr)
 	p2.Run(t)
 
 	b1 := MustSetupBGS(t, "localhost:8281", didr)
···
 	assert := assert.New(t)
 	_ = assert
 	didr := TestPLC(t)
-	p1 := MustSetupPDS(t, "localhost:5195", ".pdsuno", didr)
+	p1 := MustSetupPDS(t, ".pdsuno", didr)
 	p1.Run(t)
 
-	p2 := MustSetupPDS(t, "localhost:5196", ".pdsdos", didr)
+	p2 := MustSetupPDS(t, ".pdsdos", didr)
 	p2.Run(t)
 
 	b1 := MustSetupBGS(t, "localhost:8291", didr)
···
 	assert := assert.New(t)
 	_ = assert
 	didr := TestPLC(t)
-	p1 := MustSetupPDS(t, "localhost:5385", ".pdsuno", didr)
+	p1 := MustSetupPDS(t, ".pdsuno", didr)
 	p1.Run(t)
 
 	b1 := MustSetupBGS(t, "localhost:8391", didr)
···
 	_ = assert
 
 	didr := TestPLC(t)
-	p1 := MustSetupPDS(t, "localhost:5151", ".tpds", didr)
+	p1 := MustSetupPDS(t, ".tpds", didr)
 	p1.Run(t)
 
 	b1 := MustSetupBGS(t, "localhost:3231", didr)
···
 	}
 	assert := assert.New(t)
 	didr := TestPLC(t)
-	p1 := MustSetupPDS(t, "localhost:9155", ".tpds", didr)
+	p1 := MustSetupPDS(t, ".tpds", didr)
 	p1.Run(t)
 
 	b1 := MustSetupBGS(t, "localhost:1531", didr)

testing/labelmaker_fakedata_test.go

···
 	_ = assert
 	ctx := context.TODO()
 	didr := TestPLC(t)
-	p1 := MustSetupPDS(t, "localhost:5115", ".tpds", didr)
+	p1 := MustSetupPDS(t, ".tpds", didr)
 	p1.Run(t)
 
 	b1 := MustSetupBGS(t, "localhost:8322", didr)

testing/pds_fakedata_test.go

···
 )
 
 const (
-	pdsHost       = "http://localhost:5159"
 	adminPassword = "admin"
 	celebCount    = 2
 	regularCount  = 5
···
 	}
 	assert := assert.New(t)
 	plcc := TestPLC(t)
-	pds := MustSetupPDS(t, "localhost:5159", ".test", plcc)
+	pds := MustSetupPDS(t, ".test", plcc)
 	pds.Run(t)
 
 	time.Sleep(time.Millisecond * 50)
 
-	catalog := genTestCatalog(t, pdsHost)
+	catalog := genTestCatalog(t, pds.HTTPHost())
 	combined := catalog.Combined()
 	testClient := util.TestingHTTPClient()
 
 	// generate profile, graph, posts
 	for _, acc := range combined {
-		xrpcc, err := fakedata.AccountXrpcClient(pdsHost, &acc)
+		xrpcc, err := fakedata.AccountXrpcClient(pds.HTTPHost(), &acc)
 		xrpcc.Client = testClient
 		if err != nil {
 			t.Fatal(err)
···
 
 	// generate interactions (additional posts, etc)
 	for _, acc := range combined {
-		xrpcc, err := fakedata.AccountXrpcClient(pdsHost, &acc)
+		xrpcc, err := fakedata.AccountXrpcClient(pds.HTTPHost(), &acc)
 		xrpcc.Client = testClient
 		if err != nil {
 			t.Fatal(err)
···
 
 	// do browsing (read-only)
 	for _, acc := range combined {
-		xrpcc, err := fakedata.AccountXrpcClient(pdsHost, &acc)
+		xrpcc, err := fakedata.AccountXrpcClient(pds.HTTPHost(), &acc)
 		xrpcc.Client = testClient
 		if err != nil {
 			t.Fatal(err)

testing/utils.go

···
 	"encoding/base32"
 	"fmt"
 	mathrand "math/rand"
+	"net"
 	"net/http"
 	"os"
 	"path/filepath"
···
 	"github.com/multiformats/go-multihash"
 	"github.com/whyrusleeping/go-did"
 
+	"net/url"
+
 	"github.com/gorilla/websocket"
 	"gorm.io/driver/sqlite"
 	"gorm.io/gorm"
···
 	server *pds.Server
 	plc    *api.PLCServer
 
-	host string
+	listener net.Listener
 
 	shutdown func()
 }
 
+// HTTPHost returns a host:port string that the PDS server is running at
+func (tp *TestPDS) RawHost() string {
+	return tp.listener.Addr().String()
+}
+
+// HTTPHost returns a URL string that the PDS server is running at with the
+// scheme set for HTTP
+func (tp *TestPDS) HTTPHost() string {
+	u := url.URL{Scheme: "http", Host: tp.listener.Addr().String()}
+	return u.String()
+}
+
 func (tp *TestPDS) Cleanup() {
 	if tp.shutdown != nil {
 		tp.shutdown()
···
 	}
 }
 
-func MustSetupPDS(t *testing.T, host, suffix string, plc plc.PLCClient) *TestPDS {
+func MustSetupPDS(t *testing.T, suffix string, plc plc.PLCClient) *TestPDS {
 	t.Helper()
-
-	tpds, err := SetupPDS(host, suffix, plc)
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	tpds, err := SetupPDS(ctx, suffix, plc)
 	if err != nil {
 		t.Fatal(err)
 	}
···
 	return tpds
 }
 
-func SetupPDS(host, suffix string, plc plc.PLCClient) (*TestPDS, error) {
+func SetupPDS(ctx context.Context, suffix string, plc plc.PLCClient) (*TestPDS, error) {
 	dir, err := os.MkdirTemp("", "integtest")
 	if err != nil {
 		return nil, err
···
 		Type: did.KeyTypeP256,
 	}
 
+	var lc net.ListenConfig
+	li, err := lc.Listen(ctx, "tcp", "localhost:0")
+	if err != nil {
+		return nil, err
+	}
+
+	host := li.Addr().String()
 	srv, err := pds.NewServer(maindb, cs, serkey, suffix, host, plc, []byte(host+suffix))
 	if err != nil {
 		return nil, err
 	}
 
 	return &TestPDS{
-		dir:    dir,
-		server: srv,
-		host:   host,
+		dir:      dir,
+		server:   srv,
+		listener: li,
 	}, nil
 }
 
 func (tp *TestPDS) Run(t *testing.T) {
 	// TODO: rig this up so it t.Fatals if the RunAPI call fails immediately
 	go func() {
-		if err := tp.server.RunAPI(tp.host); err != nil {
+		if err := tp.server.RunAPIWithListener(tp.listener); err != nil {
 			fmt.Println(err)
 		}
 	}()
···
 	t.Helper()
 
 	c := &xrpc.Client{Host: "http://" + b.host}
-	if err := atproto.SyncRequestCrawl(context.TODO(), c, tp.host); err != nil {
+	if err := atproto.SyncRequestCrawl(context.TODO(), c, tp.RawHost()); err != nil {
 		t.Fatal(err)
 	}
 }
···
 	ctx := context.TODO()
 
 	c := &xrpc.Client{
-		Host: "http://" + tp.host,
+		Host: tp.HTTPHost(),
 	}
 
 	fmt.Println("HOST: ", c.Host)