Merge pull request #18 from basemachina/dynamic-connection-check-port

Make connection check server port dynamic

Author: taro-28

bridge.go

@@ -3,6 +3,7 @@ package bridge
 import (
 	"context"
 	"fmt"
+	"net"
 	"net/http"
 	"time"
 
@@ -14,17 +15,17 @@ import (
 )
 
 const (
-	OKPath    = "/ok"
-	OKMessage = "bridge is ready"
-	ProxyPath = "/htproxy"
+	OKPath                           = "/ok"
+	OKMessage                        = "bridge is ready"
+	ProxyPath                        = "/htproxy"
+	GetCheckConnectionServerAddrPath = "/get_check_connection_server_addr"
 )
 
 // Env stores configuration settings extract from enviromental variables
 // The practice getting from environmental variables comes from https://12factor.net.
 type Env struct {
 	// Port is port to listen HTTP server. Default is 8080.
-	// This value should be other than 4321. because "127.0.0.1:4321" is used in connection checking.
-	Port string `envconfig:"PORT" default:"8080" description:"bridge を HTTP としてサーブするために利用します。4321 以外を指定してください。"`
+	Port string `envconfig:"PORT" default:"8080" description:"bridge を HTTP としてサーブするために利用します。"`
 
 	// LogLevel is INFO or DEBUG. Default is "INFO".
 	LogLevel string `envconfig:"LOG_LEVEL" default:"INFO"`
@@ -44,23 +45,23 @@ type Env struct {
 
 // HTTPHandlerConfig is a config to setup bridge http handler.
 type HTTPHandlerConfig struct {
-	Logger             logr.Logger
-	PublicKeyGetter    auth.PublicKeyGetter
-	RegisterUserObject auth.TenantIDGetter
-	TenantID           string
-	Middlewares        []bridgehttp.Middleware
+	Logger                    logr.Logger
+	PublicKeyGetter           auth.PublicKeyGetter
+	RegisterUserObject        auth.TenantIDGetter
+	TenantID                  string
+	Middlewares               []bridgehttp.Middleware
+	CheckConnectionServerAddr string
 }
 
 // NewHTTPHandler is a handler for handling any requests.
 func NewHTTPHandler(c *HTTPHandlerConfig) http.Handler {
 	mux := http.NewServeMux()
-	mux.HandleFunc(OKPath, func(w http.ResponseWriter, r *http.Request) {
-		if r.Method != http.MethodGet {
-			w.WriteHeader(http.StatusMethodNotAllowed)
-			return
-		}
+	mux.HandleFunc(fmt.Sprintf("GET %s", OKPath), func(w http.ResponseWriter, r *http.Request) {
 		w.Write([]byte(OKMessage))
 	})
+	mux.HandleFunc(fmt.Sprintf("GET %s", GetCheckConnectionServerAddrPath), func(w http.ResponseWriter, r *http.Request) {
+		w.Write([]byte(c.CheckConnectionServerAddr))
+	})
 	middlewares := append(c.Middlewares,
 		ctxtime.Middleware(),
 		auth.Middleware(&auth.MiddlewareConfig{
@@ -77,20 +78,12 @@ func NewHTTPHandler(c *HTTPHandlerConfig) http.Handler {
 	return mux
 }
 
-// ConnectionCheckPort is used in connection check from API.
-const ConnectionCheckPort = "4321"
-
 func NewHTTPServer(envPort string, handler http.Handler) (*http.Server, func(), error) {
-	if envPort == ConnectionCheckPort {
-		return nil, nil, fmt.Errorf("PORT env should be other than 4321")
-	}
 	srv := &http.Server{
 		Addr:    ":" + envPort,
 		Handler: handler,
 	}
 
-	ServeCheckConnectionServer()
-
 	return srv, func() {
 		ctx, cancel := context.WithTimeout(
 			context.Background(),
@@ -108,14 +101,19 @@ func NewHTTPServer(envPort string, handler http.Handler) (*http.Server, func(),
 // because used only the connection check from API.
 //
 // Serve with goroutine.
-func ServeCheckConnectionServer() {
+func ServeCheckConnectionServer() (addr string, err error) {
+	ln, err := net.Listen("tcp", ":0")
+	if err != nil {
+		return "", fmt.Errorf("failed to listen a port for connection check: %w", err)
+	}
+
 	go func() {
-		err := http.ListenAndServe(
-			":"+ConnectionCheckPort,
-			http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				w.Write([]byte(OKMessage))
-			}),
-		)
+		srv := &http.Server{Addr: addr, Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Write([]byte(OKMessage))
+		})}
+		err := srv.Serve(ln)
 		panic(fmt.Errorf("failed to serve a server to check connection from API: %w", err))
 	}()
+
+	return ln.Addr().String(), nil
 }

bridge_test.go

@@ -10,6 +10,8 @@ import (
 
 func TestNewHTTPHandler(t *testing.T) {
 	t.Run("ok path", func(t *testing.T) {
+		t.Parallel()
+
 		h := NewHTTPHandler(&HTTPHandlerConfig{
 			Logger: testlogr.Logger,
 		})
@@ -24,4 +26,24 @@ func TestNewHTTPHandler(t *testing.T) {
 			t.Fatalf("want message %q but got %q", OKMessage, got)
 		}
 	})
+
+	t.Run("get check connection server addr path", func(t *testing.T) {
+		t.Parallel()
+
+		const addr = "127.0.0.1:4321"
+		h := NewHTTPHandler(&HTTPHandlerConfig{
+			Logger:                    testlogr.Logger,
+			CheckConnectionServerAddr: addr,
+		})
+		req := httptest.NewRequest("GET", GetCheckConnectionServerAddrPath, nil)
+		rec := httptest.NewRecorder()
+		h.ServeHTTP(rec, req)
+
+		if rec.Code != http.StatusOK {
+			t.Fatalf("want status code %d but got %d", http.StatusOK, rec.Code)
+		}
+		if got := rec.Body.String(); addr != got {
+			t.Fatalf("want message %q but got %q", addr, got)
+		}
+	})
 }

cmd/bridge/container.go

@@ -27,11 +27,16 @@ func BridgeContainerProvider() (*Container, func(), error) {
 	if err != nil {
 		return nil, nil, err
 	}
+	checkConnectionServerAddr, err := bridge.ServeCheckConnectionServer()
+	if err != nil {
+		return nil, nil, err
+	}
 	httpHandlerConfig := &bridge.HTTPHandlerConfig{
-		Logger:             logger,
-		PublicKeyGetter:    fetchWorker,
-		TenantID:           env.TenantID,
-		RegisterUserObject: auth.User{},
+		Logger:                    logger,
+		PublicKeyGetter:           fetchWorker,
+		TenantID:                  env.TenantID,
+		RegisterUserObject:        auth.User{},
+		CheckConnectionServerAddr: checkConnectionServerAddr,
 	}
 	handler := bridge.NewHTTPHandler(httpHandlerConfig)
 	server, cleanup3, err := bridge.NewHTTPServer(env.Port, handler)

go.mod

@@ -1,6 +1,6 @@
 module github.com/basemachina/bridge
 
-go 1.21.9
+go 1.22.4
 
 require (
 	github.com/go-logr/logr v1.2.2