tmm1-em-http-request 0.1.0

data/lib/em-http/request.rb

@@ -0,0 +1,63 @@
+require 'uri'
+require 'base64'
+
+module EventMachine
+
+  # EventMachine based HTTP request class with support for streaming consumption
+  # of the response. Response is parsed with a Ragel-generated whitelist parser
+  # which supports chunked HTTP encoding.
+  #
+  # == Example
+  #
+  #
+  #  EventMachine.run {
+  #    http = EventMachine::HttpRequest.new('http://127.0.0.1/').get :query => {'keyname' => 'value'}
+  #
+  #    http.callback {
+  #     p http.response_header.status
+  #     p http.response_header
+  #     p http.response
+  #
+  #	EventMachine.stop
+  #    }
+  #  }
+  #
+
+  class HttpRequest
+    attr_reader :response, :headers
+
+    def initialize(host, headers = {})
+      @headers = headers
+      @uri = URI::parse(host)
+    end
+
+    # Send an HTTP request and consume the response. Supported options:
+    #
+    #   head: {Key: Value}
+    #     Specify an HTTP header, e.g. {'Connection': 'close'}
+    #
+    #   query: {Key: Value}
+    #     Specify query string parameters (auto-escaped)
+    #
+    #   body: String
+    #     Specify the request body (you must encode it for now)
+    #
+
+    def get  options = {};    send_request(:get,  options);    end
+    def post options = {};    send_request(:post, options);    end
+
+    protected
+
+    def send_request(method, options)
+      raise ArgumentError, "invalid request path" unless /^\// === @uri.path
+
+      method = method.to_s.upcase
+
+      EventMachine.connect(@uri.host, @uri.port, EventMachine::HttpClient) { |c|
+        c.uri = @uri
+        c.method = method
+        c.options = options
+      }
+    end
+  end
+end

data/lib/em-http.rb

@@ -0,0 +1,16 @@
+#--
+# Copyright (C)2008 Ilya Grigorik
+# You can redistribute this under the terms of the Ruby license
+# See file LICENSE for details
+#++
+
+require 'rubygems'
+require 'eventmachine'
+require 'zlib'
+
+require 'http11_client'
+require 'em_buffer'
+
+require 'em-http/client'
+require 'em-http/multi'
+require 'em-http/request'

data/test/helper.rb

@@ -0,0 +1,5 @@
+require 'rubygems'
+require 'spec'
+require 'pp'
+
+require 'lib/em-http'

data/test/stallion.rb

@@ -0,0 +1,123 @@
+# #--
+# Includes portion originally Copyright (C)2008 Michael Fellinger
+# license See file LICENSE for details
+# #--
+
+require 'rack'
+
+module Stallion
+  class Mount
+    def initialize(name, *methods, &block)
+      @name, @methods, @block = name, methods, block
+    end
+
+    def ride
+      @block.call
+    end
+
+    def match?(request)
+      method = request['REQUEST_METHOD']
+      right_method = @methods.empty? or @methods.include?(method)
+    end
+  end
+
+  class Stable
+    attr_reader :request, :response
+
+    def initialize
+      @boxes = {}
+    end
+
+    def in(path, *methods, &block)
+      mount = Mount.new(path, *methods, &block)
+      @boxes[[path, methods]] = mount
+      mount
+    end
+
+    def call(request, response)
+      @request, @response = request, response
+      @boxes.each do |(path, methods), mount|
+        if mount.match?(request)
+          mount.ride
+        end
+      end
+    end
+  end
+
+  STABLES = {}
+
+  def self.saddle(name = nil)
+    STABLES[name] = stable = Stable.new
+    yield stable
+  end
+
+  def self.run(options = {})
+    options = {:Host => "127.0.0.1", :Port => 8080}.merge(options)
+    Rack::Handler::Mongrel.run(Rack::Lint.new(self), options)
+  end
+
+  def self.call(env)
+    request = Rack::Request.new(env)
+    response = Rack::Response.new
+
+    STABLES.each do |name, stable|
+      stable.call(request, response)
+    end
+
+    response.finish
+  end
+end
+
+Stallion.saddle :spec do |stable|
+  stable.in '/' do
+
+    if stable.request.path_info == '/fail'
+      stable.response.status = 404
+
+    elsif stable.request.query_string == 'q=test'
+      stable.response.write 'test'
+
+    elsif stable.request.path_info == '/echo_query'
+      stable.response.write stable.request.query_string
+
+    elsif stable.request.post?
+      stable.response.write 'test'
+
+    elsif stable.request.path_info == '/gzip'
+      io = StringIO.new
+      gzip = Zlib::GzipWriter.new(io)
+      gzip << "compressed"
+      gzip.close
+
+      stable.response.write io.string
+      stable.response["Content-Encoding"] = "gzip"
+
+    elsif stable.request.path_info == '/deflate'
+      stable.response.write Zlib::Deflate.deflate("compressed")
+      stable.response["Content-Encoding"] = "deflate"
+
+    elsif stable.request.env["HTTP_IF_NONE_MATCH"]
+      stable.response.status = 304
+
+    elsif stable.request.env["HTTP_AUTHORIZATION"]
+      auth = "Basic %s" % Base64.encode64(['user', 'pass'].join(':')).chomp
+
+      if auth == stable.request.env["HTTP_AUTHORIZATION"]
+        stable.response.status = 200
+        stable.response.write 'success'
+      else
+        stable.response.status = 401
+      end
+
+    elsif
+      stable.response.write  'Hello, World!'
+    end
+
+  end
+end
+
+Thread.new do
+  Stallion.run :Host => '127.0.0.1', :Port => 8080
+end
+
+sleep(2)

data/test/test_multi.rb

@@ -0,0 +1,34 @@
+require 'test/helper'
+require 'test/stallion'
+
+describe EventMachine::MultiRequest do
+
+  def failed
+    EventMachine.stop
+    fail
+  end
+
+  it "should submit multiple requests in parallel and return once all of them are complete" do
+    EventMachine.run {
+      
+      # create an instance of multi-request handler, and the requests themselves
+      multi = EventMachine::MultiRequest.new
+      
+      # add multiple requests to the multi-handler
+      multi.add(EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get(:query => {:q => 'test'}))
+      multi.add(EventMachine::HttpRequest.new('http://169.169.169.169/').get)
+      
+      multi.callback  {
+        # verify successfull request
+        multi.responses[:succeeded].size.should == 1
+        multi.responses[:succeeded].first.response.should match(/test/)
+        
+        # verify invalid requests
+        multi.responses[:failed].size.should == 1
+        multi.responses[:failed].first.response_header.status.should == 0
+        
+        EventMachine.stop
+      }
+    } 
+  end
+end

data/test/test_request.rb

@@ -0,0 +1,179 @@
+require 'test/helper'
+require 'test/stallion'
+
+describe EventMachine::HttpRequest do
+
+  def failed
+    EventMachine.stop
+    fail
+  end
+
+  it "should fail GET on invalid host" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://169.169.169.169/').get
+      http.callback { failed }
+      http.errback {
+        http.response_header.status.should == 0
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should fail GET on missing path" do
+    EventMachine.run {
+      lambda {
+        EventMachine::HttpRequest.new('http://www.google.com').get
+      }.should raise_error(ArgumentError)
+
+      EventMachine.stop
+    }
+  end
+
+  it "should perform successfull GET" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get
+
+      http.errback { failed }
+      http.callback {
+        http.response_header.status.should == 200
+        http.response.should match(/Hello/)
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should return 404 on invalid path" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/fail').get
+
+      http.errback { failed }
+      http.callback {
+        http.response_header.status.should == 404
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should pass query parameters" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get :query => {:q => 'test'}
+
+      http.errback { failed }
+      http.callback {
+        http.response_header.status.should == 200
+        http.response.should match(/test/)
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should encode an array of query parameters" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/echo_query').get :query => {:hash => ['value1', 'value2']}
+
+      http.errback { failed }
+      http.callback {
+        http.response_header.status.should == 200
+        http.response.should match(/hash\[\]=value1&hash\[\]=value2/)
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should perform successfull POST" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').post :body => "data"
+
+      http.errback { failed }
+      http.callback {
+        http.response_header.status.should == 200
+        http.response.should match(/test/)
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should perform successfull GET with custom header" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get :head => {'if-none-match' => 'evar!'}
+
+      http.errback { failed }
+      http.callback {
+        http.response_header.status.should == 304
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should perform a streaming GET" do
+    EventMachine.run {
+
+      # digg.com uses chunked encoding
+      http = EventMachine::HttpRequest.new('http://www.digg.com/').get
+
+      http.errback { failed }
+      http.callback {
+        http.response_header.status == 200
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should perform basic auth" do
+    EventMachine.run {
+
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get :head => {'authorization' => ['user', 'pass']}
+
+      http.errback { failed }
+      http.callback {
+        http.response_header.status == 200
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should work with keep-alive servers" do
+    EventMachine.run {
+
+      http = EventMachine::HttpRequest.new('http://mexicodiario.com/touch.public.json.php').get
+
+      http.errback { failed }
+      http.callback {
+        http.response_header.status == 200
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should detect deflate encoding" do
+    EventMachine.run {
+
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/deflate').get :head => {"accept-encoding" => "deflate"}
+
+      http.errback { failed }
+      http.callback {
+        http.response_header.status == 200
+        http.response_header["CONTENT_ENCODING"].should == "deflate"
+        http.response.should == "compressed"
+
+        EventMachine.stop
+      }
+    }
+  end
+
+   it "should detect gzip encoding" do
+    EventMachine.run {
+
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/gzip').get :head => {"accept-encoding" => "gzip, compressed"}
+
+      http.errback { failed }
+      http.callback {
+        http.response_header.status == 200
+        http.response_header["CONTENT_ENCODING"].should == "gzip"
+        http.response.should == "compressed"
+
+        EventMachine.stop
+      }
+    }
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: tmm1-em-http-request
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Ilya Grigorik
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-15 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.12.2
+    version: 
+description: EventMachine based HTTP Request interface
+email: ilya@igvita.com
+executables: []
+
+extensions: 
+- ext/buffer/extconf.rb
+- ext/http11_client/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- .autotest
+- LICENSE
+- README
+- Rakefile
+- ext/buffer/em_buffer.c
+- ext/buffer/extconf.rb
+- ext/http11_client/ext_help.h
+- ext/http11_client/extconf.rb
+- ext/http11_client/http11_client.c
+- ext/http11_client/http11_parser.c
+- ext/http11_client/http11_parser.h
+- ext/http11_client/http11_parser.rl
+- lib/em-http.rb
+- lib/em-http/client.rb
+- lib/em-http/multi.rb
+- lib/em-http/request.rb
+- test/helper.rb
+- test/stallion.rb
+- test/test_multi.rb
+- test/test_request.rb
+has_rdoc: true
+homepage: http://github.com/igrigorik/em-http-request
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: EventMachine based HTTP Request interface
+test_files: []
+