agoo 2.5.5 → 2.5.6

data/ext/agoo/websocket.c

@@ -24,13 +24,13 @@ static const char	ws_accept[] = "Sec-WebSocket-Accept: ";
 
 //static const uint8_t	close_msg[] = "\x88\x02\x03\xE8";
 
-Text
-ws_add_headers(Req req, Text t) {
+agooText
+agoo_ws_add_headers(agooReq req, agooText t) {
     int		klen = 0;
     const char	*key;
     
-    t = text_append(t, up_con, sizeof(up_con) - 1);
-    if (NULL != (key = con_header_value(req->header.start, req->header.len, "Sec-WebSocket-Key", &klen)) &&
+    t = agoo_text_append(t, up_con, sizeof(up_con) - 1);
+    if (NULL != (key = agoo_con_header_value(req->header.start, req->header.len, "Sec-WebSocket-Key", &klen)) &&
 	klen + sizeof(ws_magic) < MAX_KEY_LEN) {
 	char		buf[MAX_KEY_LEN];
 	unsigned char	sha[32];
@@ -41,23 +41,23 @@ ws_add_headers(Req req, Text t) {
 	sha1((unsigned char*)buf, len, sha);
 	len = b64_to(sha, SHA1_DIGEST_SIZE, buf);
 
-	t = text_append(t, ws_accept, sizeof(ws_accept) - 1);
-	t = text_append(t, buf, len);
-	t = text_append(t, "\r\n", 2);
+	t = agoo_text_append(t, ws_accept, sizeof(ws_accept) - 1);
+	t = agoo_text_append(t, buf, len);
+	t = agoo_text_append(t, "\r\n", 2);
     }
-    if (NULL != (key = con_header_value(req->header.start, req->header.len, "Sec-WebSocket-Protocol", &klen))) {
-	t = text_append(t, ws_protocol, sizeof(ws_protocol) - 1);
-	t = text_append(t, key, klen);
-	t = text_append(t, "\r\n", 2);
+    if (NULL != (key = agoo_con_header_value(req->header.start, req->header.len, "Sec-WebSocket-Protocol", &klen))) {
+	t = agoo_text_append(t, ws_protocol, sizeof(ws_protocol) - 1);
+	t = agoo_text_append(t, key, klen);
+	t = agoo_text_append(t, "\r\n", 2);
     }
     return t;
 }
 
-Text
-ws_expand(Text t) {
+agooText
+agoo_ws_expand(agooText t) {
     uint8_t	buf[16];
     uint8_t	*b = buf;
-    uint8_t	opcode = t->bin ? WS_OP_BIN : WS_OP_TEXT;
+    uint8_t	opcode = t->bin ? AGOO_WS_OP_BIN : AGOO_WS_OP_TEXT;
 
     *b++ = 0x80 | (uint8_t)opcode;
     // send unmasked
@@ -75,11 +75,11 @@ ws_expand(Text t) {
 	    *b++ = (uint8_t)((t->len >> i) & 0xFF);
 	}
     }
-    return text_prepend(t, (const char*)buf, (int)(b - buf));
+    return agoo_text_prepend(t, (const char*)buf, (int)(b - buf));
 }
 
 size_t
-ws_decode(char *buf, size_t mlen) {
+agoo_ws_decode(char *buf, size_t mlen) {
     uint8_t	*b = (uint8_t*)buf;
     bool	is_masked;
     uint8_t	*payload;
@@ -125,13 +125,13 @@ ws_decode(char *buf, size_t mlen) {
 
 // if -1 then err, 0 not ready yet, positive is completed length
 long
-ws_calc_len(Con c, uint8_t *buf, size_t cnt) {
+agoo_ws_calc_len(agooCon c, uint8_t *buf, size_t cnt) {
     uint8_t	*b = buf;
     bool	is_masked;
     uint64_t	plen;
 
     if (0 == (0x80 & *b)) {
-	log_cat(&error_cat, "FIN must be 1. Websocket continuation not implemented on connection %llu.", (unsigned long long)c->id);
+	agoo_log_cat(&agoo_error_cat, "FIN must be 1. Websocket continuation not implemented on connection %llu.", (unsigned long long)c->id);
 	return -1;
     }
     b++;
@@ -165,17 +165,17 @@ ws_calc_len(Con c, uint8_t *buf, size_t cnt) {
 
 // Return true on error otherwise false.
 bool
-ws_create_req(Con c, long mlen) {
+agoo_ws_create_req(agooCon c, long mlen) {
     uint8_t	op = 0x0F & *c->buf;
     
-    if (NULL == (c->req = req_create(mlen))) {
-	log_cat(&error_cat, "Out of memory attempting to allocate request.");
+    if (NULL == (c->req = agoo_req_create(mlen))) {
+	agoo_log_cat(&agoo_error_cat, "Out of memory attempting to allocate request.");
 	return true;
     }
-    if (NULL == c->up || the_server.ctx_nil_value == c->up->ctx) {
+    if (NULL == c->up || agoo_server.ctx_nil_value == c->up->ctx) {
 	return true;
     }
-    memset(c->req, 0, sizeof(struct _Req));
+    memset(c->req, 0, sizeof(struct _agooReq));
     if ((long)c->bcnt <= mlen) {
 	memcpy(c->req->msg, c->buf, c->bcnt);
 	if ((long)c->bcnt < mlen) {
@@ -186,35 +186,35 @@ ws_create_req(Con c, long mlen) {
     }
     c->req->msg[mlen] = '\0';
     c->req->mlen = mlen;
-    c->req->method = (WS_OP_BIN == op) ? ON_BIN : ON_MSG;
-    c->req->upgrade = UP_NONE;
+    c->req->method = (AGOO_WS_OP_BIN == op) ? AGOO_ON_BIN : AGOO_ON_MSG;
+    c->req->upgrade = AGOO_UP_NONE;
     c->req->up = c->up;
     c->req->res = NULL;
     if (c->up->on_msg) {
-	c->req->hook = hook_create(NONE, NULL, c->up->ctx, PUSH_HOOK, &the_server.eval_queue);
+	c->req->hook = agoo_hook_create(AGOO_NONE, NULL, c->up->ctx, PUSH_HOOK, &agoo_server.eval_queue);
     }
     return false;
 }
 
 void
-ws_req_close(Con c) {
-    if (NULL != c->up && the_server.ctx_nil_value != c->up->ctx && c->up->on_close) {
-	Req	req = req_create(0);
+agoo_ws_req_close(agooCon c) {
+    if (NULL != c->up && agoo_server.ctx_nil_value != c->up->ctx && c->up->on_close) {
+	agooReq	req = agoo_req_create(0);
 	    
 	req->up = c->up;
-	req->method = ON_CLOSE;
-	req->hook = hook_create(NONE, NULL, c->up->ctx, PUSH_HOOK, &the_server.eval_queue);
+	req->method = AGOO_ON_CLOSE;
+	req->hook = agoo_hook_create(AGOO_NONE, NULL, c->up->ctx, PUSH_HOOK, &agoo_server.eval_queue);
 	atomic_fetch_add(&c->up->ref_cnt, 1);
-	queue_push(&the_server.eval_queue, (void*)req);
+	agoo_queue_push(&agoo_server.eval_queue, (void*)req);
     }
 }
 
 void
-ws_ping(Con c) {
-    Res	res;
+agoo_ws_ping(agooCon c) {
+    agooRes	res;
     
-    if (NULL == (res = res_create(c))) {
-	log_cat(&error_cat, "Memory allocation of response failed on connection %llu.", (unsigned long long)c->id);
+    if (NULL == (res = agoo_res_create(c))) {
+	agoo_log_cat(&agoo_error_cat, "Memory allocation of response failed on connection %llu.", (unsigned long long)c->id);
     } else {
 	if (NULL == c->res_tail) {
 	    c->res_head = res;
@@ -223,17 +223,17 @@ ws_ping(Con c) {
 	}
 	c->res_tail = res;
 	res->close = false;
-	res->con_kind = CON_WS;
+	res->con_kind = AGOO_CON_WS;
 	res->ping = true;
     }
 }
 
 void
-ws_pong(Con c) {
-    Res	res;
+agoo_ws_pong(agooCon c) {
+    agooRes	res;
     
-    if (NULL == (res = res_create(c))) {
-	log_cat(&error_cat, "Memory allocation of response failed on connection %llu.", (unsigned long long)c->id);
+    if (NULL == (res = agoo_res_create(c))) {
+	agoo_log_cat(&agoo_error_cat, "Memory allocation of response failed on connection %llu.", (unsigned long long)c->id);
     } else {
 	if (NULL == c->res_tail) {
 	    c->res_head = res;
@@ -242,7 +242,7 @@ ws_pong(Con c) {
 	}
 	c->res_tail = res;
 	res->close = false;
-	res->con_kind = CON_WS;
+	res->con_kind = AGOO_CON_WS;
 	res->pong = true;
     }
 }

data/ext/agoo/websocket.h

@@ -3,25 +3,25 @@
 #ifndef AGOO_WEBSOCKET_H
 #define AGOO_WEBSOCKET_H
 
-#define WS_OP_CONT	0x00
-#define WS_OP_TEXT	0x01
-#define WS_OP_BIN	0x02
-#define WS_OP_CLOSE	0x08
-#define WS_OP_PING	0x09
-#define WS_OP_PONG	0x0A
+#define AGOO_WS_OP_CONT		0x00
+#define AGOO_WS_OP_TEXT		0x01
+#define AGOO_WS_OP_BIN		0x02
+#define AGOO_WS_OP_CLOSE	0x08
+#define AGOO_WS_OP_PING		0x09
+#define AGOO_WS_OP_PONG		0x0A
 
-struct _Req;
-struct _Text;
+struct _agooReq;
+struct _agooText;
 
-extern struct _Text*	ws_add_headers(struct _Req *req, struct _Text *t);
-extern Text		ws_expand(Text t);
-extern size_t		ws_decode(char *buf, size_t mlen);
+extern struct _agooText*	agoo_ws_add_headers(struct _agooReq *req, struct _agooText *t);
+extern struct _agooText*	agoo_ws_expand(agooText t);
+extern size_t			agoo_ws_decode(char *buf, size_t mlen);
 
-extern long		ws_calc_len(Con c, uint8_t *buf, size_t cnt);
-extern bool		ws_create_req(Con c, long mlen);
-extern void		ws_req_close(Con c);
+extern long			agoo_ws_calc_len(agooCon c, uint8_t *buf, size_t cnt);
+extern bool			agoo_ws_create_req(agooCon c, long mlen);
+extern void			agoo_ws_req_close(agooCon c);
 
-extern void		ws_ping(Con c);
-extern void		ws_pong(Con c);
+extern void			agoo_ws_ping(agooCon c);
+extern void			agoo_ws_pong(agooCon c);
 
 #endif // AGOO_WEBSOCKET_H

data/lib/agoo/version.rb

@@ -1,5 +1,5 @@
 
 module Agoo
   # Agoo version.
-  VERSION = '2.5.5'
+  VERSION = '2.5.6'
 end

data/test/static_test.rb

@@ -34,10 +34,12 @@ class StaticTest < Minitest::Test
       Agoo::Server.add_mime('odd', 'text/odd')
       Agoo::Server.start()
       fetch_index_test
+=begin
       mime_test
       fetch_auto_index_test
       fetch_nested_test
       fetch_not_found_test
+=end
     ensure
       Agoo::shutdown
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: agoo
 version: !ruby/object:Gem::Version
-  version: 2.5.5
+  version: 2.5.6
 platform: ruby
 authors:
 - Peter Ohler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-12 00:00:00.000000000 Z
+date: 2018-11-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oj
@@ -46,6 +46,7 @@ files:
 - README.md
 - bin/agoo
 - ext/agoo/agoo.c
+- ext/agoo/atomic.h
 - ext/agoo/base64.c
 - ext/agoo/base64.h
 - ext/agoo/bind.c
@@ -76,7 +77,6 @@ files:
 - ext/agoo/kinds.h
 - ext/agoo/log.c
 - ext/agoo/log.h
-- ext/agoo/log_queue.h
 - ext/agoo/method.h
 - ext/agoo/page.c
 - ext/agoo/page.h
@@ -86,6 +86,8 @@ files:
 - ext/agoo/queue.h
 - ext/agoo/rack_logger.c
 - ext/agoo/rack_logger.h
+- ext/agoo/ready.c
+- ext/agoo/ready.h
 - ext/agoo/req.c
 - ext/agoo/req.h
 - ext/agoo/request.c
@@ -113,8 +115,6 @@ files:
 - ext/agoo/sha1.h
 - ext/agoo/sse.c
 - ext/agoo/sse.h
-- ext/agoo/sub.c
-- ext/agoo/sub.h
 - ext/agoo/subject.c
 - ext/agoo/subject.h
 - ext/agoo/text.c

data/ext/agoo/log_queue.h

@@ -1,30 +0,0 @@
-// Copyright 2018 by Peter Ohler, All Rights Reserved
-
-#ifndef AGOO_LOG_QUEUE_H
-#define AGOO_LOG_QUEUE_H
-
-#include <stdatomic.h>
-#include <stdbool.h>
-
-#include "val.h"
-
-typedef struct _LogQueue {
-    opoMsg		*q;
-    opoMsg		*end;
-    _Atomic(opoMsg*)	head;
-    _Atomic(opoMsg*)	tail;
-    atomic_flag		pop_lock; // set to true when ppo in progress
-    atomic_int		wait_state;
-    int			rsock;
-    int			wsock;
-} *LogQueue;
-
-extern void	queue_init(Queue q, size_t qsize);
-
-extern void	queue_cleanup(Queue q);
-extern void	queue_push(Queue q, opoMsg item);
-extern opoMsg	queue_pop(Queue q, double timeout);
-extern bool	queue_empty(Queue q);
-extern int	queue_count(Queue q);
-
-#endif /* AGOO_LOG_QUEUE_H */

data/ext/agoo/sub.c

@@ -1,111 +0,0 @@
-// 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

@@ -1,36 +0,0 @@
-// 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