Allow HTTP::Client to work with any IO

spec/std/http/client/client_spec.cr

@@ -265,5 +265,40 @@ module HTTP
         request.host.should eq "other.example.com"
       end
     end
+
+    it "works with IO" do
+      io_response = IO::Memory.new <<-RESPONSE.gsub('\n', "\r\n")
+      HTTP/1.1 200 OK
+      Content-Type: text/plain
+      Content-Length: 3
+
+      Hi!
+      RESPONSE
+      io_request = IO::Memory.new
+      io = IO::Stapled.new(io_response, io_request)
+      client = Client.new(io)
+      response = client.get("/")
+      response.body.should eq("Hi!")
+
+      io_request.rewind
+      request = HTTP::Request.from_io(io_request).as(HTTP::Request)
+      request.host.should eq("")
+    end
+
+    it "can specify host and port when initialized with IO" do
+      client = Client.new(IO::Memory.new, "host", 1234)
+      client.host.should eq("host")
+      client.port.should eq(1234)
+    end
+
+    it "cannot reconnect when initialized with IO" do
+      io = IO::Memory.new
+      client = Client.new(io)
+      client.close
+      io.closed?.should be_true
+      expect_raises(Exception, "This HTTP::Client cannot be reconnected") do
+        client.get("/")
+      end
+    end
   end
 end

spec/std/http/server/server_spec.cr

@@ -493,7 +493,7 @@ describe "#remote_address" do
       HTTP::Client.new(URI.parse("http://#{address1}/")) do |client|
         client.get("/")
 
-        remote_address.should eq(client.@socket.as(IPSocket).local_address)
+        remote_address.should eq(client.@io.as(IPSocket).local_address)
       end
     end
   end
@@ -516,7 +516,7 @@ describe "#remote_address" do
         uri: URI.parse("https://#{ip_address1}"),
         tls: client_context) do |client|
         client.get("/")
-        remote_address.should eq(client.@socket.as(OpenSSL::SSL::Socket).local_address)
+        remote_address.should eq(client.@io.as(OpenSSL::SSL::Socket).local_address)
       end
     end
   end

src/http/client.cr

@@ -105,21 +105,21 @@ class HTTP::Client
   # ```
   {% if flag?(:without_openssl) %}
     getter! tls : Nil
-    @socket : TCPSocket | Nil
     alias TLSContext = Bool | Nil
   {% else %}
     getter! tls : OpenSSL::SSL::Context::Client
-    @socket : TCPSocket | OpenSSL::SSL::Socket | Nil
     alias TLSContext = OpenSSL::SSL::Context::Client | Bool | Nil
   {% end %}
 
   # Whether automatic compression/decompression is enabled.
   property? compress : Bool = true
 
+  @io : IO?
   @dns_timeout : Float64?
   @connect_timeout : Float64?
   @read_timeout : Float64?
   @write_timeout : Float64?
+  @reconnect = true
 
   # Creates a new HTTP client with the given *host*, *port* and *tls*
   # configurations. If no port is given, the default one will
@@ -148,6 +148,16 @@ class HTTP::Client
     @port = (port || (@tls ? 443 : 80)).to_i
   end
 
+  # Creates a new HTTP client bound to an existing `IO`.
+  # *host* and *port* can be specified and they will be used
+  # to conform the `Host` header on each request.
+  # Instances created with this constructor cannot be reconnected. Once
+  # `close` is called explicitly or if the connection doesn't support keep-alive,
+  # the next call to make a request will raise an exception.
+  def initialize(@io : IO, @host = "", @port = 80)
+    @reconnect = false
+  end
+
   private def check_host_only(string : String)
     # When parsing a URI with just a host
     # we end up with a URI with just a path
@@ -585,7 +595,7 @@ class HTTP::Client
 
   private def exec_internal_single(request)
     decompress = send_request(request)
-    HTTP::Client::Response.from_io?(socket, ignore_body: request.ignore_body?, decompress: decompress)
+    HTTP::Client::Response.from_io?(io, ignore_body: request.ignore_body?, decompress: decompress)
   end
 
   private def handle_response(response)
@@ -632,7 +642,7 @@ class HTTP::Client
 
   private def exec_internal_single(request)
     decompress = send_request(request)
-    HTTP::Client::Response.from_io?(socket, ignore_body: request.ignore_body?, decompress: decompress) do |response|
+    HTTP::Client::Response.from_io?(io, ignore_body: request.ignore_body?, decompress: decompress) do |response|
       yield response
     end
   end
@@ -647,8 +657,8 @@ class HTTP::Client
   private def send_request(request)
     decompress = set_defaults request
     run_before_request_callbacks(request)
-    request.to_io(socket)
-    socket.flush
+    request.to_io(io)
+    io.flush
     decompress
   end
 
@@ -746,29 +756,32 @@ class HTTP::Client
 
   # Closes this client. If used again, a new connection will be opened.
   def close
-    @socket.try &.close
-    @socket = nil
+    @io.try &.close
+    @io = nil
   end
 
   private def new_request(method, path, headers, body : BodyType)
     HTTP::Request.new(method, path, headers, body)
   end
 
-  private def socket
-    socket = @socket
-    return socket if socket
+  private def io
+    io = @io
+    return io if io
+    unless @reconnect
+      raise "This HTTP::Client cannot be reconnected"
+    end
 
     hostname = @host.starts_with?('[') && @host.ends_with?(']') ? @host[1..-2] : @host
-    socket = TCPSocket.new hostname, @port, @dns_timeout, @connect_timeout
-    socket.read_timeout = @read_timeout if @read_timeout
-    socket.write_timeout = @write_timeout if @write_timeout
-    socket.sync = false
+    io = TCPSocket.new hostname, @port, @dns_timeout, @connect_timeout
+    io.read_timeout = @read_timeout if @read_timeout
+    io.write_timeout = @write_timeout if @write_timeout
+    io.sync = false
 
     {% if !flag?(:without_openssl) %}
       if tls = @tls
-        tcp_socket = socket
+        tcp_socket = io
         begin
-          socket = OpenSSL::SSL::Socket::Client.new(tcp_socket, context: tls, sync_close: true, hostname: @host)
+          io = OpenSSL::SSL::Socket::Client.new(tcp_socket, context: tls, sync_close: true, hostname: @host)
         rescue exc
           # don't leak the TCP socket when the SSL connection failed
           tcp_socket.close
@@ -777,7 +790,7 @@ class HTTP::Client
       end
     {% end %}
 
-    @socket = socket
+    @io = io
   end
 
   private def host_header