Wait for domain proxy to start in tests.

Author: tecarter94

cmd/domainproxy/client/main.go

@@ -9,7 +9,9 @@ import (
 
 func main() {
 	domainProxyClient := NewDomainProxyClient()
-	domainProxyClient.Start()
+	ready := make(chan bool)
+	domainProxyClient.Start(ready)
+	<-ready
 	signals := make(chan os.Signal, 1)
 	signal.Notify(signals, syscall.SIGINT, syscall.SIGTERM)
 	<-signals

cmd/domainproxy/server/main.go

@@ -9,7 +9,9 @@ import (
 
 func main() {
 	domainProxyServer := NewDomainProxyServer()
-	domainProxyServer.Start()
+	ready := make(chan bool)
+	domainProxyServer.Start(ready)
+	<-ready
 	signals := make(chan os.Signal, 1)
 	signal.Notify(signals, syscall.SIGINT, syscall.SIGTERM)
 	<-signals

pkg/domainproxy/client/client.go

@@ -38,18 +38,19 @@ func NewDomainProxyClient() *DomainProxyClient {
 	}
 }
 
-func (dpc *DomainProxyClient) Start() {
+func (dpc *DomainProxyClient) Start(ready chan<- bool) {
 	logger.Println("Starting domain proxy client...")
 	var err error
-	dpc.listener, err = net.Listen("tcp", fmt.Sprintf("%s:%d", Localhost, dpc.serverHttpPort))
+	dpc.listener, err = net.Listen(TCP, fmt.Sprintf("%s:%d", Localhost, dpc.serverHttpPort))
 	if err != nil {
 		logger.Fatalf("Failed to start HTTP server: %v", err)
 	}
-	go dpc.startClient()
+	go dpc.startClient(ready)
 }
 
-func (dpc *DomainProxyClient) startClient() {
+func (dpc *DomainProxyClient) startClient(ready chan<- bool) {
 	logger.Printf("HTTP server listening on port %d", dpc.serverHttpPort)
+	ready <- true
 	for {
 		select {
 		case <-dpc.shutdownContext.Done():
@@ -74,7 +75,7 @@ func (dpc *DomainProxyClient) handleConnectionRequest(serverConnection net.Conn)
 	logger.Printf("Handling %s Connection %d", HttpToDomainSocket, connectionNo)
 	startTime := time.Now()
 	sharedParams := dpc.sharedParams
-	domainConnection, err := net.DialTimeout("unix", sharedParams.DomainSocket, sharedParams.ConnectionTimeout)
+	domainConnection, err := net.DialTimeout(UNIX, sharedParams.DomainSocket, sharedParams.ConnectionTimeout)
 	if err != nil {
 		logger.Printf("Failed to connect to domain socket: %v", err)
 		if err = serverConnection.Close(); err != nil {

pkg/domainproxy/common/common.go

@@ -21,6 +21,8 @@ const (
 	DefaultConnectionTimeout = 1000 * time.Millisecond
 	IdleTimeoutKey           = "IDLE_TIMEOUT"
 	DefaultIdleTimeout       = 30000 * time.Millisecond
+	TCP                      = "tcp"
+	UNIX                     = "unix"
 )
 
 type Common struct {

pkg/domainproxy/integration/domainproxy_test.go

@@ -85,9 +85,13 @@ func mockHandler(t *testing.T) http.HandlerFunc {
 
 func startDomainProxy() (*DomainProxyServer, *DomainProxyClient) {
 	domainProxyServer := NewDomainProxyServer()
-	go domainProxyServer.Start()
+	serverReady := make(chan bool)
+	go domainProxyServer.Start(serverReady)
+	<-serverReady
+	clientReady := make(chan bool)
 	domainProxyClient := NewDomainProxyClient()
-	go domainProxyClient.Start()
+	go domainProxyClient.Start(clientReady)
+	<-clientReady
 	return domainProxyServer, domainProxyClient
 }
 

pkg/domainproxy/server/server.go

@@ -71,24 +71,26 @@ func NewDomainProxyServer() *DomainProxyServer {
 	}
 }
 
-func (dps *DomainProxyServer) Start() {
+func (dps *DomainProxyServer) Start(ready chan<- bool) {
 	logger.Println("Starting domain proxy server...")
-	go dps.startServer()
-}
-
-func (dps *DomainProxyServer) startServer() {
 	sharedParams := dps.sharedParams
 	if _, err := os.Stat(sharedParams.DomainSocket); err == nil {
 		if err := os.Remove(sharedParams.DomainSocket); err != nil {
 			logger.Fatalf("Failed to delete existing domain socket: %v", err)
 		}
 	}
 	var err error
-	dps.listener, err = net.Listen("unix", sharedParams.DomainSocket)
+	dps.listener, err = net.Listen(UNIX, sharedParams.DomainSocket)
 	if err != nil {
 		logger.Fatalf("Failed to start domain socket listener: %v", err)
 	}
+	go dps.startServer(ready)
+}
+
+func (dps *DomainProxyServer) startServer(ready chan<- bool) {
+	sharedParams := dps.sharedParams
 	logger.Printf("Domain socket server listening on %s", sharedParams.DomainSocket)
+	ready <- true
 	for {
 		select {
 		case <-dps.runningContext.Done():
@@ -163,7 +165,7 @@ func (dps *DomainProxyServer) handleHttpConnection(sourceConnection net.Conn, wr
 			request.Header.Set("Proxy-Authorization", "Basic "+GetBasicAuth(dps.internalProxyUser, dps.internalProxyPassword))
 		}
 	}
-	targetConnection, err := net.DialTimeout("tcp", fmt.Sprintf("%s:%d", targetHost, targetPort), sharedParams.ConnectionTimeout)
+	targetConnection, err := net.DialTimeout(TCP, fmt.Sprintf("%s:%d", targetHost, targetPort), sharedParams.ConnectionTimeout)
 	if err != nil {
 		dps.handleErrorResponse(writer, err, fmt.Sprintf("Failed to connect to %s", targetConnectionName), false)
 		if err = sourceConnection.Close(); err != nil {
@@ -215,7 +217,7 @@ func (dps *DomainProxyServer) handleHttpsConnection(sourceConnection net.Conn, w
 	startTime := time.Now()
 	sharedParams := dps.sharedParams
 	request.Header.Set("Connection", "close")
-	targetConnection, err := net.DialTimeout("tcp", fmt.Sprintf("%s:%d", targetHost, targetPort), sharedParams.ConnectionTimeout)
+	targetConnection, err := net.DialTimeout(TCP, fmt.Sprintf("%s:%d", targetHost, targetPort), sharedParams.ConnectionTimeout)
 	if err != nil {
 		dps.handleErrorResponse(writer, err, fmt.Sprintf("Failed to connect to %s", targetConnectionName), true)
 		if err = sourceConnection.Close(); err != nil {