dwaite-em-http-request 0.1.9

data/lib/em-http/core_ext/hash.rb

@@ -0,0 +1,53 @@
+class Hash
+  # Stolen partially from Merb : http://noobkit.com/show/ruby/gems/development/merb/hash/to_params.html
+  # Convert this hash to a query string:
+  #   
+  #   { :name => "Bob",
+  #     :address => {
+  #       :street => '111 Ruby Ave.',
+  #       :city => 'Ruby Central',
+  #       :phones => ['111-111-1111', '222-222-2222']
+  #     }
+  #   }.to_params
+  #   #=> "name=Bob&address[city]=Ruby Central&address[phones]=111-111-1111222-222-2222&address[street]=111 Ruby Ave."
+  # 
+  def to_params
+    params = ''
+    stack = []
+    
+    each do |k, v|
+      if v.is_a?(Hash)
+        stack << [k,v]
+      elsif v.is_a?(Array)
+        stack << [k,Hash.from_array(v)]
+      else
+        params << "#{k}=#{v}&"
+      end
+    end
+    
+    stack.each do |parent, hash|
+      hash.each do |k, v|
+        if v.is_a?(Hash)
+          stack << ["#{parent}[#{k}]", v]
+        else
+          params << "#{parent}[#{k}]=#{v}&"
+        end
+      end
+    end
+    
+    params.chop! # trailing &
+    params
+  end
+  
+  ##
+  # Builds a hash from an array with keys as array indices.
+  def self.from_array(array = [])
+    h = Hash.new
+    array.size.times do |t|
+      h[t] = array[t]
+    end
+    h
+  end
+
+end
+

data/lib/em-http/decoders.rb

@@ -0,0 +1,119 @@
+require 'zlib'
+
+##
+# Provides a unified callback interface to decompression libraries.
+module EventMachine::HttpDecoders
+
+  class DecoderError < StandardError
+  end
+
+  class << self
+    def accepted_encodings
+      DECODERS.inject([]) { |r,d| r + d.encoding_names }
+    end
+
+    def decoder_for_encoding(encoding)
+      DECODERS.each { |d|
+        return d if d.encoding_names.include? encoding
+      }
+      nil
+    end
+  end
+
+  class Base
+    def self.encoding_names
+      name = to_s.split('::').last.downcase
+      [name]
+    end
+
+    ##
+    # chunk_callback:: [Block] To handle a decompressed chunk
+    def initialize(&chunk_callback)
+      @chunk_callback = chunk_callback
+    end
+
+    def <<(compressed)
+      return unless compressed && compressed.size > 0
+
+      decompressed = decompress(compressed)
+      receive_decompressed decompressed
+    end
+
+    def finalize!
+      decompressed = finalize
+      receive_decompressed decompressed
+    end
+    
+    private
+
+    def receive_decompressed(decompressed)
+      if decompressed && decompressed.size > 0
+        @chunk_callback.call(decompressed)
+      end
+    end
+
+    protected
+
+    ##
+    # Must return a part of decompressed
+    def decompress(compressed)
+      nil
+    end
+
+    ##
+    # May return last part
+    def finalize
+      nil
+    end
+  end
+
+  class Deflate < Base
+    def decompress(compressed)
+      begin
+        @zstream ||= Zlib::Inflate.new(nil)
+        @zstream.inflate(compressed)
+      rescue Zlib::Error
+        raise DecoderError
+      end
+    end
+
+    def finalize
+      return nil unless @zstream
+
+      begin
+        r = @zstream.inflate(nil)
+        @zstream.close
+        r
+      rescue Zlib::Error
+        raise DecoderError
+      end
+    end
+  end
+
+  ##
+  # Oneshot decompressor, due to lack of a streaming Gzip reader
+  # implementation. We may steal code from Zliby to improve this.
+  #
+  # For now, do not put `gzip' or `compressed' in your accept-encoding
+  # header if you expect much data through the :on_response interface.
+  class GZip < Base
+    def self.encoding_names
+      %w(gzip compressed)
+    end
+
+    def decompress(compressed)
+      @buf ||= ''
+      @buf += compressed
+      nil
+    end
+
+    def finalize
+      Zlib::GzipReader.new(StringIO.new(@buf)).read
+    end
+  end
+
+  DECODERS = [Deflate, GZip]
+
+end
+
+    

data/lib/em-http/multi.rb

@@ -0,0 +1,51 @@
+module EventMachine
+
+  # EventMachine based Multi request client, based on a streaming HTTPRequest class, 
+  # which allows you to open multiple parallel connections and return only when all
+  # of them finish. (i.e. ideal for parallelizing workloads)
+  # 
+  # == Example
+  # 
+  #  EventMachine.run {
+  #   
+  #   multi = EventMachine::MultiRequest.new
+  #    
+  #   # add multiple requests to the multi-handler
+  #   multi.add(EventMachine::HttpRequest.new('http://www.google.com/').get)
+  #   multi.add(EventMachine::HttpRequest.new('http://www.yahoo.com/').get)
+  #    
+  #    multi.callback  {
+  #       p multi.responses[:succeeded]
+  #       p multi.responses[:failed]
+  #     
+  #       EventMachine.stop
+  #    }
+  #  }
+  # 
+  
+  class MultiRequest
+    include EventMachine::Deferrable
+
+    attr_reader :requests, :responses
+    
+    def initialize
+      @requests = []
+      @responses = {:succeeded => [], :failed => []}
+    end
+    
+    def add(conn)
+      conn.callback { @responses[:succeeded].push(conn); check_progress }
+      conn.errback  { @responses[:failed].push(conn); check_progress }
+      
+      @requests.push(conn)
+    end
+    
+    protected
+   
+    # invoke callback if all requests have completed
+    def check_progress
+      succeed if (@responses[:succeeded].size + @responses[:failed].size) == @requests.size
+    end
+    
+  end
+end

data/lib/em-http/request.rb

@@ -0,0 +1,72 @@
+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
+
+    def initialize(host, headers = {})
+      @headers = headers
+      @uri = host.kind_of?(URI) ? host : 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)
+    #
+    #   on_response: Proc
+    #     Called for each response body chunk (you may assume HTTP 200
+    #     OK then)
+    #
+
+    def get  options = {};    send_request(:get,  options);    end
+    def head options = {};    send_request(:head, options);    end
+    def post options = {};    send_request(:post, options);    end
+
+    def send_request(method, options)
+      raise ArgumentError, "invalid request path" unless /^\// === @uri.path
+      
+      method = method.to_s.upcase
+      begin
+       EventMachine.connect(@uri.host, @uri.port, EventMachine::HttpClient) { |c|
+          c.uri = @uri
+          c.method = method
+          c.options = options
+          c.comm_inactivity_timeout = options[:timeout] || 5
+        }
+      rescue RuntimeError => e 
+        raise e unless e.message == "no connection"
+        conn = EventMachine::HttpClient.new("")
+        conn.on_error("no connection", true)
+        conn
+      end
+    end
+  end
+end

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,144 @@
+# #--
+# 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.path_info == '/echo_content_length'
+      stable.response.write stable.request.content_length
+
+    elsif stable.request.head?
+      stable.response.status = 200
+
+    elsif stable.request.post?
+      stable.response.write stable.request.body.read
+
+    elsif stable.request.path_info == '/set_cookie'
+      stable.response["Set-Cookie"] = "id=1; expires=Tue, 09-Aug-2011 17:53:39 GMT; path=/;"
+      stable.response.write "cookie set"
+
+    elsif stable.request.path_info == '/echo_cookie'
+      stable.response.write stable.request.env["HTTP_COOKIE"]
+
+    elsif stable.request.path_info == '/timeout'
+      sleep(10)
+      stable.response.write 'timeout'
+
+    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
+  begin
+    Stallion.run :Host => '127.0.0.1', :Port => 8080  
+  rescue Exception => e
+    print e
+  end
+end
+
+sleep(1)