agoo 1.2.2 → 2.0.0

data/ext/agoo/rack_logger.h

@@ -8,6 +8,6 @@
 #include "server.h"
 
 extern void	rack_logger_init(VALUE mod);
-extern VALUE	rack_logger_new(Server server);
+extern VALUE	rack_logger_new();
 
 #endif // __AGOO_RACK_LOGGER_H__

data/ext/agoo/request.c

@@ -19,6 +19,7 @@ static VALUE	get_val = Qundef;
 static VALUE	head_val = Qundef;
 static VALUE	http_val = Qundef;
 static VALUE	options_val = Qundef;
+static VALUE	patch_val = Qundef;
 static VALUE	path_info_val = Qundef;
 static VALUE	post_val = Qundef;
 static VALUE	put_val = Qundef;
@@ -29,6 +30,7 @@ static VALUE	rack_logger_val = Qundef;
 static VALUE	rack_multiprocess_val = Qundef;
 static VALUE	rack_multithread_val = Qundef;
 static VALUE	rack_run_once_val = Qundef;
+static VALUE	rack_upgrade_val = Qundef;
 static VALUE	rack_url_scheme_val = Qundef;
 static VALUE	rack_version_val = Qundef;
 static VALUE	rack_version_val_val = Qundef;
@@ -38,12 +40,33 @@ static VALUE	server_name_val = Qundef;
 static VALUE	server_port_val = Qundef;
 static VALUE	slash_val = Qundef;
 
+static VALUE	sse_sym;
+static VALUE	websocket_sym;
+
 static VALUE	stringio_class = Qundef;
 
 static ID	new_id;
 
 static const char	content_type[] = "Content-Type";
 static const char	content_length[] = "Content-Length";
+static const char	connection_key[] = "Connection";
+static const char	upgrade_key[] = "Upgrade";
+static const char	websocket_val[] = "websocket";
+static const char	accept_key[] = "Accept";
+static const char	event_stream_val[] = "text/event-stream";
+
+Req
+request_create(size_t mlen) {
+    size_t	size = mlen + sizeof(struct _Req) - 7;
+    Req		req = (Req)malloc(size);
+    
+    if (NULL != req) {
+	DEBUG_ALLOC(mem_req, req);
+	memset(req, 0, size);
+	req->mlen = mlen;
+    }
+    return req;
+}
 
 static VALUE
 req_method(Req r) {
@@ -60,6 +83,7 @@ req_method(Req r) {
     case OPTIONS:	m = options_val;	break;
     case POST:		m = post_val;		break;
     case PUT:		m = put_val;		break;
+    case PATCH:		m = patch_val;		break;
     default:		m = Qnil;		break;
     }
     return m;
@@ -218,6 +242,26 @@ server_port(VALUE self) {
     return req_server_port((Req)DATA_PTR(self));
 }
 
+static VALUE
+req_rack_upgrade(Req r) {
+    switch (r->upgrade) {
+    case UP_WS:		return websocket_sym;
+    case UP_SSE:	return sse_sym;
+    default:		return Qnil;
+    }
+}
+
+/* Document-method: rack_upgrade?
+ *
+ * call-seq: rack_upgrade?()
+ *
+ * Returns the URL scheme or either _http_ or _https_ as a string.
+ */
+static VALUE
+rack_upgrade(VALUE self) {
+    return req_rack_upgrade((Req)DATA_PTR(self));
+}
+
 /* Document-method: rack_version
  *
  * call-seq: rack_version()
@@ -271,7 +315,7 @@ rack_input(VALUE self) {
 
 static VALUE
 req_rack_errors(Req r) {
-    return error_stream_new(r->server);
+    return error_stream_new();
 }
 
 /* Document-method: rack_errors
@@ -291,7 +335,7 @@ req_rack_multithread(Req r) {
     if (NULL == r) {
 	rb_raise(rb_eArgError, "Request is no longer valid.");
     }
-    if (NULL != r->server && 1 < r->server->thread_cnt) {
+    if (1 < the_server.thread_cnt) {
 	return Qtrue;
     }
     return Qfalse;
@@ -354,13 +398,16 @@ add_header_value(VALUE hh, const char *key, int klen, const char *val, int vlen)
 
 static void
 fill_headers(Req r, VALUE hash) {
-    char		*h = r->header.start;
-    char		*end = h + r->header.len;
-    char		*key = h;
-    char		*kend = key;
-    char		*val = NULL;
-    char		*vend;
-    
+    char	*h = r->header.start;
+    char	*end = h + r->header.len + 1; // +1 for last \r
+    char	*key = h;
+    char	*kend = key;
+    char	*val = NULL;
+    char	*vend;
+    int		klen;
+    bool	upgrade = false;
+    bool	ws = false;
+
     if (NULL == r) {
 	rb_raise(rb_eArgError, "Request is no longer valid.");
     }
@@ -370,22 +417,40 @@ fill_headers(Req r, VALUE hash) {
 	    kend = h;
 	    val = h + 1;
 	    break;
-	case ' ':
-	    if (NULL != val) {
-		val++;
-	    } else {
-		// TBD handle trailing spaces as well
-		key++;
-	    }
-	    break;
 	case '\r':
 	    if (NULL != val) {
+		for (; ' ' == *val; val++) {
+		}
 		vend = h;
 	    }
+	    if (NULL != key) {
+		for (; ' ' == *key; key++) {
+		}
+	    }
 	    if ('\n' == *(h + 1)) {
 		h++;
 	    }
-	    add_header_value(hash, key, (int)(kend - key), val, (int)(vend - val));
+	    klen = (int)(kend - key);
+	    add_header_value(hash, key, klen, val, (int)(vend - val));
+	    if (sizeof(upgrade_key) - 1 == klen && 0 == strncasecmp(key, upgrade_key, sizeof(upgrade_key) - 1)) {
+		if (sizeof(websocket_val) - 1 == vend - val &&
+		    0 == strncasecmp(val, websocket_val, sizeof(websocket_val) - 1)) {
+		    ws = true;
+		}
+	    } else if (sizeof(connection_key) - 1 == klen && 0 == strncasecmp(key, connection_key, sizeof(connection_key) - 1)) {
+		char	buf[1024];
+
+		strncpy(buf, val, vend - val);
+		buf[sizeof(buf)-1] = '\0';
+		if (NULL != strstr(buf, upgrade_key)) {
+		    upgrade = true;
+		}
+	    } else if (sizeof(accept_key) - 1 == klen && 0 == strncasecmp(key, accept_key, sizeof(accept_key) - 1)) {
+		if (sizeof(event_stream_val) - 1 == vend - val &&
+		    0 == strncasecmp(val, event_stream_val, sizeof(event_stream_val) - 1)) {
+		    r->upgrade = UP_SSE;
+		}
+	    }
 	    key = h + 1;
 	    kend = NULL;
 	    val = NULL;
@@ -395,6 +460,9 @@ fill_headers(Req r, VALUE hash) {
 	    break;
 	}
     }
+    if (upgrade && ws) {
+	r->upgrade = UP_WS;
+    }
 }
 
 /* Document-method: headers
@@ -439,7 +507,7 @@ body(VALUE self) {
 
 static VALUE
 req_rack_logger(Req req) {
-    return rack_logger_new(req->server);
+    return rack_logger_new();
 }
 
 /* Document-method: rack_logger
@@ -484,6 +552,7 @@ request_env(Req req) {
     rb_hash_aset(env, rack_multiprocess_val, Qfalse);
     rb_hash_aset(env, rack_run_once_val, Qfalse);
     rb_hash_aset(env, rack_logger_val, req_rack_logger(req));
+    rb_hash_aset(env, rack_upgrade_val, req_rack_upgrade(req));
 
     return env;
 }
@@ -520,7 +589,7 @@ to_s(VALUE self) {
 
 void
 request_destroy(Req req) {
-    DEBUG_FREE(mem_req)
+    DEBUG_FREE(mem_req, req)
     free(req);
 }
 
@@ -557,6 +626,7 @@ request_init(VALUE mod) {
     rb_define_method(req_class, "rack_multithread", rack_multithread, 0);
     rb_define_method(req_class, "rack_multiprocess", rack_multiprocess, 0);
     rb_define_method(req_class, "rack_run_once", rack_run_once, 0);
+    rb_define_method(req_class, "rack_upgrade?", rack_upgrade, 0);
     rb_define_method(req_class, "headers", headers, 0);
     rb_define_method(req_class, "body", body, 0);
     rb_define_method(req_class, "rack_logger", rack_logger, 0);
@@ -579,6 +649,7 @@ request_init(VALUE mod) {
     head_val = rb_str_new_cstr("HEAD");				rb_gc_register_address(&head_val);
     http_val = rb_str_new_cstr("http");				rb_gc_register_address(&http_val);
     options_val = rb_str_new_cstr("OPTIONS");			rb_gc_register_address(&options_val);
+    patch_val = rb_str_new_cstr("PATCH");			rb_gc_register_address(&patch_val);
     path_info_val = rb_str_new_cstr("PATH_INFO");		rb_gc_register_address(&path_info_val);
     post_val = rb_str_new_cstr("POST");				rb_gc_register_address(&post_val);
     put_val = rb_str_new_cstr("PUT");				rb_gc_register_address(&put_val);
@@ -587,8 +658,9 @@ request_init(VALUE mod) {
     rack_input_val = rb_str_new_cstr("rack.input");		rb_gc_register_address(&rack_input_val);
     rack_logger_val = rb_str_new_cstr("rack.logger");		rb_gc_register_address(&rack_logger_val);
     rack_multiprocess_val = rb_str_new_cstr("rack.multiprocess");rb_gc_register_address(&rack_multiprocess_val);
-    rack_multithread_val = rb_str_new_cstr("rack.multithread");rb_gc_register_address(&rack_multithread_val);
+    rack_multithread_val = rb_str_new_cstr("rack.multithread");	rb_gc_register_address(&rack_multithread_val);
     rack_run_once_val = rb_str_new_cstr("rack.run_once");	rb_gc_register_address(&rack_run_once_val);
+    rack_upgrade_val = rb_str_new_cstr("rack.upgrade?");	rb_gc_register_address(&rack_upgrade_val);
     rack_url_scheme_val = rb_str_new_cstr("rack.url_scheme");	rb_gc_register_address(&rack_url_scheme_val);
     rack_version_val = rb_str_new_cstr("rack.version");		rb_gc_register_address(&rack_version_val);
     request_method_val = rb_str_new_cstr("REQUEST_METHOD");	rb_gc_register_address(&request_method_val);
@@ -596,4 +668,7 @@ request_init(VALUE mod) {
     server_name_val = rb_str_new_cstr("SERVER_NAME");		rb_gc_register_address(&server_name_val);
     server_port_val = rb_str_new_cstr("SERVER_PORT");		rb_gc_register_address(&server_port_val);
     slash_val = rb_str_new_cstr("/");				rb_gc_register_address(&slash_val);
+
+    sse_sym = ID2SYM(rb_intern("sse"));				rb_gc_register_address(&sse_sym);
+    websocket_sym = ID2SYM(rb_intern("websocket"));		rb_gc_register_address(&websocket_sym);
 }

data/ext/agoo/request.h

@@ -3,32 +3,43 @@
 #ifndef __AGOO_REQUEST_H__
 #define __AGOO_REQUEST_H__
 
+#include <stdint.h>
+
 #include <ruby.h>
 
 #include "hook.h"
 #include "res.h"
-#include "server.h"
 #include "types.h"
 
+struct _Server;
+
+typedef enum {
+    UP_NONE	= '\0',
+    UP_WS	= 'W',
+    UP_SSE	= 'S',
+} Upgrade;
+
 typedef struct _Str {
     char		*start;
     unsigned int	len;
 } *Str;
 
 typedef struct _Req {
-    Server	server;
-    Method	method;
-    struct _Str	path;
-    struct _Str	query;
-    struct _Str	header;
-    struct _Str	body;
-    VALUE	handler;
-    HookType	handler_type;
-    Res		res;
-    size_t	mlen;   // allocated msg length
-    char	msg[8]; // expanded to be full message
+    Method		method;
+    Upgrade		upgrade;
+    uint64_t		cid;
+    struct _Str		path;
+    struct _Str		query;
+    struct _Str		header;
+    struct _Str		body;
+    VALUE		handler;
+    HookType		handler_type;
+    Res			res;
+    size_t		mlen;   // allocated msg length
+    char		msg[8]; // expanded to be full message
 } *Req;
 
+extern Req	request_create(size_t mlen);
 extern void	request_init(VALUE mod);
 extern VALUE	request_wrap(Req req);
 extern VALUE	request_env(Req req);

data/ext/agoo/res.c

@@ -10,10 +10,13 @@ res_create() {
     Res	res = (Res)malloc(sizeof(struct _Res));
 
     if (NULL != res) {
-	DEBUG_ALLOC(mem_res)
+	DEBUG_ALLOC(mem_res, res)
 	res->next = NULL;
 	atomic_init(&res->message, NULL);
+	res->con_kind = CON_HTTP;
 	res->close = false;
+	res->ping = false;
+	res->pong = false;
     }
     return res;
 }
@@ -26,7 +29,7 @@ res_destroy(Res res) {
 	if (NULL != message) {
 	    text_release(message);
 	}
-	DEBUG_FREE(mem_res)
+	DEBUG_FREE(mem_res, res)
 	free(res);
     }
 }

data/ext/agoo/res.h

@@ -9,11 +9,15 @@
 #include <ruby.h>
 
 #include "text.h"
+#include "types.h"
 
 typedef struct _Res {
     struct _Res		*next;
     _Atomic(Text)	message;
+    ConKind		con_kind;
     bool		close;
+    bool		ping;
+    bool		pong;
 } *Res;
 
 extern Res	res_create();

data/ext/agoo/response.c

@@ -52,23 +52,23 @@ response_free(void *ptr) {
 
     while (NULL != (h = res->headers)) {
 	res->headers = h->next;
-	DEBUG_FREE(mem_header)
+	DEBUG_FREE(mem_header, h);
+	// TBD
 	xfree(h);
     }
-    DEBUG_FREE(mem_res_body);
-    DEBUG_FREE(mem_response);
+    DEBUG_FREE(mem_res_body, res->body);
+    DEBUG_FREE(mem_response, ptr);
     free(res->body); // allocated with strdup
     xfree(ptr);
 }
 
 VALUE
-response_new(Server server ) {
+response_new( ) {
     Response	res = ALLOC(struct _Response);
 
-    DEBUG_ALLOC(mem_response)
+    DEBUG_ALLOC(mem_response, res)
     memset(res, 0, sizeof(struct _Response));
     res->code = 200;
-    res->server = server;
     
     return Data_Wrap_Struct(res_class, NULL, response_free, res);
 }
@@ -85,7 +85,7 @@ to_s(VALUE self) {
     int		len = response_len(res);
     char	*s = ALLOC_N(char, len + 1);
 
-    DEBUG_ALLOC(mem_to_s)
+    DEBUG_ALLOC(mem_to_s, s)
     response_fill(res, s);
     
     return rb_str_new(s, len);
@@ -133,10 +133,11 @@ body_set(VALUE self, VALUE val) {
 
     if (T_STRING == rb_type(val)) {
 	res->body = strdup(StringValuePtr(val));
-	DEBUG_ALLOC(mem_res_body)
+	DEBUG_ALLOC(mem_res_body, res->body)
 	res->blen = (int)RSTRING_LEN(val);
     } else {
-	// TBD use Oj
+	rb_raise(rb_eArgError, "Expected a string");
+	// TBD use Oj to encode val
     }
     return Qnil;
 }
@@ -215,7 +216,7 @@ head_set(VALUE self, VALUE key, VALUE val) {
 	    } else {
 		prev->next = h->next;
 	    }
-	    DEBUG_FREE(mem_header)
+	    DEBUG_FREE(mem_header, h);
 	    xfree(h);
 	    break;
 	}
@@ -227,12 +228,12 @@ head_set(VALUE self, VALUE key, VALUE val) {
     vs = StringValuePtr(val);
     vlen = (int)RSTRING_LEN(val);
 
-    if (res->server->pedantic) {
+    if (the_server.pedantic) {
 	http_header_ok(ks, klen, vs, vlen);
     }
     hlen = klen + vlen + 4;
     h = (Header)ALLOC_N(char, sizeof(struct _Header) - 8 + hlen + 1);
-    DEBUG_ALLOC(mem_header)
+    DEBUG_ALLOC(mem_header, h)
 
     h->next = NULL;
     h->len = hlen;

data/ext/agoo/response.h

@@ -22,12 +22,11 @@ typedef struct _Response {
     Header	headers;
     int		blen;
     char	*body;
-    Server	server;
 } *Response;
 
 extern void	response_init(VALUE mod);
 
-extern VALUE	response_new(Server server);
+extern VALUE	response_new();
 extern Text	response_text(VALUE self);
 
 #endif // __AGOO_RESPONSE_H__

data/ext/agoo/server.c

@@ -6,7 +6,6 @@
 #include <netdb.h>
 #include <netinet/tcp.h>
 #include <poll.h>
-#include <signal.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -19,6 +18,7 @@
 
 #include <ruby.h>
 #include <ruby/thread.h>
+#include <ruby/encoding.h>
 
 #include "con.h"
 #include "debug.h"
@@ -28,8 +28,14 @@
 #include "response.h"
 #include "request.h"
 #include "server.h"
+#include "sse.h"
+#include "sub.h"
+#include "upgraded.h"
+#include "websocket.h"
 
-static VALUE	server_class = Qundef;
+extern void	agoo_shutdown();
+
+static VALUE	server_mod = Qundef;
 
 static VALUE	connect_sym;
 static VALUE	delete_sym;
@@ -37,102 +43,79 @@ static VALUE	get_sym;
 static VALUE	head_sym;
 static VALUE	options_sym;
 static VALUE	post_sym;
+static VALUE	push_env_key;
 static VALUE	put_sym;
 
 static ID	call_id;
 static ID	each_id;
+static ID	on_close_id;
+static ID	on_drained_id;
+static ID	on_message_id;
 static ID	on_request_id;
 static ID	to_i_id;
 
-static Server	the_server = NULL;
+static const char	err500[] = "HTTP/1.1 500 Internal Server Error\r\n";
 
-static void
-shutdown_server(Server server) {
-    if (NULL != server && server->active) {
-	the_server = NULL;
-
-	log_cat(&server->info_cat, "Agoo shutting down.");
-	server->active = false;
-	if (0 != server->listen_thread) {
-	    pthread_join(server->listen_thread, NULL);
-	    server->listen_thread = 0;
-	}
-	if (0 != server->con_thread) {
-	    pthread_join(server->con_thread, NULL);
-	    server->con_thread = 0;
-	}
-	queue_cleanup(&server->con_queue);
-	// The preferred method to of waiting for the ruby threads would be
-	// either a join or even a kill but since we don't have the gvi here
-	// that would cause a segfault. Instead we set a timeout and wait for
-	// the running counter to drop to zero.
-	if (NULL != server->eval_threads) {
-	    double	timeout = dtime() + 2.0;
-
-	    while (dtime() < timeout) {
-		if (0 >= atomic_load(&server->running)) {
-		    break;
+struct _Server	the_server = {false};
+
+void
+server_shutdown() {
+    if (the_server.inited) {
+	log_cat(&info_cat, "Agoo shutting down.");
+	the_server.inited = false;
+	if (the_server.active) {
+	    the_server.active = false;
+	    if (0 != the_server.listen_thread) {
+		pthread_join(the_server.listen_thread, NULL);
+		the_server.listen_thread = 0;
+	    }
+	    if (0 != the_server.con_thread) {
+		pthread_join(the_server.con_thread, NULL);
+		the_server.con_thread = 0;
+	    }
+	    sub_cleanup(&the_server.sub_cache);
+	    cc_cleanup(&the_server.con_cache);
+	    // The preferred method to of waiting for the ruby threads would
+	    // be either a join or even a kill but since we may not have the
+	    // gvl here that would cause a segfault. Instead we set a timeout
+	    // and wait for the running counter to drop to zero.
+	    if (NULL != the_server.eval_threads) {
+		double	timeout = dtime() + 2.0;
+
+		while (dtime() < timeout) {
+		    if (0 >= atomic_load(&the_server.running)) {
+			break;
+		    }
+		    dsleep(0.02);
 		}
-		dsleep(0.02);
+		DEBUG_FREE(mem_eval_threads, the_server.eval_threads);
+		free(the_server.eval_threads); // TBD use regular malloc and free
+		the_server.eval_threads = NULL;
 	    }
-	    DEBUG_FREE(mem_eval_threads)
-	    xfree(server->eval_threads);
-	    server->eval_threads = NULL;
-	}
-	while (NULL != server->hooks) {
-	    Hook	h = server->hooks;
+	    while (NULL != the_server.hooks) {
+		Hook	h = the_server.hooks;
 
-	    server->hooks = h->next;
-	    hook_destroy(h);
+		the_server.hooks = h->next;
+		hook_destroy(h);
+	    }
 	}
-	queue_cleanup(&server->eval_queue);
-	log_close(&server->log);
-	debug_print_stats();    
+	queue_cleanup(&the_server.con_queue);
+	queue_cleanup(&the_server.pub_queue);
+	queue_cleanup(&the_server.eval_queue);
+	cache_cleanup(&the_server.pages);
+	http_cleanup();
     }
 }
 
-static void
-sig_handler(int sig) {
-    if (NULL != the_server) {
-	shutdown_server(the_server);
-    }
-    // Use exit instead of rb_exit as rb_exit segfaults most of the time.
-    //rb_exit(0);
-    exit(0);
-}
-
-static void
-server_free(void *ptr) {
-    shutdown_server((Server)ptr);
-    // Commented out for now as it causes a segfault later. Some thread seems
-    //to be pointing at it even though they have exited so live with a memory
-    //leak that only shows up when the program exits.
-    //xfree(ptr);
-    DEBUG_FREE(mem_server)
-    the_server = NULL;
-}
-
 static int
-configure(Err err, Server s, int port, const char *root, VALUE options) {
-    s->port = port;
-    s->root = strdup(root);
-    s->thread_cnt = 0;
-    s->running = 0;
-    s->listen_thread = 0;
-    s->con_thread = 0;
-    s->log.cats = NULL;
-    log_cat_reg(&s->log, &s->error_cat, "ERROR",    ERROR, RED, true);
-    log_cat_reg(&s->log, &s->warn_cat,  "WARN",     WARN,  YELLOW, true);
-    log_cat_reg(&s->log, &s->info_cat,  "INFO",     INFO,  GREEN, true);
-    log_cat_reg(&s->log, &s->debug_cat, "DEBUG",    DEBUG, GRAY, false);
-    log_cat_reg(&s->log, &s->con_cat,   "connect",  INFO,  GREEN, false);
-    log_cat_reg(&s->log, &s->req_cat,   "request",  INFO,  CYAN, false);
-    log_cat_reg(&s->log, &s->resp_cat,  "response", INFO,  DARK_CYAN, false);
-    log_cat_reg(&s->log, &s->eval_cat,  "eval",     INFO,  BLUE, false);
-
-    if (ERR_OK != log_init(err, &s->log, options)) {
-	return err->code;
-    }
+configure(Err err, int port, const char *root, VALUE options) {
+    the_server.port = port;
+    the_server.root = strdup(root);
+    the_server.thread_cnt = 0;
+    the_server.running = 0;
+    the_server.listen_thread = 0;
+    the_server.con_thread = 0;
+    the_server.max_push_pending = 32;
     if (Qnil != options) {
 	VALUE	v;
 
@@ -140,24 +123,33 @@ configure(Err err, Server s, int port, const char *root, VALUE options) {
 	    int	tc = FIX2INT(v);
 
 	    if (1 <= tc || tc < 1000) {
-		s->thread_cnt = tc;
+		the_server.thread_cnt = tc;
 	    } else {
 		rb_raise(rb_eArgError, "thread_count must be between 1 and 1000.");
 	    }
 	}
+	if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("max_push_pending"))))) {
+	    int	tc = FIX2INT(v);
+
+	    if (0 <= tc || tc < 1000) {
+		the_server.thread_cnt = tc;
+	    } else {
+		rb_raise(rb_eArgError, "thread_count must be between 0 and 1000.");
+	    }
+	}
 	if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("pedantic"))))) {
-	    s->pedantic = (Qtrue == v);
+	    the_server.pedantic = (Qtrue == v);
 	}
 	if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("Port"))))) {
 	    if (rb_cInteger == rb_obj_class(v)) {
-		s->port = NUM2INT(v);
+		the_server.port = NUM2INT(v);
 	    } else {
 		switch (rb_type(v)) {
 		case T_STRING:
-		    s->port = atoi(StringValuePtr(v));
+		    the_server.port = atoi(StringValuePtr(v));
 		    break;
 		case T_FIXNUM:
-		    s->port = NUM2INT(v);
+		    the_server.port = NUM2INT(v);
 		    break;
 		default:
 		    break;
@@ -166,30 +158,31 @@ configure(Err err, Server s, int port, const char *root, VALUE options) {
 	}
 	if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("quiet"))))) {
 	    if (Qtrue == v) {
-		s->info_cat.on = false;
+		info_cat.on = false;
 	    }
 	}
 	if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("debug"))))) {
 	    if (Qtrue == v) {
-		s->error_cat.on = true;
-		s->warn_cat.on = true;
-		s->info_cat.on = true;
-		s->debug_cat.on = true;
-		s->con_cat.on = true;
-		s->req_cat.on = true;
-		s->resp_cat.on = true;
-		s->eval_cat.on = true;
+		error_cat.on = true;
+		warn_cat.on = true;
+		info_cat.on = true;
+		debug_cat.on = true;
+		con_cat.on = true;
+		req_cat.on = true;
+		resp_cat.on = true;
+		eval_cat.on = true;
+		push_cat.on = true;
 	    }
 	}
     }
     return ERR_OK;
 }
 
-/* Document-method: new
+/* Document-method: init
  *
- * call-seq: new(port, root, options)
+ * call-seq: init(port, root, options)
  *
- * Creates a new server that will listen on the designated _port_ and using
+ * Configures the server that will listen on the designated _port_ and using
  * the _root_ as the root of the static resources. Logging is feature based
  * and not level based and the options reflect that approach.
  *
@@ -198,35 +191,16 @@ configure(Err err, Server s, int port, const char *root, VALUE options) {
  *   - *:pedantic* [_true_|_false_] if true response header and status codes are check and an exception raised if they violate the rack spec at https://github.com/rack/rack/blob/master/SPEC, https://tools.ietf.org/html/rfc3875#section-4.1.18, or https://tools.ietf.org/html/rfc7230.
  *
  *   - *:thread_count* [_Integer_] number of ruby worker threads. Defaults to one. If zero then the _start_ function will not return but instead will proess using the thread that called _start_. Usually the default is best unless the workers are making IO calls.
- *
- *   - *:log_dir* [_String_] directory to place log files in. If nil or empty then no log files are written.
- *
- *   - *:log_console* [_true_|_false_] if true log entry are display on the console.
- *
- *   - *:log_classic* [_true_|_false_] if true log entry follow a classic format. If false log entries are JSON.
- *
- *   - *:log_colorize* [_true_|_false_] if true log entries are colorized.
- *
- *   - *:log_states* [_Hash_] a map of logging categories and whether they should be on or off. Categories are:
- *     - *:ERROR* errors
- *     - *:WARN* warnings
- *     - *:INFO* infomational
- *     - *:DEBUG* debugging
- *     - *:connect* openning and closing of connections
- *     - *:request* requests
- *     - *:response* responses
- *     - *:eval* handler evaluationss
  */
 static VALUE
-server_new(int argc, VALUE *argv, VALUE self) {
-    Server	s;
+rserver_init(int argc, VALUE *argv, VALUE self) {
     struct _Err	err = ERR_INIT;
     int		port;
     const char	*root;
     VALUE	options = Qnil;
-    
+
     if (argc < 2 || 3 < argc) {
-	rb_raise(rb_eArgError, "Wrong number of arguments to Agoo::Server.new.");
+	rb_raise(rb_eArgError, "Wrong number of arguments to Agoo::Server.configure.");
     }
     port = FIX2INT(argv[0]);
     rb_check_type(argv[1], T_STRING);
@@ -234,27 +208,25 @@ server_new(int argc, VALUE *argv, VALUE self) {
     if (3 <= argc) {
 	options = argv[2];
     }
-    s = ALLOC(struct _Server);
-    DEBUG_ALLOC(mem_server)
-    memset(s, 0, sizeof(struct _Server));
-    if (ERR_OK != configure(&err, s, port, root, options)) {
-	xfree(s);
-	DEBUG_FREE(mem_server)
-	// TBD raise Agoo specific exception
+    memset(&the_server, 0, sizeof(struct _Server));
+    if (ERR_OK != configure(&err, port, root, options)) {
 	rb_raise(rb_eArgError, "%s", err.msg);
     }
-    queue_multi_init(&s->con_queue, 256, false, false);
-    queue_multi_init(&s->eval_queue, 1024, false, true);
+    queue_multi_init(&the_server.con_queue, 256, false, false);
+    queue_multi_init(&the_server.pub_queue, 256, true, false);
+    queue_multi_init(&the_server.eval_queue, 1024, false, true);
 
-    cache_init(&s->pages);
-    the_server = s;
+    cache_init(&the_server.pages);
+    cc_init(&the_server.con_cache);
+    sub_init(&the_server.sub_cache);
     
-    return Data_Wrap_Struct(server_class, NULL, server_free, s);
+    the_server.inited = true;
+
+    return Qnil;
 }
 
 static void*
 listen_loop(void *x) {
-    Server		server = (Server)x;
     struct sockaddr_in	addr;
     int			optval = 1;
     struct pollfd	pa[1];
@@ -267,10 +239,9 @@ listen_loop(void *x) {
     int			i;
     uint64_t		cnt = 0;
 
-    atomic_fetch_add(&server->running, 1);
     if (0 >= (pa->fd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP))) {
-	log_cat(&server->error_cat, "Server failed to open server socket. %s.", strerror(errno));
-	atomic_fetch_sub(&server->running, 1);
+	log_cat(&error_cat, "Server failed to open server socket. %s.", strerror(errno));
+	atomic_fetch_sub(&the_server.running, 1);
 	return NULL;
     }
 #ifdef OSX_OS 
@@ -279,26 +250,26 @@ listen_loop(void *x) {
     memset(&addr, 0, sizeof(addr));
     addr.sin_family = AF_INET;
     addr.sin_addr.s_addr = INADDR_ANY;
-    addr.sin_port = htons(server->port);
+    addr.sin_port = htons(the_server.port);
     setsockopt(pa->fd, SOL_SOCKET, SO_REUSEPORT, &optval, sizeof(optval));
     setsockopt(pa->fd, IPPROTO_TCP, TCP_NODELAY, &optval, sizeof(optval));
     if (0 > bind(fp->fd, (struct sockaddr*)&addr, sizeof(addr))) {
-	log_cat(&server->error_cat, "Server failed to bind server socket. %s.", strerror(errno));
-	atomic_fetch_sub(&server->running, 1);
+	log_cat(&error_cat, "Server failed to bind server socket. %s.", strerror(errno));
+	atomic_fetch_sub(&the_server.running, 1);
 	return NULL;
     }
     listen(pa->fd, 1000);
-    server->ready = true;
     pa->events = POLLIN;
     pa->revents = 0;
 
     memset(&client_addr, 0, sizeof(client_addr));
-    while (server->active) {
+    atomic_fetch_add(&the_server.running, 1);
+    while (the_server.active) {
 	if (0 > (i = poll(pa, 1, 100))) {
 	    if (EAGAIN == errno) {
 		continue;
 	    }
-	    log_cat(&server->error_cat, "Server polling error. %s.", strerror(errno));
+	    log_cat(&error_cat, "Server polling error. %s.", strerror(errno));
 	    // Either a signal or something bad like out of memory. Might as well exit.
 	    break;
 	}
@@ -307,9 +278,9 @@ listen_loop(void *x) {
 	}
 	if (0 != (pa->revents & POLLIN)) {
 	    if (0 > (client_sock = accept(pa->fd, (struct sockaddr*)&client_addr, &alen))) {
-		log_cat(&server->error_cat, "Server accept connection failed. %s.", strerror(errno));
-	    } else if (NULL == (con = con_create(&err, server, client_sock, ++cnt))) {
-		log_cat(&server->error_cat, "Server accept connection failed. %s.", err.msg);
+		log_cat(&error_cat, "Server accept connection failed. %s.", strerror(errno));
+	    } else if (NULL == (con = con_create(&err, client_sock, ++cnt))) {
+		log_cat(&error_cat, "Server accept connection failed. %s.", err.msg);
 		close(client_sock);
 		cnt--;
 		err_clear(&err);
@@ -320,22 +291,22 @@ listen_loop(void *x) {
 		fcntl(client_sock, F_SETFL, O_NONBLOCK);
 		setsockopt(client_sock, SOL_SOCKET, SO_KEEPALIVE, &optval, sizeof(optval));
 		setsockopt(client_sock, IPPROTO_TCP, TCP_NODELAY, &optval, sizeof(optval));
-		log_cat(&server->con_cat, "Server accepted connection %llu on port %d [%d]", (unsigned long long)cnt, server->port, con->sock);
-		queue_push(&server->con_queue, (void*)con);
+		log_cat(&con_cat, "Server accepted connection %llu on port %d [%d]", (unsigned long long)cnt, the_server.port, con->sock);
+		queue_push(&the_server.con_queue, (void*)con);
 	    }
 	}
 	if (0 != (pa->revents & (POLLERR | POLLHUP | POLLNVAL))) {
 	    if (0 != (pa->revents & (POLLHUP | POLLNVAL))) {
-		log_cat(&server->error_cat, "Agoo server socket on port %d closed.", server->port);
+		log_cat(&error_cat, "Agoo server socket on port %d closed.", the_server.port);
 	    } else {
-		log_cat(&server->error_cat, "Agoo server socket on port %d error.", server->port);
+		log_cat(&error_cat, "Agoo server socket on port %d error.", the_server.port);
 	    }
-	    server->active = false;
+	    the_server.active = false;
 	}
 	pa->revents = 0;
     }
     close(pa->fd);
-    atomic_fetch_sub(&server->running, 1);
+    atomic_fetch_sub(&the_server.running, 1);
 
     return NULL;
 }
@@ -362,7 +333,7 @@ rescue_error(VALUE x) {
 
     req->res->close = true;
     res_set_message(req->res, message);
-    queue_wakeup(&req->server->con_queue);
+    queue_wakeup(&the_server.con_queue);
 
     return Qfalse;
 }
@@ -371,13 +342,13 @@ static VALUE
 handle_base_inner(void *x) {
     Req			req = (Req)x;
     volatile VALUE	rr = request_wrap(req);
-    volatile VALUE	rres = response_new(req->server);
+    volatile VALUE	rres = response_new();
     
     rb_funcall(req->handler, on_request_id, 2, rr, rres);
     DATA_PTR(rr) = NULL;
 
     res_set_message(req->res, response_text(rres));
-    queue_wakeup(&req->server->con_queue);
+    queue_wakeup(&the_server.con_queue);
 
     return Qfalse;
 }
@@ -512,13 +483,44 @@ handle_rack_inner(void *x) {
 	t->len = snprintf(t->text, 1024, "HTTP/1.1 %d %s\r\nContent-Length: %d\r\n", code, status_msg, bsize);
 	break;
     }
+    if (code < 300) {
+	switch (req->upgrade) {
+	case UP_WS:
+	    if (CON_WS != req->res->con_kind ||
+		Qnil == (req->handler = rb_hash_lookup(env, push_env_key))) {
+		strcpy(t->text, err500);
+		t->len = sizeof(err500) - 1;
+		break;
+	    }
+	    req->handler_type = PUSH_HOOK;
+	    upgraded_extend(req->cid, req->handler);
+	    t->len = snprintf(t->text, 1024, "HTTP/1.1 101 %s\r\n", status_msg);
+	    t = ws_add_headers(req, t);
+	    break;
+	case UP_SSE:
+	    if (CON_SSE != req->res->con_kind ||
+		Qnil == (req->handler = rb_hash_lookup(env, push_env_key))) {
+		strcpy(t->text, err500);
+		t->len = sizeof(err500) - 1;
+		break;
+	    }
+	    req->handler_type = PUSH_HOOK;
+	    upgraded_extend(req->cid, req->handler);
+	    t = sse_upgrade(req, t);
+	    res_set_message(req->res, t);
+	    queue_wakeup(&the_server.con_queue);
+	    return Qfalse;
+	default:
+	    break;
+	}
+    }
     if (HEAD == req->method) {
 	bsize = 0;
     } else {
 	if (T_HASH == rb_type(hv)) {
 	    rb_hash_foreach(hv, header_cb, (VALUE)&t);
 	} else {
-	    rb_iterate (rb_each, hv, header_each_cb, (VALUE)&t);
+	    rb_iterate(rb_each, hv, header_each_cb, (VALUE)&t);
 	}
     }
     t = text_append(t, "\r\n", 2);
@@ -537,7 +539,7 @@ handle_rack_inner(void *x) {
 	}
     }
     res_set_message(req->res, t);
-    queue_wakeup(&req->server->con_queue);
+    queue_wakeup(&the_server.con_queue);
 
     return Qfalse;
 }
@@ -559,13 +561,13 @@ static VALUE
 handle_wab_inner(void *x) {
     Req			req = (Req)x;
     volatile VALUE	rr = request_wrap(req);
-    volatile VALUE	rres = response_new(req->server);
+    volatile VALUE	rres = response_new();
     
     rb_funcall(req->handler, on_request_id, 2, rr, rres);
     DATA_PTR(rr) = NULL;
 
     res_set_message(req->res, response_text(rres));
-    queue_wakeup(&req->server->con_queue);
+    queue_wakeup(&the_server.con_queue);
 
     return Qfalse;
 }
@@ -576,17 +578,73 @@ handle_wab(void *x) {
 
     return NULL;
 }
+
+static VALUE
+handle_push_inner(void *x) {
+    Req	req = (Req)x;
+
+    switch (req->method) {
+    case ON_MSG:
+	rb_funcall(req->handler, on_message_id, 1, rb_str_new(req->msg, req->mlen));
+	break;
+    case ON_BIN: {
+	volatile VALUE	rstr = rb_str_new(req->msg, req->mlen);
+
+	rb_enc_associate(rstr, rb_ascii8bit_encoding());
+	rb_funcall(req->handler, on_message_id, 1, rstr);
+	break;
+    }
+    case ON_CLOSE:
+	rb_funcall(req->handler, on_close_id, 0);
+	break;
+    case ON_SHUTDOWN:
+	rb_funcall(req->handler, rb_intern("on_shutdown"), 0);
+	break;
+    case ON_EMPTY:
+	rb_funcall(req->handler, on_drained_id, 0);
+	break;
+    default:
+	break;
+    }
+    return Qfalse;
+}
+
+static void*
+handle_push(void *x) {
+    rb_rescue2(handle_push_inner, (VALUE)x, rescue_error, (VALUE)x, rb_eException, 0);
+    return NULL;
+}
+
 static void
-handle_protected(Req req) {
+handle_protected(Req req, bool gvi) {
     switch (req->handler_type) {
     case BASE_HOOK:
-	rb_thread_call_with_gvl(handle_base, req);
+	if (gvi) {
+	    rb_thread_call_with_gvl(handle_base, req);
+	} else {
+	    handle_base(req);
+	}
 	break;
     case RACK_HOOK:
-	rb_thread_call_with_gvl(handle_rack, req);
+	if (gvi) {
+	    rb_thread_call_with_gvl(handle_rack, req);
+	} else {
+	    handle_rack(req);
+	}
 	break;
     case WAB_HOOK:
-	rb_thread_call_with_gvl(handle_wab, req);
+	if (gvi) {
+	    rb_thread_call_with_gvl(handle_wab, req);
+	} else {
+	    handle_wab(req);
+	}
+	break;
+    case PUSH_HOOK:
+	if (gvi) {
+	    rb_thread_call_with_gvl(handle_push, req);
+	} else {
+	    handle_push(req);
+	}
 	break;
     default: {
 	char	buf[256];
@@ -595,7 +653,7 @@ handle_protected(Req req) {
 	
 	req->res->close = true;
 	res_set_message(req->res, message);
-	queue_wakeup(&req->server->con_queue);
+	queue_wakeup(&the_server.con_queue);
 	break;
     }
     }
@@ -603,25 +661,23 @@ handle_protected(Req req) {
 
 static void*
 process_loop(void *ptr) {
-    Server	server = (Server)ptr;
-    Req		req;
+    Req	req;
     
-    atomic_fetch_add(&server->running, 1);
-    while (server->active) {
-	if (NULL != (req = (Req)queue_pop(&server->eval_queue, 0.1))) {
-	    handle_protected(req);
-	    free(req);
-	    DEBUG_FREE(mem_req)
+    atomic_fetch_add(&the_server.running, 1);
+    while (the_server.active) {
+	if (NULL != (req = (Req)queue_pop(&the_server.eval_queue, 0.1))) {
+	    handle_protected(req, true);
+	    request_destroy(req);
 	}
     }
-    atomic_fetch_sub(&server->running, 1);
-    
+    atomic_fetch_sub(&the_server.running, 1);
+
     return NULL;
 }
 
 static VALUE
 wrap_process_loop(void *ptr) {
-    rb_thread_call_without_gvl(process_loop, ptr, RUBY_UBF_IO, NULL);
+    rb_thread_call_without_gvl(process_loop, NULL, RUBY_UBF_IO, NULL);
     return Qnil;
 }
 
@@ -632,73 +688,60 @@ wrap_process_loop(void *ptr) {
  * Start the server.
  */
 static VALUE
-start(VALUE self) {
-    Server	server = (Server)DATA_PTR(self);
+server_start(VALUE self) {
     VALUE	*vp;
     int		i;
     double	giveup;
     
-    server->active = true;
-    server->ready = false;
+    the_server.active = true;
 
-    pthread_create(&server->listen_thread, NULL, listen_loop, server);
-    pthread_create(&server->con_thread, NULL, con_loop, server);
+    pthread_create(&the_server.listen_thread, NULL, listen_loop, NULL);
+    pthread_create(&the_server.con_thread, NULL, con_loop, NULL);
     
     giveup = dtime() + 1.0;
     while (dtime() < giveup) {
-	if (server->ready) {
+	if (2 <= atomic_load(&the_server.running)) {
 	    break;
 	}
-	dsleep(0.001);
+	dsleep(0.01);
     }
-    signal(SIGINT, sig_handler);
-    signal(SIGTERM, sig_handler);
-    signal(SIGPIPE, SIG_IGN);
-
-    if (server->info_cat.on) {
+    if (info_cat.on) {
 	VALUE	agoo = rb_const_get_at(rb_cObject, rb_intern("Agoo"));
 	VALUE	v = rb_const_get_at(agoo, rb_intern("VERSION"));
 					       
-	log_cat(&server->info_cat, "Agoo %s listening on port %d.", StringValuePtr(v), server->port);
+	log_cat(&info_cat, "Agoo %s listening on port %d.", StringValuePtr(v), the_server.port);
     }
-    if (0 >= server->thread_cnt) {
+    if (0 >= the_server.thread_cnt) {
 	Req		req;
 
-	while (server->active) {
-	    if (NULL != (req = (Req)queue_pop(&server->eval_queue, 0.1))) {
-		switch (req->handler_type) {
-		case BASE_HOOK:
-		    handle_base(req);
-		    break;
-		case RACK_HOOK:
-		    handle_rack(req);
-		    break;
-		case WAB_HOOK:
-		    handle_wab(req);
-		    break;
-		default: {
-		    char	buf[256];
-		    int		cnt = snprintf(buf, sizeof(buf), "HTTP/1.1 500 Internal Error\r\nConnection: Close\r\nContent-Length: 0\r\n\r\n");
-		    Text	message = text_create(buf, cnt);
-	
-		    req->res->close = true;
-		    res_set_message(req->res, message);
-		    queue_wakeup(&req->server->con_queue);
-		    break;
-		}
-		}
-		free(req);
-		DEBUG_FREE(mem_req)
+	while (the_server.active) {
+	    if (NULL != (req = (Req)queue_pop(&the_server.eval_queue, 0.1))) {
+		handle_protected(req, false);
+		request_destroy(req);
+	    } else {
+		rb_thread_schedule();
 	    }
+
 	}
     } else {
-	server->eval_threads = ALLOC_N(VALUE, server->thread_cnt + 1);
-	DEBUG_ALLOC(mem_eval_threads)
+	the_server.eval_threads = (VALUE*)malloc(sizeof(VALUE) * (the_server.thread_cnt + 1));
+	DEBUG_ALLOC(mem_eval_threads, the_server.eval_threads);
 
-	for (i = server->thread_cnt, vp = server->eval_threads; 0 < i; i--, vp++) {
-	    *vp = rb_thread_create(wrap_process_loop, server);
+	for (i = the_server.thread_cnt, vp = the_server.eval_threads; 0 < i; i--, vp++) {
+	    *vp = rb_thread_create(wrap_process_loop, NULL);
 	}
 	*vp = Qnil;
+
+	giveup = dtime() + 1.0;
+	while (dtime() < giveup) {
+	    // The processing threads will not start until this thread
+	    // releases ownership so do that and then see if the threads has
+	    // been started yet.
+	    rb_thread_schedule();
+	    if (2 + the_server.thread_cnt <= atomic_load(&the_server.running)) {
+		break;
+	    }
+	}
     }
     return Qnil;
 }
@@ -710,176 +753,8 @@ start(VALUE self) {
  * Shutdown the server. Logs and queues are flushed before shutting down.
  */
 static VALUE
-server_shutdown(VALUE self) {
-    shutdown_server((Server)DATA_PTR(self));
-    return Qnil;
-}
-
-/* Document-method: error?
- *
- * call-seq: error?()
- *
- * Returns true is errors are being logged.
- */
-static VALUE
-log_errorp(VALUE self) {
-    return ((Server)DATA_PTR(self))->error_cat.on ? Qtrue : Qfalse;
-}
-
-/* Document-method: warn?
- *
- * call-seq: warn?()
- *
- * Returns true is warnings are being logged.
- */
-static VALUE
-log_warnp(VALUE self) {
-    return ((Server)DATA_PTR(self))->warn_cat.on ? Qtrue : Qfalse;
-}
-
-/* Document-method: info?
- *
- * call-seq: info?()
- *
- * Returns true is info entries are being logged.
- */
-static VALUE
-log_infop(VALUE self) {
-    return ((Server)DATA_PTR(self))->info_cat.on ? Qtrue : Qfalse;
-}
-
-/* Document-method: debug?
- *
- * call-seq: debug?()
- *
- * Returns true is debug entries are being logged.
- */
-static VALUE
-log_debugp(VALUE self) {
-    return ((Server)DATA_PTR(self))->debug_cat.on ? Qtrue : Qfalse;
-}
-
-/* Document-method: eval?
- *
- * call-seq: eval?()
- *
- * Returns true is handler evaluation entries are being logged.
- */
-static VALUE
-log_evalp(VALUE self) {
-    return ((Server)DATA_PTR(self))->eval_cat.on ? Qtrue : Qfalse;
-}
-
-/* Document-method: error
- *
- * call-seq: error(msg)
- *
- * Log an error message.
- */
-static VALUE
-log_error(VALUE self, VALUE msg) {
-    log_cat(&((Server)DATA_PTR(self))->error_cat, "%s", StringValuePtr(msg));
-    return Qnil;
-}
-
-/* Document-method: warn
- *
- * call-seq: warn(msg)
- *
- * Log a warn message.
- */
-static VALUE
-log_warn(VALUE self, VALUE msg) {
-    log_cat(&((Server)DATA_PTR(self))->warn_cat, "%s", StringValuePtr(msg));
-    return Qnil;
-}
-
-/* Document-method: info
- *
- * call-seq: info(msg)
- *
- * Log an info message.
- */
-static VALUE
-log_info(VALUE self, VALUE msg) {
-    log_cat(&((Server)DATA_PTR(self))->info_cat, "%s", StringValuePtr(msg));
-    return Qnil;
-}
-
-/* Document-method: debug
- *
- * call-seq: debug(msg)
- *
- * Log a debug message.
- */
-static VALUE
-log_debug(VALUE self, VALUE msg) {
-    log_cat(&((Server)DATA_PTR(self))->debug_cat, "%s", StringValuePtr(msg));
-    return Qnil;
-}
-
-/* Document-method: log_eval
- *
- * call-seq: log_eval(msg)
- *
- * Log an eval message.
- */
-static VALUE
-log_eval(VALUE self, VALUE msg) {
-    log_cat(&((Server)DATA_PTR(self))->eval_cat, "%s", StringValuePtr(msg));
-    return Qnil;
-}
-
-/* Document-method: log_state
- *
- * call-seq: log_state(label)
- *
- * Return the logging state of the category identified by the _label_.
- */
-static VALUE
-log_state(VALUE self, VALUE label) {
-    Server	server = (Server)DATA_PTR(self);
-    LogCat	cat = log_cat_find(&server->log, StringValuePtr(label));
-
-    if (NULL == cat) {
-	rb_raise(rb_eArgError, "%s is not a valid log category.", StringValuePtr(label));
-    }
-    return cat->on ? Qtrue : Qfalse;
-}
-
-/* Document-method: set_log_state
- *
- * call-seq: set_log_state(label, state)
- *
- * Set the logging state of the category identified by the _label_.
- */
-static VALUE
-set_log_state(VALUE self, VALUE label, VALUE on) {
-    Server	server = (Server)DATA_PTR(self);
-    LogCat	cat = log_cat_find(&server->log, StringValuePtr(label));
-
-    if (NULL == cat) {
-	rb_raise(rb_eArgError, "%s is not a valid log category.", StringValuePtr(label));
-    }
-    cat->on = (Qtrue == on);
-
-    return Qnil;
-}
-
-/* Document-method: log_flush
- *
- * call-seq: log_flush()
- *
- * Flush the log queue and write all entries to disk or the console. The call
- * waits for the flush to complete.
- */
-static VALUE
-server_log_flush(VALUE self, VALUE to) {
-    double	timeout = NUM2DBL(to);
-    
-    if (!log_flush(&((Server)DATA_PTR(self))->log, timeout)) {
-	rb_raise(rb_eStandardError, "timed out waiting for log flush.");
-    }
+rserver_shutdown(VALUE self) {
+    server_shutdown();
     return Qnil;
 }
 
@@ -893,7 +768,6 @@ server_log_flush(VALUE self, VALUE to) {
  */
 static VALUE
 handle(VALUE self, VALUE method, VALUE pattern, VALUE handler) {
-    Server	server = (Server)DATA_PTR(self);
     Hook	hook;
     Method	meth = ALL;
     const char	*pat;
@@ -926,13 +800,13 @@ handle(VALUE self, VALUE method, VALUE pattern, VALUE handler) {
 	Hook	h;
 	Hook	prev = NULL;
 
-	for (h = server->hooks; NULL != h; h = h->next) {
+	for (h = the_server.hooks; NULL != h; h = h->next) {
 	    prev = h;
 	}
 	if (NULL != prev) {
 	    prev->next = hook;
 	} else {
-	    server->hooks = hook;
+	    the_server.hooks = hook;
 	}
 	rb_gc_register_address(&hook->handler);
     }
@@ -948,12 +822,10 @@ handle(VALUE self, VALUE method, VALUE pattern, VALUE handler) {
  */
 static VALUE
 handle_not_found(VALUE self, VALUE handler) {
-    Server	server = (Server)DATA_PTR(self);
-
-    if (NULL == (server->hook404 = hook_create(GET, "/", handler))) {
+    if (NULL == (the_server.hook404 = hook_create(GET, "/", handler))) {
 	rb_raise(rb_eStandardError, "out of memory.");
     }
-    rb_gc_register_address(&server->hook404->handler);
+    rb_gc_register_address(&the_server.hook404->handler);
     
     return Qnil;
 }
@@ -967,7 +839,7 @@ handle_not_found(VALUE self, VALUE handler) {
  */
 static VALUE
 add_mime(VALUE self, VALUE suffix, VALUE type) {
-    mime_set(&((Server)DATA_PTR(self))->pages, StringValuePtr(suffix), StringValuePtr(type));
+    mime_set(&the_server.pages, StringValuePtr(suffix), StringValuePtr(type));
 
     return Qnil;
 }
@@ -979,43 +851,33 @@ add_mime(VALUE self, VALUE suffix, VALUE type) {
  */
 void
 server_init(VALUE mod) {
-    server_class = rb_define_class_under(mod, "Server", rb_cObject);
-
-    rb_define_module_function(server_class, "new", server_new, -1);
-    rb_define_method(server_class, "start", start, 0);
-    rb_define_method(server_class, "shutdown", server_shutdown, 0);
-
-    rb_define_method(server_class, "error?", log_errorp, 0);
-    rb_define_method(server_class, "warn?", log_warnp, 0);
-    rb_define_method(server_class, "info?", log_infop, 0);
-    rb_define_method(server_class, "debug?", log_debugp, 0);
-    rb_define_method(server_class, "log_eval?", log_evalp, 0);
-    rb_define_method(server_class, "error", log_error, 1);
-    rb_define_method(server_class, "warn", log_warn, 1);
-    rb_define_method(server_class, "info", log_info, 1);
-    rb_define_method(server_class, "debug", log_debug, 1);
-    rb_define_method(server_class, "log_eval", log_eval, 1);
-
-    rb_define_method(server_class, "log_state", log_state, 1);
-    rb_define_method(server_class, "set_log_state", set_log_state, 2);
-    rb_define_method(server_class, "log_flush", server_log_flush, 1);
-
-    rb_define_method(server_class, "handle", handle, 3);
-    rb_define_method(server_class, "handle_not_found", handle_not_found, 1);
-    rb_define_method(server_class, "add_mime", add_mime, 2);
+    server_mod = rb_define_module_under(mod, "Server");
+
+    rb_define_module_function(server_mod, "init", rserver_init, -1);
+    rb_define_module_function(server_mod, "start", server_start, 0);
+    rb_define_module_function(server_mod, "shutdown", rserver_shutdown, 0);
+
+    rb_define_module_function(server_mod, "handle", handle, 3);
+    rb_define_module_function(server_mod, "handle_not_found", handle_not_found, 1);
+    rb_define_module_function(server_mod, "add_mime", add_mime, 2);
 
     call_id = rb_intern("call");
     each_id = rb_intern("each");
+    on_close_id = rb_intern("on_close");
+    on_drained_id = rb_intern("on_drained");
+    on_message_id = rb_intern("on_message");
     on_request_id = rb_intern("on_request");
     to_i_id = rb_intern("to_i");
     
-    connect_sym = ID2SYM(rb_intern("CONNECT"));	rb_gc_register_address(&connect_sym);
-    delete_sym = ID2SYM(rb_intern("DELETE"));	rb_gc_register_address(&delete_sym);
-    get_sym = ID2SYM(rb_intern("GET"));		rb_gc_register_address(&get_sym);
-    head_sym = ID2SYM(rb_intern("HEAD"));	rb_gc_register_address(&head_sym);
-    options_sym = ID2SYM(rb_intern("OPTIONS"));	rb_gc_register_address(&options_sym);
-    post_sym = ID2SYM(rb_intern("POST"));	rb_gc_register_address(&post_sym);
-    put_sym = ID2SYM(rb_intern("PUT"));		rb_gc_register_address(&put_sym);
+    connect_sym = ID2SYM(rb_intern("CONNECT"));		rb_gc_register_address(&connect_sym);
+    delete_sym = ID2SYM(rb_intern("DELETE"));		rb_gc_register_address(&delete_sym);
+    get_sym = ID2SYM(rb_intern("GET"));			rb_gc_register_address(&get_sym);
+    head_sym = ID2SYM(rb_intern("HEAD"));		rb_gc_register_address(&head_sym);
+    options_sym = ID2SYM(rb_intern("OPTIONS"));		rb_gc_register_address(&options_sym);
+    post_sym = ID2SYM(rb_intern("POST"));		rb_gc_register_address(&post_sym);
+    put_sym = ID2SYM(rb_intern("PUT"));			rb_gc_register_address(&put_sym);
+
+    push_env_key = rb_str_new_cstr("rack.upgrade");	rb_gc_register_address(&push_env_key);
 
     http_init();
 }