webroar 0.2.2

data/src/worker/wkr_main.c

@@ -0,0 +1,248 @@
+/* WebROaR - Ruby Application Server - http://webroar.in/
+ * Copyright (C) 2009  WebROaR
+ *
+ * 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/>.
+ */
+
+#include <assert.h>
+#include <string.h>
+#include <worker.h>
+#include <ruby.h>
+
+//static wkr_t       *worker = NULL;
+
+struct               ev_loop *loop;    // Event loop
+int                 is_alive = 1;
+
+static int drop_privileges(wkr_t *w) {
+  change_log_file_owner(w->tmp->uid, w->tmp->gid);
+  //setting read, effective, saved group and user id
+  if(setgid(w->tmp->gid)!=0) {
+    LOG_ERROR(SEVERE,"setegid() failed");
+    return -1;
+  }
+  if(setuid(w->tmp->uid)!=0) {
+    LOG_ERROR(SEVERE,"seteuid() failed");
+    return -1;
+  }
+
+  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());
+  return 0;
+}
+
+/** Usage */
+static inline void print_usage(char *appname) {
+  printf("usage: \n%s -a <application_path> [-e <environment>] [-u <cuid >] [-g <cgid>] ",appname);
+  printf("[-c <control port/sock path>] [-i <uds>] [-t <application_type>] [-n <application_name>] ");
+  printf("[-p <analytics>] [-r <application baseuri>]\n");
+  printf("<application_path> = path of rails application. e.g. /home/xyz/rails_projects/app1\n");
+  printf("<environment> = rails environment. development/production. Default is production.\n");
+  printf("<cuid> = User id.\n");
+  printf("<cgid> = Group id.\n");
+  printf("<control port/sock path> = Control port number (control sock path in case [-i 1])\n");
+  printf("<uds> = Unix domain socket flag. Value should be 0 or 1.\n");
+  printf("<application_type> = Type of application {rails, merb}.\n");
+  printf("<application_name> = Name of application\n");
+  printf("<analytics> = Analytics flag. Value should be yes or no.\n");
+  printf("<baseuri> = Application URL baseuri.\n");
+}
+
+void sigproc() {
+  //  file_log("/tmp/too_many_worker.log","Webroar-Worker of %s getting close\n", worker->tmp->name.str);
+  LOG_DEBUG(4,"**************Caught Interrupt Signal************");
+  is_alive = 0;
+}
+
+/** Parse command line arguments */
+static inline wkr_tmp_t* parse_args(int argc, char **argv) {
+  int option;
+  extern char *optarg;
+  size_t len;
+  char *str;
+  int invalid_arg_flag = 0, app_path_flag = 0;
+  wkr_tmp_t *tmp = wkr_tmp_new();
+
+  if(tmp == NULL)
+    return NULL;
+
+  while ( (option=getopt(argc,argv,"a:b:e:l:f:g:u:c:i:t:n:o:p:r:k:")) != -1 ) {
+    str = optarg;
+    len = strlen(str);
+    switch ( option ) {
+    case 'a':  // Application Path
+      wr_string_new(tmp->path, str, len);
+      app_path_flag = 1;
+      break;
+    case 'b':  // Ruby library path
+      wr_string_new(tmp->ruby_path, str, len);
+      tmp->script_path.str = (char*) malloc(sizeof(char)*(tmp->ruby_path.len + 32));
+      tmp->script_path.len = sprintf(tmp->script_path.str, "%s%swebroar_app_loader.rb", tmp->ruby_path.str, WR_PATH_SEPARATOR);
+      break;
+    case 'e':  // Application environment
+      wr_string_new(tmp->env, str, len);
+      break;
+    case 'l':  // Logging level
+#ifdef L_DEBUG
+
+      set_log_severity(DEBUG);
+#else
+
+      set_log_severity(atoi(optarg));
+#endif
+
+      break;
+    case 'f':  // Log file name
+      wr_string_free(tmp->log_file);
+      wr_string_new(tmp->log_file, str, len);
+      break;
+    case 'g':  // Group id
+      tmp->gid = atoi(optarg);
+      break;
+    case 'u':  // User id
+      tmp->uid = atoi(optarg);
+      break;
+    case 'c':  // Control path
+      wr_string_new(tmp->ctl_path, str, len);
+      break;
+    case 'i':  // Unix domain socket flag
+      if(strcmp(optarg, "y")==0) {
+        tmp->is_uds = TRUE;
+      }
+      break;
+    case 't':  // Application type
+      wr_string_new(tmp->type, str, len);
+      break;
+    case 'n':  // Application name
+      wr_string_new(tmp->name, str, len);
+      wr_string_free(tmp->log_file);
+      tmp->log_file.str = (char*) malloc(sizeof(char)*(strlen(optarg)+8));
+      tmp->log_file.len = sprintf(tmp->log_file.str,"%s.log", optarg);
+      break;
+    case 'o':  // Server root path
+      wr_string_new(tmp->root_path, str, len);
+      break;
+    case 'r':  // Applicaiton base uri
+      wr_string_new(tmp->resolver, str, len);
+      break;
+    case 'p':  // Analytics flag
+      if(strcmp(optarg, "y")==0) {
+        tmp->profiler = 'y';
+      }
+      break;
+    case 'k':
+      if(strcmp(optarg, "n")==0) {
+        tmp->keep_alive = FALSE;
+      }
+      break;
+    default:
+      invalid_arg_flag++;
+    }
+  }
+  if (invalid_arg_flag>0 || app_path_flag == 0) {
+    print_usage(argv[0]);
+    wkr_tmp_free(&tmp);
+    return NULL;
+  }
+  return tmp;
+}
+
+int main(int argc, char **argv) {
+  int port, retval = 0;
+  wkr_t* w = NULL;
+
+  if(argc==1) {
+    print_usage(argv[0]);
+    return -1;
+  }
+  wkr_tmp_t *tmp = parse_args(argc, argv);
+
+  if(tmp == NULL)
+    return -1;
+
+  loop = ev_default_loop (0);
+  w = worker_new(loop, tmp);
+  if(w==NULL)
+    goto err;
+  //  worker = w;
+  //  assert(w!=NULL);
+
+  initialize_logger(w->tmp->log_file.str);
+
+  LOG_DEBUG(DEBUG,"control path = %s, Application baseuri = %s",
+            w->tmp->ctl_path.str,  w->tmp->resolver.str);
+
+  if((retval = drop_privileges(w))!=0) {
+    goto err;
+  }
+
+  w->http = http_new(w);
+  if(w->http == NULL) {
+    LOG_ERROR(SEVERE,"unable to load application.");
+    goto err;
+  }
+
+  retval = worker_connect(w);
+  if(retval<0) {
+    LOG_ERROR(WARN,"Error Initializing Workers.");
+    retval = -1;
+    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);
+  LOG_DEBUG(DEBUG,"path = %s, name = %s, type = %s, environment = %s, baseuri = %s, analytics = %c",
+            w->tmp->path.str,  w->tmp->name.str, w->tmp->type.str,
+            w->tmp->env.str, w->tmp->resolver.str, w->tmp->profiler);
+
+  LOG_INFO("Successfully loaded rack application=%s with environment=%s",
+           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(SIGCHLD, SIG_IGN);
+  signal(SIGTSTP, SIG_IGN);
+  signal(SIGTTOU, SIG_IGN);
+  signal(SIGTTIN, SIG_IGN);
+  signal(SIGKILL, sigproc);
+  signal(SIGPIPE, SIG_IGN);
+
+  worker_accept_requests(w);
+  LOG_INFO("Worker ready for serving requests.");
+
+  while(is_alive ==1) {
+    ev_loop(loop,EVLOOP_ONESHOT);
+  }
+
+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();
+  return retval;
+}

data/src/worker/worker.c

@@ -0,0 +1,336 @@
+/* WebROaR - Ruby Application Server - http://webroar.in/
+ * Copyright (C) 2009  WebROaR
+ *
+ * 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/>.
+ */
+/**********************************************************
+ *             Worker
+ *********************************************************/
+
+/**
+ * Parse argument list
+ * Initialize Worker to accept SCGI request from Head
+ * Load web application
+ * Start Atals Worker
+ */
+
+#include <worker.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <netinet/in.h>
+#include <sys/un.h>
+#include <ev.c>
+
+wkr_tmp_t* wkr_tmp_new() {
+  LOG_FUNCTION
+  wkr_tmp_t *tmp = wr_malloc(wkr_tmp_t);
+
+  if(tmp == NULL) {
+    return NULL;
+  }
+  wr_string_null(tmp->path);
+  wr_string_null(tmp->env);
+  wr_string_null(tmp->type);
+  wr_string_null(tmp->name);
+  wr_string_null(tmp->resolver);
+  wr_string_null(tmp->ruby_path);
+  wr_string_null(tmp->script_path);
+  wr_string_null(tmp->root_path);
+  wr_string_null(tmp->ctl_path);
+  wr_string_null(tmp->log_file);
+
+  //  tmp->path = tmp->env = tmp->type = tmp->name =
+  //  tmp->resolver = tmp->ruby_path = tmp->script_path =
+  //  tmp->root_path = tmp->ctl_path = tmp->log_file = NULL;
+
+  tmp->profiler = 'n';
+  tmp->gid = tmp->uid = 0;
+  // HTTP1.1 assumes persistent connection by default
+  tmp->keep_alive = TRUE;
+  tmp->is_uds = FALSE;
+
+  return tmp;
+}
+
+void wkr_tmp_free(wkr_tmp_t** t) {
+  LOG_FUNCTION
+  wkr_tmp_t *tmp = *t;
+  if(tmp) {
+    wr_string_free(tmp->path);
+    wr_string_free(tmp->env);
+    wr_string_free(tmp->type);
+    wr_string_free(tmp->name);
+    wr_string_free(tmp->resolver);
+    wr_string_free(tmp->ruby_path);
+    wr_string_free(tmp->script_path);
+    wr_string_free(tmp->root_path);
+    wr_string_free(tmp->ctl_path);
+    wr_string_free(tmp->log_file);
+
+    //    if(tmp->path)      free(tmp->path);
+    //    if(tmp->env)        free(tmp->env);
+    //    if(tmp->type)      free(tmp->type);
+    //    if(tmp->name)      free(tmp->name);
+    //    if(tmp->resolver)    free(tmp->resolver);
+    //    if(tmp->ruby_path)  free(tmp->ruby_path);
+    //    if(tmp->script_path)  free(tmp->script_path);
+    //    if(tmp->root_path)  free(tmp->root_path);
+    //    if(tmp->ctl_path)    free(tmp->ctl_path);
+    //    if(tmp->log_file)    free(tmp->log_file);
+
+    free(tmp);
+  }
+  *t = NULL;
+}
+
+/** Create new Worker */
+wkr_t* worker_new(struct ev_loop *loop, wkr_tmp_t *tmp) {
+  LOG_FUNCTION
+  wkr_t* w = wr_malloc(wkr_t);
+
+  assert(w!=NULL);
+
+  w->req_fd = -1;
+  w->listen_fd = -1;
+  w->is_uds = tmp->is_uds;
+  w->loop = loop;
+  wr_string_null(w->sock_path);
+  w->listen_port = 0;
+
+  w->tmp = tmp;
+  assert(w->tmp!=NULL);
+
+  w->ctl = wkr_ctl_new();
+  assert(w->ctl!=NULL);
+
+  if(tmp->is_uds) {
+    struct sockaddr_un addr;
+
+    if ((w->ctl->fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
+      LOG_ERROR(WARN,"socket()%s",strerror(errno));
+      worker_free(&w);
+      return NULL;
+    }
+
+    setsocketoption(w->ctl->fd);
+
+    memset(&addr, 0, sizeof(addr));
+    addr.sun_family = AF_UNIX;
+    strcpy(addr.sun_path, tmp->ctl_path.str);
+
+    int len = sizeof(addr.sun_family)+strlen(addr.sun_path);
+#ifdef __APPLE__
+
+    len ++;
+#endif
+
+    LOG_DEBUG(DEBUG,"send_ack_on_unix_socket() connecting with socket %s",addr.sun_path);
+    if(connect(w->ctl->fd, (struct sockaddr *)&addr, len) < 0) {
+      LOG_ERROR(SEVERE,"Connect with controller fd failed: %s",strerror(errno));
+      worker_free(&w);
+      return NULL;
+    }
+  }
+
+  return w;
+}
+
+void worker_free(wkr_t **wrk) {
+  LOG_FUNCTION
+  wkr_t *w = *wrk;
+  if(w) {
+    if(w->req_fd > 0)
+      close(w->req_fd);
+    if(w->listen_fd > 0)
+      close(w->listen_fd);
+    //    if(w->sock_path){
+    if(w->sock_path.str) {
+      // Set root privilege to remove socket file.
+      //      if(setegid(0)!=0){
+      //        LOG_ERROR(SEVERE,"setegid() to root failed");
+      //      }
+      //      if(seteuid(0)!=0){
+      //        LOG_ERROR(SEVERE,"seteuid() to root failed");
+      //      }
+      unlink(w->sock_path.str);
+      wr_string_free(w->sock_path);
+      //      unlink(w->sock_path);
+      //      free(w->sock_path);
+    }
+    ev_io_stop(w->loop, &(w->w_accept));
+    ev_io_stop(w->loop, &(w->ctl->w_read));
+    if(w->tmp)
+      wkr_tmp_free(&w->tmp);
+    if(w->ctl)
+      wkr_ctl_free(&w->ctl);
+    if(w->http)
+      http_free(&w->http);
+
+    free(w);
+  }
+  *wrk=NULL;
+}
+
+/** Conenct worker on internet socket */
+static inline int connect_internet_socket(wkr_t* w) {
+  LOG_FUNCTION
+  struct sockaddr_in addr;
+  if ((w->listen_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
+    perror("socket()");
+    return -1;
+  }
+
+  if(setnonblock(w->listen_fd)<0) {
+    LOG_ERROR(SEVERE,"Setting fd non block failed");
+    return -1;
+  }
+  setsocketoption(w->listen_fd);
+  memset(&addr, 0, sizeof(addr));
+  addr.sin_family = AF_INET;
+  addr.sin_port = 0; // to bind to an ephemeral port
+  addr.sin_addr.s_addr = htonl(INADDR_ANY);
+  if (bind(w->listen_fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+    perror("bind()");
+    return -1;
+  }
+  //determine port to which listen_fd bound
+  int len = sizeof(addr);
+  if(getsockname(w->listen_fd,(struct sockaddr *)&addr, &len) < 0) {
+    LOG_ERROR(4,"getsockname():%s",strerror(errno));
+    return -1;
+  }
+  w->listen_port = ntohs(addr.sin_port);
+  LOG_DEBUG(4,"connect_internet_socket() Initializing worker at port %d. FD is=%d",w->listen_port, w->listen_fd);
+  // TODO: Accept connections only from WebROaR
+  if (listen(w->listen_fd,2) < 0) {
+    perror("listen()");
+    return -1;
+  }
+  return 0;
+}
+
+/** Connect worker on unix domain socket */
+static inline int connect_unix_socket(wkr_t* w) {
+  LOG_FUNCTION
+  struct sockaddr_un addr;
+
+  if ((w->listen_fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
+    LOG_ERROR(SEVERE,"Socket opening error:%s",strerror(errno));
+    return -1;
+  }
+
+  if(setnonblock(w->listen_fd)<0) {
+    LOG_ERROR(SEVERE,"Setting fd non block failed");
+    return -1;
+  }
+  setsocketoption(w->listen_fd);
+  memset(&addr, 0, sizeof(addr));
+  /* Preparing socket path unique to this worker*/
+  w->sock_path.str = (char*) malloc(sizeof(char)*50);
+  w->sock_path.len = sprintf(w->sock_path.str, "%s_%d",WR_WKR_SOCK_PATH,getpid());
+
+  //  w->sock_path = wr_malloc_CHAR(50);
+  //  sprintf(w->sock_path, "%s_%d",WR_WKR_SOCK_PATH,getpid());
+
+  //  LOG_DEBUG(DEBUG,"connect_unix_socket() socket name is %s",w->sock_path);
+  LOG_DEBUG(DEBUG,"connect_unix_socket() socket name is %s",w->sock_path.str);
+
+  addr.sun_family = AF_UNIX;
+  //strcpy(addr.sun_path,w->sock_path);
+  strcpy(addr.sun_path,w->sock_path.str);
+  unlink(addr.sun_path);
+  //  LOG_DEBUG(DEBUG,"connect_unix_socket() Binding worker at socket path %s",w->sock_path);
+  LOG_DEBUG(DEBUG,"connect_unix_socket() Binding worker at socket path %s",w->sock_path.str);
+
+  int len = sizeof(addr.sun_family) + strlen(addr.sun_path);
+#ifdef __APPLE__
+
+  len ++;
+#endif
+
+  if (bind(w->listen_fd, (struct sockaddr *)&addr, len) < 0) {
+    perror("bind()");
+    return -1;
+  }
+  //LOG_DEBUG(DEBUG,"connect_unix_socket() Listening worker at socket path %s",w->sock_path);
+  LOG_DEBUG(DEBUG,"connect_unix_socket() Listening worker at socket path %s",w->sock_path.str);
+  /* TODO: Accept connections only from WebROaR*/
+  if (listen(w->listen_fd,2) < 0) {
+    perror("listen()");
+    return -1;
+  }
+  return 0;
+}
+
+
+/** Connect worket to Head */
+int worker_connect(wkr_t* w) {
+  LOG_FUNCTION
+  if(w->is_uds == 1) {
+    if(connect_unix_socket(w) >= 0)
+      return send_ack_on_unix_socket(w);
+  } else {
+    if(connect_internet_socket(w) >=0)
+      return send_ack_on_internet_socket(w);
+  }
+  return -1;
+}
+
+/** This function accept connection from Head. */
+static void request_accept_cb(struct ev_loop *loop, struct ev_io *watcher, int revents) {
+  LOG_FUNCTION
+  wkr_t *w = (wkr_t*) watcher->data;
+
+  if(EV_ERROR & revents) {
+    LOG_ERROR(SEVERE,"request_accept_cb() got error event, returning.\n");
+    return;
+  }
+
+  if(w->is_uds) {
+    struct sockaddr_un client_addr;
+    socklen_t client_len = sizeof(client_addr);
+    w->req_fd = accept(watcher->fd, (struct sockaddr *)&client_addr, &client_len); 
+    //TODO: accept from WebROaR Head only
+  } else {
+    struct sockaddr_in client_addr;
+    socklen_t client_len = sizeof(client_addr);
+    w->req_fd = accept(watcher->fd, (struct sockaddr *)&client_addr, &client_len); 
+    //TODO: accept from WebROaR Head only
+  }
+
+  if (w->req_fd < 0) {
+    LOG_ERROR(SEVERE,"accept() error:%s",strerror(errno));
+    return;
+  }
+
+  if (setnonblock(w->req_fd) < 0) {
+    LOG_ERROR(FATAL, "failed to set client socket to non-blocking");
+    return;
+  }
+  LOG_INFO("Successfully connected with client. Read watcher starting");
+  w->w_req.data = w;
+  //worker_conversation_set(w->w_conversation);
+  ev_io_init(&(w->w_req), http_req_header_cb, w->req_fd, EV_READ);
+  ev_io_start(loop, &(w->w_req));
+}
+
+void worker_accept_requests(wkr_t* w) {
+  LOG_FUNCTION
+  w->w_accept.data = w;
+  ev_io_init(&(w->w_accept), request_accept_cb, w->listen_fd, EV_READ);
+  ev_io_start(w->loop,&(w->w_accept));
+  wkr_tmp_free(&w->tmp);
+}

data/src/worker/worker.h

@@ -0,0 +1,97 @@
+/* WebROaR - Ruby Application Server - http://webroar.in/
+ * Copyright (C) 2009  WebROaR
+ *
+ * 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/>.
+ */
+/******************************************************************************
+ *           worker API declaration
+ *****************************************************************************/
+
+#ifndef WORKER_H_
+#define WORKER_H_
+
+#include <wkr_http.h>
+
+typedef struct wkr_s       wkr_t;
+typedef struct wkr_tmp_s   wkr_tmp_t;
+typedef struct wkr_ctl_s     wkr_ctl_t;
+
+/****** Worket temporary structure ****/
+struct wkr_tmp_s {
+  wr_str_t path;      /**< Application path */
+  wr_str_t env;        /**< Application environment */
+  wr_str_t type;      /**< Application type */
+  wr_str_t name;      /**< Application name */
+  wr_str_t resolver;    /**< Application baseuri */
+  wr_str_t ruby_path;  /**< Ruby library path */
+  wr_str_t script_path;  /**< webroar.rb script path */
+  wr_str_t root_path;    /**< WebROaR root path */
+  char    profiler;      /**< Analytics flag */
+  wr_str_t ctl_path;    /**< Server control path/port */
+  wr_str_t log_file;         /**< Log file name */
+  short   gid;              /**< Process group id */
+  short   uid;              /**< Process user id */
+  short    keep_alive;      /**< HTTP connection keep alive flag */
+  short   is_uds;
+};
+
+wkr_tmp_t* wkr_tmp_new();
+void wkr_tmp_free(wkr_tmp_t**);
+
+/********** Worker Control structure *********/
+struct wkr_ctl_s {
+  int       fd;
+  ev_io      w_read;
+  char      msg[WR_MSG_SIZE];
+  size_t    msg_size;
+  size_t    bytes_read;
+  ev_io     w_write;
+  size_t    bytes_write;
+  scgi_request_t*      scgi_req;
+};
+
+wkr_ctl_t* wkr_ctl_new();
+void wkr_ctl_free(wkr_ctl_t**);
+int send_ack_on_internet_socket(wkr_t* w);
+int send_ack_on_unix_socket(wkr_t* w);
+
+/********** Worker structure *********/
+struct wkr_s {
+  /** Listen request from Head */
+  int       listen_fd;
+  int       listen_port;
+  wr_str_t   sock_path;
+  ev_io     w_accept;
+  struct ev_loop      *loop;
+
+  /** Request */
+  int             req_fd;  /**< Socket fd */
+  ev_io           w_req;  /**< watcher */
+  short          is_uds;
+
+  wkr_ctl_t    *ctl;
+  wkr_tmp_t    *tmp;
+  http_t      *http;
+};
+
+wkr_t* worker_new(struct ev_loop *, wkr_tmp_t*);
+void worker_free(wkr_t**);
+void worker_accept_requests(wkr_t*);
+int worker_connect(wkr_t*);
+
+void sigproc();
+
+#endif /*WORKER_H_*/