curb 0.7.1 → 0.7.3

data/ext/curb.h

@@ -20,11 +20,11 @@
 #include "curb_macros.h"
 
 // These should be managed from the Rake 'release' task.
-#define CURB_VERSION   "0.7.1"
-#define CURB_VER_NUM   701
+#define CURB_VERSION   "0.7.3"
+#define CURB_VER_NUM   703
 #define CURB_VER_MAJ   0
 #define CURB_VER_MIN   7
-#define CURB_VER_MIC   1
+#define CURB_VER_MIC   3
 #define CURB_VER_PATCH 0
 
 
@@ -37,11 +37,13 @@
   #define RSTRING_PTR(x) RSTRING(x)->ptr
 #endif
 
+#ifndef RHASH_LEN
 #ifdef HAVE_RUBY19_HASH
   #define RHASH_LEN(hash) RHASH(hash)->ntbl->num_entries
 #else
   #define RHASH_LEN(hash) RHASH(hash)->tbl->num_entries
 #endif
+#endif
 
 extern VALUE mCurl;
 

data/ext/curb_easy.c

@@ -135,9 +135,10 @@ static int proc_debug_handler(CURL *curl,
 /* ================== MARK/FREE FUNC ==================*/
 void curl_easy_mark(ruby_curl_easy *rbce) {
   rb_gc_mark(rbce->opts);
+  if (!NIL_P(rbce->multi)) { rb_gc_mark(rbce->multi); }
 }
 
-void curl_easy_free(ruby_curl_easy *rbce) {
+static void ruby_curl_easy_free(ruby_curl_easy *rbce) {
   if (rbce->curl_headers) {
     curl_slist_free_all(rbce->curl_headers);
   }
@@ -146,40 +147,22 @@ void curl_easy_free(ruby_curl_easy *rbce) {
     curl_slist_free_all(rbce->curl_ftp_commands);
   }
 
-  curl_easy_cleanup(rbce->curl);
+  if (rbce->curl) {
+    curl_easy_cleanup(rbce->curl);
+  }
+}
+
+void curl_easy_free(ruby_curl_easy *rbce) {
+  ruby_curl_easy_free(rbce);
   free(rbce);
 }
 
 
 /* ================= ALLOC METHODS ====================*/
 
-/*
- * call-seq:
- *   Curl::Easy.new                                   => #<Curl::Easy...>
- *   Curl::Easy.new(url = nil)                        => #<Curl::Easy...>
- *   Curl::Easy.new(url = nil) { |self| ... }         => #<Curl::Easy...>
- *
- * Create a new Curl::Easy instance, optionally supplying the URL.
- * The block form allows further configuration to be supplied before
- * the instance is returned.
- */
-static VALUE ruby_curl_easy_new(int argc, VALUE *argv, VALUE klass) {
-  CURLcode ecode;
-  VALUE url, blk;
-  VALUE new_curl;
-  ruby_curl_easy *rbce;
-
-  rb_scan_args(argc, argv, "01&", &url, &blk);
-
-  rbce = ALLOC(ruby_curl_easy);
-
-  /* handler */
-  rbce->curl = curl_easy_init();
-
+static void ruby_curl_easy_zero(ruby_curl_easy *rbce) {
   rbce->opts = rb_hash_new();
 
-  rb_easy_set("url", url);
-
   rbce->curl_headers = NULL;
   rbce->curl_ftp_commands = NULL;
 
@@ -211,6 +194,39 @@ static VALUE ruby_curl_easy_new(int argc, VALUE *argv, VALUE klass) {
   rbce->verbose = 0;
   rbce->multipart_form_post = 0;
   rbce->enable_cookies = 0;
+}
+
+/*
+ * call-seq:
+ *   Curl::Easy.new                                   => #<Curl::Easy...>
+ *   Curl::Easy.new(url = nil)                        => #<Curl::Easy...>
+ *   Curl::Easy.new(url = nil) { |self| ... }         => #<Curl::Easy...>
+ *
+ * Create a new Curl::Easy instance, optionally supplying the URL.
+ * The block form allows further configuration to be supplied before
+ * the instance is returned.
+ */
+static VALUE ruby_curl_easy_new(int argc, VALUE *argv, VALUE klass) {
+  CURLcode ecode;
+  VALUE url, blk;
+  VALUE new_curl;
+  ruby_curl_easy *rbce;
+
+  rb_scan_args(argc, argv, "01&", &url, &blk);
+
+  rbce = ALLOC(ruby_curl_easy);
+
+  /* handler */
+  rbce->curl = curl_easy_init();
+  if (!rbce->curl) {
+    rb_raise(eCurlErrFailedInit, "Failed to initialize easy handle");
+  }
+
+  rbce->multi = Qnil;
+
+  ruby_curl_easy_zero(rbce);
+
+  rb_easy_set("url", url);
 
   new_curl = Data_Wrap_Struct(klass, curl_easy_mark, curl_easy_free, rbce);
 
@@ -249,6 +265,72 @@ static VALUE ruby_curl_easy_clone(VALUE self) {
   return Data_Wrap_Struct(cCurlEasy, curl_easy_mark, curl_easy_free, newrbce);
 }
 
+/*
+ * call-seq:
+ *   easy.close                                      => nil
+ *
+ * Close the Curl::Easy instance. Any open connections are closed
+ * The easy handle is reinitialized.  If a previous multi handle was 
+ * open it is set to nil and will be cleared after a GC.
+ */
+static VALUE ruby_curl_easy_close(VALUE self) {
+  CURLcode ecode;
+  ruby_curl_easy *rbce;
+
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
+
+  ruby_curl_easy_free(rbce);
+
+  /* reinit the handle */
+  rbce->curl = curl_easy_init();
+  if (!rbce->curl) {
+    rb_raise(eCurlErrFailedInit, "Failed to initialize easy handle");
+  }
+
+  rbce->multi = Qnil;
+
+  ruby_curl_easy_zero(rbce);
+
+  /* give the new curl handle a reference back to the ruby object */
+  ecode = curl_easy_setopt(rbce->curl, CURLOPT_PRIVATE, (void*)self);
+  if (ecode != CURLE_OK) {
+    raise_curl_easy_error_exception(ecode);
+  }
+
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   easy.reset                                      => Hash
+ *
+ * Reset the Curl::Easy instance, clears out all settings.
+ *
+ * from http://curl.haxx.se/libcurl/c/curl_easy_reset.html
+ * Re-initializes all options previously set on a specified CURL handle to the default values. This puts back the handle to the same state as it was in when it was just created with curl_easy_init(3).
+ * It does not change the following information kept in the handle: live connections, the Session ID cache, the DNS cache, the cookies and shares.
+ *
+ * The return value contains all settings stored.
+ */
+static VALUE ruby_curl_easy_reset(VALUE self) {
+  CURLcode ecode;
+  ruby_curl_easy *rbce;
+  VALUE opts_dup;
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  opts_dup = rb_funcall(rbce->opts, rb_intern("dup"), 0);
+
+  curl_easy_reset(rbce->curl);
+  ruby_curl_easy_zero(rbce);
+
+  /* rest clobbers the private setting, so reset it to self */
+  ecode = curl_easy_setopt(rbce->curl, CURLOPT_PRIVATE, (void*)self);
+  if (ecode != CURLE_OK) {
+    raise_curl_easy_error_exception(ecode);
+  }
+
+  return opts_dup;
+}
+
 
 /* ================ OBJ ATTRIBUTES ==================*/
 
@@ -1985,10 +2067,13 @@ VALUE ruby_curl_easy_cleanup( VALUE self, ruby_curl_easy *rbce ) {
 static VALUE handle_perform(VALUE self, ruby_curl_easy *rbce) {
 
   VALUE ret;
-  VALUE multi = ruby_curl_multi_new(cCurlMulti);
 
-  rb_funcall(multi, rb_intern("add"), 1, self );
-  ret = rb_funcall(multi, rb_intern("perform"), 0);
+  /* reuse existing multi handle for this easy handle */
+  if (NIL_P(rbce->multi)) {
+    rbce->multi = ruby_curl_multi_new(cCurlMulti);
+  }
+  rb_funcall(rbce->multi, rb_intern("add"), 1, self );
+  ret = rb_funcall(rbce->multi, rb_intern("perform"), 0);
 
   /* check for errors in the easy response and raise exceptions if anything went wrong and their is no on_failure handler */
   if (rbce->last_result != 0 && rb_easy_nil("failure_proc")) {
@@ -2134,6 +2219,7 @@ static VALUE ruby_curl_easy_perform_post(int argc, VALUE *argv, VALUE self) {
     return ret;
   } else {
     VALUE post_body = Qnil;
+    /* TODO: check for PostField.file and raise error before to_s fails */
     if ((post_body = rb_funcall(args_ary, idJoin, 1, rbstrAmp)) == Qnil) {
       rb_raise(eCurlErrError, "Failed to join arguments");
       return Qnil;
@@ -3199,7 +3285,9 @@ void init_curb_easy() {
   rb_define_method(cCurlEasy, "os_errno", ruby_curl_easy_os_errno_get, 0);
   rb_define_method(cCurlEasy, "num_connects", ruby_curl_easy_num_connects_get, 0);
   rb_define_method(cCurlEasy, "ftp_entry_path", ruby_curl_easy_ftp_entry_path_get, 0);
-  rb_define_method(cCurlEasy, "inspect", ruby_curl_easy_inspect, 0);
+
+  rb_define_method(cCurlEasy, "close", ruby_curl_easy_close, 0);
+  rb_define_method(cCurlEasy, "reset", ruby_curl_easy_reset, 0);
 
   /* Curl utils */
   rb_define_method(cCurlEasy, "escape", ruby_curl_easy_escape, 1);
@@ -3208,4 +3296,5 @@ void init_curb_easy() {
   /* Runtime support */
   rb_define_method(cCurlEasy, "clone", ruby_curl_easy_clone, 0);
   rb_define_alias(cCurlEasy, "dup", "clone");
+  rb_define_method(cCurlEasy, "inspect", ruby_curl_easy_inspect, 0);
 }

data/ext/curb_easy.h

@@ -37,6 +37,7 @@ typedef struct {
   CURL *curl;
 
   VALUE opts; /* rather then allocate everything we might need to store, allocate a Hash and only store objects we actually use... */
+  VALUE multi; /* keep a multi handle alive for each easy handle not being used by a multi handle.  This improves easy performance when not within a multi context */
 
   /* Other opts */
   unsigned short local_port;       // 0 is no port

data/ext/curb_errors.c

@@ -110,6 +110,7 @@ VALUE eCurlErrSSLCRLBadfile;
 VALUE eCurlErrSSLIssuerError;
 
 /* multi errors */
+VALUE mCurlErrFailedInit;
 VALUE mCurlErrCallMultiPerform;
 VALUE mCurlErrBadHandle;
 VALUE mCurlErrBadEasyHandle;
@@ -605,6 +606,7 @@ void init_curb_errors() {
   eCurlErrSSLShutdownFailed  = rb_define_class_under(mCurlErr, "SSLShutdownFailed", eCurlErrError);
   eCurlErrSSH                = rb_define_class_under(mCurlErr, "SSH", eCurlErrError);
 
+  mCurlErrFailedInit         = rb_define_class_under(mCurlErr, "MultiInitError", eCurlErrError);
   mCurlErrCallMultiPerform   = rb_define_class_under(mCurlErr, "MultiPerform", eCurlErrError);
   mCurlErrBadHandle          = rb_define_class_under(mCurlErr, "MultiBadHandle", eCurlErrError);
   mCurlErrBadEasyHandle      = rb_define_class_under(mCurlErr, "MultiBadEasyHandle", eCurlErrError);

data/ext/curb_errors.h

@@ -108,6 +108,7 @@ extern VALUE eCurlErrSSLCRLBadfile;
 extern VALUE eCurlErrSSLIssuerError;
 
 /* multi errors */
+extern VALUE mCurlErrFailedInit;
 extern VALUE mCurlErrCallMultiPerform;
 extern VALUE mCurlErrBadHandle;
 extern VALUE mCurlErrBadEasyHandle;

data/ext/curb_multi.c

@@ -83,6 +83,9 @@ VALUE ruby_curl_multi_new(VALUE klass) {
   ruby_curl_multi *rbcm = ALLOC(ruby_curl_multi);
 
   rbcm->handle = curl_multi_init();
+  if (!rbcm->handle) {
+    rb_raise(mCurlErrFailedInit, "Failed to initialize multi handle");
+  }
 
   rbcm->requests = rb_hash_new();
 
@@ -415,16 +418,7 @@ VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
 
   rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
 
-  while(rbcm->running) {
-    FD_ZERO(&fdread);
-    FD_ZERO(&fdwrite);
-    FD_ZERO(&fdexcep);
-
-    /* load the fd sets from the multi handle */
-    mcode = curl_multi_fdset(rbcm->handle, &fdread, &fdwrite, &fdexcep, &maxfd);
-    if (mcode != CURLM_OK) {
-      raise_curl_multi_error_exception(mcode);
-    }
+  while (rbcm->running) {
 
 #ifdef HAVE_CURL_MULTI_TIMEOUT
     /* get the curl suggested time out */
@@ -433,26 +427,34 @@ VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
       raise_curl_multi_error_exception(mcode);
     }
 #else
-    /* libcurl doesn't have a timeout method defined... make a wild guess */
+    /* libcurl doesn't have a timeout method defined, initialize to -1 we'll pick up the default later */
     timeout_milliseconds = -1;
 #endif
-    //printf("libcurl says wait: %ld ms or %ld s\n", timeout_milliseconds, timeout_milliseconds/1000);
 
     if (timeout_milliseconds == 0) { /* no delay */
       rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
       continue;
     }
-    else if(timeout_milliseconds < 0) {
-      timeout_milliseconds = cCurlMutiDefaulttimeout; /* wait half a second, libcurl doesn't know how long to wait */
+    else if (timeout_milliseconds < 0) {
+      timeout_milliseconds = cCurlMutiDefaulttimeout; /* libcurl doesn't know how long to wait, use a default timeout */
     }
-#ifdef __APPLE_CC__
-    if(timeout_milliseconds > 1000) {
-      timeout_milliseconds = cCurlMutiDefaulttimeout; /* apple libcurl sometimes reports huge timeouts... let's cap it */
+
+    if (timeout_milliseconds > cCurlMutiDefaulttimeout) {
+      timeout_milliseconds = cCurlMutiDefaulttimeout; /* buggy versions libcurl sometimes reports huge timeouts... let's cap it */
     }
-#endif
 
-    tv.tv_sec = timeout_milliseconds / 1000; // convert milliseconds to seconds
-    tv.tv_usec = (timeout_milliseconds % 1000) * 1000; // get the remainder of milliseconds and convert to micro seconds
+    tv.tv_sec  = 0; /* never wait longer than 1 second */
+    tv.tv_usec = timeout_milliseconds * 1000;
+
+    FD_ZERO(&fdread);
+    FD_ZERO(&fdwrite);
+    FD_ZERO(&fdexcep);
+
+    /* load the fd sets from the multi handle */
+    mcode = curl_multi_fdset(rbcm->handle, &fdread, &fdwrite, &fdexcep, &maxfd);
+    if (mcode != CURLM_OK) {
+      raise_curl_multi_error_exception(mcode);
+    }
 
     rc = rb_thread_select(maxfd+1, &fdread, &fdwrite, &fdexcep, &tv);
     switch(rc) {

data/ext/curb_postfield.c

@@ -281,7 +281,7 @@ static VALUE ruby_curl_postfield_new_file(int argc, VALUE *argv, VALUE klass) {
   rbcpf->content = Qnil;
   rbcpf->content_type = Qnil;
   rbcpf->buffer_str = Qnil;
-  
+ 
   return Data_Wrap_Struct(cCurlPostField, curl_postfield_mark, curl_postfield_free, rbcpf);
 }
 
@@ -465,14 +465,14 @@ static VALUE ruby_curl_postfield_to_str(VALUE self) {
           result = escd_name;
           rb_str_cat(result, "=", 1);
           rb_str_concat(result, escd_content); 
-        }            
+        }
       }
     } else {
       rb_raise(eCurlErrInvalidPostField, "Cannot convert unnamed field to string %s:%d", __FILE__, __LINE__);
-    }      
+    }
   } else {
     rb_raise(eCurlErrInvalidPostField, "Cannot convert non-content field to string %s:%d", __FILE__, __LINE__);
-  }  
+  }
   
   return result;
 }

data/lib/curb.rb

@@ -191,7 +191,7 @@ module Curl
 
       # call-seq:
       #
-      # Curl::Multi.download(['http://example.com/p/a/t/h/file1.txt','http://example.com/p/a/t/h/file2.txt'])
+      # Curl::Multi.download(['http://example.com/p/a/t/h/file1.txt','http://example.com/p/a/t/h/file2.txt']){|c|}
       #
       # will create 2 new files file1.txt and file2.txt
       # 
@@ -232,7 +232,11 @@ module Curl
           url_to_download_paths[url] = download_path # store for later
         end
 
-        Curl::Multi.http(urls_with_config, multi_options) {|c,code,method| blk.call(c,url_to_download_paths[c.url]) }
+        if blk
+          Curl::Multi.http(urls_with_config, multi_options) {|c,code,method| blk.call(c,url_to_download_paths[c.url]) }
+        else
+          Curl::Multi.http(urls_with_config, multi_options)
+        end
 
       ensure
         errors = []

data/tests/helper.rb

@@ -73,14 +73,18 @@ class TestServlet < WEBrick::HTTPServlet::AbstractServlet
   end
 
   def do_POST(req,res)
-    if req.body
-      params = {}
-      req.body.split('&').map{|s| k,v=s.split('='); params[k] = v }
-    end
-    if params and params['s'] == '500'
-      res.status = 500
+    if !req.query['filename'].nil?
+      respond_with(req.query['filename'],req,res)
     else
-      respond_with("POST\n#{req.body}",req,res)
+      if req.body
+        params = {}
+        req.body.split('&').map{|s| k,v=s.split('='); params[k] = v }
+      end
+      if params and params['s'] == '500'
+        res.status = 500
+      else
+        respond_with("POST\n#{req.body}",req,res)
+      end
     end
   end
 

data/tests/tc_curl_easy.rb

@@ -57,8 +57,7 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     assert_equal nil, c.on_body
   end
 
-  class Foo < Curl::Easy
-  end
+  class Foo < Curl::Easy ; end
   def test_new_05
     # can use Curl::Easy as a base class
     c = Foo.new
@@ -698,6 +697,40 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     end
   end
 
+  def test_post_streaming
+    readme = File.expand_path(File.join(File.dirname(__FILE__),'..','README'))
+    
+    pf = Curl::PostField.file("filename", readme)
+
+    easy = Curl::Easy.new
+
+    easy.url = TestServlet.url
+    easy.multipart_form_post = true
+    easy.http_post(pf)
+
+    assert_not_equal(0,easy.body_str.size)
+    assert_equal(easy.body_str,File.read(readme))
+  end
+
+  def test_easy_close
+    easy = Curl::Easy.new
+    easy.close
+    easy.url = TestServlet.url
+    easy.http_get
+  end
+
+  def test_easy_reset
+    easy = Curl::Easy.new
+    easy.url = TestServlet.url + "?query=foo"
+    easy.http_get
+    settings = easy.reset
+    assert settings.key?(:url)
+    assert settings.key?(:body_data)
+    assert settings.key?(:header_data)
+    easy.url = TestServlet.url
+    easy.http_get
+  end
+
   include TestServerMethods 
 
   def setup

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 7
-  - 1
-  version: 0.7.1
+  - 3
+  version: 0.7.3
 platform: ruby
 authors: 
 - Ross Bamford
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-20 00:00:00 -04:00
+date: 2010-05-18 00:00:00 -04:00
 default_executable: 
 dependencies: []