agoo 2.5.5 → 2.5.6

data/ext/agoo/queue.h

@@ -3,17 +3,18 @@
 #ifndef AGOO_QUEUE_H
 #define AGOO_QUEUE_H
 
-#include <stdatomic.h>
 #include <stdbool.h>
 #include <stdlib.h>
 
-typedef void	*QItem;
+#include "atomic.h"
 
-typedef struct _Queue {
-    QItem		*q;
-    QItem		*end;
-    _Atomic(QItem*)	head;
-    _Atomic(QItem*)	tail;
+typedef void	*agooQItem;
+
+typedef struct _agooQueue {
+    agooQItem		*q;
+    agooQItem		*end;
+    _Atomic(agooQItem*)	head;
+    _Atomic(agooQItem*)	tail;
     bool		multi_push;
     bool		multi_pop;
     atomic_flag		push_lock; // set to true when push in progress
@@ -21,20 +22,20 @@ typedef struct _Queue {
     atomic_int		wait_state;
     int			rsock;
     int			wsock;
-} *Queue;
+} *agooQueue;
 
-extern void	queue_init(Queue q, size_t qsize);
+extern void		agoo_queue_init(agooQueue q, size_t qsize);
 
-extern void	queue_multi_init(Queue q, size_t qsize, bool multi_push, bool multi_pop);
+extern void		agoo_queue_multi_init(agooQueue q, size_t qsize, bool multi_push, bool multi_pop);
 
-extern void	queue_cleanup(Queue q);
-extern void	queue_push(Queue q, QItem item);
-extern QItem	queue_pop(Queue q, double timeout);
-extern bool	queue_empty(Queue q);
-extern int	queue_listen(Queue q);
-extern void	queue_release(Queue q);
-extern int	queue_count(Queue q);
+extern void		agoo_queue_cleanup(agooQueue q);
+extern void		agoo_queue_push(agooQueue q, agooQItem item);
+extern agooQItem	agoo_queue_pop(agooQueue q, double timeout);
+extern bool		agoo_queue_empty(agooQueue q);
+extern int		agoo_queue_listen(agooQueue q);
+extern void		agoo_queue_release(agooQueue q);
+extern int		agoo_queue_count(agooQueue q);
 
-extern void	queue_wakeup(Queue q);
+extern void		agoo_queue_wakeup(agooQueue q);
 
-#endif /* AGOO_QUEUE_H */
+#endif // AGOO_QUEUE_H

data/ext/agoo/rack_logger.c

@@ -15,26 +15,26 @@ rack_logger_new() {
 }
 
 static void
-log_message(LogCat cat, VALUE message) {
+log_message(agooLogCat cat, VALUE message) {
     volatile VALUE	rs = rb_funcall(message, rb_intern("to_s"), 0);
     
     rb_check_type(rs, T_STRING);
-    if (!the_server.active) {
+    if (!agoo_server.active) {
 	return;
     }
     if (rb_block_given_p()) {
-	Text		text = text_create(StringValuePtr(rs), (int)RSTRING_LEN(rs));
+	agooText	text = agoo_text_create(StringValuePtr(rs), (int)RSTRING_LEN(rs));
 	volatile VALUE	x = rb_yield_values(0);
 
 	if (Qnil != x) {
 	    rs = rb_funcall(x, rb_intern("to_s"), 0);
-	    text = text_append(text, ": ", 2);
-	    text = text_append(text, StringValuePtr(rs), (int)RSTRING_LEN(rs));
+	    text = agoo_text_append(text, ": ", 2);
+	    text = agoo_text_append(text, StringValuePtr(rs), (int)RSTRING_LEN(rs));
 	}
-	log_cat(cat, "%s", text->text);
-	text_release(text);
+	agoo_log_cat(cat, "%s", text->text);
+	agoo_text_release(text);
     } else {
-	log_cat(cat, "%s", StringValuePtr(rs));
+	agoo_log_cat(cat, "%s", StringValuePtr(rs));
     }
 }
 
@@ -46,7 +46,7 @@ log_message(LogCat cat, VALUE message) {
  */
 static VALUE
 rl_debug(VALUE self, VALUE message) {
-    log_message(&debug_cat, message);
+    log_message(&agoo_debug_cat, message);
     return Qnil;
 }
 
@@ -58,7 +58,7 @@ rl_debug(VALUE self, VALUE message) {
  */
 static VALUE
 rl_info(VALUE self, VALUE message) {
-    log_message(&info_cat, message);
+    log_message(&agoo_info_cat, message);
     return Qnil;
 }
 
@@ -70,7 +70,7 @@ rl_info(VALUE self, VALUE message) {
  */
 static VALUE
 rl_warn(VALUE self, VALUE message) {
-    log_message(&warn_cat, message);
+    log_message(&agoo_warn_cat, message);
     return Qnil;
 }
 
@@ -82,7 +82,7 @@ rl_warn(VALUE self, VALUE message) {
  */
 static VALUE
 rl_error(VALUE self, VALUE message) {
-    log_message(&error_cat, message);
+    log_message(&agoo_error_cat, message);
     return Qnil;
 }
 
@@ -94,7 +94,7 @@ rl_error(VALUE self, VALUE message) {
  */
 static VALUE
 rl_fatal(VALUE self, VALUE message) {
-    log_message(&fatal_cat, message);
+    log_message(&agoo_fatal_cat, message);
     exit(0);
     return Qnil;
 }

data/ext/agoo/ready.c

@@ -0,0 +1,357 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#if HAVE_SYS_EPOLL_H
+#include <sys/epoll.h>
+#else
+#include <ctype.h>
+#include <netdb.h>
+#include <poll.h>
+#endif
+
+#include "dtime.h"
+#include "log.h"
+#include "ready.h"
+
+#define CHECK_FREQ		0.5
+// milliseconds
+#define MAX_WAIT		10
+
+#if HAVE_SYS_EPOLL_H
+#define EPOLL_SIZE		100
+#else
+#define INITIAL_POLL_SIZE	1024
+#endif
+
+typedef struct _link {
+    struct _link	*next;
+    struct _link	*prev;
+    int			fd;
+    void		*ctx;
+    agooHandler		handler;
+#if HAVE_SYS_EPOLL_H
+    uint32_t		events; // last events set
+#else
+    struct pollfd	*pp;
+#endif
+} *Link;
+
+struct _agooReady {
+    Link	links;
+    int		lcnt;
+    double	next_check;
+#if HAVE_SYS_EPOLL_H
+    int		epoll_fd;
+#else
+    struct pollfd	*pa;
+    struct pollfd	*pend;
+#endif
+};
+
+static Link
+link_create(agooErr err, int fd, void *ctx, agooHandler handler) {
+    // TBD use block allocator
+    Link	link = (Link)malloc(sizeof(struct _link));
+
+    if (NULL == link) {
+	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a connection link.");
+    } else {
+	//DEBUG_ALLOC(mem_???, c);
+	link->next = NULL;
+	link->prev = NULL;
+	link->fd = fd;
+	link->ctx = ctx;
+	link->handler = handler;
+    }
+    return link;
+}
+
+agooReady
+agoo_ready_create(agooErr err) {
+    agooReady	ready = (agooReady)malloc(sizeof(struct _agooReady));
+
+    if (NULL == ready) {
+	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a connection manager.");
+    } else {
+	//DEBUG_ALLOC(mem_???, c);
+	ready->links = NULL;
+	ready->lcnt = 0;
+	ready->next_check = dtime() + CHECK_FREQ;
+#if HAVE_SYS_EPOLL_H
+	if (0 > (ready->epoll_fd = epoll_create(1))) {
+	    agoo_err_no(err, "epoll create failed");
+	    return NULL;
+	}
+#else
+	{
+	    size_t	size = sizeof(struct pollfd) * INITIAL_POLL_SIZE;
+
+	    ready->pa = (struct pollfd*)malloc(size);
+	    ready->pend = ready->pa + INITIAL_POLL_SIZE;
+	    memset(ready->pa, 0, size);
+	}
+#endif
+    }
+    return ready;
+}
+
+void
+agoo_ready_destroy(agooReady ready) {
+    Link	link;
+
+    while (NULL != (link = ready->links)) {
+	ready->links = link->next;
+	if (NULL != link->handler->destroy) {
+	    link->handler->destroy(link->ctx);
+	}
+	free(link);
+    }
+#if HAVE_SYS_EPOLL_H
+    close(ready->epoll_fd);
+#else
+    free(ready->pa);
+#endif
+    free(ready);
+}
+
+int
+agoo_ready_add(agooErr		err,
+	       agooReady	ready,
+	       int		fd,
+	       agooHandler	handler,
+	       void		*ctx) {
+    Link	link;
+    
+    if (NULL == (link = link_create(err, fd, ctx, handler))) {
+	return err->code;
+    }
+    link->next = ready->links;
+    if (NULL != ready->links) {
+	ready->links->prev = link;
+    }
+    ready->links = link;
+    ready->lcnt++;
+
+#if HAVE_SYS_EPOLL_H
+    link->events = EPOLLIN;
+    {
+	struct epoll_event	event = {
+	    .events = link->events,
+	    .data = {
+		.ptr = link,
+	    },
+	};
+	if (0 > epoll_ctl(ready->epoll_fd, EPOLL_CTL_ADD, fd, &event)) {
+	    agoo_err_no(err, "epoll add failed");
+	    return err->code;
+	}
+    }
+#else
+    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*)realloc(ready->pa, size))) {
+	    agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a connection pool.");
+	    agoo_log_cat(&agoo_error_cat, "Out of memory.");
+	    agoo_log_close();
+	    exit(EXIT_FAILURE);
+
+	    return err->code;
+	}
+	ready->pend = ready->pa + cnt;
+	memset(ready->pa, 0, size);
+    }
+#endif
+    return AGOO_ERR_OK;
+}
+
+static void
+ready_remove(agooReady ready, Link link) {
+    if (NULL == link->prev) {
+	ready->links = link->next;
+    } else {
+	link->prev->next = link->next;
+    }
+    if (NULL != link->next) {
+	link->next->prev = link->prev;
+    }
+#if HAVE_SYS_EPOLL_H
+    {
+	struct epoll_event	event = {
+	    .events = 0,
+	    .data = {
+		.ptr = NULL,
+	    },
+	};
+	if (0 > epoll_ctl(ready->epoll_fd, EPOLL_CTL_DEL, link->fd, &event)) {
+	    agoo_log_cat(&agoo_error_cat, "epoll delete failed. %s", strerror(errno));
+	}
+    }
+#endif
+    if (NULL != link->handler->destroy) {
+	link->handler->destroy(link->ctx);
+    }
+    //DEBUG_FREE(mem_???, c);
+    free(link);
+    ready->lcnt--;
+}
+
+int
+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;
+    int			cnt;
+
+    for (link = ready->links; NULL != link; link = link->next) {
+	struct epoll_event	event = {
+	    .events = 0,
+	    .data = {
+		.ptr = link,
+	    },
+	};
+	switch (link->handler->io(link->ctx)) {
+	case AGOO_READY_IN:
+	    event.events = EPOLLIN;
+	    break;
+	case AGOO_READY_OUT:
+	    event.events = EPOLLOUT;
+	    break;
+	case AGOO_READY_BOTH:
+	    event.events = EPOLLIN | EPOLLOUT;
+	    break;
+	case AGOO_READY_NONE:
+	default:
+	    // ignore, either dead or closing
+	    break;
+	}
+	if (event.events != link->events) {
+	    if (0 > epoll_ctl(ready->epoll_fd, EPOLL_CTL_MOD, link->fd, &event)) {
+		agoo_err_no(err, "epoll modifiy failed");
+	    }
+	    link->events = event.events;
+	}
+    }
+    if (0 > (cnt = epoll_wait(ready->epoll_fd, events, sizeof(events) / sizeof(*events), MAX_WAIT))) {
+	agoo_err_no(err, "Polling error.");
+	agoo_log_cat(&agoo_error_cat, "%s", err->msg);
+	return err->code;
+    }
+    for (ep = events; 0 < cnt; ep++, cnt--) {
+	link = (Link)ep->data.ptr;
+	if (0 != (ep->events & EPOLLIN) && NULL != link->handler->read) {
+	    if (!link->handler->read(ready, link->ctx)) {
+		ready_remove(ready, link);
+		continue;
+	    }
+	}
+	if (0 != (ep->events & EPOLLOUT && NULL != link->handler->write)) {
+	    if (!link->handler->write(link->ctx)) {
+		ready_remove(ready, link);
+		continue;
+	    }
+	}
+	if (0 != (ep->events & (EPOLLERR | EPOLLRDHUP | EPOLLHUP | EPOLLPRI))) {
+	    if (NULL != link->handler->error) {
+		link->handler->error(link->ctx);
+	    }
+	    ready_remove(ready, link);
+	    continue;
+	}
+    }
+#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;
+	pp->revents = 0;
+	link->pp = pp;
+	switch (link->handler->io(link->ctx)) {
+	case AGOO_READY_IN:
+	    pp->events = POLLIN;
+	    break;
+	case AGOO_READY_OUT:
+	    pp->events = POLLOUT;
+	    break;
+	case AGOO_READY_BOTH:
+	    pp->events = POLLIN | POLLOUT;
+	    break;
+	case AGOO_READY_NONE:
+	default:
+	    // ignore, either dead or closing
+	    pp--;
+	    break;
+	}
+    }
+    if (0 > (i = poll(ready->pa, (nfds_t)(pp - ready->pa), MAX_WAIT))) {
+	if (EAGAIN == errno) {
+	    return AGOO_ERR_OK;
+	}
+	agoo_err_no(err, "Polling error.");
+	agoo_log_cat(&agoo_error_cat, "%s", err->msg);
+	return err->code;
+    }
+    if (0 < i) {
+	for (link = ready->links; NULL != link; link = next) {
+	    next = link->next;
+	    if (NULL == link->pp) {
+		continue;
+	    }
+	    pp = link->pp;
+	    if (0 != (pp->revents & POLLIN) && NULL != link->handler->read) {
+		if (!link->handler->read(ready, link->ctx)) {
+		    ready_remove(ready, link);
+		    continue;
+		}
+	    }
+	    if (0 != (pp->revents & POLLOUT && NULL != link->handler->write)) {
+		if (!link->handler->write(link->ctx)) {
+		    ready_remove(ready, link);
+		    continue;
+		}
+	    }
+	    if (0 != (pp->revents & (POLLERR | POLLHUP | POLLNVAL))) {
+		if (NULL != link->handler->error) {
+		    link->handler->error(link->ctx);
+		}
+		ready_remove(ready, link);
+		continue;
+	    }
+	}
+    }
+#endif
+    // Periodically check the connections to see if they are dead or not.
+    now = dtime();
+    if (ready->next_check <= now) {
+	for (link = ready->links; NULL != link; link = next) {
+	    next = link->next;
+	    if (NULL != link->handler->check) {
+		if (!link->handler->check(link->ctx, now)) {
+		    ready_remove(ready, link);
+		}
+	    }
+	}
+	ready->next_check = dtime() + CHECK_FREQ;
+    }
+    return AGOO_ERR_OK;
+}
+
+void
+agoo_ready_iterate(agooReady ready, void (*cb)(void *ctx, void *arg), void *arg) {
+    Link	link;
+
+    for (link = ready->links; NULL != link; link = link->next) {
+	cb(link->ctx, arg);
+    }
+}