agoo 2.5.1 → 2.5.2

data/ext/agoo/rupgraded.h

@@ -0,0 +1,17 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#ifndef __AGOO_RUPGRADED_H__
+#define __AGOO_RUPGRADED_H__
+
+#include <ruby.h>
+
+#include "upgraded.h"
+
+struct _Con;
+
+extern void	upgraded_init(VALUE mod);
+extern Upgraded	rupgraded_create(struct _Con *c, VALUE obj, VALUE env);
+
+extern const char*	extract_subject(VALUE subject, int *slen);
+
+#endif // __AGOO_RUPGRADED_H__

data/ext/agoo/server.c

@@ -4,6 +4,7 @@
 #include <netdb.h>
 #include <netinet/tcp.h>
 #include <poll.h>
+#include <string.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <unistd.h>
@@ -11,18 +12,40 @@
 #include "con.h"
 #include "dtime.h"
 #include "http.h"
+#include "hook.h"
 #include "log.h"
 #include "page.h"
+#include "pub.h"
+#include "upgraded.h"
 
 #include "server.h"
 
+#define LOOP_UP		512
+#define MAX_LOOP	4
+
 struct _Server	the_server = {false};
 
 void
 server_setup() {
     memset(&the_server, 0, sizeof(struct _Server));
+    pthread_mutex_init(&the_server.up_lock, 0);
+    the_server.up_list = NULL;
+    the_server.max_push_pending = 32;
     pages_init();
-    queue_multi_init(&the_server.con_queue, 256, false, false);
+    queue_multi_init(&the_server.con_queue, 1024, false, true);
+    queue_multi_init(&the_server.eval_queue, 1024, false, true);
+}
+
+static void
+add_con_loop() {
+    struct _Err	err = ERR_INIT;
+    ConLoop	loop = conloop_create(&err, 0);
+
+    if (NULL != loop) {
+	loop->next = the_server.con_loops;
+	the_server.con_loops = loop;
+	the_server.loop_cnt++;
+    }
 }
 
 static void*
@@ -50,7 +73,7 @@ listen_loop(void *x) {
     memset(&client_addr, 0, sizeof(client_addr));
     atomic_fetch_add(&the_server.running, 1);
     while (the_server.active) {
-	if (0 > (i = poll(pa, pcnt, 100))) {
+	if (0 > (i = poll(pa, pcnt, 200))) {
 	    if (EAGAIN == errno) {
 		continue;
 	    }
@@ -62,24 +85,33 @@ listen_loop(void *x) {
 	    continue;
 	}
 	for (b = the_server.binds, p = pa; NULL != b; b = b->next, p++) {
-	    // TBD instead of b->port use b->id
 	    if (0 != (p->revents & POLLIN)) {
 		if (0 > (client_sock = accept(p->fd, (struct sockaddr*)&client_addr, &alen))) {
 		    log_cat(&error_cat, "Server with pid %d accept connection failed. %s.", getpid(), strerror(errno));
-		} else if (NULL == (con = con_create(&err, client_sock, ++cnt))) {
+		} else if (NULL == (con = con_create(&err, client_sock, ++cnt, b))) {
 		    log_cat(&error_cat, "Server with pid %d accept connection failed. %s.", getpid(), err.msg);
 		    close(client_sock);
 		    cnt--;
 		    err_clear(&err);
 		} else {
+		    int	con_cnt;
 #ifdef OSX_OS
 		    setsockopt(client_sock, SOL_SOCKET, SO_NOSIGPIPE, &optval, sizeof(optval));
+#endif
+#ifdef PLATFORM_LINUX
+		    setsockopt(client_sock, IPPROTO_TCP, TCP_QUICKACK, &optval, sizeof(optval));
 #endif
 		    fcntl(client_sock, F_SETFL, O_NONBLOCK);
+		    //fcntl(client_sock, F_SETFL, FNDELAY);
 		    setsockopt(client_sock, SOL_SOCKET, SO_KEEPALIVE, &optval, sizeof(optval));
 		    setsockopt(client_sock, IPPROTO_TCP, TCP_NODELAY, &optval, sizeof(optval));
 		    log_cat(&con_cat, "Server with pid %d accepted connection %llu on %s [%d]",
 			    getpid(), (unsigned long long)cnt, b->id, con->sock);
+
+		    con_cnt = atomic_fetch_add(&the_server.con_cnt, 1);
+		    if (MAX_LOOP > the_server.loop_cnt && the_server.loop_cnt * LOOP_UP < con_cnt) {
+			add_con_loop();
+		    }
 		    queue_push(&the_server.con_queue, (void*)con);
 		}
 	    }
@@ -105,10 +137,11 @@ listen_loop(void *x) {
 int
 server_start(Err err, const char *app_name, const char *version) {
     double	giveup;
-
-    pthread_create(&the_server.listen_thread, NULL, listen_loop, NULL);
-    pthread_create(&the_server.con_thread, NULL, con_loop, NULL);
     
+    pthread_create(&the_server.listen_thread, NULL, listen_loop, NULL);
+    the_server.con_loops = conloop_create(err, 0);
+    the_server.loop_cnt = 1;
+
     giveup = dtime() + 1.0;
     while (dtime() < giveup) {
 	if (2 <= atomic_load(&the_server.running)) {
@@ -143,6 +176,8 @@ setup_listen(Err err) {
 void
 server_shutdown(const char *app_name, void (*stop)()) {
     if (the_server.inited) {
+	ConLoop	loop;
+
 	log_cat(&info_cat, "%s with pid %d shutting down.", app_name, getpid());
 	the_server.inited = false;
 	if (the_server.active) {
@@ -150,7 +185,9 @@ server_shutdown(const char *app_name, void (*stop)()) {
 	    
 	    the_server.active = false;
 	    pthread_detach(the_server.listen_thread);
-	    pthread_detach(the_server.con_thread);
+	    for (loop = the_server.con_loops; NULL != loop; loop = loop->next) {
+		pthread_detach(loop->thread);
+	    }
 	    while (0 < atomic_load(&the_server.running)) {
 		dsleep(0.1);
 		if (giveup < dtime()) {
@@ -173,6 +210,10 @@ server_shutdown(const char *app_name, void (*stop)()) {
 	    bind_destroy(b);
 	}
 	queue_cleanup(&the_server.con_queue);
+	for (loop = the_server.con_loops; NULL != loop; loop = loop->next) {
+	    queue_cleanup(&loop->pub_queue);
+	}
+	queue_cleanup(&the_server.eval_queue);
 
 	pages_cleanup();
 	http_cleanup();
@@ -181,6 +222,82 @@ server_shutdown(const char *app_name, void (*stop)()) {
 
 void
 server_bind(Bind b) {
+    // If a bind with the same port already exists, replace it.
+    Bind	prev = NULL;
+
+    if (NULL == b->read) {
+	b->read = con_http_read;
+    }
+    if (NULL == b->write) {
+	b->write = con_http_write;
+    }
+    if (NULL == b->events) {
+	b->events = con_http_events;
+    }
+    for (Bind bx = the_server.binds; NULL != bx; bx = bx->next) {
+	if (bx->port == b->port) {
+	    b->next = bx->next;
+	    if (NULL == prev) {
+		the_server.binds = b;
+	    } else {
+		prev->next = b;
+	    }
+	    bind_destroy(bx);
+	    return;
+	}
+	prev = bx;
+    }
     b->next = the_server.binds;
     the_server.binds = b;
 }
+
+void
+server_add_upgraded(Upgraded up) {
+    pthread_mutex_lock(&the_server.up_lock);
+    if (NULL == the_server.up_list) {
+	up->next = NULL;
+    } else {
+	the_server.up_list->prev = up;
+    }
+    up->next = the_server.up_list;
+    the_server.up_list = up;
+    up->con->up = up;
+    pthread_mutex_unlock(&the_server.up_lock);
+}
+
+int
+server_add_func_hook(Err	err,
+		     Method	method,
+		     const char	*pattern,
+		     void	(*func)(Req req),
+		     Queue	queue) {
+    Hook	h;
+    Hook	prev = NULL;
+    Hook	hook = hook_func_create(method, pattern, func, queue);
+
+    if (NULL == hook) {
+	return err_set(err, ERR_MEMORY, "failed to allocate memory for HTTP server Hook.");
+    }
+    for (h = the_server.hooks; NULL != h; h = h->next) {
+	prev = h;
+    }
+    if (NULL != prev) {
+	prev->next = hook;
+    } else {
+	the_server.hooks = hook;
+    }
+    return ERR_OK;
+}
+
+void
+server_publish(struct _Pub *pub) {
+    ConLoop	loop;
+
+    for (loop = the_server.con_loops; NULL != loop; loop = loop->next) {
+	if (NULL == loop->next) {
+	    queue_push(&loop->pub_queue, pub);
+	} else {
+	    queue_push(&loop->pub_queue, pub_dup(pub));
+	}
+    }
+}

data/ext/agoo/server.h

@@ -12,6 +12,11 @@
 #include "hook.h"
 #include "queue.h"
 
+struct _ConLoop;
+struct _Pub;
+struct _Req;
+struct _Upgraded;
+
 typedef struct _Server {
     volatile bool	inited;
     volatile bool	active;
@@ -19,15 +24,23 @@ typedef struct _Server {
     bool		pedantic;
     bool		root_first;
     pthread_t		listen_thread;
-    pthread_t		con_thread;
     struct _Queue	con_queue;
     Hook		hooks;
     Hook		hook404;
-
-    //int			port; // TBD remove
-    //int			fd; // TBD remove
     Bind		binds;
 
+    struct _Queue	eval_queue;
+
+    struct _ConLoop	*con_loops;
+    int			loop_cnt;
+    atomic_int		con_cnt;
+    
+    struct _Upgraded	*up_list;
+    pthread_mutex_t	up_lock;
+    int			max_push_pending;
+    void		*env_nil_value;
+    void		*ctx_nil_value;
+    
     // A count of the running threads from the wrapper or the server managed
     // threads.
     atomic_int		running;
@@ -42,4 +55,13 @@ extern void	server_bind(Bind b);
 extern int	setup_listen(Err err);
 extern int	server_start(Err err, const char *app_name, const char *version);
 
+extern void	server_add_upgraded(struct _Upgraded *up);
+extern int	server_add_func_hook(Err	err,
+				     Method	method,
+				     const char	*pattern,
+				     void	(*func)(struct _Req *req),
+				     Queue	queue);
+
+extern void	server_publish(struct _Pub *pub);
+
 #endif // __AGOO_SERVER_H__

data/ext/agoo/sse.c

@@ -1,6 +1,8 @@
 // Copyright (c) 2018, Peter Ohler, All rights reserved.
 
-#include "request.h"
+#include <stdlib.h>
+
+#include "req.h"
 #include "sse.h"
 #include "text.h"
 

data/ext/agoo/upgraded.c

@@ -1,35 +1,24 @@
 // Copyright (c) 2018, Peter Ohler, All rights reserved.
 
 #include <stdio.h>
-
-#include <ruby/encoding.h>
+#include <string.h>
 
 #include "con.h"
 #include "debug.h"
 #include "pub.h"
-#include "rserver.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 void
 destroy(Upgraded up) {
     Subject	subject;
 
-    if (Qnil != up->wrap) {
-	DATA_PTR(up->wrap) = NULL;
-	up->wrap = Qnil;
+    if (NULL != up->on_destroy) {
+	up->on_destroy(up);
     }
     if (NULL == up->prev) {
-	the_rserver.up_list = up->next;
+	the_server.up_list = up->next;
 	if (NULL != up->next) {
 	    up->next->prev = NULL;
 	}
@@ -47,45 +36,23 @@ 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_rserver.up_lock);
+    pthread_mutex_lock(&the_server.up_lock);
     if (atomic_fetch_sub(&up->ref_cnt, 1) <= 1) {
 	destroy(up);
     }    
-    pthread_mutex_unlock(&the_rserver.up_lock);
+    pthread_mutex_unlock(&the_server.up_lock);
 }
 
 void
 upgraded_release_con(Upgraded up) {
-    pthread_mutex_lock(&the_rserver.up_lock);
+    pthread_mutex_lock(&the_server.up_lock);
     up->con = NULL;
     if (atomic_fetch_sub(&up->ref_cnt, 1) <= 1) {
 	destroy(up);
     }
-    pthread_mutex_unlock(&the_rserver.up_lock);
+    pthread_mutex_unlock(&the_server.up_lock);
 }
 
 // Called from the con_loop thread, no need to lock, this steals the subject
@@ -147,274 +114,69 @@ upgraded_ref(Upgraded up) {
     atomic_fetch_add(&up->ref_cnt, 1);
 }
 
-static Upgraded
-get_upgraded(VALUE self) {
-    Upgraded	up = NULL;
-
-    if (the_server.active) {
-	pthread_mutex_lock(&the_rserver.up_lock);
-	if (NULL != (up = DATA_PTR(self))) {
-	    atomic_fetch_add(&up->ref_cnt, 1);
-	}
-	pthread_mutex_unlock(&the_rserver.up_lock);
-    }
-    return up;
-}
-
-/* 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
-up_write(VALUE self, VALUE msg) {
-    Upgraded	up = get_upgraded(self);
-    Pub		p;
+bool
+upgraded_write(Upgraded up, const char *message, size_t mlen, bool bin, bool inc_ref) {
+    Pub	p;
 
-    if (NULL == up) {
-	return Qfalse;
-    }
-    if (0 < the_rserver.max_push_pending && the_rserver.max_push_pending <= atomic_load(&up->pending)) {
+    if (0 < the_server.max_push_pending && the_server.max_push_pending <= atomic_load(&up->pending)) {
 	atomic_fetch_sub(&up->ref_cnt, 1);
 	// Too many pending messages.
-	return Qfalse;
+	return false;
     }
-    if (T_STRING == rb_type(msg)) {
-	if (RB_ENCODING_IS_ASCII8BIT(msg)) {
-	    p = pub_write(up, StringValuePtr(msg), RSTRING_LEN(msg), true);
-	} else {
-	    p = pub_write(up, StringValuePtr(msg), RSTRING_LEN(msg), false);
-	}
-    } else {
-	volatile VALUE	rs = rb_funcall(msg, to_s_id, 0);
-	
-	p = pub_write(up, StringValuePtr(rs), RSTRING_LEN(rs), false);
+    if (inc_ref) {
+	atomic_fetch_add(&up->ref_cnt, 1);
     }
+    p = pub_write(up, message, mlen, bin);
     atomic_fetch_add(&up->pending, 1);
-    queue_push(&the_rserver.pub_queue, p);
-
-    return Qtrue;
-}
-
-/* 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
-up_subscribe(VALUE self, VALUE subject) {
-    Upgraded	up;
-    int		slen;
-    const char	*subj = extract_subject(subject, &slen);
+    server_publish(p);
 
-    if (NULL != (up = get_upgraded(self))) {
-	atomic_fetch_add(&up->pending, 1);
-	queue_push(&the_rserver.pub_queue, pub_subscribe(up, subj, slen));
-    }
-    return Qnil;
+    return true;
 }
 
-/* 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
-up_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))) {
-	atomic_fetch_add(&up->pending, 1);
-	queue_push(&the_rserver.pub_queue, pub_unsubscribe(up, subject, slen));
-    }
-    return Qnil;
-}
-
-/* Document-method: close
- *
- * call-seq: close()
- *
- * Closes the connections associated with the handler.
- */
-static VALUE
-up_close(VALUE self) {
-    Upgraded	up = get_upgraded(self);
-
-    if (NULL != up) {
-	atomic_fetch_add(&up->pending, 1);
-	queue_push(&the_rserver.pub_queue, pub_close(up));
+void
+upgraded_subscribe(Upgraded up, const char *subject, int slen, bool inc_ref) {
+    if (inc_ref) {
+	atomic_fetch_add(&up->ref_cnt, 1);
     }
-    return Qnil;
+    atomic_fetch_add(&up->pending, 1);
+    server_publish(pub_subscribe(up, subject, slen));
 }
 
-/* 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
-pending(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);
+void
+upgraded_unsubscribe(Upgraded up, const char *subject, int slen, bool inc_ref) {
+    if (inc_ref) {
+	atomic_fetch_add(&up->ref_cnt, 1);
     }
-    return INT2NUM(pending);
+    atomic_fetch_add(&up->pending, 1);
+    server_publish(pub_unsubscribe(up, subject, slen));
 }
 
-/* Document-method: open?
- *
- * call-seq: open?()
- *
- * Returns true if the connection is open and false otherwise.
- */
-static VALUE
-up_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);
+void
+upgraded_close(Upgraded up, bool inc_ref) {
+    if (inc_ref) {
+	atomic_fetch_add(&up->ref_cnt, 1);
     }
-    return 0 <= pending ? Qtrue : Qfalse;
+    atomic_fetch_add(&up->pending, 1);
+    server_publish(pub_close(up));
 }
 
-/* Document-method: protocol
- *
- * call-seq: protocol()
- *
- * Returns the protocol of the upgraded connection as either :websocket or
- * :sse. If not longer connected nil is returned.
- */
-static VALUE
-protocol(VALUE self) {
-    VALUE	pro = Qnil;
-
-    if (the_server.active) {
-	Upgraded	up;
-	
-	pthread_mutex_lock(&the_rserver.up_lock);
-	if (NULL != (up = DATA_PTR(self)) && NULL != up->con) {
-	    switch (up->con->kind) {
-	    case CON_WS:
-		pro = websocket_sym;
-		break;
-	    case CON_SSE:
-		pro = sse_sym;
-		break;
-	    default:
-		break;
-	    }
-	}
-	pthread_mutex_unlock(&the_rserver.up_lock);
-    }
-    return pro;
+int
+upgraded_pending(Upgraded up) {
+    return atomic_load(&up->pending);
 }
 
 Upgraded
-upgraded_create(Con c, VALUE obj, VALUE env) {
+upgraded_create(Con c, void * ctx, void *env) {
     Upgraded	up = (Upgraded)malloc(sizeof(struct _Upgraded));
 
-    if (!the_server.active) {
-	rb_raise(rb_eIOError, "Server shutdown.");
-    }
     if (NULL != up) {
 	DEBUG_ALLOC(mem_upgraded, up);
+	memset(up, 0, sizeof(struct _Upgraded));
 	up->con = c;
-	up->handler = obj;
+	up->ctx = ctx;
 	up->env = env;
 	atomic_init(&up->pending, 0);
 	atomic_init(&up->ref_cnt, 1); // start with 1 for the Con reference
-	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->wrap = Data_Wrap_Struct(upgraded_class, NULL, NULL, up);
-	up->subjects = NULL;
-	up->prev = NULL;
-	pthread_mutex_lock(&the_rserver.up_lock);
-	if (NULL == the_rserver.up_list) {
-	    up->next = NULL;
-	} else {
-	    the_rserver.up_list->prev = up;
-	}
-	up->next = the_rserver.up_list;
-	the_rserver.up_list = up;
-	c->up = up;
-	pthread_mutex_unlock(&the_rserver.up_lock);
-
-	if (rb_respond_to(obj, on_open_id)) {
-	    rb_funcall(obj, on_open_id, 1, 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 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", up_write, 1);
-    rb_define_method(upgraded_class, "subscribe", up_subscribe, 1);
-    rb_define_method(upgraded_class, "unsubscribe", up_unsubscribe, -1);
-    rb_define_method(upgraded_class, "close", up_close, 0);
-    rb_define_method(upgraded_class, "pending", pending, 0);
-    rb_define_method(upgraded_class, "protocol", protocol, 0);
-    rb_define_method(upgraded_class, "publish", ragoo_publish, 2);
-    rb_define_method(upgraded_class, "open?", up_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);
-}