don't use Timeout.timeout

Author: tmtm

lib/mysql.rb

@@ -181,7 +181,7 @@ def options(opt, value=nil)
 #    when Mysql::OPT_OPTIONAL_RESULTSET_METADATA
 #    when Mysql::OPT_PROTOCOL
     when Mysql::OPT_READ_TIMEOUT
-      @opts[:read_timeout] = value.to_i
+      @opts[:read_timeout] = value
 #    when Mysql::OPT_RECONNECT
 #    when Mysql::OPT_RETRY_COUNT
 #    when Mysql::SET_CLIENT_IP
@@ -199,7 +199,7 @@ def options(opt, value=nil)
 #    when Mysql::OPT_TLS_VERSION
 #    when Mysql::OPT_USE_RESULT
     when Mysql::OPT_WRITE_TIMEOUT
-      @opts[:write_timeout] = value.to_i
+      @opts[:write_timeout] = value
 #    when Mysql::OPT_ZSTD_COMPRESSION_LEVEL
 #    when Mysql::PLUGIN_DIR
 #    when Mysql::READ_DEFAULT_FILE

lib/mysql/authenticator.rb

@@ -55,7 +55,7 @@ def authenticate(user, passwd, db, scramble, plugin_name)
             end
           end
         else
-          raise ClientError, "invalid packet: #{pkt.to_s}"
+          raise ClientError, "invalid packet: #{pkt.rest}"
         end
       end
     end

lib/mysql/authenticator/caching_sha2_password.rb

@@ -20,7 +20,7 @@ def name
       def authenticate(passwd, scramble)
         yield hash_password(passwd, scramble)
         pkt = @protocol.read
-        data = pkt.to_s
+        data = pkt.rest
         if data.size == 2 && data[0] == "\x01"
           case data[1]
           when "\x03"  # fast_auth_success
@@ -34,7 +34,7 @@ def authenticate(passwd, scramble)
               @protocol.write "\2"  # request public key
               pkt = @protocol.read
               pkt.utiny # skip
-              pubkey = pkt.to_s
+              pubkey = pkt.rest
               hash = (passwd+"\0").unpack("C*").zip(scramble.unpack("C*")).map{|a, b| a ^ b}.pack("C*")
               enc = OpenSSL::PKey::RSA.new(pubkey).public_encrypt(hash, OpenSSL::PKey::RSA::PKCS1_OAEP_PADDING)
               @protocol.write enc

lib/mysql/authenticator/sha256_password.rb

@@ -24,10 +24,10 @@ def authenticate(passwd, scramble)
         end
         yield "\x01"  # request public key
         pkt = @protocol.read
-        data = pkt.to_s
+        data = pkt.rest
         if data[0] == "\x01"
           pkt.utiny # skip
-          pubkey = pkt.to_s
+          pubkey = pkt.rest
           hash = (passwd+"\0").unpack("C*").zip(scramble.unpack("C*")).map{|a, b| a ^ b}.pack("C*")
           enc = OpenSSL::PKey::RSA.new(pubkey).public_encrypt(hash, OpenSSL::PKey::RSA::PKCS1_OAEP_PADDING)
           @protocol.write enc

lib/mysql/packet.rb

@@ -70,7 +70,7 @@ def eof?
       @data[0] == ?\xfe && @data.length == 5
     end
 
-    def to_s
+    def rest
       @data
     end
 

lib/mysql/protocol.rb

@@ -3,7 +3,6 @@
 # mailto:[email protected]
 
 require "socket"
-require "timeout"
 require "stringio"
 require "openssl"
 require_relative 'authenticator.rb'
@@ -511,20 +510,18 @@ def read
       data = ''
       len = nil
       begin
-        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 = @socket.read(len)
-          raise EOFError unless ret && ret.length == len
-          data.concat ret
-        end
+        header = read_timeout(4, @opts[:read_timeout])
+        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 = read_timeout(len, @opts[:read_timeout])
+        raise EOFError unless ret && ret.length == len
+        data.concat ret
       rescue EOFError
         raise ClientError::ServerGoneError, 'MySQL server has gone away'
-      rescue Timeout::Error
+      rescue Errno::ETIMEDOUT
         raise ClientError, "read timeout"
       end while len == MAX_PACKET_LENGTH
 
@@ -546,34 +543,73 @@ def read
       Packet.new(data)
     end
 
+    def read_timeout(len, timeout)
+      return @socket.read(len) if timeout.nil? || timeout == 0
+      result = ''
+      e = ::Time.now + timeout
+      while result.size < len
+        now = ::Time.now
+        raise Errno::ETIMEDOUT if now > e
+        r = @socket.read_nonblock(len - result.size, exception: false)
+        case r
+        when :wait_readable
+          IO.select([@socket], nil, nil, e - now)
+          next
+        when :wait_writable
+          IO.select(nil, [@socket], nil, e - now)
+          next
+        else
+          result << r
+        end
+      end
+      return result
+    end
+
     # Write one packet data
     # === Argument
     # data :: [String / IO] packet data. If data is nil, write empty packet.
     def write(data)
       begin
-        Timeout.timeout @opts[:write_timeout] do
-          @socket.sync = false
-          if data.nil?
-            @socket.write [0, 0, @seq].pack("CvC")
+        @socket.sync = false
+        if data.nil?
+          write_timeout([0, 0, @seq].pack("CvC"), @opts[:write_timeout])
+          @seq = (@seq + 1) % 256
+        else
+          data = StringIO.new data if data.is_a? String
+          while d = data.read(MAX_PACKET_LENGTH)
+            write_timeout([d.length%256, d.length/256, @seq].pack("CvC")+d, @opts[:write_timeout])
             @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
-          @socket.sync = true
-          @socket.flush
         end
+        @socket.sync = true
+        @socket.flush
       rescue Errno::EPIPE
         raise ClientError::ServerGoneError, 'MySQL server has gone away'
-      rescue Timeout::Error
+      rescue Errno::ETIMEDOUT
         raise ClientError, "write timeout"
       end
     end
 
+    def write_timeout(data, timeout)
+      return @socket.write(data) if timeout.nil? || timeout == 0
+      len = 0
+      e = ::Time.now + timeout
+      while len < data.size
+        now = ::Time.now
+        raise Errno::ETIMEDOUT if now > e
+        l = @socket.write_nonblock(data[len..-1], exception: false)
+        case l
+        when :wait_readable
+          IO.select([@socket], nil, nil, e - now)
+        when :wait_writable
+          IO.select(nil, [@socket], nil, e - now)
+        else
+          len += l
+        end
+      end
+      return len
+    end
+
     # Read EOF packet
     # === Exception
     # [ProtocolError] packet is not EOF

test/test_mysql.rb

@@ -201,10 +201,14 @@ class TestMysql < Test::Unit::TestCase
       end
     end
     test 'OPT_READ_TIMEOUT: set timeout for reading packet' do
-      assert{ @m.options(Mysql::OPT_READ_TIMEOUT, 10) == @m }
+      assert{ @m.options(Mysql::OPT_READ_TIMEOUT, 1) == @m }
+      @m.connect(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET)
+      @m.query("select 123").entries
     end
     test 'OPT_WRITE_TIMEOUT: set timeout for writing packet' do
-      assert{ @m.options(Mysql::OPT_WRITE_TIMEOUT, 10) == @m }
+      assert{ @m.options(Mysql::OPT_WRITE_TIMEOUT, 1) == @m }
+      @m.connect(MYSQL_SERVER, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE, MYSQL_PORT, MYSQL_SOCKET)
+      @m.query("select 123").entries
     end
     test 'SET_CHARSET_NAME: set charset for connection' do
       assert{ @m.options(Mysql::SET_CHARSET_NAME, 'utf8mb3') == @m }