You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tinkerpop.apache.org by xi...@apache.org on 2026/03/25 06:35:41 UTC

(tinkerpop) 01/04: add proper error handling for non-graphbinary cases

This is an automated email from the ASF dual-hosted git repository.

xiazcy pushed a commit to branch go-http-fix
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git

commit d8e43c3ca985b23a1ab3d8e86ea7937bb1807a20
Author: Yang Xia <xi...@gmail.com>
AuthorDate: Tue Mar 24 20:43:13 2026 -0700

    add proper error handling for non-graphbinary cases
---
 gremlin-go/driver/connection.go      |  44 +++++++++++-
 gremlin-go/driver/connection_test.go | 127 +++++++++++++++++++++++++++++++++++
 2 files changed, 168 insertions(+), 3 deletions(-)

diff --git a/gremlin-go/driver/connection.go b/gremlin-go/driver/connection.go
index 184efb681b..5086965a8d 100644
--- a/gremlin-go/driver/connection.go
+++ b/gremlin-go/driver/connection.go
@@ -22,13 +22,13 @@ package gremlingo
 import (
 	"bytes"
 	"compress/zlib"
-	"crypto/sha256"
 	"crypto/tls"
-	"encoding/hex"
+	"encoding/json"
+	"fmt"
 	"io"
 	"net"
 	"net/http"
-	"net/url"
+	"strings"
 	"time"
 )
 
@@ -230,6 +230,28 @@ func (c *connection) executeAndStream(data []byte, rs ResultSet) {
 		}
 	}()
 
+	// If the HTTP status indicates an error and the response is not GraphBinary,
+	// read the body as a text/JSON error message instead of attempting binary
+	// deserialization which would produce cryptic errors.
+	contentType := resp.Header.Get(HeaderContentType)
+	if resp.StatusCode >= 400 && !strings.Contains(contentType, graphBinaryMimeType) {
+		bodyBytes, readErr := io.ReadAll(resp.Body)
+		if readErr != nil {
+			c.logHandler.logf(Error, failedToReceiveResponse, readErr.Error())
+			rs.setError(fmt.Errorf("Gremlin Server returned HTTP %d and failed to read body: %w",
+				resp.StatusCode, readErr))
+			return
+		}
+		errorBody := string(bodyBytes)
+		errorMsg := tryExtractJSONError(errorBody)
+		if errorMsg == "" {
+			errorMsg = fmt.Sprintf("Gremlin Server returned HTTP %d: %s", resp.StatusCode, errorBody)
+		}
+		c.logHandler.logf(Error, failedToReceiveResponse, errorMsg)
+		rs.setError(fmt.Errorf("%s", errorMsg))
+		return
+	}
+
 	reader, zlibReader, err := c.getReader(resp)
 	if err != nil {
 		c.logHandler.logf(Error, failedToReceiveResponse, err.Error())
@@ -308,6 +330,22 @@ func (c *connection) streamToResultSet(reader io.Reader, rs ResultSet) {
 	}
 }
 
+// tryExtractJSONError attempts to extract an error message from a JSON response body.
+// The server sometimes responds with a JSON object containing a "message" field
+// even when it cannot produce a GraphBinary response.
+func tryExtractJSONError(body string) string {
+	var obj map[string]interface{}
+	if err := json.Unmarshal([]byte(body), &obj); err != nil {
+		return ""
+	}
+	if msg, ok := obj["message"]; ok {
+		if s, ok := msg.(string); ok {
+			return s
+		}
+	}
+	return ""
+}
+
 func (c *connection) close() {
 	c.httpClient.CloseIdleConnections()
 }
diff --git a/gremlin-go/driver/connection_test.go b/gremlin-go/driver/connection_test.go
index a222448f2c..a0e8414223 100644
--- a/gremlin-go/driver/connection_test.go
+++ b/gremlin-go/driver/connection_test.go
@@ -993,10 +993,137 @@ func TestConnectionWithMockServer(t *testing.T) {
 
 		_, _ = rs.All() // drain
 	})
+
+	t.Run("returns plain text error for non-GraphBinary 500 response", func(t *testing.T) {
+		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Set("Content-Type", "text/plain")
+			w.WriteHeader(http.StatusInternalServerError)
+			w.Write([]byte("Internal Server Error"))
+		}))
+		defer server.Close()
+
+		conn := newConnection(newTestLogHandler(), server.URL, &connectionSettings{})
+		rs, err := conn.submit(&request{gremlin: "g.V()", fields: map[string]interface{}{}})
+		require.NoError(t, err)
+
+		_, _ = rs.All()
+		rsErr := rs.GetError()
+		require.Error(t, rsErr)
+		assert.Contains(t, rsErr.Error(), "HTTP 500")
+		assert.Contains(t, rsErr.Error(), "Internal Server Error")
+	})
+
+	t.Run("extracts message from JSON error response", func(t *testing.T) {
+		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Set("Content-Type", "application/json")
+			w.WriteHeader(http.StatusUnauthorized)
+			w.Write([]byte(`{"message":"Authentication required"}`))
+		}))
+		defer server.Close()
+
+		conn := newConnection(newTestLogHandler(), server.URL, &connectionSettings{})
+		rs, err := conn.submit(&request{gremlin: "g.V()", fields: map[string]interface{}{}})
+		require.NoError(t, err)
+
+		_, _ = rs.All()
+		rsErr := rs.GetError()
+		require.Error(t, rsErr)
+		assert.Equal(t, "Authentication required", rsErr.Error())
+	})
+
+	t.Run("falls back to raw body for non-JSON error response", func(t *testing.T) {
+		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Set("Content-Type", "text/html")
+			w.WriteHeader(http.StatusBadGateway)
+			w.Write([]byte("<html>Bad Gateway</html>"))
+		}))
+		defer server.Close()
+
+		conn := newConnection(newTestLogHandler(), server.URL, &connectionSettings{})
+		rs, err := conn.submit(&request{gremlin: "g.V()", fields: map[string]interface{}{}})
+		require.NoError(t, err)
+
+		_, _ = rs.All()
+		rsErr := rs.GetError()
+		require.Error(t, rsErr)
+		assert.Contains(t, rsErr.Error(), "HTTP 502")
+		assert.Contains(t, rsErr.Error(), "<html>Bad Gateway</html>")
+	})
+
+	t.Run("falls through to GraphBinary deserialization for GraphBinary error responses", func(t *testing.T) {
+		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Set("Content-Type", graphBinaryMimeType)
+			w.WriteHeader(http.StatusInternalServerError)
+			// Write invalid GraphBinary — the point is that we don't short-circuit
+			// to the text error path when Content-Type is GraphBinary
+			w.Write([]byte{0x00})
+		}))
+		defer server.Close()
+
+		conn := newConnection(newTestLogHandler(), server.URL, &connectionSettings{})
+		rs, err := conn.submit(&request{gremlin: "g.V()", fields: map[string]interface{}{}})
+		require.NoError(t, err)
+
+		_, _ = rs.All()
+		rsErr := rs.GetError()
+		// Should get a deserialization error, NOT an "HTTP 500" text error
+		if rsErr != nil {
+			assert.NotContains(t, rsErr.Error(), "HTTP 500")
+		}
+	})
+
+	t.Run("interceptors run before serialization is checked", func(t *testing.T) {
+		var interceptorHeaders http.Header
+		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.WriteHeader(http.StatusOK)
+		}))
+		defer server.Close()
+
+		conn := newConnection(newTestLogHandler(), server.URL, &connectionSettings{})
+		conn.AddInterceptor(func(req *HttpRequest) error {
+			interceptorHeaders = req.Headers.Clone()
+			return nil
+		})
+
+		rs, err := conn.submit(&request{gremlin: "g.V()", fields: map[string]interface{}{}})
+		require.NoError(t, err)
+		_, _ = rs.All()
+
+		// Interceptor should see the default headers
+		assert.Equal(t, graphBinaryMimeType, interceptorHeaders.Get("Content-Type"))
+		assert.Equal(t, graphBinaryMimeType, interceptorHeaders.Get("Accept"))
+	})
 }
 
 // Tests for connection pool configuration settings
 
+func TestTryExtractJSONError(t *testing.T) {
+	t.Run("extracts message from valid JSON", func(t *testing.T) {
+		result := tryExtractJSONError(`{"message":"auth failed","code":401}`)
+		assert.Equal(t, "auth failed", result)
+	})
+
+	t.Run("returns empty for JSON without message field", func(t *testing.T) {
+		result := tryExtractJSONError(`{"error":"something went wrong"}`)
+		assert.Equal(t, "", result)
+	})
+
+	t.Run("returns empty for invalid JSON", func(t *testing.T) {
+		result := tryExtractJSONError("not json at all")
+		assert.Equal(t, "", result)
+	})
+
+	t.Run("returns empty for HTML content", func(t *testing.T) {
+		result := tryExtractJSONError("<html><body>Error</body></html>")
+		assert.Equal(t, "", result)
+	})
+
+	t.Run("returns empty for empty string", func(t *testing.T) {
+		result := tryExtractJSONError("")
+		assert.Equal(t, "", result)
+	})
+}
+
 func TestConnectionPoolSettings(t *testing.T) {
 	t.Run("default values are applied when settings are 0", func(t *testing.T) {
 		// Create connection with empty settings (all zeros)