api: add Do* functions to ConnectionPool and ConnectionMulti

This patch provides Do, DoTyped and DoAsync functions for
ConnectionPool and ConnectionMulti types.

Part of #126

Author: oleg-jukovec

connection_pool/connection_pool.go

@@ -524,6 +524,36 @@ func (connPool *ConnectionPool) EvalAsync(expr string, args interface{}, userMod
 	return conn.EvalAsync(expr, args)
 }
 
+// Do sends the request and returns a response.
+func (connPool *ConnectionPool) Do(req tarantool.Request, userMode Mode) (*tarantool.Response, error) {
+	conn, err := connPool.getNextConnection(userMode)
+	if err != nil {
+		return nil, err
+	}
+
+	return conn.Do(req)
+}
+
+// DoTyped sends the request and fills the typed result.
+func (connPool *ConnectionPool) DoTyped(req tarantool.Request, result interface{}, userMode Mode) error {
+	conn, err := connPool.getNextConnection(userMode)
+	if err != nil {
+		return err
+	}
+
+	return conn.DoTyped(req, result)
+}
+
+// DoAsync sends the request and returns a future.
+func (connPool *ConnectionPool) DoAsync(req tarantool.Request, userMode Mode) (*tarantool.Future, error) {
+	conn, err := connPool.getNextConnection(userMode)
+	if err != nil {
+		return nil, err
+	}
+
+	return conn.DoAsync(req)
+}
+
 //
 // private
 //

connection_pool/connection_pool_test.go

@@ -1252,6 +1252,45 @@ func TestPing(t *testing.T) {
 	require.NotNilf(t, resp, "response is nil after Ping")
 }
 
+func TestDo(t *testing.T) {
+	roles := []bool{true, true, false, true, false}
+
+	err := test_helpers.SetClusterRO(servers, connOpts, roles)
+	require.Nilf(t, err, "fail to set roles for cluster")
+
+	connPool, err := connection_pool.Connect(servers, connOpts)
+	require.Nilf(t, err, "failed to connect")
+	require.NotNilf(t, connPool, "conn is nil after Connect")
+
+	defer connPool.Close()
+
+	req := tarantool.NewPingRequest()
+	// ANY
+	resp, err := connPool.Do(req, connection_pool.ANY)
+	require.Nilf(t, err, "failed to Ping")
+	require.NotNilf(t, resp, "response is nil after Ping")
+
+	// RW
+	resp, err = connPool.Do(req, connection_pool.RW)
+	require.Nilf(t, err, "failed to Ping")
+	require.NotNilf(t, resp, "response is nil after Ping")
+
+	// RO
+	resp, err = connPool.Do(req, connection_pool.RO)
+	require.Nilf(t, err, "failed to Ping")
+	require.NotNilf(t, resp, "response is nil after Ping")
+
+	// PreferRW
+	resp, err = connPool.Do(req, connection_pool.PreferRW)
+	require.Nilf(t, err, "failed to Ping")
+	require.NotNilf(t, resp, "response is nil after Ping")
+
+	// PreferRO
+	resp, err = connPool.Do(req, connection_pool.PreferRO)
+	require.Nilf(t, err, "failed to Ping")
+	require.NotNilf(t, resp, "response is nil after Ping")
+}
+
 // runTestMain is a body of TestMain function
 // (see https://pkg.go.dev/testing#hdr-Main).
 // Using defer + os.Exit is not works so TestMain body

connection_pool/example_test.go

@@ -529,3 +529,22 @@ func ExampleConnectionPool_Eval() {
 	// Code 0
 	// Data [3]
 }
+
+func ExampleConnectionPool_Do() {
+	pool, err := examplePool(testRoles)
+	if err != nil {
+		fmt.Println(err)
+	}
+	defer pool.Close()
+
+	// Ping a Tarantool instance to check connection.
+	req := tarantool.NewPingRequest()
+	resp, err := pool.Do(req, connection_pool.ANY)
+	fmt.Println("Ping Code", resp.Code)
+	fmt.Println("Ping Data", resp.Data)
+	fmt.Println("Ping Error", err)
+	// Output:
+	// Ping Code 0
+	// Ping Data []
+	// Ping Error <nil>
+}

connector.go

@@ -41,4 +41,8 @@ type Connector interface {
 	Call16Async(functionName string, args interface{}) *Future
 	Call17Async(functionName string, args interface{}) *Future
 	EvalAsync(expr string, args interface{}) *Future
+
+	Do(req Request) (resp *Response, err error)
+	DoTyped(req Request, result interface{}) (err error)
+	DoAsync(req Request) (fut *Future, err error)
 }

multi/multi.go

@@ -481,3 +481,18 @@ func (connMulti *ConnectionMulti) Call17Async(functionName string, args interfac
 func (connMulti *ConnectionMulti) EvalAsync(expr string, args interface{}) *tarantool.Future {
 	return connMulti.getCurrentConnection().EvalAsync(expr, args)
 }
+
+// Do sends the request and returns a response.
+func (connMulti *ConnectionMulti) Do(req tarantool.Request) (*tarantool.Response, error) {
+	return connMulti.getCurrentConnection().Do(req)
+}
+
+// DoTyped sends the request and fills the typed result.
+func (connMulti *ConnectionMulti) DoTyped(req tarantool.Request, result interface{}) error {
+	return connMulti.getCurrentConnection().DoTyped(req, result)
+}
+
+// DoAsync sends the request and returns a future.
+func (connMulti *ConnectionMulti) DoAsync(req tarantool.Request) (*tarantool.Future, error) {
+	return connMulti.getCurrentConnection().DoAsync(req)
+}