webroar 0.3.0 → 0.3.1

data/src/head/wr_application.h

@@ -21,39 +21,46 @@
 
 #include <wr_server.h>
 
-#define WR_MAX_PENDING_WKR 10
-#define TOTAL_WORKER_COUNT(app) (app->pending_wkr + WR_QUEUE_SIZE(app->wkr_que))
+#define TOTAL_WORKER_COUNT(app) (WR_QUEUE_SIZE(app->q_pending_workers) + WR_QUEUE_SIZE(app->q_workers))
 
 typedef struct wr_req_s      wr_req_t;
 typedef struct wr_wkr_s      wr_wkr_t;
-//typedef struct wr_ctl_msg_s  wr_ctl_msg_t;
+
+typedef int wr_pending_wkr_t;
+
+typedef enum{
+  WR_APP_NEW,
+  WR_APP_ACTIVE,
+  WR_APP_RESTART,
+  WR_APP_RESTARTING,
+  WR_APP_DESTROY
+}wr_app_state_t;
 
 /** Application structure */
 struct wr_app_s {
-  //  wr_u_long      app_baseuri_hash;    /**< Hash value of application base uri */
-  wr_u_short     pending_wkr;  /**< Total number of pending workers */
-  wr_queue_t     *msg_que;      /**< Pending message queue */
-  wr_queue_t     *wkr_que;      /**< List of workers */
-  wr_queue_t     *free_wkr_que;  /**< List of free workers */
-  wr_app_conf_t  *conf;  /**< Application configuration parameters */
-  wr_app_t       *next;
+
+  wr_queue_t     *q_pending_workers; /**< Pending worker queue */
+  wr_queue_t     *q_workers;      /**< List of workers */
+  wr_queue_t     *q_free_workers;  /**< List of free workers */
+
+  wr_queue_t     *q_messages;      /**< Pending message queue */
+
+  wr_app_conf_t  *conf;        /**< Application configuration parameters */
   wr_svr_t       *svr;        /**< Server pointer */
   wr_ctl_t       *ctl;
 
   short          low_ratio;    /** Ratio to remove the worker */
   short          high_ratio;   /** Ratio to add the worker */
-  short          in_use;       /** Application status flag */
-
-  /** Variables used to reload an application without any downtime */
-  short          restarted;    /** Application restart status flag */
-  short          old_workers;  /** Number of old workers to be removed */
-  short          add_workers;  /** Number of new workers to be created */
-
-  wr_u_short     last_wkr_pid[WR_MAX_PENDING_WKR];    /**< PID of the last worker */
 
+  wr_app_state_t state;       /** Application status flag */
+  
+  short          timeout_counter; /**< Worker add timeout counter */
+  
   ev_timer       t_add;          /**< Timer to add worker */
   ev_timer       t_remove;      /**< Timer to remove worker */
   ev_timer       t_add_timeout;      /**< Timer to wait for add signal from worker */
+
+  wr_app_t       *next;
 };
 
 /** Destroy application */
@@ -62,8 +69,6 @@ void wr_app_free(wr_app_t*);
 void wr_app_print(wr_app_t*);
 /** Create worker for application */
 int wr_app_wkr_add(wr_app_t*);
-/** Insert application based on application configuration */
-//int wr_app_insert(wr_svr_t*, wr_app_conf_t*);
 /** Add request message in pending queue */
 int wr_app_message_insert(wr_svr_t*, wr_req_t*);
 /** Check load balance to add the worker */
@@ -71,7 +76,7 @@ void wr_app_chk_load_to_add_wkr(wr_app_t*);
 /** Check load balance to remove the worker */
 void wr_app_chk_load_to_remove_wkr(wr_app_t*);
 /** Add newly created worker to application */
-int wr_app_wrk_insert(wr_svr_t *, wr_wkr_t*, const wr_ctl_msg_t*);
+int wr_app_wkr_insert(wr_svr_t *, wr_wkr_t*, const wr_ctl_msg_t*);
 /** Remove application from application list */
 int wr_app_remove(wr_svr_t*, const char* app_name);
 /** Initialize the applications */
@@ -84,6 +89,8 @@ void wr_app_remove_cb(wr_ctl_t*, const wr_ctl_msg_t*);
 void wr_app_reload_cb(wr_ctl_t*, const wr_ctl_msg_t*);
 /** Worker added to application callback */
 void wr_app_wkr_added_cb(wr_app_t *app);
+/** Balance worker count for an application */
+void wr_app_wkr_balance(wr_app_t *app);
 
 /**************************/
 

data/src/head/wr_config.h

@@ -29,6 +29,9 @@
 // Maximum value allowed for number of workers
 #define WR_ALLOWED_MAX_WORKERS 20
 
+#define WR_MAX_PENDING_WKR 10
+#define WR_MAX_ADD_TIMEOUT_COUNTER 3 
+
 #ifdef HAVE_GNUTLS
 // Default SSL listining port
 #define WR_DEFAULT_SSL_PORT 443
@@ -84,7 +87,7 @@
 // File to store Server process id
 #define WR_PID_FILE  "/var/run/webroar.pid"
 #define WR_SERVER "WebROaR"
-#define WR_VERSION "0.2.7"
+#define WR_VERSION "0.3.1"
 #define WR_MIME_TYPE_PATH "/conf/mime_type.yml"
 #define WR_CONF_PATH "/conf/config.yml"
 #define WR_SERVER_INTERNAL_CONF_PATH "/conf/server_internal_config.yml"
@@ -156,4 +159,7 @@
 
 #define WR_MAX_HOST_NAMES 16
 
+#define TRUE  1
+#define FALSE 0
+
 #endif /*WR_CONFIG_H_*/

data/src/head/wr_connection.c

@@ -318,7 +318,7 @@ void wr_conn_err_resp(wr_conn_t *conn, wr_resp_status_t resp_code) {
     } else if(req->app) {
       // Remove req from application message list
       LOG_DEBUG(DEBUG,"Request is inserted into Application message queue.");
-      wr_queue_remove(conn->req->app->msg_que, conn->req);
+      wr_queue_remove(conn->req->app->q_messages, conn->req);
       wr_req_free(req);
     } else {
       LOG_DEBUG(DEBUG,"Request is still in parsing phase.");

data/src/head/wr_controller.c

@@ -517,10 +517,8 @@ void wr_ctl_free(wr_ctl_t* ctl) {
         wr_wkr_free(ctl->wkr);
 
       //create new worker if required
-      if(app && app->in_use &&
-          (TOTAL_WORKER_COUNT(app) < app->conf->min_worker ||
-           app->msg_que->q_count > app->high_ratio ) ) {
-        wr_app_wkr_add(app);
+      if(app && app->state == WR_APP_ACTIVE){
+        wr_app_wkr_balance(app);
       }
     }
     if(ctl->app) {

data/src/head/wr_request.c

@@ -472,7 +472,7 @@ void wr_req_complete_cb(ebb_request * request) {
   // ebb_request parsing completed, send call back to Server
   if(req->app){
     int rv;
-    WR_QUEUE_INSERT(req->app->msg_que, req, rv)
+    WR_QUEUE_INSERT(req->app->q_messages, req, rv)
     if(rv == 0){
       wr_wkr_dispatch_req(req);
       return;

data/src/head/wr_request.h

@@ -67,9 +67,9 @@ ebb_request* wr_new_req_cb(ebb_connection*);
 /** Dispatch a pending message to free worker */
 #define WR_APP_MSG_DISPATCH(app, req, worker) \
   void *_w=NULL,*_r=NULL;\
-  if(app->msg_que->q_count > 0 && app->free_wkr_que->q_count > 0){\
-    WR_QUEUE_FETCH(app->free_wkr_que, _w)\
-    WR_QUEUE_FETCH(app->msg_que, _r)}\
+  if(app->q_messages->q_count > 0 && app->q_free_workers->q_count > 0){\
+    WR_QUEUE_FETCH(app->q_free_workers, _w)\
+    WR_QUEUE_FETCH(app->q_messages, _r)}\
   req = (wr_req_t*) _r;\
   worker = (wr_wkr_t*) _w;
 

data/src/head/wr_resolver.c

@@ -49,7 +49,7 @@ int wr_req_resolve_static_content(wr_req_t *req){
   int len;
   wr_str_t decoded_req_path;
 
-  if(req->app->svr->static_app->wkr_que->q_count <= 0){
+  if(WR_QUEUE_SIZE(req->app->svr->static_app->q_workers) <= 0){
     LOG_ERROR(SEVERE,"Static content server is down.")
     return -1;
   }
@@ -296,7 +296,7 @@ int wr_req_resolve_http_req(wr_svr_t *server, wr_req_t *req) {
     app = server->default_app;
   }
 
-  if(app && app->wkr_que->q_count > 0) {
+  if(app && WR_QUEUE_SIZE(app->q_workers) > 0) {
 //    int rv = 0;
     req->app = app;
     wr_req_resolve_static_content(req);

data/src/head/wr_worker.c

@@ -42,12 +42,12 @@ static inline void wr_wrk_allocate(wr_wkr_t* worker) {
   wr_svr_t* server = app->svr;
   int retval;
   //do we need high load ratio check here?
-  if(app && app->msg_que->q_count > 0) {
+  if(app && app->q_messages->q_count > 0) {
     //There is pending request
-    WR_QUEUE_FETCH(app->msg_que, req)  ;
+    WR_QUEUE_FETCH(app->q_messages, req)  ;
 
     if(req == NULL) {
-      WR_QUEUE_INSERT(app->free_wkr_que, worker, retval)  ;
+      WR_QUEUE_INSERT(app->q_free_workers, worker, retval)  ;
     } else {
       LOG_DEBUG(4,"Allocate worker %d to req id %d", worker->id , req->id);
       req->wkr = worker;
@@ -59,7 +59,7 @@ static inline void wr_wrk_allocate(wr_wkr_t* worker) {
   } else if(app) {
     //No any pending request. Add Worker to free worker list
     LOG_DEBUG(4,"Message queue is empty");
-    WR_QUEUE_INSERT(app->free_wkr_que, worker, retval)  ;
+    WR_QUEUE_INSERT(app->q_free_workers, worker, retval)  ;
   } else {
     //Remove worker
     LOG_ERROR(SEVERE,"wr_wrk_allocate: Remove worker with pid %d.", worker->pid);
@@ -366,7 +366,7 @@ static inline void wr_wkr_recreate(wr_wkr_t *worker) {
   wr_wkr_remove(worker, 0);
   //create new worker if required
   if(TOTAL_WORKER_COUNT(app) < app->conf->min_worker ||
-      app->msg_que->q_count > app->high_ratio) {
+      app->q_messages->q_count > app->high_ratio) {
     wr_app_wkr_add(app);
   }
 }
@@ -504,19 +504,19 @@ int wr_wkr_remove(wr_wkr_t *worker, int flag) {
     worker->state -= WR_WKR_ACTIVE;
 
   if(app) {
-    LOG_INFO("Removing worker %d with pid %d...app->wkr_que->q_count=%d, q_front=%d, q_rear=%d app=%s",
-             worker->id, worker->pid,app->wkr_que->q_count,app->wkr_que->q_front,app->wkr_que->q_rear,
+    LOG_INFO("Removing worker %d with pid %d...app->q_workers->q_count=%d, q_front=%d, q_rear=%d app=%s",
+             worker->id, worker->pid,app->q_workers->q_count,app->q_workers->q_front,app->q_workers->q_rear,
              app->conf->name.str);
   } else {
     LOG_INFO("Removing worker %d with pid %d", worker->id, worker->pid);
   }
 
-  if(app && wr_queue_remove(app->wkr_que, worker) == 0) {
+  if(app && wr_queue_remove(app->q_workers, worker) == 0) {
     app->high_ratio = TOTAL_WORKER_COUNT(app) * WR_MAX_REQ_RATIO;
-    app->low_ratio = WR_QUEUE_SIZE(app->wkr_que) * WR_MIN_REQ_RATIO;
+    app->low_ratio = WR_QUEUE_SIZE(app->q_workers) * WR_MIN_REQ_RATIO;
 
     if(flag) {
-      wr_queue_remove(app->free_wkr_que, worker);
+      wr_queue_remove(app->q_free_workers, worker);
     }
     wr_wkr_free(worker);
     return 0;
@@ -679,7 +679,7 @@ int wr_wkr_connect(wr_ctl_t *ctl, const wr_ctl_msg_t *ctl_msg) {
   worker->state += WR_WKR_CONNECTING;
 
   // Insert newly added Worker to application list*/
-  if(wr_app_wrk_insert(server, worker, ctl_msg)!=0) {
+  if(wr_app_wkr_insert(server, worker, ctl_msg)!=0) {
     LOG_INFO("No more workers required.");
     free(worker);
     return -1;
@@ -765,14 +765,14 @@ int wr_wkr_connect(wr_ctl_t *ctl, const wr_ctl_msg_t *ctl_msg) {
     return -1;
   }
 
-  if(wr_queue_insert(worker->app->wkr_que, worker) < 0){
+  if(wr_queue_insert(worker->app->q_workers, worker) < 0){
     LOG_ERROR(WARN,"Worker queue is full.");
     worker->app->high_ratio = TOTAL_WORKER_COUNT(worker->app) * WR_MAX_REQ_RATIO;
     return -1;
   }
 
   //Setting low load ratio for application, refer "wr_worker_remove_cb" in wr_server.c for details.
-  worker->app->low_ratio = worker->app->wkr_que->q_count * WR_MIN_REQ_RATIO;
+  worker->app->low_ratio = worker->app->q_workers->q_count * WR_MIN_REQ_RATIO;
   ctl->wkr = worker;
   LOG_DEBUG(DEBUG,"Added Worker %d",worker->id);
 
@@ -783,7 +783,8 @@ int wr_wkr_connect(wr_ctl_t *ctl, const wr_ctl_msg_t *ctl_msg) {
   wr_wrk_allocate(worker);
   LOG_DEBUG(5,"Successfully connected to worker");
   LOG_DEBUG(DEBUG,"Allocated task to newly added worker %d",worker->id);
-  wr_app_wkr_added_cb(worker->app);
+  wr_app_wkr_balance(worker->app);
+  //wr_app_wkr_added_cb(worker->app);
 
   return 0;
 }
@@ -837,9 +838,7 @@ void wr_wkr_remove_cb(wr_ctl_t *ctl, const wr_ctl_msg_t *ctl_msg) {
   wr_ctl_resp_write(ctl);
 
   // Create new worker if required
-  if(app && app->in_use && TOTAL_WORKER_COUNT(app) < app->conf->min_worker) {
-    wr_app_wkr_add(app);
-  }
+  if(app && app->state == WR_APP_ACTIVE)   wr_app_wkr_balance(app);
 }
 
 /** Worker ping callback */

data/src/ruby_lib/ruby_interface/version.rb

@@ -21,7 +21,7 @@ module Webroar
   module VERSION #:nodoc:
     MAJOR    = "0"
     MINOR    = "3"
-    TINY     = "0"
+    TINY      = "1"
     
     STRING   = [MAJOR, MINOR, TINY].join('.')
   end

data/tasks/gem.rake

@@ -35,7 +35,7 @@ spec = Gem::Specification.new do |s|
   s.version               = Webroar::VERSION::STRING
   s.platform              = Gem::Platform::RUBY
   s.summary               = "A ruby application server."
-  s.description           = "WebROaR is the first true application server for ruby based web applications that provides in-built support for scalable and robust deployment of multiple applications simultaneously."
+  s.description           = "WebROaR is an application server that makes deployments of ruby web applications extremely simple. It provides an integrated solution to view the run time performance numbers and email notifications in case any exceptions occur in any of the deployed applications. It is 5 to 55% faster than all other comparable deployment stacks for Ruby on Rails applications. Check out http://webroar.in for more details."
   s.authors               = ["Aditya Babbar", "Dharmarth Shah", "Nikunj Limbaseeya"]
   s.email                 = ["aditya.babbar@webroar.in", "dharmarth.shah@webroar.in", "nikunj.limbaseeya@webroar.in"]
   s.homepage              = "http://webroar.in"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: webroar
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors: 
 - Aditya Babbar
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-20 00:00:00 +05:30
+date: 2010-03-22 00:00:00 +05:30
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -84,7 +84,7 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 2.3.12
     version: 
-description: WebROaR is the first true application server for ruby based web applications that provides in-built support for scalable and robust deployment of multiple applications simultaneously.
+description: WebROaR is an application server that makes deployments of ruby web applications extremely simple. It provides an integrated solution to view the run time performance numbers and email notifications in case any exceptions occur in any of the deployed applications. It is 5 to 55% faster than all other comparable deployment stacks for Ruby on Rails applications. Check out http://webroar.in for more details.
 email: 
 - aditya.babbar@webroar.in
 - dharmarth.shah@webroar.in