agoo 2.5.1 → 2.5.2

data/ext/agoo/rresponse.h

@@ -0,0 +1,14 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#ifndef __AGOO_RRESPONSE_H__
+#define __AGOO_RRESPONSE_H__
+
+#include <ruby.h>
+
+#include "text.h"
+
+extern void	response_init(VALUE mod);
+extern VALUE	response_new();
+extern Text	response_text(VALUE self);
+
+#endif // __AGOO_RRESPONSE_H__

data/ext/agoo/rserver.c

@@ -16,12 +16,16 @@
 #include "dtime.h"
 #include "err.h"
 #include "http.h"
+#include "log.h"
 #include "page.h"
 #include "pub.h"
-#include "response.h"
 #include "request.h"
+#include "res.h"
+#include "response.h"
 #include "rhook.h"
+#include "rresponse.h"
 #include "rserver.h"
+#include "rupgraded.h"
 #include "server.h"
 #include "sse.h"
 #include "sub.h"
@@ -61,19 +65,19 @@ server_mark(void *ptr) {
     Upgraded	up;
 
     rb_gc_mark(rserver);
-    pthread_mutex_lock(&the_rserver.up_lock);
-    for (up = the_rserver.up_list; NULL != up; up = up->next) {
-	if (Qnil != up->handler) {
-	    rb_gc_mark(up->handler);
+    pthread_mutex_lock(&the_server.up_lock);
+    for (up = the_server.up_list; NULL != up; up = up->next) {
+	if (Qnil != (VALUE)up->ctx) {
+	    rb_gc_mark((VALUE)up->ctx);
 	}
-	if (Qnil != up->env) {
-	    rb_gc_mark(up->env);
+	if (Qnil != (VALUE)up->env) {
+	    rb_gc_mark((VALUE)up->env);
 	}
-	if (Qnil != up->wrap) {
-	    rb_gc_mark(up->wrap);
+	if (Qnil != (VALUE)up->wrap) {
+	    rb_gc_mark((VALUE)up->wrap);
 	}
     }
-    pthread_mutex_unlock(&the_rserver.up_lock);
+    pthread_mutex_unlock(&the_server.up_lock);
 }
 
 static void
@@ -94,8 +98,7 @@ configure(Err err, int port, const char *root, VALUE options) {
     the_rserver.worker_cnt = 1;
     the_server.running = 0;
     the_server.listen_thread = 0;
-    the_server.con_thread = 0;
-    the_rserver.max_push_pending = 32;
+    the_server.con_loops = NULL;
     the_server.root_first = false;
     the_server.binds = NULL;
 
@@ -121,12 +124,12 @@ configure(Err err, int port, const char *root, VALUE options) {
 	    }
 	}
 	if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("max_push_pending"))))) {
-	    int	tc = FIX2INT(v);
+	    int	mpp = FIX2INT(v);
 
-	    if (0 <= tc || tc < 1000) {
-		the_server.thread_cnt = tc;
+	    if (0 <= mpp || mpp < 1000) {
+		the_server.max_push_pending = mpp;
 	    } else {
-		rb_raise(rb_eArgError, "thread_count must be between 0 and 1000.");
+		rb_raise(rb_eArgError, "max_push_pending must be between 0 and 1000.");
 	    }
 	}
 	if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("pedantic"))))) {
@@ -160,7 +163,7 @@ configure(Err err, int port, const char *root, VALUE options) {
 		url_bind(v);
 		break;
 	    case T_ARRAY:
-		len = RARRAY_LEN(v);
+		len = (int)RARRAY_LEN(v);
 		for (i = 0; i < len; i++) {
 		    url_bind(rb_ary_entry(v, i));
 		}
@@ -236,17 +239,12 @@ rserver_init(int argc, VALUE *argv, VALUE self) {
 	options = argv[2];
     }
     server_setup();
-    sub_init(&the_rserver.sub_cache);
+    the_server.ctx_nil_value = (void*)Qnil;
+    the_server.env_nil_value = (void*)Qnil;
 
     if (ERR_OK != configure(&err, port, root, options)) {
 	rb_raise(rb_eArgError, "%s", err.msg);
     }
-    queue_multi_init(&the_rserver.pub_queue, 256, true, false);
-    queue_multi_init(&the_rserver.eval_queue, 1024, false, true);
-
-    pthread_mutex_init(&the_rserver.up_lock, 0);
-    the_rserver.up_list = NULL;
-    
     the_server.inited = true;
 
     return Qnil;
@@ -463,8 +461,8 @@ handle_rack_inner(void *x) {
 		t->len = sizeof(err500) - 1;
 		break;
 	    }
-	    req->hook = hook_create(NONE, NULL, (void*)handler, PUSH_HOOK, &the_rserver.eval_queue);
-	    upgraded_create(req->res->con, handler, request_env(req, Qnil));
+	    req->hook = hook_create(NONE, NULL, (void*)handler, PUSH_HOOK, &the_server.eval_queue);
+	    rupgraded_create(req->res->con, handler, request_env(req, Qnil));
 
 	    t->len = snprintf(t->text, 1024, "HTTP/1.1 101 %s\r\n", status_msg);
 	    t = ws_add_headers(req, t);
@@ -476,8 +474,8 @@ handle_rack_inner(void *x) {
 		t->len = sizeof(err500) - 1;
 		break;
 	    }
-	    req->hook = hook_create(NONE, NULL, (void*)handler, PUSH_HOOK, &the_rserver.eval_queue);
-	    upgraded_create(req->res->con, handler, request_env(req, Qnil));
+	    req->hook = hook_create(NONE, NULL, (void*)handler, PUSH_HOOK, &the_server.eval_queue);
+	    rupgraded_create(req->res->con, handler, request_env(req, Qnil));
 	    t = sse_upgrade(req, t);
 	    res_set_message(req->res, t);
 	    queue_wakeup(&the_server.con_queue);
@@ -556,7 +554,7 @@ handle_push_inner(void *x) {
     switch (req->method) {
     case ON_MSG:
 	if (req->up->on_msg && NULL != req->hook) {
-	    rb_funcall((VALUE)req->hook->handler, on_message_id, 2, req->up->wrap, rb_str_new(req->msg, req->mlen));
+	    rb_funcall((VALUE)req->hook->handler, on_message_id, 2, (VALUE)req->up->wrap, rb_str_new(req->msg, req->mlen));
 	}
 	break;
     case ON_BIN:
@@ -564,19 +562,19 @@ handle_push_inner(void *x) {
 	    volatile VALUE	rstr = rb_str_new(req->msg, req->mlen);
 
 	    rb_enc_associate(rstr, rb_ascii8bit_encoding());
-	    rb_funcall((VALUE)req->hook->handler, on_message_id, 2, req->up->wrap, rstr);
+	    rb_funcall((VALUE)req->hook->handler, on_message_id, 2, (VALUE)req->up->wrap, rstr);
 	}
 	break;
     case ON_CLOSE:
 	upgraded_ref(req->up);
-	queue_push(&the_rserver.pub_queue, pub_close(req->up));
+	server_publish(pub_close(req->up));
 	if (req->up->on_close && NULL != req->hook) {
-	    rb_funcall((VALUE)req->hook->handler, on_close_id, 1, req->up->wrap);
+	    rb_funcall((VALUE)req->hook->handler, on_close_id, 1, (VALUE)req->up->wrap);
 	}
 	break;
     case ON_SHUTDOWN:
 	if (NULL != req->hook) {
-	    rb_funcall((VALUE)req->hook->handler, rb_intern("on_shutdown"), 1, req->up->wrap);
+	    rb_funcall((VALUE)req->hook->handler, rb_intern("on_shutdown"), 1, (VALUE)req->up->wrap);
 	}
 	break;
     case ON_ERROR:
@@ -584,12 +582,12 @@ handle_push_inner(void *x) {
 	    volatile VALUE	rstr = rb_str_new(req->msg, req->mlen);
 
 	    rb_enc_associate(rstr, rb_ascii8bit_encoding());
-	    rb_funcall((VALUE)req->hook->handler, on_error_id, 2, req->up->wrap, rstr);
+	    rb_funcall((VALUE)req->hook->handler, on_error_id, 2, (VALUE)req->up->wrap, rstr);
 	}
 	break;
     case ON_EMPTY:
 	if (req->up->on_empty && NULL != req->hook) {
-	    rb_funcall((VALUE)req->hook->handler, on_drained_id, 1, req->up->wrap);
+	    rb_funcall((VALUE)req->hook->handler, on_drained_id, 1, (VALUE)req->up->wrap);
 	}
 	break;
     default:
@@ -640,6 +638,10 @@ handle_protected(Req req, bool gvi) {
 	    handle_push(req);
 	}
 	break;
+    case FUNC_HOOK:
+	req->hook->func(req);
+	queue_wakeup(&the_server.con_queue);
+	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");
@@ -659,9 +661,9 @@ process_loop(void *ptr) {
     
     atomic_fetch_add(&the_server.running, 1);
     while (the_server.active) {
-	if (NULL != (req = (Req)queue_pop(&the_rserver.eval_queue, 0.1))) {
+	if (NULL != (req = (Req)queue_pop(&the_server.eval_queue, 0.1))) {
 	    handle_protected(req, true);
-	    request_destroy(req);
+	    req_destroy(req);
 	}
     }
     atomic_fetch_sub(&the_server.running, 1);
@@ -721,9 +723,9 @@ rserver_start(VALUE self) {
 	Req		req;
 
 	while (the_server.active) {
-	    if (NULL != (req = (Req)queue_pop(&the_rserver.eval_queue, 0.1))) {
+	    if (NULL != (req = (Req)queue_pop(&the_server.eval_queue, 0.1))) {
 		handle_protected(req, false);
-		request_destroy(req);
+		req_destroy(req);
 	    } else {
 		rb_thread_schedule();
 	    }
@@ -754,7 +756,6 @@ rserver_start(VALUE self) {
 
 static void
 stop_runners() {
-    sub_cleanup(&the_rserver.sub_cache);
     // The preferred method 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
@@ -785,9 +786,6 @@ rserver_shutdown(VALUE self) {
     if (the_server.inited) {
 	server_shutdown("Agoo", stop_runners);
 
-	queue_cleanup(&the_rserver.pub_queue);
-	queue_cleanup(&the_rserver.eval_queue);
-
 	if (1 < the_rserver.worker_cnt && getpid() == *the_rserver.worker_pids) {
 	    int	i;
 	    int	status;
@@ -863,7 +861,7 @@ handle(VALUE self, VALUE method, VALUE pattern, VALUE handler) {
     } else {
 	rb_raise(rb_eArgError, "invalid method");
     }
-    if (NULL == (hook = rhook_create(meth, pat, handler, &the_rserver.eval_queue))) {
+    if (NULL == (hook = rhook_create(meth, pat, handler, &the_server.eval_queue))) {
 	rb_raise(rb_eStandardError, "out of memory.");
     } else {
 	Hook	h;
@@ -891,7 +889,7 @@ handle(VALUE self, VALUE method, VALUE pattern, VALUE handler) {
  */
 static VALUE
 handle_not_found(VALUE self, VALUE handler) {
-    if (NULL == (the_server.hook404 = rhook_create(GET, "/", handler, &the_rserver.eval_queue))) {
+    if (NULL == (the_server.hook404 = rhook_create(GET, "/", handler, &the_server.eval_queue))) {
 	rb_raise(rb_eStandardError, "out of memory.");
     }
     rb_gc_register_address((VALUE*)&the_server.hook404->handler);

data/ext/agoo/rserver.h

@@ -3,35 +3,14 @@
 #ifndef __AGOO_RSERVER_H__
 #define __AGOO_RSERVER_H__
 
-#include <pthread.h>
-#include <stdbool.h>
-#include <stdatomic.h>
-
 #include <ruby.h>
 
-#include "log.h"
-#include "queue.h"
-#include "sub.h"
-#include "upgraded.h"
-
 #define MAX_WORKERS	32
 
 typedef struct _RServer {
-    // pub/sub (maybe common across servers,,,
-    struct _Queue	pub_queue;
-    struct _SubCache	sub_cache; // subscription cache
-
-    struct _Queue	eval_queue;
-
-    // upgrade
-    pthread_mutex_t	up_lock;
-    int			max_push_pending;
-    Upgraded		up_list;
-
-    // threads and workers
-    int			worker_cnt;
-    int			worker_pids[MAX_WORKERS];
-    VALUE		*eval_threads; // Qnil terminated
+    int		worker_cnt;
+    int		worker_pids[MAX_WORKERS];
+    VALUE	*eval_threads; // Qnil terminated
 } *RServer;
 
 extern struct _RServer	the_rserver;

data/ext/agoo/rupgraded.c

@@ -0,0 +1,303 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#include <stdio.h>
+
+#include <ruby.h>
+#include <ruby/encoding.h>
+
+#include "con.h"
+#include "debug.h"
+#include "pub.h"
+#include "rserver.h"
+#include "rupgraded.h"
+#include "server.h"
+#include "subject.h"
+#include "upgraded.h"
+
+static VALUE	upgraded_class = Qundef;
+
+static VALUE	sse_sym;
+static VALUE	websocket_sym;
+
+static ID	on_open_id = 0;
+static ID	to_s_id = 0;
+
+static Upgraded
+get_upgraded(VALUE self) {
+    Upgraded	up = NULL;
+
+    if (the_server.active) {
+	pthread_mutex_lock(&the_server.up_lock);
+	if (NULL != (up = DATA_PTR(self))) {
+	    atomic_fetch_add(&up->ref_cnt, 1);
+	}
+	pthread_mutex_unlock(&the_server.up_lock);
+    }
+    return 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;
+}
+
+/* Document-method: write
+ *
+ * call-seq: write(msg)
+ *
+ * Writes a message to the WebSocket or SSE connection. Returns true if the
+ * message has been queued and false otherwise. A closed connection or too
+ * many pending messages could cause a value of false to be returned.
+ */
+static VALUE
+rup_write(VALUE self, VALUE msg) {
+    Upgraded	up = get_upgraded(self);
+    const char	*message;
+    size_t	mlen;
+    bool	bin = false;
+
+    if (NULL == up) {
+	return Qfalse;
+    }
+    if (T_STRING == rb_type(msg)) {
+	message = StringValuePtr(msg);
+	mlen = RSTRING_LEN(msg);
+	if (RB_ENCODING_IS_ASCII8BIT(msg)) {
+	    bin = true;
+	}
+    } else {
+	volatile VALUE	rs = rb_funcall(msg, to_s_id, 0);
+	
+	message = StringValuePtr(rs);
+	mlen = RSTRING_LEN(rs);
+    }
+    return upgraded_write(up, message, mlen, bin, false) ? Qtrue : Qfalse;
+}
+
+/* Document-method: subscribe
+ *
+ * call-seq: subscribe(subject)
+ *
+ * Subscribes to messages published on the specified subject. The subject is a
+ * 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
+rup_subscribe(VALUE self, VALUE subject) {
+    Upgraded	up;
+    int		slen;
+    const char	*subj = extract_subject(subject, &slen);
+
+    if (NULL != (up = get_upgraded(self))) {
+	upgraded_subscribe(up, subj, slen, false);
+    }
+    return Qnil;
+}
+
+/* Document-method: unsubscribe
+ *
+ * call-seq: unsubscribe(subject=nil)
+ *
+ * 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
+rup_unsubscribe(int argc, VALUE *argv, VALUE self) {
+    Upgraded	up;
+    const char	*subject = NULL;
+    int		slen = 0;
+
+    if (0 < argc) {
+	subject = extract_subject(argv[0], &slen);
+    }
+    if (NULL != (up = get_upgraded(self))) {
+	upgraded_unsubscribe(up, subject, slen, false);
+    }
+    return Qnil;
+}
+
+/* Document-method: close
+ *
+ * call-seq: close()
+ *
+ * Closes the connections associated with the handler.
+ */
+static VALUE
+rup_close(VALUE self) {
+    Upgraded	up = get_upgraded(self);
+
+    if (NULL != up) {
+	upgraded_close(up, false);
+    }
+    return Qnil;
+}
+
+/* Document-method: pending
+ *
+ * call-seq: pending()
+ *
+ * Returns the number of pending WebSocket or SSE writes. If the connection is
+ * closed then -1 is returned.
+ */
+static VALUE
+rup_pending(VALUE self) {
+    Upgraded	up = get_upgraded(self);
+    int		pending = -1;
+    
+    if (NULL != up) {
+	pending = upgraded_pending(up);
+	atomic_fetch_sub(&up->ref_cnt, 1);
+    }
+    return INT2NUM(pending);
+}
+
+/* Document-method: open?
+ *
+ * call-seq: open?()
+ *
+ * Returns true if the connection is open and false otherwise.
+ */
+static VALUE
+rup_open(VALUE self) {
+    Upgraded	up = get_upgraded(self);
+    int		pending = -1;
+    
+    if (NULL != up) {
+	pending = atomic_load(&up->pending);
+	atomic_fetch_sub(&up->ref_cnt, 1);
+    }
+    return 0 <= pending ? Qtrue : Qfalse;
+}
+
+/* Document-method: protocol
+ *
+ * call-seq: protocol()
+ *
+ * Returns the protocol of the upgraded connection as either :websocket or
+ * :sse. If no longer connected nil is returned.
+ */
+static VALUE
+rup_protocol(VALUE self) {
+    VALUE	pro = Qnil;
+
+    if (the_server.active) {
+	Upgraded	up;
+	
+	pthread_mutex_lock(&the_server.up_lock);
+	if (NULL != (up = DATA_PTR(self)) && NULL != up->con) {
+	    switch (up->con->bind->kind) {
+	    case CON_WS:
+		pro = websocket_sym;
+		break;
+	    case CON_SSE:
+		pro = sse_sym;
+		break;
+	    default:
+		break;
+	    }
+	}
+	pthread_mutex_unlock(&the_server.up_lock);
+    }
+    return pro;
+}
+
+static void
+on_destroy(Upgraded up) {
+    if (Qnil != (VALUE)up->wrap) {
+	DATA_PTR((VALUE)up->wrap) = NULL;
+	up->wrap = (void*)Qnil;
+    }
+}
+
+Upgraded
+rupgraded_create(Con c, VALUE obj, VALUE env) {
+    Upgraded	up;
+
+    if (!the_server.active) {
+	rb_raise(rb_eIOError, "Server shutdown.");
+    }
+    if (NULL != (up = upgraded_create(c, (void*)obj, (void*)env))) {
+	up->on_empty = rb_respond_to(obj, rb_intern("on_drained"));
+	up->on_close = rb_respond_to(obj, rb_intern("on_close"));
+	up->on_shut = rb_respond_to(obj, rb_intern("on_shutdown"));
+	up->on_msg = rb_respond_to(obj, rb_intern("on_message"));
+	up->on_error = rb_respond_to(obj, rb_intern("on_error"));
+	up->on_destroy = on_destroy;
+
+	up->wrap = (void*)Data_Wrap_Struct(upgraded_class, NULL, NULL, up);
+
+	server_add_upgraded(up);
+	
+	if (rb_respond_to(obj, on_open_id)) {
+	    rb_funcall(obj, on_open_id, 1, (VALUE)up->wrap);
+	}
+    }
+    return up;
+}
+
+// Use the publish from the Agoo module.
+extern VALUE	ragoo_publish(VALUE self, VALUE subject, VALUE message);
+
+/* Document-method: env
+ *
+ * call-seq: env()
+ *
+ * Returns the environment passed to the call method that initiated the
+ * Upgraded Object creation.
+ */
+static VALUE
+env(VALUE self) {
+    Upgraded	up = get_upgraded(self);
+
+    if (NULL != up) {
+	return (VALUE)up->env;
+    }
+    return Qnil;
+}
+
+/* Document-module: Agoo::Upgraded
+ *
+ * Adds methods to a handler of WebSocket and SSE connections.
+ */
+void
+upgraded_init(VALUE mod) {
+    upgraded_class = rb_define_class_under(mod, "Upgraded", rb_cObject);
+
+    rb_define_method(upgraded_class, "write", rup_write, 1);
+    rb_define_method(upgraded_class, "subscribe", rup_subscribe, 1);
+    rb_define_method(upgraded_class, "unsubscribe", rup_unsubscribe, -1);
+    rb_define_method(upgraded_class, "close", rup_close, 0);
+    rb_define_method(upgraded_class, "pending", rup_pending, 0);
+    rb_define_method(upgraded_class, "protocol", rup_protocol, 0);
+    rb_define_method(upgraded_class, "publish", ragoo_publish, 2);
+    rb_define_method(upgraded_class, "open?", rup_open, 0);
+    rb_define_method(upgraded_class, "env", env, 0);
+
+    on_open_id = rb_intern("on_open");
+    to_s_id = rb_intern("to_s");
+
+    sse_sym = ID2SYM(rb_intern("sse"));				rb_gc_register_address(&sse_sym);
+    websocket_sym = ID2SYM(rb_intern("websocket"));		rb_gc_register_address(&websocket_sym);
+}