agoo 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 875dd13c45030ea940c3afe58571a260f6220ff8f09ed3fd1084957e0efa3586
+  data.tar.gz: d8efe96974e9299d1627373cc31be42f93b7bed3eb00c7593c32b8aa9fe954cb
+SHA512:
+  metadata.gz: b66d7a3f8265fab7f84c9a78894401950adcbd7a55df412ab7ff92bc497ff825777498cf58ff1a0e3ba0b168aecec597da823ac61455f57b4f9d26ef32e1264b
+  data.tar.gz: d82ea3f18c07459186e64a8db4fda82e07bdb55e7506a031eebeb628c05e458eb4507fb531144fd1559f39c5543d0569a9fdc9738df47110ed4edf68045c1c83

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Peter Ohler
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,61 @@
+# agoo
+
+[![Build Status](https://img.shields.io/travis/ohler55/agoo/master.svg)](http://travis-ci.org/ohler55/agoo?branch=master)
+
+A High Performance HTTP Server for Ruby
+
+## Usage
+
+```ruby
+require 'agoo'
+
+server = Agoo::Server.new(6464, 'root')
+
+class MyHandler
+  def initialize
+  end
+
+  def call(req)
+    [ 200, { }, [ "hello world" ] ]
+  end
+end
+
+handler = TellMeHandler.new
+server.handle(:GET, "/hello", handler)
+server.start()
+```
+
+## Installation
+```
+gem install agoo
+```
+
+## What Is This?
+
+Agoo is Japanese for a type of flying fish. This gem flies. It is a high
+performance HTTP server that serves static resource at hundreds of thousands
+of fetchs per second. A a simple hello world Ruby handler at over 100,000
+requests per second on a desktop computer. That places Agoo at about 80 times
+faster than Sinatra and 1000 times faster than Rails. In both cases the
+latency was an order of magnitude lower or more. Checkout the benchmarks on <a
+href="http://opo.technology/benchmarks.html#web_benchmarks">OpO
+benchmarks</a>. Note that the benchmarks had to use a C program called _hose_
+from the <a href="http://opo.technology/index.html">OpO</a> downloads to hit
+the Agoo limits. Ruby benchmarks driver could not push Agoo hard enough.
+
+Agoo supports the [Ruby rack API](https://rack.github.io) which allows for the
+use of rack compatible gems.
+
+## Releases
+
+See [{file:CHANGELOG.md}](CHANGELOG.md)
+
+## Links
+
+ - *Documentation*: http://rubydoc.info/gems/agoo
+
+ - *GitHub* *repo*: https://github.com/ohler55/agoo
+
+ - *RubyGems* *repo*: https://rubygems.org/gems/agoo
+
+Follow [@peterohler on Twitter](http://twitter.com/#!/peterohler) for announcements and news about the Agoo gem.

data/ext/agoo/agoo.c

@@ -0,0 +1,19 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#include <stdio.h>
+#include <ruby.h>
+
+#include "error_stream.h"
+#include "request.h"
+#include "response.h"
+#include "server.h"
+
+void
+Init_agoo() {
+    VALUE	mod = rb_define_module("Agoo");
+
+    error_stream_init(mod);
+    request_init(mod);
+    response_init(mod);
+    server_init(mod);
+}

data/ext/agoo/con.c

@@ -0,0 +1,515 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#include <ctype.h>
+#include <string.h>
+
+#include "con.h"
+#include "dtime.h"
+#include "hook.h"
+#include "http.h"
+#include "res.h"
+#include "server.h"
+
+#define MAX_SOCK	4096
+#define CON_TIMEOUT	5.0
+
+Con
+con_create(Err err, Server server, int sock, uint64_t id) {
+    Con	c;
+
+    if (MAX_SOCK <= sock) {
+	err_set(err, ERR_TOO_MANY, "Too many connections.");
+	return NULL;
+    }
+    if (NULL == (c = (Con)malloc(sizeof(struct _Con)))) {
+	err_set(err, ERR_MEMORY, "Failed to allocate memory for a connection.");
+    } else {
+	memset(c, 0, sizeof(struct _Con));
+	c->sock = sock;
+	c->iid = id;
+	sprintf(c->id, "%llu", (unsigned long long)id);
+	c->server = server;
+    }
+    return c;
+}
+
+void
+con_destroy(Con c) {
+    if (0 < c->sock) {
+	close(c->sock);
+	c->sock = 0;
+    }
+    if (NULL != c->req) {
+	free(c->req);
+    }
+    free(c);
+}
+
+const char*
+con_header_value(const char *header, int hlen, const char *key, int *vlen) {
+    // Search for \r then check for \n and then the key followed by a :. Keep
+    // trying until the end of the header.
+    const char	*h = header;
+    const char	*hend = header + hlen;
+    const char	*value;
+    int		klen = strlen(key);
+    
+    while (h < hend) {
+	if (0 == strncmp(key, h, klen) && ':' == h[klen]) {
+	    h += klen + 1;
+	    for (; ' ' == *h; h++) {
+	    }
+	    value = h;
+	    for (; '\r' != *h && '\0' != *h; h++) {
+	    }
+	    *vlen = h - value;
+
+	    return value;
+	}
+	for (; h < hend; h++) {
+	    if ('\r' == *h && '\n' == *(h + 1)) {
+		h += 2;
+		break;
+	    }
+	}
+    }
+    return NULL;
+}
+
+static bool
+bad_request(Con c, int status, int line) {
+    Res		res;
+    const char *msg = http_code_message(status);
+    
+    if (NULL == (res = res_create())) {
+	log_cat(&c->server->error_cat, "memory allocation of response failed on connection %llu @ %d.", c->iid, line);
+    } else {
+	char	buf[256];
+	int	cnt = snprintf(buf, sizeof(buf), "HTTP/1.1 %d %s\r\nConnection: Close\r\nContent-Length: 0\r\n\r\n", status, msg);
+	Text	message = text_create(buf, cnt);
+	
+	if (NULL == c->res_tail) {
+	    c->res_head = res;
+	} else {
+	    c->res_tail->next = res;
+	}
+	c->res_tail = res;
+	res->close = true;
+	res_set_message(res, message);
+    }
+    return true;
+}
+
+static bool
+should_close(const char *header, int hlen) {
+    const char	*v;
+    int		vlen = 0;
+    
+    if (NULL != (v = con_header_value(header, hlen, "Connection", &vlen))) {
+	return (5 == vlen && 0 == strncasecmp("Close", v, 5));
+    }
+    return false;
+}
+
+// Returns true if request has handled.
+static bool
+con_header_read(Con c) {
+    Server	server = c->server;
+    char	*hend = strstr(c->buf, "\r\n\r\n");
+    Method	method;
+    char	*path;
+    char	*pend;
+    char	*query = NULL;
+    char	*qend;
+    char	*b;
+    size_t	clen = 0;
+    size_t	mlen;
+    Hook	hook = NULL;
+
+    if (NULL == hend) {
+	if (sizeof(c->buf) - 1 <= c->bcnt) {
+	    return bad_request(c, 431, __LINE__);
+	}
+	return false;
+    }
+    if (server->req_cat.on) {
+	*hend = '\0';
+	log_cat(&server->req_cat, "%llu: %s", c->iid, c->buf);
+	*hend = '\r';
+    }
+    for (b = c->buf; ' ' != *b; b++) {
+	if ('\0' == *b) {
+	    return bad_request(c, 400, __LINE__);
+	}
+    }
+    switch (toupper(*c->buf)) {
+    case 'G':
+	if (3 != b - c->buf || 0 != strncmp("GET", c->buf, 3)) {
+	    return bad_request(c, 400, __LINE__);
+	}
+	method = GET;
+	break;
+    case 'P': {
+	const char	*v;
+	int		vlen = 0;
+	char		*vend;
+	
+	if (3 == b - c->buf && 0 == strncmp("PUT", c->buf, 3)) {
+	    method = PUT;
+	} else if (4 == b - c->buf && 0 == strncmp("POST", c->buf, 4)) {
+	    method = POST;
+	} else {
+	    return bad_request(c, 400, __LINE__);
+	}
+	if (NULL == (v = con_header_value(c->buf, hend - c->buf, "Content-Length", &vlen))) {
+	    return bad_request(c, 411, __LINE__);
+	}
+	clen = (size_t)strtoul(v, &vend, 10);
+	if (vend != v + vlen) {
+	    return bad_request(c, 411, __LINE__);
+	}
+	break;
+    }
+    case 'D':
+	if (6 != b - c->buf || 0 != strncmp("DELETE", c->buf, 6)) {
+	    return bad_request(c, 400, __LINE__);
+	}
+	method = DELETE;
+	break;
+    case 'H':
+	if (4 != b - c->buf || 0 != strncmp("HEAD", c->buf, 4)) {
+	    return bad_request(c, 400, __LINE__);
+	}
+	method = HEAD;
+	break;
+    case 'O':
+	if (7 != b - c->buf || 0 != strncmp("OPTIONS", c->buf, 7)) {
+	    return bad_request(c, 400, __LINE__);
+	}
+	method = OPTIONS;
+	break;
+    case 'C':
+	if (7 != b - c->buf || 0 != strncmp("CONNECT", c->buf, 7)) {
+	    return bad_request(c, 400, __LINE__);
+	}
+	method = CONNECT;
+	break;
+    default:
+	return bad_request(c, 400, __LINE__);
+    }
+    for (; ' ' == *b; b++) {
+	if ('\0' == *b) {
+	    return bad_request(c, 400, __LINE__);
+	}
+    }
+    path = b;
+    for (; ' ' != *b; b++) {
+	switch (*b) {
+	case '?':
+	    pend = b;
+	    query = b + 1;
+	    break;
+	case '\0':
+	    return bad_request(c, 400, __LINE__);
+	default:
+	    break;
+	}
+    }
+    if (NULL == query) {
+	pend = b;
+	query = b;
+	qend = b;
+    } else {
+	qend = b;
+    }
+    if (NULL == (hook = hook_find(server->hooks, method, path, pend))) {
+	if (GET == method) {
+	    struct _Err	err = ERR_INIT;
+	    Page	p = page_get(&err, &server->pages, server->root, path, pend - path);
+	    Res		res;
+
+	    if (NULL == p) {
+		return bad_request(c, 404, __LINE__);
+	    }
+    	    if (NULL == (res = res_create())) {
+		return bad_request(c, 500, __LINE__);
+	    }
+	    if (NULL == c->res_tail) {
+		c->res_head = res;
+	    } else {
+		c->res_tail->next = res;
+	    }
+	    c->res_tail = res;
+
+	    b = strstr(c->buf, "\r\n");
+	    res->close = should_close(b, hend - b);
+
+	    text_ref(p->resp);
+	    res_set_message(res, p->resp);
+
+	    return true;
+	}
+    }
+    // Create request and populate.
+    mlen = hend - c->buf + 4 + clen;
+    if (NULL == (c->req = (Req)malloc(mlen + sizeof(struct _Req) - 8 + 1))) {
+	return bad_request(c, 413, __LINE__);
+    }
+    memcpy(c->req->msg, c->buf, c->bcnt);
+    if (c->bcnt < mlen) {
+	memset(c->req->msg + c->bcnt, 0, mlen - c->bcnt);
+    }
+    c->req->server = server;
+    c->req->method = method;
+    c->req->path.start = c->req->msg + (path - c->buf);
+    c->req->path.len = pend - path;
+    c->req->query.start = c->req->msg + (query - c->buf);
+    c->req->query.len = qend - query;
+    c->req->mlen = mlen;
+    c->req->body.start = c->req->msg + (hend - c->buf + 4);
+    c->req->body.len = clen;
+    b = strstr(b, "\r\n");
+    c->req->header.start = c->req->msg + (b + 2 - c->buf);
+    c->req->header.len = hend - b - 2;
+    c->req->res = NULL;
+    if (NULL != hook) {
+	c->req->handler = hook->handler;
+	c->req->handler_type = hook->type;
+    } else {
+	c->req->handler = Qnil;
+	c->req->handler_type = NO_HOOK;
+    }
+    return false;
+}
+
+// return true to remove/close connection
+static bool
+con_read(Con c) {
+    ssize_t	cnt;
+
+    if (NULL != c->req) {
+	cnt = recv(c->sock, c->req->msg + c->bcnt, c->req->mlen - c->bcnt, 0);
+    } else {
+	cnt = recv(c->sock, c->buf + c->bcnt, sizeof(c->buf) - c->bcnt - 1, 0);
+    }
+    c->timeout = dtime() + CON_TIMEOUT;
+    if (0 >= cnt) {
+	// If nothing read then no need to complain. Just close.
+	if (0 < c->bcnt) {
+	    if (0 == cnt) {
+		log_cat(&c->server->warn_cat, "Nothing to read. Client closed socket %s.", c->id);
+	    } else {
+		log_cat(&c->server->warn_cat, "Failed to read request. %s.", strerror(errno));
+	    }
+	}
+	return true;
+    }
+    c->bcnt += cnt;
+    // Terminate with \0 for debug and strstr() check
+    if (NULL == c->req) {
+	c->buf[c->bcnt] = '\0';
+	if (con_header_read(c)) { // already handled
+	    c->bcnt = 0;
+	    *c->buf = '\0';
+	    // TBD handle extra data in buf
+
+	    return false;
+	}
+    }
+    if (NULL != c->req) {
+	c->req->msg[c->bcnt] = '\0';
+	if (c->req->mlen <= c->bcnt) {
+	    Res	res;
+
+	    if (c->server->debug_cat.on && NULL != c->req && NULL != c->req->body.start) {
+		log_cat(&c->server->debug_cat, "request on %llu: %s", c->iid, c->req->body.start);
+	    }
+	    if (NULL == (res = res_create())) {
+		c->req = NULL;
+		log_cat(&c->server->error_cat, "memory allocation of response failed on connection %llu.", c->iid);
+		return bad_request(c, 500, __LINE__);
+	    } else {
+		if (NULL == c->res_tail) {
+		    c->res_head = res;
+		} else {
+		    c->res_tail->next = res;
+		}
+		c->res_tail = res;
+		res->close = should_close(c->req->header.start, c->req->header.len);
+	    }
+	    c->req->res = res;
+	    queue_push(&c->server->eval_queue, (void*)c->req);
+	    c->req = NULL;
+	    c->bcnt = 0;
+	    *c->buf = '\0';
+	    // TBD handle extra data in buf
+
+	    return false;
+	}
+    }
+    return false;
+}
+
+// return true to remove/close connection
+static bool
+con_write(Con c) {
+    Text	message = res_message(c->res_head);
+    ssize_t	cnt;
+
+    c->timeout = dtime() + CON_TIMEOUT;
+    if (0 == c->wcnt) {
+	if (c->server->resp_cat.on) {
+	    char	buf[4096];
+	    char	*hend = strstr(message->text, "\r\n\r\n");
+
+	    if (NULL == hend) {
+		hend = message->text + message->len;
+	    }
+	    memcpy(buf, message->text, hend - message->text);
+	    log_cat(&c->server->resp_cat, "%llu: %s", c->iid, buf);
+	}
+	if (c->server->debug_cat.on) {
+	    log_cat(&c->server->debug_cat, "response on %llu: %s", c->iid, message->text);
+	}
+    }
+    if (0 > (cnt = send(c->sock, message->text + c->wcnt, message->len - c->wcnt, 0))) {
+	if (EAGAIN == errno) {
+	    return false;
+	}
+	log_cat(&c->server->error_cat, "Socket error @ %llu.", c->iid);
+
+	return true;
+    }
+    c->wcnt += cnt;
+    if (c->wcnt == message->len) { // finished
+	Res	res = c->res_head;
+	bool	done = res->close;
+	
+	c->res_head = res->next;
+	if (res == c->res_tail) {
+	    c->res_tail = NULL;
+	}
+	c->wcnt = 0;
+	res_destroy(res);
+
+	return done;
+    }
+    return false;
+}
+
+void*
+con_loop(void *x) {
+    Server		server = (Server)x;
+    Con			c;
+    Con			ca[MAX_SOCK];
+    struct pollfd	pa[MAX_SOCK];
+    struct pollfd	*pp;
+    Con			*end = ca + MAX_SOCK;
+    Con			*cp;
+    int			ccnt = 0;
+    int			i;
+    long		mcnt = 0;
+    double		now;
+    
+    atomic_fetch_add(&server->running, 1);
+    memset(ca, 0, sizeof(ca));
+    memset(pa, 0, sizeof(pa));
+    while (server->active) {
+	while (NULL != (c = (Con)queue_pop(&server->con_queue, 0.0))) {
+	    mcnt++;
+	    ca[c->sock] = c;
+	    ccnt++;
+	}
+	pp = pa;
+	pp->fd = queue_listen(&server->con_queue);
+	pp->events = POLLIN;
+	pp->revents = 0;
+	pp++;
+	for (i = ccnt, cp = ca; 0 < i && cp < end; cp++) {
+	    if (NULL == *cp) {
+		continue;
+	    }
+	    c = *cp;
+	    c->pp = pp;
+	    pp->fd = c->sock;
+	    if (NULL != c->res_head && NULL != res_message(c->res_head)) {
+		pp->events = POLLIN | POLLOUT;
+	    } else {
+		pp->events = POLLIN;
+	    }
+	    pp->revents = 0;
+	    i--;
+	    pp++;
+	}
+	if (0 > (i = poll(pa, pp - pa, 100))) {
+	    if (EAGAIN == errno) {
+		continue;
+	    }
+	    log_cat(&server->error_cat, "Polling error. %s.", strerror(errno));
+	    // Either a signal or something bad like out of memory. Might as well exit.
+	    break;
+	}
+	now = dtime();
+
+	if (0 == i) { // nothing to read or write
+	    // TBD check for cons to close
+	    continue;
+	}
+	if (0 != (pa->revents & POLLIN)) {
+	    queue_release(&server->con_queue);
+	    while (NULL != (c = (Con)queue_pop(&server->con_queue, 0.0))) {
+		mcnt++;
+		ca[c->sock] = c;
+		ccnt++;
+	    }
+	}
+	for (i = ccnt, cp = ca; 0 < i && cp < end; cp++) {
+	    if (NULL == *cp || 0 == (*cp)->sock || NULL == (*cp)->pp) {
+		continue;
+	    }
+	    c = *cp;
+	    i--;
+	    pp = c->pp;
+	    if (0 != (pp->revents & POLLIN)) {
+		if (con_read(c)) {
+		    goto CON_RM;
+		}
+	    }
+	    if (0 != (pp->revents & POLLOUT)) {
+		if (con_write(c)) {
+		    goto CON_RM;
+		}
+	    }
+	    if (0 != (pp->revents & (POLLERR | POLLHUP | POLLNVAL))) {
+		if (0 < c->bcnt) {
+		    if (0 != (pp->revents & (POLLHUP | POLLNVAL))) {
+			log_cat(&server->error_cat, "Socket %llu closed.", c->iid);
+		    } else if (!c->closing) {
+			log_cat(&server->error_cat, "Socket %llu error. %s", c->iid, strerror(errno));
+		    }
+		}
+		goto CON_RM;
+	    }
+	    if (0.0 == c->timeout || now < c->timeout) { 
+		continue;
+	    } else if (c->closing) {
+		goto CON_RM;
+	    } else {
+		c->closing = true;
+		c->timeout = now + 0.5;
+		//wush_text_set(&c->resp, (char*)close_resp, sizeof(close_resp) - 1, false);
+		continue;
+	    }
+	    continue;
+	CON_RM:
+	    ca[c->sock] = NULL;
+	    ccnt--;
+	    log_cat(&server->con_cat, "Connection %llu closed.", c->iid);
+	    con_destroy(c);
+	}
+    }
+    atomic_fetch_sub(&server->running, 1);
+    
+    return NULL;
+}
+