httpx 0.20.0 → 1.3.1

data/lib/httpx/io/tcp.rb

@@ -17,7 +17,7 @@ module HTTPX
       @state = :idle
       @addresses = []
       @hostname = origin.host
-      @options = Options.new(options)
+      @options = options
       @fallback_protocol = @options.fallback_protocol
       @port = origin.port
       @interests = :w
@@ -38,7 +38,10 @@ module HTTPX
         add_addresses(addresses)
       end
       @ip_index = @addresses.size - 1
-      # @io ||= build_socket
+    end
+
+    def socket
+      @io
     end
 
     def add_addresses(addrs)
@@ -74,7 +77,9 @@ module HTTPX
       try_connect
     rescue Errno::ECONNREFUSED,
            Errno::EADDRNOTAVAIL,
-           Errno::EHOSTUNREACH => e
+           Errno::EHOSTUNREACH,
+           SocketError,
+           IOError => e
       raise e if @ip_index <= 0
 
       log { "failed connecting to #{@ip} (#{e.message}), trying next..." }
@@ -90,84 +95,45 @@ module HTTPX
       retry
     end
 
-    if RUBY_VERSION < "2.3"
-      # :nocov:
-      def try_connect
-        @io.connect_nonblock(Socket.sockaddr_in(@port, @ip.to_s))
-      rescue ::IO::WaitWritable, Errno::EALREADY
-        @interests = :w
-      rescue ::IO::WaitReadable
+    def try_connect
+      ret = @io.connect_nonblock(Socket.sockaddr_in(@port, @ip.to_s), exception: false)
+      log(level: 3, color: :cyan) { "TCP CONNECT: #{ret}..." }
+      case ret
+      when :wait_readable
         @interests = :r
-      rescue Errno::EISCONN
-        transition(:connected)
-        @interests = :w
-      else
-        transition(:connected)
+        return
+      when :wait_writable
         @interests = :w
+        return
       end
-      private :try_connect
+      transition(:connected)
+      @interests = :w
+    rescue Errno::EALREADY
+      @interests = :w
+    end
+    private :try_connect
 
-      def read(size, buffer)
-        @io.read_nonblock(size, buffer)
-        log { "READ: #{buffer.bytesize} bytes..." }
-        buffer.bytesize
-      rescue ::IO::WaitReadable
+    def read(size, buffer)
+      ret = @io.read_nonblock(size, buffer, exception: false)
+      if ret == :wait_readable
         buffer.clear
-        0
-      rescue EOFError
-        nil
-      end
-
-      def write(buffer)
-        siz = @io.write_nonblock(buffer)
-        log { "WRITE: #{siz} bytes..." }
-        buffer.shift!(siz)
-        siz
-      rescue ::IO::WaitWritable
-        0
-      rescue EOFError
-        nil
-      end
-      # :nocov:
-    else
-      def try_connect
-        case @io.connect_nonblock(Socket.sockaddr_in(@port, @ip.to_s), exception: false)
-        when :wait_readable
-          @interests = :r
-          return
-        when :wait_writable
-          @interests = :w
-          return
-        end
-        transition(:connected)
-        @interests = :w
-      rescue Errno::EALREADY
-        @interests = :w
+        return 0
       end
-      private :try_connect
-
-      def read(size, buffer)
-        ret = @io.read_nonblock(size, buffer, exception: false)
-        if ret == :wait_readable
-          buffer.clear
-          return 0
-        end
-        return if ret.nil?
+      return if ret.nil?
 
-        log { "READ: #{buffer.bytesize} bytes..." }
-        buffer.bytesize
-      end
+      log { "READ: #{buffer.bytesize} bytes..." }
+      buffer.bytesize
+    end
 
-      def write(buffer)
-        siz = @io.write_nonblock(buffer, exception: false)
-        return 0 if siz == :wait_writable
-        return if siz.nil?
+    def write(buffer)
+      siz = @io.write_nonblock(buffer, exception: false)
+      return 0 if siz == :wait_writable
+      return if siz.nil?
 
-        log { "WRITE: #{siz} bytes..." }
+      log { "WRITE: #{siz} bytes..." }
 
-        buffer.shift!(siz)
-        siz
-      end
+      buffer.shift!(siz)
+      siz
     end
 
     def close
@@ -188,6 +154,17 @@ module HTTPX
       @state == :idle || @state == :closed
     end
 
+    def expired?
+      # do not mess with external sockets
+      return false if @options.io
+
+      return true unless @addresses
+
+      resolver_addresses = Resolver.nolookup_resolve(@hostname)
+
+      (Array(resolver_addresses) & @addresses).empty?
+    end
+
     # :nocov:
     def inspect
       "#<#{self.class}: #{@ip}:#{@port} (state: #{@state})>"

data/lib/httpx/io/udp.rb

@@ -6,11 +6,10 @@ module HTTPX
   class UDP
     include Loggable
 
-    def initialize(uri, _, options)
-      ip = IPAddr.new(uri.host)
-      @host = ip.to_s
-      @port = uri.port
-      @io = UDPSocket.new(ip.family)
+    def initialize(ip, port, options)
+      @host = ip
+      @port = port
+      @io = UDPSocket.new(IPAddr.new(ip).family)
       @options = options
     end
 
@@ -24,45 +23,19 @@ module HTTPX
       true
     end
 
-    if RUBY_VERSION < "2.3"
-      # :nocov:
-      def close
-        @io.close
-      rescue StandardError
-        nil
-      end
-      # :nocov:
-    else
-      def close
-        @io.close
-      end
+    def close
+      @io.close
     end
 
-    # :nocov:
-    if (RUBY_ENGINE == "truffleruby" && RUBY_ENGINE_VERSION < "21.1.0") ||
-       RUBY_VERSION < "2.3"
+    if RUBY_ENGINE == "jruby"
+      # In JRuby, sendmsg_nonblock is not implemented
       def write(buffer)
-        siz = @io.sendmsg_nonblock(buffer.to_s, 0, Socket.sockaddr_in(@port, @host.to_s))
+        siz = @io.send(buffer.to_s, 0, @host, @port)
         log { "WRITE: #{siz} bytes..." }
         buffer.shift!(siz)
         siz
-      rescue ::IO::WaitWritable
-        0
-      rescue EOFError
-        nil
-      end
-
-      def read(size, buffer)
-        data, _ = @io.recvfrom_nonblock(size)
-        buffer.replace(data)
-        log { "READ: #{buffer.bytesize} bytes..." }
-        buffer.bytesize
-      rescue ::IO::WaitReadable
-        0
-      rescue IOError
       end
     else
-
       def write(buffer)
         siz = @io.sendmsg_nonblock(buffer.to_s, 0, Socket.sockaddr_in(@port, @host.to_s), exception: false)
         return 0 if siz == :wait_writable
@@ -73,24 +46,17 @@ module HTTPX
         buffer.shift!(siz)
         siz
       end
+    end
 
-      def read(size, buffer)
-        ret = @io.recvfrom_nonblock(size, 0, buffer, exception: false)
-        return 0 if ret == :wait_readable
-        return if ret.nil?
+    def read(size, buffer)
+      ret = @io.recvfrom_nonblock(size, 0, buffer, exception: false)
+      return 0 if ret == :wait_readable
+      return if ret.nil?
 
-        buffer.bytesize
-      rescue IOError
-      end
-    end
+      log { "READ: #{buffer.bytesize} bytes..." }
 
-    # In JRuby, sendmsg_nonblock is not implemented
-    def write(buffer)
-      siz = @io.send(buffer.to_s, 0, @host, @port)
-      log { "WRITE: #{siz} bytes..." }
-      buffer.shift!(siz)
-      siz
-    end if RUBY_ENGINE == "jruby"
-    # :nocov:
+      buffer.bytesize
+    rescue IOError
+    end
   end
 end

data/lib/httpx/io/unix.rb

@@ -1,22 +1,18 @@
 # frozen_string_literal: true
 
-require "forwardable"
-
 module HTTPX
   class UNIX < TCP
-    extend Forwardable
-
     using URIExtensions
 
     attr_reader :path
 
     alias_method :host, :path
 
-    def initialize(origin, addresses, options)
-      @addresses = addresses
+    def initialize(origin, path, options)
+      @addresses = []
       @hostname = origin.host
       @state = :idle
-      @options = Options.new(options)
+      @options = options
       @fallback_protocol = @options.fallback_protocol
       if @options.io
         @io = case @options.io
@@ -30,15 +26,10 @@ module HTTPX
         @path = @io.path
         @keep_open = true
         @state = :connected
+      elsif path
+        @path = path
       else
-        if @options.transport_options
-          # :nocov:
-          warn ":#{__method__} is deprecated, use :addresses instead"
-          @path = @options.transport_options[:path]
-          # :nocov:
-        else
-          @path = addresses.first
-        end
+        raise Error, "No path given where to store the socket"
       end
       @io ||= build_socket
     end
@@ -60,6 +51,10 @@ module HTTPX
            ::IO::WaitReadable
     end
 
+    def expired?
+      false
+    end
+
     # :nocov:
     def inspect
       "#<#{self.class}(path: #{@path}): (state: #{@state})>"

data/lib/httpx/io.rb

@@ -4,14 +4,8 @@ require "socket"
 require "httpx/io/udp"
 require "httpx/io/tcp"
 require "httpx/io/unix"
-require "httpx/io/ssl"
 
-module HTTPX
-  module IO
-    extend Registry
-    register "udp", UDP
-    register "unix", HTTPX::UNIX
-    register "tcp", TCP
-    register "ssl", SSL
-  end
+begin
+  require "httpx/io/ssl"
+rescue LoadError
 end

data/lib/httpx/loggable.rb

@@ -24,26 +24,11 @@ module HTTPX
       debug_stream << message
     end
 
-    if Exception.instance_methods.include?(:full_message)
-
-      def log_exception(ex, level: @options.debug_level, color: nil)
-        return unless @options.debug
-        return unless @options.debug_level >= level
-
-        log(level: level, color: color) { ex.full_message }
-      end
-
-    else
-
-      def log_exception(ex, level: @options.debug_level, color: nil)
-        return unless @options.debug
-        return unless @options.debug_level >= level
-
-        message = +"#{ex.message} (#{ex.class})"
-        message << "\n" << ex.backtrace.join("\n") unless ex.backtrace.nil?
-        log(level: level, color: color) { message }
-      end
+    def log_exception(ex, level: @options.debug_level, color: nil)
+      return unless @options.debug
+      return unless @options.debug_level >= level
 
+      log(level: level, color: color) { ex.full_message }
     end
   end
 end