agoo 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec0e1021cff3ef520275f242403861641910567fddf30d07d0df0f4d456e2d1f
-  data.tar.gz: 7a6058474e50a04e1e068cf4911762079d9a7ec0777087914b1a40faf61b2ff6
+  metadata.gz: 6e35f7871e0927d3f8f560b3d9b529507ae392867aca53a9665c275a627070d5
+  data.tar.gz: 79a0b47f55c6b823844cf4e1679a068b0329ac407f9495bb1b5e6c3ad1b4f8de
 SHA512:
-  metadata.gz: 03fa2278f4a6b70d1495577086ed15015f70ab7600a46dc02d6d4e91d996bfdcc1e818217a9043b83d3490c637ab53859402dead80524ea2bf0319812a536c2a
-  data.tar.gz: 2517add46e2130c993aee42e69fddc05b27b62d6582217c6f6f24cae585c53051536b9bca1b914e900deba6963dd2f70a53496a77993a7310308774e797149c5
+  metadata.gz: 1916a0a04b117d76f366d0f11cf105f5245e0e20b07cd1032a9dec29c03845e490a988405946397f229fd85aba9bf3720f68fc91f07ce21e1c8079991c0ffbaf
+  data.tar.gz: 87a2b7e8345f1e8a0876f076121ae92a8659c8a8360d55a259edf037dc0e626b978567f167ba5d3702bfe426e60a6ebeb5560a6809a1253069f0d55ec851b481

data/README.md

@@ -2,6 +2,7 @@
 
 [![Build Status](https://img.shields.io/travis/ohler55/agoo/master.svg)](http://travis-ci.org/ohler55/agoo?branch=master)
 [![Gem Version](https://badge.fury.io/rb/agoo.svg)](https://badge.fury.io/rb/agoo)
+![Gem](https://img.shields.io/gem/dt/agoo.svg)
 
 A High Performance HTTP Server for Ruby
 
@@ -49,7 +50,10 @@ use of rack compatible gems.
 
 ## Releases
 
-See [{file:CHANGELOG.md}](CHANGELOG.md)
+See [file:CHANGELOG.md](CHANGELOG.md)
+
+Releases are made from the master branch. The default branch for checkout is
+the develop branch. Pull requests should be made against the develop branch.
 
 ## Links
 
@@ -59,4 +63,6 @@ See [{file:CHANGELOG.md}](CHANGELOG.md)
 
  - *RubyGems* *repo*: https://rubygems.org/gems/agoo
 
+ - *WABuR* *repo*: https://github.com/ohler55/wabur has an option to use Agoo
+
 Follow [@peterohler on Twitter](http://twitter.com/#!/peterohler) for announcements and news about the Agoo gem.

data/ext/agoo/agoo.c

@@ -4,15 +4,22 @@
 #include <ruby.h>
 
 #include "error_stream.h"
+#include "rack_logger.h"
 #include "request.h"
 #include "response.h"
 #include "server.h"
 
+/* Document-module: Agoo
+ *
+ * A High Performance HTTP Server that supports the Ruby rack API. The word
+ * agoo is a Japanese word for a type of flying fish.
+ */
 void
 Init_agoo() {
     VALUE	mod = rb_define_module("Agoo");
 
     error_stream_init(mod);
+    rack_logger_init(mod);
     request_init(mod);
     response_init(mod);
     server_init(mod);

data/ext/agoo/page.c

@@ -5,6 +5,8 @@
 #include <stdlib.h>
 #include <sys/stat.h>
 
+#include <ruby.h>
+
 #include "dtime.h"
 #include "page.h"
 
@@ -16,25 +18,51 @@ typedef struct _Mime {
     const char	*type;
 } *Mime;
 
+// These are used for the initial load.
 static struct _Mime	mime_map[] = {
+    { "asc", "text/plain" },
+    { "avi", "video/x-msvideo" },
+    { "bin", "application/octet-stream" },
+    { "bmp", "image/bmp" },
+    { "cer", "application/pkix-cert" },
+    { "crl", "application/pkix-crl" },
+    { "crt", "application/x-x509-ca-cert" },
     { "css", "text/css" },
+    { "doc", "application/msword" },
     { "eot", "application/vnd.ms-fontobject" },
+    { "eps", "application/postscript" },
     { "es5", "application/javascript" },
     { "es6", "application/javascript" },
     { "gif", "image/gif" },
+    { "htm", "text/html" },
     { "html", "text/html" },
     { "ico", "image/x-icon" },
     { "jpeg", "image/jpeg" },
     { "jpg", "image/jpeg" },
     { "js", "application/javascript" },
     { "json", "application/json" },
+    { "mov", "video/quicktime" },
+    { "mpe", "video/mpeg" },
+    { "mpeg", "video/mpeg" },
+    { "mpg", "video/mpeg" },
+    { "pdf", "application/pdf" },
     { "png", "image/png" },
+    { "ppt", "application/vnd.ms-powerpoint" },
+    { "ps", "application/postscript" },
+    { "qt", "video/quicktime" },
+    { "rb", "text/plain" },
+    { "rtf", "application/rtf" },
     { "sse", "text/plain" },
     { "svg", "image/svg+xml" },
+    { "tif", "image/tiff" },
+    { "tiff", "image/tiff" },
     { "ttf", "application/font-sfnt" },
     { "txt", "text/plain" },
     { "woff", "application/font-woff" },
     { "woff2", "font/woff2" },
+    { "xls", "application/vnd.ms-excel" },
+    { "xml", "application/xml" },
+    { "zip", "application/zip" },
     { NULL, NULL }
 };
 
@@ -72,25 +100,28 @@ get_bucketp(Cache cache, uint64_t h) {
     return cache->buckets + (PAGE_BUCKET_MASK & (h ^ (h << 5) ^ (h >> 7)));
 }
 
-void
-cache_init(Cache cache) {
-    memset(cache, 0, sizeof(struct _Cache));
+static MimeSlot*
+get_mime_bucketp(Cache cache, uint64_t h) {
+    return cache->muckets + (MIME_BUCKET_MASK & (h ^ (h << 5) ^ (h >> 7)));
 }
 
-void
-cache_destroy(Cache cache) {
-    Slot	*sp = cache->buckets;
-    Slot	s;
-    Slot	n;
+const char*
+mime_get(Cache cache, const char *key) {
+    int		klen = (int)strlen(key);
+    int		len = klen;
+    int64_t	h = calc_hash(key, &len);
+    MimeSlot	*bucket = get_mime_bucketp(cache, h);
+    MimeSlot	s;
+    const char	*v = NULL;
 
-    for (int i = PAGE_BUCKET_SIZE; 0 < i; i--, sp++) {
-	for (s = *sp; NULL != s; s = n) {
-	    n = s->next;
-	    free(s);
+    for (s = *bucket; NULL != s; s = s->next) {
+	if (h == (int64_t)s->hash && len == (int)s->klen &&
+	    ((0 <= len && len <= MAX_KEY_UNIQ) || 0 == strncmp(s->key, key, klen))) {
+	    v = s->value;
+	    break;
 	}
-	*sp = NULL;
     }
-    free(cache);
+    return v;
 }
 
 Page
@@ -111,7 +142,44 @@ cache_get(Cache cache, const char *key, int klen) {
     return v;
 }
 
-Page
+void
+mime_set(Cache cache, const char *key, const char *value) {
+    int		klen = (int)strlen(key);
+    int		len = klen;
+    int64_t	h = calc_hash(key, &len);
+    MimeSlot	*bucket = get_mime_bucketp(cache, h);
+    MimeSlot	s;
+    
+    if (MAX_MIME_KEY_LEN < len) {
+	rb_raise(rb_eArgError, "%s is too long for a file extension. Maximum is %d", key, MAX_MIME_KEY_LEN);
+    }
+    for (s = *bucket; NULL != s; s = s->next) {
+	if (h == (int64_t)s->hash && len == s->klen &&
+	    ((0 <= len && len <= MAX_KEY_UNIQ) || 0 == strcmp(s->key, key))) {
+	    if (h == (int64_t)s->hash && len == s->klen &&
+		((0 <= len && len <= MAX_KEY_UNIQ) || 0 == strcmp(s->key, key))) {
+		free(s->value);
+		s->value = strdup(value);
+		return;
+	    }
+	}
+    }
+    if (NULL == (s = (MimeSlot)malloc(sizeof(struct _MimeSlot)))) {
+	rb_raise(rb_eArgError, "out of memory adding %s", key);
+    }
+    s->hash = h;
+    s->klen = len;
+    if (NULL == key) {
+	*s->key = '\0';
+    } else {
+	strcpy(s->key, key);
+    }
+    s->value = strdup(value);
+    s->next = *bucket;
+    *bucket = s;
+}
+
+static Page
 cache_set(Cache cache, const char *key, int klen, Page value) {
     int		len = klen;
     int64_t	h = calc_hash(key, &len);
@@ -152,6 +220,44 @@ cache_set(Cache cache, const char *key, int klen, Page value) {
     return old;
 }
 
+void
+cache_init(Cache cache) {
+    Mime	m;
+
+    memset(cache, 0, sizeof(struct _Cache));
+    for (m = mime_map; NULL != m->suffix; m++) {
+	mime_set(cache, m->suffix, m->type);
+    }
+}
+
+void
+cache_destroy(Cache cache) {
+    Slot	*sp = cache->buckets;
+    Slot	s;
+    Slot	n;
+    MimeSlot	*mp = cache->muckets;
+    MimeSlot	sm;
+    MimeSlot	m;
+    int		i;
+
+    for (i = PAGE_BUCKET_SIZE; 0 < i; i--, sp++) {
+	for (s = *sp; NULL != s; s = n) {
+	    n = s->next;
+	    free(s);
+	}
+	*sp = NULL;
+    }
+
+    for (i = MIME_BUCKET_SIZE; 0 < i; i--, mp++) {
+	for (sm = *mp; NULL != sm; sm = m) {
+	    m = sm->next;
+	    free(sm);
+	}
+	*mp = NULL;
+    }
+    free(cache);
+}
+
 // The page resp contents point to the page resp msg to save memory and reduce
 // allocations.
 Page
@@ -182,7 +288,7 @@ page_destroy(Page p) {
 }
 
 static bool
-update_contents(Page p) {
+update_contents(Cache cache, Page p) {
     const char	*mime = NULL;
     int		plen = (int)strlen(p->path);
     const char	*suffix = p->path + plen - 1;
@@ -201,18 +307,9 @@ update_contents(Page p) {
 	}
     }
     if (NULL != suffix) {
-	Mime	m;
-
 	suffix++;
-	for (m = mime_map; NULL != m->suffix; m++) {
-	    if (0 == strcasecmp(m->suffix, suffix)) {
-		break;
-	    }
-	}
-	if (NULL == m) {
+	if (NULL == (mime = mime_get(cache, suffix))) {
 	    mime = "text/plain";
-	} else {
-	    mime = m->type;
 	}
     } else {
 	mime = "text/plain";
@@ -313,7 +410,7 @@ page_get(Err err, Cache cache, const char *dir, const char *path, int plen) {
 	    err_set(err, ERR_MEMORY, "Failed to allocate memory for Page.");
 	    return NULL;
 	}
-	if (!update_contents(page) || NULL == page->resp) {
+	if (!update_contents(cache, page) || NULL == page->resp) {
 	    page_destroy(page);
 	    err_set(err, ERR_NOT_FOUND, "not found.");
 	    return NULL;
@@ -328,7 +425,7 @@ page_get(Err err, Cache cache, const char *dir, const char *path, int plen) {
 	    struct stat	fattr;
 
 	    if (0 == stat(page->path, &fattr) && page->mtime != fattr.st_mtime) {
-		update_contents(page);
+		update_contents(cache, page);
 		if (NULL == page->resp) {
 		    page_destroy(page);
 		    err_set(err, ERR_NOT_FOUND, "not found.");

data/ext/agoo/page.h

@@ -13,6 +13,10 @@
 #define PAGE_BUCKET_SIZE	1024
 #define PAGE_BUCKET_MASK	1023
 
+#define MAX_MIME_KEY_LEN	15
+#define MIME_BUCKET_SIZE	64
+#define MIME_BUCKET_MASK	63
+
 typedef struct _Page {
     Text		resp;
     char		*path;
@@ -28,12 +32,22 @@ typedef struct _Slot {
     int			klen;
 } *Slot;
 
+typedef struct _MimeSlot {
+    struct _MimeSlot	*next;
+    char		key[MAX_MIME_KEY_LEN + 1];
+    char		*value;
+    uint64_t		hash;
+    int			klen;
+} *MimeSlot;
+
 typedef struct _Cache {
     Slot		buckets[PAGE_BUCKET_SIZE];
+    MimeSlot		muckets[MIME_BUCKET_SIZE];
 } *Cache;
 
 extern void	cache_init(Cache cache);
 extern void	page_destroy(Page p);
 extern Page	page_get(Err err, Cache cache, const char *dir, const char *path, int plen);
+extern void	mime_set(Cache cache, const char *key, const char *value);
 
 #endif /* __AGOO_PAGE_H__ */

data/ext/agoo/rack_logger.c

@@ -0,0 +1,162 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#include <stdlib.h>
+
+#include "rack_logger.h"
+#include "log.h"
+#include "text.h"
+
+static VALUE	rl_class = Qundef;
+
+typedef struct _RackLogger {
+    Server	server;
+} *RackLogger;
+
+VALUE
+rack_logger_new(Server server) {
+    RackLogger	rl = ALLOC(struct _RackLogger);
+
+    rl->server = server;
+    
+    return Data_Wrap_Struct(rl_class, NULL, xfree, rl);
+}
+
+static void
+log_message(RackLogger rl, LogLevel level, VALUE message) {
+    volatile VALUE	rs = rb_funcall(message, rb_intern("to_s"), 0);
+    
+    rb_check_type(rs, T_STRING);
+
+    if (rb_block_given_p()) {
+	Text		text = 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));
+	}
+	switch (level) {
+	case FATAL:
+	    log_cat(&rl->server->error_cat, "%s", text->text);
+	    exit(0);
+	    break;
+	case ERROR:
+	    log_cat(&rl->server->error_cat, "%s", text->text);
+	    break;
+	case WARN:
+	    log_cat(&rl->server->warn_cat, "%s", text->text);
+	    break;
+	case INFO:
+	    log_cat(&rl->server->info_cat, "%s", text->text);
+	    break;
+	case DEBUG:
+	    log_cat(&rl->server->debug_cat, "%s", text->text);
+	    break;
+	default:
+	    break;
+	}
+	text_release(text);
+    } else {
+	switch (level) {
+	case FATAL:
+	    log_cat(&rl->server->error_cat, "%s", StringValuePtr(rs));
+	    exit(0);
+	    break;
+	case ERROR:
+	    log_cat(&rl->server->error_cat, "%s", StringValuePtr(rs));
+	    break;
+	case WARN:
+	    log_cat(&rl->server->warn_cat, "%s", StringValuePtr(rs));
+	    break;
+	case INFO:
+	    log_cat(&rl->server->info_cat, "%s", StringValuePtr(rs));
+	    break;
+	case DEBUG:
+	    log_cat(&rl->server->debug_cat, "%s", StringValuePtr(rs));
+	    break;
+	default:
+	    break;
+	}
+    }
+}
+    
+/* Document-method: debug
+ *
+ * call-seq: debug(message, &block)
+ *
+ * Calls the Server#debug method.
+ */
+static VALUE
+rl_debug(VALUE self, VALUE message) {
+    log_message((RackLogger)DATA_PTR(self), DEBUG, message);
+
+    return Qnil;
+}
+
+/* Document-method: info
+ *
+ * call-seq: info(message, &block)
+ *
+ * Calls the Server#info method.
+ */
+static VALUE
+rl_info(VALUE self, VALUE message) {
+    log_message((RackLogger)DATA_PTR(self), INFO, message);
+
+    return Qnil;
+}
+
+/* Document-method: warn
+ *
+ * call-seq: warn(message, &block)
+ *
+ * Calls the Server#warn method.
+ */
+static VALUE
+rl_warn(VALUE self, VALUE message) {
+    log_message((RackLogger)DATA_PTR(self), WARN, message);
+
+    return Qnil;
+}
+
+/* Document-method: error
+ *
+ * call-seq: error(message, &block)
+ *
+ * Calls the Server#error method.
+ */
+static VALUE
+rl_error(VALUE self, VALUE message) {
+    log_message((RackLogger)DATA_PTR(self), ERROR, message);
+
+    return Qnil;
+}
+
+/* Document-method: fatal
+ *
+ * call-seq: fatal(message, &block)
+ *
+ * Calls the Server#fatal method.
+ */
+static VALUE
+rl_fatal(VALUE self, VALUE message) {
+    log_message((RackLogger)DATA_PTR(self), FATAL, message);
+
+    return Qnil;
+}
+
+/* Document-class: Agoo::RackLogger
+ *
+ * Used in a request as the _rack.logger_ attribute.
+ */
+void
+rack_logger_init(VALUE mod) {
+    rl_class = rb_define_class_under(mod, "RackLogger", rb_cObject);
+
+    rb_define_method(rl_class, "debug", rl_debug, 1);
+    rb_define_method(rl_class, "info", rl_info, 1);
+    rb_define_method(rl_class, "warn", rl_warn, 1);
+    rb_define_method(rl_class, "error", rl_error, 1);
+    rb_define_method(rl_class, "fatal", rl_fatal, 1);
+}

data/ext/agoo/rack_logger.h

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

data/ext/agoo/request.c

@@ -4,6 +4,7 @@
 
 #include "con.h"
 #include "error_stream.h"
+#include "rack_logger.h"
 #include "request.h"
 
 static VALUE	req_class = Qundef;
@@ -23,6 +24,7 @@ static VALUE	put_val = Qundef;
 static VALUE	query_string_val = Qundef;
 static VALUE	rack_errors_val = Qundef;
 static VALUE	rack_input_val = Qundef;
+static VALUE	rack_logger_val = Qundef;
 static VALUE	rack_multiprocess_val = Qundef;
 static VALUE	rack_multithread_val = Qundef;
 static VALUE	rack_run_once_val = Qundef;
@@ -434,6 +436,25 @@ body(VALUE self) {
     return rb_str_new(r->body.start, r->body.len);
 }
 
+static VALUE
+req_rack_logger(Req req) {
+    return rack_logger_new(req->server);
+}
+
+/* Document-method: rack_logger
+ *
+ * call-seq: rack_logger()
+ *
+ * Returns a RackLogger that can be used to log messages with the server
+ * logger. The methods supported are debug(), info(), warn(), error(), and
+ * fatal(). The signature is the same as the standard Ruby Logger of
+ * info(message, &block).
+ */
+static VALUE
+rack_logger(VALUE self) {
+    return req_rack_logger((Req)DATA_PTR(self));
+}
+
 /* Document-class: Agoo::Request
  *
  * A Request is passes to handler that respond to the _on_request_ method. The
@@ -461,6 +482,7 @@ request_env(Req 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));
 
     return env;
 }
@@ -529,6 +551,7 @@ request_init(VALUE mod) {
     rb_define_method(req_class, "rack_run_once", rack_run_once, 0);
     rb_define_method(req_class, "headers", headers, 0);
     rb_define_method(req_class, "body", body, 0);
+    rb_define_method(req_class, "rack_logger", rack_logger, 0);
 
     new_id = rb_intern("new");
     
@@ -549,6 +572,7 @@ request_init(VALUE mod) {
     query_string_val = rb_str_new_cstr("QUERY_STRING");		rb_gc_register_address(&query_string_val);
     rack_errors_val = rb_str_new_cstr("rack.errors");		rb_gc_register_address(&rack_errors_val);
     rack_input_val = rb_str_new_cstr("rack.input");		rb_gc_register_address(&rack_input_val);
+    rack_logger_val = rb_str_new_cstr("rack.logger");		rb_gc_register_address(&rack_logger_val);
     rack_multiprocess_val = rb_str_new_cstr("rack.multiprocess");rb_gc_register_address(&rack_multiprocess_val);
     rack_multithread_val = rb_str_new_cstr("rack.multithread");rb_gc_register_address(&rack_multithread_val);
     rack_run_once_val = rb_str_new_cstr("rack.run_once");	rb_gc_register_address(&rack_run_once_val);

data/ext/agoo/server.c

@@ -875,6 +875,20 @@ handle_not_found(VALUE self, VALUE handler) {
     return Qnil;
 }
 
+/* Document-method: add_mime
+ *
+ * call-seq: add_mime(suffix, type)
+ *
+ * Adds a mime type by associating a type string with a suffix. This is used
+ * for static files.
+ */
+static VALUE
+add_mime(VALUE self, VALUE suffix, VALUE type) {
+    mime_set(&((Server)DATA_PTR(self))->pages, StringValuePtr(suffix), StringValuePtr(type));
+
+    return Qnil;
+}
+
 /* Document-class: Agoo::Server
  *
  * An HTTP server that support the rack API as well as some other optimized
@@ -905,6 +919,7 @@ server_init(VALUE mod) {
 
     rb_define_method(server_class, "handle", handle, 3);
     rb_define_method(server_class, "handle_not_found", handle_not_found, 1);
+    rb_define_method(server_class, "add_mime", add_mime, 2);
 
     call_id = rb_intern("call");
     each_id = rb_intern("each");

data/lib/agoo.rb

@@ -1,6 +1,4 @@
 
-# Agoo is the module that includes an HTTP server. The word agoo is a Japanese
-# word for a type of flying fish.
 module Agoo
 end
 

data/lib/agoo/version.rb

@@ -1,5 +1,5 @@
 
 module Agoo
   # Agoo version.
-  VERSION = '1.0.0'
+  VERSION = '1.1.0'
 end

data/test/base_handler_test.rb

@@ -109,6 +109,7 @@ class BaseHandlerTest < Minitest::Test
       "rack.run_once" => false,
       "rack.url_scheme" => "http",
       "rack.version" => "1.3",
+      "rack.logger" => nil,
     }
     expect.each_pair { |k,v|
       if v.nil?

data/test/rack_handler_test.rb

@@ -57,7 +57,6 @@ class RackHandlerTest < Minitest::Test
 				  response: false,
 				  eval: true,
 				})
-      #sleep(100)
 
       handler = TellMeHandler.new
       server.handle(:GET, "/tellme", handler)

data/test/static_test.rb

@@ -30,8 +30,10 @@ class StaticTest < Minitest::Test
 				  response: false,
 				  eval: true,
 				})
+      server.add_mime('odd', 'text/odd')
       server.start()
       fetch_index_test
+      mime_test
       fetch_auto_index_test
       fetch_nested_test
       fetch_not_found_test
@@ -43,7 +45,12 @@ class StaticTest < Minitest::Test
 
   def fetch_index_test
     uri = URI('http://localhost:6466/index.html')
-    content = Net::HTTP.get(uri)
+    req = Net::HTTP::Get.new(uri)
+    res = Net::HTTP.start(uri.hostname, uri.port) { |h|
+      h.request(req)
+    }
+    content = res.body
+    assert_equal('text/html', res['Content-Type'])
     expect = %|<!DOCTYPE html>
 <html>
   <head><title>Agoo Test</title></head>
@@ -53,6 +60,15 @@ class StaticTest < Minitest::Test
     assert_equal(expect, content)
   end
 
+  def mime_test
+    uri = URI('http://localhost:6466/odd.odd')
+    req = Net::HTTP::Get.new(uri)
+    res = Net::HTTP.start(uri.hostname, uri.port) { |h|
+      h.request(req)
+    }
+    assert_equal('text/odd', res['Content-Type'])
+  end
+
   def fetch_auto_index_test
     uri = URI('http://localhost:6466/')
     content = Net::HTTP.get(uri)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: agoo
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Peter Ohler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-06 00:00:00.000000000 Z
+date: 2018-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -103,6 +103,8 @@ files:
 - ext/agoo/page.h
 - ext/agoo/queue.c
 - ext/agoo/queue.h
+- ext/agoo/rack_logger.c
+- ext/agoo/rack_logger.h
 - ext/agoo/request.c
 - ext/agoo/request.h
 - ext/agoo/res.c
@@ -132,7 +134,9 @@ rdoc_options:
 - "-m"
 - README.md
 - "-x"
-- test/*
+- '"test/*"'
+- "-x"
+- extconf.rb
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement