taf2-curb 0.2.8.0 → 0.3.0.0

data/README

@@ -2,7 +2,6 @@
 
 * http://curb.rubyforge.org/
 * http://rubyforge.org/projects/curb
-* http://groups.google.com/group/curb---ruby-libcurl-bindings
 * http://github.com/taf2/curb/tree/master
 
 Curb (probably CUrl-RuBy or something) provides Ruby-language bindings for the
@@ -18,7 +17,7 @@ Ruby license. See the LICENSE file for the gory details.
 
 === You will need
 
-* A working Ruby installation (1.8+, tested with 1.8.5)
+* A working Ruby installation (1.8+, tested with 1.8.5, 1.8.6, 1.8.7, and 1.9.1)
 * A working (lib)curl installation, with development stuff (7.5+, tested with 7.15)
 * A sane build environment
 

data/Rakefile

@@ -78,7 +78,11 @@ end
 # Test Tasks ---------------------------------------------------------
 task :ta => :alltests
 task :tu => :unittests
-task :test => :unittests
+task :test => [:rmpid,:unittests]
+
+task :rmpid do
+  sh "rm -rf tests/server_lock-*"
+end
 
 if ENV['RELTEST']
   announce "Release task testing - not running regression tests on alltests"

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.2.8.0"
-#define CURB_VER_NUM   280
+#define CURB_VERSION   "0.3.0.0"
+#define CURB_VER_NUM   300
 #define CURB_VER_MAJ   0
-#define CURB_VER_MIN   2
-#define CURB_VER_MIC   8
+#define CURB_VER_MIN   3
+#define CURB_VER_MIC   0
 #define CURB_VER_PATCH 0
 
 
@@ -32,6 +32,9 @@
 #ifndef RSTRING_LEN 
 #define RSTRING_LEN(x) RSTRING(x)->len 
 #endif
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(x) RSTRING(x)->ptr
+#endif
 
 #ifdef HAVE_RUBY19_HASH
   #define RHASH_LEN(hash) RHASH(hash)->ntbl->num_entries

data/ext/curb_easy.c

@@ -34,22 +34,41 @@ static size_t default_data_handler(char *stream,
   rb_str_buf_cat(out, stream, size * nmemb);
   return size * nmemb;
 }
+typedef struct _PutStream {
+  char *buffer;
+  size_t offset, len;
+} PutStream;
 
 // size_t function( void *ptr, size_t size, size_t nmemb, void *stream);
-static size_t read_data_handler(char *stream,
+static size_t read_data_handler(void *ptr,
                                 size_t size, 
                                 size_t nmemb, 
-                                char **buffer) {
-    size_t result = 0;
-
-    if (buffer != NULL && *buffer != NULL) {
-        int len = size * nmemb;
-        char *s1 = strncpy(stream, *buffer, len);
-        result = strlen(s1);
-        *buffer += result;
-    }
+                                void *stream) {
+
+  PutStream *pstream = (PutStream*)stream;
+  size_t sent_bytes = (size * nmemb);
+  size_t remaining = pstream->len - pstream->offset;
+
+  // amount remaining is less then the buffer to send  - can send it all
+  if( remaining < sent_bytes ) {
+    memcpy(ptr, pstream->buffer+pstream->offset, remaining);
+    sent_bytes = remaining;
+    pstream->offset += remaining;
+  }
+  else if( remaining > sent_bytes ) { // sent_bytes <= remaining - send what we can fit in the buffer(ptr)
+    memcpy(ptr, pstream->buffer+pstream->offset, sent_bytes);
+    pstream->offset += sent_bytes;
+  }
+  else { // they're equal
+    memcpy(ptr, pstream->buffer+pstream->offset, --sent_bytes);
+    pstream->offset += sent_bytes;
+  }
+  if (sent_bytes == 0) {
+    free(pstream);
+  }
 
-    return result;
+  //printf("sent_bytes: %ld of %ld\n", sent_bytes, remaining);
+  return sent_bytes;
 }
 
 static size_t proc_data_handler(char *stream, 
@@ -119,6 +138,10 @@ void curl_easy_mark(ruby_curl_easy *rbce) {
   rb_gc_mark(rbce->postdata_buffer);
   rb_gc_mark(rbce->bodybuf);
   rb_gc_mark(rbce->headerbuf);
+
+  if( rbce->self != Qnil ) {
+    rb_gc_mark(rbce->self);
+  }
 }
 
 void curl_easy_free(ruby_curl_easy *rbce) {
@@ -205,6 +228,8 @@ static VALUE ruby_curl_easy_new(int argc, VALUE *argv, VALUE klass) {
   rbce->bodybuf = Qnil;
   rbce->headerbuf = Qnil;
   rbce->curl_headers = NULL;
+
+  rbce->self = Qnil;
   
   new_curl = Data_Wrap_Struct(cCurlEasy, curl_easy_mark, curl_easy_free, rbce);
   
@@ -1367,7 +1392,7 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, VALUE *body_buffer, VALUE *hea
   }
   
   /* Setup HTTP headers if necessary */
-  curl_easy_setopt(curl, CURLOPT_HTTPHEADER, NULL);   // clear
+  curl_easy_setopt(curl, CURLOPT_HTTPHEADER, NULL);   // XXX: maybe we shouldn't be clearing this?
   
   if (rbce->headers != Qnil) {      
     if ((rb_type(rbce->headers) == T_ARRAY) || (rb_type(rbce->headers) == T_HASH)) {
@@ -1403,8 +1428,8 @@ VALUE ruby_curl_easy_cleanup( VALUE self, ruby_curl_easy *rbce, VALUE bodybuf, V
     if (TYPE(bodybuf) == T_STRING) {
       rbce->body_data = rb_str_to_str(bodybuf);
     }
-    else if (rb_respond_to(bodybuf, rb_intern("to_str"))) {
-      rbce->body_data = rb_funcall(bodybuf, rb_intern("to_str"), 0);
+    else if (rb_respond_to(bodybuf, rb_intern("to_s"))) {
+      rbce->body_data = rb_funcall(bodybuf, rb_intern("to_s"), 0);
     }
     else {
       rbce->body_data = Qnil;
@@ -1417,8 +1442,8 @@ VALUE ruby_curl_easy_cleanup( VALUE self, ruby_curl_easy *rbce, VALUE bodybuf, V
     if (TYPE(headerbuf) == T_STRING) {
       rbce->header_data = rb_str_to_str(headerbuf);
     }
-    else if (rb_respond_to(headerbuf, rb_intern("to_str"))) {
-      rbce->header_data = rb_funcall(headerbuf, rb_intern("to_str"), 0);
+    else if (rb_respond_to(headerbuf, rb_intern("to_s"))) {
+      rbce->header_data = rb_funcall(headerbuf, rb_intern("to_s"), 0);
     }
     else {
       rbce->header_data = Qnil;
@@ -1488,26 +1513,34 @@ static VALUE handle_perform(VALUE self, ruby_curl_easy *rbce) {
       FD_ZERO(&fdwrite);
       FD_ZERO(&fdexcep);
 
-      /* set a suitable timeout to play around with */
-      timeout.tv_sec = 1;
-      timeout.tv_usec = 0;
+      //time_t timer = time(NULL);
       /* get file descriptors from the transfers */
       mcode = curl_multi_fdset(multi_handle, &fdread, &fdwrite, &fdexcep, &maxfd);
       if (mcode != CURLM_CALL_MULTI_PERFORM && mcode != CURLM_OK) {
         raise_curl_multi_error_exception(mcode);
       }
 
+      /* set a suitable timeout to play around with - ruby seems to be greedy about this and won't necessarily yield so the timeout is small.. */
+      timeout.tv_sec = 0.0;
+      timeout.tv_usec = 100000.0;
       rc = rb_thread_select(maxfd+1, &fdread, &fdwrite, &fdexcep, &timeout);
       if (rc < 0) {
         rb_raise(rb_eRuntimeError, "select(): %s", strerror(errno));
       }
    
-      switch(rc) {
-      case 0:
-      default:
-        /* timeout or readable/writable sockets */
-        while(CURLM_CALL_MULTI_PERFORM == (mcode=curl_multi_perform(multi_handle, &still_running)) );
-      break;
+      if( rc >= 0 ) {
+        switch(rc) {
+        case 0:
+          //printf("timeout(%.6f) :", difftime(time(NULL), timer) );
+        default:
+          //printf("readable/writable: %d\n", rc);
+          /* timeout or readable/writable sockets */
+          while(CURLM_CALL_MULTI_PERFORM == (mcode=curl_multi_perform(multi_handle, &still_running)) );
+          break;
+        }
+      }
+      else {
+        // error
       }
    
       if (mcode != CURLM_CALL_MULTI_PERFORM && mcode != CURLM_OK) {
@@ -1549,7 +1582,7 @@ static VALUE handle_perform(VALUE self, ruby_curl_easy *rbce) {
     rb_funcall( rbce->success_proc, idCall, 1, self );
   }
   else if (rbce->failure_proc != Qnil && 
-           (response_code >= 300 && response_code < 600)) {
+           (response_code >= 300 && response_code <= 999)) {
     rb_funcall( rbce->failure_proc, idCall, 1, self );
   }
 
@@ -1723,21 +1756,31 @@ static VALUE ruby_curl_easy_perform_head(VALUE self) {
 static VALUE ruby_curl_easy_perform_put(VALUE self, VALUE data) {
   ruby_curl_easy *rbce;
   CURL *curl;
-  char *buffer;
-  int len;
+
+  PutStream *pstream = (PutStream*)malloc(sizeof(PutStream));
+  memset(pstream, 0, sizeof(PutStream));
 
   Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl = rbce->curl;
 
-  buffer = StringValuePtr(data);
-  len = RSTRING_LEN(data);
+  pstream->len = RSTRING_LEN(data);
+  pstream->buffer = StringValuePtr(data);
+
 
   curl_easy_setopt(curl, CURLOPT_UPLOAD, 1);
   curl_easy_setopt(curl, CURLOPT_READFUNCTION, (curl_read_callback)read_data_handler);
-  curl_easy_setopt(curl, CURLOPT_READDATA, &buffer);
-  curl_easy_setopt(curl, CURLOPT_INFILESIZE, len);
-
-  return handle_perform(self, rbce);
+  curl_easy_setopt(curl, CURLOPT_READDATA, pstream);
+  //printf("uploading %d bytes\n", pstream->len);
+  curl_easy_setopt(curl, CURLOPT_INFILESIZE, pstream->len);
+
+  VALUE ret = handle_perform(self, rbce);
+  /* cleanup  */
+  curl_easy_setopt(curl, CURLOPT_UPLOAD, 0);
+  curl_easy_setopt(curl, CURLOPT_READFUNCTION, NULL);
+  curl_easy_setopt(curl, CURLOPT_READDATA, NULL);
+  curl_easy_setopt(curl, CURLOPT_INFILESIZE, 0);
+
+  return ret;
 }
 
 /* =================== DATA FUNCS =============== */

data/ext/curb_errors.c

@@ -309,15 +309,21 @@ void raise_curl_easy_error_exception(CURLcode code) {
     case CURLE_FTP_SSL_FAILED:          /* 64 - Requested FTP SSL level failed */
       exclz = eCurlErrFTPSSLFailed;
       break;          
+#ifdef HAVE_CURLE_SEND_FAIL_REWIND 
     case CURLE_SEND_FAIL_REWIND:        /* 65 - Sending the data requires a rewind that failed */
       exclz = eCurlErrSendFailedRewind;
-      break;          
+      break;
+#endif
+#ifdef HAVE_CURLE_SSL_ENGINE_INITFAILED
     case CURLE_SSL_ENGINE_INITFAILED:   /* 66 - failed to initialise ENGINE */
       exclz = eCurlErrSSLEngineInitFailed;
       break;          
+#endif
+#ifdef HAVE_CURLE_LOGIN_DENIED
     case CURLE_LOGIN_DENIED:            /* 67 - user, password or similar was not accepted and we failed to login */
       exclz = eCurlErrLoginDenied;
       break;      
+#endif
       
       // recent additions, may not be present in all supported versions
 #ifdef HAVE_CURLE_TFTP_NOTFOUND
@@ -386,12 +392,16 @@ void raise_curl_multi_error_exception(CURLMcode code) {
     case CURLM_INTERNAL_ERROR: /* 4 */
       exclz = mCurlErrInternalError;
       break;
+#if HAVE_CURLM_BAD_SOCKET
     case CURLM_BAD_SOCKET: /* 5 */
       exclz = mCurlErrBadSocket;
       break;
+#endif
+#if HAVE_CURLM_UNKNOWN_OPTION
     case CURLM_UNKNOWN_OPTION: /* 6 */
       exclz = mCurlErrUnknownOption;
       break;
+#endif
     default:
       exclz = eCurlErrError;
       exmsg = "Unknown error result from libcurl";

data/ext/curb_multi.c

@@ -4,7 +4,13 @@
  * 
  * $Id$
  */
+
+#include "curb_config.h"
+#ifdef HAVE_RUBY19_ST_H
+#include <ruby/st.h>
+#else
 #include <st.h>
+#endif
 #include "curb_easy.h"
 #include "curb_errors.h"
 #include "curb_postfield.h"
@@ -41,12 +47,12 @@ static void curl_multi_flush_easy(VALUE key, VALUE easy, ruby_curl_multi *rbcm)
 
 static void curl_multi_free(ruby_curl_multi *rbcm) {
   //printf("hash entries: %d\n", RHASH(rbcm->requests)->tbl->num_entries );
-  if (RHASH_LEN(rbcm->requests) > 0) {
+  if (rbcm && RHASH_LEN(rbcm->requests) > 0) {
     rb_hash_foreach( rbcm->requests, (int (*)())curl_multi_flush_easy, (VALUE)rbcm );
 
     curl_multi_cleanup(rbcm->handle);
     //rb_hash_clear(rbcm->requests)
-    rbcm->requests = rb_hash_new();
+    rbcm->requests = Qnil;
   }
 }
 
@@ -73,6 +79,24 @@ static VALUE ruby_curl_multi_new(VALUE self) {
   return new_curlm;
 }
 
+/*
+ * call-seq:
+ * multi = Curl::Multi.new
+ * multi.max_connects = 800
+ *
+ * Set the max connections in the cache for a multi handle
+ */
+static VALUE ruby_curl_multi_max_connects(VALUE self, VALUE count) {
+#ifdef HAVE_CURLMOPT_MAXCONNECTS
+  ruby_curl_multi *rbcm;
+
+  Data_Get_Struct(self, ruby_curl_multi, rbcm);
+  curl_multi_setopt(rbcm->handle, CURLMOPT_MAXCONNECTS, NUM2INT(count));
+#endif
+
+  return self;
+}
+
 /*
  * call-seq:
  * multi = Curl::Multi.new
@@ -106,7 +130,7 @@ static VALUE ruby_curl_multi_add(VALUE self, VALUE easy) {
     curl_multi_perform(rbcm->handle, &(rbcm->running));
   }
 
-  rb_hash_aset( rbcm->requests, rb_int_new((long)rbce->curl), easy );
+  rb_hash_aset( rbcm->requests, easy, easy );
   // active should equal INT2FIX(RHASH(rbcm->requests)->tbl->num_entries)
 
   if (rbcm->active > rbcm->running) {
@@ -135,8 +159,10 @@ static VALUE ruby_curl_multi_remove(VALUE self, VALUE easy) {
 
   Data_Get_Struct(self, ruby_curl_multi, rbcm);
 
+  ruby_curl_easy *rbce;
+  Data_Get_Struct(easy, ruby_curl_easy, rbce);
+
   rb_curl_multi_remove(rbcm,easy);
-  // active should equal INT2FIX(RHASH(rbcm->requests)->tbl->num_entries)
 
   return self;
 }
@@ -157,7 +183,12 @@ static void rb_curl_multi_remove(ruby_curl_multi *rbcm, VALUE easy) {
   ruby_curl_easy_cleanup( easy, rbce, rbce->bodybuf, rbce->headerbuf, rbce->curl_headers );
   rbce->headerbuf = Qnil;
   rbce->bodybuf = Qnil;
-  rb_hash_delete( rbcm->requests, rb_int_new((long)rbce->curl) );
+
+  // active should equal INT2FIX(RHASH(rbcm->requests)->tbl->num_entries)
+  VALUE r = rb_hash_delete( rbcm->requests, easy );
+  if( r != easy || r == Qnil ) {
+    fprintf(stderr, "Critical:: Unable to remove easy from requests\n");
+  }
 }
 
 static void rb_curl_multi_read_info(VALUE self, CURLM *multi_handle) {
@@ -166,7 +197,6 @@ static void rb_curl_multi_read_info(VALUE self, CURLM *multi_handle) {
   CURLcode ecode;
   CURL *easy_handle;
   ruby_curl_easy *rbce = NULL;
-//  VALUE finished = rb_ary_new();
 
   /* check for finished easy handles and remove from the multi handle */
   while ((msg = curl_multi_info_read(multi_handle, &msgs_left))) {
@@ -182,8 +212,6 @@ static void rb_curl_multi_read_info(VALUE self, CURLM *multi_handle) {
       if (ecode != 0) {
         raise_curl_easy_error_exception(ecode);
       }
-      //printf( "finished: 0x%X\n", (long)rbce->self );
-      //rb_ary_push(finished, rbce->self);
       ruby_curl_multi_remove( self, rbce->self );
 
       if (rbce->complete_proc != Qnil) {
@@ -204,21 +232,15 @@ static void rb_curl_multi_read_info(VALUE self, CURLM *multi_handle) {
         rb_funcall( rbce->success_proc, idCall, 1, rbce->self );
       }
       else if (rbce->failure_proc != Qnil &&
-              (response_code >= 300 && response_code < 600)) {
+              (response_code >= 300 && response_code <= 999)) {
         rb_funcall( rbce->failure_proc, idCall, 1, rbce->self );
       }
+      rbce->self = Qnil;
     }
     else {
       //printf( "missing easy handle\n" );
     }
   }
-
-  /*
-  while (RARRAY(finished)->len > 0) {
-    //printf( "finished handle\n" );
-    ruby_curl_multi_remove( self, rb_ary_pop(finished) );
-  }
-   */
 }
 
 /* called within ruby_curl_multi_perform */
@@ -321,6 +343,7 @@ void init_curb_multi() {
   rb_define_singleton_method(cCurlMulti, "new", ruby_curl_multi_new, -1);
 
   /* Instnace methods */
+  rb_define_method(cCurlMulti, "max_connects=", ruby_curl_multi_max_connects, 1);
   rb_define_method(cCurlMulti, "add", ruby_curl_multi_add, 1);
   rb_define_method(cCurlMulti, "remove", ruby_curl_multi_remove, 1);
   rb_define_method(cCurlMulti, "perform", ruby_curl_multi_perform, 0);

data/ext/curb_postfield.c

@@ -429,9 +429,10 @@ static VALUE ruby_curl_postfield_to_str(VALUE self) {
 
   if ((rbcpf->local_file == Qnil) && (rbcpf->remote_file == Qnil)) {
     if (rbcpf->name != Qnil) {
-      char *tmpchrs;
+
+      char *tmpchrs = curl_escape(RSTRING_PTR(rbcpf->name), RSTRING_LEN(rbcpf->name));
       
-      if ((tmpchrs = curl_escape(StringValuePtr(rbcpf->name), RSTRING_LEN(rbcpf->name))) == NULL) {
+      if (!tmpchrs) {
         rb_raise(eCurlErrInvalidPostField, "Failed to url-encode name `%s'", tmpchrs);
       } else {
         VALUE tmpcontent = Qnil;
@@ -445,8 +446,17 @@ static VALUE ruby_curl_postfield_to_str(VALUE self) {
         } else {
           tmpcontent = rb_str_new2("");
         }
-        
-        if ((tmpchrs = curl_escape(StringValuePtr(tmpcontent), RSTRING_LEN(tmpcontent))) == NULL) {
+        if (TYPE(tmpcontent) != T_STRING) {
+          if (rb_respond_to(tmpcontent, rb_intern("to_s"))) {
+            tmpcontent = rb_funcall(tmpcontent, rb_intern("to_s"), 0);
+          }
+          else {
+            rb_raise(rb_eRuntimeError, "postfield(%s) is not a string and does not respond_to to_s", RSTRING_PTR(escd_name) );
+          }
+        }
+        //fprintf(stderr, "encoding content: %ld - %s\n", RSTRING_LEN(tmpcontent), RSTRING_PTR(tmpcontent) );
+        tmpchrs = curl_escape(RSTRING_PTR(tmpcontent), RSTRING_LEN(tmpcontent));
+        if (!tmpchrs) {
           rb_raise(eCurlErrInvalidPostField, "Failed to url-encode content `%s'", tmpchrs);
         } else {
           VALUE escd_content = rb_str_new2(tmpchrs);

data/ext/extconf.rb

@@ -70,6 +70,17 @@ have_constant "curle_tftp_illegal"
 have_constant "curle_tftp_unknownid"
 have_constant "curle_tftp_exists"
 have_constant "curle_tftp_nosuchuser"
+# older versions of libcurl 7.12
+have_constant "curle_send_fail_rewind"
+have_constant "curle_ssl_engine_initfailed"
+have_constant "curle_login_denied"
+
+# older than 7.16.3
+have_constant "curlmopt_maxconnects"
+
+# centos 4.5 build of libcurl
+have_constant "curlm_bad_socket"
+have_constant "curlm_unknown_option"
 
 if try_compile('int main() { return 0; }','-Wall')
   $CFLAGS << ' -Wall'
@@ -77,7 +88,7 @@ end
 
 # do some checking to detect ruby 1.8 hash.c vs ruby 1.9 hash.c
 def test_for(name, const, src)
-  checking_for "Ruby 1.9" do
+  checking_for name do
     if try_compile(src,"#{$CFLAGS} #{$LIBS}")
       define const
       true
@@ -86,7 +97,7 @@ def test_for(name, const, src)
     end
   end
 end
-test_for("Ruby 1.9", "RUBY19_HASH", %{
+test_for("Ruby 1.9 Hash", "RUBY19_HASH", %{
   #include <ruby.h>
   int main() {
     VALUE hash = rb_hash_new();
@@ -96,6 +107,22 @@ test_for("Ruby 1.9", "RUBY19_HASH", %{
     return 1;
   }
 })
+test_for("Ruby 1.9 st.h", "RUBY19_ST_H", %{
+  #include <ruby.h>
+  #include <ruby/st.h>
+  int main() {
+    return 0;
+  }
+})
+
+test_for("curl_easy_escape", "CURL_EASY_ESCAPE", %{
+  #include <curl/curl.h>
+  int main() {
+    CURL *easy = curl_easy_init();
+    curl_easy_escape(easy,"hello",5);
+    return 0;
+  }
+})
 
 create_header('curb_config.h')
 create_makefile('curb_core')

data/tests/helper.rb

@@ -17,6 +17,12 @@ $TEST_URL = "file://#{URI.escape(File.expand_path(__FILE__).tr('\\','/').tr(':',
 require 'thread'
 require 'webrick'
 
+# set this to true to avoid testing with multiple threads
+# or to test with multiple threads set it to false
+# this is important since, some code paths will change depending
+# on the presence of multiple threads
+TEST_SINGLE_THREADED=false
+
 # keep webrick quiet
 class ::WEBrick::HTTPServer
   def access_log(config, req, res)
@@ -87,28 +93,56 @@ module TestServerMethods
   def server_setup(port=9129,servlet=TestServlet)
     @__port = port
     if @server.nil? and !File.exist?(locked_file)
-      File.open(locked_file,'w') {|f| f << 'locked' }
-
-      # start up a webrick server for testing delete 
-      @server = WEBrick::HTTPServer.new :Port => port, :DocumentRoot => File.expand_path(File.dirname(__FILE__))
-
-      @server.mount(servlet.path, servlet)
-      queue = Queue.new # synchronize the thread startup to the main thread
 
-      @test_thread = Thread.new { queue << 1; @server.start }
+      File.open(locked_file,'w') {|f| f << 'locked' }
+      if TEST_SINGLE_THREADED
+        rd, wr = IO.pipe
+        @__pid = fork do
+          rd.close
+          rd = nil
+
+          # start up a webrick server for testing delete 
+          server = WEBrick::HTTPServer.new :Port => port, :DocumentRoot => File.expand_path(File.dirname(__FILE__))
+
+          server.mount(servlet.path, servlet)
+          trap("INT") { server.shutdown }
+          GC.start
+          wr.flush
+          wr.close
+          server.start
+        end
+        wr.close
+        rd.read
+        rd.close
+      else
+        # start up a webrick server for testing delete 
+        @server = WEBrick::HTTPServer.new :Port => port, :DocumentRoot => File.expand_path(File.dirname(__FILE__))
+
+        @server.mount(servlet.path, servlet)
+        queue = Queue.new # synchronize the thread startup to the main thread
+
+        @test_thread = Thread.new { queue << 1; @server.start }
+
+        # wait for the queue
+        value = queue.pop
+        if !value
+          STDERR.puts "Failed to startup test server!"
+          exit(1)
+        end
 
-      # wait for the queue
-      value = queue.pop
-      if !value
-        STDERR.puts "Failed to startup test server!"
-        exit(1)
       end
 
       exit_code = lambda do
         begin
-          #puts "stopping"
-          File.unlink locked_file if File.exist?(locked_file)
-          @server.shutdown unless @server.nil?
+          if File.exist?(locked_file)
+            File.unlink locked_file
+            if TEST_SINGLE_THREADED
+              Process.kill 'INT', @__pid
+            else
+              @server.shutdown unless @server.nil?
+            end
+          end
+          #@server.shutdown unless @server.nil?
         rescue Object => e
           puts "Error #{__FILE__}:#{__LINE__}\n#{e.message}"
         end

data/tests/tc_curl_multi.rb

@@ -180,7 +180,7 @@ class TestCurbCurlMulti < Test::Unit::TestCase
     def t_method
       @buf = ""
       @m = Curl::Multi.new
-      10.times do
+      10.times do|i|
         c = Curl::Easy.new($TEST_URL)
         c.on_success{|b| @buf << b.body_str }
         ObjectSpace.garbage_collect

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: taf2-curb
 version: !ruby/object:Gem::Version 
-  version: 0.2.8.0
+  version: 0.3.0.0
 platform: ruby
 authors: 
 - Ross Bamford
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-13 00:00:00 -07:00
+date: 2009-06-08 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -41,7 +41,6 @@ files:
 - ext/curb_macros.h
 - ext/curb.h
 - ext/curb_postfield.h
-- ext/curb_config.h
 - ext/curb_multi.h
 has_rdoc: true
 homepage: http://curb.rubyforge.org/