agoo 1.2.2 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6103f21468598e8f15a8a47bca17c2b7c1c358af72f8db93090cbf03e193677c
-  data.tar.gz: ee415fcfbb7a45daf9dbe52b286a03317bf900c667953b5cb632f9d1f34b19d9
+  metadata.gz: 3e5b92639ed425d8f0f8d33b8da3b5dd81a11249c5addcaec2707fd8d8917d5b
+  data.tar.gz: 84c94c8566135a06165d707c0f8f71f5728c347ae35e4deabcdb1c339f1756d3
 SHA512:
-  metadata.gz: 8874e326ca975f994409a298526d12062a788d98c428f6cd71bd3c166ca53e15add697a5aebc0321ab37816dc37598da8ab667164d77d37de5317711f84de5f3
-  data.tar.gz: 23c8284929d79573cf5de03cf57cab3bf308db6ab53e0edb112d1b31bcf5c7cc5895aad4d231a55bfc75a7b77ea5e111b134d4514938ed6e0a19afc43e585927
+  metadata.gz: fe77ec0550fe15e3ba8eb63d42c670d6738ce295bbf7dbc59e2566cbfba4a58768fc2d98af1720a73f32970d18cf92967686cc5330bac7b395dd7248a156a45e
+  data.tar.gz: 49f218eae4272aeda0e915279dc69fed7225e6bcdc07b6382a7a189b451a954b6685e6ce0195cf64c3efa0fb25df4dd1faa0e2e75cb071edfe4e2a24918371c4

data/README.md

@@ -11,7 +11,7 @@ A High Performance HTTP Server for Ruby
 ```ruby
 require 'agoo'
 
-server = Agoo::Server.new(6464, 'root')
+Agoo::Server.init(6464, 'root')
 
 class MyHandler
   def call(req)
@@ -20,8 +20,8 @@ class MyHandler
 end
 
 handler = MyHandler.new
-server.handle(:GET, "/hello", handler)
-server.start()
+Agoo::Server.handle(:GET, "/hello", handler)
+Agoo::Server.start()
 # To run this example type the following then go to a browser and enter a URL of localhost:6464/hello.
 # ruby hello.rb
 ```
@@ -38,14 +38,14 @@ performance HTTP server that serves static resource at hundreds of thousands
 of fetchs per second. A a simple hello world Ruby handler at over 100,000
 requests per second on a desktop computer. That places Agoo at about 85 times
 faster than Sinatra and 1000 times faster than Rails. In both cases the
-latency was two orders of magnitude lower or more. Checkout the benchmarks on <a
-href="http://opo.technology/benchmarks.html#web_benchmarks">OpO
-benchmarks</a>. Note that the benchmarks had to use a C program called _hose_
-from the <a href="http://opo.technology/index.html">OpO</a> downloads to hit
-the Agoo limits. Ruby benchmarks driver could not push Agoo hard enough.
+latency was two orders of magnitude lower or more. Checkout the benchmarks on
+<a href="http://opo.technology/benchmarks.html#web_benchmarks">OpO
+benchmarks</a>. Note that the benchmarks had to use a C program called <a
+href="https://github.com/ohler55/perfer">Perfer</a> to hit the Agoo
+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.
+use of rack compatible gems. Agoo also supports WebSockets and SSE.
 
 ## Releases
 
@@ -64,4 +64,6 @@ the develop branch. Pull requests should be made against the develop branch.
 
  - *WABuR* *repo*: https://github.com/ohler55/wabur has an option to use Agoo
 
+ - *Perfer* *repo*: https://github.com/ohler55/perfer
+
 Follow [@peterohler on Twitter](http://twitter.com/#!/peterohler) for announcements and news about the Agoo gem.

data/ext/agoo/agoo.c

@@ -1,13 +1,49 @@
 // Copyright (c) 2018, Peter Ohler, All rights reserved.
 
+#include <signal.h>
 #include <stdio.h>
+
 #include <ruby.h>
 
+#include "debug.h"
 #include "error_stream.h"
+#include "log.h"
 #include "rack_logger.h"
 #include "request.h"
 #include "response.h"
 #include "server.h"
+#include "subscription.h"
+#include "upgraded.h"
+
+void
+agoo_shutdown() {
+    server_shutdown();
+    log_close();
+}
+
+/* Document-method: shutdown
+ *
+ * call-seq: shutdown()
+ *
+ * Shutdown the server and logger.
+ */
+static VALUE
+ragoo_shutdown(VALUE self) {
+    agoo_shutdown();
+    debug_rreport();
+    return Qnil;
+}
+
+static void
+sig_handler(int sig) {
+    agoo_shutdown();
+
+    debug_report();
+    // Use exit instead of rb_exit as rb_exit segfaults most of the time.
+    //rb_exit(0);
+    exit(0);
+}
+
 
 /* Document-module: Agoo
  *
@@ -18,9 +54,18 @@ void
 Init_agoo() {
     VALUE	mod = rb_define_module("Agoo");
 
+    log_init(mod);
     error_stream_init(mod);
     rack_logger_init(mod);
     request_init(mod);
     response_init(mod);
     server_init(mod);
+    subscription_init(mod);
+    upgraded_init(mod);
+
+    rb_define_module_function(mod, "shutdown", ragoo_shutdown, 0);
+
+    signal(SIGINT, sig_handler);
+    signal(SIGTERM, sig_handler);
+    signal(SIGPIPE, SIG_IGN);
 }

data/ext/agoo/base64.c

@@ -0,0 +1,107 @@
+// Copyright 2011, 2016, 2018 by Peter Ohler, All Rights Reserved
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "base64.h"
+
+static char	digits[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+/* invalid or terminating characters are set to 'X' or \x58 */
+static uchar	s_digits[257] = "\
+\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\
+\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\
+\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x3E\x58\x58\x58\x3F\
+\x34\x35\x36\x37\x38\x39\x3A\x3B\x3C\x3D\x58\x58\x58\x58\x58\x58\
+\x58\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\
+\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x58\x58\x58\x58\x58\
+\x58\x1A\x1B\x1C\x1D\x1E\x1F\x20\x21\x22\x23\x24\x25\x26\x27\x28\
+\x29\x2A\x2B\x2C\x2D\x2E\x2F\x30\x31\x32\x33\x58\x58\x58\x58\x58\
+\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\
+\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\
+\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\
+\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\
+\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\
+\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\
+\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\
+\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58";
+
+int
+b64_to(const uchar *src, int len, char *b64) {
+    const uchar	*end3;
+    int		len3 = len % 3;
+    uchar	b1, b2, b3;
+    char	*start = b64;
+    
+    end3 = src + (len - len3);
+    while (src < end3) {
+	b1 = *src++;
+	b2 = *src++;
+	b3 = *src++;
+	*b64++ = digits[(uchar)(b1 >> 2)];
+	*b64++ = digits[(uchar)(((b1 & 0x03) << 4) | (b2 >> 4))];
+	*b64++ = digits[(uchar)(((b2 & 0x0F) << 2) | (b3 >> 6))];
+	*b64++ = digits[(uchar)(b3 & 0x3F)];
+    }
+    if (1 == len3) {
+	b1 = *src++;
+	*b64++ = digits[b1 >> 2];
+	*b64++ = digits[(b1 & 0x03) << 4];
+	*b64++ = '=';
+	*b64++ = '=';
+    } else if (2 == len3) {
+	b1 = *src++;
+	b2 = *src++;
+	*b64++ = digits[b1 >> 2];
+	*b64++ = digits[((b1 & 0x03) << 4) | (b2 >> 4)];
+	*b64++ = digits[(b2 & 0x0F) << 2];
+	*b64++ = '=';
+    }
+    *b64 = '\0';
+
+    return (int)(b64 - start);
+}
+
+unsigned long
+b64_orig_size(const char *text) {
+    const char		*start = text;
+    unsigned long	size = 0;
+
+    if ('\0' != *text) {
+	for (; 0 != *text; text++) { }
+	size = (text - start) * 3 / 4;
+	text--;
+	if ('=' == *text) {
+	    size--;
+	    text--;
+	    if ('=' == *text) {
+		size--;
+	    }
+	}
+    }
+    return size;
+}
+
+void
+b64_from(const char *b64, uchar *str) {
+    uchar	b0, b1, b2, b3;
+    
+    while (1) {
+	if ('X' == (b0 = s_digits[(uchar)*b64++])) {
+	    break;
+	}
+	if ('X' == (b1 = s_digits[(uchar)*b64++])) {
+	    break;
+	}
+	*str++ = (b0 << 2) | ((b1 >> 4) & 0x03);
+	if ('X' == (b2 = s_digits[(uchar)*b64++])) {
+	    break;
+	}
+	*str++ = (b1 << 4) | ((b2 >> 2) & 0x0F);
+	if ('X' == (b3 = s_digits[(uchar)*b64++])) {
+	    break;
+	}
+	*str++ = (b2 << 6) | b3;
+    }
+    *str = '\0';
+}

data/ext/agoo/base64.h

@@ -0,0 +1,15 @@
+// Copyright 2011, 2016, 2018 by Peter Ohler, All Rights Reserved
+
+#ifndef __AGOO_BASE64_H__
+#define __AGOO_BASE64_H__
+
+typedef unsigned char	uchar;
+
+#define b64_size(len) ((len + 2) / 3 * 4)
+
+extern unsigned long    b64_orig_size(const char *text);
+
+extern int	        b64_to(const uchar *src, int len, char *b64);
+extern void             b64_from(const char *b64, uchar *str);
+
+#endif /* __AGOO_BASE64_H__ */

data/ext/agoo/ccache.c

@@ -0,0 +1,301 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <stdio.h>
+
+#include "ccache.h"
+#include "con.h"
+#include "debug.h"
+
+static void
+cc_mark(void *ptr) {
+    if (NULL != ptr) {
+	CCache	cc = (CCache)ptr;
+	CSlot	slot;
+	CSlot	*bp = cc->buckets;
+	CSlot	*end = bp + CC_BUCKET_SIZE;
+
+	if (Qnil != cc->wrap) {
+	    rb_gc_mark(cc->wrap);
+	}
+	pthread_mutex_lock(&cc->lock);
+	for (bp = cc->buckets; bp < end; bp++) {
+	    for (slot = *bp; NULL != slot; slot = slot->next) {
+		if (Qnil != slot->handler) {
+		    rb_gc_mark(slot->handler);
+		}
+	    }
+	}
+	pthread_mutex_unlock(&cc->lock);
+    }
+}
+
+
+void
+cc_init(CCache cc) {
+    memset(cc, 0, sizeof(struct _CCache));
+    pthread_mutex_init(&cc->lock, 0);
+    cc->wrap = Data_Wrap_Struct(rb_cObject, cc_mark, NULL, cc);
+}
+
+void
+cc_cleanup(CCache cc) {
+    CSlot	*sp = cc->buckets;
+    CSlot	s;
+    CSlot	n;
+    int		i;
+    
+    for (i = CC_BUCKET_SIZE; 0 < i; i--, sp++) {
+	for (s = *sp; NULL != s; s = n) {
+	    n = s->next;
+	    DEBUG_FREE(mem_cslot, s);
+	    free(s);
+	}
+	*sp = NULL;
+    }
+}
+
+CSlot
+cc_set_con(CCache cc, Con con) {
+    CSlot	*bucket = cc->buckets + (CC_BUCKET_MASK & con->id);
+    CSlot	slot;
+
+    pthread_mutex_lock(&cc->lock);
+    for (slot = *bucket; NULL != slot; slot = slot->next) {
+	if (con->id = slot->cid) {
+	    slot->con = con;
+	    break;
+	}
+    }
+    if (NULL == slot) {
+	if (NULL != (slot = (CSlot)malloc(sizeof(struct _CSlot)))) {
+	    DEBUG_ALLOC(mem_cslot, slot);
+	    slot->cid = con->id;
+	    slot->con = con;
+	    slot->handler = Qnil;
+	    slot->on_empty = false;
+	    slot->on_close = false;
+	    slot->on_shut = false;
+	    slot->on_msg = false;
+	    atomic_init(&slot->pending, 0);
+	    atomic_init(&slot->ref_cnt, 1);
+	    slot->next = *bucket;
+	    *bucket = slot;
+	}
+    }
+    pthread_mutex_unlock(&cc->lock);
+
+    return slot;
+}
+
+void
+cc_set_handler(CCache cc, uint64_t cid, VALUE handler, bool on_empty, bool on_close, bool on_shut, bool on_msg) {
+    CSlot	*bucket = cc->buckets + (CC_BUCKET_MASK & cid);
+    CSlot	slot;
+
+    pthread_mutex_lock(&cc->lock);
+    for (slot = *bucket; NULL != slot; slot = slot->next) {
+	if (cid = slot->cid) {
+	    slot->handler = handler;
+	    break;
+	}
+    }
+    if (NULL == slot) {
+	// TBD is is faster to lock twice or allocate while locked?
+	if (NULL != (slot = (CSlot)malloc(sizeof(struct _CSlot)))) {
+	    DEBUG_ALLOC(mem_cslot, slot);
+	    slot->cid = cid;
+	    slot->con = NULL;
+	    slot->handler = handler;
+	    slot->on_empty = on_empty;
+	    slot->on_close = on_close;
+	    slot->on_shut = on_shut;
+	    slot->on_msg = on_msg;
+	    atomic_init(&slot->pending, 0);
+	    atomic_init(&slot->ref_cnt, 1);
+	    slot->next = *bucket;
+	    slot->on_empty = on_empty;
+	    slot->on_close = on_close;
+	    slot->on_shut = on_shut;
+	    slot->on_msg = on_msg;
+	    *bucket = slot;
+	}
+    }
+    pthread_mutex_unlock(&cc->lock);
+}
+
+void
+cc_remove(CCache cc, uint64_t cid) {
+    CSlot	*bucket = cc->buckets + (CC_BUCKET_MASK & cid);
+    CSlot	slot;
+    CSlot	prev = NULL;
+
+    pthread_mutex_lock(&cc->lock);
+    for (slot = *bucket; NULL != slot; slot = slot->next) {
+	if (cid = slot->cid) {
+	    if (NULL == prev) {
+		*bucket = slot->next;
+	    } else {
+		prev->next = slot->next;
+	    }
+	    break;
+	}
+	prev = slot;
+    }
+    pthread_mutex_unlock(&cc->lock);
+    if (NULL != slot) {
+	DEBUG_FREE(mem_cslot, slot)
+	free(slot);
+    }
+}
+
+void
+cc_remove_con(CCache cc, uint64_t cid) {
+    CSlot	*bucket = cc->buckets + (CC_BUCKET_MASK & cid);
+    CSlot	slot;
+    CSlot	prev = NULL;
+
+    pthread_mutex_lock(&cc->lock);
+    for (slot = *bucket; NULL != slot; slot = slot->next) {
+	if (cid = slot->cid) {
+	    if (atomic_fetch_sub(&slot->ref_cnt, 1) <= 1) {
+		if (NULL == prev) {
+		    *bucket = slot->next;
+		} else {
+		    prev->next = slot->next;
+		}
+	    } else {
+		atomic_store(&slot->pending, -1);
+		slot = NULL;
+	    }
+	    break;
+	}
+	prev = slot;
+    }
+    pthread_mutex_unlock(&cc->lock);
+    if (NULL != slot) {
+	DEBUG_FREE(mem_cslot, slot)
+	free(slot);
+    }
+}
+
+VALUE
+cc_ref_dec(CCache cc, uint64_t cid) {
+    CSlot	*bucket = cc->buckets + (CC_BUCKET_MASK & cid);
+    CSlot	slot;
+    VALUE	handler = Qnil;
+    CSlot	prev = NULL;
+
+    pthread_mutex_lock(&cc->lock);
+    for (slot = *bucket; NULL != slot; slot = slot->next) {
+	if (cid = slot->cid) {
+	    int	rcnt = atomic_fetch_sub(&slot->ref_cnt, 1);
+
+	    handler = slot->handler;
+	    if (rcnt <= 1) {
+		if (NULL == prev) {
+		    *bucket = slot->next;
+		} else {
+		    prev->next = slot->next;
+		}
+	    } else {
+		slot = NULL;
+	    }
+	    break;
+	}
+	prev = slot;
+    }
+    pthread_mutex_unlock(&cc->lock);
+    if (NULL != slot) {
+	DEBUG_FREE(mem_cslot, slot)
+	free(slot);
+    }
+    return handler;
+}
+
+Con
+cc_get_con(CCache cc, uint64_t cid) {
+    CSlot	*bucket = cc->buckets + (CC_BUCKET_MASK & cid);
+    CSlot	slot;
+    Con		con = NULL;
+
+    pthread_mutex_lock(&cc->lock);
+    for (slot = *bucket; NULL != slot; slot = slot->next) {
+	if (cid = slot->cid) {
+	    con = slot->con;
+	    break;
+	}
+    }
+    pthread_mutex_unlock(&cc->lock);
+
+    return con;
+}
+
+VALUE
+cc_get_handler(CCache cc, uint64_t cid) {
+    CSlot	*bucket = cc->buckets + (CC_BUCKET_MASK & cid);
+    CSlot	slot;
+    VALUE	handler = Qnil;
+
+    pthread_mutex_lock(&cc->lock);
+    for (slot = *bucket; NULL != slot; slot = slot->next) {
+	if (cid = slot->cid) {
+	    handler = slot->handler;
+	    break;
+	}
+    }
+    pthread_mutex_unlock(&cc->lock);
+
+    return handler;
+}
+
+int
+cc_get_pending(CCache cc, uint64_t cid) {
+    CSlot	*bucket = cc->buckets + (CC_BUCKET_MASK & cid);
+    CSlot	slot;
+    int		pending = -1;
+
+    pthread_mutex_lock(&cc->lock);
+    for (slot = *bucket; NULL != slot; slot = slot->next) {
+	if (cid = slot->cid) {
+	    pending = atomic_load(&slot->pending);
+	    break;
+	}
+    }
+    pthread_mutex_unlock(&cc->lock);
+
+    return pending;
+}
+
+CSlot
+cc_get_slot(CCache cc, uint64_t cid) {
+    CSlot	*bucket = cc->buckets + (CC_BUCKET_MASK & cid);
+    CSlot	slot;
+
+    pthread_mutex_lock(&cc->lock);
+    for (slot = *bucket; NULL != slot; slot = slot->next) {
+	if (cid = slot->cid) {
+	    break;
+	}
+    }
+    pthread_mutex_unlock(&cc->lock);
+
+    return slot;
+}
+
+void
+cc_pending_inc(CCache cc, uint64_t cid) {
+    CSlot	*bucket = cc->buckets + (CC_BUCKET_MASK & cid);
+    CSlot	slot;
+
+    pthread_mutex_lock(&cc->lock);
+    for (slot = *bucket; NULL != slot; slot = slot->next) {
+	if (cid = slot->cid) {
+	    atomic_fetch_add(&slot->pending, 1);
+	    break;
+	}
+    }
+    pthread_mutex_unlock(&cc->lock);
+}