dbalatero-typhoeus 0.0.20

data/lib/typhoeus/remote_proxy_object.rb

@@ -0,0 +1,48 @@
+module Typhoeus
+  class RemoteProxyObject
+    instance_methods.each { |m| undef_method m unless m =~ /^__/ }
+    
+    def initialize(clear_memoized_store_proc, easy, options = {})
+      @clear_memoized_store_proc = clear_memoized_store_proc
+      @easy      = easy
+      @success   = options[:on_success]
+      @failure   = options[:on_failure]
+      @cache     = options.delete(:cache)
+      @cache_key = options.delete(:cache_key)
+      @timeout   = options.delete(:cache_timeout)
+      Typhoeus.add_easy_request(@easy)
+    end
+    
+    def method_missing(sym, *args, &block)
+      unless @proxied_object
+        if @cache && @cache_key
+          @proxied_object = @cache.get(@cache_key) rescue nil
+        end
+        
+        unless @proxied_object
+          Typhoeus.perform_easy_requests
+          response = Response.new(:code => @easy.response_code,
+                                  :headers => @easy.response_header,
+                                  :body => @easy.response_body,
+                                  :time => @easy.total_time_taken,
+                                  :requested_url => @easy.url,
+                                  :requested_http_method => @easy.method,
+                                  :start_time => @easy.start_time)
+          if @easy.response_code >= 200 && @easy.response_code < 300
+            Typhoeus.release_easy_object(@easy)
+            @proxied_object = @success.nil? ? response : @success.call(response)
+            
+            if @cache && @cache_key
+              @cache.set(@cache_key, @proxied_object, @timeout)
+            end
+          else
+            @proxied_object = @failure.nil? ? response : @failure.call(response)
+          end
+         @clear_memoized_store_proc.call
+       end
+      end
+      
+      @proxied_object.__send__(sym, *args, &block)
+    end
+  end
+end

data/lib/typhoeus/response.rb

@@ -0,0 +1,17 @@
+module Typhoeus
+  class Response
+    attr_reader :code, :headers, :body, :time,
+                :requested_url, :requested_remote_method,
+                :requested_http_method, :start_time
+    
+    def initialize(params = {})
+      @code                     = params[:code]
+      @headers                  = params[:headers]
+      @body                     = params[:body]
+      @time                     = params[:time]
+      @requested_url            = params[:requested_url]
+      @requested_http_method    = params[:requested_http_method]
+      @start_time               = params[:start_time]
+    end
+  end
+end

data/lib/typhoeus.rb

@@ -0,0 +1,53 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__)) unless $LOAD_PATH.include?(File.dirname(__FILE__))
+
+require 'cgi'
+require 'digest/sha2'
+require 'typhoeus/easy'
+require 'typhoeus/multi'
+require 'typhoeus/native'
+require 'typhoeus/filter'
+require 'typhoeus/remote_method'
+require 'typhoeus/remote'
+require 'typhoeus/remote_proxy_object'
+require 'typhoeus/response'
+
+module Typhoeus
+  VERSION = "0.0.20"
+  
+  def self.easy_object_pool
+    @easy_objects ||= []
+  end
+  
+  def self.init_easy_object_pool
+    20.times do
+      easy_object_pool << Typhoeus::Easy.new
+    end
+  end
+  
+  def self.release_easy_object(easy)
+    easy.reset
+    easy_object_pool << easy
+  end
+  
+  def self.get_easy_object
+    if easy_object_pool.empty?
+      Typhoeus::Easy.new
+    else
+      easy_object_pool.pop
+    end
+  end
+  
+  def self.add_easy_request(easy_object)
+    Thread.current[:curl_multi] ||= Typhoeus::Multi.new
+    Thread.current[:curl_multi].add(easy_object)
+  end
+  
+  def self.perform_easy_requests
+    multi = Thread.current[:curl_multi]
+    start_time = Time.now
+    multi.easy_handles.each do |easy|
+      easy.start_time = start_time
+    end
+    multi.perform
+  end
+end

data/spec/servers/delay_fixture_server.rb

@@ -0,0 +1,66 @@
+# this server simply accepts requests and blocks for a passed in interval before returning a passed in reqeust value to
+# the client
+require 'rubygems'
+require 'eventmachine'
+require 'evma_httpserver'
+ 
+class DelayFixtureServer  < EventMachine::Connection
+  include EventMachine::HttpServer
+ 
+  def process_http_request
+    EventMachine.stop if ENV["PATH_INFO"] == "/die"
+    puts "got a request #{ENV['PATH_INFO']}"
+    resp = EventMachine::DelegatedHttpResponse.new( self )
+    
+    # Block which fulfills the request
+    operation = proc do
+      sleep DelayFixtureServer.response_delay
+
+      resp.status = 200
+      resp.content = "whatever"
+    end
+
+    # Callback block to execute once the request is fulfilled
+    callback = proc do |res|
+      resp.send_response
+    end
+
+    # Let the thread pool (20 Ruby threads) handle request
+    EM.defer(operation, callback)
+  end
+  
+  def self.response_fixture
+    @response_fixture ||= ""
+  end
+  
+  def self.response_fixture=(val)
+    @response_fixture = val
+  end
+
+  def self.response_delay
+    @response_delay ||= 0
+  end
+
+  def self.response_delay=(val)
+    @response_delay = val
+  end
+  
+  def self.reponse_number
+    @response_number
+  end
+  
+  def self.response_number=(val)
+    @response_number = val
+  end
+end
+
+port = (ARGV[0] || 3000).to_i
+
+DelayFixtureServer.response_delay   = 0.5
+DelayFixtureServer.response_number = 0
+#DelayFixtureServer.response_fixture = File.read(File.dirname(__FILE__) + "/../fixtures/result_set.xml")
+
+EventMachine::run {
+  EventMachine.epoll
+  EventMachine::start_server("0.0.0.0", port, DelayFixtureServer)
+}

data/spec/servers/method_server.rb

@@ -0,0 +1,51 @@
+# this server simply is for testing out the different http methods. it echoes back the passed in info
+require 'rubygems'
+require 'eventmachine'
+require 'evma_httpserver'
+ 
+class MethodServer  < EventMachine::Connection
+  include EventMachine::HttpServer
+ 
+  def process_http_request
+    EventMachine.stop if ENV["PATH_INFO"] == "/die"
+    
+    resp = EventMachine::DelegatedHttpResponse.new( self )
+    
+    # Block which fulfills the request
+    operation = proc do
+      sleep MethodServer.sleep_time
+      resp.status = 200
+      resp.content = request_params + "\n#{@http_post_content}"
+    end
+
+    # Callback block to execute once the request is fulfilled
+    callback = proc do |res|
+      resp.send_response
+    end
+
+    # Let the thread pool (20 Ruby threads) handle request
+    EM.defer(operation, callback)
+  end
+  
+  def request_params
+    %w( PATH_INFO QUERY_STRING HTTP_COOKIE IF_NONE_MATCH CONTENT_TYPE REQUEST_METHOD REQUEST_URI ).collect do |param|
+      "#{param}=#{ENV[param]}"
+    end.join("\n")
+  end
+  
+  def self.sleep_time=(val)
+    @sleep_time = val
+  end
+  
+  def self.sleep_time
+    @sleep_time || 0
+  end
+end
+# 
+# port = (ARGV[0] || 3000).to_i
+# #Process.fork do
+#   EventMachine::run {
+#     EventMachine.epoll
+#     EventMachine::start_server("0.0.0.0", port, MethodServer)
+#   }
+# #end

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--diff
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+require "rubygems"
+require "spec"
+
+# gem install redgreen for colored test output
+begin require "redgreen" unless ENV['TM_CURRENT_LINE']; rescue LoadError; end
+
+path = File.expand_path(File.dirname(__FILE__) + "/../lib/")
+$LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
+
+require "lib/typhoeus"
+
+# local servers for running tests
+require File.dirname(__FILE__) + "/servers/method_server.rb"
+
+def start_method_server(port, sleep = 0)
+  MethodServer.sleep_time = sleep
+  pid = Process.fork do
+    EventMachine::run {
+      EventMachine.epoll
+      EventMachine::start_server("0.0.0.0", port, MethodServer)
+    }
+  end
+  sleep 0.2
+  pid
+end
+
+def stop_method_server(pid)
+  Process.kill("HUP", pid)
+end

data/spec/typhoeus/easy_spec.rb

@@ -0,0 +1,148 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Typhoeus::Easy do
+  before(:all) do
+    @pid = start_method_server(3002)
+  end
+  
+  after(:all) do
+    stop_method_server(@pid)
+  end
+  
+  describe "options" do
+    it "should allow for following redirects"
+    it "should allow you to set the user agent"
+    it "should provide a timeout in milliseconds" do
+      pid = start_method_server(3001, 5)
+      e = Typhoeus::Easy.new
+      e.url = "http://localhost:3001"
+      e.method = :get
+      e.timeout = 50
+      e.perform
+      puts e.response_code
+      puts e.total_time_taken
+#      e.timed_out?.should == true
+      stop_method_server(pid)
+    end
+  end
+  
+  describe "get" do
+    it "should perform a get" do
+      easy = Typhoeus::Easy.new
+      easy.url    = "http://localhost:3002"
+      easy.method = :get
+      easy.perform
+      easy.response_code.should == 200
+      easy.response_body.should include("REQUEST_METHOD=GET")
+    end
+    
+    it "should send a request body" do
+      easy = Typhoeus::Easy.new
+      easy.url    = "http://localhost:3002"
+      easy.method = :get
+      easy.request_body = "this is a body!"
+      easy.perform
+      easy.response_code.should == 200
+      easy.response_body.should include("this is a body!")
+    end
+  end
+
+  describe "start_time" do
+    it "should be get/settable" do
+      time = Time.now
+      easy = Typhoeus::Easy.new
+      easy.start_time.should be_nil
+      easy.start_time = time
+      easy.start_time.should == time
+    end
+  end
+
+  describe "params=" do
+    it "should handle arrays of params" do
+      easy = Typhoeus::Easy.new
+      easy.url = "http://localhost:3002/index.html"
+      easy.method = :get
+      easy.request_body = "this is a body!"
+      easy.params = {
+        :foo => 'bar',
+        :username => ['dbalatero', 'dbalatero2']
+      }
+      
+      easy.url.should =~ /\?.*username=dbalatero&username=dbalatero2/
+    end
+  end
+
+
+  describe "put" do
+    it "should perform a put" do
+      easy = Typhoeus::Easy.new
+      easy.url    = "http://localhost:3002"
+      easy.method = :put
+      easy.perform
+      easy.response_code.should == 200
+      easy.response_body.should include("REQUEST_METHOD=PUT")      
+    end
+    
+    it "should send a request body" do
+      easy = Typhoeus::Easy.new
+      easy.url    = "http://localhost:3002"
+      easy.method = :put
+      easy.request_body = "this is a body!"
+      easy.perform
+      easy.response_code.should == 200
+      easy.response_body.should include("this is a body!")
+    end
+  end
+  
+  describe "post" do
+    it "should perform a post" do
+      easy = Typhoeus::Easy.new
+      easy.url    = "http://localhost:3002"
+      easy.method = :post
+      easy.perform
+      easy.response_code.should == 200
+      easy.response_body.should include("REQUEST_METHOD=POST")      
+    end
+    
+    it "should send a request body" do
+      easy = Typhoeus::Easy.new
+      easy.url    = "http://localhost:3002"
+      easy.method = :post
+      easy.request_body = "this is a body!"
+      easy.perform
+      easy.response_code.should == 200
+      easy.response_body.should include("this is a body!")
+    end
+    
+    it "should handle params" do
+      easy = Typhoeus::Easy.new
+      easy.url    = "http://localhost:3002"
+      easy.method = :post
+      easy.params = {:foo => "bar"}
+      easy.perform
+      easy.response_code.should == 200
+      easy.response_body.should include("foo=bar")
+    end
+  end
+  
+  describe "delete" do
+    it "should perform a delete" do
+      easy = Typhoeus::Easy.new
+      easy.url    = "http://localhost:3002"
+      easy.method = :delete
+      easy.perform
+      easy.response_code.should == 200
+      easy.response_body.should include("REQUEST_METHOD=DELETE")
+    end
+    
+    it "should send a request body" do
+      easy = Typhoeus::Easy.new
+      easy.url    = "http://localhost:3002"
+      easy.method = :delete
+      easy.request_body = "this is a body!"
+      easy.perform
+      easy.response_code.should == 200
+      easy.response_body.should include("this is a body!")
+    end
+  end  
+end

data/spec/typhoeus/filter_spec.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Typhoeus::Filter do
+  it "should take a method name and optionally take options" do
+    filter = Typhoeus::Filter.new(:bar, :only => :foo)
+    filter = Typhoeus::Filter.new(:bar)
+  end
+  
+  describe "#apply_filter?" do
+    it "should return true for any method when :only and :except aren't specified" do
+      filter = Typhoeus::Filter.new(:bar)
+      filter.apply_filter?(:asdf).should be_true
+    end
+    
+    it "should return true if a method is in only" do
+      filter = Typhoeus::Filter.new(:bar, :only => :foo)
+      filter.apply_filter?(:foo).should be_true
+    end
+    
+    it "should return false if a method isn't in only" do
+      filter = Typhoeus::Filter.new(:bar, :only => :foo)
+      filter.apply_filter?(:bar).should be_false
+    end
+    
+    it "should return true if a method isn't in except" do
+      filter = Typhoeus::Filter.new(:bar, :except => :foo)
+      filter.apply_filter?(:bar).should be_true
+    end
+    
+    it "should return false if a method is in except" do
+      filter = Typhoeus::Filter.new(:bar, :except => :foo)
+      filter.apply_filter?(:foo).should be_false
+    end
+  end
+end

data/spec/typhoeus/multi_spec.rb

@@ -0,0 +1,82 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Typhoeus::Easy do
+  before(:all) do
+    @pid = start_method_server(3002)
+  end
+  
+  after(:all) do
+    stop_method_server(@pid)
+  end
+
+  it "should save easy handles that get added" do
+    multi = Typhoeus::Multi.new
+    easy = Typhoeus::Easy.new
+    easy.url = "http://localhost:3002"
+    easy.method = :get
+
+    multi.add(easy)
+    multi.easy_handles.should == [easy]
+    multi.perform
+    multi.easy_handles.should == []
+  end
+  
+  it "should be reusable" do
+    easy = Typhoeus::Easy.new
+    easy.url = "http://localhost:3002"
+    easy.method = :get
+    
+    multi = Typhoeus::Multi.new
+    multi.add(easy)
+    multi.perform
+    easy.response_code.should == 200
+    easy.response_body.should include("METHOD=GET")
+    
+    e2 = Typhoeus::Easy.new
+    e2.url = "http://localhost:3002"
+    e2.method = :post
+    multi.add(e2)
+    multi.perform
+    
+    e2.response_code.should == 200
+    e2.response_body.should include("METHOD=POST")
+  end
+  
+  it "should perform easy handles added after the first one runs" do
+    easy = Typhoeus::Easy.new
+    easy.url = "http://localhost:3002"
+    easy.method = :get
+    multi = Typhoeus::Multi.new
+    multi.add(easy)
+
+    e2 = Typhoeus::Easy.new
+    e2.url = "http://localhost:3002"
+    e2.method = :post
+    easy.on_success do |e|
+      multi.add(e2)
+    end
+    
+    multi.perform
+    easy.response_code.should == 200
+    easy.response_body.should include("METHOD=GET")    
+    e2.response_code.should == 200
+    e2.response_body.should include("METHOD=POST")    
+  end
+  
+  # it "should do multiple gets" do
+    # multi = Typhoeus::Multi.new
+    # 
+    # handles = []
+    # 5.times do |i|
+    #   easy = Typhoeus::Easy.new
+    #   easy.url = "http://localhost:3002"
+    #   easy.method = :get
+    #   easy.on_success {|e| puts "get #{i} succeeded"}
+    #   easy.on_failure {|e| puts "get #{i} failed with #{e.response_code}"}
+    #   handles << easy
+    #   multi.add(easy)
+    # end
+    # 
+    # multi.perform
+  # end
+end

data/spec/typhoeus/remote_method_spec.rb

@@ -0,0 +1,141 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Typhoeus::RemoteMethod do
+  it "should take options" do
+    Typhoeus::RemoteMethod.new(:body => "foo")
+  end
+  
+  describe "http_method" do
+    it "should return the http method" do
+      m = Typhoeus::RemoteMethod.new(:method => :put)
+      m.http_method.should == :put
+    end
+    
+    it "should default to :get" do
+      m = Typhoeus::RemoteMethod.new
+      m.http_method.should == :get
+    end
+  end
+  
+  it "should return the options" do
+    m = Typhoeus::RemoteMethod.new(:body => "foo")
+    m.options.should == {:body => "foo"}
+  end
+  
+  it "should pull uri out of the options hash" do
+    m = Typhoeus::RemoteMethod.new(:base_uri => "http://pauldix.net")
+    m.base_uri.should == "http://pauldix.net"
+    m.options.should_not have_key(:base_uri)
+  end
+  
+  describe "on_success" do
+    it "should return the block" do
+      m = Typhoeus::RemoteMethod.new(:on_success => lambda {:foo})
+      m.on_success.call.should == :foo
+    end
+  end
+  
+  describe "on_failure" do
+    it "should return method name" do
+      m = Typhoeus::RemoteMethod.new(:on_failure => lambda {:bar})
+      m.on_failure.call.should == :bar
+    end
+  end
+  
+  describe "path" do
+    it "should pull path out of the options hash" do
+      m = Typhoeus::RemoteMethod.new(:path => "foo")
+      m.path.should == "foo"
+      m.options.should_not have_key(:path)
+    end
+    
+    it "should output argument names from the symbols in the path" do
+      m = Typhoeus::RemoteMethod.new(:path => "/posts/:post_id/comments/:comment_id")
+      m.argument_names.should == [:post_id, :comment_id]
+    end
+    
+    it "should output an empty string when there are no arguments in path" do
+      m = Typhoeus::RemoteMethod.new(:path => "/default.html")
+      m.argument_names.should == []
+    end
+    
+    it "should output and empty string when there is no path specified" do
+      m = Typhoeus::RemoteMethod.new
+      m.argument_names.should == []
+    end
+    
+    it "should interpolate a path with arguments" do
+      m = Typhoeus::RemoteMethod.new(:path => "/posts/:post_id/comments/:comment_id")
+      m.interpolate_path_with_arguments(:post_id => 1, :comment_id => "asdf").should == "/posts/1/comments/asdf"
+    end
+    
+    it "should provide the path when interpolated called and there is nothing to interpolate" do
+      m = Typhoeus::RemoteMethod.new(:path => "/posts/123")
+      m.interpolate_path_with_arguments(:foo => :bar).should == "/posts/123"
+    end
+  end
+  
+  describe "#merge_options" do
+    it "should keep the passed in options first" do
+      m = Typhoeus::RemoteMethod.new("User-Agent" => "whatev", :foo => :bar)
+      m.merge_options({"User-Agent" => "http-machine"}).should == {"User-Agent" => "http-machine", :foo => :bar}
+    end
+    
+    it "should combine the params" do
+      m = Typhoeus::RemoteMethod.new(:foo => :bar, :params => {:id => :asdf})
+      m.merge_options({:params => {:desc => :jkl}}).should == {:foo => :bar, :params => {:id => :asdf, :desc => :jkl}}
+    end
+  end
+  
+  describe "memoize_reponses" do
+    before(:each) do
+      @m = Typhoeus::RemoteMethod.new(:memoize_responses => true)
+      @args    = ["foo", "bar"]
+      @options = {:asdf => {:jkl => :bar}}
+    end
+    
+    it "should store if responses should be memoized" do
+      @m.memoize_responses?.should be_true
+      @m.options.should == {}
+    end
+    
+    it "should tell when a method is already called" do
+      @m.already_called?(@args, @options).should be_false
+      @m.calling(@args, @options)
+      @m.already_called?(@args, @options).should be_true
+      @m.already_called?([], {}).should be_false
+    end
+    
+    it "should call response blocks and clear the methods that have been called" do
+      response_block_called = mock('response_block')
+      response_block_called.should_receive(:call).exactly(1).times
+      
+      @m.add_response_block(lambda {|res| res.should == :foo; response_block_called.call}, @args, @options)
+      @m.calling(@args, @options)
+      @m.call_response_blocks(:foo, @args, @options)
+      @m.already_called?(@args, @options).should be_false
+      @m.call_response_blocks(:asdf, @args, @options) #just to make sure it doesn't actually call that block again
+    end
+  end
+  
+  describe "cache_reponses" do
+    before(:each) do
+      @m = Typhoeus::RemoteMethod.new(:cache_responses => true)
+      @args    = ["foo", "bar"]
+      @options = {:asdf => {:jkl => :bar}}
+    end
+    
+    it "should store if responses should be cached" do
+      @m.cache_responses?.should be_true
+      @m.options.should == {}
+    end
+    
+    it "should force memoization if caching is enabled" do
+      @m.memoize_responses?.should be_true
+    end
+    
+    it "should store cache ttl" do
+      Typhoeus::RemoteMethod.new(:cache_responses => 30).cache_ttl.should == 30
+    end
+  end
+end