aspirin 0.0.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 fistfvck
+
+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.rdoc

@@ -0,0 +1,17 @@
+= aspirin
+
+Description goes here.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 fistfvck. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "aspirin"
+    gem.summary = %Q{evhttp wrapper and Rack interface}
+    gem.description = %Q{evhttp wrapper and Rack interface}
+    gem.email = "fistfvck@gmail.com"
+    gem.homepage = "http://github.com/fistfvck/aspirin"
+    gem.authors = ["fistfvck"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "aspirin #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/example/mong.rb

@@ -0,0 +1,84 @@
+# -*- coding: utf-8 -*-
+require 'rubygems'
+require 'rack'
+
+class HelloApp
+  def call(env)
+    # env.keys.sort.each do |k|
+    #   v = env[k]
+    #   puts "#{k.inspect} => #{v.inspect}"
+    # end
+    [200, {"Content-Type" => "text/plain"}, ["Hello, Rack"]]
+  end
+end
+Rack::Handler::Mongrel.run HelloApp.new
+__END__
+∴ curl "localhost:8080/path/to/file?arg1=1&arg2=2"
+"GATEWAY_INTERFACE" => "CGI/1.2"
+"HTTP_ACCEPT" => "*/*"
+"HTTP_HOST" => "localhost:8080"
+"HTTP_USER_AGENT" => "curl/7.19.7 (i486-pc-linux-gnu) libcurl/7.19.7 OpenSSL/0.9.8k zlib/1.2.3.3 libidn/1.15"
+"HTTP_VERSION" => "HTTP/1.1"
+"PATH_INFO" => "/path/to/file"
+"QUERY_STRING" => "arg1=1&arg2=2"
+"REMOTE_ADDR" => "127.0.0.1"
+"REQUEST_METHOD" => "GET"
+"REQUEST_PATH" => "/path/to/file"
+"REQUEST_URI" => "/path/to/file?arg1=1&arg2=2"
+"SCRIPT_NAME" => ""
+"SERVER_NAME" => "localhost"
+"SERVER_PORT" => "8080"
+"SERVER_PROTOCOL" => "HTTP/1.1"
+"SERVER_SOFTWARE" => "Mongrel 1.1.5"
+"rack.errors" => #<IO:0x816a550>
+"rack.input" => #<StringIO:0x8c3e440>
+"rack.multiprocess" => false
+"rack.multithread" => true
+"rack.run_once" => false
+"rack.url_scheme" => "http"
+"rack.version" => [1, 1]
+
+∴ ab -n 10000 -c 100 http://127.0.0.1:8080/ 2>/dev/null
+This is ApacheBench, Version 2.3 <$Revision: 655654 $>
+Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
+Licensed to The Apache Software Foundation, http://www.apache.org/
+
+Benchmarking 127.0.0.1 (be patient)
+
+
+Server Software:
+Server Hostname:        127.0.0.1
+Server Port:            8080
+
+Document Path:          /
+Document Length:        11 bytes
+
+Concurrency Level:      100
+Time taken for tests:   10.356 seconds
+Complete requests:      10000
+Failed requests:        0
+Write errors:           0
+Total transferred:      1320000 bytes
+HTML transferred:       110000 bytes
+Requests per second:    965.64 [#/sec] (mean)
+Time per request:       103.558 [ms] (mean)
+Time per request:       1.036 [ms] (mean, across all concurrent requests)
+Transfer rate:          124.48 [Kbytes/sec] received
+
+Connection Times (ms)
+              min  mean[+/-sd] median   max
+Connect:        0    0   0.7      0      10
+Processing:    28  103  12.7     98     138
+Waiting:       28  103  12.7     98     138
+Total:         37  103  12.5     98     138
+
+Percentage of the requests served within a certain time (ms)
+  50%     98
+  66%    102
+  75%    116
+  80%    118
+  90%    121
+  95%    124
+  98%    131
+  99%    133
+ 100%    138 (longest request)

data/example/test.rb

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+require "#{File.dirname __FILE__}/../ext/aspirin"
+
+class HelloApp
+  def call(env)
+    # env.keys.sort.each do |k|
+    #   v = env[k]
+    #   $stderr.puts "#{k.inspect} => #{v.inspect}"
+    # end
+    [200, {"Content-Type" => "text/plain"}, ["Hello, Rack"]]
+  end
+end
+Rack::Handler::Aspirin.run HelloApp.new
+__END__
+∴ curl "localhost:9292/path/to/file?arg1=1&arg2=2"
+∴ ab -n 10000 -c 100 http://127.0.0.1:9292/ 2>/dev/null
+This is ApacheBench, Version 2.3 <$Revision: 655654 $>
+Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
+Licensed to The Apache Software Foundation, http://www.apache.org/
+
+Benchmarking 127.0.0.1 (be patient)
+
+
+Server Software:
+Server Hostname:        127.0.0.1
+Server Port:            9292
+
+Document Path:          /
+Document Length:        11 bytes
+
+Concurrency Level:      100
+Time taken for tests:   3.184 seconds
+Complete requests:      10000
+Failed requests:        0
+Write errors:           0
+Total transferred:      750000 bytes
+HTML transferred:       110000 bytes
+Requests per second:    3141.16 [#/sec] (mean)
+Time per request:       31.835 [ms] (mean)
+Time per request:       0.318 [ms] (mean, across all concurrent requests)
+Transfer rate:          230.07 [Kbytes/sec] received
+
+Connection Times (ms)
+              min  mean[+/-sd] median   max
+Connect:        0    0   0.7      0       9
+Processing:     5   32   3.1     31      43
+Waiting:        5   31   3.1     31      43
+Total:         13   32   2.8     31      43
+
+Percentage of the requests served within a certain time (ms)
+  50%     31
+  66%     32
+  75%     33
+  80%     33
+  90%     35
+  95%     36
+  98%     40
+  99%     41
+ 100%     43 (longest request)

data/example/thn.rb

@@ -0,0 +1,87 @@
+# -*- coding: utf-8 -*-
+require 'rubygems'
+require 'thin'
+require 'rack'
+
+class HelloApp
+  def call(env)
+    # env.keys.sort.each do |k|
+    #   v = env[k]
+    #   puts "#{k.inspect} => #{v.inspect}"
+    # end
+    [200, {"Content-Type" => "text/plain"}, ["Hello, Rack"]]
+  end
+end
+Rack::Handler::Thin.run HelloApp.new
+__END__
+∴ curl "localhost:8080/path/to/file?arg1=1&arg2=2"
+"GATEWAY_INTERFACE" => "CGI/1.2"
+"HTTP_ACCEPT" => "*/*"
+"HTTP_HOST" => "localhost:8080"
+"HTTP_USER_AGENT" => "curl/7.19.7 (i486-pc-linux-gnu) libcurl/7.19.7 OpenSSL/0.9.8k zlib/1.2.3.3 libidn/1.15"
+"HTTP_VERSION" => "HTTP/1.1"
+"PATH_INFO" => "/path/to/file"
+"QUERY_STRING" => "arg1=1&arg2=2"
+"REMOTE_ADDR" => "127.0.0.1"
+"REQUEST_METHOD" => "GET"
+"REQUEST_PATH" => "/path/to/file"
+"REQUEST_URI" => "/path/to/file?arg1=1&arg2=2"
+"SCRIPT_NAME" => ""
+"SERVER_NAME" => "localhost"
+"SERVER_PORT" => "8080"
+"SERVER_PROTOCOL" => "HTTP/1.1"
+"SERVER_SOFTWARE" => "thin 1.2.7 codename No Hup"
+"async.callback" => #<Method: Thin::Connection#post_process>
+"async.close" => #<EventMachine::DefaultDeferrable:0x966bb5c>
+"rack.errors" => #<IO:0x92f4550>
+"rack.input" => #<StringIO:0x966bdb4>
+"rack.multiprocess" => false
+"rack.multithread" => false
+"rack.run_once" => false
+"rack.url_scheme" => "http"
+"rack.version" => [1, 0]
+
+∴ ab -n 10000 -c 100 http://127.0.0.1:8080/ 2>/dev/null
+This is ApacheBench, Version 2.3 <$Revision: 655654 $>
+Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
+Licensed to The Apache Software Foundation, http://www.apache.org/
+
+Benchmarking 127.0.0.1 (be patient)
+
+
+Server Software:        thin
+Server Hostname:        127.0.0.1
+Server Port:            8080
+
+Document Path:          /
+Document Length:        11 bytes
+
+Concurrency Level:      100
+Time taken for tests:   6.314 seconds
+Complete requests:      10000
+Failed requests:        0
+Write errors:           0
+Total transferred:      1310000 bytes
+HTML transferred:       110000 bytes
+Requests per second:    1583.76 [#/sec] (mean)
+Time per request:       63.141 [ms] (mean)
+Time per request:       0.631 [ms] (mean, across all concurrent requests)
+Transfer rate:          202.61 [Kbytes/sec] received
+
+Connection Times (ms)
+              min  mean[+/-sd] median   max
+Connect:        0    0   0.6      0      10
+Processing:    19   63  23.0     56     224
+Waiting:       11   58  22.0     52     215
+Total:         28   63  23.0     57     224
+
+Percentage of the requests served within a certain time (ms)
+  50%     57
+  66%     60
+  75%     65
+  80%     66
+  90%     71
+  95%     90
+  98%    170
+  99%    188
+ 100%    224 (longest request)

data/ext/aspirin.c

@@ -0,0 +1,566 @@
+#include <ruby.h>
+#ifdef HAVE_RUBY_ST_H
+#include <ruby/st.h>
+#else
+#include <st.h>
+#endif
+#include <signal.h>
+#include <sys/queue.h>
+#include <stdio.h>
+#include <ctype.h>
+
+#include <event.h>
+#include <evhttp.h>
+#include <evutil.h>
+
+#define INSPECT(obj) {VALUE __obj__ = rb_inspect((obj)); fprintf(stderr, "%d:%s\n", __LINE__, RSTRING_PTR(__obj__));}
+
+static VALUE rb_mAspirin;
+static VALUE rb_cAspirin_Server;
+static VALUE rb_cStringIO;
+static struct st_table *status_code_tbl;
+static const int const status_code_int[] = {
+    100,101,102,200,201,202,203,204,205,206,207,208,226,300,301,302,303,304,305,306,307,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,420,421,422,423,424,425,426,500,501,502,503,504,505,506,507,508,510
+};
+static const char* const status_code_str[] = {
+    "Continue","Switching Protocols","Processing","OK","Created","Accepted","Non-Authoritative Information","No Content","Reset Content","Partial Content","Multi-Status","Already Reported","IM Used","Multiple Choices","Moved Permanently","Found","See Other","Not Modified","Use Proxy","","Temporary Redirect","Bad Request","Unauthorized","Payment Required","Forbidden","Not Found","Method Not Allowed","Not Acceptable","Proxy Authentication Required","Request Timeout","Conflict","Gone","Length Required","Precondition Failed","Request Entity Too Large","Request-URI Too Long","Unsupported Media Type","Requested Range Not Satisfiable","Expectation Failed","","","Unprocessable Entity","Locked","Failed Dependency","","Upgrade Required","Internal Server Error","Not Implemented","Bad Gateway","Service Unavailable","Gateway Timeout","HTTP Version Not Supported","Variant Also Negotiates","Insufficient Storage","Loop Detected","Not Extended"
+};
+static VALUE default_env;
+
+typedef struct
+{
+    struct event_base* base;
+    struct evhttp*     http;
+    struct event       signal;
+    VALUE              app;
+    VALUE              options;
+    VALUE              env;
+} Aspirin_Server;
+
+// Aspirin::Server.new
+static VALUE aspirin_server_initialize(VALUE, VALUE, VALUE);
+// Aspirin::Server.start
+static VALUE aspirin_server_start(VALUE);
+// Rack::Handler::Aspirin.run
+static VALUE rack_handler_aspirin_run(int, VALUE*, VALUE);
+
+static VALUE aspirin_server_address(VALUE);
+static int   aspirin_server_port(VALUE);
+
+static VALUE aspirin_server_alloc(VALUE);
+static void  aspirin_server_mark(Aspirin_Server*);
+static void  aspirin_server_free(Aspirin_Server*);
+
+static void  aspirin_server_http_request(struct evhttp_request*, void*);
+static VALUE aspirin_server_create_env(struct evhttp_request*, Aspirin_Server*);
+
+static void  aspirin_server_base_initialize(Aspirin_Server*);
+static void  aspirin_server_signal_initialize(Aspirin_Server*);
+static void  aspirin_server_sigint(int, short, void*);
+static void  aspirin_server_http_initialize(Aspirin_Server*);
+
+static void  set_http_version(VALUE, struct evhttp_request*);
+static void  set_path_info(VALUE, struct evhttp_request*);
+static void  set_response_header(struct evhttp_request*, VALUE);
+static void  set_additional_header(struct evhttp_request*);
+
+static void  init_default_env();
+static VALUE dupe_default_env();
+static void  init_status_code_tbl();
+static char* get_status_code_message(int);
+
+static char* upcase(char*);
+static char* hyphen_to_under(char*);
+
+static void
+init_default_env()
+{
+    VALUE rack_url_scheme, rack_version, gateway_interface, server_protocol, script_name;
+
+    rack_url_scheme   = rb_str_new2("http");
+    rack_version      = rb_ary_new3(2, INT2FIX(1), INT2FIX(1));
+    gateway_interface = rb_str_new2("CGI/1.2");
+    server_protocol   = rb_str_new2("HTTP/1.1");
+    script_name       = rb_str_new2("");
+
+    OBJ_FREEZE(rack_url_scheme);
+    OBJ_FREEZE(rack_version);
+    OBJ_FREEZE(gateway_interface);
+    OBJ_FREEZE(server_protocol);
+    OBJ_FREEZE(script_name);
+
+    default_env = rb_hash_new();
+
+    rb_hash_aset(default_env, rb_str_new2("rack.multiprocess"), Qfalse);
+    rb_hash_aset(default_env, rb_str_new2("rack.multithread"),  Qfalse);
+    rb_hash_aset(default_env, rb_str_new2("rack.run_once"),     Qfalse);
+    rb_hash_aset(default_env, rb_str_new2("rack.url_scheme"),   rack_url_scheme);
+    rb_hash_aset(default_env, rb_str_new2("rack.version"),      rack_version);
+    rb_hash_aset(default_env, rb_str_new2("GATEWAY_INTERFACE"), gateway_interface);
+    rb_hash_aset(default_env, rb_str_new2("SCRIPT_NAME"),       script_name);
+    rb_hash_aset(default_env, rb_str_new2("SERVER_PROTOCOL"),   server_protocol);
+}
+
+static VALUE
+dupe_default_env()
+{
+    return rb_funcall(default_env, rb_intern("dup"), 0);
+}
+
+static void
+init_status_code_tbl()
+{
+    int i, n = sizeof(status_code_int)/sizeof(int);
+    status_code_tbl = st_init_numtable();
+    for(i=0; i<n; i++)
+    {
+        st_add_direct(status_code_tbl, (st_data_t)status_code_int[i], (st_data_t)status_code_str[i]);
+    }
+}
+
+static char*
+get_status_code_message(int status_code)
+{
+    char* result = NULL;
+    st_lookup(status_code_tbl, (st_data_t)status_code, (st_data_t*)&result);
+    return result;
+}
+
+static void
+set_http_version(VALUE env, struct evhttp_request *req)
+{
+    char  buf[8 + 1]; // HTTP/x.y
+    snprintf(buf, 9, "HTTP/%d.%d", req->major, req->minor);
+    rb_hash_aset(env, rb_str_new2("HTTP_VERSION"), rb_str_new2(buf));
+}
+
+static void
+set_path_info(VALUE env, struct evhttp_request *req)
+{
+    VALUE request_uri, query_string;
+    char *buf, *query;
+    int   len = strlen(evhttp_request_uri(req));
+
+    buf = xmalloc(len + 1);
+    strcpy(buf, evhttp_request_uri(req));
+
+    query = strrchr(buf, '?');
+    if(query != NULL)
+    {
+        *query++ = '\0';
+    }
+    else
+    {
+        query = "";
+    }
+
+    request_uri  = rb_str_new2(buf);
+    query_string = rb_str_new2(query);
+
+    OBJ_FREEZE(request_uri);
+    OBJ_FREEZE(query_string);
+
+    rb_hash_aset(env, rb_str_new2("PATH_INFO"), request_uri);
+    rb_hash_aset(env, rb_str_new2("REQUEST_PATH"), request_uri);
+    rb_hash_aset(env, rb_str_new2("QUERY_STRING"), query_string);
+
+    xfree(buf);
+}
+
+static void
+set_http_header(VALUE env, struct evhttp_request *req)
+{
+    char  *buf;
+    size_t len;
+    struct evkeyval *header;
+    VALUE key, val;
+
+    TAILQ_FOREACH(header, req->input_headers, next)
+    {
+        len = strlen(header->key);
+        if(len > 0)
+        {
+            buf = xmalloc(5 + len + 1);
+
+            strncpy(buf, "HTTP_", 5);
+            strncpy(buf + 5, header->key, len);
+            buf[len + 5] = '\0';
+            hyphen_to_under(upcase(buf));
+
+            key = rb_str_new2(buf);
+            val = rb_str_new2(header->value);
+            OBJ_FREEZE(val);
+            rb_hash_aset(env, key, val);
+
+            xfree(buf);
+        }
+    }
+}
+
+static VALUE
+aspirin_server_create_env(struct evhttp_request *req, Aspirin_Server *srv)
+{
+    VALUE env, rack_input, strio, remote_host, request_uri, method;
+
+    env = rb_funcall(srv->env, rb_intern("dup"), 0);
+
+    rb_hash_aset(env, rb_str_new2("rack.errors"), rb_gv_get("$stderr"));
+
+    rack_input = rb_str_new((const char*)EVBUFFER_DATA(req->input_buffer),
+                            EVBUFFER_LENGTH(req->input_buffer));
+    OBJ_FREEZE(rack_input);
+    strio = rb_funcall(rb_cStringIO, rb_intern("new"), 1, rack_input);
+    rb_hash_aset(env, rb_str_new2("rack.input"), strio);
+
+    remote_host = rb_str_new2(req->remote_host);
+    OBJ_FREEZE(remote_host);
+    rb_hash_aset(env, rb_str_new2("REMOTE_ADDR"), remote_host);
+
+    request_uri = rb_str_new2(evhttp_request_uri(req));
+    OBJ_FREEZE(request_uri);
+    rb_hash_aset(env, rb_str_new2("REQUEST_URI"), request_uri);
+
+    method = rb_str_new2("REQUEST_METHOD");
+    switch(req->type)
+    {
+    case EVHTTP_REQ_GET:
+        rb_hash_aset(env, method, rb_str_new2("GET"));
+        break;
+    case EVHTTP_REQ_POST:
+        rb_hash_aset(env, method, rb_str_new2("POST"));
+        break;
+    case EVHTTP_REQ_HEAD:
+        rb_hash_aset(env, method, rb_str_new2("HEAD"));
+        break;
+    }
+
+    set_http_version(env, req);
+    set_path_info(env, req);
+    set_http_header(env, req);
+
+    return env;
+}
+
+static void
+set_response_header(struct evhttp_request *req, VALUE headers)
+{
+    VALUE header_keys, key, val;
+    int i, n;
+
+    header_keys = rb_funcall(headers, rb_intern("keys"), 0);
+
+    n = RARRAY_LEN(header_keys);
+    for(i=0; i<n; i++)
+    {
+        key = rb_ary_entry(header_keys, i);
+        val = rb_hash_aref(headers, key);
+        StringValue(key);
+        StringValue(val);
+        if(RSTRING_LEN(key) > 0 && RSTRING_LEN(val) > 0)
+        {
+            evhttp_remove_header(req->output_headers, StringValueCStr(key));
+            evhttp_add_header(req->output_headers, StringValueCStr(key), StringValueCStr(val));
+        }
+    }
+}
+
+static void
+set_additional_header(struct evhttp_request *req)
+{
+    evhttp_remove_header(req->output_headers, "Connection");
+    evhttp_add_header(req->output_headers, "Connection", "close");
+}
+
+static void
+aspirin_server_http_request(struct evhttp_request *req, void *arg)
+{
+    static VALUE args[][1] = {{INT2FIX(0)},{INT2FIX(1)},{INT2FIX(2)}};
+    struct evbuffer *buf;
+    Aspirin_Server  *srv;
+    VALUE env, result, bodies;
+    int   status_code;
+    char *status_code_msg;
+
+    srv = arg;
+    env = aspirin_server_create_env(req, srv);
+    result = rb_funcall(srv->app, rb_intern("call"), 1, env);
+
+    status_code = NUM2INT(rb_ary_aref(1, args[0], result));
+    status_code_msg = get_status_code_message(status_code);
+    if(status_code_msg == NULL)
+    {
+        status_code_msg = "";
+    }
+
+    set_response_header(req, rb_ary_aref(1, args[1], result));
+    set_additional_header(req);
+
+    bodies = rb_funcall(rb_ary_aref(1, args[2], result), rb_intern("to_s"), 0);
+
+    buf = evbuffer_new();
+    evbuffer_add(buf, RSTRING_PTR(bodies), RSTRING_LEN(bodies));
+    evhttp_send_reply(req, status_code, status_code_msg, buf);
+    evbuffer_free(buf);
+}
+
+static Aspirin_Server*
+check_aspirin_server(VALUE obj)
+{
+    Check_Type(obj, T_DATA);
+    return DATA_PTR(obj);
+}
+
+static Aspirin_Server*
+alloc_aspirin_server()
+{
+    Aspirin_Server *srv = ALLOC(Aspirin_Server);
+    memset(srv, 0, sizeof(Aspirin_Server));
+    return srv;
+}
+
+
+static VALUE
+aspirin_server_initialize(VALUE obj, VALUE app, VALUE options)
+{
+    Aspirin_Server *srv = check_aspirin_server(obj);
+
+    if(!srv)
+    {
+        DATA_PTR(obj) = srv = alloc_aspirin_server();
+    }
+
+    srv->app = app;
+    srv->options = options;
+    srv->env = dupe_default_env();
+
+    aspirin_server_base_initialize(srv);
+    aspirin_server_signal_initialize(srv);
+    aspirin_server_http_initialize(srv);
+
+    return obj;
+}
+
+static VALUE
+aspirin_server_start(VALUE obj)
+{
+    Aspirin_Server *srv = DATA_PTR(obj);
+    event_base_loop(srv->base, 0);
+    return Qnil;
+}
+
+static void
+aspirin_server_mark(Aspirin_Server* srv)
+{
+    if(!srv)
+    {
+        return;
+    }
+    rb_gc_mark(srv->app);
+    rb_gc_mark(srv->options);
+    rb_gc_mark(srv->env);
+}
+
+static void
+aspirin_server_free(Aspirin_Server* srv)
+{
+    if(!srv)
+    {
+        return;
+    }
+
+    event_del(&srv->signal);
+
+    if(srv->http)
+    {
+        evhttp_free(srv->http);
+        srv->http = NULL;
+    }
+
+    if(srv->base)
+    {
+        event_base_loopbreak(srv->base);
+        event_base_free(srv->base);
+        srv->base = NULL;
+    }
+
+    xfree(srv);
+}
+
+static VALUE
+aspirin_server_alloc(VALUE klass)
+{
+    return Data_Wrap_Struct(klass, aspirin_server_mark, aspirin_server_free, 0);
+}
+
+static void
+aspirin_server_sigint(int fd, short event, void *arg)
+{
+    Aspirin_Server *srv = arg;
+    struct timeval delay = {1, 0};
+    event_del(&srv->signal);
+    event_base_loopexit(srv->base, &delay);
+}
+
+static int
+aspirin_server_port(VALUE options)
+{
+    VALUE port = Qnil;
+    if(TYPE(options) == T_HASH)
+    {
+        port = rb_hash_aref(options, ID2SYM(rb_intern("port")));
+        if(!NIL_P(port)){
+            return NUM2INT(port);
+        }
+        port = rb_hash_aref(options, rb_str_new2("port"));
+        if(!NIL_P(port)){
+            return NUM2INT(port);
+        }
+        port = rb_hash_aref(options, ID2SYM(rb_intern("Port")));
+        if(!NIL_P(port)){
+            return NUM2INT(port);
+        }
+        port = rb_hash_aref(options, rb_str_new2("Port"));
+        if(!NIL_P(port)){
+            return NUM2INT(port);
+        }
+        port = rb_hash_aref(options, ID2SYM(rb_intern("PORT")));
+        if(!NIL_P(port)){
+            return NUM2INT(port);
+        }
+        port = rb_hash_aref(options, rb_str_new2("PORT"));
+        if(!NIL_P(port)){
+            return NUM2INT(port);
+        }
+    }
+    return 9292;
+}
+
+static VALUE
+aspirin_server_address(VALUE options)
+{
+    VALUE address = Qnil;
+    if(TYPE(options) == T_HASH)
+    {
+        address = rb_hash_aref(options, ID2SYM(rb_intern("address")));
+        if(!NIL_P(address)){
+            return address;
+        }
+        address = rb_hash_aref(options, rb_str_new2("address"));
+        if(!NIL_P(address)){
+            return address;
+        }
+        address = rb_hash_aref(options, ID2SYM(rb_intern("Address")));
+        if(!NIL_P(address)){
+            return address;
+        }
+        address = rb_hash_aref(options, rb_str_new2("Address"));
+        if(!NIL_P(address)){
+            return address;
+        }
+        address = rb_hash_aref(options, ID2SYM(rb_intern("ADDRESS")));
+        if(!NIL_P(address)){
+            return address;
+        }
+        address = rb_hash_aref(options, rb_str_new2("ADDRESS"));
+        if(!NIL_P(address)){
+            return address;
+        }
+    }
+    return rb_str_new2("0.0.0.0");
+}
+
+static void
+aspirin_server_base_initialize(Aspirin_Server *srv)
+{
+    srv->base = event_base_new();
+}
+
+static void
+aspirin_server_signal_initialize(Aspirin_Server *srv)
+{
+    event_set(&srv->signal, SIGINT, EV_SIGNAL|EV_PERSIST, aspirin_server_sigint, srv);
+    event_base_set(srv->base, &srv->signal);
+    event_add(&srv->signal, NULL);
+}
+
+static void
+aspirin_server_http_initialize(Aspirin_Server *srv)
+{
+    VALUE addr = aspirin_server_address(srv->options);
+    int   port = aspirin_server_port(srv->options);
+
+    StringValue(addr);
+    rb_hash_aset(srv->env, rb_str_new2("SERVER_NAME"), addr);
+
+    char port_str[6];
+    snprintf(port_str, 5, "%d", port);
+    rb_hash_aset(srv->env, rb_str_new2("SERVER_PORT"), rb_str_new2(port_str));
+
+    srv->http = evhttp_new(srv->base);
+    evhttp_bind_socket(srv->http, RSTRING_PTR(addr), port);
+    evhttp_set_gencb(srv->http, aspirin_server_http_request, srv);
+}
+
+static char*
+upcase(char* str)
+{
+    if(str){
+        int i, n=strlen(str);
+        for(i=0; i<n; i++)
+        {
+            str[i] = toupper(str[i]);
+        }
+    }
+    return str;
+}
+
+static char*
+hyphen_to_under(char* str)
+{
+    if(str){
+        int i, n=strlen(str);
+        for(i=0; i<n; i++)
+        {
+            if(str[i] == '-')
+            {
+                str[i] = '_';
+            }
+        }
+    }
+    return str;
+}
+
+static VALUE
+rack_handler_aspirin_run(int argc, VALUE *argv, VALUE obj)
+{
+    VALUE app, options;
+    if(rb_scan_args(argc, argv, "11", &app, &options) == 1)
+    {
+        options = rb_hash_new();
+    }
+    aspirin_server_start(rb_funcall(rb_cAspirin_Server, rb_intern("new"), 2, app, options));
+    return Qnil;
+}
+
+void Init_aspirin(void)
+{
+    init_default_env();
+    init_status_code_tbl();
+
+    rb_require("stringio");
+    rb_cStringIO = rb_const_get(rb_cObject, rb_intern("StringIO"));
+
+    rb_mAspirin         = rb_define_module("Aspirin");
+    rb_cAspirin_Server  = rb_define_class_under(rb_mAspirin, "Server", rb_cObject);
+
+    // Aspirin::Server
+    rb_define_alloc_func(rb_cAspirin_Server, aspirin_server_alloc);
+    rb_define_method(rb_cAspirin_Server, "initialize", aspirin_server_initialize, 2);
+    rb_define_method(rb_cAspirin_Server, "start", aspirin_server_start, 0);
+
+    // Rack::Handler::Aspirin
+    VALUE rb_mRack = rb_define_module("Rack");
+    VALUE rb_mRack_Handler = rb_define_module_under(rb_mRack, "Handler");
+    VALUE rb_mRack_Handler_Aspirin = rb_define_module_under(rb_mRack_Handler, "Aspirin");
+    rb_define_singleton_method(rb_mRack_Handler_Aspirin, "run", rack_handler_aspirin_run, -1);
+}

data/ext/extconf.rb

@@ -0,0 +1,7 @@
+require "mkmf"
+
+dir_config("event")
+have_header("event.h")
+have_header("evhttp.h")
+have_library("event")
+create_makefile("aspirin")

data/spec/aspirin_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Aspirin" do
+  it "fails" do
+    fail "hey buddy, you should probably rename this file and start specing for real"
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'aspirin'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification 
+name: aspirin
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 0
+  version: 0.0.0
+platform: ruby
+authors: 
+- fistfvck
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-29 00:00:00 +09:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 9
+        version: 1.2.9
+  type: :development
+  version_requirements: *id001
+description: evhttp wrapper and Rack interface
+email: fistfvck@gmail.com
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- example/mong.rb
+- example/test.rb
+- example/thn.rb
+- ext/aspirin.c
+- ext/extconf.rb
+- spec/aspirin_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/fistfvck/aspirin
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: evhttp wrapper and Rack interface
+test_files: 
+- spec/aspirin_spec.rb
+- spec/spec_helper.rb