agoo 2.6.1 → 2.7.0

data/ext/agoo/page.h

@@ -30,17 +30,18 @@ typedef struct _agooGroup {
     agooDir		dirs;
 } *agooGroup;
 
-extern void		agoo_pages_init();
-extern void		agoo_pages_set_root(const char *root);
+extern int		agoo_pages_init(agooErr err);
+extern int		agoo_pages_set_root(agooErr err, const char *root);
 extern void		agoo_pages_cleanup();
 
 extern agooGroup	group_create(const char *path);
-extern void		group_add(agooGroup g, const char *dir);
+extern agooDir		group_add(agooErr err, agooGroup g, const char *dir);
 extern agooPage		group_get(agooErr err, const char *path, int plen);
 
 extern agooPage		agoo_page_create(const char *path);
 extern agooPage		agoo_page_immutable(agooErr err, const char *path, const char *content, int clen);
 extern agooPage		agoo_page_get(agooErr err, const char *path, int plen);
 extern int		mime_set(agooErr err, const char *key, const char *value);
+extern int		agoo_header_rule(agooErr err, const char *path, const char *mime, const char *key, const char *value);
 
 #endif // AGOO_PAGE_H

data/ext/agoo/queue.c

@@ -26,20 +26,21 @@
 // When head == tail the queue is full. This happens when tail catches up with head.
 // 
 
-void
-agoo_queue_init(agooQueue q, size_t qsize) {
-    agoo_queue_multi_init(q, qsize, false, false);
+int
+agoo_queue_init(agooErr err, agooQueue q, size_t qsize) {
+    return agoo_queue_multi_init(err, q, qsize, false, false);
 }
 
-void
-agoo_queue_multi_init(agooQueue q, size_t qsize, bool multi_push, bool multi_pop) {
+int
+agoo_queue_multi_init(agooErr err, agooQueue q, size_t qsize, bool multi_push, bool multi_pop) {
     if (qsize < 4) {
 	qsize = 4;
     }
-    q->q = (agooQItem*)AGOO_MALLOC(sizeof(agooQItem) * qsize);
+    if (NULL == (q->q = (agooQItem*)AGOO_CALLOC(qsize, sizeof(agooQItem)))) {
+	return AGOO_ERR_MEM(err, "Queue");
+    }
     q->end = q->q + qsize;
 
-    memset(q->q, 0, sizeof(agooQItem) * qsize);
     atomic_init(&q->head, q->q);
     atomic_init(&q->tail, q->q + 1);
     agoo_atomic_flag_init(&q->push_lock);
@@ -50,6 +51,8 @@ agoo_queue_multi_init(agooQueue q, size_t qsize, bool multi_push, bool multi_pop
     // Create when/if needed.
     q->rsock = 0;
     q->wsock = 0;
+
+    return AGOO_ERR_OK;
 }
 
 void

data/ext/agoo/queue.h

@@ -7,6 +7,7 @@
 #include <stdlib.h>
 
 #include "atomic.h"
+#include "err.h"
 
 typedef void	*agooQItem;
 
@@ -24,9 +25,9 @@ typedef struct _agooQueue {
     int			wsock;
 } *agooQueue;
 
-extern void		agoo_queue_init(agooQueue q, size_t qsize);
+extern int		agoo_queue_init(agooErr err, agooQueue q, size_t qsize);
 
-extern void		agoo_queue_multi_init(agooQueue q, size_t qsize, bool multi_push, bool multi_pop);
+extern int		agoo_queue_multi_init(agooErr err, agooQueue q, size_t qsize, bool multi_push, bool multi_pop);
 
 extern void		agoo_queue_cleanup(agooQueue q);
 extern void		agoo_queue_push(agooQueue q, agooQItem item);

data/ext/agoo/ready.c

@@ -59,7 +59,7 @@ link_create(agooErr err, int fd, void *ctx, agooHandler handler) {
     Link	link = (Link)AGOO_MALLOC(sizeof(struct _link));
 
     if (NULL == link) {
-	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a connection link.");
+	AGOO_ERR_MEM(err, "Connection Link");
     } else {
 	//DEBUG_ALLOC(mem_???, c);
 	link->next = NULL;
@@ -76,7 +76,7 @@ agoo_ready_create(agooErr err) {
     agooReady	ready = (agooReady)AGOO_MALLOC(sizeof(struct _agooReady));
 
     if (NULL == ready) {
-	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a connection manager.");
+	AGOO_ERR_MEM(err, "Connection Manager");
     } else {
 	//DEBUG_ALLOC(mem_???, c);
 	ready->links = NULL;
@@ -126,7 +126,7 @@ agoo_ready_add(agooErr		err,
 	       agooHandler	handler,
 	       void		*ctx) {
     Link	link;
-    
+
     if (NULL == (link = link_create(err, fd, ctx, handler))) {
 	return err->code;
     }
@@ -155,9 +155,9 @@ agoo_ready_add(agooErr		err,
     if (ready->pend - ready->pa <= ready->lcnt) {
 	size_t	cnt = (ready->pend - ready->pa) * 2;
 	size_t	size = cnt * sizeof(struct pollfd);
-	
+
 	if (NULL == (ready->pa = (struct pollfd*)AGOO_REALLOC(ready->pa, size))) {
-	    agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a connection pool.");
+	    AGOO_ERR_MEM(err, "Connection Pool");
 	    agoo_log_cat(&agoo_error_cat, "Out of memory.");
 	    agoo_log_close();
 	    exit(EXIT_FAILURE);
@@ -206,7 +206,7 @@ agoo_ready_go(agooErr err, agooReady ready) {
     double	now;
     Link	link;
     Link	next;
-    
+
 #if HAVE_SYS_EPOLL_H
     struct epoll_event	events[EPOLL_SIZE];
     struct epoll_event	*ep;
@@ -271,7 +271,7 @@ agoo_ready_go(agooErr err, agooReady ready) {
 #else
     struct pollfd	*pp;
     int			i;
-    
+
     // Setup the poll events.
     for (link = ready->links, pp = ready->pa; NULL != link; link = link->next, pp++) {
 	pp->fd = link->fd;
@@ -290,6 +290,7 @@ agoo_ready_go(agooErr err, agooReady ready) {
 	case AGOO_READY_NONE:
 	default:
 	    // ignore, either dead or closing
+	    link->pp = NULL;
 	    pp--;
 	    break;
 	}

data/ext/agoo/rgraphql.c

@@ -6,6 +6,7 @@
 #include <ruby.h>
 #include <ruby/thread.h>
 
+#include "debug.h"
 #include "err.h"
 #include "gqleval.h"
 #include "gqlintro.h"
@@ -90,7 +91,7 @@ eval_wrap(agooErr err, gqlDoc doc) {
 	.err = err,
 	.value = NULL,
     };
-    
+
     rb_thread_call_with_gvl(protect_eval, &eval);
 
     return eval.value;
@@ -123,7 +124,7 @@ gval_to_ruby(gqlValue value) {
 	    break;
 	case GQL_SCALAR_TIME: {
 	    time_t	secs = (time_t)(value->time / 1000000000LL);
-	    
+
 	    rval = rb_time_nano_new(secs, (long)(value->time - secs * 1000000000LL));
 	    break;
 	}
@@ -141,7 +142,7 @@ gval_to_ruby(gqlValue value) {
 	}
 	case GQL_SCALAR_LIST: {
 	    gqlLink	link;
-	    
+
 	    rval = rb_ary_new();
 	    for (link = value->members; NULL != link; link = link->next) {
 		rb_ary_push(rval, gval_to_ruby(link->value));
@@ -150,11 +151,11 @@ gval_to_ruby(gqlValue value) {
 	}
 	case GQL_SCALAR_OBJECT: {
 	    gqlLink	link;
-	    
+
 	    rval = rb_hash_new();
 	    for (link = value->members; NULL != link; link = link->next) {
 		rb_hash_aset(rval, rb_str_new_cstr(link->key), gval_to_ruby(link->value));
-		
+
 	    }
 	    break;
 	}
@@ -170,7 +171,7 @@ gval_to_ruby(gqlValue value) {
 static VALUE
 ref_to_string(gqlRef ref) {
     volatile VALUE	value;
-    
+
     if (T_STRING == rb_type((VALUE)ref)) {
 	value = (VALUE)ref;
     } else {
@@ -344,7 +345,7 @@ ref_type(gqlRef ref) {
     if (NULL != type_class_map) {
 	TypeClass	tc;
 	const char	*classname = rb_obj_classname((VALUE)ref);
-	
+
 	for (tc = type_class_map; NULL != tc->type; tc++) {
 	    if (0 == strcmp(classname, tc->classname)) {
 		type = tc->type;
@@ -383,10 +384,10 @@ resolve(agooErr err, gqlDoc doc, gqlRef target, gqlField field, gqlSel sel, gqlV
     if (NULL == sel->args) {
 	child = rb_funcall(obj, rb_intern(sel->name), 0);
     } else {
-	volatile VALUE	rargs = rb_hash_new();	
+	volatile VALUE	rargs = rb_hash_new();
 	gqlSelArg	sa;
 	gqlValue	v;
-	
+
 	for (sa = sel->args; NULL != sa; sa = sa->next) {
 	    if (NULL != sa->var) {
 		v = sa->var->value;
@@ -395,7 +396,7 @@ resolve(agooErr err, gqlDoc doc, gqlRef target, gqlField field, gqlSel sel, gqlV
 	    }
 	    if (NULL != field) {
 		gqlArg	fa;
-		
+
 		for (fa = field->args; NULL != fa; fa = fa->next) {
 		    if (0 == strcmp(sa->name, fa->name)) {
 			if (v->type != fa->type && GQL_SCALAR_VAR != v->type->scalar_kind) {
@@ -418,7 +419,7 @@ resolve(agooErr err, gqlDoc doc, gqlRef target, gqlField field, gqlSel sel, gqlV
 	gqlValue	list;
 	int		cnt;
 	int		i;
-	
+
 	rb_check_type(child, RUBY_T_ARRAY);
 	if (NULL == (list = gql_list_create(err, NULL))) {
 	    return err->code;
@@ -452,7 +453,7 @@ resolve(agooErr err, gqlDoc doc, gqlRef target, gqlField field, gqlSel sel, gqlV
 	}
     } else if (NULL == sel->sels) {
 	gqlValue	cv;
-	
+
 	if (NULL == (cv = coerce(err, (gqlRef)child, sel->type)) ||
 	    AGOO_ERR_OK != gql_object_set(err, result, key, cv)) {
 	    return err->code;
@@ -482,7 +483,7 @@ ruby_types_cb(gqlType type, void *ctx) {
 	    if (NULL != type_class_map) {
 		TypeClass	tc = &type_class_map[*(int*)ctx];
 		gqlLink		arg;
-		
+
 		tc->type = type;
 		for (arg = dir->args; NULL != arg; arg = arg->next) {
 		    if (0 == strcmp("class", arg->key)) {
@@ -498,16 +499,15 @@ ruby_types_cb(gqlType type, void *ctx) {
 static int
 build_type_class_map(agooErr err) {
     int		cnt = 0;
-    
-    free(type_class_map);
+
+    AGOO_FREE(type_class_map);
     type_class_map = NULL;
 
     gql_type_iterate(ruby_types_cb, &cnt);
 
-    if (NULL == (type_class_map = (TypeClass)malloc(sizeof(struct _typeClass) * (cnt + 1)))) {
-	return agoo_err_set(err, AGOO_ERR_MEMORY, "out of memory");
+    if (NULL == (type_class_map = (TypeClass)AGOO_CALLOC(cnt + 1, sizeof(struct _typeClass)))) {
+	return AGOO_ERR_MEM(err, "GraphQL Class map");
     }
-    memset(type_class_map, 0, sizeof(struct _typeClass) * (cnt + 1));
     cnt = 0;
     gql_type_iterate(ruby_types_cb, &cnt);
 
@@ -657,9 +657,9 @@ static VALUE
 graphql_load_file(VALUE self, VALUE path) {
     struct _agooErr	err = AGOO_ERR_INIT;
     FILE		*f;
-    size_t		len;
+    long		len;
     char		*sdl;
-    
+
     if (NULL == gql_root) {
 	rb_raise(rb_eStandardError, "GraphQL root not set. Use Agoo::GraphQL.schema.");
     }
@@ -670,10 +670,14 @@ graphql_load_file(VALUE self, VALUE path) {
     if (0 != fseek(f, 0, SEEK_END)) {
 	rb_raise(rb_eIOError, "%s", strerror(errno));
     }
-    len = ftell(f);
+    if (0 > (len = ftell(f))) {
+	rb_raise(rb_eIOError, "%s", strerror(errno));
+    }
     sdl = ALLOC_N(char, len + 1);
-    fseek(f, 0, SEEK_SET);
-    if (len != fread(sdl, 1, len, f)) {
+    if (0 != fseek(f, 0, SEEK_SET)) {
+	rb_raise(rb_eIOError, "%s", strerror(errno));
+    }
+    if (len != (long)fread(sdl, 1, len, f)) {
 	rb_raise(rb_eIOError, "%s", strerror(errno));
     } else {
 	sdl[len] = '\0';
@@ -711,7 +715,7 @@ graphql_sdl_dump(VALUE self, VALUE options) {
     VALUE		v;
     bool		with_desc = true;
     bool		all = false;
-    
+
     Check_Type(options, T_HASH);
 
     v = rb_hash_aref(options, ID2SYM(rb_intern("with_descriptions")));
@@ -726,7 +730,7 @@ graphql_sdl_dump(VALUE self, VALUE options) {
 
     dump = rb_str_new(t->text, t->len);
     agoo_text_release(t);
-    
+
     return dump;
 }
 

data/ext/agoo/rlog.c

@@ -468,8 +468,8 @@ rlog_init(VALUE mod) {
 
     agoo_log.on_error = on_error;
     
-    agoo_log_init("agoo");
-    if (AGOO_ERR_OK != agoo_log_start(&err, false)) {
+    if (AGOO_ERR_OK != agoo_log_init(&err, "agoo") ||
+	AGOO_ERR_OK != agoo_log_start(&err, false)) {
 	rb_raise(rb_eStandardError, "%s", err.msg);
     }
 }

data/ext/agoo/rresponse.c

@@ -28,6 +28,9 @@ VALUE
 response_new() {
     agooResponse	res = (agooResponse)AGOO_MALLOC(sizeof(struct _agooResponse));
 
+    if (NULL == res) {
+	return Qnil;
+    }
     memset(res, 0, sizeof(struct _agooResponse));
     res->code = 200;
     
@@ -46,6 +49,9 @@ to_s(VALUE self) {
     int			len = agoo_response_len(res);
     char		*s = (char*)AGOO_MALLOC(len + 1);
 
+    if (NULL == s) {
+	rb_raise(rb_eNoMemError, "out of memory");
+    }
     agoo_response_fill(res, s);
     
     return rb_str_new(s, len);

data/ext/agoo/rserver.c

@@ -4,6 +4,7 @@
 #include <netinet/tcp.h>
 #include <signal.h>
 #include <stdio.h>
+#include <string.h>
 #include <sys/wait.h>
 
 #include <ruby.h>
@@ -93,7 +94,9 @@ url_bind(VALUE rurl) {
 
 static int
 configure(agooErr err, int port, const char *root, VALUE options) {
-    agoo_pages_set_root(root);
+    if (AGOO_ERR_OK != agoo_pages_set_root(err, root)) {
+	return err->code;
+    }
     agoo_server.thread_cnt = 0;
     the_rserver.worker_cnt = 1;
     atomic_init(&agoo_server.running, 0);
@@ -236,9 +239,10 @@ configure(agooErr err, int port, const char *root, VALUE options) {
  * call-seq: init(port, root, options)
  *
  * Configures the server that will listen on the designated _port_ and using
- * the _root_ as the root of the static resources. Logging is feature based
- * and not level based and the options reflect that approach. If bind option
- * is to be used instead of the port then set the port to zero.
+ * the _root_ as the root of the static resources. This must be called before
+ * using other server methods. Logging is feature based and not level based
+ * and the options reflect that approach. If bind option is to be used instead
+ * of the port then set the port to zero.
  *
  * - *options* [_Hash_] server options
  *
@@ -268,7 +272,9 @@ rserver_init(int argc, VALUE *argv, VALUE self) {
     if (3 <= argc) {
 	options = argv[2];
     }
-    agoo_server_setup();
+    if (AGOO_ERR_OK != agoo_server_setup(&err)) {
+	rb_raise(rb_eStandardError, "%s", err.msg);
+    }
     agoo_server.ctx_nil_value = (void*)Qnil;
     agoo_server.env_nil_value = (void*)Qnil;
 
@@ -762,7 +768,7 @@ rserver_start(VALUE self) {
 	agooReq	req;
 
 	while (agoo_server.active) {
-	    if (NULL != (req = (agooReq)agoo_queue_pop(&agoo_server.eval_queue, 0.01))) { // TBD 0.1
+	    if (NULL != (req = (agooReq)agoo_queue_pop(&agoo_server.eval_queue, 0.1))) {
 		handle_protected(req, false);
 		agoo_req_destroy(req);
 	    } else {
@@ -998,7 +1004,8 @@ add_mime(VALUE self, VALUE suffix, VALUE type) {
  */
 static VALUE
 path_group(VALUE self, VALUE path, VALUE dirs) {
-    agooGroup	g;
+    struct _agooErr	err = AGOO_ERR_INIT;
+    agooGroup		g;
 
     rb_check_type(path, T_STRING);
     rb_check_type(dirs, T_ARRAY);
@@ -1013,12 +1020,45 @@ path_group(VALUE self, VALUE path, VALUE dirs) {
 	    if (T_STRING != rb_type(entry)) {
 		entry = rb_funcall(entry, rb_intern("to_s"), 0);
 	    }
-	    group_add(g, StringValuePtr(entry));
+	    if (NULL == group_add(&err, g, StringValuePtr(entry))) {
+		rb_raise(rb_eStandardError, "%s", err.msg);
+	    }
 	}
     }
     return Qnil;
 }
 
+/* Document-method: header_rule
+ *
+ * call-seq: header_rule(path, mime, key, value)
+ *
+ * Add a header rule. A header rule will add the key and value to the headers
+ * of any static asset that matches the path and mime type specified. The path
+ * pattern follows glob like rules in that a single * matches a single token
+ * bounded by the `/` character and a double ** matches all remaining. The
+ * mime can also be a * which matches all types. The mime argument will be
+ * compared to the mine type as well as the file extension so
+ * 'applicaiton/json', a mime type can be used as can 'json' as a file
+ * extension. All rules that match add the header key and value to the header
+ * of a static asset.
+ *
+ * Note that the server must be initialized before calling this method.
+ */
+static VALUE
+header_rule(VALUE self, VALUE path, VALUE mime, VALUE key, VALUE value) {
+    struct _agooErr	err = AGOO_ERR_INIT;
+    
+    rb_check_type(path, T_STRING);
+    rb_check_type(mime, T_STRING);
+    rb_check_type(key, T_STRING);
+    rb_check_type(value, T_STRING);
+
+    if (AGOO_ERR_OK != agoo_header_rule(&err, StringValuePtr(path), StringValuePtr(mime), StringValuePtr(key), StringValuePtr(value))) {
+	rb_raise(rb_eArgError, "%s", err.msg);
+    }
+    return Qnil;
+}
+
 /* Document-class: Agoo::Server
  *
  * An HTTP server that support the rack API as well as some other optimized
@@ -1036,6 +1076,7 @@ server_init(VALUE mod) {
     rb_define_module_function(server_mod, "handle_not_found", handle_not_found, 1);
     rb_define_module_function(server_mod, "add_mime", add_mime, 2);
     rb_define_module_function(server_mod, "path_group", path_group, 2);
+    rb_define_module_function(server_mod, "header_rule", header_rule, 4);
 
     call_id = rb_intern("call");
     each_id = rb_intern("each");