Add web.NewListener()

Author: ecnepsnai

.github/workflows/go.yml

@@ -16,9 +16,9 @@ jobs:
       - uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8 # [email protected]
 
       - name: Set up Go
-        uses: actions/setup-go@268d8c0ca0432bb2cf416faae41297df9d262d7f # pin@v3.3.0
+        uses: actions/setup-go@d0a58c1c4d2b25278816e339b944508c875f3613 # pin@v3.4.0
         with:
-          go-version: 1.19.2
+          go-version: 1.19.4
 
       - name: Build
         run: go build -v ./...

server.go

@@ -13,10 +13,9 @@ import (
 
 // Server describes an web server
 type Server struct {
-	// The socket address that the server will listen to. Must be in the format of "address:port", such as
-	// "localhost:8080" or "0.0.0.0:8080". Changing this after the server has started has no effect.
+	// The socket address that the server is listening on. Only populated if the server was created with web.New().
 	BindAddress string
-	// The port that this server is listening on.
+	// The port that this server is listening on. Only populated if the server was created with web.New().
 	ListenPort uint16
 	// The API instance that is used to register JSON endpoints.
 	API API
@@ -51,7 +50,8 @@ type ServerOptions struct {
 	IgnoreHTTPRangeRequests bool
 }
 
-// New create a new server object that will bind to the provided address. Does not start the service automatically.
+// New create a new server object that will bind to the provided address. Does not accept incoming connections until
+// the server is started.
 // Bind address must be in the format of "address:port", such as "localhost:8080" or "0.0.0.0:8080".
 func New(bindAddress string) *Server {
 	httpRouter := router.New()
@@ -76,24 +76,51 @@ func New(bindAddress string) *Server {
 	return &server
 }
 
+// NewListener creates a new server object that will use the given listener. Does not accept incoming connections until
+// the server is started.
+func NewListener(listener net.Listener) *Server {
+	httpRouter := router.New()
+	server := Server{
+		Options: ServerOptions{
+			RequestLogLevel: logtic.LevelDebug,
+		},
+		router:    httpRouter,
+		listener:  listener,
+		limits:    map[string]*rate.Limiter{},
+		limitLock: &sync.Mutex{},
+	}
+	httpRouter.SetNotFoundHandle(server.notFoundHandle)
+	httpRouter.SetMethodNotAllowedHandle(server.methodNotAllowedHandle)
+	server.API = API{
+		server: &server,
+	}
+	server.HTTP = HTTP{
+		server: &server,
+	}
+
+	return &server
+}
+
 // Start will start the web server and listen on the socket address. This method blocks.
 // If a server is stopped using the Stop() method, this returns no error.
 func (s *Server) Start() error {
-	listener, err := net.Listen("tcp", s.BindAddress)
-	if err != nil {
-		log.PError("Error listening on address", map[string]interface{}{
+	if s.BindAddress != "" {
+		listener, err := net.Listen("tcp", s.BindAddress)
+		if err != nil {
+			log.PError("Error listening on address", map[string]interface{}{
+				"listen_address": s.BindAddress,
+				"error":          err.Error(),
+			})
+			return err
+		}
+		s.listener = listener
+		s.ListenPort = uint16(listener.Addr().(*net.TCPAddr).Port)
+		log.PInfo("HTTP server listen", map[string]interface{}{
 			"listen_address": s.BindAddress,
-			"error":          err.Error(),
+			"listen_port":    s.ListenPort,
 		})
-		return err
 	}
-	s.listener = listener
-	s.ListenPort = uint16(listener.Addr().(*net.TCPAddr).Port)
-	log.PInfo("HTTP server listen", map[string]interface{}{
-		"listen_address": s.BindAddress,
-		"listen_port":    s.ListenPort,
-	})
-	if err := s.router.Serve(listener); err != nil {
+	if err := s.router.Serve(s.listener); err != nil {
 		if s.shuttingDown {
 			log.Info("HTTP server stopped")
 			return nil

server_test.go

@@ -1,16 +1,64 @@
 package web_test
 
 import (
+	"context"
 	"fmt"
 	"io"
+	"net"
 	"net/http"
+	"path"
 	"strings"
 	"testing"
 	"time"
 
 	"github.com/ecnepsnai/web"
 )
 
+func TestUnixSocket(t *testing.T) {
+	t.Parallel()
+	socketPath := path.Join(t.TempDir(), "TestUnixSocket")
+	l, err := net.Listen("unix", socketPath)
+	if err != nil {
+		t.Fatalf("Error starting unix socket: %s", err.Error())
+	}
+	server := web.NewListener(l)
+	go server.Start()
+	time.Sleep(5 * time.Millisecond)
+
+	handle := func(request web.Request) (interface{}, *web.Error) {
+		return true, nil
+	}
+	options := web.HandleOptions{}
+
+	path1 := "path1"
+	path2 := "path2"
+
+	server.API.GET("/"+path1, handle, options)
+
+	httpc := http.Client{
+		Transport: &http.Transport{
+			DialContext: func(_ context.Context, _, _ string) (net.Conn, error) {
+				return net.Dial("unix", socketPath)
+			},
+		},
+	}
+
+	check := func(path string, expected int) {
+		resp, err := httpc.Get(fmt.Sprintf("http://unix/%s", path))
+		if err != nil {
+			t.Fatalf("Network error: %s", err.Error())
+		}
+
+		if resp.StatusCode != expected {
+			body, _ := io.ReadAll(resp.Body)
+			t.Fatalf("Unexpected status code for %s. Expected %d got %d: %s", path, expected, resp.StatusCode, body)
+		}
+	}
+
+	check(path1, 200)
+	check(path2, 404)
+}
+
 func TestRestartServer(t *testing.T) {
 	t.Parallel()
 	server := newServer()

util.go

@@ -32,16 +32,10 @@ func getIPFromRemoteAddr(remoteAddr string) string {
 // stripPortFromSocketAddr strip the port from a socket address (address:port, return address)
 func stripPortFromSocketAddr(socketAddr string) string {
 	length := len(socketAddr)
-	if socketAddr[length-6] == ':' {
-		return socketAddr[0 : length-6]
-	} else if socketAddr[length-5] == ':' {
-		return socketAddr[0 : length-5]
-	} else if socketAddr[length-4] == ':' {
-		return socketAddr[0 : length-4]
-	} else if socketAddr[length-3] == ':' {
-		return socketAddr[0 : length-3]
-	} else if socketAddr[length-2] == ':' {
-		return socketAddr[0 : length-2]
+	for i := length - 1; i >= 0; i-- {
+		if socketAddr[i] == ':' {
+			return socketAddr[0:i]
+		}
 	}
 
 	return socketAddr

util_test.go

@@ -14,6 +14,10 @@ func TestGetIPFromRemoteAddr(t *testing.T) {
 	if ip := getIPFromRemoteAddr("[1::1]:4233"); ip != "1::1" {
 		t.Errorf("Incorrect result for IP address. Expected: %s Actual: %s", "1::1", ip)
 	}
+
+	if ip := getIPFromRemoteAddr("@"); ip != "@" {
+		t.Errorf("Incorrect result for invalid IP address. Expected: %s Actual %s", "@", ip)
+	}
 }
 
 func BenchmarkGetIPFromRemoteAddr(b *testing.B) {

web_example_test.go

@@ -1,6 +1,7 @@
 package web_test
 
 import (
+	"net"
 	"net/http"
 	"os"
 	"time"
@@ -158,3 +159,22 @@ func Example_ratelimit() {
 		panic(err)
 	}
 }
+
+func Example_unixsocket() {
+	l, err := net.Listen("unix", "/example.socket")
+	if err != nil {
+		panic(err)
+	}
+	server := web.NewListener(l)
+
+	handle := func(request web.Request) (interface{}, *web.Error) {
+		return time.Now().Unix(), nil
+	}
+
+	options := web.HandleOptions{}
+	server.API.GET("/time", handle, options)
+
+	if err := server.Start(); err != nil {
+		panic(err)
+	}
+}