webroar 0.3.1 → 0.4.0

data/src/worker/wkr_controller.c

@@ -18,13 +18,21 @@
  */
 
 #include <worker.h>
-#include <wr_logger.h>
 #include <netinet/in.h>
 #include <sys/un.h>
 
+#define WR_CTL_ACK_TIMEOUT 15.
+
 extern int is_alive;
 
-wkr_ctl_t* wkr_ctl_new() {
+int ctl_msg_process(wkr_t* w);
+
+void ctl_ack_timeout_cb(struct ev_loop *loop, ev_timer *w, int revents) {
+  LOG_INFO("Control message timeout");
+  is_alive = 0;
+};
+
+wkr_ctl_t* wkr_ctl_new(wkr_t *w) {
   LOG_FUNCTION
   wkr_ctl_t *ctl = wr_malloc(wkr_ctl_t);
 
@@ -34,8 +42,13 @@ wkr_ctl_t* wkr_ctl_new() {
 
   ctl->fd = -1;
   ctl->msg_size = ctl->bytes_read = 0;
+  ctl->w_read.data = ctl->w_write.data = w;
   ctl->scgi = NULL;
+  ctl->error = FALSE;
+  ctl->t_ack.data = ctl;
 
+  ev_timer_init (&ctl->t_ack, ctl_ack_timeout_cb, 0., WR_CTL_ACK_TIMEOUT);
+  
   return ctl;
 }
 
@@ -52,53 +65,60 @@ void wkr_ctl_free(wkr_ctl_t **c) {
   *c = NULL;
 }
 
-/** Process control message */
-static inline void ctl_msg_process(wkr_t* w) {
+/** Connect to head process **/
+int connect_to_head(wkr_t *w){
   LOG_FUNCTION
   wkr_ctl_t *ctl = w->ctl;
-  char *value;
-
-  scgi_t* ctl_req = ctl->scgi;
-  ctl->scgi = NULL;
-
-  value = (char*) scgi_header_value_get(ctl_req, "METHOD");
-  if(value) {
-    if(strcmp(value,"ADD")==0) {
-      // Response of ADD method
-      value = (char*) scgi_header_value_get(ctl_req, "STATUS");
-      if(value && strcmp(value, "OK")==0) {
-        LOG_INFO("Worker connected with Head.");
-      } else {
-        LOG_ERROR(SEVERE,"Unable to connect with Head.");
-        sigproc();
-      }
-    } else if(strcmp(value,"REMOVE")==0) {
-      //Request to REMOVE worker
-      //TODO: need to send acknowledgement for clossing or not
-      /*scgi_t* ctl_resp = scgi_new();
-      if(ctl_resp){
-        scgi_header_add(ctl_resp, "METHOD", strlen("METHOD"), "REMOVE", strlen("REMOVE"));
-        scgi_header_add(ctl_resp, "STATUS", strlen("STATUS"), "OK", strlen("OK"));
-        scgi_build(ctl_resp);
-        send(control.fd, ctl_resp->request_buffer, ctl_resp->request_length, 0);
-        scgi_free(ctl_resp);
-    }*/
-      sigproc();
-    } else if(strcmp(value,"PING") == 0) {
-      LOG_INFO("Worker got PING message");
-      scgi_t* ctl_resp = scgi_new();
-      if(ctl_resp) {
-        scgi_header_add(ctl_resp, "COMPONENT", strlen("COMPONENT"), "WORKER", strlen("WORKER"));
-        scgi_header_add(ctl_resp, "METHOD", strlen("METHOD"), "PING", strlen("PING"));
-        scgi_header_add(ctl_resp, "STATUS", strlen("STATUS"), "OK", strlen("OK"));
-        scgi_build(ctl_resp);
-        ctl->scgi = ctl_resp;
-        ev_io_start(w->loop, &ctl->w_write);
-      }
+  
+  if(w->is_uds == FALSE) {
+    struct sockaddr_in addr;
+    
+    LOG_DEBUG(DEBUG,"connect_to_head() port = %i", w->listen_port);
+    
+    if ((ctl->fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
+      LOG_ERROR(WARN,"socket():%s",strerror(errno));
+      return FALSE;
+    }
+    setsocketoption(ctl->fd);
+    LOG_DEBUG(DEBUG,"connect_to_head() FD for control.fd is %d",ctl->fd);
+    
+    int iport = atoi(w->tmp->ctl_path.str);
+    addr.sin_family = AF_INET;         // host byte order
+    addr.sin_port = htons(iport);     // short, network byte order
+    addr.sin_addr.s_addr =  htonl(INADDR_ANY); // auto-fill with my IP
+    memset(addr.sin_zero, '\0', sizeof addr.sin_zero);
+    
+    if(connect(ctl->fd, (struct sockaddr *)&addr, sizeof addr) < 0) {
+      LOG_ERROR(SEVERE,"Connection with controller failed:%s",strerror(errno));
+      return FALSE;
+    }
+  }else{
+    LOG_DEBUG(DEBUG,"connect_to_head() path = %s", w->sock_path.str);
+    struct sockaddr_un addr;
+    
+    if ((ctl->fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
+      LOG_ERROR(WARN,"socket()%s",strerror(errno));
+      return FALSE;
+    }
+    
+    setsocketoption(ctl->fd);
+    
+    memset(&addr, 0, sizeof(addr));
+    addr.sun_family = AF_UNIX;
+    strcpy(addr.sun_path, w->tmp->ctl_path.str);
+    
+    int len = sizeof(addr.sun_family)+strlen(addr.sun_path);
+#ifdef __APPLE__
+    len ++;
+#endif
+    
+    LOG_DEBUG(DEBUG,"connect_to_head() connecting with socket %s",addr.sun_path);
+    if(connect(ctl->fd, (struct sockaddr *)&addr, len) < 0) {
+      LOG_ERROR(SEVERE,"Connect with controller fd failed: %s",strerror(errno));
+      return FALSE;
     }
-  } else {
-    LOG_ERROR(SEVERE,"METHOD is missing");
   }
+  return TRUE;
 }
 
 /** Send SCGI control message */
@@ -106,26 +126,27 @@ void ctl_write_cb(struct ev_loop *loop, struct ev_io *watcher, int revents) {
   LOG_FUNCTION
   wkr_t* w = (wkr_t*) watcher->data;
   wkr_ctl_t *ctl = w->ctl;
-
+  
   if(revents & EV_ERROR) {
     ev_io_stop(loop, watcher);
     LOG_ERROR(SEVERE,"Error writing control message :%s",strerror(errno));
-    sigproc();
+    is_alive = 0;
     return;
   }
   if(scgi_send(ctl->scgi, watcher->fd) <= 0){
     ev_io_stop(loop, watcher);
     LOG_ERROR(SEVERE,"Error writing control message :%s",strerror(errno));
-    sigproc();
+    is_alive = 0;
     return;
   }
-
+  
   // Check message length
   if(ctl->scgi->bytes_sent >= ctl->scgi->length) {
     ev_io_stop(loop, watcher);
     LOG_DEBUG(DEBUG, "ctl_write_cb() message sent successfully");
     scgi_free(ctl->scgi);
     ctl->scgi = NULL;
+    if(ctl->error == TRUE)       is_alive = 0;
   }
 }
 
@@ -134,7 +155,7 @@ void ctl_read_cb(struct ev_loop *loop, struct ev_io *watcher, int revents) {
   LOG_FUNCTION
   wkr_t* w = (wkr_t*) watcher->data;
   wkr_ctl_t *ctl = w->ctl;
-
+  
   if(revents & EV_ERROR) {
     ev_io_stop(loop, watcher);
     is_alive = 0;
@@ -142,8 +163,8 @@ void ctl_read_cb(struct ev_loop *loop, struct ev_io *watcher, int revents) {
     return;
   }
   int bytesRead = recv(watcher->fd, ctl->msg + ctl->bytes_read,
-                       WR_MSG_SIZE - ctl->bytes_read, 0);
-
+                       STR_SIZE1KB - ctl->bytes_read, 0);
+  
   if(bytesRead <= 0) {
     LOG_ERROR(SEVERE,"Error reading control message :%s",strerror(errno));
     ev_io_stop(loop, watcher);
@@ -151,7 +172,7 @@ void ctl_read_cb(struct ev_loop *loop, struct ev_io *watcher, int revents) {
     return;
   }
   ctl->bytes_read += bytesRead;
-
+  
   int i;
   for(i = 0 ; i <  ctl->bytes_read ; i++) {
     if(ctl->msg[i] == ':') {
@@ -162,9 +183,9 @@ void ctl_read_cb(struct ev_loop *loop, struct ev_io *watcher, int revents) {
     return;
   ctl->msg_size = atoi(ctl->msg);
   ctl->msg_size += (i+2);
-
+  
   scgi_t* ctl_req = NULL;
-
+  
   if(ctl->bytes_read >= ctl->msg_size) {
     ctl_req = scgi_parse(ctl->msg, ctl->msg_size);
     if(ctl_req == NULL ) {
@@ -178,109 +199,148 @@ void ctl_read_cb(struct ev_loop *loop, struct ev_io *watcher, int revents) {
       scgi_free(ctl_req);
       return;
     }
-
+    
     ctl->scgi = ctl_req;
-    ctl_msg_process(w);
-    scgi_free(ctl_req);
+    if(ctl_msg_process(w) == TRUE){
+      scgi_free(ctl_req);
+    }else{
+      scgi_free(ctl_req);
+      is_alive = 0;
+    }
   } else {
     return;
   }
-
+  
   ctl->bytes_read = ctl->msg_size = 0;
 }
 
-/** Send connect acknowledgement on internet socket */
-int send_ack_on_internet_socket(wkr_t* w) {
-  LOG_FUNCTION
-  LOG_DEBUG(DEBUG,"send_ack_on_internet_socket() port = %i", w->listen_port);
-  wkr_ctl_t *ctl = w->ctl;
-
-  struct sockaddr_in addr;
-
-  if ((ctl->fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
-    LOG_ERROR(WARN,"socket():%s",strerror(errno));
-    return -1;
-  }
-  setsocketoption(ctl->fd);
-  LOG_DEBUG(DEBUG,"send_ack_on_internet_socket() FD for control.fd is %d",ctl->fd);
-  int iport = atoi(w->tmp->ctl_path.str);
-  addr.sin_family = AF_INET;         // host byte order
-  addr.sin_port = htons(iport);     // short, network byte order
-  addr.sin_addr.s_addr =  htonl(INADDR_ANY); // auto-fill with my IP
-  memset(addr.sin_zero, '\0', sizeof addr.sin_zero);
+/** Start control wathers */
+void start_ctl_watcher(wkr_t *w){
+  ev_io_init(&(w->ctl->w_read),ctl_read_cb, w->ctl->fd, EV_READ);
+  ev_io_init(&(w->ctl->w_write),ctl_write_cb, w->ctl->fd, EV_WRITE);
+  ev_io_start(w->loop,&(w->ctl->w_read));
+}
 
-  if(connect(ctl->fd, (struct sockaddr *)&addr, sizeof addr) < 0) {
-    LOG_ERROR(SEVERE,"Connection with controller failed:%s",strerror(errno));
-    return -1;
-  }
-  char buf[WR_SHORT_STR_LEN];
-  int len;
+/** Set flag to TRUE to generate error request */
+void get_worker_add_ctl_scgi(wkr_t* w, const int flag){
   pid_t pid = getpid();
-
-  scgi_t* add_request = scgi_new();
-  if(add_request == NULL) {
-    LOG_ERROR(SEVERE,"Cannot create SCGI Request");
-    return -1;
-  }
-
+  char buf[STR_SIZE32];
+  int len = sprintf(buf, "%d", pid);
+  
+  scgi_t* scgi = w->ctl->scgi;
+  
   // Construct SCGI request
-  scgi_header_add(add_request, "COMPONENT", strlen("COMPONENT"), "WORKER", strlen("WORKER"));
-  scgi_header_add(add_request, "METHOD", strlen("METHOD"), "ADD", strlen("ADD"));
-  scgi_header_add(add_request, "APPLICATION", strlen("APPLICATION"), w->tmp->name.str, w->tmp->name.len);
-  scgi_header_add(add_request, "UDS", strlen("UDS"), "NO", strlen("NO"));
-  len = sprintf(buf, "%d", w->listen_port);
-  scgi_header_add(add_request, "PORT", strlen("PORT"), buf, len);
-  len = sprintf(buf, "%d", pid);
-  scgi_header_add(add_request, "PID", strlen("PID"), buf, len);
-
-  scgi_build(add_request);
-
-  ctl->w_read.data = ctl->w_write.data = w;
-  ctl->bytes_read = 0;
-//  ctl->bytes_write = 0;
-  ctl->scgi = add_request;
-  ev_io_init(&(ctl->w_read),ctl_read_cb, ctl->fd,EV_READ);
-  ev_io_start(w->loop,&(ctl->w_read));
-  ev_io_init(&(ctl->w_write),ctl_write_cb, ctl->fd,EV_WRITE);
-  ev_io_start(w->loop,&(ctl->w_write));
-
-  return 0;
+  
+  scgi_header_add(scgi, "COMPONENT", strlen("COMPONENT"), "WORKER", strlen("WORKER"));
+  
+  if(flag == TRUE){
+    scgi_header_add(scgi, "METHOD", strlen("METHOD"), "ERROR", strlen("ERROR"));
+  }else{
+    scgi_header_add(scgi, "METHOD", strlen("METHOD"), "ADD", strlen("ADD"));
+  }
+  
+  scgi_header_add(scgi, "APPLICATION", strlen("APPLICATION"), w->tmp->name.str, w->tmp->name.len);
+  scgi_header_add(scgi, "PID", strlen("PID"), buf, len);
+  
+  if(w->is_uds == 1) {
+    scgi_header_add(scgi, "UDS", strlen("UDS"), "YES", strlen("YES"));
+    scgi_header_add(scgi, "SOCK_PATH", strlen("SOCK_PATH"), w->sock_path.str, w->sock_path.len);
+  }else{
+    scgi_header_add(scgi, "UDS", strlen("UDS"), "NO", strlen("NO"));
+    len = sprintf(buf, "%d", w->listen_port);
+    scgi_header_add(scgi, "PORT", strlen("PORT"), buf, len);
+  }
+  
+  scgi_build(scgi);
 }
 
-/** Send connect  acknowledgement on unix domain socket */
-int send_ack_on_unix_socket(wkr_t* w) {
+/** Process control message */
+int ctl_msg_process(wkr_t* w) {
   LOG_FUNCTION
-  LOG_DEBUG(DEBUG,"send_ack_on_unix_socket() path = %s", w->sock_path.str);
   wkr_ctl_t *ctl = w->ctl;
-  size_t len;
+  char *value;
 
-  char buf[WR_SHORT_STR_LEN];
-  pid_t pid = getpid();
-  scgi_t* add_request = scgi_new();
-  if(add_request == NULL) {
-    LOG_ERROR(SEVERE,"Cannot create SCGI Request");
-    return -1;
-  }
+  scgi_t* ctl_req = ctl->scgi;
+  ctl->scgi = NULL;
 
-  // Construct SCGI request
-  scgi_header_add(add_request, "COMPONENT", strlen("COMPONENT"), "WORKER", strlen("WORKER"));
-  scgi_header_add(add_request, "METHOD", strlen("METHOD"), "ADD", strlen("ADD"));
-  scgi_header_add(add_request, "APPLICATION", strlen("APPLICATION"), w->tmp->name.str, w->tmp->name.len);
-  scgi_header_add(add_request, "UDS", strlen("UDS"), "YES", strlen("YES"));
-  scgi_header_add(add_request, "SOCK_PATH", strlen("SOCK_PATH"), w->sock_path.str, w->sock_path.len);
-  len = sprintf(buf, "%d",  pid);
-  scgi_header_add(add_request, "PID", strlen("PID"), buf, len);
+  value = (char*) scgi_header_value_get(ctl_req, "METHOD");
+  if(value) {
+    if(strcmp(value,"ADD")==0) {
+      // Response of ADD method
+      value = (char*) scgi_header_value_get(ctl_req, "STATUS");
+      if(value && strcmp(value, "OK")==0) {
+        LOG_INFO("Worker connected with Head.");
+      } else {
+        LOG_ERROR(SEVERE,"Unable to connect with Head.");
+        return FALSE;
+      }
+    } else if(strcmp(value,"REMOVE")==0) {
+      //Request to REMOVE worker
+      //TODO: need to send acknowledgement for clossing or not
+      /*scgi_t* ctl_resp = scgi_new();
+      if(ctl_resp){
+        scgi_header_add(ctl_resp, "METHOD", strlen("METHOD"), "REMOVE", strlen("REMOVE"));
+        scgi_header_add(ctl_resp, "STATUS", strlen("STATUS"), "OK", strlen("OK"));
+        scgi_build(ctl_resp);
+        send(control.fd, ctl_resp->request_buffer, ctl_resp->request_length, 0);
+        scgi_free(ctl_resp);
+    }*/
+      return FALSE;
+    } else if(strcmp(value,"PING") == 0) {
+      LOG_INFO("Worker got PING message");
+      scgi_t* ctl_resp = scgi_new();
+      if(ctl_resp) {
+        scgi_header_add(ctl_resp, "COMPONENT", strlen("COMPONENT"), "WORKER", strlen("WORKER"));
+        scgi_header_add(ctl_resp, "METHOD", strlen("METHOD"), "PING", strlen("PING"));
+        scgi_header_add(ctl_resp, "STATUS", strlen("STATUS"), "OK", strlen("OK"));
+        scgi_build(ctl_resp);
+        ctl->scgi = ctl_resp;
+        ev_io_start(w->loop, &ctl->w_write);
+      }
+    }else if(strcmp(value,"ACK") == 0) {
+      LOG_INFO("Worker got ACK message");
+      return FALSE;   
+    }else if(strcmp(value,"CONF_REQ") == 0){
+      value = (char*) scgi_header_value_get(ctl_req, "STATUS");
+      if(value && strcmp(value, "OK") != 0) {
+        LOG_ERROR(SEVERE,"Did not receive application configuration.");
+        return FALSE;
+      }      
+      //Application configuration received
+      application_config_read_cb(w, ctl_req);
+    }
+  } else {
+    LOG_ERROR(SEVERE,"METHOD is missing");
+  }
+  return TRUE;
+}
 
-  scgi_build(add_request);
+/** Create config request message */
+scgi_t* get_config_req_scgi(wkr_t* worker){
 
-  ctl->w_read.data = ctl->w_write.data = w;
-  ctl->bytes_read = 0; 
-  //ctl->bytes_write = 0;
-  ctl->scgi = add_request;
-  ev_io_init(&(ctl->w_read),ctl_read_cb, ctl->fd,EV_READ);
-  ev_io_start(w->loop,&(ctl->w_read));
-  ev_io_init(&(ctl->w_write),ctl_write_cb, ctl->fd,EV_WRITE);
-  ev_io_start(w->loop,&(ctl->w_write));
+  scgi_t* scgi = scgi_new();
+  if(scgi == NULL) {
+    LOG_ERROR(SEVERE,"Cannot create SCGI Request");
+    is_alive = 0;
+    return NULL;
+  }
+  
+  // Construct SCGI request  
+  scgi_header_add(scgi, "COMPONENT", strlen("COMPONENT"), "WORKER", strlen("WORKER"));
+  scgi_header_add(scgi, "APPLICATION", strlen("APPLICATION"), worker->tmp->name.str, worker->tmp->name.len);
+  scgi_header_add(scgi, "METHOD", strlen("METHOD"), "CONF_REQ", strlen("CONF_REQ"));
+  scgi_build(scgi);
+  
+  return scgi;
+}
 
+/** Send Config request control message */
+int send_config_req_msg(wkr_t* w) {
+  LOG_FUNCTION
+  
+  w->ctl->scgi = get_config_req_scgi(w);
+  if(w->ctl->scgi == NULL)   return -1;
+  ev_io_start(w->loop,&(w->ctl->w_write));
+  
   return 0;
 }

data/src/worker/wkr_http.c

@@ -19,7 +19,7 @@
 #include <worker.h>
 #include <ruby.h>
 
-#include "wkr_static.h"
+extern config_t *Config;
 
 /** for handling of $0, courtesy http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/16221 */
 static VALUE gProgName = Qnil;
@@ -41,7 +41,7 @@ static http_t *g_http;
 /** Call 'Ruby' method 'RequestHandler.process' */
 void http_req_process() {
   LOG_FUNCTION
-  if(g_http->is_static){
+  if(g_http->stat){
     static_file_process(g_http);
   }else{
     rb_funcall(cRequestHandler, rb_intern("process"),1,rb_req);
@@ -153,7 +153,7 @@ VALUE log_message(VALUE _, VALUE message_type, VALUE severity, VALUE message) {
 }
 
 /** for handling of $0 */
-static void setProgName(VALUE name, ID id) {
+void setProgName(VALUE name, ID id) {
   LOG_FUNCTION
   gProgName = rb_obj_as_string(name);
   rb_obj_taint(gProgName);
@@ -181,7 +181,7 @@ void init_ruby_interface(http_t *h) {
   rb_define_hooked_variable("$0", &gProgName, 0, setProgName);
 }
 
-static int init_ruby_interpreter(wkr_t *w) {
+int init_ruby_interpreter(wkr_t *w) {
   LOG_FUNCTION
   //initializing ruby interpreter ... referred from main.c and ruby.c of ruby-dev
   //preparing pseudo argc and argv to set ruby_option
@@ -202,13 +202,13 @@ static int init_ruby_interpreter(wkr_t *w) {
   }
   strcpy(v[0],"webroar-worker");
 
-  v[1] =  (char*) malloc(sizeof(char)*(w->tmp->script_path.len+1));
+  v[1] =  (char*) malloc(sizeof(char)*(Config->Worker.File.app_loader.len +1));
   if(!v[1]) {
     LOG_ERROR(WARN,"Memory allocation to pseudo argv failed.");
     retval = -1;
     goto err;
   }
-  strcpy(v[1], w->tmp->script_path.str);
+  strcpy(v[1], Config->Worker.File.app_loader.str);
 
   //RUBY_INIT_STACK;
   ruby_init();
@@ -274,7 +274,7 @@ int load_rack_adapter(wkr_tmp_t *tmp) {
 
   rb_gv_set("g_options",g_options);
 
-  rb_protect(RUBY_METHOD_FUNC(rb_require), (VALUE)tmp->script_path.str, &state);
+  rb_protect(RUBY_METHOD_FUNC(rb_require), (VALUE)Config->Worker.File.app_loader.str, &state);
   LOG_DEBUG(DEBUG, "state=%d", state);
   if ( state != 0 ) {
     LOG_ERROR(FATAL, "Some problem occurred while loading application.");
@@ -297,6 +297,7 @@ http_t* http_new(void *ptr) {
   
   h->req = http_req_new();
   h->resp = http_resp_new();
+  h->stat = NULL;  
 
   if(h->req==NULL || h->resp == NULL) {
     http_free(&h);
@@ -304,11 +305,11 @@ http_t* http_new(void *ptr) {
   }
   
   if(w->tmp->is_static){
-    if(static_module_init(w->tmp->root_path.str)!=0){
+    h->stat = static_server_new(w);
+    if(h->stat == NULL){
       http_free(&h);
       return NULL;
     }
-    h->is_static = 1;
   }else{
     if(init_ruby_interpreter(w)!=0) {
       http_free(&h);
@@ -321,7 +322,6 @@ http_t* http_new(void *ptr) {
       return NULL;
     }
     rb_req = Data_Wrap_Struct(cReq, 0, 0, h->req);
-    h->is_static = 0;
   }
   g_http = h;
   return h;
@@ -331,29 +331,15 @@ void http_free(http_t** http) {
   LOG_FUNCTION
   http_t *h = *http;  
   if(h) {
-    if(h->is_static){
-      static_module_free();
-    }else{
+    if(h->stat == NULL){
       ruby_finalize();
     }
     
-    if(h->resp)
-      http_resp_free(&h->resp);
-    if(h->req)
-      http_req_free(&h->req);
+    if(h->resp) http_resp_free(&h->resp);
+    if(h->req) http_req_free(&h->req);
+    if(h->stat) static_server_free(h->stat);
     free(h);
   }
   *http = NULL;
 }
 
-void http_set(http_t* h) {
-  LOG_FUNCTION
-  if(h->resp)
-    http_resp_set(h->resp);
-  if(h->req)
-    http_req_set(h->req);
-#ifdef L_DEBUG
-
-  h->conn_id = h->req_id = 0;
-#endif
-}

data/src/worker/wkr_http.h

@@ -19,7 +19,8 @@
 #ifndef WKR_HTTP_H_
 #define WKR_HTTP_H_
 
-#include <wkr_http_response.h>
+#include <wkr_static.h>
+
 
 typedef struct http_s    http_t;
 
@@ -28,16 +29,15 @@ struct http_s {
   void          *wkr;
   http_req_t      *req;
   http_resp_t     *resp;
-  short            is_static;
-#ifdef L_DEBUG
+  static_server_t *stat;
 
+#ifdef L_DEBUG
   wr_u_int       conn_id;
   wr_u_int       req_id;
 #endif
 };
 
 http_t* http_new(void *worker);
-void http_set(http_t*);
 void http_free(http_t**);
 void http_req_process();