http_client 0.5.0-universal-java-1.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a120508893a08fdf41e1cd67421138ae3e043088
+  data.tar.gz: eca3be3cb0a0f5c12f112ceb8a384a99269b6081
+SHA512:
+  metadata.gz: 3d4477baa911fbfdd8750816571d862f4a55e892e7e90fd39e9483668f9e634ff62970f1d722f6651fe9ea5b27ae9867556bfb8a4e23760d59e49b7384343eb4
+  data.tar.gz: b1dd2383ee8362db2199e942cf297872315e3e90f3d0cdadac17602a1e8810b2bf090ac34984537f4ad5f8496dd499038fab013cfaa35eb0d512e63d1c45379e

data/README.md

@@ -0,0 +1,79 @@
+# A simple yet powerful HTTP client for JRuby
+
+This library wraps the Apache HTTPClient (4.3) in a simple fashion.
+It currently implements all common HTTP verbs, connection pooling, retries and transparent gzip response handling. All common exceptions from Javaland are wrapped as Ruby exceptions. The library is intended to be used in a multithreaded environment.
+
+## Examples
+
+#### A simple GET request
+
+```ruby
+require "http_client"
+
+client = HTTPClient.new
+response = client.get("http://www.google.com/robots.txt")
+
+response.status
+# => 200
+
+response.body
+# =>
+# User-agent: *
+# ...
+```
+
+#### POST a form
+
+```ruby
+response = client.post("http://geocities.com/darrensden/guestbook",
+  :form => {
+    :name => "Joe Stub",
+    :email => "joey@ymail.com",
+    :comment => "Hey, I really like your site! Awesome stuff"
+  }
+)
+```
+
+#### POST JSON data
+
+```ruby
+response = client.post("http://webtwoopointo.com/v1/api/guestbooks/123/comments",
+  :json => {
+    :name => "Jason",
+    :email => "jaz0r@gmail.com",
+    :comment => "Yo dawg, luv ur site!"
+  }
+)
+```
+
+#### Provide request headers
+
+```ruby
+response = client.get("http://secretservice.com/users/123",
+  :headers => { "X-Auth": "deadbeef23" }
+)
+```
+
+#### Using a connection pool
+
+```ruby
+$client = HTTPClient.new(
+  :use_connection_pool => true,
+  :max_connections => 10,
+)
+
+%[www.google.de www.yahoo.com www.altavista.com].each do |host|
+  Thread.new do
+    response = $client.get("http://#{host}/robots.txt")
+    puts response.body
+  end
+end
+```
+
+## Contribute
+
+This library covers just what I need. I wanted to have a thread safe HTTP client that has a fixed connection pool with fine grained timeout configurations.
+
+Before you start hacking away, have a look at the issues. There might be stuff that is already in the making. If so, there will be a published branch you can contribute to.
+
+Just create a fork and send me a pull request. I would be honored to look at your input.

data/http_client.gemspec

@@ -0,0 +1,15 @@
+Gem::Specification.new do |s|
+  s.name = "http_client"
+  s.version = "0.5.0"
+  s.date = "2013-11-07"
+  s.summary = "HTTP client for JRuby"
+  s.description = "This library wraps the Apache HTTPClient (4.3) in a simple fashion. The library is intended to be used in a multithreaded environment."
+  s.platform = Gem::Platform::CURRENT
+  s.requirements << "JRuby"
+  s.requirements << "Java, since this library wraps a Java library"
+  s.authors = ["Lukas Rieder"]
+  s.email = "l.rieder@gmail.com"
+  s.files = Dir["**/*"]
+  s.homepage = "https://github.com/Overbryd/http_client"
+  s.license = "MIT"
+end

data/lib/http_client.rb

@@ -0,0 +1,223 @@
+# coding: utf-8
+
+require "uri"
+require "java"
+%w[httpcore-4.3 httpclient-4.3.1 httpmime-4.3.1 commons-logging-1.1.3].each do |jar|
+  require_relative "../vendor/#{jar}.jar"
+end
+
+class HttpClient
+  import org.apache.http.impl.client.HttpClients
+  import org.apache.http.impl.conn.BasicHttpClientConnectionManager
+  import org.apache.http.impl.conn.PoolingHttpClientConnectionManager
+  import org.apache.http.client.methods.HttpGet
+  import org.apache.http.client.methods.HttpPost
+  import org.apache.http.client.methods.HttpPut
+  import org.apache.http.client.methods.HttpPatch
+  import org.apache.http.client.methods.HttpDelete
+  import org.apache.http.client.methods.HttpHead
+  import org.apache.http.client.methods.HttpOptions
+  import org.apache.http.client.config.RequestConfig
+  import org.apache.http.entity.StringEntity
+  import org.apache.http.client.entity.UrlEncodedFormEntity
+  import org.apache.http.client.entity.GzipDecompressingEntity
+  import org.apache.http.client.entity.DeflateDecompressingEntity
+  import org.apache.http.message.BasicNameValuePair
+  import org.apache.http.entity.ContentType
+  import org.apache.http.util.EntityUtils
+  import org.apache.http.HttpException
+  import org.apache.http.conn.ConnectTimeoutException
+  import java.io.IOException
+  import java.net.SocketTimeoutException
+  import java.util.concurrent.TimeUnit
+
+  class Error < StandardError; end
+  class Timeout < Error; end
+  class IOError < Error; end
+
+  class Response
+    attr_reader :status, :body, :headers
+
+    def initialize(closeable_response)
+      @status = closeable_response.status_line.status_code
+      @headers = closeable_response.get_all_headers.inject({}) do |headers, header|
+        headers[header.name] = header.value
+        headers
+      end
+      @body = read_body(closeable_response)
+    end
+
+    def success?
+      @status >= 200 && @status <= 206
+    end
+
+    def json_body(options = {})
+      @json_body ||= JSON.parse(body, options)
+    end
+
+  private
+
+    def read_body(closeable_response)
+      return "" unless entity = closeable_response.entity
+      return "" unless entity.content_length > 0
+      if content_encoding = entity.content_encoding
+        entity = case content_encoding.value
+          when "gzip", "x-gzip" then
+            GzipDecompressingEntity.new(entity)
+          when "deflate" then
+            DeflateDecompressingEntity.new(entity)
+          else
+            entity
+        end
+      end
+      EntityUtils.to_string(entity, "UTF-8")
+    end
+  end
+
+  attr_reader :client, :max_retries, :response_class, :default_request_options
+
+  def initialize(options = {})
+    options = {
+      :use_connection_pool => false,
+      :max_connections => 20,
+      :max_connections_per_route => nil,
+      :max_retries => 0,
+      :response_class => Response,
+      :connection_request_timeout => 100,
+      :connect_timeout => 1000,
+      :socket_timeout => 2000,
+      :default_request_options => {}
+    }.merge(options)
+    @request_config = create_request_config(options)
+    @connection_manager = create_connection_manager(options)
+    @client = HttpClients.create_minimal(@connection_manager)
+    @max_retries = options[:max_retries]
+    @response_class = options[:response_class]
+    @default_request_options = options[:default_request_options]
+  end
+
+  def get(uri, options = {})
+    uri = uri.sub(/\?.+$|$/, "?#{URI.encode_www_form(options[:params])}") if options[:params]
+    request = create_request(HttpGet, uri, options)
+    execute(request)
+  end
+
+  def post(uri, options = {})
+    request = create_request(HttpPost, uri, options)
+    entity = create_entity(options)
+    request.set_entity(entity) if entity
+    execute(request)
+  end
+
+  def put(uri, options = {})
+    request = create_request(HttpPut, uri, options)
+    entity = create_entity(options)
+    request.set_entity(entity) if entity
+    execute(request)
+  end
+
+  def patch(uri, options = {})
+    request = create_request(HttpPatch, uri, options)
+    entity = create_entity(options)
+    request.set_entity(entity) if entity
+    execute(request)
+  end
+
+  def delete(uri, options = {})
+    request = create_request(HttpDelete, uri, options)
+    execute(request)
+  end
+
+  def head(uri, options = {})
+    request = create_request(HttpHead, uri, options)
+    execute(request)
+  end
+
+  def options(uri, options = {})
+    request = create_request(HttpOptions, uri, options)
+    execute(request)
+  end
+
+  def pool_stats
+    raise "#{self.class.name}#pool_stats is supported only when using a connection pool" unless @connection_manager.is_a?(PoolingHttpClientConnectionManager)
+    total_stats = @connection_manager.total_stats
+    Hash(
+      :idle => total_stats.available,
+      :in_use => total_stats.leased,
+      :max => total_stats.max,
+      :waiting => total_stats.pending
+    )
+  end
+
+  def cleanup_connections(max_idle = 5)
+    @connection_manager.close_idle_connections(max_idle, TimeUnit::SECONDS)
+  end
+
+  def shutdown
+    @connection_manager.shutdown
+  end
+
+private
+
+  def execute(request)
+    retries = max_retries
+    begin
+      closeable_response = client.execute(request)
+      response_class.new(closeable_response)
+    rescue ConnectTimeoutException, SocketTimeoutException => e
+      retry if (retries -= 1) > 0
+      raise Timeout, "#{e.message}"
+    rescue IOException => e
+      retry if (retries -= 1) > 0
+      raise IOError, "#{e.message}"
+    rescue HttpException => e
+      raise Error, "#{e.message}"
+    ensure
+      closeable_response.close if closeable_response
+    end
+  end
+
+  def create_request(method_class, uri, options)
+    request = method_class.new(uri)
+    request.config = @request_config
+    options = default_request_options.merge(options)
+    options[:headers].each do |name, value|
+      request.set_header(name.to_s.gsub("_", "-"), value)
+    end if options[:headers]
+    request
+  end
+
+  def create_entity(options)
+    if options[:body]
+      StringEntity.new(options[:body], ContentType.create(options[:content_type] || "text/plain", "UTF-8"))
+    elsif options[:json]
+      json = options[:json].to_json
+      StringEntity.new(json, ContentType.create("application/json", "UTF-8"))
+    elsif options[:form]
+      form = options[:form].map { |k, v| BasicNameValuePair.new(k.to_s, v.to_s) }
+      UrlEncodedFormEntity.new(form, "UTF-8")
+    else
+      nil
+    end
+  end
+
+  def create_request_config(options)
+    config = RequestConfig.custom
+    config.set_stale_connection_check_enabled(true)
+    config.set_connection_request_timeout(options[:connection_request_timeout])
+    config.set_connect_timeout(options[:connect_timeout])
+    config.set_socket_timeout(options[:socket_timeout])
+    config.build
+  end
+
+  def create_connection_manager(options)
+    options[:use_connection_pool] ? create_pooling_connection_manager(options) : BasicHttpClientConnectionManager.new
+  end
+
+  def create_pooling_connection_manager(options)
+    connection_manager = PoolingHttpClientConnectionManager.new
+    connection_manager.max_total = options[:max_connections]
+    connection_manager.default_max_per_route = options[:max_connections_per_route] || options[:max_connections]
+  end
+
+end

data/test/http_client_test.rb

@@ -0,0 +1,95 @@
+# coding: utf-8
+
+require "rubygems"
+gem "minitest"
+require "minitest/pride"
+require "minitest/autorun"
+
+require "json"
+require_relative "../lib/http_client"
+
+module Minitest
+  class Test
+    def self.test(name, &block)
+      define_method("test_#{name.gsub(" ", " ")}", &block)
+    end
+  end
+end
+
+class HttpClientTest < Minitest::Test
+  attr_reader :client
+
+  def setup
+    @client = HttpClient.new
+  end
+
+  test "GET request with params in uri" do
+    response = client.get("http://httpbin.org/get?foo=bar")
+    assert_equal Hash("foo" => "bar"), response.json_body["args"]
+  end
+
+  test "GET request with params in options" do
+    response = client.get("http://httpbin.org/get", :params => { :foo => "bar" })
+    assert_equal Hash("foo" => "bar"), response.json_body["args"]
+  end
+
+  test "GET request with headers" do
+    response = client.get("http://httpbin.org/get", :headers => { "X-Send-By" => "foobar" })
+    assert_equal "foobar", response.json_body["headers"]["X-Send-By"]
+  end
+
+  test "GET request with gzipped response" do
+    response = client.get("http://httpbin.org/gzip")
+    assert_equal true, response.json_body["gzipped"]
+    assert_nil response.json_body["headers"]["Content-Encoding"]
+  end
+
+  test "POST request with string body" do
+    response = client.post("http://httpbin.org/post", :body => "foo:bar|zig:zag")
+    assert_equal "text/plain; charset=UTF-8", response.json_body["headers"]["Content-Type"]
+    assert_equal "foo:bar|zig:zag", response.json_body["data"]
+  end
+
+  test "POST request with form data" do
+    response = client.post("http://httpbin.org/post", :form => { :foo => "bar"})
+    assert_equal "application/x-www-form-urlencoded; charset=UTF-8", response.json_body["headers"]["Content-Type"]
+    assert_equal Hash("foo" => "bar"), response.json_body["form"]
+  end
+
+  test "POST request with json data" do
+    response = client.post("http://httpbin.org/post", :json => { :foo => "bar"})
+    assert_equal "application/json; charset=UTF-8", response.json_body["headers"]["Content-Type"]
+    assert_equal Hash("foo" => "bar"), response.json_body["json"]
+  end
+
+  test "POST request Content-Type in header takes precedence" do
+    response = client.post("http://httpbin.org/post",
+      :json => { "foo" => "bar" },
+      :headers => { "Content-Type" => "application/x-json" }
+    )
+    assert_equal "application/x-json", response.json_body["headers"]["Content-Type"]
+  end
+end
+
+# # Content-Type precedence
+# 
+# client.post("http://httpbin.org/post",
+#   :headers => {
+#     :content_type => "application/xml"
+#   },
+#   :body => %Q'<?xml version="1.0" encoding="utf-8"?><foo>bar</foo>'
+# )
+# client.post("http://httpbin.org/post",
+#   :content_type => "application/xml+foo",
+#   :headers => {
+#     :content_type => "application/xml"
+#   },
+#   :body => %Q'<?xml version="1.0" encoding="utf-8"?><foo>bar</foo>'
+# )
+# client.post("http://httpbin.org/post",
+#   :content_type => "application/xml+foo",
+#   :headers => {
+#     :content_type => "application/xml"
+#   },
+#   :json => %Q'{"foo":"bar"}'
+# )

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: http_client
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+platform: universal-java-1.7
+authors:
+- Lukas Rieder
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2013-11-07 00:00:00.000000000 Z
+dependencies: []
+description: This library wraps the Apache HTTPClient (4.3) in a simple fashion. The library is intended to be used in a multithreaded environment.
+email: l.rieder@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- http_client-0.5.0-universal-java-1.7.gem
+- http_client-0.5.0.gem
+- http_client.gemspec
+- README.md
+- lib/http_client.rb
+- test/http_client_test.rb
+- vendor/commons-logging-1.1.3.jar
+- vendor/httpclient-4.3.1.jar
+- vendor/httpcore-4.3.jar
+- vendor/httpmime-4.3.1.jar
+homepage: https://github.com/Overbryd/http_client
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- JRuby
+- Java, since this library wraps a Java library
+rubyforge_project:
+rubygems_version: 2.1.9
+signing_key:
+specification_version: 4
+summary: HTTP client for JRuby
+test_files: []