agoo 2.2.2 → 2.3.0

data/ext/agoo/log.h

@@ -3,15 +3,11 @@
 #ifndef __AGOO_LOG_H__
 #define __AGOO_LOG_H__
 
-#include <netdb.h>
 #include <pthread.h>
 #include <stdarg.h>
 #include <stdatomic.h>
 #include <stdbool.h>
 #include <stdint.h>
-#include <stdio.h>
-
-#include <ruby.h>
 
 #include "err.h"
 
@@ -89,6 +85,8 @@ struct _Log {
     atomic_int		wait_state;
     int			rsock;
     int			wsock;
+
+    void		(*on_error)(Err err);
 };
 
 extern struct _Log	the_log;
@@ -103,7 +101,8 @@ extern struct _LogCat	resp_cat;
 extern struct _LogCat	eval_cat;
 extern struct _LogCat	push_cat;
 
-extern void	log_init(VALUE mod);
+extern void	log_init();
+extern void	open_log_file();
 
 extern void	log_close();
 extern bool	log_flush(double timeout);
@@ -119,4 +118,6 @@ extern void	log_catv(LogCat cat, const char *fmt, va_list ap);
 
 extern void	log_start(bool with_pid);
 
+extern Color	find_color(const char *name);
+
 #endif /* __AGOO_LOG_H__ */

data/ext/agoo/method.h

@@ -0,0 +1,25 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#ifndef __AGOO_METHOD_H__
+#define __AGOO_METHOD_H__
+
+typedef enum {
+    CONNECT	= 'C',
+    DELETE	= 'D',
+    GET		= 'G',
+    HEAD	= 'H',
+    OPTIONS	= 'O',
+    POST	= 'P',
+    PUT		= 'U',
+    PATCH	= 'T',
+    ALL		= 'A',
+    NONE	= '\0',
+
+    ON_MSG	= 'M', // use for on_message callback
+    ON_BIN	= 'B', // use for on_message callback with binary (ASCII8BIT)
+    ON_CLOSE	= 'X', // use for on_close callback
+    ON_SHUTDOWN	= 'S', // use for on_shotdown callback
+    ON_EMPTY	= 'E', // use for on_drained callback
+} Method;
+
+#endif // __AGOO_METHOD_H__

data/ext/agoo/request.c

@@ -64,6 +64,7 @@ request_create(size_t mlen) {
     if (NULL != req) {
 	DEBUG_ALLOC(mem_req, req);
 	memset(req, 0, size);
+	req->env = Qnil;
 	req->mlen = mlen;
     }
     return req;
@@ -546,30 +547,33 @@ rack_logger(VALUE self) {
  */
 VALUE
 request_env(Req req) {
-    volatile VALUE	env = rb_hash_new();
+    if (Qnil == req->env) {
+	volatile VALUE	env = rb_hash_new();
     
-    // As described by
-    // http://www.rubydoc.info/github/rack/rack/master/file/SPEC and
-    // https://github.com/rack/rack/blob/master/SPEC.
-
-    rb_hash_aset(env, request_method_val, req_method(req));
-    rb_hash_aset(env, script_name_val, req_script_name(req));
-    rb_hash_aset(env, path_info_val, req_path_info(req));
-    rb_hash_aset(env, query_string_val, req_query_string(req));
-    rb_hash_aset(env, server_name_val, req_server_name(req));
-    rb_hash_aset(env, server_port_val, req_server_port(req));
-    fill_headers(req, env);
-    rb_hash_aset(env, rack_version_val, rack_version_val_val);
-    rb_hash_aset(env, rack_url_scheme_val, req_rack_url_scheme(req));
-    rb_hash_aset(env, rack_input_val, req_rack_input(req));
-    rb_hash_aset(env, rack_errors_val, req_rack_errors(req));
-    rb_hash_aset(env, rack_multithread_val, req_rack_multithread(req));
-    rb_hash_aset(env, rack_multiprocess_val, Qfalse);
-    rb_hash_aset(env, rack_run_once_val, Qfalse);
-    rb_hash_aset(env, rack_logger_val, req_rack_logger(req));
-    rb_hash_aset(env, rack_upgrade_val, req_rack_upgrade(req));
-
-    return env;
+	// As described by
+	// http://www.rubydoc.info/github/rack/rack/master/file/SPEC and
+	// https://github.com/rack/rack/blob/master/SPEC.
+
+	rb_hash_aset(env, request_method_val, req_method(req));
+	rb_hash_aset(env, script_name_val, req_script_name(req));
+	rb_hash_aset(env, path_info_val, req_path_info(req));
+	rb_hash_aset(env, query_string_val, req_query_string(req));
+	rb_hash_aset(env, server_name_val, req_server_name(req));
+	rb_hash_aset(env, server_port_val, req_server_port(req));
+	fill_headers(req, env);
+	rb_hash_aset(env, rack_version_val, rack_version_val_val);
+	rb_hash_aset(env, rack_url_scheme_val, req_rack_url_scheme(req));
+	rb_hash_aset(env, rack_input_val, req_rack_input(req));
+	rb_hash_aset(env, rack_errors_val, req_rack_errors(req));
+	rb_hash_aset(env, rack_multithread_val, req_rack_multithread(req));
+	rb_hash_aset(env, rack_multiprocess_val, Qfalse);
+	rb_hash_aset(env, rack_run_once_val, Qfalse);
+	rb_hash_aset(env, rack_logger_val, req_rack_logger(req));
+	rb_hash_aset(env, rack_upgrade_val, req_rack_upgrade(req));
+
+	req->env = env;
+    }
+    return req->env;
 }
 
 /* Document-method: to_h

data/ext/agoo/request.h

@@ -34,6 +34,7 @@ typedef struct _Req {
     struct _Str		header;
     struct _Str		body;
     VALUE		handler;
+    VALUE		env;
     HookType		handler_type;
     Res			res;
     size_t		mlen;   // allocated msg length

data/ext/agoo/response.c

@@ -53,7 +53,6 @@ response_free(void *ptr) {
     while (NULL != (h = res->headers)) {
 	res->headers = h->next;
 	DEBUG_FREE(mem_header, h);
-	// TBD
 	xfree(h);
     }
     DEBUG_FREE(mem_res_body, res->body);

data/ext/agoo/rhook.c

@@ -0,0 +1,82 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <ruby.h>
+
+#include "debug.h"
+#include "rhook.h"
+#include "hook.h"
+
+static VALUE
+resolve_classname(VALUE mod, const char *classname) {
+    VALUE	clas;
+    ID		ci = rb_intern(classname);
+
+    if (rb_const_defined_at(mod, ci)) {
+	clas = rb_const_get_at(mod, ci);
+    } else {
+	clas = Qundef;
+    }
+    return clas;
+}
+
+static VALUE
+resolve_classpath(const char *name, size_t len) {
+    char	class_name[1024];
+    VALUE	clas;
+    char	*end = class_name + sizeof(class_name) - 1;
+    char	*s;
+    const char	*n = name;
+
+    clas = rb_cObject;
+    for (s = class_name; 0 < len; n++, len--) {
+	if (':' == *n) {
+	    *s = '\0';
+	    n++;
+	    len--;
+	    if (':' != *n) {
+		return Qundef;
+	    }
+	    if (Qundef == (clas = resolve_classname(clas, class_name))) {
+		return Qundef;
+	    }
+	    s = class_name;
+	} else if (end <= s) {
+	    return Qundef;
+	} else {
+	    *s++ = *n;
+	}
+    }
+    *s = '\0';
+    return resolve_classname(clas, class_name);
+}
+
+Hook
+rhook_create(Method method, const char *pattern, VALUE handler) {
+    Hook	hook = hook_create(method,pattern, NULL, RACK_HOOK);
+
+    if (NULL != hook) {
+	if (T_STRING == rb_type(handler)) {
+	    handler = resolve_classpath(StringValuePtr(handler), RSTRING_LEN(handler));
+	    // TBD does class handle it or should an instance be made?
+	    //  
+	}
+	hook->handler = (void*)handler;
+	rb_gc_register_address(&handler);
+	if (rb_respond_to(handler, rb_intern("on_request"))) {
+	    hook->type = BASE_HOOK;
+	} else if (rb_respond_to(handler, rb_intern("call"))) {
+	    hook->type = RACK_HOOK;
+	} else if (rb_respond_to(handler, rb_intern("create")) &&
+		   rb_respond_to(handler, rb_intern("read")) &&
+		   rb_respond_to(handler, rb_intern("update")) &&
+		   rb_respond_to(handler, rb_intern("delete"))) {
+	    hook->type = WAB_HOOK;
+	} else {
+	    rb_raise(rb_eArgError, "handler does not have a on_request, or call method nor is it a WAB::Controller");
+	}
+    }
+    return hook;
+}

data/ext/agoo/rhook.h

@@ -0,0 +1,13 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#ifndef __AGOO_RHOOK_H__
+#define __AGOO_RHOOK_H__
+
+#include <ruby.h>
+
+#include "hook.h"
+#include "method.h"
+
+extern Hook	rhook_create(Method method, const char *pattern, VALUE handler);
+
+#endif // __AGOO_RHOOK_H__

data/ext/agoo/rlog.c

@@ -0,0 +1,469 @@
+// Copyright 2018 by Peter Ohler, All Rights Reserved
+
+#include <dirent.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <time.h>
+#include <unistd.h>
+
+#include "debug.h"
+#include "dtime.h"
+#include "rlog.h"
+
+static VALUE	log_mod = Qundef;
+
+/* Document-method: configure
+ *
+ * call-seq: configure(options)
+ *
+ * Configures the logger
+ *
+ * - *options* [_Hash_] server options
+ *
+ *   - *:dir* [_String_] directory to place log files in. If nil or empty then no log files are written.
+ *
+ *   - *:console* [_true_|_false_] if true log entry are display on the console.
+ *
+ *   - *:classic* [_true_|_false_] if true log entry follow a classic format. If false log entries are JSON.
+ *
+ *   - *:colorize* [_true_|_false_] if true log entries are colorized.
+ *
+ *   - *:states* [_Hash_] a map of logging categories and whether they should be on or off. Categories are:
+ *     - *:ERROR* errors
+ *     - *:WARN* warnings
+ *     - *:INFO* infomational
+ *     - *:DEBUG* debugging
+ *     - *:connect* openning and closing of connections
+ *     - *:request* requests
+ *     - *:response* responses
+ *     - *:eval* handler evaluationss
+ *     - *:push* writes to WebSocket or SSE connection
+ */
+static VALUE
+rlog_configure(VALUE self, VALUE options) {
+    if (Qnil != options) {
+	VALUE	v;
+
+	if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("dir"))))) {
+	    rb_check_type(v, T_STRING);
+	    strncpy(the_log.dir, StringValuePtr(v), sizeof(the_log.dir));
+	    the_log.dir[sizeof(the_log.dir) - 1] = '\0';
+	}
+	if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("max_files"))))) {
+	    int	max = FIX2INT(v);
+
+	    if (1 <= max || max < 100) {
+		the_log.max_files = max;
+	    } else {
+		rb_raise(rb_eArgError, "max_files must be between 1 and 100.");
+	    }
+	}
+	if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("max_size"))))) {
+	    int	max = FIX2INT(v);
+
+	    if (1 <= max) {
+		the_log.max_size = max;
+	    } else {
+		rb_raise(rb_eArgError, "max_size must be 1 or more.");
+	    }
+	}
+	if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("console"))))) {
+	    the_log.console = (Qtrue == v);
+	}
+	if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("classic"))))) {
+	    the_log.classic = (Qtrue == v);
+	}
+	if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("colorize"))))) {
+	    the_log.colorize = (Qtrue == v);
+	}
+	if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("states"))))) {
+	    if (T_HASH == rb_type(v)) {
+		LogCat	cat = the_log.cats;
+		VALUE	cv;
+		
+		for (; NULL != cat; cat = cat->next) {
+		    if (Qnil != (cv = rb_hash_lookup(v, ID2SYM(rb_intern(cat->label))))) {
+			if (Qtrue == cv) {
+			    cat->on = true;
+			} else if (Qfalse == cv) {
+			    cat->on = false;
+			}
+		    }
+		}
+	    } else {
+		rb_raise(rb_eArgError, "states must be a Hash.");
+	    }
+	}
+    }
+    if (NULL != the_log.file) {
+	fclose(the_log.file);
+	the_log.file = NULL;
+    }
+    if ('\0' != *the_log.dir) {
+	if (0 != mkdir(the_log.dir, 0770) && EEXIST != errno) {
+	    rb_raise(rb_eIOError, "Failed to create '%s'.", the_log.dir);
+	}
+	open_log_file();
+    }
+    return Qnil;
+}
+
+/* Document-method: shutdown
+ *
+ * call-seq: shutdown()
+ *
+ * Shutdown the logger. Writes are flushed before shutting down.
+ */
+static VALUE
+rlog_shutdown(VALUE self) {
+    log_close();
+    return Qnil;
+}
+
+/* Document-method: error?
+ *
+ * call-seq: error?()
+ *
+ * Returns true is errors are being logged.
+ */
+static VALUE
+rlog_errorp(VALUE self) {
+    return error_cat.on ? Qtrue : Qfalse;
+}
+
+/* Document-method: warn?
+ *
+ * call-seq: warn?()
+ *
+ * Returns true is warnings are being logged.
+ */
+static VALUE
+rlog_warnp(VALUE self) {
+    return warn_cat.on ? Qtrue : Qfalse;
+}
+
+/* Document-method: info?
+ *
+ * call-seq: info?()
+ *
+ * Returns true is info entries are being logged.
+ */
+static VALUE
+rlog_infop(VALUE self) {
+    return info_cat.on ? Qtrue : Qfalse;
+}
+
+/* Document-method: debug?
+ *
+ * call-seq: debug?()
+ *
+ * Returns true is debug entries are being logged.
+ */
+static VALUE
+rlog_debugp(VALUE self) {
+    return debug_cat.on ? Qtrue : Qfalse;
+}
+
+/* Document-method: error
+ *
+ * call-seq: error(msg)
+ *
+ * Log an error message.
+ */
+static VALUE
+rlog_error(VALUE self, VALUE msg) {
+    log_cat(&error_cat, "%s", StringValuePtr(msg));
+    return Qnil;
+}
+
+/* Document-method: warn
+ *
+ * call-seq: warn(msg)
+ *
+ * Log a warn message.
+ */
+static VALUE
+rlog_warn(VALUE self, VALUE msg) {
+    log_cat(&warn_cat, "%s", StringValuePtr(msg));
+    return Qnil;
+}
+
+/* Document-method: info
+ *
+ * call-seq: info(msg)
+ *
+ * Log an info message.
+ */
+static VALUE
+rlog_info(VALUE self, VALUE msg) {
+    log_cat(&info_cat, "%s", StringValuePtr(msg));
+    return Qnil;
+}
+
+/* Document-method: debug
+ *
+ * call-seq: debug(msg)
+ *
+ * Log a debug message.
+ */
+static VALUE
+rlog_debug(VALUE self, VALUE msg) {
+    log_cat(&debug_cat, "%s", StringValuePtr(msg));
+    return Qnil;
+}
+
+/* Document-method: color
+ *
+ * call-seq: color(label)
+ *
+ * Returns the current color name as a Symbol for the specified label.
+ */
+static VALUE
+rlog_color_get(VALUE self, VALUE label) {
+    LogCat	cat = log_cat_find(StringValuePtr(label));
+
+    if (NULL == cat) {
+	return Qnil;
+    }
+    return ID2SYM(rb_intern(cat->color->name));
+}
+
+/* Document-method: set_color
+ *
+ * call-seq: set_color(label, color_symbol)
+ *
+ * Sets color of the category associated with a label. Valid colors are
+ * :black, :red, :green, :yellow, :blue, :magenta, :cyan, :white, :gray,
+ * :dark_red, :dark_green, :brown, :dark_blue, :purple, and :dark_cyan.
+ */
+static VALUE
+rlog_color_set(VALUE self, VALUE label, VALUE color) {
+    const char	*label_str = StringValuePtr(label);
+    const char	*color_name = StringValuePtr(color);
+    LogCat	cat = log_cat_find(label_str);
+    Color	c = find_color(color_name);
+
+    if (NULL == cat) {
+	rb_raise(rb_eArgError, "%s is not a valid category.", label_str);
+    }
+    if (NULL == c) {
+	rb_raise(rb_eArgError, "%s is not a valid color.", color_name);
+    }
+    cat->color = c;
+    
+    return Qnil;
+}
+
+/* Document-method: state
+ *
+ * call-seq: state(label)
+ *
+ * Returns the current state of the category identified by the specified
+ * label.
+ */
+static VALUE
+rlog_on_get(VALUE self, VALUE label) {
+    LogCat	cat = log_cat_find(StringValuePtr(label));
+
+    if (NULL == cat) {
+	return Qfalse;
+    }
+    return cat->on ? Qtrue : Qfalse;
+}
+
+/* Document-method: set_state
+ *
+ * call-seq: set_state(label, state)
+ *
+ * Sets state of the category associated with a label.
+ */
+static VALUE
+rlog_on_set(VALUE self, VALUE label, VALUE state) {
+    const char	*label_str = StringValuePtr(label);
+    LogCat	cat = log_cat_find(label_str);
+
+    if (NULL == cat) {
+	rb_raise(rb_eArgError, "%s is not a valid category.", label_str);
+    }
+    cat->on = (Qtrue == state);
+    
+    return cat->on ? Qtrue : Qfalse;
+}
+
+/* Document-method: log
+ *
+ * call-seq: log[label] = msg
+ *
+ * Log a message in the specified category.
+ */
+static VALUE
+rlog_log(VALUE self, VALUE label, VALUE msg) {
+    const char	*label_str = StringValuePtr(label);
+    LogCat	cat = log_cat_find(label_str);
+
+    if (NULL == cat) {
+	rb_raise(rb_eArgError, "%s is not a valid category.", label_str);
+    }
+    log_cat(cat, "%s", StringValuePtr(msg));
+    
+    return Qnil;
+}
+
+/* Document-method: flush
+ *
+ * call-seq: flush
+ *
+ * Flush the log queue and write all entries to disk or the console. The call
+ * waits for the flush to complete or the timeout to be exceeded.
+ */
+static VALUE
+rlog_flush(VALUE self, VALUE to) {
+    double	timeout = NUM2DBL(to);
+    
+    if (!log_flush(timeout)) {
+	rb_raise(rb_eStandardError, "timed out waiting for log flush.");
+    }
+    return Qnil;
+}
+
+/* Document-method: rotate
+ *
+ * call-seq: rotate()
+ *
+ * Rotate the log files.
+ */
+static VALUE
+rlog_rotate(VALUE self) {
+    log_rotate();
+    return Qnil;
+}
+
+/* Document-method: console=
+ *
+ * call-seq: console=(on)
+ *
+ * If on then log output also goes to the console.
+ */
+static VALUE
+rlog_console(VALUE self, VALUE on) {
+    the_log.console = (Qtrue == on);
+    return Qnil;
+}
+
+/* Document-method: classic
+ *
+ * call-seq: classic()
+ *
+ * Set the log format to classic format.
+ */
+static VALUE
+rlog_classic(VALUE self) {
+    the_log.classic = true;
+    return Qnil;
+}
+
+/* Document-method: json
+ *
+ * call-seq: json()
+ *
+ * Set the log format to JSON format.
+ */
+static VALUE
+rlog_json(VALUE self) {
+    the_log.classic = false;
+    return Qnil;
+}
+
+/* Document-method: max_size
+ *
+ * call-seq: max_size(size)
+ *
+ * Maximum log files size is reset.
+ */
+static VALUE
+rlog_max_size(VALUE self, VALUE rmax) {
+    int	max = FIX2INT(rmax);
+
+    if (1 <= max) {
+	the_log.max_size = max;
+    } else {
+	rb_raise(rb_eArgError, "max_size must be 1 or more.");
+    }
+    return Qnil;
+}
+
+/* Document-method: max_files
+ *
+ * call-seq: max_files(max)
+ *
+ * Maximum log files files is reset.
+ */
+static VALUE
+rlog_max_files(VALUE self, VALUE rmax) {
+    int	max = FIX2INT(rmax);
+
+    if (1 <= max || max < 100) {
+	the_log.max_files = max;
+    } else {
+	rb_raise(rb_eArgError, "max_files must be between 1 and 100.");
+    }
+    return Qnil;
+}
+
+static void
+on_error(Err err) {
+    rb_raise(rb_eStandardError, "%s", err->msg);
+}
+
+/* Document-class: Agoo::Log
+ *
+ * An asynchronous and thread safe logger that includes file rollover and
+ * multiple logging categories. It is a feature based logger with a level
+ * overlay.
+ */
+void
+rlog_init(VALUE mod) {
+    log_mod = rb_define_module_under(mod, "Log");
+
+    rb_define_module_function(log_mod, "configure", rlog_configure, 1);
+    rb_define_module_function(log_mod, "shutdown", rlog_shutdown, 0);
+
+    rb_define_module_function(log_mod, "error?", rlog_errorp, 0);
+    rb_define_module_function(log_mod, "warn?", rlog_warnp, 0);
+    rb_define_module_function(log_mod, "info?", rlog_infop, 0);
+    rb_define_module_function(log_mod, "debug?", rlog_debugp, 0);
+
+    rb_define_module_function(log_mod, "error", rlog_error, 1);
+    rb_define_module_function(log_mod, "warn", rlog_warn, 1);
+    rb_define_module_function(log_mod, "info", rlog_info, 1);
+    rb_define_module_function(log_mod, "debug", rlog_debug, 1);
+
+    // TBD maybe in a future version
+    //rb_define_module_function(log_mod, "register", rlog_register, 2);
+
+    rb_define_module_function(log_mod, "color", rlog_color_get, 1);
+    rb_define_module_function(log_mod, "set_color", rlog_color_set, 2);
+
+    rb_define_module_function(log_mod, "state", rlog_on_get, 1);
+    rb_define_module_function(log_mod, "set_state", rlog_on_set, 2);
+
+    rb_define_module_function(log_mod, "log", rlog_log, 2);
+
+    rb_define_module_function(log_mod, "flush", rlog_flush, 1);
+    rb_define_module_function(log_mod, "rotate", rlog_rotate, 0);
+    rb_define_module_function(log_mod, "console=", rlog_console, 1);
+    rb_define_module_function(log_mod, "classic", rlog_classic, 0);
+    rb_define_module_function(log_mod, "json", rlog_json, 0);
+    rb_define_module_function(log_mod, "max_size=", rlog_max_size, 1);
+    rb_define_module_function(log_mod, "max_files=", rlog_max_files, 1);
+
+    the_log.on_error = on_error;
+    
+    log_init();
+}