typhoeus 0.1.24 → 0.1.31

data/CHANGELOG.markdown

@@ -0,0 +1,23 @@
+0.1.31
+------
+* Fixed bug in setting compression encoding [morhekil]
+* Exposed authentication control methods through Request interface [morhekil]
+
+0.1.30
+-----------
+* Exposed CURLOPT_CONNECTTIMEOUT_MS to Requests [balexis]
+
+0.1.29
+------
+* Fixed a memory corruption with using CURLOPT_POSTFIELDS [gravis,
+32531d0821aecc4]
+
+0.1.28
+----------------
+* Added SSL cert options for Typhoeus::Easy [GH-25, gravis]
+* Ported SSL cert options to Typhoeus::Request interface [gravis]
+* Added support for any HTTP method (purge for Varnish) [ryana]
+
+0.1.27
+------
+* Added rack as dependency, added dev dependencies to Rakefile [GH-21]

data/README.textile

@@ -0,0 +1,333 @@
+h1. Typhoeus
+
+"http://github.com/pauldix/typhoeus/tree/master":http://github.com/pauldix/typhoeus/tree/master
+
+"the mailing list":http://groups.google.com/group/typhoeus
+
+Thanks to my employer "kgbweb":http://kgbweb.com for allowing me to release this as open source. Btw, we're hiring and we work on cool stuff like this every day. Get a hold of me if you rock at rails/js/html/css or if you have experience in search, information retrieval, and machine learning.
+
+I also wanted to thank Todd A. Fisher. I ripped a good chunk of the c libcurl-multi code from his update to Curb. Awesome stuff Todd!
+
+h2. Summary
+
+Like a modern code version of the mythical beast with 100 serpent heads, Typhoeus runs HTTP requests in parallel while cleanly encapsulating handling logic. To be a little more specific, it's a library for accessing web services in Ruby. It's specifically designed for building RESTful service oriented architectures in Ruby that need to be fast enough to process calls to multiple services within the client's HTTP request/response life cycle.
+
+Some of the awesome features are parallel request execution, memoization of request responses (so you don't make the same request multiple times in a single group), built in support for caching responses to memcached (or whatever), and mocking capability baked in. It uses libcurl and libcurl-multi to work this speedy magic. I wrote the c bindings myself so it's yet another Ruby libcurl library, but with some extra awesomeness added in.
+
+h2. Installation
+
+Typhoeus requires you to have a current version of libcurl installed. I've tested this with 7.19.4 and higher.
+<pre>
+gem install typhoeus --source http://gemcutter.org
+</pre>
+If you're on Debian or Ubuntu and getting errors while trying to install, it could be because you don't have the latest version of libcurl installed. Do this to fix:
+<pre>
+sudo apt-get install libcurl4-gnutls-dev
+</pre>
+There's also something built in so that if you have a super old version of curl that you can't get rid of for some reason, you can install in a user directory and specify that during installation like so:
+<pre>
+gem install typhoeus --source http://gemcutter.org -- --with-curl=/usr/local/curl/7.19.7/
+</pre>
+
+Another problem could be if you are running Mac Ports and you have libcurl installed through there. You need to uninstall it for Typhoeus to work! The version in Mac Ports is old and doesn't play nice. You should "download curl":http://curl.haxx.se/download.html and build from source. Then you'll have to install the gem again.
+
+If you're still having issues, please let me know on "the mailing list":http://groups.google.com/group/typhoeus.
+
+There's one other thing you should know. The Easy object (which is just a libcurl thing) allows you to set timeout values in milliseconds. However, for this to work you need to build libcurl with c-ares support built in.
+
+h2. Usage
+
+*Deprecation Warning!*
+The old version of Typhoeus used a module that you included in your class to get functionality. That interface has been deprecated. Here is the new interface.
+
+The primary interface for Typhoeus is comprised of three classes: Request, Response, and Hydra. Request represents an HTTP request object, response represents an HTTP response, and Hydra manages making parallel HTTP connections.
+
+<pre>
+require 'rubygems'
+require 'typhoeus'
+require 'json'
+
+# the request object
+request = Typhoeus::Request.new("http://www.pauldix.net",
+                                :body          => "this is a request body",
+                                :method        => :post,
+                                :headers       => {:Accepts => "text/html"},
+                                :timeout       => 100, # milliseconds
+                                :cache_timeout => 60, # seconds
+                                :params        => {:field1 => "a field"})
+# we can see from this that the first argument is the url. the second is a set of options.
+# the options are all optional. The default for :method is :get. Timeout is measured in milliseconds.
+# cache_timeout is measured in seconds.
+
+# the response object will be set after the request is run
+response = request.response
+response.code    # http status code
+response.time    # time in seconds the request took
+response.headers # the http headers
+response.headers_hash # http headers put into a hash
+response.body    # the response body
+</pre>
+
+*Making Quick Requests*
+The request object has some convenience methods for performing single HTTP requests. The arguments are the same as those you pass into the request constructor.
+
+<pre>
+response = Typhoeus::Request.get("http://www.pauldix.net")
+response = Typhoeus::Request.head("http://www.pauldix.net")
+response = Typhoeus::Request.put("http://localhost:3000/posts/1", :body => "whoo, a body")
+response = Typhoeus::Request.post("http://localhost:3000/posts", :params => {:title => "test post", :content => "this is my test"})
+response = Typhoeus::Request.delete("http://localhost:3000/posts/1")
+</pre>
+
+*Making Parallel Requests*
+
+<pre>
+# Generally, you should be running requests through hydra. Here is how that looks
+hydra = Typhoeus::Hydra.new
+
+first_request = Typhoeus::Request.new("http://localhost:3000/posts/1.json")
+first_request.on_complete do |response|
+  post = JSON.parse(response.body)
+  third_request = Typhoeus::Request.new(post.links.first) # get the first url in the post
+  third_request.on_complete do |response|
+    # do something with that
+  end
+  hydra.queue third_request
+  return post
+end
+second_request = Typhoeus::Request.new("http://localhost:3000/users/1.json")
+second_request.on_complete do |response|
+  JSON.parse(response.body)
+end
+hydra.queue first_request
+hydra.queue second_request
+hydra.run # this is a blocking call that returns once all requests are complete
+
+first_request.handled_response # the value returned from the on_complete block
+second_request.handled_response # the value returned from the on_complete block (parsed JSON)
+</pre>
+
+The execution of that code goes something like this. The first and second requests are built and queued. When hydra is run the first and second requests run in parallel. When the first request completes, the third request is then built and queued up. The moment it is queued Hydra starts executing it. Meanwhile the second request would continue to run (or it could have completed before the first). Once the third request is done, hydra.run returns.
+
+*Specifying Max Concurrency*
+
+Hydra will also handle how many requests you can make in parallel. Things will get flakey if you try to make too many requests at the same time. The built in limit is 200. When more requests than that are queued up, hydra will save them for later and start the requests as others are finished. You can raise or lower the concurrency limit through the Hydra constructor.
+
+<pre>
+hydra = Typhoeus::Hydra.new(:max_concurrency => 20) # keep from killing some servers
+</pre>
+
+*Memoization*
+Hydra memoizes requests within a single run call. You can also disable memoization.
+
+<pre>
+hydra = Typhoeus::Hydra.new
+2.times do
+  r = Typhoeus::Request.new("http://localhost/3000/users/1")
+  hydra.queue r
+end
+hydra.run # this will result in a single request being issued. However, the on_complete handlers of both will be called.
+hydra.disable_memoization
+2.times do
+  r = Typhoeus::Request.new("http://localhost/3000/users/1")
+  hydra.queue r
+end
+hydra.run # this will result in a two requests.
+</pre>
+
+*Caching*
+Hydra includes built in support for creating cache getters and setters. In the following example, if there is a cache hit, the cached object is passed to the on_complete handler of the request object.
+
+<pre>
+hydra = Typhoeus::Hydra.new
+hydra.cache_setter do |request|
+  @cache.set(request.cache_key, request.response, request.cache_timeout)
+end
+
+hydra.cache_getter do |request|
+  @cache.get(request.cache_key) rescue nil
+end
+</pre>
+
+*Stubbing*
+Hydra allows you to stub out specific urls and patters to avoid hitting remote servers while testing.
+
+<pre>
+hydra = Typhoeus::Hydra.new
+response = Response.new(:code => 200, :headers => "", :body => "{'name' : 'paul'}", :time => 0.3)
+hydra.stub(:get, "http://localhost:3000/users/1").and_return(response)
+
+request = Typhoeus::Request.new("http://localhost:3000/users/1")
+request.on_complete do |response|
+  JSON.parse(response.body)
+end
+hydra.queue request
+hydra.run
+</pre>
+
+The queued request will hit the stub. The on_complete handler will be called and will be passed the response object. You can also specify a regex to match urls.
+
+<pre>
+hydra.stub(:get, /http\:\/\/localhost\:3000\/users\/.*/).and_return(response)
+# any requests for a user will be stubbed out with the pre built response.
+</pre>
+
+*The Singleton*
+All of the quick requests are done using the singleton hydra object. If you want to enable caching or stubbing on the quick requests, set those options on the singleton.
+
+<pre>
+hydra = Typhoeus::Hydra.hydra
+hydra.stub(:get, "http://localhost:3000/users")
+</pre>
+
+*Basic Authentication*
+
+<pre>
+response = Typhoeus::Request.get("http://twitter.com/statuses/followers.json",
+                                 :username => username, :password => password)
+</pre>
+
+*SSL*
+SSL comes built in to libcurl so it's in Typhoeus as well. If you pass in a url with "https" it should just work assuming that you have your "cert bundle":http://curl.haxx.se/docs/caextract.html in order and the server is verifiable. You must also have libcurl built with SSL support enabled. You can check that by doing this:
+
+<pre>
+Typhoeus::Easy.new.curl_version # output should include OpenSSL/...
+</pre>
+
+Now, even if you have libcurl built with OpenSSL you may still have a messed up cert bundle or if you're hitting a non-verifiable SSL server then you'll have to disable peer verification to make SSL work. Like this:
+
+<pre>
+Typhoeus::Request.get("https://mail.google.com/mail", :disable_ssl_peer_verification => true)
+</pre>
+
+*LibCurl*
+Typhoeus also has a more raw libcurl interface. These are the Easy and Multi objects. If you're into accessing just the raw libcurl style, those are your best bet.
+
+SSL Certs can be provided to the Easy interface :
+
+<pre>
+e = Typhoeus::Easy.new
+e.url = "https://example.com/action"
+s.ssl_cacert = "ca_file.cer"
+e.ssl_cert = "acert.crt"
+e.ssl_key = "akey.key"
+[...]
+e.perform
+</pre>
+
+or directly to a Typhoeus::Request :
+
+<pre>
+e = Typhoeus::Request.get("https://example.com/action",
+  :ssl_cacert => "ca_file.cer",
+  :ssl_cert => "acert.crt",
+  :ssl_key => "akey.key",
+  [...]
+end
+</pre>
+
+h2. Advanced authentication
+
+Thanks for the authentication piece and this description go to Oleg Ivanov (morhekil). The major reason to start this fork was the need to perform NTLM authentication in Ruby, and other libcurl's authentications method were made possible as a result. Now you can do it via Typhoeus::Easy interface using the following API.
+
+<pre>
+e = Typhoeus::Easy.new
+e.auth = {
+  :username => 'username',
+  :password => 'password',
+  :method => Typhoeus::Easy::AUTH_TYPES[:CURLAUTH_NTLM]
+}
+e.url = "http://example.com/auth_ntlm"
+e.method = :get
+e.perform
+</pre>
+
+*Other authentication types*
+
+The following authentication types are available:
+* CURLAUTH_BASIC
+* CURLAUTH_DIGEST
+* CURLAUTH_GSSNEGOTIATE
+* CURLAUTH_NTLM
+* CURLAUTH_DIGEST_IE
+* CURLAUTH_AUTO
+
+The last one (CURLAUTH_AUTO) is really a combination of all previous methods and is provided by Typhoeus for convenience. When you set authentication to auto, Typhoeus will retrieve the given URL first and examine it's headers to confirm what auth types are supported by the server. The it will select the strongest of available auth methods and will send the second request using the selected authentication method.
+
+*Authentication via the quick request interface*
+
+There's also an easy way to perform any kind of authentication via the quick request interface:
+
+<pre>
+e = Typhoeus::Request.get("http://example.com",
+  :username => 'username',
+  :password => 'password',
+  :method => :ntlm)
+</pre>
+
+All methods listed above is available in a shorter form - :basic, :digest, :gssnegotiate, :ntlm, :digest_ie, :auto.
+
+*Query of available auth types*
+
+After the initial request you can get the authentication types available on the server via Typhoues::Easy#auth_methods call. It will return a number
+that you'll need to decode yourself, please refer to easy.rb source code to see the numeric values of different auth types.
+
+h2. Verbose debug output
+
+Sometime it's useful to see verbose output from curl. You may now enable it:
+
+<pre>
+e = Typhoeus::Easy.new
+e.verbose = 1
+</pre>
+
+or using the quick request:
+
+<pre>
+e = Typhoeus::Request.get("http://example.com", :verbose => true)
+</pre>
+
+Just remember that libcurl prints it's debug output to the console (to STDERR), so you'll need to run your scripts from the console to see it.
+
+h2. Benchmarks
+
+I set up a benchmark to test how the parallel performance works vs Ruby's built in NET::HTTP. The setup was a local evented HTTP server that would take a request, sleep for 500 milliseconds and then issued a blank response. I set up the client to call this 20 times. Here are the results:
+
+<pre>
+  net::http  0.030000   0.010000   0.040000 ( 10.054327)
+  typhoeus   0.020000   0.070000   0.090000 (  0.508817)
+</pre>
+
+We can see from this that NET::HTTP performs as expected, taking 10 seconds to run 20 500ms requests. Typhoeus only takes 500ms (the time of the response that took the longest.) One other thing to note is that Typhoeus keeps a pool of libcurl Easy handles to use. For this benchmark I warmed the pool first. So if you test this out it may be a bit slower until the Easy handle pool has enough in it to run all the simultaneous requests. For some reason the easy handles can take quite some time to allocate.
+
+h2. Next Steps
+
+* Add in ability to keep-alive requests and reuse them within hydra.
+* Add support for automatic retry, exponential back-off, and queuing for later.
+
+h2. LICENSE
+
+(The MIT License)
+
+Copyright (c) 2009:
+
+"Paul Dix":http://pauldix.net
+
+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/Rakefile

@@ -0,0 +1,39 @@
+require "spec"
+require "spec/rake/spectask"
+require 'lib/typhoeus.rb'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "typhoeus"
+    gemspec.summary = "A library for interacting with web services (and building SOAs) at blinding speed."
+    gemspec.description = "Like a modern code version of the mythical beast with 100 serpent heads, Typhoeus runs HTTP requests in parallel while cleanly encapsulating handling logic."
+    gemspec.email = "paul@pauldix.net"
+    gemspec.homepage = "http://github.com/pauldix/typhoeus"
+    gemspec.authors = ["Paul Dix"]
+    gemspec.add_dependency "rack"
+    gemspec.add_development_dependency "rspec"
+    gemspec.add_development_dependency "jeweler"
+    gemspec.add_development_dependency "diff-lcs"
+    gemspec.add_development_dependency "sinatra"
+    gemspec.add_development_dependency "json"
+  end
+
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = ['--options', "\"#{File.dirname(__FILE__)}/spec/spec.opts\""]
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+task :install do
+  rm_rf "*.gem"
+  puts `gem build typhoeus.gemspec`
+  puts `sudo gem install typhoeus-#{Typhoeus::VERSION}.gem`
+end
+
+desc "Run all the tests"
+task :default => :spec

data/VERSION

@@ -0,0 +1 @@
+0.1.31

data/benchmarks/profile.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/../lib/typhoeus.rb'
+require 'rubygems'
+require 'ruby-prof'
+
+calls = 20
+@klass = Class.new do
+  include Typhoeus
+end
+
+Typhoeus.init_easy_objects
+
+RubyProf.start
+
+responses = []
+calls.times do |i|
+  responses << @klass.get("http://127.0.0.1:3000/#{i}")
+end
+
+responses.each {|r| }#raise unless r.response_body == "whatever"}
+
+result = RubyProf.stop
+
+ # Print a flat profile to text
+ printer = RubyProf::FlatPrinter.new(result)
+ printer.print(STDOUT, 0)

data/benchmarks/vs_nethttp.rb

@@ -0,0 +1,35 @@
+require 'rubygems'
+require File.dirname(__FILE__) + '/../lib/typhoeus.rb'
+require 'open-uri'
+require 'benchmark'
+include Benchmark
+
+
+calls = 20
+@klass = Class.new do
+  include Typhoeus
+end
+
+Typhoeus.init_easy_object_pool
+
+benchmark do |t|    
+  t.report("net::http") do
+    responses = []
+    
+    calls.times do |i|
+      responses << open("http://127.0.0.1:3000/#{i}").read
+    end
+    
+    responses.each {|r| raise unless r == "whatever"}    
+  end
+  
+  t.report("typhoeus") do
+    responses = []
+    
+    calls.times do |i|
+      responses << @klass.get("http://127.0.0.1:3000/#{i}")
+    end
+    
+    responses.each {|r| raise unless r.body == "whatever"}
+  end
+end

data/examples/twitter.rb

@@ -0,0 +1,21 @@
+require 'rubygems'
+require File.dirname(__FILE__) + '/../lib/typhoeus.rb'
+require 'json'
+
+class Twitter
+  include Typhoeus
+  remote_defaults :on_success => lambda {|response| JSON.parse(response.body)},
+                  :on_failure => lambda {|response| puts "error code: #{response.code}"},
+                  :base_uri   => "http://search.twitter.com"
+
+  define_remote_method :search, :path => '/search.json'
+  define_remote_method :trends, :path => '/trends/:time_frame.json'
+end
+
+tweets = Twitter.search(:params => {:q => "railsconf"})
+trends = Twitter.trends(:time_frame => :current)
+
+# and then the calls don't actually happen until the first time you
+# call a method on one of the objects returned from the remote_method
+
+puts tweets.keys # it's a hash from parsed JSON

data/lib/typhoeus/easy.rb

@@ -1,8 +1,9 @@
 module Typhoeus
   class Easy
-    attr_reader :response_body, :response_header, :method, :headers, :url
+    attr_reader :response_body, :response_header, :method, :headers, :url, :params
     attr_accessor :start_time
 
+    # These integer codes are available in curl/curl.h
     CURLINFO_STRING = 1048576
     OPTION_VALUES = {
       :CURLOPT_URL            => 10002,
@@ -11,9 +12,14 @@ module Typhoeus
       :CURLOPT_UPLOAD         => 46,
       :CURLOPT_CUSTOMREQUEST  => 10036,
       :CURLOPT_POSTFIELDS     => 10015,
+      :CURLOPT_COPYPOSTFIELDS     => 10165,
       :CURLOPT_POSTFIELDSIZE  => 60,
       :CURLOPT_USERAGENT      => 10018,
       :CURLOPT_TIMEOUT_MS     => 155,
+      # Time-out connect operations after this amount of milliseconds.
+      # [Only works on unix-style/SIGALRM operating systems. IOW, does
+      # not work on Windows.
+      :CURLOPT_CONNECTTIMEOUT_MS  => 156,
       :CURLOPT_NOSIGNAL       => 99,
       :CURLOPT_HTTPHEADER     => 10023,
       :CURLOPT_FOLLOWLOCATION => 52,
@@ -23,25 +29,37 @@ module Typhoeus
       :CURLOPT_VERBOSE        => 41,
       :CURLOPT_PROXY          => 10004,
       :CURLOPT_VERIFYPEER     => 64,
-      :CURLOPT_NOBODY         => 44
+      :CURLOPT_NOBODY         => 44,
+      :CURLOPT_ENCODING       => 10000 + 102,
+      :CURLOPT_SSLCERT        => 10025,
+      :CURLOPT_SSLCERTTYPE    => 10086,
+      :CURLOPT_SSLKEY         => 10087,
+      :CURLOPT_SSLKEYTYPE     => 10088,
+      :CURLOPT_KEYPASSWD      => 10026,
+      :CURLOPT_CAINFO         => 10065,
+      :CURLOPT_CAPATH         => 10097
     }
     INFO_VALUES = {
       :CURLINFO_RESPONSE_CODE => 2097154,
       :CURLINFO_TOTAL_TIME    => 3145731,
-      :CURLINFO_HTTPAUTH_AVAIL => 0x200000 + 23
+      :CURLINFO_HTTPAUTH_AVAIL => 0x200000 + 23,
+      :CURLINFO_EFFECTIVE_URL => 0x100000 + 1
     }
     AUTH_TYPES = {
       :CURLAUTH_BASIC         => 1,
       :CURLAUTH_DIGEST        => 2,
       :CURLAUTH_GSSNEGOTIATE  => 4,
       :CURLAUTH_NTLM          => 8,
-      :CURLAUTH_DIGEST_IE     => 16
+      :CURLAUTH_DIGEST_IE     => 16,
+      :CURLAUTH_AUTO          => 16 | 8 | 4 | 2 | 1
     }
 
     def initialize
       @method = :get
-      @post_dat_set = nil
       @headers = {}
+
+      # Enable encoding/compression support
+      set_option(OPTION_VALUES[:CURLOPT_ENCODING], '')
     end
 
     def headers=(hash)
@@ -69,6 +87,10 @@ module Typhoeus
       get_info_double(INFO_VALUES[:CURLINFO_TOTAL_TIME])
     end
 
+    def effective_url
+      get_info_string(INFO_VALUES[:CURLINFO_EFFECTIVE_URL])
+    end
+
     def response_code
       get_info_long(INFO_VALUES[:CURLINFO_RESPONSE_CODE])
     end
@@ -84,6 +106,12 @@ module Typhoeus
     def max_redirects=(redirects)
       set_option(OPTION_VALUES[:CURLOPT_MAXREDIRS], redirects)
     end
+    
+    def connect_timeout=(milliseconds)
+      @connect_timeout = milliseconds
+      set_option(OPTION_VALUES[:CURLOPT_NOSIGNAL], 1)
+      set_option(OPTION_VALUES[:CURLOPT_CONNECTTIMEOUT_MS], milliseconds)
+    end
 
     def timeout=(milliseconds)
       @timeout = milliseconds
@@ -95,6 +123,10 @@ module Typhoeus
       @timeout && total_time_taken > @timeout && response_code == 0
     end
 
+    def supports_zlib?
+      !!(curl_version.match(/zlib/))
+    end
+
     def request_body=(request_body)
       @request_body = request_body
       if @method == :put
@@ -132,17 +164,18 @@ module Typhoeus
       elsif method == :head
         set_option(OPTION_VALUES[:CURLOPT_NOBODY], 1)
       else
-        set_option(OPTION_VALUES[:CURLOPT_CUSTOMREQUEST], "DELETE")
+        set_option(OPTION_VALUES[:CURLOPT_CUSTOMREQUEST], method.to_s.upcase)
       end
     end
 
     def post_data=(data)
       @post_data_set = true
-      set_option(OPTION_VALUES[:CURLOPT_POSTFIELDS], data)
       set_option(OPTION_VALUES[:CURLOPT_POSTFIELDSIZE], data.length)
+      set_option(OPTION_VALUES[:CURLOPT_COPYPOSTFIELDS], data)
     end
 
     def params=(params)
+      @params = params
       params_string = params.keys.collect do |k|
         value = params[k]
         if value.is_a? Hash
@@ -162,10 +195,58 @@ module Typhoeus
       end
     end
 
+    # Set SSL certificate
+    # " The string should be the file name of your certificate. "
+    # The default format is "PEM" and can be changed with ssl_cert_type=
+    def ssl_cert=(cert)
+      set_option(OPTION_VALUES[:CURLOPT_SSLCERT], cert)
+    end
+
+    # Set SSL certificate type
+    # " The string should be the format of your certificate. Supported formats are "PEM" and "DER" "
+    def ssl_cert_type=(cert_type)
+      raise "Invalid ssl cert type : '#{cert_type}'..." if cert_type and !%w(PEM DER).include?(cert_type) 
+      set_option(OPTION_VALUES[:CURLOPT_SSLCERTTYPE], cert_type)
+    end
+
+    # Set SSL Key file
+    # " The string should be the file name of your private key. "
+    # The default format is "PEM" and can be changed with ssl_key_type=
+    #
+    def ssl_key=(key)
+      set_option(OPTION_VALUES[:CURLOPT_SSLKEY], key)
+    end
+
+    # Set SSL Key type
+    # " The string should be the format of your private key. Supported formats are "PEM", "DER" and "ENG". "
+    #
+    def ssl_key_type=(key_type)
+      raise "Invalid ssl key type : '#{key_type}'..." if key_type and !%w(PEM DER ENG).include?(key_type)
+      set_option(OPTION_VALUES[:CURLOPT_SSLKEYTYPE], key_type)
+    end
+
+    def ssl_key_password=(key_password)
+      set_option(OPTION_VALUES[:CURLOPT_KEYPASSWD], key_password)
+    end
+
+    # Set SSL CACERT
+    # " File holding one or more certificates to verify the peer with. "
+    #
+    def ssl_cacert=(cacert)
+      set_option(OPTION_VALUES[:CURLOPT_CAINFO], cacert)
+    end
+
+    # Set CAPATH
+    # " directory holding multiple CA certificates to verify the peer with. The certificate directory must be prepared using the openssl c_rehash utility. "
+    #
+    def ssl_capath=(capath)
+      set_option(OPTION_VALUES[:CURLOPT_CAPATH], capath)
+    end
+
     def set_option(option, value)
       if value.class == String
         easy_setopt_string(option, value)
-      else
+      elsif value
         easy_setopt_long(option, value)
       end
     end
@@ -173,7 +254,13 @@ module Typhoeus
     def perform
       set_headers()
       easy_perform()
-      response_code()
+      resp_code = response_code() 
+      if resp_code >= 200 && resp_code <= 299
+        success
+      else
+        failure
+      end
+      resp_code
     end
 
     def set_headers
@@ -249,5 +336,6 @@ module Typhoeus
     def curl_version
       version
     end
+
   end
 end