webroar 0.2.2 → 0.2.3

data/src/worker/wkr_http_response.c

@@ -1,5 +1,5 @@
 /* WebROaR - Ruby Application Server - http://webroar.in/
- * Copyright (C) 2009  WebROaR
+ * Copyright (C) 2009  Goonj LLC
  *
  * This file is part of WebROaR.
  *
@@ -20,26 +20,21 @@
 #include <stdlib.h>
 #include <wr_logger.h>
 
-#define RESP_CODE               "RESP_CODE"
-#define RESP_CONTENT_LENGTH   "RESP_CONTENT_LEN"
-
 http_resp_t* http_resp_new() {
   LOG_FUNCTION
   http_resp_t *rsp = wr_malloc(http_resp_t);
 
-  if(rsp == NULL) {
+  if (rsp == NULL) {
     return NULL;
   }
 
-  //rsp->resp_body_len = rsp->resp_body_ptr = rsp->header_len = 0;
-
-  wr_string_buf_null(rsp->resp_body);
+  wr_buffer_new(rsp->resp_body);
   wr_string_null(rsp->header);
 
   rsp->bytes_write = 0;
   rsp->resp_code = 0;
-  //rsp->resp_body = rsp->header = NULL;
-  rsp->scgi_req = NULL;
+  rsp->scgi = NULL;
+  rsp->file = NULL;
 
   return rsp;
 }
@@ -47,13 +42,19 @@ http_resp_t* http_resp_new() {
 void http_resp_free(http_resp_t **r) {
   LOG_FUNCTION
   http_resp_t *rsp = *r;
-  if(rsp) {
-    //if(rsp->resp_body)    free(rsp->resp_body);
-    //if(rsp->header)  free(rsp->header);
-    wr_string_buf_free(rsp->resp_body);
+  if (rsp) {
+    wr_buffer_free(rsp->resp_body);
     wr_string_free(rsp->header);
-    if(rsp->scgi_req)
-      scgi_request_free(rsp->scgi_req);
+    if (rsp->scgi)
+      scgi_free(rsp->scgi);
+    if (rsp->file) {
+#ifdef _POSIX_C_SOURCE
+      close(rsp->file);
+#else
+      fclose(rsp->file);
+      rsp->file = NULL;
+#endif      
+    }
     free(rsp);
   }
   *r = NULL;
@@ -61,145 +62,224 @@ void http_resp_free(http_resp_t **r) {
 
 void http_resp_set(http_resp_t *rsp) {
   LOG_FUNCTION
-  //rsp->resp_body_len = rsp->resp_body_ptr = rsp->header_len = 0;
-  rsp->bytes_write =  0;
+  rsp->bytes_write = 0;
   rsp->resp_code = 0;
-  //if(rsp->resp_body)    free(rsp->resp_body);
-  //if(rsp->header)  free(rsp->header);
-  wr_string_buf_free(rsp->resp_body);
+  wr_buffer_null(rsp->resp_body);
   wr_string_free(rsp->header);
-  if(rsp->scgi_req)
-    scgi_request_free(rsp->scgi_req);
-  //  rsp->resp_body = rsp->header = NULL;
-  rsp->scgi_req = NULL;
+  if (rsp->scgi)
+    scgi_free(rsp->scgi);
+  if (rsp->file) {
+#ifdef _POSIX_C_SOURCE
+      close(rsp->file);
+#else
+      fclose(rsp->file);
+      rsp->file = NULL;
+#endif
+  }
+  rsp->scgi = NULL;
 }
 
 int http_resp_body_add(http_resp_t *rsp, const char* str, size_t len) {
   LOG_FUNCTION
-  wr_string_buf_add(rsp->resp_body, str, len);
+  wr_buffer_add(rsp->resp_body, str, len);
   return 0;
-  //  if(rsp->resp_body_ptr + len <= rsp->resp_body_len){
-  //    memcpy(rsp->resp_body + rsp->resp_body_ptr, str, len);
-  //    rsp->resp_body_ptr += len;
-  //    return 0;
-  //  }
-  //  return -1;
 }
 
 int http_resp_process(http_resp_t *rsp) {
   LOG_FUNCTION
-  rsp->scgi_req = scgi_request_new();
+  rsp->scgi = scgi_new();
 
-  if(rsp->scgi_req == NULL) {
+  if (rsp->scgi == NULL) {
     return -1;
   }
 
   char str[16];
+  size_t len;
 
-  sprintf(str, "%d", rsp->resp_code);
-  scgi_request_add_header(rsp->scgi_req, RESP_CODE ,str);
+  len = sprintf(str, "%d", rsp->resp_code);
+  scgi_header_add(rsp->scgi, RESP_CODE, strlen(RESP_CODE), str, len);
 
-  sprintf(str, "%d", rsp->resp_body.len);
-  scgi_request_add_header(rsp->scgi_req, RESP_CONTENT_LENGTH ,str);
+  len = sprintf(str, "%d", rsp->resp_body->len);
+  scgi_header_add(rsp->scgi, RESP_CONTENT_LENGTH, strlen(RESP_CONTENT_LENGTH), str, len);
 
-  //scgi_request_add_content_len(rsp->scgi_req, rsp->resp_body_len + rsp->header_len);
-  scgi_request_add_content_len(rsp->scgi_req, rsp->resp_body.len + rsp->header.len);
+  scgi_content_length_add(rsp->scgi, rsp->resp_body->len + rsp->header.len);
 
-  scgi_request_build(rsp->scgi_req);
+  scgi_build(rsp->scgi);
 
   return 0;
 }
 
+void http_resp_file_write_cb(struct ev_loop* loop, struct ev_io* watcher, int revent) {
+  LOG_FUNCTION
+  wkr_t *w = (wkr_t*) watcher->data;
+  http_resp_t *rsp = w->http->resp;
+
+  ssize_t sent;
+
+  LOG_DEBUG(DEBUG, "http_resp_file_write_cb() conn id=%d, Request id=%d",
+          w->http->conn_id, w->http->req_id);
+
+  if (revent & EV_WRITE) {
+
+    if (rsp->file) {
+      char buffer[WR_REQ_BODY_MAX_SIZE];
+      ssize_t read;
+      int rv = fseek(rsp->file, rsp->bytes_write, SEEK_SET);
+      if (rv < 0) {
+        LOG_ERROR(WARN, "Error reading file:%s", strerror(errno));
+        return;
+      }
+      read = fread(buffer, 1, WR_REQ_BODY_MAX_SIZE, rsp->file);
+      sent = send(watcher->fd, buffer, read, 0);
+    }
+
+    if (sent < 0) {
+      ev_io_stop(loop, watcher);
+      LOG_ERROR(WARN, "Error sending response:%s,errno=%d", strerror(errno), errno);
+      // errno 32 = Broken Pipe.
+      if (errno == 32)
+        sigproc();
+      return;
+    }
+
+    rsp->bytes_write += sent;
+
+    LOG_DEBUG(DEBUG, "http_resp_file_write_cb() bytes write = %d, sent = %d", rsp->bytes_write, sent);
+
+    if (rsp->bytes_write >= rsp->resp_body->len) {
+      ev_io_stop(loop, watcher);
+      http_resp_set(rsp);
+      LOG_DEBUG(DEBUG, "http_resp_file_write_cb() starting read watcher.");
+      ev_io_init(watcher, http_req_header_cb, w->req_fd, EV_READ);
+      ev_io_start(loop, watcher);
+    }
+  }
+}
+
 void http_resp_body_write_cb(struct ev_loop* loop, struct ev_io* watcher, int revent) {
   LOG_FUNCTION
-  wkr_t *w       = (wkr_t*) watcher->data;
-  http_resp_t *rsp   = w->http->resp;
+  wkr_t *w = (wkr_t*) watcher->data;
+  http_resp_t *rsp = w->http->resp;
 
-  ssize_t   sent;
+  ssize_t sent;
 
   LOG_DEBUG(DEBUG, "http_resp_body_write_cb() conn id=%d, Request id=%d",
-            w->http->conn_id, w->http->req_id);
+          w->http->conn_id, w->http->req_id);
 
   if (revent & EV_WRITE) {
     sent = send(watcher->fd,
-                rsp->resp_body.str + rsp->bytes_write,
-                rsp->resp_body.len - rsp->bytes_write,
-                0);
+            rsp->resp_body->str + rsp->bytes_write,
+            rsp->resp_body->len - rsp->bytes_write,
+            0);
 
-    //    sent = send(watcher->fd,
-    //                rsp->resp_body + rsp->bytes_write,
-    //                rsp->resp_body_len - rsp->bytes_write,
-    //                0);
-
-    if(sent<0) {
+    if (sent < 0) {
       ev_io_stop(loop, watcher);
-      LOG_ERROR(WARN,"Error sending response:%s,errno=%d",strerror(errno),errno);
+      LOG_ERROR(WARN, "Error sending response:%s,errno=%d", strerror(errno), errno);
       // errno 32 = Broken Pipe.
-      if(errno==32)
+      if (errno == 32)
         sigproc();
       return;
     }
 
     rsp->bytes_write += sent;
 
-    LOG_DEBUG(DEBUG,"http_resp_body_write_cb() bytes write = %d, sent = %d", rsp->bytes_write, sent);
+    LOG_DEBUG(DEBUG, "http_resp_body_write_cb() bytes write = %d, sent = %d", rsp->bytes_write, sent);
 
-    //    if(rsp->bytes_write >= rsp->resp_body_len){
-    if(rsp->bytes_write >= rsp->resp_body.len) {
+    if (rsp->bytes_write >= rsp->resp_body->len) {
       ev_io_stop(loop, watcher);
       http_resp_set(rsp);
-      LOG_DEBUG(DEBUG,"http_resp_body_write_cb() starting read watcher. bytes write=%d",rsp->bytes_write);
+      LOG_DEBUG(DEBUG, "http_resp_body_write_cb() starting read watcher.");
       ev_io_init(watcher, http_req_header_cb, w->req_fd, EV_READ);
       ev_io_start(loop, watcher);
     }
   }
 }
 
-void http_resp_header_write_cb(struct ev_loop* loop, struct ev_io* watcher, int revent) {
+void http_resp_file_send_cb(struct ev_loop* loop, struct ev_io* watcher, int revent) {
   LOG_FUNCTION
-  wkr_t *w       = (wkr_t*) watcher->data;
-  http_resp_t *rsp   = w->http->resp;
+  wkr_t *w = (wkr_t*) watcher->data;
+  http_resp_t *rsp = w->http->resp;
+
+#ifdef _POSIX_C_SOURCE
+   long int rv = sendfile(watcher->fd, rsp->file, &rsp->bytes_write, rsp->resp_body->len - rsp->bytes_write);
+   if (rv == -1) {
+    LOG_ERROR(SEVERE, "error from sendfile: %s\n", strerror(errno));
+    return;
+  }
+#else
+   char buffer[WR_REQ_BODY_MAX_SIZE];
+   ssize_t read, sent;
+   int rv = fseek(rsp->file, rsp->bytes_write, SEEK_SET);
+   if(rv < 0) {
+     LOG_ERROR(WARN,"Error reading file:%s",strerror(errno));
+     return;
+   }
+   read = fread(buffer, 1, WR_REQ_BODY_MAX_SIZE, rsp->file);
+   sent = send(watcher->fd, buffer, read, 0);
+   if (sent < 0) {
+    LOG_ERROR(SEVERE, "error in file sending: %s\n", strerror(errno));
+    return;
+  }
+  rsp->bytes_write += sent;
+#endif
+
+  LOG_DEBUG(DEBUG, "http_resp_body_write_cb() bytes wrire = %d, file size = %d",
+          rsp->bytes_write, rsp->resp_body->len);
+
+  if (rsp->bytes_write >= rsp->resp_body->len) {
+    ev_io_stop(w->loop, &w->w_req);
+    http_resp_set(rsp);
+    LOG_DEBUG(DEBUG, "http_resp_body_write_cb() starting read watcher.");
+    ev_io_init(watcher, http_req_header_cb, w->req_fd, EV_READ);
+    ev_io_start(loop, watcher);
+  }
+}
+
+void http_resp_header_write_cb(struct ev_loop* loop, struct ev_io* watcher, int revent) {
+  LOG_FUNCTION;
+  wkr_t *w = (wkr_t*) watcher->data;
+  http_resp_t *rsp = w->http->resp;
 
-  ssize_t   sent;
+  ssize_t sent;
 
-  LOG_DEBUG(DEBUG,"http_resp_header_write_cb() conn id=%d, Request id=%d",
-            w->http->conn_id, w->http->req_id);
+  LOG_DEBUG(DEBUG, "http_resp_header_write_cb() conn id=%d, Request id=%d",
+          w->http->conn_id, w->http->req_id);
 
   if (revent & EV_WRITE) {
     sent = send(watcher->fd,
-                rsp->header.str + rsp->bytes_write,
-                rsp->header.len - rsp->bytes_write,
-                0);
+            rsp->header.str + rsp->bytes_write,
+            rsp->header.len - rsp->bytes_write,
+            0);
 
-    //    sent = send(watcher->fd,
-    //                rsp->header + rsp->bytes_write,
-    //                rsp->header_len - rsp->bytes_write,
-    //                0);
-
-    if(sent<0) {
+    if (sent < 0) {
       ev_io_stop(loop, watcher);
-      LOG_ERROR(WARN,"Error sending response:%s,errno=%d",strerror(errno),errno);
+      LOG_ERROR(WARN, "Error sending response:%s,errno=%d", strerror(errno), errno);
       // errno 32 = Broken Pipe.
-      if(errno==32)
+      if (errno == 32)
         sigproc();
       return;
     }
 
     rsp->bytes_write += sent;
 
-    LOG_DEBUG(DEBUG,"http_resp_header_write_cb() bytes write = %d, sent = %d", rsp->bytes_write, sent);
+    LOG_DEBUG(DEBUG, "http_resp_header_write_cb() bytes write = %d, sent = %d", rsp->bytes_write, sent);
 
-    //    if(rsp->bytes_write >= rsp->header_len){
-    if(rsp->bytes_write >= rsp->header.len) {
+    if (rsp->bytes_write >= rsp->header.len) {
       ev_io_stop(loop, watcher);
-      LOG_DEBUG(DEBUG,"http_resp_header_write_cb() starting read watcher. bytes write=%d",rsp->bytes_write);
-      if(rsp->resp_body.len > 0) {
+      LOG_DEBUG(DEBUG, "http_resp_header_write_cb() starting read watcher. bytes write=%d", rsp->bytes_write);
+      if (rsp->resp_body->len > 0) {
         rsp->bytes_write = 0;
-        ev_io_init(watcher, http_resp_body_write_cb, w->req_fd, EV_WRITE);
+        if (w->http->is_static && w->http->resp->resp_code == 200) {
+          ev_io_init(watcher, http_resp_file_send_cb, w->req_fd, EV_WRITE);
+          //send_file(w);
+          //ev_io_init(watcher, http_resp_file_write_cb, w->req_fd, EV_WRITE);
+        }else {
+          ev_io_init(watcher, http_resp_body_write_cb, w->req_fd, EV_WRITE);
+        }
         ev_io_start(loop, watcher);
       } else {
         http_resp_set(rsp);
-        LOG_DEBUG(DEBUG,"http_resp_body_write_cb() starting read watcher. bytes write=%d",rsp->bytes_write);
+        LOG_DEBUG(DEBUG, "http_resp_body_write_cb() starting read watcher");
         ev_io_init(watcher, http_req_header_cb, w->req_fd, EV_READ);
         ev_io_start(loop, watcher);
       }
@@ -209,36 +289,29 @@ void http_resp_header_write_cb(struct ev_loop* loop, struct ev_io* watcher, int
 
 void http_resp_scgi_write_cb(struct ev_loop* loop, struct ev_io* watcher, int revent) {
   LOG_FUNCTION
-  wkr_t *w       = (wkr_t*) watcher->data;
-  http_resp_t *rsp   = w->http->resp;
+  wkr_t *w = (wkr_t*) watcher->data;
+  http_resp_t *rsp = w->http->resp;
 
-  ssize_t   sent;
+  ssize_t sent;
 
-  LOG_DEBUG(DEBUG,"http_resp_scgi_write_cb() conn id=%d, Request id=%d",
-            w->http->conn_id, w->http->req_id);
+  LOG_DEBUG(DEBUG, "http_resp_scgi_write_cb() conn id=%d, Request id=%d",
+          w->http->conn_id, w->http->req_id);
 
   if (revent & EV_WRITE) {
-    sent = send(watcher->fd,
-                rsp->scgi_req->request_buffer + rsp->bytes_write,
-                rsp->scgi_req->request_length - rsp->bytes_write,
-                0);
-
-    if(sent<0) {
+  if (scgi_send(rsp->scgi, watcher->fd) <= 0) {
       ev_io_stop(loop, watcher);
-      LOG_ERROR(WARN,"Error sending response:%s,errno=%d",strerror(errno),errno);
+      LOG_ERROR(WARN, "Error sending response:%s,errno=%d", strerror(errno), errno);
       // errno 32 = Broken Pipe.
-      if(errno==32)
+      if (errno == 32)
         sigproc();
       return;
     }
 
-    rsp->bytes_write += sent;
-
-    LOG_DEBUG(DEBUG,"http_resp_scgi_write_cb() bytes write = %d, sent = %d", rsp->bytes_write, sent);
+    LOG_DEBUG(DEBUG, "http_resp_scgi_write_cb() bytes write = %d, sent = %d", rsp->scgi->length, rsp->scgi->bytes_sent);
 
-    if(rsp->bytes_write >= rsp->scgi_req->request_length) {
+    if (rsp->scgi->bytes_sent >= rsp->scgi->length) {
       ev_io_stop(loop, watcher);
-      LOG_DEBUG(DEBUG,"http_resp_scgi_write_cb() starting read watcher. bytes write=%d",rsp->bytes_write);
+      LOG_DEBUG(DEBUG, "http_resp_scgi_write_cb() starting read watcher. bytes write=%d", rsp->bytes_write);
       rsp->bytes_write = 0;
       ev_io_init(watcher, http_resp_header_write_cb, w->req_fd, EV_WRITE);
       ev_io_start(loop, watcher);

data/src/worker/wkr_http_response.h

@@ -1,5 +1,5 @@
 /* WebROaR - Ruby Application Server - http://webroar.in/
- * Copyright (C) 2009  WebROaR
+ * Copyright (C) 2009  Goonj LLC
  *
  * This file is part of WebROaR.
  *
@@ -27,9 +27,15 @@ typedef struct http_resp_s    http_resp_t;
 struct http_resp_s {
   wr_u_short         resp_code;
   size_t            bytes_write;
-  scgi_request_t    *scgi_req;
-  wr_str_buf_t      resp_body;
-  wr_str_t        header;
+  scgi_t    *scgi;
+  wr_buffer_t       *resp_body;
+  wr_str_t          header;
+#ifdef _POSIX_C_SOURCE
+  int              file;
+#else  
+  FILE              *file;
+#endif
+  
 };
 
 http_resp_t* http_resp_new();

data/src/worker/wkr_main.c

@@ -1,5 +1,5 @@
 /* WebROaR - Ruby Application Server - http://webroar.in/
- * Copyright (C) 2009  WebROaR
+ * Copyright (C) 2009  Goonj LLC
  *
  * This file is part of WebROaR.
  *
@@ -21,10 +21,16 @@
 #include <string.h>
 #include <worker.h>
 #include <ruby.h>
+#include <rubysig.h>
+#include <execinfo.h>
+#ifdef __linux__
+#include <sys/prctl.h>
+#endif
 
-//static wkr_t       *worker = NULL;
+static wkr_t       *worker = NULL;
 
 struct               ev_loop *loop;    // Event loop
+struct               ev_idle idle_watcher;
 int                 is_alive = 1;
 
 static int drop_privileges(wkr_t *w) {
@@ -42,6 +48,13 @@ static int drop_privileges(wkr_t *w) {
   LOG_DEBUG(DEBUG,"Passed userid=%d and groupid=%d",
             w->tmp->uid, w->tmp->gid);
   LOG_DEBUG(DEBUG,"effective userid=%d and groupid=%d",geteuid(),getegid());
+#ifdef __linux__
+  int rv = prctl(PR_SET_DUMPABLE, 1, 0, 0, 0);
+  LOG_DEBUG(DEBUG,"prctl(PR_SET_DUMPABLE, 1, 0, 0, 0) = %d", rv);
+  if (rv < 0) {
+    LOG_ERROR(SEVERE,"error setting prctl(PR_SET_DUMPABLE, 1, 0, 0, 0), errno = %d, desc = %s", errno, strerror(errno));
+  }
+#endif  
   return 0;
 }
 
@@ -68,6 +81,67 @@ void sigproc() {
   is_alive = 0;
 }
 
+void cleanup() {
+  LOG_FUNCTION
+  stop_idle_watcher();
+  LOG_DEBUG(DEBUG,"stoping event loop");
+  ev_unloop(loop,EVUNLOOP_ALL);
+  //TODO: send worker stopping signal
+  worker_free(&worker);
+  LOG_INFO("Worker stopped and exiting gracefully.");
+  close_logger();
+  exit(0);
+}
+ 
+/** Handle segmentation fault */
+void crash_handler(int sig) {
+  void *array[WR_STACKTRACE_SIZE];
+  size_t size;
+  char **bt_symbols;
+  char bt_string[WR_STACKTRACE_SIZE * WR_LONG_STR_LEN * 2];
+  int i;
+  
+  LOG_ERROR(FATAL, "Got %d signal, trying to create core file.", sig);
+  signal(sig, SIG_DFL);
+  //kill(getpid(), sig);
+  if(fork() == 0) { // child
+    char cmd[64], core_file_name[48], timestamp[24];
+    int rv;
+    signal(SIGCHLD, SIG_DFL);
+    //TODO: add application name
+    sprintf(core_file_name, "/tmp/webroar-worker");
+    if ( get_timestamp(timestamp) == 0 ) {
+      strcat(core_file_name, "-");
+      strcat(core_file_name, timestamp);
+    }
+#ifdef __APPLE__
+    sprintf(cmd, "gcore -c %s %ld", core_file_name, (long) getppid() );
+#else
+    sprintf(cmd, "gcore -o %s %ld", core_file_name, (long) getppid() );
+#endif
+    rv = system(cmd);
+    if ( rv < 0 ) {
+      LOG_ERROR(FATAL, "Core file creation failed, gcore might be missing... rv = %d, errno = %d, error = %s", rv, errno, strerror(errno));
+    } else {
+      LOG_INFO("Core file - %s created", core_file_name);
+    }
+    exit(0);
+  }
+  sleep(5);
+  // get void*'s for all entries on the stack
+  size = backtrace(array, WR_STACKTRACE_SIZE);
+  bt_symbols = backtrace_symbols(array, size);
+  strcpy(bt_string, "\n");
+  for(i = 0; i < size; i++) {
+    strcat(bt_string, bt_symbols[i]);
+    strcat(bt_string, "\n");
+  }
+  LOG_ERROR(FATAL, "Obtained %zd stack frames.%s", size, bt_string);
+  free(bt_symbols);
+  //TODO: carefully dump worker state, current request
+  cleanup();
+}
+
 /** Parse command line arguments */
 static inline wkr_tmp_t* parse_args(int argc, char **argv) {
   int option;
@@ -158,9 +232,47 @@ static inline wkr_tmp_t* parse_args(int argc, char **argv) {
     wkr_tmp_free(&tmp);
     return NULL;
   }
+  if(strcmp(tmp->name.str, WR_STATIC_FILE_SERVER_NAME) == 0){
+    tmp->is_static = 1;
+  }
   return tmp;
 }
 
+void start_idle_watcher() {
+  LOG_FUNCTION
+  if(!ev_is_active(&idle_watcher)) {
+    ev_idle_start (loop, &idle_watcher);
+  }
+}
+
+void stop_idle_watcher() {
+  LOG_FUNCTION
+  ev_idle_stop(loop, &idle_watcher);
+}
+
+void idle_cb (struct ev_loop *loop, struct ev_idle *w, int revents) {
+  LOG_FUNCTION
+  /* Calling libev's blocking call ev_loop() between TRAP_* macros were working on Ruby 1.8, 
+   * but didn't worked on Ruby 1.9, looks we need to schedule ruby threads on our own
+   */
+  if(rb_thread_alone()) {
+    /* Stop scheduling ruby threads, there is only one! */
+    stop_idle_watcher();    
+  } else {
+    /* TODO: Found following three api to schedule ruby threads  
+     * rb_thread_schedule() was getting called infinitely and eating most of the CPU. 
+     * rb_thread_polling() was getting called, for approximately 16 times in a second on 1.8
+     * and 10 times on 1.9 
+     * rb_thread_select() takes delay(in struct timeval) as last argument, useful to control 
+     * number of call in a second, but need to checkout best value for that argument
+     * Ruby 1.9 have rb_thread_blocking_region() to execute C blocking call, need to explore it
+     * Checkout the best strategy to combine ruby thread scheduling with libev. 
+     * Currently rb_thread_polling looks suitable to use  */
+    rb_thread_polling();
+    //rb_thread_schedule();
+  } 
+}
+
 int main(int argc, char **argv) {
   int port, retval = 0;
   wkr_t* w = NULL;
@@ -169,6 +281,13 @@ int main(int argc, char **argv) {
     print_usage(argv[0]);
     return -1;
   }
+  
+  signal(SIGSEGV, crash_handler); /* set our handler for segfault */
+//  signal(SIGQUIT, crash_handler);
+//  signal(SIGILL, crash_handler);
+//  signal(SIGABRT, crash_handler);
+//  signal(SIGFPE, crash_handler);
+  
   wkr_tmp_t *tmp = parse_args(argc, argv);
 
   if(tmp == NULL)
@@ -178,11 +297,12 @@ int main(int argc, char **argv) {
   w = worker_new(loop, tmp);
   if(w==NULL)
     goto err;
-  //  worker = w;
+  worker = w;
   //  assert(w!=NULL);
 
   initialize_logger(w->tmp->log_file.str);
-
+  redirect_standard_io();
+  
   LOG_DEBUG(DEBUG,"control path = %s, Application baseuri = %s",
             w->tmp->ctl_path.str,  w->tmp->resolver.str);
 
@@ -203,12 +323,6 @@ int main(int argc, char **argv) {
     goto err;
   }
 
-  //  w->http = http_new(w);
-  //  if(w->http == NULL)
-  //  {
-  //    goto err;
-  //  }
-
   //loading adapter according to application type
   LOG_DEBUG(DEBUG,"ruby lib = %s and webroar_root = %s",
             w->tmp->ruby_path.str, w->tmp->root_path.str);
@@ -220,29 +334,31 @@ int main(int argc, char **argv) {
            w->tmp->path.str,   w->tmp->env.str);
 
   //TODO: Windows Portability?
-  signal(SIGHUP, SIG_IGN); /* catch hangup signal */
-  signal(SIGINT, SIG_IGN);
-  signal(SIGTERM, SIG_IGN);
+  signal(SIGHUP, sigproc); /* catch hangup signal */
+  signal(SIGINT, sigproc);
+  signal(SIGTERM, sigproc);
   signal(SIGCHLD, SIG_IGN);
   signal(SIGTSTP, SIG_IGN);
   signal(SIGTTOU, SIG_IGN);
-  signal(SIGTTIN, SIG_IGN);
-  signal(SIGKILL, sigproc);
+  signal(SIGTTIN, SIG_IGN);  
   signal(SIGPIPE, SIG_IGN);
 
   worker_accept_requests(w);
   LOG_INFO("Worker ready for serving requests.");
 
+  if(!w->http->is_static){
+    ev_idle_init (&idle_watcher, idle_cb);
+    start_idle_watcher();
+  }
+
   while(is_alive ==1) {
+    /* TODO: wrapping ev_loop() between TARP_* macros didn't worked in Ruby 1.9 */
+    //TRAP_BEG;
     ev_loop(loop,EVLOOP_ONESHOT);
+    //TRAP_END;
   }
 
 err:
-  LOG_DEBUG(DEBUG,"stoping event loop");
-  ev_unloop(loop,EVUNLOOP_ALL);
-  //TODO: send worker stopping signal
-  worker_free(&w);
-  LOG_INFO("Worker stopped and exiting gracefully.");
-  close_logger();
+  cleanup();
   return retval;
 }