Merge pull request #478 from aerospike/stage

Go Client v8.2.0

Author: khaf

CHANGELOG.md

@@ -1,5 +1,16 @@
 # Change History
 
+## March 18 2025: v8.2.0
+
+- **Fixes**
+  - [CLIENT-3379] Setting `TotalTimeout` to 0 causes Scan / Query to fail (timeout).
+  - [CLIENT-3376] `BatchRead` on Non-Existing namespace with transaction policy does not throw expected error.
+  - [CLIENT-3353] Insufficient Error Messages from MRT commit failure.
+  - [CLIENT-3374] Fix panic when trying to commit a MRT with no read and write transaction.
+
+- **Improvements**
+  - [CLIENT-3361] Update documentation for `RecordsPerSecond` scan/query policy.
+
 ## February 26 2025: v8.1.0
 
 - **New Features**

admin_command.go

@@ -396,7 +396,7 @@ func (acmd *AdminCommand) executeCommand(conn *Connection, policy *AdminPolicy)
 		timeout = policy.Timeout
 	}
 
-	if err := conn.SetTimeout(time.Now().Add(timeout), timeout); err != nil {
+	if err := conn.SetTimeout(timeout, timeout); err != nil {
 		return err
 	}
 
@@ -426,7 +426,7 @@ func (acmd *AdminCommand) readUsers(conn *Connection, policy *AdminPolicy) ([]*U
 		timeout = policy.Timeout
 	}
 
-	if err := conn.SetTimeout(time.Now().Add(timeout), timeout); err != nil {
+	if err := conn.SetTimeout(timeout, timeout); err != nil {
 		return nil, err
 	}
 
@@ -579,7 +579,7 @@ func (acmd *AdminCommand) readRoles(conn *Connection, policy *AdminPolicy) ([]*R
 		timeout = policy.Timeout
 	}
 
-	if err := conn.SetTimeout(time.Now().Add(timeout), timeout); err != nil {
+	if err := conn.SetTimeout(timeout, timeout); err != nil {
 		return nil, err
 	}
 

aerospike_suite_test.go

@@ -59,6 +59,7 @@ var (
 	tlsConfig    *tls.Config
 	clientPolicy *as.ClientPolicy
 	client       *as.Client
+	dbHosts      []*as.Host
 )
 
 func initTestVars() {
@@ -94,8 +95,6 @@ func initTestVars() {
 	clientPolicy.TlsConfig = tlsConfig
 	clientPolicy.UseServicesAlternate = *UseServicesAlternate
 
-	var dbHosts []*as.Host
-
 	if len(strings.TrimSpace(*hosts)) > 0 {
 		dbHosts, err = as.NewHosts(strings.Split(*hosts, ",")...)
 		if err != nil {

batch_command.go

@@ -14,17 +14,13 @@
 
 package aerospike
 
-import (
-	"time"
-)
-
 type batcher interface {
 	command
 
 	cloneBatchCommand(batch *batchNode) batcher
 	filteredOut() int
 
-	retryBatch(ifc batcher, cluster *Cluster, deadline time.Time, iteration int) (bool, Error)
+	retryBatch(ifc batcher, cluster *Cluster, iteration int) (bool, Error)
 	generateBatchNodes(*Cluster) ([]*batchNode, Error)
 	setSequence(int, int)
 
@@ -75,7 +71,7 @@ func (cmd *batchCommand) prepareRetry(ifc command, isTimeout bool) bool {
 	return false
 }
 
-func (cmd *batchCommand) retryBatch(ifc batcher, cluster *Cluster, deadline time.Time, iteration int) (bool, Error) {
+func (cmd *batchCommand) retryBatch(ifc batcher, cluster *Cluster, iteration int) (bool, Error) {
 	// Retry requires keys for this node to be split among other nodes.
 	// This is both recursive and exponential.
 	batchNodes, err := ifc.generateBatchNodes(cluster)

batch_test.go

@@ -427,6 +427,21 @@ var _ = gg.Describe("Aerospike", func() {
 				// gm.Expect(err.Matches(types.BATCH_MAX_REQUESTS_EXCEEDED)).To(gm.BeTrue())
 			})
 
+			gg.It("XXXShould return the error for invalid namespace", func() {
+				var brs []as.BatchRecordIfc
+
+				for i := 0; i < 1; i++ {
+					key, _ := as.NewKey("non_exist", "non_exist", i)
+					brr := as.NewBatchReadOps(nil, key, []*as.Operation{as.GetBinOp("i_bin")}...)
+					brs = append(brs, brr)
+				}
+
+				bp := as.NewBatchPolicy()
+				err := client.BatchOperate(bp, brs)
+				gm.Expect(err).To(gm.HaveOccurred())
+				gm.Expect(err.Matches(types.INVALID_NAMESPACE)).To(gm.BeTrue())
+			})
+
 			gg.It("Overall command error should be reflected in API call error and not BatchRecord error", func() {
 				var batchRecords []as.BatchRecordIfc
 				key, _ := as.NewKey(*namespace, set, 0)

client.go

@@ -858,6 +858,10 @@ func (clnt *Client) BatchOperate(policy *BatchPolicy, records []BatchRecordIfc)
 		return err
 	}
 
+	if len(batchNodes) == 0 {
+		return newError(types.INVALID_NAMESPACE)
+	}
+
 	cmd := newBatchCommandOperate(clnt, nil, policy, records)
 	_, err = clnt.batchExecute(policy, batchNodes, &cmd)
 	return err

command.go

@@ -3647,7 +3647,7 @@ func (cmd *baseCommand) executeAt(ifc command, policy *BasePolicy, deadline time
 			if !ifc.prepareRetry(ifc, isClientTimeout || (err != nil && err.Matches(types.SERVER_NOT_AVAILABLE))) {
 				if bc, ok := ifc.(batcher); ok {
 					// Batch may be retried in separate commands.
-					alreadyRetried, err := bc.retryBatch(bc, cmd.node.cluster, deadline, cmd.commandSentCounter)
+					alreadyRetried, err := bc.retryBatch(bc, cmd.node.cluster, cmd.commandSentCounter)
 					if alreadyRetried {
 						// Batch was retried in separate subcommands. Complete this command.
 						applyTransactionMetrics(cmd.node, ifc.commandType(), transStart)

connection.go

@@ -63,8 +63,9 @@ type Connection struct {
 	node *Node
 
 	// timeouts
-	socketTimeout time.Duration
-	deadline      time.Time
+	socketTimeout  time.Duration
+	deadline       time.Time
+	socketDeadline time.Time // this is not strictly required, but is used in testing
 
 	// duration after which connection is considered idle
 	idleTimeout  time.Duration
@@ -155,7 +156,7 @@ func newConnection(address string, timeout time.Duration) (*Connection, Error) {
 	newConn.limitReader = &io.LimitedReader{R: conn, N: 0}
 
 	// set timeout at the last possible moment
-	if err := newConn.SetTimeout(time.Now().Add(timeout), timeout); err != nil {
+	if err := newConn.SetTimeout(timeout, timeout); err != nil {
 		newConn.Close()
 		return nil, err
 	}
@@ -295,33 +296,33 @@ func (ctn *Connection) IsConnected() bool {
 // the function will return a TIMEOUT error.
 func (ctn *Connection) updateDeadline() Error {
 	now := time.Now()
-	var socketDeadline time.Time
+	ctn.socketDeadline = now.Add(_DEFAULT_TIMEOUT)
 	if ctn.deadline.IsZero() {
 		if ctn.socketTimeout > 0 {
-			socketDeadline = now.Add(ctn.socketTimeout)
+			ctn.socketDeadline = now.Add(ctn.socketTimeout)
 		}
 	} else {
-		if now.After(ctn.deadline) {
+		if !ctn.deadline.IsZero() && now.After(ctn.deadline) {
 			return newError(types.TIMEOUT)
 		}
-		if ctn.socketTimeout == 0 {
-			socketDeadline = ctn.deadline
+		if ctn.socketTimeout <= 0 {
+			ctn.socketDeadline = ctn.deadline
 		} else {
 			tDeadline := now.Add(ctn.socketTimeout)
 			if tDeadline.After(ctn.deadline) {
-				socketDeadline = ctn.deadline
+				ctn.socketDeadline = ctn.deadline
 			} else {
-				socketDeadline = tDeadline
+				ctn.socketDeadline = tDeadline
 			}
 		}
 
 		// floor to a millisecond to avoid too short timeouts
-		if socketDeadline.Sub(now) < time.Millisecond {
-			socketDeadline = now.Add(time.Millisecond)
+		if ctn.socketDeadline.Sub(now) < time.Millisecond {
+			ctn.socketDeadline = now.Add(time.Millisecond)
 		}
 	}
 
-	if err := ctn.conn.SetDeadline(socketDeadline); err != nil {
+	if err := ctn.conn.SetDeadline(ctn.socketDeadline); err != nil {
 		if ctn.node != nil {
 			ctn.node.stats.ConnectionsFailed.IncrementAndGet()
 		}
@@ -332,10 +333,22 @@ func (ctn *Connection) updateDeadline() Error {
 }
 
 // SetTimeout sets connection timeout for both read and write operations.
-func (ctn *Connection) SetTimeout(deadline time.Time, socketTimeout time.Duration) Error {
-	ctn.deadline = deadline
-	ctn.socketTimeout = socketTimeout
+func (ctn *Connection) SetTimeout(totalTimeout, socketTimeout time.Duration) Error {
+	now := time.Now()
+	ctn.socketTimeout = _DEFAULT_TIMEOUT
+	ctn.deadline = time.Time{}
+
+	if socketTimeout > 0 {
+		ctn.socketTimeout = socketTimeout
+	}
 
+	// keep the deadline.IsZero() == true if totalTimeout is not set
+	if totalTimeout > 0 {
+		ctn.deadline = now.Add(totalTimeout)
+		if socketTimeout <= 0 {
+			ctn.socketTimeout = totalTimeout
+		}
+	}
 	return nil
 }
 

connection_heap.go

@@ -165,9 +165,7 @@ func (h *singleConnectionHeap) RefreshIdleTail(tendInterval time.Duration) bool
 
 			// refresh in a goroutine asynchronously
 			go func() {
-				timeout := time.Second
-				deadline := time.Now().Add(timeout)
-				conn.SetTimeout(deadline, timeout)
+				conn.SetTimeout(time.Second, time.Second)
 				conn.refresh()
 				if _, err := conn.RequestInfo("build"); err == nil {
 					// return to the pool

connection_test.go

@@ -0,0 +1,69 @@
+// Copyright 2014-2022 Aerospike, Inc.
+//
+// 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.
+
+package aerospike_test
+
+import (
+	"fmt"
+	"time"
+
+	as "github.com/aerospike/aerospike-client-go/v8"
+
+	gg "github.com/onsi/ginkgo/v2"
+	gm "github.com/onsi/gomega"
+)
+
+// ALL tests are isolated by SetName and Key, which are 50 random characters
+var _ = gg.Describe("Connection Test", func() {
+	var conn *as.Connection
+
+	type testExpectations struct {
+		totalTimeout, socketTimeout time.Duration
+		expTotalDeadline            time.Time
+		expSocketDeadline           time.Time
+		expSocketTimeout            time.Duration
+	}
+
+	gg.BeforeEach(func() {
+		var err as.Error
+		conn, err = as.NewConnection(clientPolicy, dbHosts[0])
+		gm.Expect(err).ToNot(gm.HaveOccurred())
+		gm.Expect(conn).ToNot(gm.BeNil())
+	})
+
+	gg.It("Dealines should be calculated correctly", func() {
+		testMatrix := []testExpectations{
+			{0, 0, time.Time{}, time.Now().Add(as.DefaultTimeout()), as.DefaultTimeout()},
+			{0, time.Second, time.Time{}, time.Now().Add(time.Second), time.Second},
+			{time.Second, 0, time.Now().Add(time.Second), time.Now().Add(time.Second), time.Second},
+			{5 * time.Second, time.Second, time.Now().Add(5 * time.Second), time.Now().Add(time.Second), time.Second},
+		}
+
+		for _, matrix := range testMatrix {
+			gg.By(fmt.Sprintf("TotalTimeout: %v, SocketTimeout: %v", matrix.totalTimeout, matrix.socketTimeout))
+			err := conn.SetTimeout(matrix.totalTimeout, matrix.socketTimeout)
+			gm.Expect(err).ToNot(gm.HaveOccurred())
+
+			expTotalDeadline, expSocketDeadline, expSocketTimeout, err := conn.UpdateDeadline()
+			gm.Expect(err).ToNot(gm.HaveOccurred())
+
+			gg.By(fmt.Sprintf("expTotalDeadline: %v, expSocketDeadline: %v, expSocketTimeout: %v", matrix.expTotalDeadline, matrix.expSocketDeadline, matrix.expSocketTimeout))
+
+			gm.Expect(expTotalDeadline).To(gm.BeTemporally("~", matrix.expTotalDeadline, time.Millisecond))
+			gm.Expect(expSocketDeadline).To(gm.BeTemporally("~", matrix.expSocketDeadline, time.Millisecond))
+			gm.Expect(expSocketTimeout).To(gm.Equal(matrix.expSocketTimeout))
+		}
+	})
+
+})

helper_test.go

@@ -14,6 +14,12 @@
 
 package aerospike
 
+import "time"
+
+func DefaultTimeout() time.Duration {
+	return _DEFAULT_TIMEOUT
+}
+
 func ParseInfoErrorCode(response string) Error {
 	return parseInfoErrorCode(response)
 }
@@ -97,3 +103,8 @@ func (cmd *deleteCommand) WriteBuffer(ifc command) Error {
 func (cmd *deleteCommand) Buffer() []byte {
 	return cmd.dataBuffer[:cmd.dataOffset]
 }
+
+func (ctn *Connection) UpdateDeadline() (time.Time, time.Time, time.Duration, Error) {
+	err := ctn.updateDeadline()
+	return ctn.deadline, ctn.socketDeadline, ctn.socketTimeout, err
+}

login_command.go

@@ -93,11 +93,7 @@ func (lcmd *loginCommand) login(policy *ClientPolicy, conn *Connection, hashedPa
 
 	lcmd.writeSize()
 
-	var deadline time.Time
-	if policy.LoginTimeout > 0 {
-		deadline = time.Now().Add(policy.Timeout)
-	}
-	conn.SetTimeout(deadline, policy.LoginTimeout)
+	conn.SetTimeout(policy.LoginTimeout, policy.LoginTimeout)
 
 	if _, err := conn.Write(lcmd.dataBuffer[:lcmd.dataOffset]); err != nil {
 		return err

multi_command.go

@@ -113,7 +113,7 @@ func (cmd *baseMultiCommand) prepareRetry(ifc command, isTimeout bool) bool {
 }
 
 func (cmd *baseMultiCommand) getConnection(policy Policy) (*Connection, Error) {
-	return cmd.node.getConnectionWithHint(policy.GetBasePolicy().deadline(), policy.GetBasePolicy().socketTimeout(), byte(rand.Int63()&0xff))
+	return cmd.node.getConnectionWithHint(policy.GetBasePolicy().TotalTimeout, policy.GetBasePolicy().SocketTimeout, byte(rand.Int63()&0xff))
 }
 
 func (cmd *baseMultiCommand) putConnection(conn *Connection) {

multi_policy.go

@@ -40,8 +40,11 @@ type MultiPolicy struct {
 	MaxRecords int64
 
 	// RecordsPerSecond limits returned records per second (rps) rate for each server.
-	// Will not apply rps limit if recordsPerSecond is zero (default).
-	// Currently only applicable to a query without a defined filter.
+	// It does not apply rps limit if RecordsPerSecond is zero (default).
+	//
+	// RecordsPerSecond is supported in all primary and secondary index
+	// queries in server versions 6.0+. For background queries, RecordsPerSecond
+	// is bounded by the server config background-query-max-rps.
 	RecordsPerSecond int
 
 	// Number of records to place in queue before blocking.