agoo 2.1.0 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 729ca7dab10faf0c9196e1297f814dc06471f5de2948a04e4a3d074067f042d6
-  data.tar.gz: 65f231b27c3eb5db90db659e920090fc075ffece27f65753d9769c32157f540d
+  metadata.gz: '0618dff57c263cccb782e0fbccc807bf434815109c3809078ebd4d12570e1bde'
+  data.tar.gz: 2603682170f882a06d20e50ad0d9ab753b927f730331c224ce9e4dcc2cbea581
 SHA512:
-  metadata.gz: 8135b9c196acc16c80a81aa532d55f8452c1008f4ab22cd285a3f327655cf66f2f4b4f6177c9e7d3781f05964dde9ffb2d238f0808acd5c0150f95bd58eeec24
-  data.tar.gz: 7943dc936c2cb113054f04f2780185bbe80d9c62ab94e7a601874219ece58ee2c2ba5f3e8f71e4b23bb8ba24f3a31526bd944ea3351fd62a452c45bf06c0f187
+  metadata.gz: cc4b5878761a72885f79ed8baecfb8bf23b6d516e7035ec97d14e655980432feb3923d8bbeae4824bcbfcb5e61c05562fb5e53fda03afdc40e841cbb2676f9fc
+  data.tar.gz: 159dba44203a4612598949a47e4fbd8f11a99b19dcceb368f1ebab4c65a5c785790163dcdb6998f780b17d0d9836c26087d3a68ae6367376d144007993094fc0

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # CHANGELOG
 
+### 2.1.1 - 2018-05-11
+
+- Subject can now be Symbols or any other object that responds top `#to_s`.
+
+- Fixed bug where publishes from the `#on_open` callback broke the connection.
+
+- Super fast asset loading for Rails and Rack using `Agoo::Server.path_group`
+
 ### 2.1.0 - 2018-05-10
 
 - This is a minor release even though the API has changed. The changed API is the one for Rack based WebSocket and SSE connection upgrades. The PR for the spec addition is currently stalled but some suggestions for a stateless API are implemented in this release. The proposed Rack SPEC is [here](misc/SPEC). The PR is [here](https://github.com/rack/rack/pull/1272)

data/README.md

@@ -50,6 +50,16 @@ limits. Ruby benchmarks driver could not push Agoo hard enough.
 Agoo supports the [Ruby rack API](https://rack.github.io) which allows for the
 use of rack compatible gems such as Hanami and Rails. Agoo also supports WebSockets and SSE.
 
+## News
+
+- WebSocket and SSE are supported and a PR has been submitted to updated the
+  Rack spec. Go over to the [proposed Rack
+  extension](https://github.com/rack/rack/pull/1272) and give it a look and a
+  thumbs-up or heart if you like it.
+
+- Agoo now serves Rails static assets 2000 times faster than the default
+  Puma. Thats right, 2000 times faster.
+
 ## Releases
 
 See [file:CHANGELOG.md](CHANGELOG.md)

data/ext/agoo/agoo.c

@@ -38,15 +38,16 @@ ragoo_shutdown(VALUE self) {
  *
  * call-seq: publish(subject, message)
  *
- * Publish a message on the given subject.
+ * Publish a message on the given subject. A subject is normally a String but
+ * Symbols can also be used as can any other object that responds to #to_s.
  */
 VALUE
 ragoo_publish(VALUE self, VALUE subject, VALUE message) {
-    rb_check_type(subject, T_STRING);
-    rb_check_type(message, T_STRING);
+    int		slen;
+    const char	*subj = extract_subject(subject, &slen);
 
-    queue_push(&the_server.pub_queue, pub_publish(StringValuePtr(subject), (int)RSTRING_LEN(subject),
-						  StringValuePtr(message), (int)RSTRING_LEN(message)));
+    rb_check_type(message, T_STRING);
+    queue_push(&the_server.pub_queue, pub_publish(subj, slen, StringValuePtr(message), (int)RSTRING_LEN(message)));
 
     return Qnil;
 }
@@ -55,7 +56,9 @@ ragoo_publish(VALUE self, VALUE subject, VALUE message) {
  *
  * call-seq: unsubscribe(subject)
  *
- * Unsubscribes on client listeners on the specified subject.
+ * Unsubscribes on client listeners on the specified subject. Subjects are
+ * normally Strings but Symbols can also be used as can any other object that
+ * responds to #to_s.
  */
 static VALUE
 ragoo_unsubscribe(VALUE self, VALUE subject) {

data/ext/agoo/con.c

@@ -141,7 +141,10 @@ con_header_read(Con c) {
     size_t	clen = 0;
     long	mlen;
     Hook	hook = NULL;
-
+    Page	p;
+    struct _Err	err = ERR_INIT;
+    Res		res;
+    
     if (NULL == hend) {
 	if (sizeof(c->buf) - 1 <= c->bcnt) {
 	    return bad_request(c, 431, __LINE__);
@@ -239,13 +242,29 @@ con_header_read(Con c) {
 	qend = b;
     }
     mlen = hend - c->buf + 4 + clen;
-    if (NULL == (hook = hook_find(the_server.hooks, method, path, pend))) {
-	if (GET == method) {
-	    struct _Err	err = ERR_INIT;
-	    Page	p = page_get(&err, &the_server.pages, the_server.root, path, (int)(pend - path));
-	    Res		res;
+    if (GET == method &&
+	NULL != (p = group_get(&err, &the_server.pages, path, (int)(pend - path)))) {
+	if (NULL == (res = res_create(c))) {
+	    return bad_request(c, 500, __LINE__);
+	}
+	if (NULL == c->res_tail) {
+	    c->res_head = res;
+	} else {
+	    c->res_tail->next = res;
+	}
+	c->res_tail = res;
+
+	b = strstr(c->buf, "\r\n");
+	res->close = should_close(b, (int)(hend - b));
+	if (res->close) {
+	    c->closing = true;
+	}
+	res_set_message(res, p->resp);
 
-	    if (NULL == p) {
+	return -mlen;
+    } else if (NULL == (hook = hook_find(the_server.hooks, method, path, pend))) {
+	if (GET == method) {
+	    if (NULL == (p = page_get(&err, &the_server.pages, path, (int)(pend - path)))) {
 		if (NULL != the_server.hook404) {
 		    // There would be too many parameters to pass to a
 		    // separate function so just goto the hook processing.
@@ -620,6 +639,10 @@ con_ws_write(Con c) {
 	    }
 	} else {
 	    ws_req_close(c);
+	    c->res_head = res->next;
+	    if (res == c->res_tail) {
+		c->res_tail = NULL;
+	    }
 	    res_destroy(res);
 	    return true;
 	}
@@ -764,7 +787,7 @@ con_write(Con c) {
     default:
 	break;
     }
-    if (kind != c->kind) {
+    if (kind != c->kind && CON_ANY != kind) {
 	c->kind = kind;
 	/*
 	if (CON_HTTP != kind && !remove) {
@@ -792,7 +815,7 @@ publish_pub(Pub pub) {
 		    up->con->res_tail->next = res;
 		}
 		up->con->res_tail = res;
-		res->con_kind = up->con->kind;
+		res->con_kind = CON_ANY;
 		res_set_message(res, text_dup(pub->msg));
 	    }
 	}
@@ -849,7 +872,7 @@ process_pub_con(Pub pub) {
 		    up->con->res_tail->next = res;
 		}
 		up->con->res_tail = res;
-		res->con_kind = up->con->kind;
+		res->con_kind = CON_ANY;
 		res_set_message(res, pub->msg);
 	    }
 	}

data/ext/agoo/debug.c

@@ -25,6 +25,8 @@ atomic_int	mem_con = 0;
 atomic_int	mem_cslot = 0;
 atomic_int	mem_err_stream = 0;
 atomic_int	mem_eval_threads = 0;
+atomic_int	mem_group = 0;
+atomic_int	mem_group_path = 0;
 atomic_int	mem_header = 0;
 atomic_int	mem_hook = 0;
 atomic_int	mem_hook_pattern = 0;

data/ext/agoo/debug.h

@@ -20,6 +20,8 @@ extern atomic_int	mem_con;
 extern atomic_int	mem_cslot;
 extern atomic_int	mem_err_stream;
 extern atomic_int	mem_eval_threads;
+extern atomic_int	mem_group;
+extern atomic_int	mem_group_path;
 extern atomic_int	mem_header;
 extern atomic_int	mem_hook;
 extern atomic_int	mem_hook_pattern;

data/ext/agoo/hook.c

@@ -6,6 +6,50 @@
 #include "debug.h"
 #include "hook.h"
 
+static VALUE
+resolve_classname(VALUE mod, const char *classname) {
+    VALUE	clas;
+    ID		ci = rb_intern(classname);
+
+    if (rb_const_defined_at(mod, ci)) {
+	clas = rb_const_get_at(mod, ci);
+    } else {
+	clas = Qundef;
+    }
+    return clas;
+}
+
+static VALUE
+resolve_classpath(const char *name, size_t len) {
+    char	class_name[1024];
+    VALUE	clas;
+    char	*end = class_name + sizeof(class_name) - 1;
+    char	*s;
+    const char	*n = name;
+
+    clas = rb_cObject;
+    for (s = class_name; 0 < len; n++, len--) {
+	if (':' == *n) {
+	    *s = '\0';
+	    n++;
+	    len--;
+	    if (':' != *n) {
+		return Qundef;
+	    }
+	    if (Qundef == (clas = resolve_classname(clas, class_name))) {
+		return Qundef;
+	    }
+	    s = class_name;
+	} else if (end <= s) {
+	    return Qundef;
+	} else {
+	    *s++ = *n;
+	}
+    }
+    *s = '\0';
+    return resolve_classname(clas, class_name);
+}
+
 Hook
 hook_create(Method method, const char *pattern, VALUE handler) {
     Hook	hook = (Hook)malloc(sizeof(struct _Hook));
@@ -16,6 +60,9 @@ hook_create(Method method, const char *pattern, VALUE handler) {
 	    pattern = "";
 	}
 	hook->next = NULL;
+	if (T_STRING == rb_type(handler)) {
+	    handler = resolve_classpath(StringValuePtr(handler), RSTRING_LEN(handler));
+	}
 	hook->handler = handler;
 	rb_gc_register_address(&handler);
 	hook->pattern = strdup(pattern);

data/ext/agoo/page.c

@@ -4,6 +4,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/stat.h>
+#include <unistd.h>
 
 #include <ruby.h>
 
@@ -225,7 +226,7 @@ cache_set(Cache cache, const char *key, int klen, Page value) {
 }
 
 void
-cache_init(Cache cache) {
+pages_init(Cache cache) {
     Mime	m;
 
     memset(cache, 0, sizeof(struct _Cache));
@@ -235,7 +236,7 @@ cache_init(Cache cache) {
 }
 
 void
-cache_cleanup(Cache cache) {
+pages_cleanup(Cache cache) {
     Slot	*sp = cache->buckets;
     Slot	s;
     Slot	n;
@@ -262,6 +263,7 @@ cache_cleanup(Cache cache) {
 	}
 	*mp = NULL;
     }
+    free(cache->root);
 }
 
 // The page resp contents point to the page resp msg to save memory and reduce
@@ -400,15 +402,16 @@ update_contents(Cache cache, Page p) {
 }
 
 Page
-page_get(Err err, Cache cache, const char *dir, const char *path, int plen) {
+page_get(Err err, Cache cache, const char *path, int plen) {
     Page	page;
 
+    // TBD check for .. and ~
     if (NULL == (page = cache_get(cache, path, plen))) {
 	Page	old;
 	char	full_path[2048];
-	char	*s = stpcpy(full_path, dir);
+	char	*s = stpcpy(full_path, cache->root);
 
-	if ('/' != *dir && '/' != *path) {
+	if ('/' != *cache->root && '/' != *path) {
 	    *s++ = '/';
 	}
 	if ((int)sizeof(full_path) <= plen + (s - full_path)) {
@@ -448,3 +451,103 @@ page_get(Err err, Cache cache, const char *dir, const char *path, int plen) {
     }
     return page;
 }
+
+Page
+group_get(Err err, Cache cache, const char *path, int plen) {
+    Page	page = NULL;
+    Group	g = NULL;
+    char	full_path[2048];
+    Page	old;
+    char	*s;
+    Dir		d;
+
+    // TBD check for .. and ~
+    for (g = cache->groups; NULL != g; g = g->next) {
+	if (g->plen < plen && 0 == strncmp(path, g->path, g->plen) && '/' == path[g->plen]) {
+	    break;
+	}
+    }
+    if (NULL == g) {
+	return NULL;
+    }
+    for (d = g->dirs; NULL != d; d = d->next) {
+	if (sizeof(full_path) <= d->plen + plen) {
+	    continue;
+	}
+	s = stpcpy(full_path, d->path);
+	strncpy(s, path + g->plen, plen - g->plen);
+	s += plen - g->plen;
+	*s = '\0';
+	if (0 == access(full_path, R_OK)) {
+	    break;
+	}
+    }
+    if (NULL == d) {
+	return NULL;
+    }
+    plen = s - full_path;
+    path = full_path;
+    if (NULL == (page = cache_get(cache, path, plen))) {
+	Page	old;
+
+	if (NULL == (page = page_create(path))) {
+	    err_set(err, ERR_MEMORY, "Failed to allocate memory for Page.");
+	    return NULL;
+	}
+	if (!update_contents(cache, page) || NULL == page->resp) {
+	    page_destroy(page);
+	    err_set(err, ERR_NOT_FOUND, "not found.");
+	    return NULL;
+	}
+	if (NULL != (old = cache_set(cache, path, plen, page))) {
+	    page_destroy(old);
+	}
+    } else {
+	double	now = dtime();
+
+	if (page->last_check + PAGE_RECHECK_TIME < now) {
+	    struct stat	fattr;
+
+	    if (0 == stat(page->path, &fattr) && page->mtime != fattr.st_mtime) {
+		update_contents(cache, page);
+		if (NULL == page->resp) {
+		    page_destroy(page);
+		    err_set(err, ERR_NOT_FOUND, "not found.");
+		    return NULL;
+		}
+	    }
+	    page->last_check = now;
+	}
+    }
+    return page;
+}
+
+Group
+group_create(Cache cache, const char *path) {
+    Group	g = (Group)malloc(sizeof(struct _Group));
+
+    if (NULL != g) {
+	DEBUG_ALLOC(mem_group, g);
+	g->next = cache->groups;
+	cache->groups = g;
+	g->path = strdup(path);
+	g->plen = strlen(path);
+	DEBUG_ALLOC(mem_group_path, g->path);
+	g->dirs = NULL;
+    }
+    return g;
+}
+
+void
+group_add(Group g, const char *dir) {
+    Dir	d = (Dir)malloc(sizeof(struct _Dir));
+
+    if (NULL != d) {
+	DEBUG_ALLOC(mem_dir, d);
+	d->next = g->dirs;
+	g->dirs = d;
+	d->path = strdup(dir);
+	d->plen = strlen(dir);
+	DEBUG_ALLOC(mem_dir_path, d->path);
+    }
+}

data/ext/agoo/page.h

@@ -40,16 +40,35 @@ typedef struct _MimeSlot {
     int			klen;
 } *MimeSlot;
 
+typedef struct _Dir {
+    struct _Dir		*next;
+    char		*path;
+    int			plen;
+} *Dir;
+
+typedef struct _Group {
+    struct _Group	*next;
+    char		*path;
+    int			plen;
+    Dir			dirs;
+} *Group;
+
 typedef struct _Cache {
     Slot		buckets[PAGE_BUCKET_SIZE];
     MimeSlot		muckets[MIME_BUCKET_SIZE];
+    char		*root;
+    Group		groups;
 } *Cache;
 
-extern void	cache_init(Cache cache);
-extern void	cache_cleanup(Cache cache);
+extern void	pages_init(Cache cache);
+extern void	pages_cleanup(Cache cache);
+
+extern Group	group_create(Cache cache, const char *path);
+extern void	group_add(Group g, const char *dir);
+extern Page	group_get(Err err, Cache cache, const char *path, int plen);
 
 extern void	page_destroy(Page p);
-extern Page	page_get(Err err, Cache cache, const char *dir, const char *path, int plen);
+extern Page	page_get(Err err, Cache cache, const char *path, int plen);
 extern void	mime_set(Cache cache, const char *key, const char *value);
 
 #endif /* __AGOO_PAGE_H__ */

data/ext/agoo/pub.c

@@ -60,7 +60,7 @@ pub_unsubscribe(Upgraded up, const char *subject, int slen) {
 }
 
 Pub
-pub_publish(char *subject, int slen, const char *message, size_t mlen) {
+pub_publish(const char *subject, int slen, const char *message, size_t mlen) {
     Pub	p = (Pub)malloc(sizeof(struct _Pub));
 
     if (NULL != p) {

data/ext/agoo/pub.h

@@ -32,7 +32,7 @@ typedef struct _Pub {
 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_publish(const 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);
 

data/ext/agoo/server.c

@@ -121,7 +121,7 @@ server_shutdown() {
 	queue_cleanup(&the_server.con_queue);
 	queue_cleanup(&the_server.pub_queue);
 	queue_cleanup(&the_server.eval_queue);
-	cache_cleanup(&the_server.pages);
+	pages_cleanup(&the_server.pages);
 	http_cleanup();
     }
 }
@@ -129,7 +129,7 @@ server_shutdown() {
 static int
 configure(Err err, int port, const char *root, VALUE options) {
     the_server.port = port;
-    the_server.root = strdup(root);
+    the_server.pages.root = strdup(root);
     the_server.thread_cnt = 0;
     the_server.running = 0;
     the_server.listen_thread = 0;
@@ -228,6 +228,9 @@ rserver_init(int argc, VALUE *argv, VALUE self) {
 	options = argv[2];
     }
     memset(&the_server, 0, sizeof(struct _Server));
+    pages_init(&the_server.pages);
+    sub_init(&the_server.sub_cache);
+
     if (ERR_OK != configure(&err, port, root, options)) {
 	rb_raise(rb_eArgError, "%s", err.msg);
     }
@@ -235,9 +238,6 @@ rserver_init(int argc, VALUE *argv, VALUE self) {
     queue_multi_init(&the_server.pub_queue, 256, true, false);
     queue_multi_init(&the_server.eval_queue, 1024, false, true);
 
-    cache_init(&the_server.pages);
-    sub_init(&the_server.sub_cache);
-
     pthread_mutex_init(&the_server.up_lock, 0);
     the_server.up_list = NULL;
     
@@ -609,15 +609,18 @@ handle_push_inner(void *x) {
 
     switch (req->method) {
     case ON_MSG:
-	rb_funcall(req->handler, on_message_id, 2, req->up->wrap, rb_str_new(req->msg, req->mlen));
+	if (req->up->on_msg) { // TBD move this to earlier
+	    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);
+    case ON_BIN:
+	if (req->up->on_msg) { // TBD move this to earlier
+	    volatile VALUE	rstr = rb_str_new(req->msg, req->mlen);
 
-	rb_enc_associate(rstr, rb_ascii8bit_encoding());
-	rb_funcall(req->handler, on_message_id, 2, req->up->wrap, rstr);
+	    rb_enc_associate(rstr, rb_ascii8bit_encoding());
+	    rb_funcall(req->handler, on_message_id, 2, req->up->wrap, rstr);
+	}
 	break;
-    }
     case ON_CLOSE:
 	upgraded_ref(req->up);
 	queue_push(&the_server.pub_queue, pub_close(req->up));
@@ -872,6 +875,37 @@ add_mime(VALUE self, VALUE suffix, VALUE type) {
     return Qnil;
 }
 
+/* Document-method: path_group
+ *
+ * call-seq: path_group(path, dirs)
+ *
+ * Sets up a path group where the path defines a group of directories to
+ * search for a file. For example a path of '/assets' could be mapped to a set
+ * of [ 'home/user/images', '/home/user/app/assets/images' ].
+ */
+static VALUE
+path_group(VALUE self, VALUE path, VALUE dirs) {
+    Group	g;
+
+    rb_check_type(path, T_STRING);
+    rb_check_type(dirs, T_ARRAY);
+
+    if (NULL != (g = group_create(&the_server.pages, StringValuePtr(path)))) {
+	int	i;
+	int	dcnt = (int)RARRAY_LEN(dirs);
+	VALUE	entry;
+	
+	for (i = dcnt - 1; 0 <= i; i--) {
+	    entry = rb_ary_entry(dirs, i);
+	    if (T_STRING != rb_type(entry)) {
+		entry = rb_funcall(entry, rb_intern("to_s"), 0);
+	    }
+	    group_add(g, StringValuePtr(entry));
+	}
+    }
+    return Qnil;
+}
+
 /* Document-class: Agoo::Server
  *
  * An HTTP server that support the rack API as well as some other optimized
@@ -888,6 +922,7 @@ server_init(VALUE mod) {
     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);
+    rb_define_module_function(server_mod, "path_group", path_group, 2);
 
     call_id = rb_intern("call");
     each_id = rb_intern("each");

data/ext/agoo/server.h

@@ -23,7 +23,6 @@ typedef struct _Server {
     int			max_push_pending;
     int			port;
     bool		pedantic;
-    char		*root;
     atomic_int		running;
     pthread_t		listen_thread;
     pthread_t		con_thread;

data/ext/agoo/text.c

@@ -25,16 +25,15 @@ text_create(const char *str, int len) {
 
 Text
 text_dup(Text t0) {
-    int		len = t0->len;
-    Text	t = (Text)malloc(sizeof(struct _Text) - TEXT_MIN_SIZE + len + 1);
+    Text	t = (Text)malloc(sizeof(struct _Text) - TEXT_MIN_SIZE + t0->alen + 1);
 
     if (NULL != t) {
 	DEBUG_ALLOC(mem_text, t)
-	t->len = len;
-	t->alen = len;
+	t->len = t0->len;
+	t->alen = t0->alen;
 	t->bin = false;
 	atomic_init(&t->ref_cnt, 0);
-	memcpy(t->text, t0->text, len + 1);
+	memcpy(t->text, t0->text, t0->len + 1);
     }
     return t;
 }
@@ -99,10 +98,14 @@ text_prepend(Text t, const char *s, int len) {
     if (t->alen <= t->len + len) {
 	long	new_len = t->alen + len + t->alen / 2;
 	size_t	size = sizeof(struct _Text) - TEXT_MIN_SIZE + new_len + 1;
+#ifdef MEM_DEBUG
+	Text	t0 = t;
+#endif	
 
 	if (NULL == (t = (Text)realloc(t, size))) {
 	    return NULL;
 	}
+	DEBUG_REALLOC(mem_text, t0, t);
 	t->alen = new_len;
     }
     memmove(t->text + len, t->text, t->len + 1);

data/ext/agoo/types.h

@@ -23,6 +23,7 @@ typedef enum {
 } Method;
 
 typedef enum {
+    CON_ANY	= '\0',
     CON_HTTP	= 'H',
     CON_WS	= 'W',
     CON_SSE	= 'S',

data/ext/agoo/upgraded.c

@@ -46,6 +46,28 @@ destroy(Upgraded up) {
     free(up);
 }
 
+const char*
+extract_subject(VALUE subject, int *slen) {
+    const char	*subj;
+    
+    switch (rb_type(subject)) {
+    case T_STRING:
+	subj = StringValuePtr(subject);
+	*slen = (int)RSTRING_LEN(subject);
+	break;
+    case T_SYMBOL:
+	subj = rb_id2name(rb_sym2id(subject));
+	*slen = strlen(subj);
+	break;
+    default:
+	subject = rb_funcall(subject, to_s_id, 0);
+	subj = StringValuePtr(subject);
+	*slen = (int)RSTRING_LEN(subject);
+	break;
+    }
+    return subj;
+}
+
 void
 upgraded_release(Upgraded up) {
     pthread_mutex_lock(&the_server.up_lock);
@@ -184,15 +206,18 @@ up_write(VALUE self, VALUE msg) {
  * dot delimited string that can include a '*' character as a wild card that
  * matches any set of characters. The '>' character matches all remaining
  * characters. Examples: people.fred.log, people.*.log, people.fred.>
+ *
+ * Symbols can also be used as can any other object that responds to #to_s.
  */
 static VALUE
 up_subscribe(VALUE self, VALUE subject) {
     Upgraded	up;
-    
-    rb_check_type(subject, T_STRING);
+    int		slen;
+    const char	*subj = extract_subject(subject, &slen);
+
     if (NULL != (up = get_upgraded(self))) {
 	atomic_fetch_add(&up->pending, 1);
-	queue_push(&the_server.pub_queue, pub_subscribe(up, StringValuePtr(subject), RSTRING_LEN(subject)));
+	queue_push(&the_server.pub_queue, pub_subscribe(up, subj, slen));
     }
     return Qnil;
 }
@@ -203,6 +228,8 @@ up_subscribe(VALUE self, VALUE subject) {
  *
  * Unsubscribes to messages on the provided subject. If the subject is nil
  * then all subscriptions for the object are removed.
+ *
+ * Symbols can also be used as can any other object that responds to #to_s.
  */
 static VALUE
 up_unsubscribe(int argc, VALUE *argv, VALUE self) {
@@ -211,9 +238,7 @@ up_unsubscribe(int argc, VALUE *argv, VALUE self) {
     int		slen = 0;
 
     if (0 < argc) {
-	rb_check_type(argv[0], T_STRING);
-	subject = StringValuePtr(argv[0]);
-	slen = (int)RSTRING_LEN(argv[0]);
+	subject = extract_subject(argv[0], &slen);
     }
     if (NULL != (up = get_upgraded(self))) {
 	atomic_fetch_add(&up->pending, 1);

data/ext/agoo/upgraded.h

@@ -36,4 +36,6 @@ extern void	upgraded_add_subject(Upgraded up, struct _Subject *subject);
 extern void	upgraded_del_subject(Upgraded up, struct _Subject *subject);
 extern bool	upgraded_match(Upgraded up, const char *subject);
 
+extern const char*	extract_subject(VALUE subject, int *slen);
+
 #endif // __AGOO_UPGRADED_H__

data/ext/agoo/websocket.c

@@ -215,7 +215,6 @@ ws_ping(Con c) {
     if (NULL == (res = res_create(c))) {
 	log_cat(&error_cat, "Memory allocation of response failed on connection %llu.", c->id);
     } else {
-	DEBUG_ALLOC(mem_res, res)
 	if (NULL == c->res_tail) {
 	    c->res_head = res;
 	} else {
@@ -235,7 +234,6 @@ ws_pong(Con c) {
     if (NULL == (res = res_create(c))) {
 	log_cat(&error_cat, "Memory allocation of response failed on connection %llu.", c->id);
     } else {
-	DEBUG_ALLOC(mem_res, res)
 	if (NULL == c->res_tail) {
 	    c->res_head = res;
 	} else {

data/lib/agoo/version.rb

@@ -1,5 +1,5 @@
 
 module Agoo
   # Agoo version.
-  VERSION = '2.1.0'
+  VERSION = '2.1.1'
 end

data/lib/rack/handler/agoo.rb

@@ -27,12 +27,15 @@ module Rack
 	  elsif :root == k
 	    root = v
 	    options.delete(k)
-	  elsif k.is_a?(String) && k.start_with?('/')
-	    path_map[k] = v
-	    options.delete(k)
 	  elsif k.nil?
 	    not_found_handler = v
 	    options.delete(k)
+	  elsif
+            k = k.to_s
+            if k.start_with?('/')
+              path_map[k] = v
+              options.delete(k)
+            end
 	  end
 	}
 	options[:thread_count] = 0
@@ -40,6 +43,11 @@ module Rack
 	path_map.each { |path,handler|
 			::Agoo::Server.handle(nil, path, handler)
 	}
+        begin
+          # If Rails is loaded this should work else just ignore.
+          ::Agoo::Server.path_group('/assets', Rails.configuration.assets.paths)
+        rescue Exception
+        end
 	unless default_handler.nil?
 	  ::Agoo::Server.handle(nil, '**', default_handler)
 	end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: agoo
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.1.1
 platform: ruby
 authors:
 - Peter Ohler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-10 00:00:00.000000000 Z
+date: 2018-05-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oj