webroar 0.3.1 → 0.4.0

data/src/head/wr_worker.h

@@ -25,24 +25,39 @@
 
 /** Worker states */
 typedef enum{
-  WR_WKR_CLEAR = 0,
-  WR_WKR_ACTIVE = 1,    //worker is active to service an application
-  WR_WKR_ERROR = 2,
-  WR_WKR_CONNECTING = 4,
-  WR_WKR_REMOVING = 8,
-  WR_WKR_DISCONNECT = 16,
-  WR_WKR_PING_SENT = 32,    //Sent PING when worker found idle for certain time
-  WR_WKR_PING_REPLIED = 64,    //PING replied, indicating worker is live
-  WR_WKR_HANG = 128,
-  WR_WKR_OLD = 256
+  WKR_STATE_CONNECTING = 100,
+  WKR_STATE_ACTIVE = 200,
+  WKR_STATE_INACTIVE = 201,
+  WKR_STATE_PINGING = 202,
+  WKR_STATE_EXPIRED = 203,
+  WKR_STATE_ERROR = 401,
+  WKR_STATE_TIMEDOUT = 402,
+  WKR_STATE_ERROR_ACK = 403,
+  WKR_STATE_HANGUP = 404,
+  WKR_STATE_DISCONNECTING = 501
 }wr_wkr_state_t;
 
+/** Worker actions */
+typedef enum{
+  WKR_ACTION_ADD,
+  WKR_ACTION_ADD_TIMEOUT,
+  WKR_ACTION_ADD_ERROR,
+  WKR_ACTION_REMOVE,
+  WKR_ACTION_PING,
+  WKR_ACTION_PING_TIMEOUT,
+  WKR_ACTION_PING_REPLAY,
+  WKR_ACTION_REQ_PROCESSED,
+  WKR_ACTION_REQ_PROCESSING,
+  WKR_ACTION_ERROR
+}wr_wkr_action_t;
+
+
 /** Worker structure */
 struct wr_wkr_s {
-  wr_u_short    id;    /**< Worker index/id */
-  int        state;      /**< Worker state */
-  wr_u_short    pid;    /**< Worker id */
-  struct ev_loop   *loop;
+  wr_u_short      id;    /**< Worker index/id */
+  wr_wkr_state_t  state;      /**< Worker state */
+  wr_u_short      pid;    /**< Worker id */
+  struct ev_loop  *loop;
 
   int         fd;      /**< Socket fd */
   ev_io       watcher;  /**< watcher */
@@ -50,29 +65,27 @@ struct wr_wkr_s {
   ev_timer     t_wait;   /**< idle watcher for worker */
   wr_u_short   trials_done;  /**< Number of time we want to send PING before killing */
 
-  wr_ctl_t      *ctl;      /**< Pointer to control structure */
+  wr_ctl_t    *ctl;      /**< Pointer to control structure */
   wr_req_t    *req;
   wr_app_t    *app;  /**< Application pointer*/
 };
 
-/** Create new worker */
-wr_wkr_t* wr_wkr_new(wr_ctl_t*);
 /** Destroy worker */
 void wr_wkr_free(wr_wkr_t*);
 /** Remove worker */
 int wr_wkr_remove(wr_wkr_t*, int);
 /** Create the Worker */
-int wr_wkr_create(wr_svr_t*, wr_app_conf_t*);
+int wr_wkr_create(wr_svr_t*, config_application_list_t*);
 /** Dispatch the request to Worker process */
 void wr_wkr_dispatch_req(wr_req_t*);
-/** Handle connect request from Worker */
-//int wr_wkr_connect(wr_ctl_msg_t*,  wr_ctl_t*);
 /** This would get called when worker reply to PING */
 //void wr_wkr_ping_reply(wr_wkr_t*);
 /** Worker add callback */
 void wr_wkr_add_cb(wr_ctl_t*, const wr_ctl_msg_t*);
 /** Worker remove callback */
 void wr_wkr_remove_cb(wr_ctl_t*, const wr_ctl_msg_t*);
+/** Worker Add error callback */
+void wr_wkr_add_error_cb(wr_ctl_t*, const wr_ctl_msg_t*);
 /** Worker ping callback */
 void wr_wkr_ping_cb(wr_ctl_t*, const wr_ctl_msg_t*);
 

data/src/helper/wr_config.c

@@ -0,0 +1,316 @@
+/* WebROaR - Ruby Application Server - http://webroar.in/
+ * Copyright (C) 2009  Goonj LLC
+ *
+ * This file is part of WebROaR.
+ *
+ * WebROaR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * WebROaR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with WebROaR.  If not, see <http://www.gnu.org/licenses/>.
+ */
+ 
+ /*****************************************************************
+ *     Set Configuration parameters
+ *****************************************************************/
+ 
+#include <wr_config.h>
+#include <sys/socket.h>
+
+#define SERVER_NAME       "WebROaR"
+#define SERVER_VERSION    "0.4.0"
+ 
+#define FILE_PATH         "FILE_PATH"
+#define CONN_ID           "CONNECTION_ID"
+#define REQ_ID            "REQ_ID"
+#define RESP_CODE         "RESP_CODE"
+#define RESP_CONTENT_LEN  "RESP_CONTENT_LEN"
+
+int wr_config_server_init(config_t *Config, const char* root_path){
+  wr_string_new(Config->Server.Dir.root, root_path, strlen(root_path));
+
+  Config->Server.Control.conn_pool = 5;
+  wr_string_new(Config->Server.Control.sock_path, "/tmp/webroar_controller_sock", strlen("/tmp/webroar_controller_sock"));
+  
+  wr_string_new(Config->Server.File.sock, "/tmp/webroar.sock", strlen("/tmp/webroar.sock"));
+  wr_string_new(Config->Server.File.pid, "/var/run/webroar.pid", strlen("/var/run/webroar.pid"));
+  wr_string_new(Config->Server.File.high_rss, "/var/run/high_rss.pid", strlen("/var/run/high_rss.pid"));
+  wr_string_new(Config->Server.File.log, "webroar.log", strlen("webroar.log"));  
+  wr_string_dump(Config->Server.File.config, Config->Server.Dir.root);
+  wr_string_append(Config->Server.File.config, "/conf/config.yml", strlen("/conf/config.yml"));
+  wr_string_dump(Config->Server.File.internal_config, Config->Server.Dir.root);
+  wr_string_append(Config->Server.File.internal_config, "/conf/server_internal_config.yml", strlen("/conf/server_internal_config.yml"));
+  wr_string_dump(Config->Server.File.worker_bin, Config->Server.Dir.root);
+  wr_string_append(Config->Server.File.worker_bin, "/bin/webroar-worker", strlen("/bin/webroar-worker"));
+
+  wr_string_dump(Config->Server.Dir.admin_panel, Config->Server.Dir.root);
+  wr_string_append(Config->Server.Dir.admin_panel, "/admin_panel", strlen("/admin_panel"));
+  
+  Config->Server.Worker.max         = 20;
+  Config->Server.Worker.pending     = 10;
+  Config->Server.Worker.add_trials  = 3;
+  Config->Server.Worker.add_wait    = 1800;
+  Config->Server.Worker.add_timeout = 25;
+  Config->Server.Worker.kill_timeout= 10;
+  Config->Server.Worker.idle_time   = 60;
+  Config->Server.Worker.ping_timeout= 15;
+  Config->Server.Worker.ping_trials = 2;
+
+#ifdef HAVE_GNUTLS
+  Config->Server.SSL.port  = 443;
+  wr_string_null(Config->Server.SSL.certificate);
+  wr_string_null(Config->Server.SSL.key);
+#endif
+  
+  wr_string_new(Config->Server.name, SERVER_NAME, strlen(SERVER_NAME));
+  wr_string_new(Config->Server.version, SERVER_VERSION, strlen(SERVER_VERSION));
+  
+  Config->Server.port            = 3000;
+  Config->Server.log_level       = SEVERE;  
+  // using 'AF_UNIX' macro to identify UDS support.  
+#ifdef AF_UNIX
+  Config->Server.flag            = SERVER_UDS_SUPPORT;
+#else
+  Config->Server.flag            = 0;
+#endif
+  Config->Server.flag            |= SERVER_KEEP_ALIVE;
+  Config->Server.stack_trace     = 50;
+
+  return TRUE;
+}
+
+int wr_config_application_init(config_t *Config){
+  Config->Application.Default.max_workers = 4;
+  Config->Application.Default.min_workers = 8;
+  wr_string_new(Config->Application.Default.env, "production", strlen("production"));
+    
+  wr_string_new(Config->Application.Admin_panel.name, "Admin Panel", strlen("Admin Panel"));
+  wr_string_new(Config->Application.Admin_panel.base_uri, "/admin-panel", strlen("/admin-panel"));
+  
+  wr_string_new(Config->Application.Static_server.name, "static-worker", strlen("static-worker"));
+  Config->Application.Static_server.min_workers = 4;
+  Config->Application.Static_server.max_workers = 8;
+  
+  wr_string_new(Config->Application.analytics_on, "enabled", strlen("enabled"));
+  Config->Application.msg_queue_size  = 2048;
+  Config->Application.max_req_ratio   = 1;
+  Config->Application.min_req_ratio   = 3;
+  Config->Application.high_load       = 2;
+  Config->Application.low_load        = 600;
+  Config->Application.max_hosts       = 16;
+  
+  Config->Application.list = NULL;
+  
+  return TRUE;
+}
+
+int wr_config_worker_init(config_t *Config, const char *root_path){
+  
+  wr_u_short root_path_len = strlen(root_path);
+  
+  wr_string_new(Config->Worker.File.config, root_path, root_path_len);
+  wr_string_append(Config->Worker.File.config, "/conf/config.yml", strlen("/conf/config.yml"));
+  wr_string_new(Config->Worker.File.mime_type, root_path, root_path_len);
+  wr_string_append(Config->Worker.File.mime_type, "/conf/mime_type.yml", strlen("/conf/mime_type.yml"));
+  wr_string_new(Config->Worker.File.internal_config, root_path, root_path_len);
+  wr_string_append(Config->Worker.File.internal_config, "/conf/server_internal_config.yml", strlen("/conf/server_internal_config.yml"));
+  wr_string_new(Config->Worker.File.app_loader, root_path, root_path_len);
+  wr_string_append(Config->Worker.File.app_loader, "/src/ruby_lib/webroar_app_loader.rb", strlen("/src/ruby_lib/webroar_app_loader.rb"));
+  
+  wr_string_new(Config->Worker.Header.file_path, FILE_PATH, strlen(FILE_PATH));
+  wr_string_new(Config->Worker.Header.conn_id, CONN_ID, strlen(CONN_ID));
+  wr_string_new(Config->Worker.Header.req_id, REQ_ID, strlen(REQ_ID));
+  wr_string_new(Config->Worker.Header.resp_code, RESP_CODE, strlen(RESP_CODE));
+  wr_string_new(Config->Worker.Header.resp_content_len, RESP_CONTENT_LEN, strlen(RESP_CONTENT_LEN));
+  
+  wr_string_new(Config->Worker.Server.name, SERVER_NAME, strlen(SERVER_NAME));
+  wr_string_new(Config->Worker.Server.version, SERVER_VERSION, strlen(SERVER_VERSION));
+  
+  wr_string_new(Config->Worker.static_server, "static-worker", strlen("static-worker"));
+  wr_string_new(Config->Worker.sock_path, "/tmp/webroar_worker_sock", strlen("/tmp/webroar_worker_sock"));
+  Config->Worker.stack_tace    = 50;
+  Config->Worker.max_body_size = 65536;
+  
+  Config->Worker.Compress.lower_limit = 10240;   //10KB
+  Config->Worker.Compress.upper_limit = 1024*1024; //1MB
+  
+  return TRUE;
+}
+
+int wr_config_request_init(config_t *Config){
+  Config->Request.prefix_hash     = 5381;
+  Config->Request.conn_pool       = 10;
+  Config->Request.max_body_size   = 65536;
+  Config->Request.max_uri_size    = 12288;
+  Config->Request.max_path_size   = 1024;
+  Config->Request.max_frag_size   = 1024;
+  Config->Request.max_query_size  = 1024;
+  Config->Request.max_field_size  = 256;
+  Config->Request.max_value_size  = 81920;
+  Config->Request.max_header_size = 112640;
+  Config->Request.max_header_count= 40;
+  
+#ifdef L_DEBUG
+  wr_string_new(Config->Request.Header.conn_id, CONN_ID, strlen(CONN_ID));
+  wr_string_new(Config->Request.Header.req_id, REQ_ID, strlen(REQ_ID));
+#endif
+  wr_string_new(Config->Request.Header.file_path, FILE_PATH, strlen(FILE_PATH));
+  wr_string_new(Config->Request.Header.resp_code, RESP_CODE, strlen(RESP_CODE));
+  wr_string_new(Config->Request.Header.resp_content_len, RESP_CONTENT_LEN, strlen(RESP_CONTENT_LEN));
+  
+  return TRUE;
+}
+ 
+config_t* wr_worker_config_init(const char* root_path){  
+  config_t *Config;
+  if(root_path == NULL) return NULL;
+  Config = wr_malloc(config_t);
+  
+  if(Config){
+    if(!wr_config_worker_init(Config, root_path)){
+      free(Config);
+      return NULL;      
+    }    
+  }
+  
+  return Config;
+}
+
+config_t* wr_server_config_init(const char *root_path){  
+  config_t *Config;
+  wr_u_short retval = TRUE;
+  
+  if(root_path == NULL) return NULL;
+  Config = wr_malloc(config_t);
+  
+
+  if(Config){
+    if(!wr_config_server_init(Config, root_path)) retval = FALSE;
+    if(!wr_config_request_init(Config))           retval = FALSE;
+    if(! wr_config_application_init(Config))      retval = FALSE;
+  }
+  
+  if(retval == FALSE){
+    free(Config);
+    return NULL;
+  }
+  
+  return Config;
+}
+
+void wr_config_server_free(config_t *Config){
+  wr_string_free(Config->Server.Control.sock_path);
+  wr_string_free(Config->Server.File.sock);
+  wr_string_free(Config->Server.File.pid);
+  wr_string_free(Config->Server.File.high_rss);
+  wr_string_free(Config->Server.File.log);
+  wr_string_free(Config->Server.File.config);
+  wr_string_free(Config->Server.File.internal_config);
+  wr_string_free(Config->Server.File.worker_bin);
+  wr_string_free(Config->Server.Dir.admin_panel);
+  wr_string_free(Config->Server.Dir.root);
+#ifdef HAVE_GNUTLS
+  wr_string_free(Config->Server.SSL.certificate);
+  wr_string_free(Config->Server.SSL.key);
+#endif
+  wr_string_free(Config->Server.name);
+  wr_string_free(Config->Server.version);
+}
+
+void wr_config_request_free(config_t *Config){
+#ifdef L_DEBUG
+  wr_string_free(Config->Request.Header.conn_id);
+  wr_string_free(Config->Request.Header.req_id);
+#endif
+  wr_string_free(Config->Request.Header.file_path);
+  wr_string_free(Config->Request.Header.resp_code);
+  wr_string_free(Config->Request.Header.resp_content_len);
+}
+
+void wr_config_application_free(config_t *Config){
+  wr_string_free(Config->Application.Default.env);
+  wr_string_free(Config->Application.Admin_panel.name);
+  wr_string_free(Config->Application.Admin_panel.base_uri);
+  wr_string_free(Config->Application.Static_server.name);
+  wr_string_free(Config->Application.analytics_on);
+  wr_application_list_free(Config->Application.list);
+}
+
+void wr_config_worker_free(config_t *Config){
+  wr_string_free(Config->Worker.File.config);
+  wr_string_free(Config->Worker.File.mime_type);
+  wr_string_free(Config->Worker.File.internal_config);
+  wr_string_free(Config->Worker.File.app_loader);
+  wr_string_free(Config->Worker.Header.file_path);
+  wr_string_free(Config->Worker.Header.conn_id);
+  wr_string_free(Config->Worker.Header.req_id);
+  wr_string_free(Config->Worker.Header.resp_code);
+  wr_string_free(Config->Worker.Header.resp_content_len);
+  wr_string_free(Config->Worker.Server.name);
+  wr_string_free(Config->Worker.Server.version);
+  wr_string_free(Config->Worker.static_server);
+  wr_string_free(Config->Worker.sock_path);
+}
+
+void wr_host_list_free(config_host_list_t *list) {
+  config_host_list_t *next;
+  while(list) {
+    next = list->next;
+    wr_string_free(list->name);
+    free(list);
+    list = next;
+  }
+}
+
+/** Destroy application configuration */
+void wr_application_list_free(config_application_list_t* list){
+  LOG_FUNCTION
+  config_application_list_t* next;
+  
+  // Iterate applications and destroy each application
+  while(list) {
+    next = list->next;
+    wr_string_free(list->name);
+    wr_string_free(list->baseuri);
+    wr_string_free(list->path);
+    scgi_free(list->scgi);
+    wr_host_list_free(list->host_name_list);
+    wr_application_list_free(list->new);
+    free(list);
+    list = next;
+  }
+}
+
+void wr_server_config_free(config_t *Config){
+  if(Config == NULL) return;
+  wr_config_server_free(Config);
+  wr_config_request_free(Config);
+  wr_config_application_free(Config);
+  free(Config);
+}
+
+void wr_worker_config_free(config_t *Config){
+  if(Config == NULL) return;
+  wr_config_worker_free(Config);
+  free(Config);
+}
+
+void wr_set_numeric_value(node_t *root, const char *path, void *value, wr_u_short flag){
+  char *str = wr_validate_string(get_node_value(root, path));
+  long *lvalue = (long*) value;
+  if(str) {
+    wr_u_long val = atoi(str);
+    if(val > 0){
+      *lvalue = val;
+    }else if(flag && strcmp(str,"0") == 0){
+      *lvalue = 0;
+    }
+  }  
+}

data/src/helper/wr_config.h

@@ -0,0 +1,235 @@
+/* WebROaR - Ruby Application Server - http://webroar.in/
+ * Copyright (C) 2009  Goonj LLC
+ *
+ * This file is part of WebROaR.
+ *
+ * WebROaR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * WebROaR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with WebROaR.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef WR_CONFIG_H_
+#define WR_CONFIG_H_
+
+#include<wr_string.h>
+#include<wr_macro.h>
+#include<wr_logger.h>
+#include<wr_scgi.h>
+#include<wr_yaml_parser.h>
+
+#define TRUE  1
+#define FALSE 0
+
+#define STR_SIZE16    16
+#define STR_SIZE32    32
+#define STR_SIZE64    64
+#define STR_SIZE128   128
+#define STR_SIZE256   256
+#define STR_SIZE512   512
+#define STR_SIZE1KB   1024
+#define STR_SIZE10KB  10240
+
+#define SERVER_ACCESS_LOG   1
+#define SERVER_SSL_SUPPORT  2
+#define SERVER_UDS_SUPPORT  4
+#define SERVER_KEEP_ALIVE   8
+
+typedef struct config_server_s{
+  
+  struct control{
+    wr_str_t    sock_path;
+    wr_u_short  conn_pool;
+  }Control;
+  
+  struct file{
+    wr_str_t    log;
+    wr_str_t    pid;
+    wr_str_t    config;
+    wr_str_t    sock;
+    wr_str_t    high_rss;
+    wr_str_t    worker_bin;
+    wr_str_t    internal_config;
+  }File;
+  
+  struct dir{
+    wr_str_t    admin_panel;
+    wr_str_t    root;
+  }Dir;
+  
+  struct worker{
+    wr_u_short  max;
+    wr_u_short  pending;
+    wr_u_short  add_trials;
+    wr_u_short  add_wait;
+    wr_u_short  add_timeout;
+    wr_u_short  kill_timeout;
+    wr_u_short  idle_time;
+    wr_u_short  ping_timeout;
+    wr_u_short  ping_trials;
+  }Worker;
+  
+#ifdef HAVE_GNUTLS
+  struct ssl{
+    wr_u_int    port;
+    wr_str_t    certificate;
+    wr_str_t    key;
+  }SSL;
+#endif
+  
+  wr_str_t    name;
+  wr_str_t    version;
+  wr_u_int    port;
+
+  LOG_SEVERITY log_level;
+  wr_u_short  flag; // To store different bit level flags like access_log, ssl_support, uds support
+  wr_u_short  stack_trace;
+  
+}config_server_t;
+
+
+typedef struct config_request_s{
+  wr_u_short    prefix_hash;
+  wr_u_short    conn_pool;
+  wr_u_long     max_body_size;
+  wr_u_int      max_uri_size;
+  wr_u_short    max_path_size;
+  wr_u_short    max_frag_size;
+  wr_u_short    max_query_size;
+  wr_u_short    max_field_size;
+  wr_u_long     max_value_size;
+  wr_u_long     max_header_size;
+  wr_u_short    max_header_count;
+  
+  struct header{
+  #ifdef L_DEBUG
+    wr_str_t      conn_id;
+    wr_str_t      req_id;
+  #endif
+    wr_str_t      file_path;
+    wr_str_t      resp_code;
+    wr_str_t      resp_content_len;
+  }Header;
+  
+}config_request_t;
+
+typedef enum config_host_type_s{
+  HOST_TPE_INVALID                 = 0,
+  HOST_TYPE_STATIC                 = 1,
+  HOST_TYPE_WILDCARD_IN_START      = 2,
+  HOST_TYPE_WILDCARD_IN_END        = 4,
+  HOST_TYPE_WILDCARD_IN_START_END  = 8,
+}config_host_type_t;
+
+typedef struct config_host_list_s  config_host_list_t;
+struct config_host_list_s {
+  wr_str_t            name;
+  config_host_type_t  type;
+  config_host_list_t  *next;
+};
+
+typedef struct config_application_list_s config_application_list_t;
+struct config_application_list_s {
+  wr_str_t        name;       /**< Application name */
+  wr_str_t        baseuri;    /**< Application baseuri */
+  wr_str_t        path;    /**< Application path */
+  wr_u_short      min_worker; /**< Minimum number of workers required */
+  wr_u_short      max_worker; /**< Maximum number of workers */
+  LOG_SEVERITY    log_level;  /**< Logging level */
+  
+  scgi_t          *scgi;
+  config_host_list_t          *host_name_list;
+  config_application_list_t   *new;
+  config_application_list_t   *next;
+};
+
+
+typedef struct config_application_s{
+  
+  struct application_default{
+    wr_u_short  max_workers;
+    wr_u_short  min_workers;
+    wr_str_t    env;
+  }Default;
+  
+  struct admin_panel{
+    wr_str_t   name;
+    wr_str_t   base_uri;
+  }Admin_panel;
+  
+  struct static_server{
+    wr_str_t    name;
+    wr_u_short  min_workers;
+    wr_u_short  max_workers;
+  }Static_server;
+  
+  wr_str_t    analytics_on;
+  wr_u_int    msg_queue_size;
+  wr_u_short  max_req_ratio;
+  wr_u_short  min_req_ratio;
+  wr_u_short  high_load;
+  wr_u_short  low_load;
+  wr_u_short  max_hosts;
+  
+  config_application_list_t *list;
+  
+}config_application_t;
+
+typedef struct config_worker_s{
+  
+  struct worker_file{
+    wr_str_t    config;
+    wr_str_t    mime_type;
+    wr_str_t    internal_config;
+    wr_str_t    app_loader;
+  }File;
+  
+  struct worker_header{
+    wr_str_t    file_path;
+    wr_str_t    conn_id;
+    wr_str_t    req_id;
+    wr_str_t    resp_code;
+    wr_str_t    resp_content_len;
+  }Header;
+  
+  struct server{
+    wr_str_t    name;
+    wr_str_t    version;
+  }Server;
+  
+  struct compress{
+    wr_u_long lower_limit;
+    wr_u_long upper_limit;
+  }Compress;
+  
+  wr_str_t    static_server;
+  wr_str_t    sock_path;
+  wr_u_short  stack_tace;
+  wr_u_long   max_body_size;
+  
+}config_worker_t;
+
+typedef struct config_s{
+  config_server_t       Server;
+  config_request_t      Request;
+  config_worker_t       Worker;
+  config_application_t  Application;
+}config_t;
+
+config_t* wr_server_config_init(const char* root_path);
+config_t* wr_worker_config_init(const char* root_path);
+
+void wr_server_config_free(config_t *Config);
+void wr_worker_config_free(config_t *Config);
+void wr_application_list_free(config_application_list_t* list);
+
+void wr_set_numeric_value(node_t *root, const char *path, void *value, wr_u_short flag);
+  
+#endif /*WR_CONFIG_H_*/

data/src/helper/wr_helper.h

@@ -20,13 +20,9 @@
 #ifndef WR_HELPER_H_
 #define WR_HELPER_H_
 
-#include <wr_macro.h>
-#include <wr_string.h>
+#include <wr_config.h>
 #include <wr_queue.h>
 #include <wr_util.h>
-#include <wr_scgi.h>
-#include <wr_logger.h>
-#include <wr_yaml_parser.h>
 #include <wr_msg_queue_client.h>
 
 #endif /*WR_HELPER_H_*/

data/src/helper/wr_logger.c

@@ -28,8 +28,8 @@
 #include<time.h>
 #include<errno.h>
 
-static inline char* get_date_time();
-static inline char* get_log_file_path();
+char* get_date_time();
+char* get_log_file_path();
 
 //this macro should included in common utility
 #define null_check(ptr) if (ptr == NULL) \
@@ -51,11 +51,11 @@ void close_logger() {
   fclose(stderr);
 }
 
-static inline char* get_log_file_path() {
+char* get_log_file_path() {
   return log_file_path;
 }
 
-static inline  char* get_date_time() {
+ char* get_date_time() {
   struct tm     *now=NULL;
   time_t         time_value=0;
   char         *str;