agoo 1.2.2 → 2.0.0

data/ext/agoo/server.h

@@ -9,33 +9,30 @@
 
 #include <ruby.h>
 
+#include "ccache.h"
 #include "hook.h"
 #include "log.h"
 #include "page.h"
 #include "queue.h"
+#include "sub.h"
 
 typedef struct _Server {
+    volatile bool	inited;
     volatile bool	active;
-    volatile bool	ready;
     int			thread_cnt;
+    int			max_push_pending;
     int			port;
     bool		pedantic;
     char		*root;
     atomic_int		running;
     pthread_t		listen_thread;
     pthread_t		con_thread;
-    struct _Log		log;
-    struct _LogCat	error_cat;
-    struct _LogCat	warn_cat;
-    struct _LogCat	info_cat;
-    struct _LogCat	debug_cat;
-    struct _LogCat	con_cat;
-    struct _LogCat	req_cat;
-    struct _LogCat	resp_cat;
-    struct _LogCat	eval_cat;
     
     struct _Queue	con_queue;
+    struct _Queue	pub_queue;
     struct _Cache	pages;
+    struct _SubCache	sub_cache; // subscription cache
+    struct _CCache	con_cache; // Only WebSocket and SSE connections
 
     Hook		hooks;
     Hook		hook404;
@@ -44,6 +41,9 @@ typedef struct _Server {
     VALUE		*eval_threads; // Qnil terminated
 } *Server;
 
+extern struct _Server	the_server;
+
 extern void	server_init(VALUE mod);
+extern void	server_shutdown();
 
 #endif // __AGOO_SERVER_H__

data/ext/agoo/sha1.c

@@ -0,0 +1,148 @@
+// Taken and modified from the original by Steve Reid which is in the public
+// domain. It has been modified by James H. Brown, Saul Kravitz, Ralph Giles,
+// and now Peter Ohler.
+
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "sha1.h"
+
+typedef struct {
+    uint32_t    h0;
+    uint32_t    h1;
+    uint32_t    h2;
+    uint32_t    h3;
+    uint32_t    h4;
+    uint32_t    count[2];
+    uint8_t     buffer[64];
+} Ctx;
+
+// TBD make this stuff ENDIAN independent. Now it is little endian only.
+#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
+#define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00)|(rol(block->l[i],8)&0x00FF00FF))
+#define blk(i) (block->l[i&0x0F] = rol(block->l[(i+13)&0x0F]^block->l[(i+8)&0x0F]^block->l[(i+2)&0x0F]^block->l[i&0x0F],1))
+
+#define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
+#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
+#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
+#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
+#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
+
+// Transform a 512 bit block.
+static void
+transform(Ctx *ctx, const uint8_t buffer[64]) {
+    uint32_t    a = ctx->h0;
+    uint32_t    b = ctx->h1;
+    uint32_t    c = ctx->h2;
+    uint32_t    d = ctx->h3;
+    uint32_t    e = ctx->h4;
+
+    typedef union {
+        uint8_t c[64];
+        uint32_t l[16];
+    } CHAR64LONG16;
+    CHAR64LONG16* block;
+
+    block = (CHAR64LONG16*)buffer;
+
+    /* 4 rounds of 20 operations each. Loop unrolled. */
+    R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3);
+    R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7);
+    R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
+    R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15);
+    R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
+    R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23);
+    R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27);
+    R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31);
+    R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35);
+    R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39);
+    R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43);
+    R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47);
+    R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51);
+    R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55);
+    R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59);
+    R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63);
+    R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67);
+    R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
+    R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
+    R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
+
+    ctx->h0 += a;
+    ctx->h1 += b;
+    ctx->h2 += c;
+    ctx->h3 += d;
+    ctx->h4 += e;
+}
+
+static void
+update(Ctx *ctx, const uint8_t* data, const size_t len) {
+    size_t      i;
+    size_t      j = (ctx->count[0] >> 3) & 0x3F;
+
+    if ((ctx->count[0] += len << 3) < (len << 3)) {
+        ctx->count[1]++;
+    }
+    ctx->count[1] += (len >> 29);
+    if ((j + len) > 63) {
+        i = 64 - j;
+        memcpy(ctx->buffer + j, data, i);
+        transform(ctx, ctx->buffer);
+        for (; i + 63 < len; i += 64) {
+            transform(ctx, data + i);
+        }
+        j = 0;
+    } else {
+        i = 0;
+    }
+    memcpy(ctx->buffer + j, data + i, len - i);
+}
+
+void
+sha1(const uint8_t *data, size_t len, uint8_t *digest) {
+    Ctx		ctx;
+    uint32_t    i;
+    uint8_t     finalcount[8];
+    int         shift;
+
+    ctx.h0 = 0x67452301;
+    ctx.h1 = 0xEFCDAB89;
+    ctx.h2 = 0x98BADCFE;
+    ctx.h3 = 0x10325476;
+    ctx.h4 = 0xC3D2E1F0;
+    ctx.count[0] = 0;
+    ctx.count[1] = 0;
+
+    update(&ctx, data, len);
+
+    for (i = 0; i < 8; i++) {
+        finalcount[i] = (uint8_t)((ctx.count[(i >= 4 ? 0 : 1)] >> ((3-(i & 3)) * 8) ) & 0xFF);
+    }
+    update(&ctx, (uint8_t*)"\x80", 1);
+    while ((ctx.count[0] & 0x000001F8) != 0x000001C0) {
+        update(&ctx, (uint8_t*)"", 1);
+    }
+    update(&ctx, finalcount, 8);
+    for (i = 0; i < SHA1_DIGEST_SIZE; i++) {
+        shift = (3 - (i & 3)) * 8;
+        switch (i >> 2) {
+        case 0:
+            digest[i] = (uint8_t)((ctx.h0 >> shift) & 0xFF);
+            break;
+        case 1:
+            digest[i] = (uint8_t)((ctx.h1 >> shift) & 0xFF);
+            break;
+        case 2:
+            digest[i] = (uint8_t)((ctx.h2 >> shift) & 0xFF);
+            break;
+        case 3:
+            digest[i] = (uint8_t)((ctx.h3 >> shift) & 0xFF);
+            break;
+        case 4:
+            digest[i] = (uint8_t)((ctx.h4 >> shift) & 0xFF);
+            break;
+        default:
+            break;
+        }
+    }
+}

data/ext/agoo/sha1.h

@@ -0,0 +1,10 @@
+#ifndef __AGOO_SHA1_H__
+#define __AGOO_SHA1_H__
+
+#include <stdint.h>
+
+#define SHA1_DIGEST_SIZE 20
+
+extern void sha1(const uint8_t *data, size_t len, uint8_t *digest);
+
+#endif // __AGOO_SHA1_H__

data/ext/agoo/sse.c

@@ -0,0 +1,26 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#include "request.h"
+#include "sse.h"
+#include "text.h"
+
+static const char	prefix[] = "event: msg\ndata: ";
+static const char	suffix[] = "\n\n";
+static const char	up[] = "HTTP/1.1 200 OK\r\n\
+Content-Type: text/event-stream\r\n\
+Cache-Control: no-cache\r\n\
+Connection: keep-alive\r\n\
+\r\n\
+retry: 5\n\n";
+
+Text
+sse_upgrade(Req req, Text t) {
+    t->len = 0; // reset
+    return text_append(t, up, sizeof(up) - 1);
+}
+
+Text
+sse_expand(Text t) {
+    t = text_prepend(t, prefix, sizeof(prefix) - 1);
+    return text_append(t, suffix, sizeof(suffix) - 1);
+}

data/ext/agoo/sse.h

@@ -0,0 +1,12 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#ifndef __AGOO_SSE_H__
+#define __AGOO_SSE_H__
+
+struct _Req;
+struct _Text;
+
+extern struct _Text*	sse_upgrade(struct _Req *req, struct _Text *t);
+extern struct _Text*	sse_expand(struct _Text *t);
+
+#endif // __AGOO_SSE_H__

data/ext/agoo/sub.c

@@ -0,0 +1,111 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "sub.h"
+
+Sub
+sub_new(uint64_t cid, uint64_t id, const char *subject, size_t slen) {
+    Sub	s = (Sub)malloc(sizeof(struct _Sub) - 8 + slen + 1);
+
+    if (NULL != s) {
+	s->cid = cid;
+	s->id = id;
+	strncpy(s->subject, subject, slen);
+	s->subject[slen] = '\0';
+    }
+    return s;
+}
+
+bool
+sub_match(Sub s, const char *subject, size_t slen) {
+    const char	*pat = s->subject;
+    const char	*end = subject + slen;
+
+    for (; '\0' != *pat && subject < end; subject++) {
+	if (*subject == *pat) {
+	    subject++;
+	} else if ('*' == *pat) {
+	    for (; subject < end && '.' != *subject; subject++) {
+	    }
+	} else if ('>' == *pat) {
+	    return true;
+	} else {
+	    break;
+	}
+    }
+    return '\0' == *pat && subject == end;
+}
+
+void
+sub_init(SubCache sc) {
+    memset(sc, 0, sizeof(struct _SubCache));
+}
+
+void
+sub_cleanup(SubCache sc) {
+    Sub	s;
+    Sub	head;
+    Sub	*bucket;
+    int	i;
+    
+    for (i = 0, bucket = sc->buckets; i < SUB_BUCKET_SIZE; i++, bucket++) {
+	head = *bucket;
+	while (NULL != head) {
+	    s = head;
+	    head = head->next;
+	    free(s);
+	}
+    }
+}
+
+static uint64_t
+calc_hash(uint64_t cid, uint64_t sid) {
+    return (SUB_BUCKET_MASK & (cid ^ sid));
+}
+
+void
+sub_add(SubCache sc, Sub s) {
+    Sub	*bucket = sc->buckets + calc_hash(s->cid, s->id);
+
+    s->next = *bucket;
+    *bucket = s;
+}
+
+Sub
+sub_get(SubCache sc, uint64_t cid, uint64_t sid) {
+    Sub	s = *(sc->buckets + calc_hash(cid, sid));
+    
+    for (; NULL != s; s = s->next) {
+	if (s->cid == cid && s->id == sid) {
+	    return s;
+	}
+    }
+    return NULL;
+}
+
+void
+sub_del(SubCache sc, uint64_t cid, uint64_t sid) {
+    Sub	*bucket = sc->buckets + calc_hash(cid, sid);
+
+    if (NULL != *bucket) {
+	Sub	s = *bucket;
+
+	if (s->cid == cid && s->id == sid) {
+	    *bucket = s->next;
+	} else {
+	    Sub	prev = s;
+	    
+	    for (s = s->next; NULL != s; s = s->next) {
+		if (s->cid == cid && s->id == sid) {
+		    prev->next = s->next;
+		    free(s);
+		    break;
+		}
+		prev = s;
+	    }
+	}
+    }
+}
+

data/ext/agoo/sub.h

@@ -0,0 +1,36 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#ifndef __AGOO_SUB_H__
+#define __AGOO_SUB_H__
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#define SUB_BUCKET_SIZE	1024
+#define SUB_BUCKET_MASK	1023
+
+struct _Con;
+
+typedef struct _Sub {
+    struct _Sub	*next;
+    uint64_t	cid;
+    struct _Con	*con;
+    uint64_t	id;
+    uint64_t	key; // hash key
+    char	subject[8];
+} *Sub;
+
+typedef struct _SubCache {
+    Sub	buckets[SUB_BUCKET_SIZE];
+} *SubCache;
+
+extern void	sub_init(SubCache sc);
+extern void	sub_cleanup(SubCache sc);
+
+extern Sub	sub_new(uint64_t cid, uint64_t id, const char *subject, size_t slen);
+extern bool	sub_match(Sub s, const char *subject, size_t slen);
+extern void	sub_add(SubCache sc, Sub s);
+extern Sub	sub_get(SubCache sc, uint64_t cid, uint64_t sid);
+extern void	sub_del(SubCache sc, uint64_t cid, uint64_t sid);
+
+#endif // __AGOO_SUB_H__

data/ext/agoo/subscription.c

@@ -0,0 +1,54 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#include "pub.h"
+#include "queue.h"
+#include "server.h"
+#include "subscription.h"
+
+static VALUE	subscription_class = Qundef;
+
+VALUE
+subscription_new(uint64_t cid, uint64_t id, VALUE handler) {
+    Subscription	s = ALLOC(struct _Subscription);
+
+    s->cid = cid;
+    s->id = id;
+    s->handler = handler;
+    s->self = Data_Wrap_Struct(subscription_class, NULL, xfree, s);
+
+    return s->self;
+}
+
+/* Document-method: close
+ *
+ * call-seq: close()
+ *
+ * Close or unsubscribe a subscription.
+ */
+static VALUE
+subscription_close(VALUE self) {
+    Subscription	s = DATA_PTR(self);
+
+    if (0 != s->cid && 0 != s->id) {
+	Pub	p = pub_unsubscribe(s->cid, s->id);
+	
+	queue_push(&the_server.pub_queue, (void*)p);
+	queue_wakeup(&the_server.pub_queue);
+	s->cid = 0;
+	s->id = 0;
+    }
+    return Qnil;
+}
+
+/* Document-class: Agoo::Subscription
+ *
+ * The handle on a subscriptionscription used to register interest in messages
+ * published on a subscriptionject. Published messages are delivered to Javascript
+ * clients.
+ */
+void
+subscription_init(VALUE mod) {
+    subscription_class = rb_define_class_under(mod, "Subscription", rb_cObject);
+
+    rb_define_method(subscription_class, "close", subscription_close, 0);
+}