agoo 2.0.5 → 2.1.0

data/ext/agoo/con.h

@@ -15,9 +15,10 @@
 
 #define MAX_HEADER_SIZE	8192
 
-struct _CSlot;
+struct _Upgraded;
 
 typedef struct _Con {
+    struct _Con		*next;
     int			sock;
     ConKind		kind;
     struct pollfd	*pp;
@@ -30,11 +31,12 @@ typedef struct _Con {
 
     double		timeout;
     bool		closing;
+    bool		dead;
     Req			req;
     Res			res_head;
     Res			res_tail;
 
-    struct _CSlot	*slot; // only set for push connections
+    struct _Upgraded	*up; // only set for push connections
 } *Con;
 
 extern Con		con_create(Err err, int sock, uint64_t id);

data/ext/agoo/debug.c

@@ -44,8 +44,10 @@ atomic_int	mem_req = 0;
 atomic_int	mem_res = 0;
 atomic_int	mem_res_body = 0;
 atomic_int	mem_response = 0;
+atomic_int	mem_subject = 0;
 atomic_int	mem_text = 0;
 atomic_int	mem_to_s = 0;
+atomic_int	mem_upgraded = 0;
 
 #ifdef MEM_DEBUG
 static void

data/ext/agoo/debug.h

@@ -39,8 +39,10 @@ extern atomic_int	mem_req;
 extern atomic_int	mem_res;
 extern atomic_int	mem_res_body;
 extern atomic_int	mem_response;
+extern atomic_int	mem_subject;
 extern atomic_int	mem_text;
 extern atomic_int	mem_to_s;
+extern atomic_int	mem_upgraded;
 
 extern void	debug_add(void *ptr, const char *type, const char *file, int line);
 extern void	debug_update(void *orig, void *ptr, const char *type, const char *file, int line);

data/ext/agoo/page.c

@@ -353,6 +353,7 @@ update_contents(Cache cache, Page p) {
 	    if (NULL == (f = fopen(path, "rb"))) {
 		return false;
 	    }
+	    mime = "text/html";
 	} else {
 	    return false;
 	}

data/ext/agoo/pub.c

@@ -6,74 +6,79 @@
 
 #include "debug.h"
 #include "pub.h"
+#include "subject.h"
 #include "text.h"
+#include "upgraded.h"
 
 Pub
-pub_close(uint64_t cid) {
+pub_close(Upgraded up) {
     Pub	p = (Pub)malloc(sizeof(struct _Pub));
 
     if (NULL != p) {
 	DEBUG_ALLOC(mem_pub, p);
 	p->next = NULL;
 	p->kind = PUB_CLOSE;
-	p->cid = cid;
-	p->sid = 0;
+	p->up = up;
 	p->subject = NULL;
+	p->msg = NULL;
     }
     return p;
 }
 
 Pub
-pub_subscribe(uint64_t cid, uint64_t sid, const char *subject) {
+pub_subscribe(Upgraded up, const char *subject, int slen) {
     Pub	p = (Pub)malloc(sizeof(struct _Pub));
 
     if (NULL != p) {
 	DEBUG_ALLOC(mem_pub, p);
 	p->next = NULL;
 	p->kind = PUB_SUB;
-	p->cid = cid;
-	p->sid = sid;
-	p->subject = strdup(subject);
+	p->up = up;
+	p->subject = subject_create(subject, slen);
+	p->msg = NULL;
     }
     return p;
 }
 
 Pub
-pub_unsubscribe(uint64_t cid, uint64_t sid) {
+pub_unsubscribe(Upgraded up, const char *subject, int slen) {
     Pub	p = (Pub)malloc(sizeof(struct _Pub));
 
     if (NULL != p) {
 	DEBUG_ALLOC(mem_pub, p);
 	p->next = NULL;
 	p->kind = PUB_UN;
-	p->cid = cid;
-	p->sid = sid;
-	p->subject = NULL;
+	p->up = up;
+	if (NULL != subject) {
+	    p->subject = subject_create(subject, slen);
+	} else {
+	    p->subject = NULL;
+	}
+	p->msg = NULL;
     }
     return p;
 }
 
 Pub
-pub_publish(char *subject, const char *message, size_t mlen, bool bin) {
+pub_publish(char *subject, int slen, const char *message, size_t mlen) {
     Pub	p = (Pub)malloc(sizeof(struct _Pub));
 
     if (NULL != p) {
 	DEBUG_ALLOC(mem_pub, p);
 	p->next = NULL;
 	p->kind = PUB_MSG;
-	p->cid = 0;
-	p->subject = strdup(subject);
+	p->up = NULL;
+	p->subject = subject_create(subject, slen);
 	// Allocate an extra 24 bytes so the message can be expanded in place
 	// if a WebSocket or SSE write.
-	p->msg = text_allocate((int)mlen + 24);
-	p->msg = text_append(text_allocate((int)mlen + 16), message, (int)mlen);
+	p->msg = text_append(text_allocate((int)mlen + 24), message, (int)mlen);
 	text_ref(p->msg);
     }
     return p;
 }
 
 Pub
-pub_write(uint64_t cid, const char *message, size_t mlen, bool bin) {
+pub_write(Upgraded up, const char *message, size_t mlen, bool bin) {
     // Allocate an extra 16 bytes so the message can be expanded in place if a
     // WebSocket write.
     Pub	p = (Pub)malloc(sizeof(struct _Pub));
@@ -82,7 +87,7 @@ pub_write(uint64_t cid, const char *message, size_t mlen, bool bin) {
 	DEBUG_ALLOC(mem_pub, p);
 	p->next = NULL;
 	p->kind = PUB_WRITE;
-	p->cid = cid;
+	p->up = up;
 	p->subject = NULL;
 	// Allocate an extra 16 bytes so the message can be expanded in place
 	// if a WebSocket write.
@@ -95,15 +100,14 @@ pub_write(uint64_t cid, const char *message, size_t mlen, bool bin) {
 
 void
 pub_destroy(Pub pub) {
-    switch (pub->kind) {
-    case PUB_MSG:
-    case PUB_WRITE:
-	if (NULL != pub->msg) {
-	    text_release(pub->msg);
-	}
-	break;
-    default:
-	break;
+    if (NULL != pub->msg) {
+	text_release(pub->msg);
+    }
+    if (NULL != pub->subject) {
+	subject_destroy(pub->subject);
+    }
+    if (NULL != pub->up) {
+	upgraded_release(pub->up);
     }
     DEBUG_FREE(mem_pub, pub);
     free(pub);

data/ext/agoo/pub.h

@@ -8,6 +8,8 @@
 #include <stdlib.h>
 
 struct _Text;
+struct _Upgraded;
+struct _Subject;
 
 typedef enum {
     PUB_SUB	= 'S',
@@ -22,19 +24,16 @@ typedef enum {
 typedef struct _Pub {
     struct _Pub		*next;
     PubKind		kind;
-    uint64_t		cid;
-    char		*subject;
-    union {
-	uint64_t	sid;
-	struct _Text	*msg;
-    };
+    struct _Upgraded	*up;
+    struct _Subject	*subject;
+    struct _Text	*msg;
 } *Pub;
 
-extern Pub	pub_close(uint64_t cid);
-extern Pub	pub_subscribe(uint64_t cid, uint64_t sid, const char *subject);
-extern Pub	pub_unsubscribe(uint64_t cid, uint64_t sid);
-extern Pub	pub_publish(char *subject, const char *message, size_t mlen, bool bin);
-extern Pub	pub_write(uint64_t cid, const char *message, size_t mlen, bool bin);
+extern Pub	pub_close(struct _Upgraded *up);
+extern Pub	pub_subscribe(struct _Upgraded *up, const char *subject, int slen);
+extern Pub	pub_unsubscribe(struct _Upgraded *up, const char *subject, int slen);
+extern Pub	pub_publish(char *subject, int slen, const char *message, size_t mlen);
+extern Pub	pub_write(struct _Upgraded *up, const char *message, size_t mlen, bool bin);
 extern void	pub_destroy(Pub pub);
 
 #endif // __AGOO_PUB_H__

data/ext/agoo/request.c

@@ -383,8 +383,9 @@ add_header_value(VALUE hh, const char *key, int klen, const char *val, int vlen)
     } else if (sizeof(content_length) - 1 == klen && 0 == strncasecmp(key, content_length, sizeof(content_length) - 1)) {
 	rb_hash_aset(hh, content_length_val, rb_str_new(val, vlen));
     } else {
-	char	hkey[1024];
-	char	*k = hkey;
+	char		hkey[1024];
+	char		*k = hkey;
+	volatile VALUE	sval = rb_str_new(val, vlen);
 	
 	strcpy(hkey, "HTTP_");
 	k = hkey + 5;
@@ -394,12 +395,12 @@ add_header_value(VALUE hh, const char *key, int klen, const char *val, int vlen)
 	strncpy(k, key, klen);
 	hkey[klen + 5] = '\0';
     
-	rb_hash_aset(hh, rb_str_new(hkey, klen + 5), rb_str_new(val, vlen));
+	rb_hash_aset(hh, rb_str_new(hkey, klen + 5), sval);
 	// Contrary to the Rack spec, Rails expects all upper case keys so add those as well.
 	for (k = hkey + 5; '\0' != *k; k++) {
 	    *k = toupper(*k);
 	}
-	rb_hash_aset(hh, rb_str_new(hkey, klen + 5), rb_str_new(val, vlen));
+	rb_hash_aset(hh, rb_str_new(hkey, klen + 5), sval);
     }
 }
 

data/ext/agoo/request.h

@@ -12,6 +12,7 @@
 #include "types.h"
 
 struct _Server;
+struct _Upgraded;
 
 typedef enum {
     UP_NONE	= '\0',
@@ -27,7 +28,7 @@ typedef struct _Str {
 typedef struct _Req {
     Method		method;
     Upgrade		upgrade;
-    uint64_t		cid;
+    struct _Upgraded	*up;
     struct _Str		path;
     struct _Str		query;
     struct _Str		header;

data/ext/agoo/res.c

@@ -2,17 +2,19 @@
 
 #include <stdlib.h>
 
+#include "con.h"
 #include "debug.h"
 #include "res.h"
 
 Res
-res_create() {
+res_create(Con con) {
     Res	res = (Res)malloc(sizeof(struct _Res));
 
     if (NULL != res) {
 	DEBUG_ALLOC(mem_res, res)
 	res->next = NULL;
 	atomic_init(&res->message, NULL);
+	res->con = con;
 	res->con_kind = CON_HTTP;
 	res->close = false;
 	res->ping = false;

data/ext/agoo/res.h

@@ -11,8 +11,11 @@
 #include "text.h"
 #include "types.h"
 
+struct _Con;
+
 typedef struct _Res {
     struct _Res		*next;
+    struct _Con		*con;
     _Atomic(Text)	message;
     ConKind		con_kind;
     bool		close;
@@ -20,7 +23,7 @@ typedef struct _Res {
     bool		pong;
 } *Res;
 
-extern Res	res_create();
+extern Res	res_create(struct _Con *con);
 extern void	res_destroy(Res res);
 extern void	res_set_message(Res res, Text t);
 

data/ext/agoo/server.c

@@ -25,6 +25,7 @@
 #include "dtime.h"
 #include "err.h"
 #include "http.h"
+#include "pub.h"
 #include "response.h"
 #include "request.h"
 #include "server.h"
@@ -46,6 +47,8 @@ static VALUE	post_sym;
 static VALUE	push_env_key;
 static VALUE	put_sym;
 
+static VALUE	rserver;
+
 static ID	call_id;
 static ID	each_id;
 static ID	on_close_id;
@@ -58,6 +61,23 @@ static const char	err500[] = "HTTP/1.1 500 Internal Server Error\r\n";
 
 struct _Server	the_server = {false};
 
+static void
+server_mark(void *ptr) {
+    Upgraded	up;
+
+    rb_gc_mark(rserver);
+    pthread_mutex_lock(&the_server.up_lock);
+    for (up = the_server.up_list; NULL != up; up = up->next) {
+	if (Qnil != up->handler) {
+	    rb_gc_mark(up->handler);
+	}
+	if (Qnil != up->wrap) {
+	    rb_gc_mark(up->wrap);
+	}
+    }
+    pthread_mutex_unlock(&the_server.up_lock);
+}
+
 void
 server_shutdown() {
     if (the_server.inited) {
@@ -74,7 +94,6 @@ server_shutdown() {
 		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
@@ -89,7 +108,7 @@ server_shutdown() {
 		    dsleep(0.02);
 		}
 		DEBUG_FREE(mem_eval_threads, the_server.eval_threads);
-		free(the_server.eval_threads); // TBD use regular malloc and free
+		free(the_server.eval_threads);
 		the_server.eval_threads = NULL;
 	    }
 	    while (NULL != the_server.hooks) {
@@ -217,8 +236,10 @@ rserver_init(int argc, VALUE *argv, VALUE self) {
     queue_multi_init(&the_server.eval_queue, 1024, false, true);
 
     cache_init(&the_server.pages);
-    cc_init(&the_server.con_cache);
     sub_init(&the_server.sub_cache);
+
+    pthread_mutex_init(&the_server.up_lock, 0);
+    the_server.up_list = NULL;
     
     the_server.inited = true;
 
@@ -320,21 +341,25 @@ rescue_error(VALUE x) {
     volatile VALUE	msg = rb_funcall(info, rb_intern("message"), 0);
     const char		*classname = rb_obj_classname(info);
     const char		*ms = rb_string_value_ptr(&msg);
-    char		buf[1024];
-    int			len = (int)(strlen(classname) + 2 + strlen(ms));
-    int			cnt;
-    Text		message;
 
-    if ((int)(sizeof(buf) - sizeof(bad500) + 7) <= len) {
-	len = sizeof(buf) - sizeof(bad500) + 7;
-    }
-    cnt = snprintf(buf, sizeof(buf), "%s%d\r\n\r\n%s: %s", bad500, len, classname, ms);
-    message = text_create(buf, cnt);
+    if (NULL == req->up) {
+	char	buf[1024];
+	int	len = (int)(strlen(classname) + 2 + strlen(ms));
+	int	cnt;
+	Text	message;
 
-    req->res->close = true;
-    res_set_message(req->res, message);
-    queue_wakeup(&the_server.con_queue);
+	if ((int)(sizeof(buf) - sizeof(bad500) + 7) <= len) {
+	    len = sizeof(buf) - sizeof(bad500) + 7;
+	}
+	cnt = snprintf(buf, sizeof(buf), "%s%d\r\n\r\n%s: %s", bad500, len, classname, ms);
+	message = text_create(buf, cnt);
 
+	req->res->close = true;
+	res_set_message(req->res, message);
+	queue_wakeup(&the_server.con_queue);
+    } else {
+	log_cat(&error_cat, "%s: %s", classname, ms);
+    }
     return Qfalse;
 }
 
@@ -495,7 +520,7 @@ handle_rack_inner(void *x) {
 		break;
 	    }
 	    req->handler_type = PUSH_HOOK;
-	    upgraded_extend(req->cid, req->handler);
+	    upgraded_create(req->res->con, req->handler);
 	    t->len = snprintf(t->text, 1024, "HTTP/1.1 101 %s\r\n", status_msg);
 	    t = ws_add_headers(req, t);
 	    break;
@@ -507,7 +532,7 @@ handle_rack_inner(void *x) {
 		break;
 	    }
 	    req->handler_type = PUSH_HOOK;
-	    upgraded_extend(req->cid, req->handler);
+	    upgraded_create(req->res->con, req->handler);
 	    t = sse_upgrade(req, t);
 	    res_set_message(req->res, t);
 	    queue_wakeup(&the_server.con_queue);
@@ -548,9 +573,6 @@ handle_rack_inner(void *x) {
 
 static void*
 handle_rack(void *x) {
-    // Disable GC. The handle_rack function or rather the env seems to get
-    // collected even though it is volatile so for now turn off GC
-    // temporarily.
     //rb_gc_disable();
     rb_rescue2(handle_rack_inner, (VALUE)x, rescue_error, (VALUE)x, rb_eException, 0);
     //rb_gc_enable();
@@ -587,27 +609,31 @@ handle_push_inner(void *x) {
 
     switch (req->method) {
     case ON_MSG:
-	rb_funcall(req->handler, on_message_id, 1, rb_str_new(req->msg, req->mlen));
+	rb_funcall(req->handler, on_message_id, 2, req->up->wrap, 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);
+	rb_funcall(req->handler, on_message_id, 2, req->up->wrap, rstr);
 	break;
     }
     case ON_CLOSE:
-	rb_funcall(req->handler, on_close_id, 0);
+	upgraded_ref(req->up);
+	queue_push(&the_server.pub_queue, pub_close(req->up));
+	rb_funcall(req->handler, on_close_id, 1, req->up->wrap);
 	break;
     case ON_SHUTDOWN:
-	rb_funcall(req->handler, rb_intern("on_shutdown"), 0);
+	rb_funcall(req->handler, rb_intern("on_shutdown"), 1, req->up->wrap);
 	break;
     case ON_EMPTY:
-	rb_funcall(req->handler, on_drained_id, 0);
+	rb_funcall(req->handler, on_drained_id, 1, req->up->wrap);
 	break;
     default:
 	break;
     }
+    upgraded_release(req->up);
+    
     return Qfalse;
 }
 
@@ -652,7 +678,7 @@ handle_protected(Req req, bool gvi) {
 	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(&the_server.con_queue);
@@ -881,5 +907,8 @@ server_init(VALUE mod) {
 
     push_env_key = rb_str_new_cstr("rack.upgrade");	rb_gc_register_address(&push_env_key);
 
+    rserver = Data_Wrap_Struct(rb_cObject, server_mark, NULL, strdup("dummy"));
+    rb_gc_register_address(&rserver);
+
     http_init();
 }