More server scaffolding

Implements JSON unmarshalling/marshalling of request/response bodies.

Author: liujed

handler.go

@@ -8,6 +8,7 @@ import (
 	"github.com/caddyserver/caddy/v2/caddyconfig"
 	"github.com/caddyserver/caddy/v2/modules/caddyhttp"
 	"github.com/caddyserver/caddy/v2/modules/caddyhttp/caddyauth"
+	"github.com/liujed/caddy-dns01proxy/jsonutil"
 	"github.com/liujed/goutil/optionals"
 )
 
@@ -108,8 +109,50 @@ func (h *Handler) Provision(ctx caddy.Context) error {
 func (h *Handler) ServeHTTP(
 	w http.ResponseWriter,
 	req *http.Request,
-	_ caddyhttp.Handler,
+	nextHandler caddyhttp.Handler,
 ) error {
-	w.WriteHeader(http.StatusNotFound)
-	return nil
+	var mode handlerMode
+	switch req.URL.Path {
+	case "/present":
+		if req.Method != http.MethodPost {
+			w.WriteHeader(http.StatusMethodNotAllowed)
+			return nil
+		}
+		mode = hmPresent
+
+	case "/cleanup":
+		if req.Method != http.MethodPost {
+			w.WriteHeader(http.StatusMethodNotAllowed)
+			return nil
+		}
+		mode = hmCleanup
+
+	default:
+		return nextHandler.ServeHTTP(w, req)
+	}
+
+	handlerImpl := jsonutil.WrapHandler(h.handleDNSRequest(mode))
+	if auth, exists := h.Authentication.Get(); exists {
+		return auth.ServeHTTP(w, req, handlerImpl)
+	}
+	return handlerImpl.ServeHTTP(w, req)
+}
+
+type handlerMode string
+
+const (
+	hmPresent handlerMode = "present"
+	hmCleanup handlerMode = "cleanup"
+)
+
+func (h *Handler) handleDNSRequest(
+	mode handlerMode,
+) func(*http.Request, any) (int, optionals.Optional[any], error) {
+	return func(
+		req *http.Request,
+		reqBody any,
+	) (httpStatus int, respBody optionals.Optional[any], err error) {
+		// TODO
+		return http.StatusInternalServerError, optionals.None[any](), nil
+	}
 }

jsonutil/handler.go

@@ -0,0 +1,76 @@
+package jsonutil
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+
+	"github.com/caddyserver/caddy/v2/modules/caddyhttp"
+	"github.com/liujed/goutil/optionals"
+)
+
+// Wraps the given handler function with a layer that handles the marshalling
+// and unmarshalling of request/response modies.
+func WrapHandler[RequestT any, ResponseT any](
+	handler func(
+		req *http.Request,
+		requestBody RequestT,
+	) (
+		httpStatus int,
+		responseBody optionals.Optional[ResponseT],
+		err error,
+	),
+) caddyhttp.Handler {
+	return wrappedHandler[RequestT, ResponseT]{handler: handler}
+}
+
+type wrappedHandler[RequestT any, ResponseT any] struct {
+	handler func(
+		req *http.Request,
+		requestBody RequestT,
+	) (
+		httpStatus int,
+		responseBody optionals.Optional[ResponseT],
+		err error,
+	)
+}
+
+var _ caddyhttp.Handler = (*wrappedHandler[any, any])(nil)
+
+func (h wrappedHandler[RequestT, ResponseT]) ServeHTTP(
+	w http.ResponseWriter,
+	req *http.Request,
+) error {
+	// Unmarshal the request body.
+	var reqBody RequestT
+	err := json.NewDecoder(req.Body).Decode(&reqBody)
+	if err != nil {
+		http.Error(
+			w,
+			"Unable to read request body as JSON",
+			http.StatusBadRequest,
+		)
+		return nil
+	}
+
+	// Call the wrapped handler.
+	httpStatus, responseBodyOpt, err := h.handler(req, reqBody)
+	if err != nil {
+		return err
+	}
+
+	// Write out the response.
+	if respBody, exists := responseBodyOpt.Get(); exists {
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(httpStatus)
+		err = json.NewEncoder(w).Encode(respBody)
+		if err != nil {
+			return fmt.Errorf("unable to write response body: %w", err)
+		}
+		return nil
+	}
+
+	// No response body. Just write the HTTP status.
+	w.WriteHeader(httpStatus)
+	return nil
+}