api: create AuthDialer and ProtocolDialer

To disable SSL by default we want to transfer
`OpenSslDialer` to the go-openssl repository.
In order to do so, we need to minimize the amount of
copy-paste of the private functions.

`AuthDialer` is created as a dialer-wrapper, that
calls authentication methods.
`ProtoDialer` is created to check expected `ProtocolInfo`
with the actual (in the created connection).

Part of #301

Author: DerekBum

CHANGELOG.md

@@ -37,6 +37,8 @@ Versioning](http://semver.org/spec/v2.0.0.html) except to the first release.
   the response (#237)
 - Ability to mock connections for tests (#237). Added new types `MockDoer`,
   `MockRequest` to `test_helpers`.
+- `AuthDialer` and `ProtocolDialer` types for creating a dialer with
+  authentication and `ProtocolInfo` check (#301)
 
 ### Changed
 

connection.go

@@ -440,7 +440,9 @@ func (conn *Connection) dial(ctx context.Context) error {
 	}
 
 	conn.addr = c.Addr()
-	conn.Greeting.Version = c.Greeting().Version
+	connGreeting := c.Greeting()
+	conn.Greeting.Version = connGreeting.Version
+	conn.Greeting.Salt = connGreeting.Salt
 	conn.serverProtocolInfo = c.ProtocolInfo()
 
 	spaceAndIndexNamesSupported :=

dial.go

@@ -21,6 +21,7 @@ const bufSize = 128 * 1024
 // Greeting is a message sent by Tarantool on connect.
 type Greeting struct {
 	Version string
+	Salt    string
 }
 
 // writeFlusher is the interface that groups the basic Write and Flush methods.
@@ -80,21 +81,48 @@ type tntConn struct {
 
 // rawDial does basic dial operations:
 // reads greeting, identifies a protocol and validates it.
-func rawDial(conn *tntConn, requiredProto ProtocolInfo) (string, error) {
+func rawDial(conn *tntConn) error {
 	version, salt, err := readGreeting(conn.reader)
 	if err != nil {
-		return "", fmt.Errorf("failed to read greeting: %w", err)
+		return fmt.Errorf("failed to read greeting: %w", err)
 	}
 	conn.greeting.Version = version
+	conn.greeting.Salt = salt
 
 	if conn.protocol, err = identify(conn.writer, conn.reader); err != nil {
-		return "", fmt.Errorf("failed to identify: %w", err)
+		return fmt.Errorf("failed to identify: %w", err)
 	}
 
-	if err = checkProtocolInfo(requiredProto, conn.protocol); err != nil {
-		return "", fmt.Errorf("invalid server protocol: %w", err)
+	return nil
+}
+
+type netDialer struct {
+	address string
+}
+
+func (d netDialer) Dial(ctx context.Context, opts DialOpts) (Conn, error) {
+	var err error
+	conn := new(tntConn)
+
+	network, address := parseAddress(d.address)
+	dialer := net.Dialer{}
+	conn.net, err = dialer.DialContext(ctx, network, address)
+	if err != nil {
+		return nil, fmt.Errorf("failed to dial: %w", err)
+	}
+
+	dc := &deadlineIO{to: opts.IoTimeout, c: conn.net}
+	conn.reader = bufio.NewReaderSize(dc, bufSize)
+	conn.writer = bufio.NewWriterSize(dc, bufSize)
+
+	err = rawDial(conn)
+	if err != nil {
+		conn.net.Close()
+		return nil, err
 	}
-	return salt, err
+
+	conn.protocol.Auth = ChapSha1Auth
+	return conn, nil
 }
 
 // NetDialer is a basic Dialer implementation.
@@ -121,12 +149,45 @@ type NetDialer struct {
 
 // Dial makes NetDialer satisfy the Dialer interface.
 func (d NetDialer) Dial(ctx context.Context, opts DialOpts) (Conn, error) {
+	dialer := AuthDialer{
+		Dialer: ProtocolDialer{
+			Dialer: netDialer{
+				address: d.Address,
+			},
+			RequiredProtocolInfo: d.RequiredProtocolInfo,
+		},
+		Auth:     ChapSha1Auth,
+		Username: d.User,
+		Password: d.Password,
+	}
+
+	return dialer.Dial(ctx, opts)
+}
+
+type openSslDialer struct {
+	address         string
+	auth            Auth
+	sslKeyFile      string
+	sslCertFile     string
+	sslCaFile       string
+	sslCiphers      string
+	sslPassword     string
+	sslPasswordFile string
+}
+
+func (d openSslDialer) Dial(ctx context.Context, opts DialOpts) (Conn, error) {
 	var err error
 	conn := new(tntConn)
 
-	network, address := parseAddress(d.Address)
-	dialer := net.Dialer{}
-	conn.net, err = dialer.DialContext(ctx, network, address)
+	network, address := parseAddress(d.address)
+	conn.net, err = sslDialContext(ctx, network, address, sslOpts{
+		KeyFile:      d.sslKeyFile,
+		CertFile:     d.sslCertFile,
+		CaFile:       d.sslCaFile,
+		Ciphers:      d.sslCiphers,
+		Password:     d.sslPassword,
+		PasswordFile: d.sslPasswordFile,
+	})
 	if err != nil {
 		return nil, fmt.Errorf("failed to dial: %w", err)
 	}
@@ -135,20 +196,18 @@ func (d NetDialer) Dial(ctx context.Context, opts DialOpts) (Conn, error) {
 	conn.reader = bufio.NewReaderSize(dc, bufSize)
 	conn.writer = bufio.NewWriterSize(dc, bufSize)
 
-	salt, err := rawDial(conn, d.RequiredProtocolInfo)
+	err = rawDial(conn)
 	if err != nil {
 		conn.net.Close()
 		return nil, err
 	}
 
-	if d.User == "" {
-		return conn, nil
-	}
-
-	conn.protocol.Auth = ChapSha1Auth
-	if err = authenticate(conn, ChapSha1Auth, d.User, d.Password, salt); err != nil {
-		conn.net.Close()
-		return nil, fmt.Errorf("failed to authenticate: %w", err)
+	if d.auth == AutoAuth {
+		if conn.protocol.Auth == AutoAuth {
+			conn.protocol.Auth = ChapSha1Auth
+		}
+	} else {
+		conn.protocol.Auth = d.auth
 	}
 
 	return conn, nil
@@ -206,51 +265,26 @@ type OpenSslDialer struct {
 
 // Dial makes OpenSslDialer satisfy the Dialer interface.
 func (d OpenSslDialer) Dial(ctx context.Context, opts DialOpts) (Conn, error) {
-	var err error
-	conn := new(tntConn)
-
-	network, address := parseAddress(d.Address)
-	conn.net, err = sslDialContext(ctx, network, address, sslOpts{
-		KeyFile:      d.SslKeyFile,
-		CertFile:     d.SslCertFile,
-		CaFile:       d.SslCaFile,
-		Ciphers:      d.SslCiphers,
-		Password:     d.SslPassword,
-		PasswordFile: d.SslPasswordFile,
-	})
-	if err != nil {
-		return nil, fmt.Errorf("failed to dial: %w", err)
-	}
-
-	dc := &deadlineIO{to: opts.IoTimeout, c: conn.net}
-	conn.reader = bufio.NewReaderSize(dc, bufSize)
-	conn.writer = bufio.NewWriterSize(dc, bufSize)
-
-	salt, err := rawDial(conn, d.RequiredProtocolInfo)
-	if err != nil {
-		conn.net.Close()
-		return nil, err
-	}
-
-	if d.User == "" {
-		return conn, nil
-	}
-
-	if d.Auth == AutoAuth {
-		if conn.protocol.Auth != AutoAuth {
-			d.Auth = conn.protocol.Auth
-		} else {
-			d.Auth = ChapSha1Auth
-		}
-	}
-	conn.protocol.Auth = d.Auth
-
-	if err = authenticate(conn, d.Auth, d.User, d.Password, salt); err != nil {
-		conn.net.Close()
-		return nil, fmt.Errorf("failed to authenticate: %w", err)
-	}
-
-	return conn, nil
+	dialer := AuthDialer{
+		Dialer: ProtocolDialer{
+			Dialer: openSslDialer{
+				address:         d.Address,
+				auth:            d.Auth,
+				sslKeyFile:      d.SslKeyFile,
+				sslCertFile:     d.SslCertFile,
+				sslCaFile:       d.SslCaFile,
+				sslCiphers:      d.SslCiphers,
+				sslPassword:     d.SslPassword,
+				sslPasswordFile: d.SslPasswordFile,
+			},
+			RequiredProtocolInfo: d.RequiredProtocolInfo,
+		},
+		Auth:     d.Auth,
+		Username: d.User,
+		Password: d.Password,
+	}
+
+	return dialer.Dial(ctx, opts)
 }
 
 // FdDialer allows to use an existing socket fd for connection.
@@ -263,6 +297,10 @@ type FdDialer struct {
 	RequiredProtocolInfo ProtocolInfo
 }
 
+type fdDialer struct {
+	fd uintptr
+}
+
 type fdAddr struct {
 	Fd uintptr
 }
@@ -284,22 +322,21 @@ func (c *fdConn) RemoteAddr() net.Addr {
 	return c.Addr
 }
 
-// Dial makes FdDialer satisfy the Dialer interface.
-func (d FdDialer) Dial(ctx context.Context, opts DialOpts) (Conn, error) {
-	file := os.NewFile(d.Fd, "")
+func (d fdDialer) Dial(ctx context.Context, opts DialOpts) (Conn, error) {
+	file := os.NewFile(d.fd, "")
 	c, err := net.FileConn(file)
 	if err != nil {
 		return nil, fmt.Errorf("failed to dial: %w", err)
 	}
 
 	conn := new(tntConn)
-	conn.net = &fdConn{Conn: c, Addr: fdAddr{Fd: d.Fd}}
+	conn.net = &fdConn{Conn: c, Addr: fdAddr{Fd: d.fd}}
 
 	dc := &deadlineIO{to: opts.IoTimeout, c: conn.net}
 	conn.reader = bufio.NewReaderSize(dc, bufSize)
 	conn.writer = bufio.NewWriterSize(dc, bufSize)
 
-	_, err = rawDial(conn, d.RequiredProtocolInfo)
+	err = rawDial(conn)
 	if err != nil {
 		conn.net.Close()
 		return nil, err
@@ -308,6 +345,84 @@ func (d FdDialer) Dial(ctx context.Context, opts DialOpts) (Conn, error) {
 	return conn, nil
 }
 
+// Dial makes FdDialer satisfy the Dialer interface.
+func (d FdDialer) Dial(ctx context.Context, opts DialOpts) (Conn, error) {
+	dialer := ProtocolDialer{
+		Dialer: fdDialer{
+			fd: d.Fd,
+		},
+		RequiredProtocolInfo: d.RequiredProtocolInfo,
+	}
+
+	return dialer.Dial(ctx, opts)
+}
+
+type AuthDialer struct {
+	// Dialer is a base dialer.
+	Dialer Dialer
+	// Authentication options.
+	Auth     Auth
+	Username string
+	Password string
+}
+
+// Dial makes AuthDialer satisfy the Dialer interface.
+func (d AuthDialer) Dial(ctx context.Context, opts DialOpts) (Conn, error) {
+	conn, err := d.Dialer.Dial(ctx, opts)
+	if err != nil {
+		return conn, err
+	}
+	greeting := conn.Greeting()
+	if greeting.Salt == "" {
+		conn.Close()
+		return nil, fmt.Errorf("failed to authenticate: " +
+			"an invalid connection without salt")
+	}
+
+	if d.Username == "" {
+		return conn, nil
+	}
+
+	protocolAuth := conn.ProtocolInfo().Auth
+	if d.Auth == AutoAuth {
+		if protocolAuth != AutoAuth {
+			d.Auth = protocolAuth
+		} else {
+			d.Auth = ChapSha1Auth
+		}
+	}
+
+	if err := authenticate(conn, d.Auth, d.Username, d.Password,
+		conn.Greeting().Salt); err != nil {
+		conn.Close()
+		return nil, fmt.Errorf("failed to authenticate: %w", err)
+	}
+	return conn, nil
+}
+
+type ProtocolDialer struct {
+	// Dialer is a base dialer.
+	Dialer Dialer
+	// RequiredProtocol contains minimal protocol version and
+	// list of protocol features that should be supported by
+	// Tarantool server. By default, there are no restrictions.
+	RequiredProtocolInfo ProtocolInfo
+}
+
+// Dial makes ProtocolDialer satisfy the Dialer interface.
+func (d ProtocolDialer) Dial(ctx context.Context, opts DialOpts) (Conn, error) {
+	conn, err := d.Dialer.Dial(ctx, opts)
+	if err != nil {
+		return conn, err
+	}
+	err = checkProtocolInfo(d.RequiredProtocolInfo, conn.ProtocolInfo())
+	if err != nil {
+		conn.Close()
+		return nil, fmt.Errorf("invalid server protocol: %w", err)
+	}
+	return conn, nil
+}
+
 // Addr makes tntConn satisfy the Conn interface.
 func (c *tntConn) Addr() net.Addr {
 	return c.net.RemoteAddr()