Add protocol helpers to infer procedure and type

error_writer.go

@@ -61,34 +61,7 @@ func NewErrorWriter(opts ...HandlerOption) *ErrorWriter {
 }
 
 func (w *ErrorWriter) classifyRequest(request *http.Request) protocolType {
-	ctype := canonicalizeContentType(getHeaderCanonical(request.Header, headerContentType))
-	isPost := request.Method == http.MethodPost
-	isGet := request.Method == http.MethodGet
-	switch {
-	case isPost && (ctype == grpcContentTypeDefault || strings.HasPrefix(ctype, grpcContentTypePrefix)):
-		return grpcProtocol
-	case isPost && (ctype == grpcWebContentTypeDefault || strings.HasPrefix(ctype, grpcWebContentTypePrefix)):
-		return grpcWebProtocol
-	case isPost && strings.HasPrefix(ctype, connectStreamingContentTypePrefix):
-		// Streaming ignores the requireConnectProtocolHeader option as the
-		// Content-Type is enough to determine the protocol.
-		if err := connectCheckProtocolVersion(request, false /* required */); err != nil {
-			return unknownProtocol
-		}
-		return connectStreamProtocol
-	case isPost && strings.HasPrefix(ctype, connectUnaryContentTypePrefix):
-		if err := connectCheckProtocolVersion(request, w.requireConnectProtocolHeader); err != nil {
-			return unknownProtocol
-		}
-		return connectUnaryProtocol
-	case isGet:
-		if err := connectCheckProtocolVersion(request, w.requireConnectProtocolHeader); err != nil {
-			return unknownProtocol
-		}
-		return connectUnaryProtocol
-	default:
-		return unknownProtocol
-	}
+	return classifyRequest(request, w.requireConnectProtocolHeader)
 }
 
 // IsSupported checks whether a request is using one of the ErrorWriter's
@@ -177,3 +150,34 @@ func (w *ErrorWriter) writeGRPCWeb(response http.ResponseWriter, err error) erro
 	response.WriteHeader(http.StatusOK)
 	return nil
 }
+
+func classifyRequest(request *http.Request, requireConnectProtocolHeader bool) protocolType {
+	ctype := canonicalizeContentType(getHeaderCanonical(request.Header, headerContentType))
+	isPost := request.Method == http.MethodPost
+	isGet := request.Method == http.MethodGet
+	switch {
+	case isPost && (ctype == grpcContentTypeDefault || strings.HasPrefix(ctype, grpcContentTypePrefix)):
+		return grpcProtocol
+	case isPost && (ctype == grpcWebContentTypeDefault || strings.HasPrefix(ctype, grpcWebContentTypePrefix)):
+		return grpcWebProtocol
+	case isPost && strings.HasPrefix(ctype, connectStreamingContentTypePrefix):
+		// Streaming ignores the requireConnectProtocolHeader option as the
+		// Content-Type is enough to determine the protocol.
+		if err := connectCheckProtocolVersion(request, false /* required */); err != nil {
+			return unknownProtocol
+		}
+		return connectStreamProtocol
+	case isPost && strings.HasPrefix(ctype, connectUnaryContentTypePrefix):
+		if err := connectCheckProtocolVersion(request, requireConnectProtocolHeader); err != nil {
+			return unknownProtocol
+		}
+		return connectUnaryProtocol
+	case isGet:
+		if err := connectCheckProtocolVersion(request, requireConnectProtocolHeader); err != nil {
+			return unknownProtocol
+		}
+		return connectUnaryProtocol
+	default:
+		return unknownProtocol
+	}
+}

protocol.go

@@ -48,6 +48,45 @@ const (
 
 var errNoTimeout = errors.New("no timeout")
 
+// ProtocolFromRequest returns the inferred protocol name for parsing an
+// HTTP request. It inspects the request's method and headers to determine the
+// protocol. If the request doesn't match any known protocol, an empty string
+// is returned.
+func ProtocolFromRequest(request *http.Request) (string, bool) {
+	switch classifyRequest(request, false) {
+	case connectUnaryProtocol, connectStreamProtocol:
+		return ProtocolConnect, true
+	case grpcProtocol:
+		return ProtocolGRPC, true
+	case grpcWebProtocol:
+		return ProtocolGRPCWeb, true
+	case unknownProtocol:
+		return "", false
+	default:
+		return "", false
+	}
+}
+
+// ProcedureFromURL returns the inferred procedure name from a URL. It's
+// returned in the form "/service/method" if a valid suffix is found. If the
+// path doesn't contain a service and method, the entire path is returned.
+func ProcedureFromURL(url *url.URL) (string, bool) {
+	path := strings.TrimSuffix(url.Path, "/")
+	ultimate := strings.LastIndex(path, "/")
+	if ultimate < 0 {
+		return url.Path, false
+	}
+	penultimate := strings.LastIndex(path[:ultimate], "/")
+	if penultimate < 0 {
+		return url.Path, false
+	}
+	procedure := path[penultimate:]
+	if len(procedure) < 4 { // two slashes + service + method
+		return url.Path, false
+	}
+	return procedure, true
+}
+
 // A Protocol defines the HTTP semantics to use when sending and receiving
 // messages. It ties together codecs, compressors, and net/http to produce
 // Senders and Receivers.

protocol_test.go

@@ -15,6 +15,7 @@
 package connect
 
 import (
+	"net/url"
 	"testing"
 
 	"connectrpc.com/connect/internal/assert"
@@ -63,3 +64,36 @@ func BenchmarkCanonicalizeContentType(b *testing.B) {
 		b.ReportAllocs()
 	})
 }
+
+func TestProcedureFromURL(t *testing.T) {
+	t.Parallel()
+	tests := []struct {
+		name string
+		url  string
+		want string
+	}{
+		{name: "simple", url: "http://localhost:8080/foo", want: "/foo"},
+		{name: "service", url: "http://localhost:8080/service/bar", want: "/service/bar"},
+		{name: "trailing", url: "http://localhost:8080/service/bar/", want: "/service/bar"},
+		{name: "subroute", url: "http://localhost:8080/api/service/bar/", want: "/service/bar"},
+		{name: "subrouteTrailing", url: "http://localhost:8080/api/service/bar/", want: "/service/bar"},
+		{
+			name: "real",
+			url:  "http://localhost:8080/connect.ping.v1.PingService/Ping",
+			want: "/connect.ping.v1.PingService/Ping",
+		},
+	}
+	for _, testcase := range tests {
+		testcase := testcase
+		t.Run(testcase.name, func(t *testing.T) {
+			t.Parallel()
+			url, err := url.Parse(testcase.url)
+			if !assert.Nil(t, err) {
+				return
+			}
+			t.Log(url.String())
+			got, _ := ProcedureFromURL(url)
+			assert.Equal(t, got, testcase.want)
+		})
+	}
+}