evdispatch 0.2.2 → 0.2.4

data/History.txt

@@ -1,3 +1,11 @@
+== 0.2.4 2008-04-16
+  * Fix a crash caused by CURLM_CALL_MULTI_PERFORM being misinterrupted as an error
+
+== 0.2.3 2008-04-14
+  * Add support to make POST requests
+  * Fix a deadlock bug caused by not breaking out of the pop loop
+  * Improve timeout handling
+
 == 0.2.2 2008-04-14
   * Make options optional in request method
   * Improve timeouts

data/Manifest.txt

@@ -40,7 +40,6 @@ ext/revdispatch/libdispatch-0.1/LICENSE
 ext/revdispatch/libdispatch-0.1/Makefile.am
 ext/revdispatch/libdispatch-0.1/Makefile.in
 ext/revdispatch/libdispatch-0.1/README
-ext/revdispatch/libdispatch-0.1/TODO
 ext/revdispatch/libdispatch-0.1/aclocal.m4
 ext/revdispatch/libdispatch-0.1/autogen.sh
 ext/revdispatch/libdispatch-0.1/config.guess
@@ -96,3 +95,5 @@ ext/revdispatch/libdispatch-0.1/test/key_test.cc
 ext/revdispatch/libdispatch-0.1/test/next_test.cc
 ext/revdispatch/libdispatch-0.1/test/pipe_test.cc
 ext/revdispatch/libdispatch-0.1/test/opt_test.cc
+ext/revdispatch/libdispatch-0.1/test/post_test.cc
+ext/revdispatch/libdispatch-0.1/test/stress_test.cc

data/ext/revdispatch/libdispatch-0.1/Makefile.in

@@ -37,7 +37,7 @@ build_triplet = @build@
 host_triplet = @host@
 DIST_COMMON = README $(am__configure_deps) $(srcdir)/Makefile.am \
 	$(srcdir)/Makefile.in $(srcdir)/config.h.in \
-	$(top_srcdir)/configure TODO config.guess config.sub depcomp \
+	$(top_srcdir)/configure config.guess config.sub depcomp \
 	install-sh ltmain.sh missing
 subdir = .
 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4

data/ext/revdispatch/libdispatch-0.1/src/ev_dispatch.cc

@@ -9,7 +9,7 @@
 #include <assert.h>
 #define ASSERT_IS_D_THRAD\
   pthread_t tid = pthread_self();\
-  assert( tid == this->m_tid );
+  assert( pthread_equal( tid, this->m_tid ) );
 #else
 #define ASSERT_IS_D_THRAD
 #endif
@@ -23,6 +23,18 @@
 
 namespace EVD {
 
+int Timer::current_time( struct timeval *tv)
+{
+#if HAVE_CLOCK_GETTIME
+  struct timespec ts;
+  clock_gettime (CLOCK_REALTIME, &ts);
+  tv->tv_sec = ts.tv_sec;
+  tv->tv_usec = (long)(ts.tv_nsec * 0.0001);
+#else
+  gettimeofday (tv, 0);
+#endif
+}
+
 double Timer::elapsed_time( struct timeval *y )
 {
   struct timeval duration;
@@ -57,6 +69,36 @@ double Timer::elapsed_time( struct timeval *y )
   }
   return elasped;
 }
+template <typename T> 
+T *Queue<T>::pop_or_wait( POP_STATE *rstate, volatile bool &cond, Timer timer )
+{
+  Guard lock(m_lock);
+  T *req =  NULL;
+  size_t size = m_queue.size();
+  if( size > 0 ){
+    req = m_queue.front();
+  }
+  while( !req ) {
+    timer.update();
+    m_cond.timed_wait( m_lock, timer );
+    if( !cond ){ *rstate = EXITING; break; }
+    size = m_queue.size();
+    if( size > 0 ){
+      req = m_queue.front();
+      break;
+    }
+    else {
+      *rstate = EXPIRED;
+      req = NULL;
+      break;
+    }
+  }
+  if( req ){
+    *rstate = POPPED;
+    m_queue.pop(); 
+  }
+  return req;
+}
 
 Dispatch::Dispatch() : m_loop(NULL), m_counter(0), m_loop_started(false), m_http_client(NULL), m_pending(0)
 {
@@ -82,7 +124,7 @@ bool Dispatch::start()
 
   rc = pthread_create( &m_tid, NULL, Dispatch::event_loop_start, this );
   if( rc ){ return false; }
-   pthread_detach( m_tid );
+   //pthread_detach( m_tid );
 
   m_http_client = new HttpClient(this);
 
@@ -117,13 +159,30 @@ void Dispatch::stop()
 {
   if( !m_loop_started ){ return ; }
 
-  //printf( "EVD::Dispatch stopping...\n" );
+  printf( "EVD::Dispatch stopping...\n" );
+  m_lock.lock();
   m_loop_started = false;
-
   m_cond.broadcast();
   m_requests.signal();
   m_responses.signal();
-  ev_unloop( m_loop, EVUNLOOP_ALL );
+  m_lock.unlock();
+
+  // send the message to unloop all
+  { 
+    Guard g(m_lock);
+    do {
+      // unloop again
+      printf( "main loop is waiting on the event loop to go down\n" );
+      ev_unloop( m_loop, EVUNLOOP_ALL );
+      if( m_loop_down ) { break; }
+      ev_unref( m_loop ); // decrement the ref count
+      // sleep until the event loop tells us it's done
+      m_cond.timed_wait(m_lock,Timer(1,0)); // wait until we're done
+    }while( !m_loop_down );
+  }
+
+  printf( "okay, we're joining the thread\n" );
+  pthread_join( m_tid, NULL );
   if( m_http_client ) {
     delete m_http_client;
     m_http_client = NULL;
@@ -156,29 +215,33 @@ void Dispatch::request_cb( struct ev_loop *loop, struct ev_async *w, int revents
 {
   ASSERT_IS_D_THRAD
 
+  // lock and read as much as we can out of the queue
+  m_requests.m_lock.lock();
   // create a new queue to store incoming requests
   std::queue<Request*> new_requests;
-  // lock down the request queue
-  m_requests.m_lock.lock();
-  // lock and read as much as we can out of the queue
-  new_requests = m_requests.m_queue;
-  m_requests.m_queue = std::queue<Request*>(); // empty out the request queue
+  while( !m_requests.m_queue.empty() ){
+    new_requests.push( m_requests.m_queue.front() );
+    m_requests.m_queue.pop(); // empty out the request queue
+  }
   m_requests.m_lock.unlock(); // unlock the queue
 
   // process the new requests 
   while( !new_requests.empty() ) {
-    Request *req = new_requests.front();
+    HttpRequest *req = (HttpRequest*)new_requests.front();
     new_requests.pop();
-    //printf( "Request: %s, time since requested: %.2f\n", req->url.c_str(), difftime(time(NULL),req->start_time) );
+//    printf( "Request: %s, time since requested: %.5lf\n", req->url.c_str(), Timer::elapsed_time( &(req->start_time) ) );
  
-    // inc before we enable the request, since the time to enable and push to responses queue may
-    // be long enough for a context switch to allow someone to check request, response and pending count all be zero.
-    ++m_pending;
-    if( !req->enable() ) { // XXX: if using DNS in requests expect this method to block while dns resolves
-      --m_pending;
-      printf("EVD::Dispatch request error\n");
-      // for some reason we couldn't enable the request cleanup the request and continue
-      delete req;
+    // NOTE: there is a potential for a race condition, where the request is cleaned up but not yet been popped
+    if( req && req->m_client ) {
+      // inc before we enable the request, since the time to enable and push to responses queue may
+      // be long enough for a context switch to allow someone to check request, response and pending count all be zero.
+      ++m_pending;
+      if( !req->enable() ) { // XXX: if using DNS in requests expect this method to block while dns resolves
+        --m_pending;
+        printf("EVD::Dispatch request error\n");
+        // for some reason we couldn't enable the request cleanup the request and continue
+        delete req;
+      }
     }
   }
 
@@ -187,34 +250,32 @@ void Dispatch::request_cb( struct ev_loop *loop, struct ev_async *w, int revents
 // the main event loop
 void Dispatch::event_loop_main()
 {
-//  struct ev_signal signal_exit_watcher;
-  m_loop = ev_loop_new(0); //ev_default_loop(0);
-
-//  m_clock.data = this;
-
-  // every 100s of a second we'll check the queue for requests
-//  ev_timer_init( &m_clock, timeout_cb_start, 0.5, 0.5 );
-//  ev_timer_again( m_loop, &m_clock ); // start timer
-
-  // trap sigint to ensure we clean up the event loop before exit
-//  signal_exit_watcher.data = this;
-//  ev_signal_init( &signal_exit_watcher, sigint_cb, SIGINT );
-//  ev_signal_start( m_loop, &signal_exit_watcher );
+  m_loop = ev_loop_new(0);
 
   m_request_watcher.data = this;
   ev_async_init( &m_request_watcher, request_cb_start );
   ev_async_start( m_loop, &m_request_watcher );
 
-  // start the main event loop
-
   m_lock.lock();
   m_loop_started = true;
+  m_loop_down = false;
   m_cond.signal(); // let the world know we're ready for them
   m_lock.unlock();
 
+  // start the main event loop
   ev_loop( m_loop, 0 );
+  ev_async_stop( m_loop, &m_request_watcher );
+  m_http_client->stop();
   ev_loop_destroy( m_loop );
-  pthread_exit(NULL);
+
+  m_lock.lock();
+  printf( "let the world know the event loop is going down\n" );
+  m_loop_down = true;
+  m_cond.signal(); // let the world know we're done
+  m_lock.unlock();
+
+  m_loop = NULL;
+
 }
 void Dispatch::timeout_cb_start(struct ev_loop *loop, struct ev_timer *w, int revents)
 {
@@ -235,6 +296,7 @@ request_t Dispatch::request( Request *req )
   request_t key = m_counter++;
   req->set_key( key );
   m_requests.push( req ); // load the request into the request queue
+  req = NULL; // at this point req is no longer valid on this thread
   ev_async_send( m_loop, &m_request_watcher ); // signal to the event loop we have new requests pending
   return key; // return to the client a unique identifier for matching up the response to this request
 }
@@ -251,21 +313,52 @@ Response *Dispatch::response_for( request_t id )
 Queue<Response>::POP_STATE Dispatch::wait_for_response_by_id( request_t id, Timer timeout )
 {
   // first check if the response is loaded 
-  Response *rep = NULL;
+  Response *res = NULL;
   Queue<Response>::POP_STATE rstate;
   RespondedTable::iterator loc = m_responded.find(id);
+  int res_buff_size = m_responded.size();
 
   if( loc != m_responded.end() ){ return Queue<Response>::POPPED; }
 
+  m_responses.m_lock.lock();
+
+  // see if we can get the response back
+  std::queue<Response*>::size_type size = m_responses.m_queue.size();
+  if( size > 0 ) {
+    res = m_responses.m_queue.front();
+    m_responses.m_queue.pop();
+    m_responded[res->id] = res;
+  }
+  else {
+    // update the timeout to right now
+    timeout.update();
+    m_responses.m_cond.timed_wait( m_responses.m_lock, timeout );
+    if( size > 0 ) {
+      res = m_responses.m_queue.front();
+      m_responses.m_queue.pop();
+      m_responded[res->id] = res;
+      rstate = Queue<Response>::POPPED;
+    }
+    else {
+      rstate = Queue<Response>::EXPIRED;
+      res = NULL;
+    }
+  }
+  m_responses.m_lock.unlock();
+
+  return rstate;
+  /*
   timeout.update();
-  while( (rep = m_responses.pop_or_wait( &rstate, m_loop_started, timeout )) ) {
-    //printf( "rep: %s, id: %d\n", rep->name.c_str(), rep->id );
-    m_responded[rep->id] = rep;
-    if( rep->id == id ){ return rstate; }
+  while( (res = m_responses.pop_or_wait( &rstate, m_loop_started, timeout )) ) {
+    //printf( "res: %s, id: %d\n", res->name.c_str(), res->id );
+    m_responded[res->id] = res;
+    if( res->id == id ){ return rstate; }
     timeout.update();
   }
 
+
   return rstate;
+*/
 }
 
 Response *Dispatch::get_next_response( Timer timer )

data/ext/revdispatch/libdispatch-0.1/src/ev_dispatch.h

@@ -29,7 +29,7 @@ namespace EVD {
       //printf( "seconds: %ld, nanoseconds: %ld, from s: %ld, ns: %ld, based s: %ld, us: %ld\n", m_time.tv_sec, m_time.tv_nsec, m_seconds, m_nanoseconds, now.tv_sec, now.tv_usec );
     }
 
-    inline static int current_time( struct timeval *now) { return gettimeofday(now, NULL); }
+    static int current_time( struct timeval *now );
     static double elapsed_time( struct timeval *then );
     int long m_seconds;
     int long m_nanoseconds;
@@ -37,11 +37,6 @@ namespace EVD {
   };
 
   struct Request {
-    enum Type{
-      HTTP,
-      SPHINX,
-      MEMCACHED
-    };
     Request( request_t k, const std::string &u ) : key(k), url(u){ Timer::current_time( &start_time); }
     virtual ~Request (){ }
 
@@ -145,34 +140,8 @@ namespace EVD {
     // returns a value from the queue
     // rstate: the status of the return, see POP_STATE above.
     // cond: an external reason to abort and not pop e.g. exiting event loop
-    T *pop_or_wait( POP_STATE *rstate, volatile bool &cond = true, Timer timer = Timer(1,0) ) {
- 
-      Guard lock(m_lock);
-      T *req =  NULL;
-      size_t size = m_queue.size();
-      if( size > 0 ){
-        req = m_queue.front();
-      }
-      while( !req ) {
-        timer.update();
-        m_cond.timed_wait( m_lock, timer );
-        if( !cond ){ *rstate = EXITING; break; }
-        size = m_queue.size();
-        if( size > 0 ){
-          req = m_queue.front();
-        }
-        else {
-          *rstate = EXPIRED;
-          req = NULL;
-          break;
-        }
-      }
-      if( req ){
-        *rstate = POPPED;
-        m_queue.pop(); 
-      }
-      return req;
-    }
+    T *pop_or_wait( POP_STATE *rstate, volatile bool &cond = true, Timer timer = Timer(1,0) );
+
     size_t size(){
       Guard lock(m_lock);
       return m_queue.size();
@@ -297,7 +266,7 @@ namespace EVD {
     // sync startup to main thread
     Mutex m_lock;
     Cond m_cond;
-    bool m_loop_started;
+    bool m_loop_started, m_loop_down;
 
     Queue <Request> m_requests;
     Queue <Response> m_responses;

data/ext/revdispatch/libdispatch-0.1/src/ev_http.cc

@@ -10,12 +10,42 @@ namespace EVD {
 #define ASSERT_IS_D_THRAD(id)\
   {\
   pthread_t tid = pthread_self();\
-  assert( tid == id );\
+  assert( pthread_equal(tid, id) );\
   }
 #else
 #define ASSERT_IS_D_THRAD
 #endif
 
+static void multi_error_report(CURLMcode rc)
+{
+  switch(rc) {
+  case CURLM_CALL_MULTI_PERFORM:
+    printf("curlm:perform\n");
+    break;
+  case CURLM_OK:
+//    printf("curlm:ok\n");
+    break;
+  case CURLM_BAD_HANDLE:
+    printf("curlm:bad handle\n");
+    break;
+  case CURLM_BAD_EASY_HANDLE:
+    printf("curlm:bad easy handle\n");
+    break;
+  case CURLM_OUT_OF_MEMORY:
+    printf("curlm:oh shit out of memory\n");
+    break;
+  case CURLM_INTERNAL_ERROR:
+    printf("curlm:oh shit internal error\n");
+    break;
+  case CURLM_BAD_SOCKET:
+    printf("curlm:bad socket\n");
+    break;
+  case CURLM_UNKNOWN_OPTION:
+    printf("curlm:unknown option\n");
+    break;
+  }
+}
+
 void HttpClient::SocketInfo::response_cb(struct ev_loop *loop, struct ev_io *w, int revents)
 {
   CURLMcode rc;
@@ -42,11 +72,14 @@ HttpClient::SocketInfo::SocketInfo( HttpClient *client, curl_socket_t sock, CURL
 }
 void HttpClient::SocketInfo::set_sock( curl_socket_t sock, CURL *e, int action )
 {
-  int kind = (action&CURL_POLL_IN?EV_READ:0)|(action&CURL_POLL_OUT?EV_WRITE:0);
+  int kind = (action&CURL_POLL_IN?EV_READ:0)|(action&CURL_POLL_OUT?EV_WRITE:0)|(action&CURL_POLL_INOUT?EV_READ|EV_WRITE:0);
+  ev_io_stop( m_client->m_disp->get_loop(), m_watcher );
   ev_io_set( m_watcher, sock, kind );
+  ev_io_start( m_client->m_disp->get_loop(), m_watcher );
 }
 void HttpClient::SocketInfo::finish()
 {
+//  printf("  sock finish: 0x%X\n", this );
   ev_io_stop( m_client->m_disp->get_loop(), m_watcher );
 }
 HttpClient::SocketInfo::~SocketInfo()
@@ -60,22 +93,31 @@ int HttpClient::sock_cb(CURL *e, curl_socket_t sock, int action, void *cbp, void
   HttpClient *client = (HttpClient*)cbp;
   HttpClient::SocketInfo *sockinfo = (HttpClient::SocketInfo *)sockp;
   ASSERT_IS_D_THRAD(client->m_disp->get_thread_id());
+
   if( !sockinfo ) {
     sockinfo = new HttpClient::SocketInfo( client, sock, e, action );
     curl_multi_assign(client->m_handle, sock, sockinfo);
+//    printf( " new sock: 0x%X\n", sockinfo );
   }
 
   switch( action ){
   case CURL_POLL_REMOVE: // (4) unregister
     // make sure we clear it out
+//    printf( " del sock: 0x%X\n", sockinfo );
     curl_multi_assign(client->m_handle, sock, NULL);
     sockinfo->finish();
     delete sockinfo;
+    client->check_handles();
     break;
   case CURL_POLL_NONE: // (0) register, not interested in readiness (yet)
+//    printf("none\n");
+    break;
   case CURL_POLL_IN: // (1) register, interested in read readiness 
+//    printf("in\n");
   case CURL_POLL_OUT: // (2) register, interested in write readiness
+//    printf("out\n");
   case CURL_POLL_INOUT: // (3) register, interested in both read and write readiness
+//    printf("inout\n");
   default:
     sockinfo->set_sock( sock, e, action );
     client->check_handles();
@@ -89,6 +131,7 @@ void HttpClient::timeout_cb(struct ev_loop *loop, struct ev_timer *w, int revent
 {
   CURLMcode rc;
   HttpClient *client = (HttpClient*)w->data;
+//  printf( "timeout\n" );
   do {
     rc = curl_multi_socket(client->m_handle, CURL_SOCKET_TIMEOUT, &(client->m_active));
   } while( rc == CURLM_CALL_MULTI_PERFORM );
@@ -103,13 +146,22 @@ int HttpClient::update_timeout_cb(CURLM *multi, long timeout_ms, void *userp)
   HttpClient *client = (HttpClient*)userp;
 
   // update the timer
-  ev_tstamp timeout = ev_now(client->m_disp->get_loop()) + (timeout_ms * 0.001);
+  ev_tstamp timeout = /*ev_now(client->m_disp->get_loop()) + */(timeout_ms * 0.001);
+  if( timeout_ms == 0 ) {
+    timeout = 0.1; // enforce always timeout
+  }
+  if( timeout < 0.05 ) {
+    timeout = 0.05; // never let it go below this
+  }
+//  printf( "timeout set %lf\n", timeout );
   if( client->m_timer_set ) {
-    ev_timer_set( &(client->m_timer), timeout, 0.0 );
-    ev_timer_again( client->m_disp->get_loop(), &(client->m_timer) );
+//    printf( "timeout again\n" );
+    ev_timer_stop( client->m_disp->get_loop(), &(client->m_timer) );
+    ev_timer_init( &(client->m_timer), timeout_cb, timeout, timeout );
+    ev_timer_start( client->m_disp->get_loop(), &(client->m_timer) );
   }
   else {
-    ev_timer_init( &(client->m_timer), timeout_cb, timeout, 0.0 );
+    ev_timer_init( &(client->m_timer), timeout_cb, timeout, timeout );
     client->m_timer.data = client;
     ev_timer_start( client->m_disp->get_loop(), &(client->m_timer) );
   }
@@ -128,13 +180,17 @@ HttpClient::HttpClient( Dispatch *disp )
   curl_multi_setopt( m_handle, CURLMOPT_TIMERFUNCTION, update_timeout_cb );
   curl_multi_setopt( m_handle, CURLMOPT_TIMERDATA, this );
 }
+void HttpClient::stop()
+{
+  ev_timer_stop(m_disp->get_loop(), &m_timer);
+}
 HttpClient::~HttpClient()
 {
-  //printf("cleaning up client\n");
-  this->check_handles();
   curl_multi_cleanup( m_handle );
+  m_handle = NULL;
 }
 
+
 void HttpClient::check_handles()
 {
   //see: http://curl.haxx.se/lxr/source/docs/examples/ghiper.c
@@ -146,7 +202,9 @@ void HttpClient::check_handles()
 
   do {
     easy = NULL;
+    //printf( "check handle messages\n" );
     while( (msg = curl_multi_info_read( m_handle, &msgs_left )) ) {
+//      printf( "  handle info: %d, left: %d\n", msg->msg, msgs_left );
       if( msg->msg == CURLMSG_DONE ) {
         easy = msg->easy_handle;
         rc = msg->data.result;
@@ -157,6 +215,7 @@ void HttpClient::check_handles()
     // handles above, to avoid this we break out and loop again
     if( easy ) {
       curl_easy_getinfo( easy, CURLINFO_PRIVATE, &req );
+      //printf( "   req %s finished\n", req->url.c_str() );
       req->finish(rc);
       delete req;
     }
@@ -216,6 +275,7 @@ HttpRequest::HttpRequest( Dispatch &dispatch, const std::string &url, int fd )
     m_handle(curl_easy_init()),
     m_client(dispatch.getHttpClient())
 {
+  assert(m_client);
   init_curl();
 }
 
@@ -241,13 +301,18 @@ HttpRequest::~HttpRequest()
 bool HttpRequest::enable()
 {
   CURLMcode rc = curl_multi_add_handle( m_client->m_handle, m_handle );
-  do {
-    rc = curl_multi_socket_all( m_client->m_handle, &m_client->m_active );
-  } while( rc == CURLM_CALL_MULTI_PERFORM );
-
-  m_client->check_handles();
+  
+  if( m_client ) {
+    do {
+      rc = curl_multi_socket_all( m_client->m_handle, &m_client->m_active );
+    } while( rc == CURLM_CALL_MULTI_PERFORM && m_client );
+  }
 
-  return (rc == CURLM_OK);
+  if( m_client ) { 
+    m_client->check_handles();
+  }
+  multi_error_report(rc);
+  return (rc == CURLM_OK || rc == CURLM_CALL_MULTI_PERFORM);
 }
 
 void HttpRequest::finish(CURLcode rc)
@@ -285,18 +350,29 @@ void HttpRequest::set_opt( const std::string &key, const std::string &value )
   key_loopup["referer"] = CURLOPT_REFERER;
   key_loopup["useragent"] = CURLOPT_USERAGENT;
   key_loopup["cookie"] = CURLOPT_COOKIE;
+  key_loopup["post"] = CURLOPT_POSTFIELDS;
 
   std::map<std::string,CURLoption>::iterator loc = key_loopup.find(key);
   if( loc != key_loopup.end() ){
     CURLoption val_type = loc->second;
     if( val_type >= CURLOPTTYPE_LONG && val_type < CURLOPTTYPE_OBJECTPOINT ) {
       long val = atoi(value.c_str());
-      printf( "set opt %s : %ld\n", key.c_str(), val );
       curl_easy_setopt( m_handle, val_type, val );
     }
     else if( val_type >= CURLOPTTYPE_OBJECTPOINT && val_type < CURLOPTTYPE_FUNCTIONPOINT ) {
-      printf( "set opt %s : %s\n", key.c_str(), value.c_str() );
-      curl_easy_setopt( m_handle, val_type, value.c_str() );
+      if( key == "post" ) {
+        printf( "set %s as str, with value: %s\n", key.c_str(), value.c_str() );
+        // enable HTTP POST
+        curl_easy_setopt( m_handle, CURLOPT_POST, 1 );
+        // set the buffer size to copy
+        curl_easy_setopt( m_handle, CURLOPT_POSTFIELDSIZE, value.length() );
+        // copy the buffer
+        curl_easy_setopt( m_handle, CURLOPT_COPYPOSTFIELDS, value.c_str() );
+//        printf("setup easy handle to perform a post\n");
+      }
+      else {
+        curl_easy_setopt( m_handle, val_type, value.c_str() );
+      }
     }
   }
 }
@@ -311,19 +387,23 @@ HttpResponse::HttpResponse(  const std::string &url, int fd )
 }
 void HttpResponse::write( void *ptr, size_t realsize, size_t size, size_t nmemb )
 {
+//  printf( "  write: %s, %d\n", this->name.c_str(), realsize );
   if( m_fd == -1 ) {
     body.append((const char*)ptr,realsize);
   }
   else {
     ::write( m_fd, ptr, realsize );
   }
+  //fwrite( ptr, size, nmemb, stdout );
 }
 void HttpResponse::write_header( void *ptr, size_t realsize, size_t size, size_t nmemb )
 {
   m_header.append((const char*)ptr,realsize);
+  //fwrite( ptr, size, nmemb, stdout );
 }
 void HttpResponse::finish( HttpClient *client, CURLcode rc )
 {
+//  printf( "   finish: %s\n", this->name.c_str() );
   if( m_fd == -1 ) {
     client->m_disp->send_response( this );
   }

data/ext/revdispatch/libdispatch-0.1/src/ev_http.h

@@ -34,6 +34,8 @@ namespace EVD {
     static int update_timeout_cb(CURLM *multi, long timeout_ms, void *userp);
     static void timeout_cb(struct ev_loop *loop, struct ev_timer *w, int revents);
 
+    void stop();
+
     int m_active; // number of active requests
     CURLM *m_handle;
     Dispatch *m_disp;

data/ext/revdispatch/libdispatch-0.1/test/Makefile.am

@@ -1,4 +1,4 @@
-bin_PROGRAMS = next_test key_test pipe_test opt_test
+bin_PROGRAMS = next_test key_test pipe_test opt_test post_test stress_test
 next_test_SOURCES = next_test.cc
 next_test_CPPFLAGS = -I$(top_srcdir)/src/ -I$(LIBEV_PATH)
 next_test_LDADD = -ldispatch -lev
@@ -18,3 +18,13 @@ opt_test_SOURCES = opt_test.cc
 opt_test_CPPFLAGS = -I$(top_srcdir)/src/ -I$(LIBEV_PATH)
 opt_test_LDADD = -ldispatch -lev
 opt_test_LDFLAGS = -L$(top_srcdir)/src/.libs/ `curl-config --libs` -L$(LIBEV_PATH)/.libs/
+
+post_test_SOURCES = post_test.cc
+post_test_CPPFLAGS = -I$(top_srcdir)/src/ -I$(LIBEV_PATH)
+post_test_LDADD = -ldispatch -lev
+post_test_LDFLAGS = -L$(top_srcdir)/src/.libs/ `curl-config --libs` -L$(LIBEV_PATH)/.libs/
+
+stress_test_SOURCES = stress_test.cc
+stress_test_CPPFLAGS = -I$(top_srcdir)/src/ -I$(LIBEV_PATH)
+stress_test_LDADD = -ldispatch -lev
+stress_test_LDFLAGS = -L$(top_srcdir)/src/.libs/ `curl-config --libs` -L$(LIBEV_PATH)/.libs/