move HTTP utilities in a dedicated package (#2123)

needed by #2068

internal/httpserv/middleware_logger.go

@@ -0,0 +1,55 @@
+package httpserv
+
+import (
+	"bytes"
+	"fmt"
+	"net/http"
+	"net/http/httputil"
+
+	"github.com/gin-gonic/gin"
+
+	"github.com/bluenviron/mediamtx/internal/logger"
+)
+
+type loggerWriter struct {
+	gin.ResponseWriter
+	buf bytes.Buffer
+}
+
+func (w *loggerWriter) Write(b []byte) (int, error) {
+	w.buf.Write(b)
+	return w.ResponseWriter.Write(b)
+}
+
+func (w *loggerWriter) WriteString(s string) (int, error) {
+	w.buf.WriteString(s)
+	return w.ResponseWriter.WriteString(s)
+}
+
+func (w *loggerWriter) dump() string {
+	var buf bytes.Buffer
+	fmt.Fprintf(&buf, "%s %d %s\n", "HTTP/1.1", w.ResponseWriter.Status(), http.StatusText(w.ResponseWriter.Status()))
+	w.ResponseWriter.Header().Write(&buf)
+	buf.Write([]byte("\n"))
+	if w.buf.Len() > 0 {
+		fmt.Fprintf(&buf, "(body of %d bytes)", w.buf.Len())
+	}
+	return buf.String()
+}
+
+// MiddlewareLogger is a middleware that logs requests and responses.
+func MiddlewareLogger(p logger.Writer) func(*gin.Context) {
+	return func(ctx *gin.Context) {
+		p.Log(logger.Debug, "[conn %v] %s %s", ctx.Request.RemoteAddr, ctx.Request.Method, ctx.Request.URL.Path)
+
+		byts, _ := httputil.DumpRequest(ctx.Request, true)
+		p.Log(logger.Debug, "[conn %v] [c->s] %s", ctx.Request.RemoteAddr, string(byts))
+
+		logw := &loggerWriter{ResponseWriter: ctx.Writer}
+		ctx.Writer = logw
+
+		ctx.Next()
+
+		p.Log(logger.Debug, "[conn %v] [s->c] %s", ctx.Request.RemoteAddr, logw.dump())
+	}
+}

internal/httpserv/middleware_server_header.go

@@ -0,0 +1,11 @@
+package httpserv
+
+import (
+	"github.com/gin-gonic/gin"
+)
+
+// MiddlewareServerHeader is a middleware that sets the Server header.
+func MiddlewareServerHeader(ctx *gin.Context) {
+	ctx.Writer.Header().Set("Server", "mediamtx")
+	ctx.Next()
+}

internal/httpserv/wrapped_server.go

@@ -0,0 +1,102 @@
+// Package httpserv contains HTTP server utilities.
+package httpserv
+
+import (
+	"context"
+	"crypto/tls"
+	"fmt"
+	"log"
+	"net"
+	"net/http"
+	"os"
+	"runtime"
+	"time"
+
+	"github.com/bluenviron/mediamtx/internal/conf"
+)
+
+type nilWriter struct{}
+
+func (nilWriter) Write(p []byte) (int, error) {
+	return len(p), nil
+}
+
+// exit when there's a panic inside the HTTP handler.
+// https://github.com/golang/go/issues/16542
+type exitOnPanicHandler struct {
+	http.Handler
+}
+
+func (h exitOnPanicHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	defer func() {
+		err := recover()
+		if err != nil {
+			buf := make([]byte, 1<<20)
+			n := runtime.Stack(buf, true)
+			fmt.Fprintf(os.Stderr, "panic: %v\n\n%s", err, buf[:n])
+			os.Exit(1)
+		}
+	}()
+	h.Handler.ServeHTTP(w, r)
+}
+
+// WrappedServer is a wrapper around http.Server that provides:
+// - net.Listener allocation and closure
+// - TLS allocation
+// - exit on panic
+type WrappedServer struct {
+	ln    net.Listener
+	inner *http.Server
+}
+
+// NewWrappedServer allocates a WrappedServer.
+func NewWrappedServer(
+	network string,
+	address string,
+	readTimeout conf.StringDuration,
+	serverCert string,
+	serverKey string,
+	handler http.Handler,
+) (*WrappedServer, error) {
+	ln, err := net.Listen(network, address)
+	if err != nil {
+		return nil, err
+	}
+
+	var tlsConfig *tls.Config
+	if serverCert != "" {
+		crt, err := tls.LoadX509KeyPair(serverCert, serverKey)
+		if err != nil {
+			ln.Close()
+			return nil, err
+		}
+
+		tlsConfig = &tls.Config{
+			Certificates: []tls.Certificate{crt},
+		}
+	}
+
+	s := &WrappedServer{
+		ln: ln,
+		inner: &http.Server{
+			Handler:           exitOnPanicHandler{handler},
+			TLSConfig:         tlsConfig,
+			ReadHeaderTimeout: time.Duration(readTimeout),
+			ErrorLog:          log.New(&nilWriter{}, "", 0),
+		},
+	}
+
+	if tlsConfig != nil {
+		go s.inner.ServeTLS(s.ln, "", "")
+	} else {
+		go s.inner.Serve(s.ln)
+	}
+
+	return s, nil
+}
+
+// Close closes all resources and waits for all routines to return.
+func (s *WrappedServer) Close() {
+	s.inner.Shutdown(context.Background())
+	s.ln.Close() // in case Shutdown() is called before Serve()
+}