GT-593 External versioning

Author: jwierzbo

v2/connection/connection.go

@@ -46,12 +46,12 @@ type ArangoDBConfiguration struct {
 	DriverFlags []string
 
 	// Compression is used to enable compression between client and server
-	Compression *Compression
+	Compression *CompressionConfig
 }
 
-// Compression is used to enable compression for the connection
-type Compression struct {
-	// Compression is used to enable compression for the requests
+// CompressionConfig is used to enable compression for the connection
+type CompressionConfig struct {
+	// CompressionConfig is used to enable compression for the requests
 	CompressionType CompressionType
 
 	// ResponseCompressionEnabled is used to enable compression for the responses (requires server side adjustments)

v2/connection/connection_compression.go

@@ -0,0 +1,87 @@
+//
+// DISCLAIMER
+//
+// Copyright 2024 ArangoDB GmbH, Cologne, Germany
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Copyright holder is ArangoDB GmbH, Cologne, Germany
+//
+
+package connection
+
+import (
+	"compress/gzip"
+	"compress/zlib"
+	"io"
+
+	"github.com/pkg/errors"
+
+	"github.com/arangodb/go-driver/v2/log"
+)
+
+type Compression interface {
+	ApplyRequestHeaders(r Request)
+	ApplyRequestCompression(r *httpRequest, rootWriter io.Writer) (io.WriteCloser, error)
+}
+
+type compression struct {
+	config *CompressionConfig
+}
+
+func newCompression(config *CompressionConfig) Compression {
+	return &compression{
+		config: config,
+	}
+}
+
+func (g compression) ApplyRequestHeaders(r Request) {
+	if g.config != nil && g.config.ResponseCompressionEnabled {
+		if g.config.CompressionType == "gzip" {
+			r.AddHeader("Accept-Encoding", "gzip")
+		} else if g.config.CompressionType == "deflate" {
+			r.AddHeader("Accept-Encoding", "deflate")
+		}
+	}
+}
+
+func (g compression) ApplyRequestCompression(r *httpRequest, rootWriter io.Writer) (io.WriteCloser, error) {
+	config := g.config
+
+	if config != nil && config.RequestCompressionEnabled {
+		if config.CompressionType == "gzip" {
+			r.headers["Content-Encoding"] = "gzip"
+
+			gzipWriter, err := gzip.NewWriterLevel(rootWriter, config.RequestCompressionLevel)
+			if err != nil {
+				log.Errorf(err, "error creating gzip writer")
+				return nil, err
+			}
+			return gzipWriter, nil
+		} else if config.CompressionType == "deflate" {
+			r.headers["Content-Encoding"] = "deflate"
+
+			zlibWriter, err := zlib.NewWriterLevel(rootWriter, config.RequestCompressionLevel)
+			if err != nil {
+				log.Errorf(err, "error creating zlib writer")
+				return nil, err
+			}
+
+			return zlibWriter, nil
+		} else {
+			return nil, errors.Errorf("unsupported compression type: %s", config.CompressionType)
+		}
+	}
+
+	return nil, nil
+}

v2/connection/connection_http_internal.go

@@ -311,7 +311,7 @@ func (j *httpConnection) bodyReadFunc(decoder Decoder, req *httpRequest, stream
 	if !stream {
 		return func() (io.Reader, error) {
 			b := bytes.NewBuffer([]byte{})
-			compressedWriter, err := j.applyCompression(req, b)
+			compressedWriter, err := newCompression(j.config.Compression).ApplyRequestCompression(req, b)
 			if err != nil {
 				log.Errorf(err, "error applying compression")
 				return nil, err
@@ -335,7 +335,7 @@ func (j *httpConnection) bodyReadFunc(decoder Decoder, req *httpRequest, stream
 		return func() (io.Reader, error) {
 			reader, writer := io.Pipe()
 
-			compressedWriter, err := j.applyCompression(req, writer)
+			compressedWriter, err := newCompression(j.config.Compression).ApplyRequestCompression(req, writer)
 			if err != nil {
 				log.Errorf(err, "error applying compression")
 				return nil, err
@@ -361,34 +361,3 @@ func (j *httpConnection) bodyReadFunc(decoder Decoder, req *httpRequest, stream
 		}
 	}
 }
-
-func (j *httpConnection) applyCompression(req *httpRequest, rootWriter io.Writer) (io.WriteCloser, error) {
-	compression := j.config.Compression
-
-	if compression != nil && compression.RequestCompressionEnabled {
-		if compression.CompressionType == "gzip" {
-			req.headers["Content-Encoding"] = "gzip"
-
-			gzipWriter, err := gzip.NewWriterLevel(rootWriter, compression.RequestCompressionLevel)
-			if err != nil {
-				log.Errorf(err, "error creating gzip writer")
-				return nil, err
-			}
-			return gzipWriter, nil
-		} else if compression.CompressionType == "deflate" {
-			req.headers["Content-Encoding"] = "deflate"
-
-			zlibWriter, err := zlib.NewWriterLevel(rootWriter, compression.RequestCompressionLevel)
-			if err != nil {
-				log.Errorf(err, "error creating zlib writer")
-				return nil, err
-			}
-
-			return zlibWriter, nil
-		} else {
-			return nil, errors.Errorf("unsupported compression type: %s", compression.CompressionType)
-		}
-	}
-
-	return nil, nil
-}

v2/connection/modifiers.go

@@ -104,13 +104,7 @@ func applyArangoDBConfiguration(config ArangoDBConfiguration, ctx context.Contex
 			}
 		}
 
-		if config.Compression != nil && config.Compression.ResponseCompressionEnabled {
-			if config.Compression.CompressionType == "gzip" {
-				r.AddHeader("Accept-Encoding", "gzip")
-			} else if config.Compression.CompressionType == "deflate" {
-				r.AddHeader("Accept-Encoding", "deflate")
-			}
-		}
+		newCompression(config.Compression).ApplyRequestHeaders(r)
 
 		return nil
 	}

v2/tests/call_test.go

@@ -116,7 +116,7 @@ func Test_Compression_Builtin(t *testing.T) {
 
 				for _, tc := range testCases {
 					config := client.Connection().GetConfiguration()
-					config.Compression = &connection.Compression{
+					config.Compression = &connection.CompressionConfig{
 						CompressionType:            tc.compression,
 						RequestCompressionEnabled:  tc.request,
 						RequestCompressionLevel:    tc.level,
@@ -158,7 +158,7 @@ func Test_Compression_Raw(t *testing.T) {
 
 				for _, tc := range testCases {
 					config := client.Connection().GetConfiguration()
-					config.Compression = &connection.Compression{
+					config.Compression = &connection.CompressionConfig{
 						CompressionType:            tc.compression,
 						RequestCompressionEnabled:  tc.request,
 						RequestCompressionLevel:    tc.level,

v2/tests/run_wrap_test.go

@@ -161,7 +161,7 @@ func WrapConnectionFactory(t *testing.T, w WrapperConnectionFactory, wo ...WrapO
 func applyCompression(conn connection.Connection) {
 	if os.Getenv("ENABLE_DATABASE_EXTRA_FEATURES") == "true" {
 		cmp := conn.GetConfiguration()
-		cmp.Compression = &connection.Compression{
+		cmp.Compression = &connection.CompressionConfig{
 			CompressionType:            connection.RequestCompressionTypeDeflate,
 			RequestCompressionLevel:    9,
 			ResponseCompressionEnabled: true,