HTTP endpoints cleanup (#13251)

* remove validation package

* structs cleanup

* merge with apimiddleware removal

* more validation and Bls capitalization

* builder test fix

* use strconv for uint->str conversions

* use DecodeHexWithLength

* use exact param names

* rename http package to httputil

* change conversions to fmt.Sprintf

* handle query paramsd and route variables

* spans and receiver name

* split structs, move bytes helper

* missing ok check

* fix reference to indexed failure

* errors fixup

* add godoc to helper

* fix BLS casing and chainhead ref

* review

* fix import in tests

* gzl

network/httputil/BUILD.bazel

@@ -0,0 +1,26 @@
+load("@prysm//tools/go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "errors.go",
+        "reader.go",
+        "writer.go",
+    ],
+    importpath = "github.com/prysmaticlabs/prysm/v4/network/httputil",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//api:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["reader_test.go"],
+    embed = [":go_default_library"],
+    deps = [
+        "//api:go_default_library",
+        "//testing/assert:go_default_library",
+    ],
+)

network/httputil/errors.go

@@ -0,0 +1,13 @@
+package httputil
+
+import (
+	"net/http"
+)
+
+func HandleError(w http.ResponseWriter, message string, code int) {
+	errJson := &DefaultErrorJson{
+		Message: message,
+		Code:    code,
+	}
+	WriteError(w, errJson)
+}

network/httputil/reader.go

@@ -0,0 +1,53 @@
+package httputil
+
+import (
+	"net/http"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/prysmaticlabs/prysm/v4/api"
+)
+
+// match a number with optional decimals
+var priorityRegex = regexp.MustCompile(`q=(\d+(?:\.\d+)?)`)
+
+// SszRequested takes a http request and checks to see if it should be requesting a ssz response.
+func SszRequested(req *http.Request) bool {
+	accept := req.Header.Values("Accept")
+	if len(accept) == 0 {
+		return false
+	}
+	types := strings.Split(accept[0], ",")
+	currentType, currentPriority := "", 0.0
+	for _, t := range types {
+		values := strings.Split(t, ";")
+		name := values[0]
+		if name != api.JsonMediaType && name != api.OctetStreamMediaType {
+			continue
+		}
+		// no params specified
+		if len(values) == 1 {
+			priority := 1.0
+			if priority > currentPriority {
+				currentType, currentPriority = name, priority
+			}
+			continue
+		}
+		params := values[1]
+
+		match := priorityRegex.FindAllStringSubmatch(params, 1)
+		if len(match) != 1 {
+			continue
+		}
+		priority, err := strconv.ParseFloat(match[0][1], 32)
+		if err != nil {
+			return false
+		}
+		if priority > currentPriority {
+			currentType, currentPriority = name, priority
+		}
+	}
+
+	return currentType == api.OctetStreamMediaType
+}

network/httputil/reader_test.go

@@ -0,0 +1,88 @@
+package httputil
+
+import (
+	"fmt"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v4/api"
+	"github.com/prysmaticlabs/prysm/v4/testing/assert"
+)
+
+func TestSSZRequested(t *testing.T) {
+	t.Run("ssz_requested", func(t *testing.T) {
+		request := httptest.NewRequest("GET", "http://foo.example", nil)
+		request.Header["Accept"] = []string{api.OctetStreamMediaType}
+		result := SszRequested(request)
+		assert.Equal(t, true, result)
+	})
+
+	t.Run("ssz_content_type_first", func(t *testing.T) {
+		request := httptest.NewRequest("GET", "http://foo.example", nil)
+		request.Header["Accept"] = []string{fmt.Sprintf("%s,%s", api.OctetStreamMediaType, api.JsonMediaType)}
+		result := SszRequested(request)
+		assert.Equal(t, true, result)
+	})
+
+	t.Run("ssz_content_type_preferred_1", func(t *testing.T) {
+		request := httptest.NewRequest("GET", "http://foo.example", nil)
+		request.Header["Accept"] = []string{fmt.Sprintf("%s;q=0.9,%s", api.JsonMediaType, api.OctetStreamMediaType)}
+		result := SszRequested(request)
+		assert.Equal(t, true, result)
+	})
+
+	t.Run("ssz_content_type_preferred_2", func(t *testing.T) {
+		request := httptest.NewRequest("GET", "http://foo.example", nil)
+		request.Header["Accept"] = []string{fmt.Sprintf("%s;q=0.95,%s;q=0.9", api.OctetStreamMediaType, api.JsonMediaType)}
+		result := SszRequested(request)
+		assert.Equal(t, true, result)
+	})
+
+	t.Run("other_content_type_preferred", func(t *testing.T) {
+		request := httptest.NewRequest("GET", "http://foo.example", nil)
+		request.Header["Accept"] = []string{fmt.Sprintf("%s,%s;q=0.9", api.JsonMediaType, api.OctetStreamMediaType)}
+		result := SszRequested(request)
+		assert.Equal(t, false, result)
+	})
+
+	t.Run("other_params", func(t *testing.T) {
+		request := httptest.NewRequest("GET", "http://foo.example", nil)
+		request.Header["Accept"] = []string{fmt.Sprintf("%s,%s;q=0.9,otherparam=xyz", api.JsonMediaType, api.OctetStreamMediaType)}
+		result := SszRequested(request)
+		assert.Equal(t, false, result)
+	})
+
+	t.Run("no_header", func(t *testing.T) {
+		request := httptest.NewRequest("GET", "http://foo.example", nil)
+		result := SszRequested(request)
+		assert.Equal(t, false, result)
+	})
+
+	t.Run("empty_header", func(t *testing.T) {
+		request := httptest.NewRequest("GET", "http://foo.example", nil)
+		request.Header["Accept"] = []string{}
+		result := SszRequested(request)
+		assert.Equal(t, false, result)
+	})
+
+	t.Run("empty_header_value", func(t *testing.T) {
+		request := httptest.NewRequest("GET", "http://foo.example", nil)
+		request.Header["Accept"] = []string{""}
+		result := SszRequested(request)
+		assert.Equal(t, false, result)
+	})
+
+	t.Run("other_content_type", func(t *testing.T) {
+		request := httptest.NewRequest("GET", "http://foo.example", nil)
+		request.Header["Accept"] = []string{"application/other"}
+		result := SszRequested(request)
+		assert.Equal(t, false, result)
+	})
+
+	t.Run("garbage", func(t *testing.T) {
+		request := httptest.NewRequest("GET", "http://foo.example", nil)
+		request.Header["Accept"] = []string{"This is Sparta!!!"}
+		result := SszRequested(request)
+		assert.Equal(t, false, result)
+	})
+}

network/httputil/writer.go

@@ -0,0 +1,65 @@
+package httputil
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"strconv"
+
+	"github.com/prysmaticlabs/prysm/v4/api"
+	log "github.com/sirupsen/logrus"
+)
+
+type HasStatusCode interface {
+	StatusCode() int
+}
+
+// DefaultErrorJson is a JSON representation of a simple error value, containing only a message and an error code.
+type DefaultErrorJson struct {
+	Message string `json:"message"`
+	Code    int    `json:"code"`
+}
+
+func (e *DefaultErrorJson) StatusCode() int {
+	return e.Code
+}
+
+func (e *DefaultErrorJson) Error() string {
+	return fmt.Sprintf("HTTP request unsuccessful (%d: %s)", e.Code, e.Message)
+}
+
+// WriteJson writes the response message in JSON format.
+func WriteJson(w http.ResponseWriter, v any) {
+	w.Header().Set("Content-Type", api.JsonMediaType)
+	w.WriteHeader(http.StatusOK)
+	if err := json.NewEncoder(w).Encode(v); err != nil {
+		log.WithError(err).Error("Could not write response message")
+	}
+}
+
+// WriteSsz writes the response message in ssz format
+func WriteSsz(w http.ResponseWriter, respSsz []byte, fileName string) {
+	w.Header().Set("Content-Length", strconv.Itoa(len(respSsz)))
+	w.Header().Set("Content-Type", api.OctetStreamMediaType)
+	w.Header().Set("Content-Disposition", "attachment; filename="+fileName)
+	if _, err := io.Copy(w, io.NopCloser(bytes.NewReader(respSsz))); err != nil {
+		log.WithError(err).Error("could not write response message")
+	}
+}
+
+// WriteError writes the error by manipulating headers and the body of the final response.
+func WriteError(w http.ResponseWriter, errJson HasStatusCode) {
+	j, err := json.Marshal(errJson)
+	if err != nil {
+		log.WithError(err).Error("Could not marshal error message")
+		return
+	}
+	w.Header().Set("Content-Length", strconv.Itoa(len(j)))
+	w.Header().Set("Content-Type", api.JsonMediaType)
+	w.WriteHeader(errJson.StatusCode())
+	if _, err := io.Copy(w, io.NopCloser(bytes.NewReader(j))); err != nil {
+		log.WithError(err).Error("Could not write error message")
+	}
+}