exchange protocol info on dial

Author: DifferentialOrange

connection.go

@@ -393,13 +393,6 @@ func Connect(addr string, opts Opts) (conn *Connection, err error) {
 		}
 	}
 
-	if err = conn.loadProtocolInfo(); err != nil {
-		conn.mutex.Lock()
-		defer conn.mutex.Unlock()
-		conn.closeConnection(err, true)
-		return nil, err
-	}
-
 	return conn, err
 }
 
@@ -511,6 +504,13 @@ func (conn *Connection) dial() (err error) {
 	conn.Greeting.Version = bytes.NewBuffer(greeting[:64]).String()
 	conn.Greeting.auth = bytes.NewBuffer(greeting[64:108]).String()
 
+	// IPROTO_ID requests can be processed without authentication.
+	// https://www.tarantool.io/en/doc/latest/dev_guide/internals/iproto/requests/#iproto-id
+	if err = conn.loadProtocolInfo(w, r); err != nil {
+		connection.Close()
+		return err
+	}
+
 	// Auth
 	if opts.User != "" {
 		scr, err := scramble(conn.Greeting.auth, opts.Pass)
@@ -590,43 +590,64 @@ func pack(h *smallWBuf, enc *encoder, reqid uint32,
 	return
 }
 
-func (conn *Connection) writeAuthRequest(w *bufio.Writer, scramble []byte) (err error) {
+func (conn *Connection) writeRequestRaw(w *bufio.Writer, req Request,
+	reqName string) (err error) {
 	var packet smallWBuf
-	req := newAuthRequest(conn.opts.User, string(scramble))
 	err = pack(&packet, newEncoder(&packet), 0, req, ignoreStreamId, conn.Schema)
 
 	if err != nil {
-		return errors.New("auth: pack error " + err.Error())
+		return errors.New(reqName + ": pack error " + err.Error())
 	}
 	if err := write(w, packet.b); err != nil {
-		return errors.New("auth: write error " + err.Error())
+		return errors.New(reqName + ": write error " + err.Error())
 	}
 	if err = w.Flush(); err != nil {
-		return errors.New("auth: flush error " + err.Error())
+		return errors.New(reqName + ": flush error " + err.Error())
 	}
 	return
 }
 
-func (conn *Connection) readAuthResponse(r io.Reader) (err error) {
+func (conn *Connection) writeAuthRequest(w *bufio.Writer, scramble []byte) (err error) {
+	req := newAuthRequest(conn.opts.User, string(scramble))
+	return conn.writeRequestRaw(w, req, "auth")
+}
+
+func (conn *Connection) writeProtocolInfoRequest(w *bufio.Writer, version ProtocolVersion,
+	features []ProtocolFeature) (err error) {
+	req := newProtocolInfoRequest(version, features)
+	return conn.writeRequestRaw(w, req, "iproto id")
+}
+
+func (conn *Connection) readResponseRaw(r io.Reader,
+	reqName string) (resp Response, err error) {
 	respBytes, err := conn.read(r)
 	if err != nil {
-		return errors.New("auth: read error " + err.Error())
+		return resp, errors.New(reqName + ": read error " + err.Error())
 	}
-	resp := Response{buf: smallBuf{b: respBytes}}
+	resp = Response{buf: smallBuf{b: respBytes}}
 	err = resp.decodeHeader(conn.dec)
 	if err != nil {
-		return errors.New("auth: decode response header error " + err.Error())
+		return resp, errors.New(reqName + ": decode response header error " + err.Error())
 	}
 	err = resp.decodeBody()
 	if err != nil {
 		switch err.(type) {
 		case Error:
-			return err
+			return resp, err
 		default:
-			return errors.New("auth: decode response body error " + err.Error())
+			return resp, errors.New(reqName + ": decode response body error " + err.Error())
 		}
 	}
-	return
+	return resp, nil
+}
+
+func (conn *Connection) readAuthResponse(r io.Reader) (err error) {
+	_, err = conn.readResponseRaw(r, "auth")
+	return err
+}
+
+func (conn *Connection) readProtocolInfoResponse(r io.Reader) (resp Response, err error) {
+	return conn.readResponseRaw(r, "iproto id")
 }
 
 func (conn *Connection) createConnection(reconnect bool) (err error) {
@@ -696,10 +717,6 @@ func (conn *Connection) reconnect(neterr error, c net.Conn) {
 			conn.closeConnection(neterr, false)
 			if err := conn.createConnection(true); err != nil {
 				conn.closeConnection(err, true)
-			} else {
-				if err = conn.loadProtocolInfo(); err != nil {
-					conn.closeConnection(err, true)
-				}
 			}
 		}
 	} else {
@@ -1180,15 +1197,21 @@ func (conn *Connection) NewStream() (*Stream, error) {
 // loadProtocolInfo sends info about client protocol,
 // receives info about server protocol in response
 // and store in in connection serverProtocolInfo.
-func (conn *Connection) loadProtocolInfo() error {
+func (conn *Connection) loadProtocolInfo(w *bufio.Writer, r *bufio.Reader) error {
 	var ok bool
+	var resp Response
+	var err error
+
+	err = conn.writeProtocolInfoRequest(w, ClientProtocolVersion, ClientProtocolFeatures)
+	if err != nil {
+		return err
+	}
 
-	resp, err := conn.exchangeProtocolInfo(
-		ClientProtocolVersion,
-		ClientProtocolFeatures)
+	resp, err = conn.readProtocolInfoResponse(r)
 
 	if err != nil {
-		if resp.Code == ErrUnknownRequestType {
+		tarantoolError, ok := err.(Error)
+		if ok && tarantoolError.Code == ErrUnknownRequestType {
 			// IPROTO_ID requests are not supported by server.
 			conn.serverProtocolInfo = protocolInfo{
 				version:  ProtocolVersionUnsupported,

request.go

@@ -1124,14 +1124,6 @@ func newProtocolInfoRequest(protocolVersion ProtocolVersion,
 	return req
 }
 
-// exchangeProtocolInfo sends info about client protocol
-// and receives info about server protocol in response.
-func (conn *Connection) exchangeProtocolInfo(version ProtocolVersion,
-	features []ProtocolFeature) (resp *Response, err error) {
-	req := newProtocolInfoRequest(version, features)
-	return conn.Do(req).Get()
-}
-
 // Body fills an encoder with the protocol version request body.
 func (req *protocolInfoRequest) Body(res SchemaResolver, enc *encoder) error {
 	return req.fillProtocolInfoRequest(enc)