webroar 0.3.1 → 0.4.0

data/src/head/wr_controller.c

@@ -31,10 +31,17 @@
  *         USD: {YES/NO}
  *         PORT: <port> or SOCK_PATH: <sock_path>
  *         PID: <pid>
- * 2) Remove Worker
+ * 2) Error on adding worker
+ *         COMPONENT: WORKER
+ *         METHOD: ERROR
+ *         APPLICATION: /<baseuri>
+ *         USD: {YES/NO}
+ *         PORT: <port> or SOCK_PATH: <sock_path>
+ *         PID: <pid>
+ * 3) Remove Worker
  *         COMPONENT: WORKER
  *         METHOD: REMOVE
- * 3) Add Application
+ * 4) Add Application
  *         COMPONENT: APPLICATION
  *         METHOD: ADD
  *         APP_NAME: <application name>
@@ -45,16 +52,18 @@
  *         APP_LOG_LEVEL: <logging level> (optional)
  *         APP_MIN_WORKER: <min workers> (optional)
  *         APP_MAX_WORKER: <max workers> (optional)
- * 4) Remove Application
+ * 5) Remove Application
  *         COMPONENT: APPLICATION
  *         METHOD: ADD
  **/
 
-static inline wr_ctl_msg_t* wr_ctl_msg_validate(scgi_t* request, wr_ctl_t* ctl) {
+extern config_t *Config;
+
+wr_ctl_msg_t* wr_ctl_msg_validate(scgi_t* request, wr_ctl_t* ctl) {
   LOG_FUNCTION
   wr_ctl_msg_t* ctl_msg = wr_malloc(wr_ctl_msg_t);
   char *val;
-  char error[WR_STR_LEN];
+  char error[STR_SIZE64];
 
   ctl->type = WR_CTL_MSG_NONE;
   ctl->scgi = scgi_new();
@@ -71,8 +80,9 @@ static inline wr_ctl_msg_t* wr_ctl_msg_validate(scgi_t* request, wr_ctl_t* ctl)
       strcpy(error,"METHOD missing.");
       goto ctl_msg_err;
     }
-    scgi_header_add(ctl->scgi, "METHOD", strlen("METHOD"), val, strlen(val));
 
+    scgi_header_add(ctl->scgi, "METHOD", strlen("METHOD"), val, strlen(val));
+    
     ctl_msg->msg.app.app_name.str = (char*) scgi_header_value_get(request,"APP_NAME");
     if(ctl_msg->msg.app.app_name.str == NULL) {
       strcpy(error,"Application name is missing.");
@@ -86,7 +96,7 @@ static inline wr_ctl_msg_t* wr_ctl_msg_validate(scgi_t* request, wr_ctl_t* ctl)
       ctl->type = WR_CTL_MSG_APPLICATION_REMOVE;
     } else if(strcmp(val,"RELOAD")==0) {
       ctl->type = WR_CTL_MSG_APPLICATION_RELOAD;
-    } else {
+    }else {
       strcpy(error,"Invalid METHOD.");
       goto ctl_msg_err;
     }
@@ -96,7 +106,13 @@ static inline wr_ctl_msg_t* wr_ctl_msg_validate(scgi_t* request, wr_ctl_t* ctl)
       strcpy(error,"METHOD missing.");
       goto ctl_msg_err;
     }
-    scgi_header_add(ctl->scgi, "METHOD", strlen("METHOD"), val, strlen(val));
+
+    if(strcmp(val,"ERROR")==0) {
+      scgi_header_add(ctl->scgi, "METHOD", strlen("METHOD"), "ACK", strlen("ACK"));
+    }else{
+      scgi_header_add(ctl->scgi, "METHOD", strlen("METHOD"), val, strlen(val));
+    }
+    
     // Worker Add
     if(strcmp(val,"ADD")==0) {
       ctl->type = WR_CTL_MSG_WORKER_ADD;
@@ -118,7 +134,24 @@ static inline wr_ctl_msg_t* wr_ctl_msg_validate(scgi_t* request, wr_ctl_t* ctl)
       ctl->type = WR_CTL_MSG_WORKER_REMOVE;
     } else if(strcmp(val,"PING") == 0) {
       ctl->type = WR_CTL_MSG_WORKER_PING;
-    } else {
+    } else if(strcmp(val,"CONF_REQ") == 0){
+      ctl->type = WR_CTL_MSG_WORKER_CONF_REQ;
+      ctl_msg->msg.wkr.app_name.str  =   (char*) scgi_header_value_get(request,"APPLICATION");
+    } else if(strcmp(val,"ERROR") == 0) {
+      ctl->type = WR_CTL_MSG_WORKER_ADD_ERROR;
+      ctl_msg->msg.wkr.app_name.str  =   (char*) scgi_header_value_get(request,"APPLICATION");
+      ctl_msg->msg.wkr.pid.str =   (char*) scgi_header_value_get(request,"PID");
+      ctl_msg->msg.wkr.port.str  =   (char*) scgi_header_value_get(request,"PORT");
+      ctl_msg->msg.wkr.sock_path.str  =   (char*) scgi_header_value_get(request,"SOCK_PATH");
+      ctl_msg->msg.wkr.uds.str  =   (char*) scgi_header_value_get(request,"UDS");
+
+      if(ctl_msg->msg.wkr.app_name.str == NULL ||
+          ctl_msg->msg.wkr.pid.str == NULL ||
+          ctl_msg->msg.wkr.uds.str == NULL) {
+        strcpy(error,"Missing some headers.");
+        goto ctl_msg_err;
+      }
+    }else {
       strcpy(error,"Invalid METHOD.");
       goto ctl_msg_err;
     }
@@ -136,7 +169,7 @@ ctl_msg_err:
   return ctl_msg;
 }
 
-static void wr_ctl_msg_write_cb(struct ev_loop *loop, struct ev_io *w, int revents) {
+void wr_ctl_msg_write_cb(struct ev_loop *loop, struct ev_io *w, int revents) {
   LOG_FUNCTION
   if(EV_ERROR & revents) {
     LOG_ERROR(4,"got error event, returning.");
@@ -144,8 +177,8 @@ static void wr_ctl_msg_write_cb(struct ev_loop *loop, struct ev_io *w, int reven
   }
 
   wr_ctl_t* ctl = (wr_ctl_t*) w->data;
-  
-  if(scgi_send(ctl->scgi, w->fd) <= 0){
+
+  if(scgi_send(ctl->scgi, ctl->fd) <= 0){
     LOG_ERROR(4,"got error event, returning.");
     return;
   }
@@ -153,27 +186,25 @@ static void wr_ctl_msg_write_cb(struct ev_loop *loop, struct ev_io *w, int reven
   LOG_DEBUG(DEBUG,"Sending control messag %d/%d", ctl->scgi->bytes_sent, ctl->scgi->length);
   if(ctl->scgi->bytes_sent >= ctl->scgi->length) {
     ev_io_stop(loop, w);
-    scgi_free(ctl->scgi);
+    if(ctl->destroy_scgi == TRUE){
+       scgi_free(ctl->scgi);
+    }else{
+      ctl->scgi->bytes_sent = 0;
+    }
     ctl->scgi = NULL;
-    if(ctl->type == WR_CTL_MSG_TYPE_ERROR) {
+    ctl->destroy_scgi = TRUE;
+    if(ctl->type == WR_CTL_MSG_TYPE_ERROR || ctl->type == WR_CTL_MSG_WORKER_ADD_ERROR) {
       wr_ctl_free(ctl);
     }
-    /*if(control->type == WR_CTL_MSG_WORKER_PING){
-      ev_io_start(loop, &control->w_read);
-  }*/
   }
 }
 
 /** Process Control message */
-static inline void wr_ctl_msg_process(scgi_t* request,  wr_ctl_t* ctl) {
+void wr_ctl_msg_process(scgi_t* request,  wr_ctl_t* ctl) {
   LOG_FUNCTION
 
   wr_ctl_msg_t* ctl_msg = wr_ctl_msg_validate(request, ctl);
-
-  //  ctl->type.type = ctl_msg->type;
-  //ctl->resp_nbytes = 0;
-  ctl->w_write.data = ctl;
-  ev_io_init(&(ctl->w_write ), wr_ctl_msg_write_cb, ctl->fd, EV_WRITE);
+  
   int flag = 0;
 
   switch(ctl->type) {
@@ -195,7 +226,6 @@ static inline void wr_ctl_msg_process(scgi_t* request,  wr_ctl_t* ctl) {
     break;
   case WR_CTL_MSG_APPLICATION_RELOAD:
     LOG_DEBUG(DEBUG,"WR_CTL_MSG_APPLICATION_RELOAD");
-    //    wr_ctl_msg_app_reload(ctl_msg, ctl);
     if(ctl->svr && ctl->svr->on_app_reload)
       ctl->svr->on_app_reload(ctl, ctl_msg);
     else
@@ -203,15 +233,20 @@ static inline void wr_ctl_msg_process(scgi_t* request,  wr_ctl_t* ctl) {
     break;
   case WR_CTL_MSG_WORKER_ADD:
     LOG_DEBUG(DEBUG,"WR_CTL_MSG_WORKER_ADD");
-    //    wr_ctl_msg_wkr_add(ctl_msg, ctl);
     if(ctl->svr && ctl->svr->on_wkr_add)
       ctl->svr->on_wkr_add(ctl, ctl_msg);
     else
       flag =1;
     break;
+  case WR_CTL_MSG_WORKER_ADD_ERROR:
+    LOG_DEBUG(DEBUG,"WR_CTL_MSG_WORKER_ADD_ERROR");
+    if(ctl->svr && ctl->svr->on_wkr_add_error)
+      ctl->svr->on_wkr_add_error(ctl, ctl_msg);
+    else
+      flag =1;
+    break;
   case WR_CTL_MSG_WORKER_REMOVE:
     LOG_DEBUG(DEBUG,"WR_CTL_MSG_WORKER_REMOVE");
-    //    wr_ctl_msg_wkr_remove(ctl_msg, ctl);
     if(ctl->svr && ctl->svr->on_wkr_remove)
       ctl->svr->on_wkr_remove(ctl, ctl_msg);
     else
@@ -219,13 +254,18 @@ static inline void wr_ctl_msg_process(scgi_t* request,  wr_ctl_t* ctl) {
     break;
   case WR_CTL_MSG_WORKER_PING:
     LOG_DEBUG(DEBUG,"WR_CTL_MSG_WORKER_PING");
-    //    scgi_free(ctl_msg->resp);
-    //    wr_wkr_ping_reply(ctl->wkr);
     if(ctl->svr && ctl->svr->on_wkr_ping)
       ctl->svr->on_wkr_ping(ctl, ctl_msg);
     else
       flag =1;
     break;
+  case WR_CTL_MSG_WORKER_CONF_REQ:
+      LOG_DEBUG(DEBUG,"WR_CTL_MSG_WORKER_CONF_REQ");
+      if(ctl->svr && ctl->svr->on_wkr_conf_req)
+        ctl->svr->on_wkr_conf_req(ctl, ctl_msg);
+      else
+        flag =1;
+      break;
   case WR_CTL_MSG_TYPE_ERROR:
     LOG_DEBUG(DEBUG,"WR_CTL_MSG_TYPE_ERROR");
     wr_ctl_resp_write(ctl);
@@ -243,7 +283,7 @@ static inline void wr_ctl_msg_process(scgi_t* request,  wr_ctl_t* ctl) {
 }
 
 /** Read and handle data sent by control port of Workers*/
-static void wr_ctl_msg_read_cb(struct ev_loop *loop, struct ev_io *w, int revents) {
+void wr_ctl_msg_read_cb(struct ev_loop *loop, struct ev_io *w, int revents) {
   LOG_FUNCTION
   wr_ctl_t* ctl = (wr_ctl_t*) w->data;
 
@@ -255,14 +295,11 @@ static void wr_ctl_msg_read_cb(struct ev_loop *loop, struct ev_io *w, int revent
   //Read data
   int bytesRead = recv(w->fd,
                        ctl->msg + ctl->ctl_nbytes,
-                       WR_MSG_SIZE - ctl->ctl_nbytes,
+                       STR_SIZE1KB - ctl->ctl_nbytes,
                        0);
 
   if(bytesRead <= 0 && ctl && ctl->svr && ctl->svr->is_running) {
     LOG_ERROR(WARN,"Error receiving contol message port or socket path:%s, fd = %d, bytesRead=%d",strerror(errno), w->fd, bytesRead);
-    if(ctl->wkr) {
-      ctl->wkr->state += (WR_WKR_ERROR + WR_WKR_HANG);
-    }
     wr_ctl_free(ctl);
     return;
   }
@@ -286,12 +323,30 @@ static void wr_ctl_msg_read_cb(struct ev_loop *loop, struct ev_io *w, int revent
   ctl->ctl_nbytes = 0;
 }
 
+wr_ctl_t* wr_ctl_new(wr_svr_t* server) {
+  LOG_FUNCTION
+  wr_ctl_t* ctl = wr_malloc(wr_ctl_t);
+  if(ctl == NULL) {
+    LOG_DEBUG(SEVERE, "Error Control object allocation failed. Returning ... ");
+    return NULL;
+  }
+  ctl->svr = server;
+  ctl->w_read.data = ctl->w_write.data = ctl;
+  ctl->w_read.active = 0;
+  ctl->wkr = NULL;
+  ctl->app = NULL;
+  ctl->ctl_nbytes = 0;
+  ctl->fd = -1;
+  ctl->destroy_scgi = TRUE;
+  return ctl;
+}
+
 /**
  * This function accept connection from worker.
  * We need to change it to keep detail of each worker. Currently it is maintaining only latest worker connected.
  * Its prone produce bug.
  */
-static void wr_ctl_accept_cb(struct ev_loop *loop, struct ev_io *w, int revents) {
+void wr_ctl_accept_cb(struct ev_loop *loop, struct ev_io *w, int revents) {
   LOG_FUNCTION
   wr_svr_t* server = (wr_svr_t*) w->data;
   wr_ctl_t* ctl = NULL;
@@ -302,7 +357,7 @@ static void wr_ctl_accept_cb(struct ev_loop *loop, struct ev_io *w, int revents)
   }
 
   int client_fd;
-  if(server->ctl->uds) {
+  if(Config->Server.flag & SERVER_UDS_SUPPORT) {
     //Accept connection from Internet socket
     struct sockaddr_in client_addr;
     socklen_t client_len = sizeof(client_addr);
@@ -337,14 +392,13 @@ static void wr_ctl_accept_cb(struct ev_loop *loop, struct ev_io *w, int revents)
   LOG_INFO("Successfully connected with controller client. Read watcher starting...");
 
   //Start control read watcher
-  ctl->w_read.data = ctl;
-
-  ev_io_init(&(ctl->w_read),wr_ctl_msg_read_cb,client_fd,EV_READ);
+  ev_io_init(&(ctl->w_read),wr_ctl_msg_read_cb,ctl->fd, EV_READ);
+  ev_io_init(&(ctl->w_write),wr_ctl_msg_write_cb,ctl->fd, EV_WRITE);
   ev_io_start(loop,&(ctl->w_read));
 }
 
 /** Start listening for Workers connect request on Internet socket */
-static inline int wr_ctl_init_on_inet_sock(wr_svr_t *server) {
+int wr_ctl_init_on_inet_sock(wr_svr_t *server) {
   LOG_FUNCTION
   struct sockaddr_in addr;
   int len;
@@ -380,7 +434,7 @@ static inline int wr_ctl_init_on_inet_sock(wr_svr_t *server) {
     return -1;
   }
   server->ctl->port = ntohs(addr.sin_port);
-  FILE *tmp_sock = fopen(WR_TMP_SOCK_FILE,"w");
+  FILE *tmp_sock = fopen(Config->Server.File.sock.str,"w");
   if(tmp_sock) {
     fprintf(tmp_sock,"%d", server->ctl->port);
     fclose(tmp_sock);
@@ -389,7 +443,7 @@ static inline int wr_ctl_init_on_inet_sock(wr_svr_t *server) {
   //determine port to which controller_fd bound
   LOG_DEBUG(4,"Initializing controller on port %d, FD is=%d",server->ctl->port,server->ctl->fd);
 
-  if(listen(server->ctl->fd, WR_REQ_CONN_POOL) < 0 )// TODO: Accept connections only from workers
+  if(listen(server->ctl->fd, Config->Request.conn_pool) < 0 )// TODO: Accept connections only from workers
   {
     LOG_ERROR(SEVERE,"listen error on port=%d:%s",server->ctl->port,strerror(errno));
     close_fd(server->ctl->fd);
@@ -399,10 +453,10 @@ static inline int wr_ctl_init_on_inet_sock(wr_svr_t *server) {
 }
 
 /** Start listening for Workers connect request on UNIX domain socket */
-static inline int wr_ctl_init_on_uds(wr_svr_t *server) {
+int wr_ctl_init_on_uds(wr_svr_t *server) {
   LOG_FUNCTION
   struct sockaddr_un addr;
-  char sock_path[WR_LONG_STR_LEN];
+  char sock_path[STR_SIZE128];
 
   if ((server->ctl->fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
     LOG_ERROR(SEVERE,"Socket opening error:%s",strerror(errno));
@@ -419,12 +473,12 @@ static inline int wr_ctl_init_on_uds(wr_svr_t *server) {
 
   /* Preparing unique controller socket path*/
   pid_t pid=getpid();
-  sprintf(sock_path,"%s_%d",WR_CTL_SOCK_PATH,pid);
+  sprintf(sock_path,"%s_%d",Config->Server.Control.sock_path.str,pid);
   size_t len = strlen(sock_path);
 
   wr_string_new(server->ctl->sock_path, sock_path, len);
 
-  FILE *tmp_sock = fopen(WR_TMP_SOCK_FILE,"w");
+  FILE *tmp_sock = fopen(Config->Server.File.sock.str,"w");
   if(tmp_sock) {
     fprintf(tmp_sock,"%s", server->ctl->sock_path.str);
     fclose(tmp_sock);
@@ -447,7 +501,7 @@ static inline int wr_ctl_init_on_uds(wr_svr_t *server) {
     return -1;
   }
   LOG_DEBUG(4,"Getting ready to listen on socket path=%s",addr.sun_path);
-  if(listen(server->ctl->fd, WR_CTL_CONN_POOL) < 0) // TODO: Accept connections only from workers
+  if(listen(server->ctl->fd, Config->Server.Control.conn_pool) < 0) // TODO: Accept connections only from workers
   {
     LOG_ERROR(SEVERE,"listen() error on socket path=%s:%s",server->ctl->sock_path.str,strerror(errno));
     close_fd(server->ctl->fd);
@@ -460,22 +514,6 @@ static inline int wr_ctl_init_on_uds(wr_svr_t *server) {
 /********************************************************
  *     Control Function Definition                *
  ********************************************************/
-wr_ctl_t* wr_ctl_new(wr_svr_t* server) {
-  LOG_FUNCTION
-  wr_ctl_t* ctl = wr_malloc(wr_ctl_t);
-  if(ctl == NULL) {
-    LOG_DEBUG(SEVERE, "Error Control object allocation failed. Returning ... ");
-    return NULL;
-  }
-  ctl->svr = server;
-  ctl->w_read.active = 0;
-  ctl->wkr = NULL;
-  ctl->app = NULL;
-  ctl->ctl_nbytes = 0;
-  //ctl->msg_size = 0;
-  ctl->fd = -1;
-  return ctl;
-}
 
 void wr_ctl_free(wr_ctl_t* ctl) {
   LOG_FUNCTION
@@ -490,31 +528,10 @@ void wr_ctl_free(wr_ctl_t* ctl) {
       ev_io_stop(ctl->svr->ebb_svr.loop, &ctl->w_read);
     }
     if(ctl->wkr) {
-      wr_wkr_t *worker = ctl->wkr;
-      // Need to stop ev_io so that all the pending call related to worker turns out to void
-      if(worker->watcher.active != 0) {
-        ev_io_stop(worker->ctl->svr->ebb_svr.loop, &worker->watcher);
-      }
-      worker->ctl = NULL;
-      //if head is waiting for PING reply, and worker got killed inbetween, we need to stop time watcher
-      ev_timer_stop(worker->loop, &worker->t_wait);
-      //wr_recreate_worker(worker);
-      wr_req_t * req = worker->req;
-      //we are killing worker in mid of some processing, render 500 to corresponding req
-      if(req) {
-        LOG_ERROR(SEVERE,"Worker %d Hangup. Killing it. Req id = %d, Connection id = %d, Request Path is %s",
-                  worker->id,
-                  req->id, req->conn->id, req->req_uri.str);
-        req->resp_buf_len = 0;
-        wr_conn_err_resp(req->conn, WR_HTTP_STATUS_500);
-
-      }
-      wr_app_t *app = worker->app;
-      LOG_ERROR(SEVERE,"wr_ctl_free: Remove worker with pid %d.", ctl->wkr->pid);
-      if(ctl->wkr->state & WR_WKR_ACTIVE)
-        wr_wkr_remove(ctl->wkr, 1);
-      else
-        wr_wkr_free(ctl->wkr);
+      wr_app_t *app = ctl->wkr->app;
+      ctl->wkr->state = WKR_STATE_ERROR;
+      ctl->wkr->ctl = NULL;
+      wr_wkr_free(ctl->wkr);
 
       //create new worker if required
       if(app && app->state == WR_APP_ACTIVE){
@@ -534,9 +551,8 @@ int wr_ctl_init(wr_svr_t* server) {
   int rv;
 
   /* Start listening for workers control */
-  server->ctl->uds = server->conf->uds;
-
-  if(server->ctl->uds) {
+  
+  if(Config->Server.flag & SERVER_UDS_SUPPORT) {
     // Start listening on UNIX domain socket
     rv = wr_ctl_init_on_uds(server);
     if(rv < 0) {
@@ -577,8 +593,7 @@ wr_svr_ctl_t* wr_svr_ctl_new() {
   ctl->port = -1;
   wr_string_null(ctl->sock_path);
   ctl->w_req = NULL;
-  ctl->uds = -1;
-
+  
   return ctl;
 }
 
@@ -600,7 +615,9 @@ void wr_svr_ctl_free(wr_svr_ctl_t *ctl) {
 void wr_ctl_resp_write(wr_ctl_t *ctl) {
   LOG_FUNCTION
   if(ctl->scgi) {
-    scgi_build(ctl->scgi);
+    if(ctl->destroy_scgi == TRUE){
+      scgi_build(ctl->scgi);
+    }
     LOG_DEBUG(DEBUG,"sending control signal response");
     ev_io_start(ctl->svr->ebb_svr.loop, (&ctl->w_write));
   }

data/src/head/wr_controller.h

@@ -42,8 +42,10 @@ typedef enum{
   WR_CTL_MSG_APPLICATION_ADD,
   WR_CTL_MSG_APPLICATION_REMOVE,
   WR_CTL_MSG_WORKER_ADD,
-  WR_CTL_MSG_WORKER_REMOVE,
+  WR_CTL_MSG_WORKER_ADD_ERROR,
+  WR_CTL_MSG_WORKER_REMOVE,  
   WR_CTL_MSG_WORKER_PING,
+  WR_CTL_MSG_WORKER_CONF_REQ,
   WR_CTL_MSG_TYPE_ERROR
 }wr_ctl_msg_type_t;
 
@@ -65,16 +67,15 @@ struct wr_ctl_s {
   wr_svr_t           *svr;    /* Pointer to wr_server_t */
   wr_wkr_t           *wkr;    /* Pointer to wr_processsor_t */
   wr_app_t           *app;    /* Pointer to wr_app_t, would be used at time of freeing control object */
-  char               msg[WR_MSG_SIZE];
+  char               msg[STR_SIZE1KB];
   size_t             ctl_nbytes;
   wr_ctl_msg_type_t  type;
 
   ev_io              w_write;
-  scgi_t            *scgi;
+  scgi_t             *scgi;
+  wr_u_short         destroy_scgi;
   //size_t             resp_nbytes;
 };
-/** Create new control structure */
-wr_ctl_t* wr_ctl_new(wr_svr_t*);
 /** Destroy control */
 void wr_ctl_free(wr_ctl_t*);
 /** Initialize controller */
@@ -85,7 +86,6 @@ void wr_ctl_resp_write(wr_ctl_t*);
 /** Server Control structure */
 struct wr_svr_ctl_s {
   int       fd;        /**< Control socket fd */
-  int       uds;      /**< Flag for Unix Domain Socket */
   int       port;      /**< Control port */
   wr_str_t  sock_path;    /**< Control socket path */
   ev_io*     w_req;      /**< Accept worker connect request watcher */

data/src/head/wr_main.c

@@ -23,14 +23,15 @@
 #include <execinfo.h>
 
 // wr_server object
-static wr_svr_t *server;
+static wr_svr_t *server = NULL;
+config_t        *Config = NULL;
 
 /** Cleanup and destroy the Server */
-static inline void cleanup(wr_svr_t *server) {
+void cleanup(wr_svr_t *server) {
   LOG_FUNCTION
 
   // Delete 'webroar.sock' file
-  remove(WR_TMP_SOCK_FILE);
+  remove(Config->Server.File.sock.str);
 
   // Stop event loop
   ev_unloop(server->ebb_svr.loop, EVUNLOOP_ALL);
@@ -39,7 +40,8 @@ static inline void cleanup(wr_svr_t *server) {
   wr_svr_free(server);
 
   // Delete 'webroar.pid' file
-  remove(WR_PID_FILE);
+  remove(Config->Server.File.pid.str);
+  wr_server_config_free(Config);
   LOG_INFO("Shutting down network server. No more request can be served");
 
   // Destroy logger object
@@ -47,7 +49,7 @@ static inline void cleanup(wr_svr_t *server) {
 }
 
 /** Daemonize the process */
-static inline void daemonize() {
+void daemonize() {
   LOG_FUNCTION
   /* Our process ID and Session ID */
   pid_t pid, sid;
@@ -90,9 +92,9 @@ static inline void daemonize() {
   LOG_DEBUG(DEBUG,"j=%d",j);
 
   //Log current pid
-  char str[WR_SHORT_STR_LEN];
+  char str[STR_SIZE32];
 
-  int pid_FD=open(WR_PID_FILE,O_RDWR|O_CREAT,0640);
+  int pid_FD=open(Config->Server.File.pid.str,O_RDWR|O_CREAT,0640);
   LOG_DEBUG(4,"FD for PID is %i",pid_FD);
 
   if (pid_FD<0) {
@@ -130,10 +132,10 @@ void sigproc() {
 
 /** Handle segmentation fault */
 void crash_handler(int sig) {
-  void *array[WR_STACKTRACE_SIZE];
+  void *array[Config->Server.stack_trace];
   size_t size;
   char **bt_symbols;
-  char bt_string[WR_STACKTRACE_SIZE * WR_LONG_STR_LEN * 2];
+  char bt_string[Config->Server.stack_trace * STR_SIZE256];
   int i;
   sigset_t unblock_sig;
   
@@ -185,7 +187,7 @@ void crash_handler(int sig) {
   sleep(5);
     
   // get void*'s for all entries on the stack
-  size = backtrace(array, WR_STACKTRACE_SIZE);
+  size = backtrace(array, Config->Server.stack_trace);
   bt_symbols = backtrace_symbols(array, size);
   strcpy(bt_string, "\n");
   for(i = 0; i < size; i++) {
@@ -202,33 +204,36 @@ void crash_handler(int sig) {
 
 int main(int argc, char *argv[]) {
   int retval = 0;
-  wr_conf_t *conf=NULL;
-  char *WR_ROOT = argv[1];
-
-  //Initialize logger
-  if(initialize_logger(WR_LOG_FILE, WR_SERVER, WR_VERSION) == 0) {
-    LOG_DEBUG(DEBUG,"Logging started in %s file",WR_LOG_FILE);
+  
+  Config = wr_server_config_init(argv[1]);
+  
+  if(Config == NULL) return -1;
+  
+    //Initialize logger
+  if(initialize_logger(Config->Server.File.log.str, Config->Server.name.str, Config->Server.version.str) == 0) {
+    LOG_DEBUG(DEBUG,"Logging started in %s file",Config->Server.File.log.str);
   } else {
     printf("Logger initialization failed. Please make sure you have write permission on '/var/log/webroar' directory.");
   }
-
+  
   //Allocate and initialize configuration structure
-  conf = wr_conf_read(WR_ROOT);
-  if(conf == NULL ) {
+  if(wr_conf_read() == FALSE ) {
     LOG_ERROR(FATAL,"Configuration reading failed.");
     printf("Server not started.\nProblem with reading the configuration file. Kindly refer the log files for details.\n");
+    wr_server_config_free(Config);
     return -1;
   }
+
 #ifdef L_DEBUG
   set_log_severity(DEBUG);
 #else
-  set_log_severity(conf->server->log_level);
+  set_log_severity(Config->Server.log_level);
 #endif
   // Add Admin Panel
-  wr_conf_admin_panel_add(conf);
+  wr_conf_admin_panel_add();
   
   // Add staic file server
-  wr_conf_static_server_add(conf);
+  wr_conf_static_server_add();
 
   //TODO: Windows Portability?
   signal(SIGINT, sigproc);
@@ -243,13 +248,14 @@ int main(int argc, char *argv[]) {
   
 
   // Initialize and start the Server to accept requests
-  retval = wr_svr_init(&server, conf);
+  retval = wr_svr_init(&server);
   if(retval<0) {
     LOG_ERROR(FATAL,"Initialization of network server failed.");
     printf("Server not started. Kindly refer the log files for details.\n");
+    wr_server_config_free(Config);
     return retval;
   }
-  LOG_INFO("Network server successfully initialized on port %d",server->conf->server->port);
+  LOG_INFO("Network server successfully initialized on port %d",Config->Server.port);
 
   // Set keep alive flag
   server->is_running = 1;
@@ -260,6 +266,7 @@ int main(int argc, char *argv[]) {
     LOG_ERROR(FATAL,"Controller Initialization failed.");
     printf("Server not started. Kindly refer the log files for details.\n");
     wr_svr_free(server);
+    wr_server_config_free(Config);
     return retval;
   }
   LOG_INFO("Controller initialized");