refactor

Author: tmtm

lib/mysql.rb

@@ -86,18 +86,20 @@ def initialize
     @fields = nil
     @protocol = nil
     @charset = nil
-    @connect_timeout = nil
-    @read_timeout = nil
-    @write_timeout = nil
     @init_command = nil
     @sqlstate = "00000"
     @query_with_result = true
     @host_info = nil
     @last_error = nil
     @result_exist = false
-    @local_infile = nil
-    @ssl_mode = SSL_MODE_PREFERRED
-    @get_server_public_key = false
+    @opts = {
+      connect_timeout: nil,
+      read_timeout: nil,
+      write_timeout: nil,
+      local_infile: nil,
+      ssl_mode: SSL_MODE_PREFERRED,
+      get_server_public_key: false,
+    }
   end
 
   # Connect to mysqld.
@@ -114,7 +116,7 @@ def connect(host=nil, user=nil, passwd=nil, db=nil, port=nil, socket=nil, flag=0
       warn 'unsupported flag: CLIENT_COMPRESS' if $VERBOSE
       flag &= ~CLIENT_COMPRESS
     end
-    @protocol = Protocol.new host, port, socket, @connect_timeout, @read_timeout, @write_timeout, @local_infile, @ssl_mode, @get_server_public_key
+    @protocol = Protocol.new(host, port, socket, @opts)
     @protocol.authenticate user, passwd, db, flag, @charset
     @charset ||= @protocol.charset
     @host_info = (host.nil? || host == "localhost") ? 'Localhost via UNIX socket' : "#{host} via TCP/IP"
@@ -166,20 +168,20 @@ def options(opt, value=nil)
 #    when Mysql::OPT_CONNECT_ATTR_DELETE
 #    when Mysql::OPT_CONNECT_ATTR_RESET
     when Mysql::OPT_CONNECT_TIMEOUT
-      @connect_timeout = value
+      @opts[:connect_timeout] = value
     when Mysql::OPT_GET_SERVER_PUBLIC_KEY
-      @get_server_public_key = value
+      @opts[:get_server_public_key] = value
     when Mysql::OPT_LOAD_DATA_LOCAL_DIR
-      @local_infile = value
+      @opts[:local_infile] = value
     when Mysql::OPT_LOCAL_INFILE
-      @local_infile = value ? '' : nil
+      @opts[:local_infile] = value ? '' : nil
 #    when Mysql::OPT_MAX_ALLOWED_PACKET
 #    when Mysql::OPT_NAMED_PIPE
 #    when Mysql::OPT_NET_BUFFER_LENGTH
 #    when Mysql::OPT_OPTIONAL_RESULTSET_METADATA
 #    when Mysql::OPT_PROTOCOL
     when Mysql::OPT_READ_TIMEOUT
-      @read_timeout = value.to_i
+      @opts[:read_timeout] = value.to_i
 #    when Mysql::OPT_RECONNECT
 #    when Mysql::OPT_RETRY_COUNT
 #    when Mysql::SET_CLIENT_IP
@@ -192,12 +194,12 @@ def options(opt, value=nil)
 #    when Mysql::OPT_SSL_FIPS_MODE
 #    when Mysql::OPT_SSL_KEY
     when Mysql::OPT_SSL_MODE
-      @ssl_mode = value
+      @opts[:ssl_mode] = value
 #    when Mysql::OPT_TLS_CIPHERSUITES
 #    when Mysql::OPT_TLS_VERSION
 #    when Mysql::OPT_USE_RESULT
     when Mysql::OPT_WRITE_TIMEOUT
-      @write_timeout = value.to_i
+      @opts[:write_timeout] = value.to_i
 #    when Mysql::OPT_ZSTD_COMPRESSION_LEVEL
 #    when Mysql::PLUGIN_DIR
 #    when Mysql::READ_DEFAULT_FILE

lib/mysql/protocol.rb

@@ -130,45 +130,38 @@ def self.value2net(v)
     # :RESULT :: After retr_fields(), retr_all_records() or stmt_retr_all_records() is needed.
 
     # make socket connection to server.
-    # === Argument
-    # host :: [String] if "localhost" or "" nil then use UNIXSocket. Otherwise use TCPSocket
-    # port :: [Integer] port number using by TCPSocket
-    # socket :: [String] socket file name using by UNIXSocket
-    # conn_timeout :: [Integer] connect timeout (sec).
-    # read_timeout :: [Integer] read timeout (sec).
-    # write_timeout :: [Integer] write timeout (sec).
-    # local_infile :: [String] local infile path
-    # ssl_mode :: [Integer]
-    # get_server_public_key :: [Boolean]
-    # === Exception
-    # [ClientError] :: connection timeout
-    def initialize(host, port, socket, conn_timeout, read_timeout, write_timeout, local_infile, ssl_mode, get_server_public_key)
+    # @param host [String] if "localhost" or "" or nil then use UNIX socket. Otherwise use TCP socket
+    # @param port [Integer] port number using by TCP socket
+    # @param socket [String] socket file name using by UNIX socket
+    # @param [Hash] opts
+    # @option opts :conn_timeout [Integer] connect timeout (sec).
+    # @option opts :read_timeout [Integer] read timeout (sec).
+    # @option opts :write_timeout [Integer] write timeout (sec).
+    # @option opts :local_infile [String] local infile path
+    # @option opts :get_server_public_key [Boolean]
+    # @raise [ClientError] connection timeout
+    def initialize(host, port, socket, opts)
+      @opts = opts
       @insert_id = 0
       @warning_count = 0
       @gc_stmt_queue = []   # stmt id list which GC destroy.
       set_state :INIT
-      @read_timeout = read_timeout
-      @write_timeout = write_timeout
-      @local_infile = local_infile
-      @ssl_mode = ssl_mode
-      @get_server_public_key = get_server_public_key
+      @get_server_public_key = @opts[:get_server_public_key]
       begin
-        Timeout.timeout conn_timeout do
-          if host.nil? or host.empty? or host == "localhost"
-            socket ||= ENV["MYSQL_UNIX_PORT"] || MYSQL_UNIX_PORT
-            @sock = UNIXSocket.new socket
-          else
-            port ||= ENV["MYSQL_TCP_PORT"] || (Socket.getservbyname("mysql","tcp") rescue MYSQL_TCP_PORT)
-            @sock = TCPSocket.new host, port
-          end
+        if host.nil? or host.empty? or host == "localhost"
+          socket ||= ENV["MYSQL_UNIX_PORT"] || MYSQL_UNIX_PORT
+          @socket = Socket.unix(socket)
+        else
+          port ||= ENV["MYSQL_TCP_PORT"] || (Socket.getservbyname("mysql","tcp") rescue MYSQL_TCP_PORT)
+          @socket = Socket.tcp(host, port, connect_timeout: @opts[:connect_timeout])
         end
-      rescue Timeout::Error
+      rescue Errno::ETIMEDOUT
         raise ClientError, "connection timeout"
       end
     end
 
     def close
-      @sock.close
+      @socket.close
     end
 
     # initial negotiate and authenticate.
@@ -190,7 +183,7 @@ def authenticate(user, passwd, db, flag, charset)
       @server_capabilities = init_packet.server_capabilities
       @thread_id = init_packet.thread_id
       @client_flags = CLIENT_LONG_PASSWORD | CLIENT_LONG_FLAG | CLIENT_TRANSACTIONS | CLIENT_PROTOCOL_41 | CLIENT_SECURE_CONNECTION | CLIENT_PLUGIN_AUTH
-      @client_flags |= CLIENT_LOCAL_FILES if @local_infile
+      @client_flags |= CLIENT_LOCAL_FILES if @opts[:local_infile]
       @client_flags |= CLIENT_CONNECT_WITH_DB if db
       @client_flags |= flag
       @charset = charset
@@ -204,28 +197,28 @@ def authenticate(user, passwd, db, flag, charset)
     end
 
     def enable_ssl
-      case @ssl_mode
+      case @opts[:ssl_mode]
       when SSL_MODE_DISABLED
         return
       when SSL_MODE_PREFERRED
-        return if @sock.is_a? UNIXSocket
+        return if @socket.local_address.unix?
         return if @server_capabilities & CLIENT_SSL == 0
       when SSL_MODE_REQUIRED
         if @server_capabilities & CLIENT_SSL == 0
           raise ClientError::SslConnectionError, "SSL is required but the server doesn't support it"
         end
       else
-        raise ClientError, "ssl_mode #{@ssl_mode} is not supported"
+        raise ClientError, "ssl_mode #{@opts[:ssl_mode]} is not supported"
       end
       begin
         @client_flags |= CLIENT_SSL
         write Protocol::TlsAuthenticationPacket.serialize(@client_flags, 1024**3, @charset.number)
-        @sock = OpenSSL::SSL::SSLSocket.new(@sock)
-        @sock.sync_close = true
-        @sock.connect
+        @socket = OpenSSL::SSL::SSLSocket.new(@socket)
+        @socket.sync_close = true
+        @socket.connect
       rescue => e
         @client_flags &= ~CLIENT_SSL
-        return if @ssl_mode == SSL_MODE_PREFERRED
+        return if @opts[:ssl_mode] == SSL_MODE_PREFERRED
         raise e
       end
     end
@@ -282,7 +275,7 @@ def get_result
     # send local file to server
     def send_local_file(filename)
       filename = File.absolute_path(filename)
-      if filename.start_with? @local_infile
+      if filename.start_with? @opts[:local_infile]
         File.open(filename){|f| write f}
       else
         raise ClientError::LoadDataLocalInfileRejected, 'LOAD DATA LOCAL INFILE file request rejected due to restrictions on access.'
@@ -482,7 +475,7 @@ def check_state(st)
 
     def set_state(st)
       @state = st
-      if st == :READY
+      if st == :READY && !@gc_stmt_queue.empty?
         gc_disabled = GC.disable
         begin
           while st = @gc_stmt_queue.shift
@@ -518,14 +511,14 @@ def read
       data = ''
       len = nil
       begin
-        Timeout.timeout @read_timeout do
-          header = @sock.read(4)
+        Timeout.timeout @opts[:read_timeout] do
+          header = @socket.read(4)
           raise EOFError unless header && header.length == 4
           len1, len2, seq = header.unpack("CvC")
           len = (len2 << 8) + len1
           raise ProtocolError, "invalid packet: sequence number mismatch(#{seq} != #{@seq}(expected))" if @seq != seq
           @seq = (@seq + 1) % 256
-          ret = @sock.read(len)
+          ret = @socket.read(len)
           raise EOFError unless ret && ret.length == len
           data.concat ret
         end
@@ -558,25 +551,21 @@ def read
     # data :: [String / IO] packet data. If data is nil, write empty packet.
     def write(data)
       begin
-        @sock.sync = false
-        if data.nil?
-          Timeout.timeout @write_timeout do
-            @sock.write [0, 0, @seq].pack("CvC")
-          end
-          @seq = (@seq + 1) % 256
-        else
-          data = StringIO.new data if data.is_a? String
-          while d = data.read(MAX_PACKET_LENGTH)
-            Timeout.timeout @write_timeout do
-              @sock.write [d.length%256, d.length/256, @seq].pack("CvC")
-              @sock.write d
-            end
+        Timeout.timeout @opts[:write_timeout] do
+          @socket.sync = false
+          if data.nil?
+            @socket.write [0, 0, @seq].pack("CvC")
             @seq = (@seq + 1) % 256
+          else
+            data = StringIO.new data if data.is_a? String
+            while d = data.read(MAX_PACKET_LENGTH)
+              @socket.write [d.length%256, d.length/256, @seq].pack("CvC")
+              @socket.write d
+              @seq = (@seq + 1) % 256
+            end
           end
-        end
-        @sock.sync = true
-        Timeout.timeout @write_timeout do
-          @sock.flush
+          @socket.sync = true
+          @socket.flush
         end
       rescue Errno::EPIPE
         raise ClientError::ServerGoneError, 'MySQL server has gone away'

test/test_mysql.rb

@@ -140,8 +140,8 @@ class TestMysql < Test::Unit::TestCase
     end
     test 'OPT_CONNECT_TIMEOUT: set timeout for connecting' do
       assert{ @m.options(Mysql::OPT_CONNECT_TIMEOUT, 0.1) == @m }
-      stub(UNIXSocket).new{ sleep 1}
-      stub(TCPSocket).new{ sleep 1}
+      stub(Socket).tcp{ raise Errno::ETIMEDOUT }
+      stub(Socket).unix{ raise Errno::ETIMEDOUT }
       assert_raise Mysql::ClientError, 'connection timeout' do
         @m.connect(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET)
       end