evdispatch 0.1.0

data/ext/revdispatch/libevdispatch/src/ev_dispatch.cc

@@ -0,0 +1,264 @@
+#include "config.h"
+#include <stdio.h>
+#include "ev_dispatch.h"
+#include "ev_http.h"
+
+#define DEBUG
+
+#ifdef DEBUG
+#include <assert.h>
+#define ASSERT_IS_D_THRAD\
+  pthread_t tid = pthread_self();\
+  assert( tid == this->m_tid );
+#else
+#define ASSERT_IS_D_THRAD
+#endif
+
+// ---
+// TODO:
+// libcurl: is used to handle the http requests
+// sphinxclient: library for the search engine requests
+// memcached: client library for the memcached requests
+//
+
+namespace EVD {
+
+Dispatch::Dispatch() : m_loop(NULL), m_counter(0), m_loop_started(false), m_http_client(NULL), m_pending(0)
+{
+  // zero everything out
+  memset(&m_clock,0,sizeof(ev_timer));
+  memset(&m_request_watcher,0,sizeof(ev_async));
+  memset(&m_tid,0,sizeof(pthread_t));
+  m_pid = getpid();
+}
+
+Dispatch::~Dispatch()
+{
+  if( m_http_client ) {
+    delete m_http_client;
+  }
+}
+
+// start up the background event listener
+bool Dispatch::start()
+{
+  int rc;
+  if( m_loop_started ){ return false; }
+
+  rc = pthread_create( &m_tid, NULL, Dispatch::event_loop_start, this );
+  if( rc ){ return false; }
+   pthread_detach( m_tid );
+
+  m_http_client = new HttpClient(this);
+
+  // block until we get notified that the event thead is up and running
+  Guard lock(m_lock);
+  int count = 0;
+
+  // wait until the event loop is started
+  while( !m_loop_started && count < 100 ) { // never wait more then 100 iterations
+    m_cond.timed_wait( m_lock, Timer(1,0) );
+    //printf( "waiting another second\n" );
+    ++count;
+  }
+
+  return (count < 100);
+}
+
+// tell the background event listener to terminate
+void Dispatch::stop()
+{
+  if( !m_loop_started ){ return ; }
+
+  //printf( "EVD::Dispatch stopping...\n" );
+  m_loop_started = false;
+
+  m_cond.broadcast();
+  m_requests.signal();
+  m_responses.signal();
+  ev_unloop( m_loop, EVUNLOOP_ALL );
+  if( m_http_client ) {
+    delete m_http_client;
+    m_http_client = NULL;
+  }
+}
+
+// all event loop activity happens on this thread
+void* Dispatch::event_loop_start( void *ptr )
+{
+  Dispatch *dis = (Dispatch*)ptr;
+  dis->event_loop_main();
+  //printf( "EVD::Dispatch event loop stopped\n" );
+  return NULL;
+}
+
+static void
+sigint_cb( struct ev_loop *loop, struct ev_signal *w, int revents )
+{
+  Dispatch *ptr = ((Dispatch*)w->data);
+  ptr->stop();
+}
+
+// called when a new request was signaled from the main thread
+void Dispatch::request_cb_start( struct ev_loop *loop, struct ev_async *w, int revents )
+{
+  Dispatch *ptr = (Dispatch*)w->data;
+  ptr->request_cb( loop, w, revents );
+}
+void Dispatch::request_cb( struct ev_loop *loop, struct ev_async *w, int revents )
+{
+  ASSERT_IS_D_THRAD
+
+  // 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
+  m_requests.m_lock.unlock(); // unlock the queue
+
+  // process the new requests 
+  while( !new_requests.empty() ) {
+    Request *req = new_requests.front();
+    new_requests.pop();
+    //printf( "Request: %s, time since requested: %.2f\n", req->url.c_str(), difftime(time(NULL),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;
+    }
+  }
+
+}
+
+// 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_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_cond.signal(); // let the world know we're ready for them
+  m_lock.unlock();
+
+  ev_loop( m_loop, 0 );
+  ev_loop_destroy( m_loop );
+  pthread_exit(NULL);
+}
+void Dispatch::timeout_cb_start(struct ev_loop *loop, struct ev_timer *w, int revents)
+{
+  Dispatch *ptr = ((Dispatch*)w->data);
+  ptr->timeout_cb( loop, w, revents );
+}
+
+// called on the event loop thread
+void Dispatch::timeout_cb(struct ev_loop *loop, struct ev_timer *w, int revents)
+{
+  ASSERT_IS_D_THRAD
+  //printf("timeout cb\n");
+}
+
+// called on the main thread, not the event loop thread
+request_t Dispatch::request( Request::Type type, const std::string &url )
+{
+  request_t key = m_counter++;
+  Request *req = NULL;
+  // check the request type and 
+  switch( type ) {
+  case Request::HTTP:
+    req = new HttpRequest( m_http_client, key, url );
+    break;
+  case Request::SPHINX:
+    //req = new SphinxRequest( key, url );
+    break;
+  case Request::MEMCACHED:
+    break;
+  default:
+    // TODO: log an error
+    break;
+  }
+  m_requests.push( req );
+  ev_async_send( m_loop, &m_request_watcher );
+  return key;
+}
+
+Response *Dispatch::response_for( request_t id )
+{
+  RespondedTable::iterator loc = m_responded.find(id);
+  if( loc == m_responded.end() ){ return NULL; }
+  Response *res = loc->second;
+  m_responded.erase(loc);
+  return res;
+}
+
+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;
+  Queue<Response>::POP_STATE rstate;
+  RespondedTable::iterator loc = m_responded.find(id);
+
+  if( loc != m_responded.end() ){ return Queue<Response>::POPPED; }
+
+  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; }
+  }
+
+  return rstate;
+}
+
+Response *Dispatch::get_next_response( Timer timer )
+{
+  Response *rep = NULL;
+  Queue<Response>::POP_STATE  rstate;
+
+  do {
+    rep = m_responses.pop_or_wait( &rstate, m_loop_started, timer );
+    if( rstate == Queue<Response>::EXITING ){ rep = NULL; break; }
+    if( !rep && rstate == Queue<Response>::EXPIRED ) {
+      int pending_count = m_pending;
+      if( pending_count == 0 ) { // if pending is zero then acquire locks on the request and response queue 
+        int request_count = m_requests.size();
+        int response_count = m_responses.size();
+        //printf( "pending: %d, request: %d, response: %d\n", pending_count, request_count, response_count );
+        if( pending_count == 0 && request_count == 0 && response_count == 0 ) {
+          return NULL;
+        }
+      }
+    }
+    else if( rep ) {
+      --m_pending;
+    }
+
+  } while( !rep && rstate == Queue<Response>::EXPIRED );
+
+  return rep;
+}
+
+}// end namespace EVD

data/ext/revdispatch/libevdispatch/src/ev_dispatch.h

@@ -0,0 +1,300 @@
+#ifndef EV_DISPATCH_H
+#define EV_DISPATCH_H
+
+#include "config.h"
+#include <time.h>
+#include <sys/time.h>
+#include <ev.h>
+#include <pthread.h>
+#include <string>
+#include <list>
+#include <queue>
+#include <map>
+
+namespace EVD {
+
+  // unique id to represent a request
+  typedef unsigned long request_t;
+
+  struct Request {
+    enum Type{
+      HTTP,
+      SPHINX,
+      MEMCACHED
+    };
+    Request( request_t k, const std::string &u ) : key(k), url(u){ time( &start_time); }
+    virtual ~Request (){ }
+
+    // attach to the event loop
+    virtual bool enable() = 0;
+
+    // TODO: add a method to access the response
+
+    request_t key;
+    std::string url;
+    time_t start_time;
+  };
+
+  // TODO:
+  //struct MemcachedRequesst : public Request {
+  //};
+
+  // TODO:
+  //struct SphinxRequest : public Request {
+  //};
+
+  struct Response {
+    virtual ~Response(){}
+    std::string name;
+    std::string body;
+    request_t id;
+    double response_time; // computed as difftime(start_time,end_time);
+  };
+
+  struct Mutex {
+    Mutex() {
+      pthread_mutex_init( &m_lock, NULL );
+    }
+    ~Mutex() {
+      pthread_mutex_destroy( &m_lock );
+    }
+    void lock() {
+      pthread_mutex_lock( &m_lock );
+    }
+    void unlock() {
+      pthread_mutex_unlock( &m_lock );
+    }
+
+    pthread_mutex_t m_lock;
+  };
+
+  struct Timer {
+    Timer( long int seconds, long int nanoseconds ){
+      struct timeval now;
+      gettimeofday(&now, NULL);
+      m_time.tv_sec = now.tv_sec + seconds;
+      m_time.tv_nsec = (now.tv_usec * 1000) + nanoseconds;
+    }
+    struct timespec m_time;
+  };
+
+  struct Cond {
+    Cond() {
+      pthread_cond_init( &m_cond, NULL );
+    }
+    ~Cond() {
+      pthread_cond_destroy( &m_cond );
+    }
+
+    void wait( Mutex &m ) {
+      pthread_cond_wait( &m_cond, &(m.m_lock) );
+    }
+
+    // wait 500 ms
+    // timed_wait( m, Timer(0,500) );
+    void timed_wait( Mutex &m, const Timer &t ) {
+      pthread_cond_timedwait( &m_cond, &(m.m_lock), &(t.m_time) );
+    }
+
+    void signal() {
+      pthread_cond_signal( &m_cond );
+    }
+
+    void broadcast() {
+      pthread_cond_broadcast( &m_cond );
+    }
+
+    pthread_cond_t m_cond;
+  };
+
+  struct Guard {
+    Guard( Mutex &mutex ): m_mutex(mutex){ m_mutex.lock(); }
+    ~Guard(){ m_mutex.unlock(); }
+    Mutex &m_mutex;
+  };
+
+  // thread safe queue
+  template <typename T> 
+  struct Queue {
+    Queue() {}
+    ~Queue() {}
+
+    // the reason the pop returned, time expired, event loop is exiting, or an object was popped
+    enum POP_STATE {
+      POPPED = 0,
+      EXPIRED = 1,
+      EXITING = 2
+    };
+
+    // heap allocated T object
+    void push( T *req ) {
+      m_lock.lock();
+      m_queue.push( req );
+      m_lock.unlock();
+      m_cond.signal();
+    }
+
+    // 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 ) {
+        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;
+    }
+    size_t size(){
+      Guard lock(m_lock);
+      return m_queue.size();
+    }
+
+    T *pop() {
+      Guard lock(m_lock);
+      T *req =  NULL;
+      req = m_queue.front();
+      if( req ){
+        m_queue.pop();
+      }
+      return req;
+    }
+
+    void signal(){ m_cond.signal(); }
+
+    std::queue<T*> m_queue;
+    Mutex m_lock;
+    Cond m_cond;
+  };
+
+  // used to keep track of pending requests vs completed responses
+  struct AtomicCounter {
+    // initialization is not threadsafe
+    AtomicCounter( int init ) : m_count(init){}
+    inline operator int(){ Guard g(m_lock); return m_count; }
+    inline int operator++(){  Guard g(m_lock); return ++m_count; }
+    inline int operator--(){ Guard g(m_lock); return --m_count;  }
+
+    Mutex m_lock;
+    int m_count;
+  };
+
+  //
+  // Dispatch requests to a thread running an event loop
+  // all methods here should be used within the same thread
+  //
+  // create a Dispatcher
+  //  call start
+  //
+  //  send the dispatcher some requests
+  //
+  //  do some work
+  //
+  //  request the dispatcher results
+  //
+  //  TODO: optionally you can tell the dispatcher to store the results on the file system via a pipe 
+  //
+  struct Dispatch {
+    typedef std::map<request_t,Response*> RespondedTable;
+
+    Dispatch();
+    ~Dispatch();
+
+    // start up the background event listener
+    bool start();
+    // tell the background event listener to terminate
+    void stop();
+
+    request_t request( Request::Type type, const std::string &url );
+
+    // from the main thread, get the next available response
+    // just keep pop'ing off the response queue until we get something
+    // if you get a non NULL response from this method it's your responsiblity to delete it
+    // 
+    // Use this method if you want to get all pending requests
+    Response *get_next_response( Timer timer = Timer(1,0) );
+
+    // get a specific respone by id
+    // if you get a non NULL response from this method it's your responsiblity to delete it
+    //
+    // Use this method if you want to get a specific request
+    Response *response_for( request_t id );
+
+    // call this method to block and wait for a specific request
+    // then call response_for to retrieve the response, in the background this will collect
+    // other pending requests into an internal lookup table
+    Queue<Response>::POP_STATE wait_for_response_by_id( request_t id, Timer timeout );
+
+    // from the backend called on the event loop thread
+    inline void send_response( Response *response ) {
+      m_responses.push( response );
+    }
+
+    inline struct ev_loop *get_loop(){ return m_loop; }
+
+    inline pthread_t get_thread_id()const{ return m_tid; }
+
+  protected:
+
+    // all event loop activity happens on this thread
+    static void* event_loop_start( void *ptr );
+    void event_loop_main();
+
+    static void timeout_cb_start(struct ev_loop *loop, struct ev_timer *w, int revents);
+    void timeout_cb(struct ev_loop *loop, struct ev_timer *w, int revents);
+    
+    static void request_cb_start( struct ev_loop *loop, struct ev_async *w, int revents );
+    void request_cb( struct ev_loop *loop, struct ev_async *w, int revents );
+
+    bool store_response_for( request_t id );
+
+  protected:
+
+    struct ev_loop *m_loop;
+
+    // this triggers a callback once every N milliseconds
+    struct ev_timer m_clock;
+
+    struct ev_async m_request_watcher;
+
+    pid_t m_pid;
+    pthread_t m_tid;
+    request_t m_counter;  // used to create ids for each requests
+
+    // sync startup to main thread
+    Mutex m_lock;
+    Cond m_cond;
+    bool m_loop_started;
+
+    Queue <Request> m_requests;
+    Queue <Response> m_responses;
+
+    // stores all responded messages stored when calling wait_for_request_by_id( request_t id )
+    RespondedTable m_responded;
+
+    struct HttpClient *m_http_client;
+    AtomicCounter m_pending;
+  };
+
+}
+
+#endif