Class: FastHttp::HttpClient

Inherits:

Object

Object
FastHttp::HttpClient

Includes:: HttpEncoding

Defined in:: lib/fast_http/client.rb

Overview

The actual HttpClient that does the work with the thinnest layer between you and the protocol. All exceptions and leaks are allowed to pass through since those are important when testing. It doesn’t pretend to be a full client, but instead is just enough client to track cookies, form proper HTTP requests, and return HttpResponse hashes with the results.

It’s designed so that you create one client, and then you work it with a minimum of parameters as you need. The initialize method lets you pass in defaults for most of the parameters you’ll need, and you can simple call the method you want and it’ll be translated to an HTTP method (client.get => GET, client.foobar = FOOBAR).

Here’s a few examples:

client = HttpClient.new(:head => {"X-DefaultHeader" => "ONE"})
resp = client.post("/test")
resp = client.post("/test", :head => {"X-TestSend" => "Status"}, :body => "TEST BODY")
resp = client.put("/testput", :query => {"q" => "test"}, :body => "SOME JUNK")
client.reset

The HttpClient.reset call clears cookies that are maintained.

It uses method_missing to do the translation of .put to “PUT /testput HTTP/1.1” so you can get into trouble if you’re calling unknown methods on it. By default the methods are PUT, GET, POST, DELETE, HEAD. You can change the allowed methods by passing :allowed_methods => [:put, :get, ..] to the initialize for the object.

Notifications

You can register a “notifier” with the client that will get called when different events happen. Right now the Notifier class just has a few functions for the common parts of an HTTP request that each take a symbol and some extra parameters. See FastHttp::Notifier for more information.

Parameters

:head => {K => V}  or {K => [V1,V2]}
:query => {K => V} or {K => [V1,V2]}
:body => "some body" (you must encode for now)
:cookies => {K => V} or {K => [V1, V2]}
:allowed_methods => [:put, :get, :post, :delete, :head]
:notifier => Notifier.new
:redirect => false (give it a number and it'll follow redirects for that count)

Constant Summary collapse

TRANSFER_ENCODING =

"TRANSFER_ENCODING"

CONTENT_LENGTH =

"CONTENT_LENGTH"

SET_COOKIE =

"SET_COOKIE"

LOCATION =

"LOCATION"

HOST =

"HOST"

HTTP_REQUEST_HEADER =

"%s %s HTTP/1.1\r\n"

REQ_CONTENT_LENGTH =

"Content-Length"

REQ_HOST =

"Host"

CHUNK_SIZE =

1024 * 16

CRLF =

"\r\n"

Constants included from HttpEncoding

FastHttp::HttpEncoding::COOKIE, FastHttp::HttpEncoding::FIELD_ENCODING

Instance Attribute Summary collapse

#allowed_methods ⇒ Object

Access to the host, port, default options, and cookies currently in play.
#cookies ⇒ Object

Access to the host, port, default options, and cookies currently in play.
#host ⇒ Object

Access to the host, port, default options, and cookies currently in play.
#options ⇒ Object

Access to the host, port, default options, and cookies currently in play.
#port ⇒ Object

Access to the host, port, default options, and cookies currently in play.
#sock ⇒ Object

Access to the host, port, default options, and cookies currently in play.

Instance Method Summary collapse

#build_request(out, method, uri, req) ⇒ Object

Builds a full request from the method, uri, req, and @cookies using the default @options and writes it to out (should be an IO).
#initialize(host, port, options = {}) ⇒ HttpClient constructor

Doesn’t make the connect until you actually call a .put,.get, etc.
#method_missing(symbol, *args) ⇒ Object

Translates unknown function calls into PUT, GET, POST, DELETE, HEAD methods.
#read_chunked_body(header) ⇒ Object

Collects up a chunked body both collecting the body together and collecting the chunks into HttpResponse.raw_chunks[] for alternative analysis.
#read_chunked_header ⇒ Object

Used to process chunked headers and then read up their bodies.
#read_parsed_header ⇒ Object

Does the read operations needed to parse a header with the @parser.
#read_response ⇒ Object

Reads an HTTP response from the given socket.
#redirect(method, resp, *args) ⇒ Object

Keeps doing requests until it doesn’t receive a 3XX request.
#reset ⇒ Object

Clears out the cookies in use so far in order to get a clean slate.
#send_request(method, uri, req) ⇒ Object

Does the socket connect and then build_request, read_response calls finally returning the result.
#store_cookies(resp) ⇒ Object

Reads the SET_COOKIE string out of resp and translates it into the @cookies store for this HttpClient.

Methods included from HttpEncoding

#encode_cookies, #encode_field, #encode_headers, #encode_host, #encode_param, #encode_query, #escape, #query_parse, #unescape

Constructor Details

#initialize(host, port, options = {}) ⇒ `HttpClient`

Doesn’t make the connect until you actually call a .put,.get, etc.

# File 'lib/fast_http/client.rb', line 229

def initialize(host, port, options = {})
  @options = options
  @host = host
  @port = port
  @cookies = options[:cookies]
  @allowed_methods = options[:allowed_methods] || [:put, :get, :post, :delete, :head]
  @redirect = options[:redirect] || false
  @parser = HttpClientParser.new
  @ignore_data = options[:ignore_data]
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(symbol, *args) ⇒ `Object`

Translates unknown function calls into PUT, GET, POST, DELETE, HEAD methods. The allowed HTTP methods allowed are restricted by the during construction with :allowed_methods => [:put, :get, …]

# File 'lib/fast_http/client.rb', line 402

def method_missing(symbol, *args)
  if @allowed_methods.include? symbol
    method = symbol.to_s.upcase
    resp = send_request(method, args[0], args[1] || {})
    resp = redirect(symbol, resp) if @redirect

    return resp
  else
    raise HttpClientError.new("Invalid method: #{symbol}")
  end
end