http_client 0.5.3-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b421fafaae4821bf74f136d92e5ba9c54da80482
+  data.tar.gz: 767e58bcfc6e22c21093ba51dc1f8995cab036b9
+SHA512:
+  metadata.gz: f2b280ef32020b5b4a14b1eeae03afe94dd24520c55e11108ad347a22d826d49226ddef862d2ffa8153d893d60c78bd1d3b90309a0009c48019bbcf8a71df68b
+  data.tar.gz: c91ad4500a47825a572ff51dcab97cc37239fa1ebded2a69d44e3549cd8d2e9f462513a8d39ba8b475b36085be03ffc0689ed9ef4cde8d390cc39857a0513db2

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+group :test do
+  gem "minitest"
+  gem "json"
+end

data/Gemfile.lock

@@ -0,0 +1,12 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    json (1.8.1-java)
+    minitest (5.0.8)
+
+PLATFORMS
+  java
+
+DEPENDENCIES
+  json
+  minitest

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Lukas Rieder
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,85 @@
+# 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](https://github.com/Overbryd/http_client/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.
+
+![Build Status](https://travis-ci.org/Overbryd/http_client.png)
+
+## Legal
+
+Copyright by Lukas Rieder, 2013, Licensed under the MIT License, see LICENSE

data/http_client.gemspec

@@ -0,0 +1,15 @@
+Gem::Specification.new do |s|
+  s.name = "http_client"
+  s.version = "0.5.3"
+  s.date = "2013-11-08"
+  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 = "java"
+  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["**/*"].reject { |path| path =~ /\.gem$/ }
+  s.homepage = "https://github.com/Overbryd/http_client"
+  s.license = "MIT"
+end

data/lib/http_client.rb

@@ -0,0 +1,231 @@
+# coding: utf-8
+
+require "uri"
+require "base64"
+require "java"
+%w[httpcore-4.3 httpclient-4.3.1 httpmime-4.3.1 commons-logging-1.1.3].each do |jar|
+  require File.expand_path("../../vendor/#{jar}.jar", __FILE__)
+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.is_chunked? || 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)
+    set_basic_auth(request, options[:basic_auth])
+    options[:headers].each do |name, value|
+      request.set_header(name.to_s.gsub("_", "-"), value)
+    end if options[:headers]
+    request
+  end
+
+  def set_basic_auth(request, basic_auth)
+    return unless basic_auth.is_a?(Hash)
+    credentials = "#{basic_auth[:user]}:#{basic_auth[:password]}"
+    request.set_header("Authorization", "Basic #{Base64.strict_encode64(credentials)}")
+  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,109 @@
+# coding: utf-8
+
+require "rubygems"
+require "bundler/setup"
+require "minitest/pride"
+require "minitest/autorun"
+require "json"
+
+require File.expand_path("../../lib/http_client", __FILE__)
+
+def Hash(h); h; end
+
+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(:socket_timeout => 5000, :connect_timeout => 5000, :max_retries => 2)
+  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 "GET request with chunked response" do
+    response = client.get("http://httpbin.org/stream/10")
+    assert_equal 10, response.body.split("\n").size
+  end
+
+  test "GET request with basic auth" do
+    response = client.get("http://httpbin.org/basic-auth/foo/bar",
+      :basic_auth => { :user => "foo", :password => "bar" }
+    )
+    assert_equal 200, response.status
+  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,57 @@
+--- !ruby/object:Gem::Specification
+name: http_client
+version: !ruby/object:Gem::Version
+  version: 0.5.3
+platform: java
+authors:
+- Lukas Rieder
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2013-11-08 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:
+- Gemfile
+- Gemfile.lock
+- http_client.gemspec
+- LICENSE
+- 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: []
+has_rdoc: