agoo 2.5.5 → 2.5.6

data/ext/agoo/graphql.h

@@ -21,13 +21,14 @@ typedef enum {
     // NON_NULL
 } gqlKind;
 
-struct _gqlType;
-struct _gqlValue;
-struct _gqlLink;
-struct _gqlField;
-struct _Req;
+struct _agooCon;
+struct _agooReq;
 struct _gqlDirUse;
+struct _gqlField;
+struct _gqlLink;
 struct _gqlLink;
+struct _gqlType;
+struct _gqlValue;
 
 // Used for references to implemenation entities.
 typedef void*	gqlRef;
@@ -106,7 +107,7 @@ typedef struct _gqlDirUse {
 typedef struct _gqlType {
     const char	*name;
     const char	*desc;
-    Text	(*to_json)(Text text, struct _gqlValue *value, int indent, int depth);
+    agooText	(*to_json)(agooText text, struct _gqlValue *value, int indent, int depth);
     gqlDirUse	dir;
     gqlKind	kind;
     bool	locked; // set by app
@@ -123,21 +124,21 @@ typedef struct _gqlType {
 	gqlStrLink		choices;      // Enums
 	// Returns error code. Only for scalars.
 	struct {
-	    int			(*coerce)(Err err, struct _gqlValue *src, struct _gqlType *type);
+	    int			(*coerce)(agooErr err, struct _gqlValue *src, struct _gqlType *type);
 	    void		(*destroy)(struct _gqlValue *value);
 	};
     };
 } *gqlType;
 
-extern int	gql_init(Err err);
+extern int	gql_init(agooErr err);
 extern void	gql_destroy(); // clear out all
 
-extern gqlType	gql_type_create(Err err, const char *name, const char *desc, int dlen, bool locked, gqlType *interfaces);
-extern gqlType	gql_fragment_create(Err err, const char *name, const char *desc, int dlen, bool locked, gqlType on);
-extern gqlType	gql_input_create(Err err, const char *name, const char *desc, int dlen, bool locked);
-extern gqlType	gql_interface_create(Err err, const char *name, const char *desc, int dlen, bool locked);
+extern gqlType	gql_type_create(agooErr err, const char *name, const char *desc, int dlen, bool locked, gqlType *interfaces);
+extern gqlType	gql_fragment_create(agooErr err, const char *name, const char *desc, int dlen, bool locked, gqlType on);
+extern gqlType	gql_input_create(agooErr err, const char *name, const char *desc, int dlen, bool locked);
+extern gqlType	gql_interface_create(agooErr err, const char *name, const char *desc, int dlen, bool locked);
 
-extern gqlField	gql_type_field(Err		err,
+extern gqlField	gql_type_field(agooErr		err,
 			       gqlType		type,
 			       const char	*name,
 			       gqlType		return_type,
@@ -147,7 +148,7 @@ extern gqlField	gql_type_field(Err		err,
 			       bool 		not_empty,
 			       gqlResolveFunc	resolve);
 
-extern gqlArg	gql_field_arg(Err 		err,
+extern gqlArg	gql_field_arg(agooErr 		err,
 			      gqlField 		field,
 			      const char 	*name,
 			      gqlType 		type,
@@ -158,11 +159,11 @@ extern gqlArg	gql_field_arg(Err 		err,
 // TBD maybe create then add fields
 // TBD same with op? create then add args
 
-extern gqlType	gql_scalar_create(Err err, const char *name, const char *desc, int dlen, bool locked);
+extern gqlType	gql_scalar_create(agooErr err, const char *name, const char *desc, int dlen, bool locked);
 
-extern gqlDir	gql_directive_create(Err err, const char *name, const char *desc, int dlen, bool locked);
-extern int	gql_directive_on(Err err, gqlDir d, const char *on, int len);
-extern gqlArg	gql_dir_arg(Err 		err,
+extern gqlDir	gql_directive_create(agooErr err, const char *name, const char *desc, int dlen, bool locked);
+extern int	gql_directive_on(agooErr err, gqlDir d, const char *on, int len);
+extern gqlArg	gql_dir_arg(agooErr 		err,
 			    gqlDir 		dir,
 			    const char 		*name,
 			    const char 		*type_name,
@@ -172,27 +173,27 @@ extern gqlArg	gql_dir_arg(Err 		err,
 			    bool 		required);
 extern gqlDir	gql_directive_get(const char *name);
 
-extern gqlType	gql_union_create(Err err, const char *name, const char *desc, int dlen, bool locked);
-extern int	gql_union_add(Err err, gqlType type, const char *name, int len);
+extern gqlType	gql_union_create(agooErr err, const char *name, const char *desc, int dlen, bool locked);
+extern int	gql_union_add(agooErr err, gqlType type, const char *name, int len);
 
-extern gqlType	gql_enum_create(Err err, const char *name, const char *desc, int dlen, bool locked);
-extern int	gql_enum_add(Err err, gqlType type, const char *value, int len);
-extern int	gql_enum_append(Err err, gqlType type, const char *value, int len);
+extern gqlType	gql_enum_create(agooErr err, const char *name, const char *desc, int dlen, bool locked);
+extern int	gql_enum_add(agooErr err, gqlType type, const char *value, int len);
+extern int	gql_enum_append(agooErr err, gqlType type, const char *value, int len);
 
-extern int	gql_type_set(Err err, gqlType type);
+extern int	gql_type_set(agooErr err, gqlType type);
 extern gqlType	gql_type_get(const char *name);
 extern void	gql_type_destroy(gqlType type);
 
-extern Text	gql_type_sdl(Text text, gqlType type, bool comments);
-extern Text	gql_directive_sdl(Text text, gqlDir dir, bool comments);
-extern Text	gql_schema_sdl(Text text, bool with_desc, bool all);
+extern agooText	gql_type_sdl(agooText text, gqlType type, bool comments);
+extern agooText	gql_directive_sdl(agooText text, gqlDir dir, bool comments);
+extern agooText	gql_schema_sdl(agooText text, bool with_desc, bool all);
 
-extern Text	gql_object_to_json(Text text, struct _gqlValue *value, int indent, int depth);
-extern Text	gql_object_to_graphql(Text text, struct _gqlValue *value, int indent, int depth);
-extern Text	gql_union_to_text(Text text, struct _gqlValue *value, int indent, int depth);
-extern Text	gql_enum_to_text(Text text, struct _gqlValue *value, int indent, int depth);
+extern agooText	gql_object_to_json(agooText text, struct _gqlValue *value, int indent, int depth);
+extern agooText	gql_object_to_graphql(agooText text, struct _gqlValue *value, int indent, int depth);
+extern agooText	gql_union_to_text(agooText text, struct _gqlValue *value, int indent, int depth);
+extern agooText	gql_enum_to_text(agooText text, struct _gqlValue *value, int indent, int depth);
 
-extern void	gql_dump_hook(struct _Req *req);
-extern void	gql_eval_hook(struct _Req *req);
+extern void	gql_dump_hook(struct _agooReq *req);
+extern void	gql_eval_hook(struct _agooReq *req);
 
 #endif // AGOO_GRAPHQL_H

data/ext/agoo/hook.c

@@ -3,20 +3,21 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include "con.h"
 #include "debug.h"
 #include "hook.h"
 #include "req.h"
 
-Hook
-hook_create(Method method, const char *pattern, void *handler, HookType type, Queue q) {
-    Hook	hook = (Hook)malloc(sizeof(struct _Hook));
+agooHook
+agoo_hook_create(agooMethod method, const char *pattern, void *handler, agooHookType type, agooQueue q) {
+    agooHook	hook = (agooHook)malloc(sizeof(struct _agooHook));
 
     if (NULL != hook) {
 	char	*pat = NULL;
 	
 	DEBUG_ALLOC(mem_hook, hook);
 	if (NULL == pattern) {
-	    if (NONE != method) {
+	    if (AGOO_NONE != method) {
 		pat = strdup("");
 	    }
 	} else {
@@ -35,16 +36,16 @@ hook_create(Method method, const char *pattern, void *handler, HookType type, Qu
     return hook;
 }
 
-Hook
-hook_func_create(Method method, const char *pattern, void (*func)(Req req), Queue q) {
-    Hook	hook = (Hook)malloc(sizeof(struct _Hook));
+agooHook
+agoo_hook_func_create(agooMethod method, const char *pattern, void (*func)(agooReq req), agooQueue q) {
+    agooHook	hook = (agooHook)malloc(sizeof(struct _agooHook));
 
     if (NULL != hook) {
 	char	*pat = NULL;
 	
 	DEBUG_ALLOC(mem_hook, hook);
 	if (NULL == pattern) {
-	    if (NONE != method) {
+	    if (AGOO_NONE != method) {
 		pat = strdup("");
 	    }
 	} else {
@@ -64,7 +65,7 @@ hook_func_create(Method method, const char *pattern, void (*func)(Req req), Queu
 }
 
 void
-hook_destroy(Hook hook) {
+agoo_hook_destroy(agooHook hook) {
     if (NULL != hook->pattern) {
 	DEBUG_FREE(mem_hook_pattern, hook->pattern);
 	free(hook->pattern);
@@ -74,7 +75,7 @@ hook_destroy(Hook hook) {
 }
 
 bool
-hook_match(Hook hook, Method method, const Seg path) {
+agoo_hook_match(agooHook hook, agooMethod method, const agooSeg path) {
     const char	*pat = hook->pattern;
     char	*p = path->start;
     char	*end = path->end;
@@ -82,7 +83,7 @@ hook_match(Hook hook, Method method, const Seg path) {
     if (1 < end - p && '/' == *(end - 1)) {
 	end--;
     }
-    if (method != hook->method && ALL != hook->method) {
+    if (method != hook->method && AGOO_ALL != hook->method) {
 	return false;
     }
     for (; '\0' != *pat && p < end; pat++) {
@@ -101,10 +102,10 @@ hook_match(Hook hook, Method method, const Seg path) {
     return '\0' == *pat && p == end;
 }
 
-Hook
-hook_find(Hook hook, Method method, const Seg path) {
+agooHook
+agoo_hook_find(agooHook hook, agooMethod method, const agooSeg path) {
     for (; NULL != hook; hook = hook->next) {
-	if (hook_match(hook, method, path)) {
+	if (agoo_hook_match(hook, method, path)) {
 	    return hook;
 	}
     }

data/ext/agoo/hook.h

@@ -9,7 +9,8 @@
 #include "queue.h"
 #include "seg.h"
 
-struct _Req;
+struct _agooCon;
+struct _agooReq;
 
 typedef enum {
     NO_HOOK		= '\0',
@@ -19,26 +20,29 @@ typedef enum {
     PUSH_HOOK		= 'P',
     FUNC_HOOK		= 'F',
     FAST_HOOK		= 'O', // for OpO
-} HookType;
+} agooHookType;
 
-typedef struct _Hook {
-    struct _Hook	*next;
-    Method		method;
+typedef struct _agooHook {
+    struct _agooHook	*next;
+    agooMethod		method;
     char		*pattern;
-    HookType		type;
+    agooHookType	type;
     union {
 	void		*handler;
-	void		(*func)(struct _Req *req);
+	void		(*func)(struct _agooReq *req);
     };
-    Queue		queue;
+    agooQueue		queue;
     bool		no_queue;
-} *Hook;
+} *agooHook;
 
-extern Hook	hook_create(Method method, const char *pattern, void *handler, HookType type, Queue q);
-extern Hook	hook_func_create(Method method, const char *pattern, void (*func)(struct _Req *req), Queue q);
-extern void	hook_destroy(Hook hook);
+extern agooHook	agoo_hook_create(agooMethod method, const char *pattern, void *handler, agooHookType type, agooQueue q);
+extern agooHook	agoo_hook_func_create(agooMethod	method,
+				      const char	*pattern,
+				      void 		(*func)(struct _agooReq *req),
+				      agooQueue		q);
+extern void	agoo_hook_destroy(agooHook hook);
 
-extern bool	hook_match(Hook hook, Method method, const Seg seg);
-extern Hook	hook_find(Hook hook, Method method, const Seg seg);
+extern bool	agoo_hook_match(agooHook hook, agooMethod method, const agooSeg seg);
+extern agooHook	agoo_hook_find(agooHook hook, agooMethod method, const agooSeg seg);
 
 #endif // AGOO_HOOK_H

data/ext/agoo/http.c

@@ -11,18 +11,18 @@
 #define BUCKET_MASK	1023
 #define MAX_KEY_UNIQ	9
 
-typedef struct _Slot {
-    struct _Slot	*next;
+typedef struct _slot {
+    struct _slot	*next;
     const char		*key;
     uint64_t		hash;
     int			klen;
 } *Slot;
 
-typedef struct _Cache {
+typedef struct _cache {
     Slot		buckets[BUCKET_SIZE];
 } *Cache;
 
-struct _Cache		key_cache;
+struct _cache		key_cache;
 
 // The rack spec indicates the characters (),/:;<=>?@[]{} are invalid which
 // clearly is not consisten with RFC7230 so stick with the RFC.
@@ -469,7 +469,7 @@ key_set(const char *key) {
     Slot	*bucket = get_bucketp(h);
     Slot	s;
     
-    if (NULL != (s = (Slot)malloc(sizeof(struct _Slot)))) {
+    if (NULL != (s = (Slot)malloc(sizeof(struct _slot)))) {
 	DEBUG_ALLOC(mem_http_slot, s)
 	s->hash = h;
 	s->klen = len;
@@ -480,17 +480,17 @@ key_set(const char *key) {
 }
 
 void
-http_init() {
+agoo_http_init() {
     const char	**kp = header_keys;
     
-    memset(&key_cache, 0, sizeof(struct _Cache));
+    memset(&key_cache, 0, sizeof(struct _cache));
     for (; NULL != *kp; kp++) {
 	key_set(*kp);
     }
 }
 
 void
-http_cleanup() {
+agoo_http_cleanup() {
     Slot	*sp = key_cache.buckets;
     Slot	s;
     Slot	n;
@@ -507,7 +507,7 @@ http_cleanup() {
 }
 
 int
-http_header_ok(Err err, const char *key, int klen, const char *value, int vlen) {
+agoo_http_header_ok(agooErr err, const char *key, int klen, const char *value, int vlen) {
     int		len = klen;
     int64_t	h = calc_hash(key, &len);
     Slot	*bucket = get_bucketp(h);
@@ -530,26 +530,26 @@ http_header_ok(Err err, const char *key, int klen, const char *value, int vlen)
 	strncpy(buf, key, klen);
 	buf[klen] = '\0';
 
-	return err_set(err, ERR_ARG, "%s is not a valid HTTP header key.", buf);
+	return agoo_err_set(err, AGOO_ERR_ARG, "%s is not a valid HTTP header key.", buf);
     }
     // Now check the value.
     found = false; // reuse as indicator for in a quoted string
     for (; 0 < vlen; vlen--, value++) {
 	if ('o' != header_value_chars[(uint8_t)*value]) {
-	    return err_set(err, ERR_ARG, "%02x is not a valid HTTP header value character.", *value);
+	    return agoo_err_set(err, AGOO_ERR_ARG, "%02x is not a valid HTTP header value character.", *value);
 	}
 	if ('"' == *value) {
 	    found = !found;
 	}
     }
     if (found) {
-	return err_set(err, ERR_ARG, "HTTP header has unmatched quote.");
+	return agoo_err_set(err, AGOO_ERR_ARG, "HTTP header has unmatched quote.");
     }
-    return ERR_OK;
+    return AGOO_ERR_OK;
 }
 
 const char*
-http_code_message(int code) {
+agoo_http_code_message(int code) {
     const char	*msg = "";
     
     switch (code) {

data/ext/agoo/http.h

@@ -7,11 +7,11 @@
 
 #include "err.h"
 
-extern void		http_init();
-extern void		http_cleanup();
+extern void		agoo_http_init();
+extern void		agoo_http_cleanup();
 
-extern int		http_header_ok(Err err, const char *key, int klen, const char *value, int vlen);
+extern int		agoo_http_header_ok(agooErr err, const char *key, int klen, const char *value, int vlen);
 
-extern const char*	http_code_message(int code);
+extern const char*	agoo_http_code_message(int code);
 
 #endif // AGOO_HTTP_H

data/ext/agoo/kinds.h

@@ -4,10 +4,10 @@
 #define AGOO_KINDS_H
 
 typedef enum {
-    CON_ANY	= '\0',
-    CON_HTTP	= 'H',
-    CON_WS	= 'W',
-    CON_SSE	= 'S',
-} ConKind;
+    AGOO_CON_ANY	= '\0',
+    AGOO_CON_HTTP	= 'H',
+    AGOO_CON_WS		= 'W',
+    AGOO_CON_SSE	= 'S',
+} agooConKind;
 
 #endif // AGOO_KINDS_H

data/ext/agoo/log.c

@@ -25,7 +25,7 @@
 #define RESET_COLOR	"\033[0m"
 #define RESET_SIZE	4
 
-static struct _Color	colors[] = {
+static struct _agooColor	colors[] = {
     { .name = "black",      .ansi = "\033[30;1m" },
     { .name = "red",        .ansi = "\033[31;1m" },
     { .name = "green",      .ansi = "\033[32;1m" },
@@ -46,22 +46,22 @@ static struct _Color	colors[] = {
 
 static const char	level_chars[] = { 'F', 'E', 'W', 'I', 'D', '?' };
 
-struct _Log	the_log = {NULL};
-struct _LogCat	fatal_cat;
-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 _LogCat	push_cat;
-
-Color
+struct _agooLog	agoo_log = {NULL};
+struct _agooLogCat	agoo_fatal_cat;
+struct _agooLogCat	agoo_error_cat;
+struct _agooLogCat	agoo_warn_cat;
+struct _agooLogCat	agoo_info_cat;
+struct _agooLogCat	agoo_debug_cat;
+struct _agooLogCat	agoo_con_cat;
+struct _agooLogCat	agoo_req_cat;
+struct _agooLogCat	agoo_resp_cat;
+struct _agooLogCat	agoo_eval_cat;
+struct _agooLogCat	agoo_push_cat;
+
+agooColor
 find_color(const char *name) {
     if (NULL != name) {
-	for (Color c = colors; NULL != c->name; c++) {
+	for (agooColor c = colors; NULL != c->name; c++) {
 	    if (0 == strcasecmp(c->name, name)) {
 		return c;
 	    }
@@ -71,79 +71,80 @@ find_color(const char *name) {
 }
 
 static bool
-log_queue_empty() {
-    LogEntry	head = atomic_load(&the_log.head);
-    LogEntry	next = head + 1;
+agoo_log_queue_empty() {
+    agooLogEntry	head = atomic_load(&agoo_log.head);
+    agooLogEntry	next = head + 1;
 
-    if (the_log.end <= next) {
-	next = the_log.q;
+    if (agoo_log.end <= next) {
+	next = agoo_log.q;
     }
-    if (!head->ready && the_log.tail == next) {
+    if (!head->ready && atomic_load(&agoo_log.tail) == next) {
 	return true;
     }
     return false;
 }
 
 static int
-log_listen() {
-    if (0 == the_log.rsock) {
+agoo_log_listen() {
+    if (0 == agoo_log.rsock) {
 	int	fd[2];
 
 	if (0 == pipe(fd)) {
 	    fcntl(fd[0], F_SETFL, O_NONBLOCK);
 	    fcntl(fd[1], F_SETFL, O_NONBLOCK);
-	    the_log.rsock = fd[0];
-	    the_log.wsock = fd[1];
+	    agoo_log.rsock = fd[0];
+	    agoo_log.wsock = fd[1];
 	}
     }
-    atomic_store(&the_log.wait_state, WAITING);
+    atomic_store(&agoo_log.wait_state, WAITING);
     
-    return the_log.rsock;
+    return agoo_log.rsock;
 }
 
 static void
-log_release() {
+agoo_log_release() {
     char	buf[8];
 
     // clear pipe
-    while (0 < read(the_log.rsock, buf, sizeof(buf))) {
+    while (0 < read(agoo_log.rsock, buf, sizeof(buf))) {
     }
-    atomic_store(&the_log.wait_state, NOT_WAITING);
+    atomic_store(&agoo_log.wait_state, NOT_WAITING);
 }
 
-static LogEntry
-log_queue_pop(double timeout) {
-    LogEntry	e = the_log.head;
-    LogEntry	next;
+static agooLogEntry
+agoo_log_queue_pop(double timeout) {
+    agooLogEntry	e = atomic_load(&agoo_log.head);
+    agooLogEntry	next;
+
     if (e->ready) {
 	return e;
     }
-    next = the_log.head + 1;
-    if (the_log.end <= next) {
-	next = the_log.q;
+    next = (agooLogEntry)atomic_load(&agoo_log.head) + 1;
+    if (agoo_log.end <= next) {
+	next = agoo_log.q;
     }
     // If the next is the tail then wait for something to be appended.
-    for (int cnt = (int)(timeout / (double)WAIT_MSECS * 1000.0); atomic_load(&the_log.tail) == next; cnt--) {
+    for (int cnt = (int)(timeout / (double)WAIT_MSECS * 1000.0); atomic_load(&agoo_log.tail) == next; cnt--) {
 	struct pollfd	pa;
 
 	if (cnt <= 0) {
 	    return NULL;
 	}
-	pa.fd = log_listen();
+	pa.fd = agoo_log_listen();
 	pa.events = POLLIN;
 	pa.revents = 0;
 	if (0 < poll(&pa, 1, WAIT_MSECS)) {
-	    log_release();
+	    agoo_log_release();
 	}
     }
-    atomic_store(&the_log.head, next);
+    atomic_store(&agoo_log.head, next);
 
-    return the_log.head;
+    return next;
 }
 
 
 static int
-jwrite(LogEntry e, FILE *file) {
+jwrite(agooLogEntry e, FILE *file) {
     // TBD make e->what JSON friendly
     if (NULL == e->tidp && '\0' == *e->tid) {
 	return fprintf(file, "{\"when\":%lld.%09lld,\"where\":\"%s\",\"level\":%d,\"what\":\"%s\"}\n",
@@ -166,7 +167,7 @@ jwrite(LogEntry e, FILE *file) {
 // I 2015/05/23 11:22:33.123456789 label: The contents of the what field.
 // I 2015/05/23 11:22:33.123456789 [tid] label: The contents of the what field.
 static int
-classic_write(LogEntry e, FILE *file) {
+classic_write(agooLogEntry e, FILE *file) {
     time_t	t = (time_t)(e->when / 1000000000LL);
     int		hour = 0;
     int		min = 0;
@@ -175,9 +176,9 @@ classic_write(LogEntry e, FILE *file) {
     char	levelc = level_chars[e->cat->level];
     int		cnt = 0;
     
-    t += the_log.zone;
-    if (the_log.day_start <= t && t < the_log.day_end) {
-	t -= the_log.day_start;
+    t += agoo_log.zone;
+    if (agoo_log.day_start <= t && t < agoo_log.day_end) {
+	t -= agoo_log.day_start;
 	hour = (int)(t / 3600);
 	min = t % 3600 / 60;
 	sec = t % 60;
@@ -187,20 +188,20 @@ classic_write(LogEntry e, FILE *file) {
 	hour = tm->tm_hour;
 	min = tm->tm_min;
 	sec = tm->tm_sec;
-	sprintf(the_log.day_buf, "%04d/%02d/%02d ", tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday);
-	the_log.day_start = t - (hour * 3600 + min * 60 + sec);
-	the_log.day_end = the_log.day_start + 86400;
+	sprintf(agoo_log.day_buf, "%04d/%02d/%02d ", tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday);
+	agoo_log.day_start = t - (hour * 3600 + min * 60 + sec);
+	agoo_log.day_end = agoo_log.day_start + 86400;
     }
-    if (the_log.colorize) {
+    if (agoo_log.colorize) {
 	if (NULL == e->tidp && '\0' == *e->tid) {
 	    cnt = fprintf(file, "%s%c %s%02d:%02d:%02d.%09lld %s: %s%s\n",
-			  e->cat->color->ansi, levelc, the_log.day_buf, hour, min, sec, frac,
+			  e->cat->color->ansi, levelc, agoo_log.day_buf, hour, min, sec, frac,
 			  e->cat->label,
 			  (NULL == e->whatp ? e->what : e->whatp),
 			  RESET_COLOR);
 	} else {
 	    cnt = fprintf(file, "%s%c %s%02d:%02d:%02d.%09lld [%s] %s: %s%s\n",
-			  e->cat->color->ansi, levelc, the_log.day_buf, hour, min, sec, frac,
+			  e->cat->color->ansi, levelc, agoo_log.day_buf, hour, min, sec, frac,
 			  (NULL == e->tidp ? e->tid : e->tidp),
 			  e->cat->label,
 			  (NULL == e->whatp ? e->what : e->whatp),
@@ -209,12 +210,12 @@ classic_write(LogEntry e, FILE *file) {
     } else {
 	if (NULL == e->tidp && '\0' == *e->tid) {
 	    cnt += fprintf(file, "%c %s%02d:%02d:%02d.%09lld %s: %s\n",
-			   levelc, the_log.day_buf, hour, min, sec, frac,
+			   levelc, agoo_log.day_buf, hour, min, sec, frac,
 			   e->cat->label,
 			   (NULL == e->whatp ? e->what : e->whatp));
 	} else {
 	    cnt += fprintf(file, "%c %s%02d:%02d:%02d.%09lld [%s] %s: %s\n",
-			   levelc, the_log.day_buf, hour, min, sec, frac,
+			   levelc, agoo_log.day_buf, hour, min, sec, frac,
 			   (NULL == e->tidp ? e->tid : e->tidp),
 			   e->cat->label,
 			   (NULL == e->whatp ? e->what : e->whatp));
@@ -231,17 +232,17 @@ remove_old_logs() {
     long		seq;
     char		*end;
     char		path[1500];
-    DIR			*dir = opendir(the_log.dir);
+    DIR			*dir = opendir(agoo_log.dir);
     char		prefix[64];
     int			psize;
     char		name[64];
 
-    if (the_log.with_pid) {
-	psize = sprintf(prefix, "%s_%d.log.", the_log.app, getpid());
-	sprintf(name, "%s_%d.log", the_log.app, getpid());
+    if (agoo_log.with_pid) {
+	psize = sprintf(prefix, "%s_%d.log.", agoo_log.app, getpid());
+	sprintf(name, "%s_%d.log", agoo_log.app, getpid());
     } else {
-	psize = sprintf(prefix, "%s.log.", the_log.app);
-	sprintf(name, "%s.log", the_log.app);
+	psize = sprintf(prefix, "%s.log.", agoo_log.app);
+	sprintf(name, "%s.log", agoo_log.app);
     }
     while (NULL != (de = readdir(dir))) {
 	if ('.' == *de->d_name || '\0' == *de->d_name) {
@@ -255,8 +256,8 @@ remove_old_logs() {
 	    continue;
 	}
 	seq = strtol(de->d_name + psize, &end, 10);
-	if (the_log.max_files < seq) {
-	    snprintf(path, sizeof(path), "%s/%s", the_log.dir, de->d_name);
+	if (agoo_log.max_files < seq) {
+	    snprintf(path, sizeof(path), "%s/%s", agoo_log.dir, de->d_name);
 	    remove(path);
 	}
     }
@@ -264,72 +265,72 @@ remove_old_logs() {
 }
 
 void
-log_rotate() {
+agoo_log_rotate() {
     char	from[1060];
     char	to[1060];
 
-    if (NULL != the_log.file) {
-	fclose(the_log.file);
-	the_log.file = NULL;
+    if (NULL != agoo_log.file) {
+	fclose(agoo_log.file);
+	agoo_log.file = NULL;
     }
-    if (the_log.with_pid) {
+    if (agoo_log.with_pid) {
 	char	name[32];
 
-	sprintf(name, "%s_%d.log", the_log.app, getpid());
-	for (int seq = the_log.max_files; 0 < seq; seq--) {
-	    snprintf(to, sizeof(to) - 1, "%s/%s_%d.log.%d", the_log.dir, the_log.app, getpid(), seq + 1);
-	    snprintf(from, sizeof(from) - 1, "%s/%s_%d.log.%d", the_log.dir, the_log.app, getpid(), seq);
+	sprintf(name, "%s_%d.log", agoo_log.app, getpid());
+	for (int seq = agoo_log.max_files; 0 < seq; seq--) {
+	    snprintf(to, sizeof(to) - 1, "%s/%s_%d.log.%d", agoo_log.dir, agoo_log.app, getpid(), seq + 1);
+	    snprintf(from, sizeof(from) - 1, "%s/%s_%d.log.%d", agoo_log.dir, agoo_log.app, getpid(), seq);
 	    rename(from, to);
 	}
-	snprintf(to, sizeof(to) - 1, "%s/%s_%d.log.%d", the_log.dir, the_log.app, getpid(), 1);
-	snprintf(from, sizeof(from) - 1, "%s/%s", the_log.dir, name);
+	snprintf(to, sizeof(to) - 1, "%s/%s_%d.log.%d", agoo_log.dir, agoo_log.app, getpid(), 1);
+	snprintf(from, sizeof(from) - 1, "%s/%s", agoo_log.dir, name);
     } else {
-	for (int seq = the_log.max_files; 0 < seq; seq--) {
-	    snprintf(to, sizeof(to) - 1, "%s/%s.log.%d", the_log.dir, the_log.app, seq + 1);
-	    snprintf(from, sizeof(from) - 1, "%s/%s.log.%d", the_log.dir, the_log.app, seq);
+	for (int seq = agoo_log.max_files; 0 < seq; seq--) {
+	    snprintf(to, sizeof(to) - 1, "%s/%s.log.%d", agoo_log.dir, agoo_log.app, seq + 1);
+	    snprintf(from, sizeof(from) - 1, "%s/%s.log.%d", agoo_log.dir, agoo_log.app, seq);
 	    rename(from, to);
 	}
-	snprintf(to, sizeof(to) - 1, "%s/%s.log.%d", the_log.dir, the_log.app, 1);
-	snprintf(from, sizeof(from) - 1, "%s/%s.log", the_log.dir, the_log.app);
+	snprintf(to, sizeof(to) - 1, "%s/%s.log.%d", agoo_log.dir, agoo_log.app, 1);
+	snprintf(from, sizeof(from) - 1, "%s/%s.log", agoo_log.dir, agoo_log.app);
     }
     rename(from, to);
 
-    the_log.file = fopen(from, "w");
-    the_log.size = 0;
+    agoo_log.file = fopen(from, "w");
+    agoo_log.size = 0;
 
     remove_old_logs();
 }
 
 static void*
 loop(void *ctx) {
-    LogEntry	e;
+    agooLogEntry	e;
 
-    while (!the_log.done || !log_queue_empty()) {
-	if (NULL != (e = log_queue_pop(0.5))) {
-	    if (the_log.console) {
-		if (the_log.classic) {
+    while (!agoo_log.done || !agoo_log_queue_empty()) {
+	if (NULL != (e = agoo_log_queue_pop(0.5))) {
+	    if (agoo_log.console) {
+		if (agoo_log.classic) {
 		    classic_write(e, stdout);
 		} else {
 		    jwrite(e, stdout);
 		}
 	    }
-	    if (NULL != the_log.file) {
-		if (the_log.classic) {
-		    the_log.size += classic_write(e, the_log.file);
+	    if (NULL != agoo_log.file) {
+		if (agoo_log.classic) {
+		    agoo_log.size += classic_write(e, agoo_log.file);
 		} else {
-		    the_log.size += jwrite(e, the_log.file);
+		    agoo_log.size += jwrite(e, agoo_log.file);
 		}
-		if (the_log.max_size <= the_log.size) {
-		    log_rotate();
+		if (agoo_log.max_size <= agoo_log.size) {
+		    agoo_log_rotate();
 		}
 	    }
 	    if (NULL != e->whatp) {
 		free(e->whatp);
-		DEBUG_FREE(mem_log_what, e->whatp)
+		DEBUG_FREE(mem_agoo_log_what, e->whatp)
 	    }
 	    if (NULL != e->tidp) {
 		free(e->tidp);
-		DEBUG_FREE(mem_log_tid, e->tidp)
+		DEBUG_FREE(mem_agoo_log_tid, e->tidp)
 	    }
 	    e->ready = false;
 	}
@@ -338,76 +339,76 @@ loop(void *ctx) {
 }
 
 bool
-log_flush(double timeout) {
+agoo_log_flush(double timeout) {
     timeout += dtime();
     
-    while (!the_log.done && !log_queue_empty()) {
+    while (!agoo_log.done && !agoo_log_queue_empty()) {
 	if (timeout < dtime()) {
 	    return false;
 	}
 	dsleep(0.001);
     }
-    if (NULL != the_log.file) {
-	fflush(the_log.file);
+    if (NULL != agoo_log.file) {
+	fflush(agoo_log.file);
     }
     return true;
 }
 
 void
-open_log_file() {
+agoo_log_open_file() {
     char	path[1500];
 
-    if (the_log.with_pid) {
-	snprintf(path, sizeof(path), "%s/%s_%d.log", the_log.dir, the_log.app, getpid());
+    if (agoo_log.with_pid) {
+	snprintf(path, sizeof(path), "%s/%s_%d.log", agoo_log.dir, agoo_log.app, getpid());
     } else {
-	snprintf(path, sizeof(path), "%s/%s.log", the_log.dir, the_log.app);
+	snprintf(path, sizeof(path), "%s/%s.log", agoo_log.dir, agoo_log.app);
     }
-    the_log.file = fopen(path, "a");
-    if (NULL == the_log.file) {
-	struct _Err	err;
+    agoo_log.file = fopen(path, "a");
+    if (NULL == agoo_log.file) {
+	struct _agooErr	err;
 
-	err_no(&err, "Failed to create '%s'.", path);
-	the_log.on_error(&err);
+	agoo_err_no(&err, "Failed to create '%s'.", path);
+	agoo_log.on_error(&err);
     }
-    the_log.size = ftell(the_log.file);
-    if (the_log.max_size <= the_log.size) {
-	log_rotate();
+    agoo_log.size = ftell(agoo_log.file);
+    if (agoo_log.max_size <= agoo_log.size) {
+	agoo_log_rotate();
     }
     // TBD open rsock and wsock
 }
 
 void
-log_close() {
-    the_log.done = true;
+agoo_log_close() {
+    agoo_log.done = true;
     // TBD wake up loop like push does
-    log_cat_on(NULL, false);
-    if (0 != the_log.thread) {
-	pthread_join(the_log.thread, NULL);
-	the_log.thread = 0;
+    agoo_log_cat_on(NULL, false);
+    if (0 != agoo_log.thread) {
+	pthread_join(agoo_log.thread, NULL);
+	agoo_log.thread = 0;
     }
-    if (NULL != the_log.file) {
-	fclose(the_log.file);
-	the_log.file = NULL;
+    if (NULL != agoo_log.file) {
+	fclose(agoo_log.file);
+	agoo_log.file = NULL;
     }
-    if (NULL != the_log.q) {
-	DEBUG_FREE(mem_log_entry, the_log.q);
-	free(the_log.q);
-	the_log.q = NULL;
-	the_log.end = NULL;
+    if (NULL != agoo_log.q) {
+	DEBUG_FREE(mem_agoo_log_entry, agoo_log.q);
+	free(agoo_log.q);
+	agoo_log.q = NULL;
+	agoo_log.end = NULL;
     }
-    if (0 < the_log.wsock) {
-	close(the_log.wsock);
-	the_log.wsock = 0;
+    if (0 < agoo_log.wsock) {
+	close(agoo_log.wsock);
+	agoo_log.wsock = 0;
     }
-    if (0 < the_log.rsock) {
-	close(the_log.rsock);
-	the_log.rsock = 0;
+    if (0 < agoo_log.rsock) {
+	close(agoo_log.rsock);
+	agoo_log.rsock = 0;
     }
 }
 
 void
-log_cat_reg(LogCat cat, const char *label, LogLevel level, const char *color, bool on) {
-    LogCat	xcat = log_cat_find(label);
+agoo_log_cat_reg(agooLogCat cat, const char *label, agooLogLevel level, const char *color, bool on) {
+    agooLogCat	xcat = agoo_log_cat_find(label);
     
     if (NULL != xcat) {
 	cat = xcat;
@@ -418,16 +419,16 @@ log_cat_reg(LogCat cat, const char *label, LogLevel level, const char *color, bo
     cat->color = find_color(color);
     cat->on = on;
     if (NULL == xcat) {
-	cat->next = the_log.cats;
-	the_log.cats = cat;
+	cat->next = agoo_log.cats;
+	agoo_log.cats = cat;
     }
 }
 
 void
-log_cat_on(const char *label, bool on) {
-    LogCat	cat;
+agoo_log_cat_on(const char *label, bool on) {
+    agooLogCat	cat;
 
-    for (cat = the_log.cats; NULL != cat; cat = cat->next) {
+    for (cat = agoo_log.cats; NULL != cat; cat = cat->next) {
 	if (NULL == label || 0 == strcasecmp(label, cat->label)) {
 	    cat->on = on;
 	    break;
@@ -435,11 +436,11 @@ log_cat_on(const char *label, bool on) {
     }
 }
 
-LogCat
-log_cat_find(const char *label) {
-    LogCat	cat;
+agooLogCat
+agoo_log_cat_find(const char *label) {
+    agooLogCat	cat;
 
-    for (cat = the_log.cats; NULL != cat; cat = cat->next) {
+    for (cat = agoo_log.cats; NULL != cat; cat = cat->next) {
 	if (0 == strcasecmp(label, cat->label)) {
 	    return cat;
 	}
@@ -468,7 +469,7 @@ now_nano() {
 #endif
 
 static void
-set_entry(LogEntry e, LogCat cat, const char *tid, const char *fmt, va_list ap) {
+set_entry(agooLogEntry e, agooLogCat cat, const char *tid, const char *fmt, va_list ap) {
     int		cnt;
     va_list	ap2;
 
@@ -502,135 +503,142 @@ set_entry(LogEntry e, LogCat cat, const char *tid, const char *fmt, va_list ap)
 }
 
 void
-log_catv(LogCat cat, const char *tid, const char *fmt, va_list ap) {
-    if (cat->on && !the_log.done) {
-	LogEntry	e;
-	LogEntry	tail;
+agoo_log_catv(agooLogCat cat, const char *tid, const char *fmt, va_list ap) {
+    if (cat->on && !agoo_log.done) {
+	agooLogEntry	e;
+	agooLogEntry	tail;
 	
-	while (atomic_flag_test_and_set(&the_log.push_lock)) {
+	while (atomic_flag_test_and_set(&agoo_log.push_lock)) {
 	    dsleep(RETRY_SECS);
 	}
-	if (0 == the_log.thread) {
-	    struct _LogEntry	entry;
+	if (0 == agoo_log.thread) {
+	    struct _agooLogEntry	entry;
 	    
 	    set_entry(&entry, cat, tid, fmt, ap);
-	    if (the_log.classic) {
+	    if (agoo_log.classic) {
 		classic_write(&entry, stdout);
 	    } else {
 		jwrite(&entry, stdout);
 	    }
-	    atomic_flag_clear(&the_log.push_lock);
+	    atomic_flag_clear(&agoo_log.push_lock);
+
+	    return;
 	}
 	// Wait for head to move on.
-	while (atomic_load(&the_log.head) == the_log.tail) {
+	while (atomic_load(&agoo_log.head) == atomic_load(&agoo_log.tail)) {
 	    dsleep(RETRY_SECS);
 	}
-	e = the_log.tail;
+	e = atomic_load(&agoo_log.tail);
 	set_entry(e, cat, tid, fmt, ap);
-	tail = the_log.tail + 1;
-	if (the_log.end <= tail) {
-	    tail = the_log.q;
+	tail = e + 1;
+	if (agoo_log.end <= tail) {
+	    tail = agoo_log.q;
 	}
-	atomic_store(&the_log.tail, tail);
-	atomic_flag_clear(&the_log.push_lock);
+	atomic_store(&agoo_log.tail, tail);
+	atomic_flag_clear(&agoo_log.push_lock);
 
-	if (0 != the_log.wsock && WAITING == atomic_load(&the_log.wait_state)) {
-	    if (write(the_log.wsock, ".", 1)) {}
-	    atomic_store(&the_log.wait_state, NOTIFIED);
+	if (0 != agoo_log.wsock && WAITING == (int)(long)atomic_load(&agoo_log.wait_state)) {
+	    if (write(agoo_log.wsock, ".", 1)) {}
+	    atomic_store(&agoo_log.wait_state, NOTIFIED);
 	}
     }
 }
 
 void
-log_cat(LogCat cat, const char *fmt, ...) {
+agoo_log_cat(agooLogCat cat, const char *fmt, ...) {
     va_list	ap;
 
     va_start(ap, fmt);
-    log_catv(cat, NULL, fmt, ap);
+    agoo_log_catv(cat, NULL, fmt, ap);
     va_end(ap);
 }
 
 void
-log_tid_cat(LogCat cat, const char *tid, const char *fmt, ...) {
+agoo_log_tid_cat(agooLogCat cat, const char *tid, const char *fmt, ...) {
     va_list	ap;
 
     va_start(ap, fmt);
-    log_catv(cat, tid, fmt, ap);
+    agoo_log_catv(cat, tid, fmt, ap);
     va_end(ap);
 }
 
-void
-log_start(bool with_pid) {
-    if (0 != the_log.thread) {
+int
+agoo_log_start(agooErr err, bool with_pid) {
+    int	stat;
+    
+    if (0 != agoo_log.thread) {
 	// Already started.
-	return;
+	return AGOO_ERR_OK;
     }
-    if (NULL != the_log.file) {
-	fclose(the_log.file);
-	the_log.file = NULL;
+    if (NULL != agoo_log.file) {
+	fclose(agoo_log.file);
+	agoo_log.file = NULL;
 	// TBD close rsock and wsock
     }
-    the_log.with_pid = with_pid;
-    if ('\0' != *the_log.dir) {
-	if (0 != mkdir(the_log.dir, 0770) && EEXIST != errno) {
-	    struct _Err	err;
+    agoo_log.with_pid = with_pid;
+    if ('\0' != *agoo_log.dir) {
+	if (0 != mkdir(agoo_log.dir, 0770) && EEXIST != errno) {
+	    struct _agooErr	err;
 
-	    err_no(&err, "Failed to create '%s'", the_log.dir);
-	    the_log.on_error(&err);
+	    agoo_err_no(&err, "Failed to create '%s'", agoo_log.dir);
+	    agoo_log.on_error(&err);
 	}
-	open_log_file();
+	agoo_log_open_file();
+    }
+    if (0 != (stat = pthread_create(&agoo_log.thread, NULL, loop, NULL))) {
+	return agoo_err_set(err, stat, "Failed to create log thread. %s", strerror(stat));
     }
-    pthread_create(&the_log.thread, NULL, loop, NULL);
+    return AGOO_ERR_OK;
 }
 
 void
-log_init(const char *app) {
+agoo_log_init(const char *app) {
     time_t	t = time(NULL);
     struct tm	*tm = localtime(&t);
     int		qsize = 1024;
 
-    strncpy(the_log.app, app, sizeof(the_log.app));
-    the_log.app[sizeof(the_log.app) - 1] = '\0';
-    the_log.cats = NULL;
-    *the_log.dir = '\0';
-    the_log.file = NULL;
-    the_log.max_files = 3;
-    the_log.max_size = 100000000; // 100M
-    the_log.size = 0;
-    the_log.done = false;
-    the_log.console = true;
-    the_log.classic = true;
-    the_log.colorize = true;
-    the_log.with_pid = false;
-    the_log.zone = (int)(timegm(tm) - t);
-    the_log.day_start = 0;
-    the_log.day_end = 0;
-    *the_log.day_buf = '\0';
-    the_log.thread = 0;
-
-    the_log.q = (LogEntry)malloc(sizeof(struct _LogEntry) * qsize);
-    DEBUG_ALLOC(mem_log_entry, the_log.q)
-    the_log.end = the_log.q + qsize;
-    memset(the_log.q, 0, sizeof(struct _LogEntry) * qsize);
-    the_log.head = the_log.q;
-    the_log.tail = the_log.q + 1;
-
-    atomic_flag_clear(&the_log.push_lock);
-    the_log.wait_state = NOT_WAITING;
+    strncpy(agoo_log.app, app, sizeof(agoo_log.app));
+    agoo_log.app[sizeof(agoo_log.app) - 1] = '\0';
+    agoo_log.cats = NULL;
+    *agoo_log.dir = '\0';
+    agoo_log.file = NULL;
+    agoo_log.max_files = 3;
+    agoo_log.max_size = 100000000; // 100M
+    agoo_log.size = 0;
+    agoo_log.done = false;
+    agoo_log.console = true;
+    agoo_log.classic = true;
+    agoo_log.colorize = true;
+    agoo_log.with_pid = false;
+    agoo_log.zone = (int)(timegm(tm) - t);
+    agoo_log.day_start = 0;
+    agoo_log.day_end = 0;
+    *agoo_log.day_buf = '\0';
+    agoo_log.thread = 0;
+
+    agoo_log.q = (agooLogEntry)malloc(sizeof(struct _agooLogEntry) * qsize);
+    DEBUG_ALLOC(mem_log_entry, agoo_log.q)
+    agoo_log.end = agoo_log.q + qsize;
+    memset(agoo_log.q, 0, sizeof(struct _agooLogEntry) * qsize);
+    atomic_init(&agoo_log.head, agoo_log.q);
+    atomic_init(&agoo_log.tail, agoo_log.q + 1);
+
+    agoo_atomic_flag_init(&agoo_log.push_lock);
+    atomic_init(&agoo_log.wait_state, NOT_WAITING);
     // Create when/if needed.
-    the_log.rsock = 0;
-    the_log.wsock = 0;
-
-    log_cat_reg(&fatal_cat, "FATAL",    FATAL, RED, true);
-    log_cat_reg(&error_cat, "ERROR",    ERROR, RED, true);
-    log_cat_reg(&warn_cat,  "WARN",     WARN,  YELLOW, true);
-    log_cat_reg(&info_cat,  "INFO",     INFO,  GREEN, true);
-    log_cat_reg(&debug_cat, "DEBUG",    DEBUG, GRAY, false);
-    log_cat_reg(&con_cat,   "connect",  INFO,  GREEN, false);
-    log_cat_reg(&req_cat,   "request",  INFO,  CYAN, false);
-    log_cat_reg(&resp_cat,  "response", INFO,  DARK_CYAN, false);
-    log_cat_reg(&eval_cat,  "eval",     INFO,  BLUE, false);
-    log_cat_reg(&push_cat,  "push",     INFO,  DARK_CYAN, false);
-
-    //log_start(false);
+    agoo_log.rsock = 0;
+    agoo_log.wsock = 0;
+
+    agoo_log_cat_reg(&agoo_fatal_cat, "FATAL",    AGOO_FATAL, AGOO_RED, true);
+    agoo_log_cat_reg(&agoo_error_cat, "ERROR",    AGOO_ERROR, AGOO_RED, true);
+    agoo_log_cat_reg(&agoo_warn_cat,  "WARN",     AGOO_WARN,  AGOO_YELLOW, true);
+    agoo_log_cat_reg(&agoo_info_cat,  "INFO",     AGOO_INFO,  AGOO_GREEN, true);
+    agoo_log_cat_reg(&agoo_debug_cat, "DEBUG",    AGOO_DEBUG, AGOO_GRAY, false);
+    agoo_log_cat_reg(&agoo_con_cat,   "connect",  AGOO_INFO,  AGOO_GREEN, false);
+    agoo_log_cat_reg(&agoo_req_cat,   "request",  AGOO_INFO,  AGOO_CYAN, false);
+    agoo_log_cat_reg(&agoo_resp_cat,  "response", AGOO_INFO,  AGOO_DARK_CYAN, false);
+    agoo_log_cat_reg(&agoo_eval_cat,  "eval",     AGOO_INFO,  AGOO_BLUE, false);
+    agoo_log_cat_reg(&agoo_push_cat,  "push",     AGOO_INFO,  AGOO_DARK_CYAN, false);
+
+    //agoo_log_start(false);
 }