abhay-typhoeus 0.0.22

data/.gitignore

@@ -0,0 +1 @@
+.*.sw?

data/README.textile

@@ -0,0 +1,212 @@
+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), a nifty DSL for creating classes that make http calls and process responses, 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
+
+For now Typhoeus exists only on github. It requires you to have a current version of libcurl installed. I've tested this with 7.19.4.
+<pre>
+gem sources -a http://gems.github.com # if you haven't already
+gem install pauldix-typhoeus
+</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>
+
+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. Unfortunately, I still haven't been able to get this to work on either my Mac or Linux. I'll have to figure that out.
+
+h2. Usage
+
+
+<pre>
+require 'rubygems'
+require 'typhoeus'
+require 'json'  
+
+# here's an example for twitter search
+# Including Typhoeus adds http methods like get, put, post, and delete.
+# What's more interesting though is the stuff to build up what I call
+# remote_methods.
+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"})
+
+# if you look at the path argument for the :trends method, it has :time_frame.
+# this tells it to add in a parameter called :time_frame that gets interpolated
+# and inserted.
+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
+
+# you can also do things like override any of the default parameters
+Twitter.search(:params => {:q => "hi"}, :on_success => lambda {|response| puts response.body})
+
+# on_success and on_failure lambdas take a response object. 
+# It has four accesssors: code, body, headers, and time
+
+# here's and example of memoization
+twitter_searches = []
+10.times do
+  twitter_searches << Twitter.search(:params => {:q => "railsconf"})
+end
+
+# this next part will actually make the call. However, it only makes one
+# http request and parses the response once. The rest are memoized.
+twitter_searches.each {|s| puts s.keys}
+
+# you can also have it cache responses and do gets automatically
+# here we define a remote method that caches the responses for 60 seconds
+klass = Class.new do
+  include Typhoeus
+  
+  define_remote_method :foo, :base_uri => "http://localhost:3001", :cache_responses => 60
+end
+
+klass.cache = some_memcached_instance_or_whatever
+response = klass.foo 
+puts response.body # makes the request
+
+second_response = klass.foo
+puts response.body # pulls from the cache without making a request
+
+# you can also pass timeouts on the define_remote_method or as a parameter
+# Note that timeouts are in milliseconds.
+Twitter.trends(:time_frame => :current, :timeout => 2000)
+
+# you also get the normal get, put, post, and delete methods
+class Remote
+  include Typhoeus
+end
+
+Remote.get("http://www.pauldix.net")
+Remote.put("http://", :body => "this is a request body")
+Remote.post("http://localhost:3001/posts.xml", 
+  {:params => {:post => {:author => "paul", :title => "a title", :body => "a body"}}})
+Remote.delete("http://localhost:3001/posts/1")
+
+# you also have the ability to set request headers. So you can set your user agent and manually
+Remote.get("http://www.pauldix.net", :headers => {"User-Agent" => "typhoeus", "If-None-Match" => "some etag"})
+
+# and do things like basic HTTP authentication
+require 'base64'
+Remote.get("http://twitter.com/statuses/followers.json", 
+           :headers => {"Authorization" => "Basic #{Base64.b64encode("login:password")}"})
+
+# body and headers arguments also get passed through on defined remote methods.
+class TwitterRestAPI
+  include Typhoeus
+  remote_defaults :on_success => lambda {|response| JSON.parse(response.body)},
+                  :on_failure => lambda {|response| puts "error code: #{response.code}"},
+                  :base_uri   => "http://twitter.com"
+
+  define_remote_method :followers, 
+                       :path => '/statuses/followers.json', 
+                       :headers => {"Authorization" => "Basic #{Base64.b64encode("twitter_id:password")}"}
+end
+
+# The response object returned by get, put, post, and delete is passed to the on_success 
+# or on_failure lambda block if declared.
+# The return value of the lambda block is then what is returned by the remote method invocation.
+# The response object can do the following:
+response.code    # the http return code
+response.body    # the body of the response
+response.headers # the response headers
+response.time    # the response time in seconds
+
+# Typhoeus also has a nifty mocking framework built in
+# mock all calls to get
+Remote.mock(:get, :code => 200, :body => "whatever")
+
+# here we mock calls to get for the url
+Remote.mock(:get, :url => "http://pauldix.net", :code => 200, :body => "hi", :headers => "there", :time => 2)
+
+# note that url, code, body, headers, and time are all optional parameters to mock.
+# the first parameter can be either :get, :put, :post, or :delete
+
+# you can also provide headers and body that are expected on the call. An exception will be raised if they don't match
+Remote.mock(:get, :url => "http://pauldix.net", :expected_headers => {"If-None-Match" => "sldfkj234"})
+Remote.mock(:put, :url => "http://pauldix.net", :expected_body => "this is a body!")
+
+# using that mocking you could mock out the Twitter client like so:
+Twitter.mock(:get, :body => '{"hi": "there"}')
+# now any calls to trends, or search will get the mock and call the on_success handler. the response object will have that body.
+# we could also mock out a failure like so
+Twitter.mock(:get, :body => '{"fail": "oh noes!"}', :code => 500)
+# now calls to a remote method will result in the on_failure handler being called
+</pre>
+
+The best place to see the functionality of what including Typhoeus in a class gives you is to look at the "remote_spec.rb"
+
+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
+
+* Write up some more examples.
+* Create a SimpleDB client library using Typhoeus.
+* Create or get someone to create a CouchDB client library using Typhoeus.
+* Add support for automatic retry, exponential back-off, and queuing for later.
+* Add in the support for custom get and set methods on the cache.
+* Add in support for integrated HTTP caching with Memcached.
+
+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,45 @@
+begin
+  require './lib/typhoeus.rb'
+rescue LoadError => err
+  puts "Typhoeus has not been built correctly: #{err.message}"
+end
+
+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.email = "paul@pauldix.net"
+    gemspec.homepage = "http://github.com/pauldix/typhoeus"
+    gemspec.authors = ["Paul Dix"]
+    
+    gemspec.require_path = ['lib', 'ext']
+    gemspec.extra_rdoc_files = `git ls-files *.rdoc`.split("\n")
+    gemspec.files = `git ls-files`.split("\n")
+    gemspec.extensions = ["ext/typhoeus/extconf.rb"]
+  end
+  
+  task :install do
+    # rm_rf "*.gem"
+    # puts `gem build typhoeus.gemspec`
+    # puts `sudo gem install typhoeus-#{Typhoeus::VERSION}.gem`
+  end
+  
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install jeweler"
+end
+
+begin
+  require "spec"
+  require "spec/rake/spectask"
+  
+  Spec::Rake::SpecTask.new do |t|
+    t.spec_opts = ['--options', "\"#{File.dirname(__FILE__)}/spec/spec.opts\""]
+    t.spec_files = FileList['spec/**/*_spec.rb']
+  end
+
+  desc "Run all the tests"
+  task :default => :spec
+rescue LoadError => err
+  puts "RSpec not available"
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.22

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 File.dirname(__FILE__) + '/../lib/typhoeus.rb'
+require 'rubygems'
+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/ext/typhoeus/.gitignore

@@ -0,0 +1,6 @@
+conftest.dSYM/*
+conftest.dSYM
+mkmf.log
+*.o
+native.bundle
+Makefile

data/ext/typhoeus/extconf.rb

@@ -0,0 +1,23 @@
+ENV["ARCHFLAGS"] = "-arch #{`uname -p` =~ /powerpc/ ? 'ppc' : 'i386'}"
+
+require 'mkmf'
+
+dir_config('curl')
+
+if find_executable('curl-config')
+  $CFLAGS << " #{`curl-config --cflags`.strip}"
+  $LIBS << " #{`curl-config --libs`.strip}"
+elsif !have_library('curl') or !have_header('curl/curl.h')
+  fail <<-EOM
+Can't find libcurl or curl/curl.h
+ 
+Try passing --with-curl-dir or --with-curl-lib and --with-curl-include
+options to extconf.
+EOM
+end
+
+if try_compile('int main() { return 0; }','-Wall')
+  $CFLAGS << ' -O3 -Wall -Wcast-qual -Wwrite-strings -Wconversion -Wmissing-noreturn -Winline'
+end
+
+create_makefile("typhoeus/native")

data/ext/typhoeus/native.c

@@ -0,0 +1,11 @@
+#include <native.h>
+
+VALUE mTyphoeus;
+
+void Init_native()
+{
+	mTyphoeus = rb_const_get(rb_cObject, rb_intern("Typhoeus"));
+	
+	init_typhoeus_easy();
+	init_typhoeus_multi();
+}

data/ext/typhoeus/native.h

@@ -0,0 +1,20 @@
+#ifndef TYPHOEUS_NATIVE
+#define TYPHOEUS_NATIVE
+
+#include <ruby.h>
+
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#endif
+
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
+
+#include <curl/curl.h>
+#include <curl/easy.h>
+#include <curl/multi.h>
+
+extern VALUE mTyphoeus;
+
+#endif

data/ext/typhoeus/typhoeus_easy.c

@@ -0,0 +1,206 @@
+#include <typhoeus_easy.h>
+	
+static VALUE idAppend;
+VALUE cTyphoeusEasy;
+
+static void dealloc(CurlEasy *curl_easy) {
+	if (curl_easy->request_chunk != NULL) {
+		free(curl_easy->request_chunk);
+	}
+	
+	if (curl_easy->headers != NULL) {
+		curl_slist_free_all(curl_easy->headers);
+	}
+	
+	curl_easy_cleanup(curl_easy->curl);
+	
+	free(curl_easy);
+}
+
+static VALUE easy_setopt_string(VALUE self, VALUE opt_name, VALUE parameter) {
+	CurlEasy *curl_easy;
+	Data_Get_Struct(self, CurlEasy, curl_easy);
+
+	long opt = NUM2LONG(opt_name);
+	curl_easy_setopt(curl_easy->curl, opt, StringValuePtr(parameter));
+	return opt_name;
+}
+
+static VALUE easy_setopt_long(VALUE self, VALUE opt_name, VALUE parameter) {
+	CurlEasy *curl_easy;
+	Data_Get_Struct(self, CurlEasy, curl_easy);
+
+	long opt = NUM2LONG(opt_name);
+	curl_easy_setopt(curl_easy->curl, opt, NUM2LONG(parameter));
+	return opt_name;	
+}
+
+static VALUE easy_getinfo_string(VALUE self, VALUE info) {
+	char *info_string;
+	CurlEasy *curl_easy;
+	Data_Get_Struct(self, CurlEasy, curl_easy);
+
+	long opt = NUM2LONG(info);
+	curl_easy_getinfo(curl_easy->curl, opt, &info_string);
+	
+	return rb_str_new2(info_string);
+}
+
+static VALUE easy_getinfo_long(VALUE self, VALUE info) {
+	long info_long;
+	CurlEasy *curl_easy;
+	Data_Get_Struct(self, CurlEasy, curl_easy);
+
+	long opt = NUM2LONG(info);
+	curl_easy_getinfo(curl_easy->curl, opt, &info_long);
+	
+	return LONG2NUM(info_long);
+}
+
+static VALUE easy_getinfo_double(VALUE self, VALUE info) {
+	double info_double = 0;
+	CurlEasy *curl_easy;
+	Data_Get_Struct(self, CurlEasy, curl_easy);
+
+	long opt = NUM2LONG(info);
+	curl_easy_getinfo(curl_easy->curl, opt, &info_double);
+
+	return rb_float_new(info_double);
+}
+
+static VALUE easy_perform(VALUE self) {
+	CurlEasy *curl_easy;
+	Data_Get_Struct(self, CurlEasy, curl_easy);
+	curl_easy_perform(curl_easy->curl);
+
+	return Qnil;
+}
+
+static size_t write_data_handler(char *stream, size_t size, size_t nmemb, VALUE val) {
+	rb_funcall(val, idAppend, 1, rb_str_new(stream, size * nmemb));
+	return size * nmemb;
+}
+
+static size_t read_callback(void *ptr, size_t size, size_t nmemb, void *data) {
+	int realsize = size * nmemb;
+	RequestChunk *mem = (RequestChunk *)data;
+
+	if (realsize > mem->size - mem->read) {
+		realsize = mem->size - mem->read;
+	}
+	
+	if (realsize != 0) {
+		memcpy(ptr, &(mem->memory[mem->read]), realsize);
+		mem->read += realsize;
+	}
+	
+	return realsize; 
+}
+
+static void set_response_handlers(VALUE easy, CURL *curl) {
+	rb_iv_set(easy, "@response_body", rb_str_new2(""));
+	rb_iv_set(easy, "@response_header", rb_str_new2(""));
+	
+  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, (curl_write_callback)&write_data_handler);
+  curl_easy_setopt(curl, CURLOPT_WRITEDATA, rb_iv_get(easy, "@response_body"));	
+  curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, (curl_write_callback)&write_data_handler);
+  curl_easy_setopt(curl, CURLOPT_HEADERDATA, rb_iv_get(easy, "@response_header"));
+}
+
+static VALUE easy_reset(VALUE self) {
+	CurlEasy *curl_easy;
+	Data_Get_Struct(self, CurlEasy, curl_easy);
+
+	if (curl_easy->request_chunk != NULL) {
+		free(curl_easy->request_chunk);
+		curl_easy->request_chunk = NULL;
+	}
+	
+	if (curl_easy->headers != NULL) {
+		curl_slist_free_all(curl_easy->headers);
+		curl_easy->headers = NULL;
+	}
+
+	curl_easy_reset(curl_easy->curl);
+
+	set_response_handlers(self, curl_easy->curl);
+	
+	return Qnil;	
+}
+
+static VALUE easy_add_header(VALUE self, VALUE header) {
+	CurlEasy *curl_easy;
+	Data_Get_Struct(self, CurlEasy, curl_easy);
+	
+	curl_easy->headers = curl_slist_append(curl_easy->headers, RSTRING_PTR(header));
+	return header;
+}
+
+static VALUE easy_set_headers(VALUE self) {
+	CurlEasy *curl_easy;
+	Data_Get_Struct(self, CurlEasy, curl_easy);
+
+	curl_easy_setopt(curl_easy->curl, CURLOPT_HTTPHEADER, curl_easy->headers);
+	
+	return Qnil;
+}
+
+static VALUE easy_set_request_body(VALUE self, VALUE data, VALUE content_length_header) {
+	CurlEasy *curl_easy;
+	Data_Get_Struct(self, CurlEasy, curl_easy);
+
+	curl_easy->request_chunk = ALLOC(RequestChunk);
+	curl_easy->request_chunk->size = RSTRING_LEN(data);
+	curl_easy->request_chunk->memory = StringValuePtr(data);
+	curl_easy->request_chunk->read = 0;
+
+  curl_easy_setopt(curl_easy->curl, CURLOPT_READFUNCTION, (curl_read_callback)read_callback);
+  curl_easy_setopt(curl_easy->curl, CURLOPT_READDATA, curl_easy->request_chunk);
+	curl_easy_setopt(curl_easy->curl, CURLOPT_INFILESIZE, RSTRING_LEN(data));
+
+	return Qnil;
+}
+
+static VALUE easy_escape(VALUE self, VALUE data, VALUE length) {
+	CurlEasy *curl_easy;
+	Data_Get_Struct(self, CurlEasy, curl_easy);
+
+	return rb_str_new2(curl_easy_escape(curl_easy->curl, StringValuePtr(data), NUM2INT(length)));
+}
+
+static VALUE version(VALUE self) {
+	return rb_str_new2(curl_version());
+}
+
+static VALUE new(int argc, VALUE *argv, VALUE klass) {
+	CURL *curl = curl_easy_init();
+	CurlEasy *curl_easy = ALLOC(CurlEasy);
+	curl_easy->curl = curl;
+	curl_easy->headers = NULL;
+	curl_easy->request_chunk = NULL;
+	VALUE easy = Data_Wrap_Struct(cTyphoeusEasy, 0, dealloc, curl_easy);
+
+	set_response_handlers(easy, curl);
+
+	rb_obj_call_init(easy, argc, argv);
+
+	return easy;
+}
+
+void init_typhoeus_easy() {
+	VALUE klass = cTyphoeusEasy = rb_define_class_under(mTyphoeus, "Easy", rb_cObject);
+	idAppend = rb_intern("<<");
+	rb_define_singleton_method(klass, "new", new, -1);
+	rb_define_private_method(klass, "easy_setopt_string", easy_setopt_string, 2);
+	rb_define_private_method(klass, "easy_setopt_long", easy_setopt_long, 2);
+	rb_define_private_method(klass, "easy_getinfo_string", easy_getinfo_string, 1);
+	rb_define_private_method(klass, "easy_getinfo_long", easy_getinfo_long, 1);
+	rb_define_private_method(klass, "easy_getinfo_double", easy_getinfo_double, 1);
+	rb_define_private_method(klass, "easy_perform", easy_perform, 0);
+	rb_define_private_method(klass, "easy_reset", easy_reset, 0);
+	rb_define_private_method(klass, "easy_set_request_body", easy_set_request_body, 1);
+	rb_define_private_method(klass, "easy_set_headers", easy_set_headers, 0);
+	rb_define_private_method(klass, "easy_add_header", easy_add_header, 1);
+	rb_define_private_method(klass, "easy_escape", easy_escape, 2);
+	rb_define_private_method(klass, "version", version, 0);
+}