agoo 0.9.0

data/ext/agoo/con.h

@@ -0,0 +1,46 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#ifndef __AGOO_CON_H__
+#define __AGOO_CON_H__
+
+#include <poll.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "err.h"
+#include "request.h"
+#include "response.h"
+#include "server.h"
+
+#define MAX_HEADER_SIZE	8192
+
+typedef struct _Con {
+    int			sock;
+    struct pollfd	*pp;
+    char		id[32];
+    uint64_t		iid;
+    char		buf[MAX_HEADER_SIZE];
+    size_t		bcnt;
+
+    ssize_t		msize; // size of complete message
+    ssize_t		mcnt;  // how much has been read so far
+
+    ssize_t		wcnt;  // how much has been written
+
+    Server		server;
+    double		timeout;
+    bool		closing;
+    Req			req;
+    Res			res_head;
+    Res			res_tail;
+
+    //FEval		eval;
+} *Con;
+
+extern Con		con_create(Err err, Server server, int sock, uint64_t id);
+extern void		con_destroy(Con c);
+extern const char*	con_header_value(const char *header, int hlen, const char *key, int *vlen);
+
+extern void*		con_loop(void *ctx);
+
+#endif /* __AGOO_CON_H__ */

data/ext/agoo/dtime.c

@@ -0,0 +1,52 @@
+// Copyright 2009, 2015, 2016, 2018 by Peter Ohler, All Rights Reserved
+
+#include <time.h>
+#include <sys/time.h>
+#include <errno.h>
+
+#include "dtime.h"
+
+#define MIN_SLEEP	(1.0 / (double)CLOCKS_PER_SEC)
+
+double
+dtime() {
+    struct timeval	tv;
+    struct timezone	tz;
+
+    gettimeofday(&tv, &tz);
+
+    return (double)tv.tv_sec + (double)tv.tv_usec / 1000000.0;
+}
+
+double
+dsleep(double t) {
+    struct timespec	req, rem;
+
+    if (MIN_SLEEP > t) {
+	t = MIN_SLEEP;
+    }
+    req.tv_sec = (time_t)t;
+    req.tv_nsec = (long)(1000000000.0 * (t - (double)req.tv_sec));
+    if (nanosleep(&req, &rem) == -1 && EINTR == errno) {
+	return (double)rem.tv_sec + (double)rem.tv_nsec / 1000000000.0;
+    }
+    return 0.0;
+}
+
+double
+dwait(double t) {
+    double	end = dtime() + t;
+    
+    if (MIN_SLEEP < t) {
+	struct timespec	req, rem;
+
+	t -= MIN_SLEEP;
+	req.tv_sec = (time_t)t;
+	req.tv_nsec = (long)(1000000000.0 * (t - (double)req.tv_sec));
+	nanosleep(&req, &rem);
+    }
+    while (dtime() < end) {
+	continue;
+    }
+    return 0.0;
+}

data/ext/agoo/dtime.h

@@ -0,0 +1,10 @@
+// Copyright 2009, 2015, 2018, 2016 by Peter Ohler, All Rights Reserved
+
+#ifndef __AGOO_DTIME_H__
+#define __AGOO_DTIME_H__
+
+extern double	dtime(void);
+extern double	dsleep(double t);
+extern double	dwait(double t);
+
+#endif /* __AGOO_DTIME_H__ */

data/ext/agoo/err.c

@@ -0,0 +1,78 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "err.h"
+
+#ifdef PLATFORM_LINUX
+#pragma GCC diagnostic ignored "-Wsuggest-attribute=format"
+#endif
+
+int
+err_set(Err err, int code, const char *fmt, ...) {
+    va_list	ap;
+
+    va_start(ap, fmt);
+    vsnprintf(err->msg, sizeof(err->msg), fmt, ap);
+    va_end(ap);
+    err->code = code;
+
+    return err->code;
+}
+
+int
+err_no(Err err, const char *fmt, ...) {
+    int	cnt = 0;
+    
+    if (NULL != fmt) {
+	va_list	ap;
+
+	va_start(ap, fmt);
+	cnt = vsnprintf(err->msg, sizeof(err->msg), fmt, ap);
+	va_end(ap);
+    }
+    if (cnt < (int)sizeof(err->msg) + 2 && 0 <= cnt) {
+	err->msg[cnt] = ' ';
+	cnt++;
+	strncpy(err->msg + cnt, strerror(errno), sizeof(err->msg) - cnt);
+	err->msg[sizeof(err->msg) - 1] = '\0';
+    }
+    err->code = errno;
+
+    return err->code;
+}
+
+void
+err_clear(Err err) {
+    err->code = ERR_OK;
+    *err->msg = '\0';
+}
+
+const char*
+err_str(ErrCode code) {
+    const char	*str = NULL;
+    
+    if (code <= ELAST) {
+	str = strerror(code);
+    }
+    if (NULL == str) {
+	switch (code) {
+	case ERR_PARSE:		str = "parse error";		break;
+	case ERR_READ:		str = "read failed";		break;
+	case ERR_WRITE:		str = "write failed";		break;
+	case ERR_ARG:		str = "invalid argument";	break;
+	case ERR_NOT_FOUND:	str = "not found";		break;
+	case ERR_THREAD:	str = "thread error";		break;
+	case ERR_NETWORK:	str = "network error";		break;
+	case ERR_LOCK:		str = "lock error";		break;
+	case ERR_FREE:		str = "already freed";		break;
+	case ERR_IN_USE:	str = "in use";			break;
+	case ERR_TOO_MANY:	str = "too many";		break;
+	case ERR_TYPE:		str = "type error";		break;
+	default:		str = "unknown error";		break;
+	}
+    }
+    return str;
+}

data/ext/agoo/err.h

@@ -0,0 +1,48 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#ifndef __AGOO_ERR_H__
+#define __AGOO_ERR_H__
+
+#include <errno.h>
+
+#ifndef ELAST
+#define ELAST 300
+#endif
+
+#define ERR_INIT	{ 0, { 0 } }
+
+typedef enum {
+    ERR_OK	= 0,
+    ERR_MEMORY	= ENOMEM,
+    ERR_DENIED	= EACCES,
+    ERR_IMPL	= ENOSYS,
+    ERR_PARSE	= ELAST + 1,
+    ERR_READ,
+    ERR_WRITE,
+    ERR_OVERFLOW,
+    ERR_ARG,
+    ERR_NOT_FOUND,
+    ERR_THREAD,
+    ERR_NETWORK,
+    ERR_LOCK,
+    ERR_FREE,
+    ERR_IN_USE,
+    ERR_TOO_MANY,
+    ERR_TYPE,
+    ERR_LAST
+} ErrCode;
+
+// The struct used to report errors or status after a function returns. The
+// struct must be initialized before use as most calls that take an err
+// argument will return immediately if an error has already occurred.
+typedef struct _Err {
+    int		code;
+    char	msg[256];
+} *Err;
+
+extern int		err_set(Err err, int code, const char *fmt, ...);
+extern int		err_no(Err err, const char *fmt, ...);
+extern const char*	err_str(ErrCode code);
+extern void		err_clear(Err err);
+
+#endif /* __AGOO_ERR_H__ */

data/ext/agoo/error_stream.c

@@ -0,0 +1,92 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#include "error_stream.h"
+#include "text.h"
+
+static VALUE	es_class = Qundef;
+
+typedef struct _ErrorStream {
+    Server	server;
+    Text	text;
+} *ErrorStream;
+
+static void
+es_free(void *ptr) {
+    ErrorStream	es = (ErrorStream)ptr;
+
+    free(es->text); // allocated with malloc
+    xfree(ptr);
+}
+
+VALUE
+error_stream_new(Server server) {
+    ErrorStream	es = ALLOC(struct _ErrorStream);
+
+    es->text = text_allocate(1024);
+    es->server = server;
+    
+    return Data_Wrap_Struct(es_class, NULL, es_free, es);
+}
+
+/* Document-method: puts
+
+ * call-seq: puts(str)
+ *
+ * Write the _str_ to the stream along with a newline character, accumulating
+ * it until _flush_ is called.
+ */
+static VALUE
+es_puts(VALUE self, VALUE str) {
+    ErrorStream	es = (ErrorStream)DATA_PTR(self);
+
+    es->text = text_append(es->text, StringValuePtr(str), RSTRING_LEN(str));
+    es->text = text_append(es->text, "\n", 1);
+
+    return Qnil;
+}
+
+/* Document-method: write
+
+ * call-seq: write(str)
+ *
+ * Write the _str_ to the stream, accumulating it until _flush_ is called.
+ */
+static VALUE
+es_write(VALUE self, VALUE str) {
+    ErrorStream	es = (ErrorStream)DATA_PTR(self);
+    int		cnt = RSTRING_LEN(str);
+    
+    es->text = text_append(es->text, StringValuePtr(str), cnt);
+
+    return INT2NUM(cnt);
+}
+
+/* Document-method: flush
+
+ * call-seq: flush()
+ *
+ * Flushs the accumulated text in the stream as an error log entry.
+ */
+static VALUE
+es_flush(VALUE self) {
+    ErrorStream	es = (ErrorStream)DATA_PTR(self);
+
+    log_cat(&es->server->error_cat, "%s", es->text->text);
+    es->text->len = 0;
+
+    return self;
+}
+
+/* Document-class: Agoo::ErrorStream
+ *
+ * Used in a reqquest as the _rack.errors_ attribute. Writing to the stream
+ * and flushing will make an error log entry.
+ */
+void
+error_stream_init(VALUE mod) {
+    es_class = rb_define_class_under(mod, "ErrorStream", rb_cObject);
+
+    rb_define_method(es_class, "puts", es_puts, 1);
+    rb_define_method(es_class, "write", es_write, 1);
+    rb_define_method(es_class, "flush", es_flush, 0);
+}

data/ext/agoo/error_stream.h

@@ -0,0 +1,13 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#ifndef __AGOO_ERROR_STREAM_H__
+#define __AGOO_ERROR_STREAM_H__
+
+#include <ruby.h>
+
+#include "server.h"
+
+extern void	error_stream_init(VALUE mod);
+extern VALUE	error_stream_new(Server server);
+
+#endif // __AGOO_ERROR_STREAM_H__

data/ext/agoo/extconf.rb

@@ -0,0 +1,13 @@
+require 'mkmf'
+require 'rbconfig'
+
+extension_name = 'agoo'
+dir_config(extension_name)
+
+$CPPFLAGS += " -DPLATFORM_LINUX" if 'x86_64-linux' == RUBY_PLATFORM
+
+create_makefile(File.join(extension_name, extension_name))
+
+puts ">>>>> Created Makefile for #{RUBY_DESCRIPTION.split(' ')[0]} version #{RUBY_VERSION} on #{RUBY_PLATFORM} <<<<<"
+
+%x{make clean}

data/ext/agoo/hook.c

@@ -0,0 +1,74 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "hook.h"
+
+Hook
+hook_create(Method method, const char *pattern, VALUE handler) {
+    Hook	hook = (Hook)malloc(sizeof(struct _Hook));
+
+    if (NULL != hook) {
+	if (NULL == pattern) {
+	    pattern = "";
+	}
+	hook->next = NULL;
+	hook->handler = handler;
+	rb_gc_register_address(&handler);
+	hook->pattern = strdup(pattern);
+	hook->method = method;
+	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;
+}
+
+void
+hook_destroy(Hook hook) {
+    free(hook->pattern);
+    free(hook);
+}
+
+bool
+hook_match(Hook hook, Method method, const char *path, const char *pend) {
+    const char	*pat = hook->pattern;
+
+    if (method != hook->method && ALL != hook->method) {
+	return false;
+    }
+    for (; '\0' != *pat && path < pend; pat++) {
+	if (*path == *pat) {
+	    path++;
+	} else if ('*' == *pat) {
+	    if ('*' == *(pat + 1)) {
+		return true;
+	    }
+	    for (; path < pend && '/' != *path; path++) {
+	    }
+	} else {
+	    break;
+	}
+    }
+    return '\0' == *pat && path == pend;
+}
+
+Hook
+hook_find(Hook hook, Method method, const char *path, const char *pend) {
+    for (; NULL != hook; hook = hook->next) {
+	if (hook_match(hook, method, path, pend)) {
+	    return hook;
+	}
+    }
+    return NULL;
+}

data/ext/agoo/hook.h

@@ -0,0 +1,33 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#ifndef __AGOO_HOOK_H__
+#define __AGOO_HOOK_H__
+
+#include <stdbool.h>
+
+#include <ruby.h>
+
+#include "types.h"
+
+typedef enum {
+    NO_HOOK	= '\0',
+    RACK_HOOK	= 'R',
+    BASE_HOOK	= 'B',
+    WAB_HOOK	= 'W',
+} HookType;
+
+typedef struct _Hook {
+    struct _Hook	*next;
+    Method		method;
+    VALUE		handler;
+    char		*pattern;
+    HookType		type;
+} *Hook;
+
+extern Hook	hook_create(Method method, const char *pattern, VALUE handler);
+extern void	hook_destroy(Hook hook);
+
+extern bool	hook_match(Hook hook, Method method, const char *path, const char *pend);
+extern Hook	hook_find(Hook hook, Method method, const char *path, const char *pend);
+
+#endif // __AGOO_HOOK_H__