libevent 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+lib/*.so
+tmp/*

data/Gemfile

@@ -0,0 +1,5 @@
+source "http://rubygems.org"
+
+gemspec
+
+gem "rake-compiler"

data/README.md

@@ -0,0 +1,146 @@
+## Libevent
+
+C extension to [libevent](http://libevent.org/) library.
+
+## Description
+
+The nice feature of libevent is it already contains build in HTTP server (evhttp).
+
+Currently libevent extension implements mostly http server.
+
+## Dependencies
+
+* libevent v2
+
+## Documentation
+
+Please read [libevent rubydoc](http://rubydoc.info/github/ayanko/libevent/frames)
+
+## Installation
+
+    gem install libevent
+
+## Using Libevent HTTP server
+
+Check `samples` directory
+
+### From scratch
+
+Simple server
+
+    require "libevent" 
+
+    # create event base
+    base = Libevent::Base.new
+
+    # create http server instance
+    http = Libevent::Http.new(base)
+
+    # bind socket
+    http.bind_socket("0.0.0.0", 15015)
+
+    # set handler
+    http.handler do |request|
+      request.send_reply(200, {}, ["Hello World\n"])
+    end
+
+    # catch SIGINT
+    base.trap_signal("INT") { base.exit_loop }
+ 
+    # start libevent loop
+    base.dispatch
+
+Check with curl
+
+    $ curl -v http://localhost:15015
+    > GET / HTTP/1.1
+    > User-Agent: curl/7.22.0 (x86_64-unknown-linux-gnu) libcurl/7.22.0 OpenSSL/1.0.0e zlib/1.2.5 libssh2/1.3.0
+    > Host: localhost:15015
+    > Accept: */*
+    > 
+    < HTTP/1.1 200 OK
+    < Transfer-Encoding: chunked
+    < Date: Fri, 18 Nov 2011 19:09:04 GMT
+    < Content-Type: text/html; charset=ISO-8859-1
+    < 
+    Hello World
+
+### Server with virtual hosts
+
+    require "libevent"
+
+    Libevent::Builder.new do
+
+      server "0.0.0.0", 3000 do |http|
+
+	http.handler do |request|
+	  case request.get_uri_path
+	  when '/hello'
+	    request.send_reply 200, { 'Content->Type' => 'text/plain'},  [ "Hello World" ]
+	  when '/api'
+	    request.send_reply 200, { 'Content->Type' => 'application/json'},  [ "{\"version\":\"1.0\"}" ]
+	  else
+	    request.send_error 404, "Nothing Found"
+	  end
+	end
+
+	http.vhost "blog.local" do |host|
+	  host.handler do |request|
+	    request.send_reply 200, {}, ["It's blog"]
+	  end
+	end
+
+	http.vhost "wiki.local" do |host|
+	  host.handler do |request|
+	    request.send_reply 200, {}, ["It's wiki"]
+	  end
+	end
+
+	http.vhost "*.local" do |host|
+	  host.handler do |request|
+	    request.send_error 404, "Please use blog.local or wiki.local"
+	  end
+	end
+
+      end
+
+      server "0.0.0.0", 3001 do |http|
+	http.handler do |request|
+	  request.send_reply 200, { 'Content->Type' => 'text/plain'},  [ "Hello World 3001" ]
+	end
+      end
+
+      signal("INT") do
+	base.exit_loop
+      end
+
+      signal("HUP") do
+	Kernel.puts "HUP received ..."
+      end
+
+      dispatch
+
+    end
+
+### Serve Rails application
+
+Add to `Gemfile`
+
+    gem "libevent", :require => false
+
+Update gems
+
+    $ bundle install
+
+Run application
+
+    $ script/rails s Libevent
+
+Or via rackup
+
+    $ bundle exec rackup -s Libevent -p 3000
+
+### Serve Rack application
+
+Check rack handler `rack/handler/libevent.rb`
+

data/Rakefile

@@ -0,0 +1,4 @@
+require "bundler/gem_tasks"
+require 'rake/extensiontask'
+
+Rake::ExtensionTask.new("libevent_ext")

data/ext/libevent_ext/base.c

@@ -0,0 +1,94 @@
+#include "ext.h"
+
+static VALUE t_allocate(VALUE klass);
+
+static void t_free(Libevent_Base *base);
+
+static VALUE t_dispatch(VALUE self);
+
+static VALUE t_exit_loop(VALUE self);
+
+static VALUE t_break_loop(VALUE self);
+
+void Init_libevent_base() {
+  cLibevent_Base = rb_define_class_under(mLibevent, "Base", rb_cObject);
+  
+  rb_define_alloc_func(cLibevent_Base, t_allocate);
+
+  rb_define_method(cLibevent_Base, "dispatch", t_dispatch, 0);
+  rb_define_method(cLibevent_Base, "exit_loop", t_exit_loop, 0);
+  rb_define_method(cLibevent_Base, "break_loop", t_break_loop, 0);
+}
+
+/*
+ * Allocate memmory
+ */
+static VALUE t_allocate(VALUE klass) {
+  Libevent_Base *base;
+
+  base = ALLOC(Libevent_Base);
+  base->ev_base = event_base_new();
+
+  if ( !base->ev_base ) {
+    rb_fatal("Couldn't get an event base");
+  }
+
+  return Data_Wrap_Struct(klass, 0, t_free, base); 
+}
+
+/*
+ * Free memmory
+ */
+static void t_free(Libevent_Base *base) {
+  event_base_free(base->ev_base);
+}
+
+/*
+ * Event dispatching loop.
+ *
+ * This loop will run the event base until either there are no more added events, 
+ * or until something calls Libevent::Base#break_loop or Base#exit_loop.
+ * @see #break_loop
+ * @see #exit_loop
+*/
+static VALUE t_dispatch(VALUE self) {
+  Libevent_Base *base;
+  int status;
+
+  Data_Get_Struct(self, Libevent_Base, base);
+  status = event_base_dispatch(base->ev_base);
+
+  return INT2FIX(status);
+}
+
+/*
+ * Exit the event loop after the specified time
+ *
+ * @todo specified time is not implemented
+ */
+static VALUE t_exit_loop(VALUE self) {
+  Libevent_Base *base;
+  int status;
+
+  Data_Get_Struct(self, Libevent_Base, base);
+  status = event_base_loopexit(base->ev_base, NULL);
+
+  return (status == -1 ? Qfalse : Qtrue);
+}
+/*
+ * Abort the active event_base loop immediately.
+ *
+ * It will abort the loop after the next event is completed;
+ * event_base_loopbreak() is typically invoked from this event's callback. 
+ * This behavior is analogous to the "break;" statement.
+ * Subsequent invocations of event_loop() will proceed normally.
+ */
+static VALUE t_break_loop(VALUE self) {
+  Libevent_Base *base;
+  int status;
+
+  Data_Get_Struct(self, Libevent_Base, base);
+  status = event_base_loopbreak(base->ev_base);
+
+  return (status == -1 ? Qfalse : Qtrue);
+}

data/ext/libevent_ext/ext.c

@@ -0,0 +1,10 @@
+#include "ext.h"
+
+void Init_libevent_ext() {
+  mLibevent = rb_define_module("Libevent");
+
+  Init_libevent_base();
+  Init_libevent_signal();
+  Init_libevent_http();
+  Init_libevent_http_request();
+}

data/ext/libevent_ext/ext.h

@@ -0,0 +1,40 @@
+#ifndef LIBEVENT_EXT_H
+#define LIBEVENT_EXT_H
+
+#include "ruby.h"
+#include "ruby18_compat.h"
+
+#include <event.h>
+#include <evhttp.h>
+
+VALUE mLibevent;
+VALUE cLibevent_Base;
+VALUE cLibevent_Signal;
+VALUE cLibevent_Http;
+VALUE cLibevent_HttpRequest;
+
+typedef struct Libevent_Base {
+  struct event_base *ev_base;
+} Libevent_Base;
+
+typedef struct Libevent_Signal {
+  struct event *ev_event;
+} Libevent_Signal;
+
+typedef struct Libevent_Http {
+  struct event_base *ev_base;
+  struct evhttp *ev_http;
+  struct evhttp *ev_http_parent;
+} Libevent_Http;
+
+typedef struct Libevent_HttpRequest {
+  struct evhttp_request *ev_request;
+  struct evbuffer *ev_buffer;
+} Libevent_HttpRequest;
+
+void Init_libevent_base();
+void Init_libevent_signal();
+void Init_libevent_http();
+void Init_libevent_http_request();
+
+#endif

data/ext/libevent_ext/extconf.rb

@@ -0,0 +1,7 @@
+require "mkmf"
+
+$CFLAGS << ' -Wall '
+
+$LDFLAGS << ' ' << `pkg-config --libs libevent`
+
+create_makefile('libevent_ext')

data/ext/libevent_ext/http.c

@@ -0,0 +1,184 @@
+#include "ext.h"
+
+static VALUE t_allocate(VALUE klass);
+
+static void t_free(Libevent_Http *http);
+
+static VALUE t_initialize(VALUE self, VALUE object);
+
+static VALUE t_bind_socket(VALUE self, VALUE address, VALUE port);
+
+static VALUE t_set_request_handler(VALUE self, VALUE handler);
+
+static VALUE t_set_timeout(VALUE self, VALUE timeout);
+
+static void t_request_handler(struct evhttp_request *ev_request, void *context);
+
+static VALUE t_add_virtual_host(VALUE self, VALUE domain, VALUE vhttp);
+
+void Init_libevent_http() {
+  cLibevent_Http = rb_define_class_under(mLibevent, "Http", rb_cObject);
+  
+  rb_define_alloc_func(cLibevent_Http, t_allocate);
+
+  rb_define_method(cLibevent_Http, "initialize", t_initialize, 1);
+  rb_define_method(cLibevent_Http, "bind_socket", t_bind_socket, 2);
+  rb_define_method(cLibevent_Http, "set_request_handler", t_set_request_handler, 1);
+  rb_define_method(cLibevent_Http, "set_timeout", t_set_timeout, 1);
+  rb_define_method(cLibevent_Http, "add_virtual_host", t_add_virtual_host, 2);
+}
+
+/*
+ * Allocate memory
+ */
+static VALUE t_allocate(VALUE klass) {
+  Libevent_Http *http = ALLOC(Libevent_Http);
+
+  http->ev_base = NULL;
+  http->ev_http = NULL;
+  http->ev_http_parent = NULL;
+
+  return Data_Wrap_Struct(klass, 0, t_free, http); 
+}
+
+/*
+ * Free memory
+ */
+static void t_free(Libevent_Http *http) {
+  if ( http->ev_http ) {
+    // main http frees all associated vhosts
+    if ( http->ev_http_parent == NULL )
+      evhttp_free(http->ev_http);
+  }
+
+  xfree(http);
+}
+
+/*
+ * Initialize http instance and allocate evhttp structure
+ *
+ * @param [Base] object
+ * @yield [self]
+ */
+static VALUE t_initialize(VALUE self, VALUE object) {
+  Libevent_Http *http;
+  Libevent_Base *base;
+
+  Data_Get_Struct(self, Libevent_Http, http);
+  Data_Get_Struct(object, Libevent_Base, base);
+
+  http->ev_base = base->ev_base;
+  http->ev_http = evhttp_new(http->ev_base);
+
+  if (!http->ev_http) {
+    rb_fatal("Couldn't create evhttp");
+  }
+
+  rb_iv_set(self, "@base", object);
+
+  if (rb_block_given_p())
+    rb_yield(self);
+
+  return self;
+}
+
+/*
+ * Binds an HTTP instance on the specified address and port.
+ * Can be called multiple times to bind the same http server to multiple different ports.
+ * @param [String] address IP address
+ * @param [Fixnum] port port to bind
+ * @return [true] on success
+ * @return [false] on failure
+ */
+static VALUE t_bind_socket(VALUE self, VALUE address, VALUE port) {
+  Libevent_Http *http;
+  int status;
+
+  Data_Get_Struct(self, Libevent_Http, http);
+  Check_Type(address, T_STRING);
+  Check_Type(port, T_FIXNUM);
+  status = evhttp_bind_socket(http->ev_http, RSTRING_PTR(address), FIX2INT(port));
+
+  return ( status == -1 ? Qfalse : Qtrue );
+}
+
+/*
+ * Set a callback for all requests that are not caught by specific callbacks.
+ * @note
+ *   handler should response to :call method.
+ *
+ *   Libevent::HttpRequest instance will be passed to handler as first argument
+ *   
+ * @param [Object] handler object that response to :call
+ * @return [nil]
+ */
+static VALUE t_set_request_handler(VALUE self, VALUE handler) {
+  Libevent_Http *http;
+
+  Data_Get_Struct(self, Libevent_Http, http);
+
+  if ( !rb_respond_to(handler, rb_intern("call")))
+    rb_raise(rb_eArgError, "handler does not response to call method");
+
+  rb_iv_set(self, "@request_handler", handler);
+  evhttp_set_gencb(http->ev_http, t_request_handler, (void *)handler);
+
+  return Qnil;
+}
+
+/*
+ * C callback function that create HttpRequest instance and call Ruby handler object with it.
+ */
+static void t_request_handler(struct evhttp_request *ev_request, void* context) {
+  Libevent_HttpRequest *le_http_request;
+  VALUE http_request;
+  VALUE handler = (VALUE)context;
+
+  http_request = rb_obj_alloc(cLibevent_HttpRequest);
+  Data_Get_Struct(http_request, Libevent_HttpRequest, le_http_request);
+  le_http_request->ev_request = ev_request;
+  rb_obj_call_init(http_request, 0, 0);
+
+  rb_funcall(handler, rb_intern("call"), 1, http_request);
+}
+
+/*
+ * Set the timeout for an HTTP request.
+ * @param [Fixnum] timeout he timeout, in seconds
+ * return nil
+ */
+static VALUE t_set_timeout(VALUE self, VALUE timeout) {
+  Libevent_Http *http;
+
+  Data_Get_Struct(self, Libevent_Http, http);
+  evhttp_set_timeout(http->ev_http, NUM2INT(timeout));
+
+  return Qnil;
+}
+
+/*
+ * Adds a virtual host to the http server.
+ * It is possible to have hierarchical vhosts.
+ * @param [String] domain the glob pattern against which the hostname is matched. The match is case insensitive and follows otherwise regular shell matching.
+ * @param [Http] vhttp the virtual host to add the regular http server
+ * @return [true false]
+ * @example 
+ *   A vhost with the pattern *.example.com may have other vhosts with patterns foo.example.com and bar.example.com associated with it.
+ * @note
+ *   A virtual host is a newly initialized evhttp object that has request handler
+ *   It most not have any listing sockets associated with it.
+ */
+static VALUE t_add_virtual_host(VALUE self, VALUE domain, VALUE vhttp) {
+  Libevent_Http *le_http;
+  Libevent_Http *le_vhttp;
+  int status;
+
+  Data_Get_Struct(self, Libevent_Http, le_http);
+  Data_Get_Struct(vhttp, Libevent_Http, le_vhttp);
+  Check_Type(domain, T_STRING);
+  le_vhttp->ev_http_parent = le_http->ev_http;
+  status = evhttp_add_virtual_host(le_http->ev_http, RSTRING_PTR(domain), le_vhttp->ev_http);
+
+  return ( status == -1 ? Qfalse : Qtrue );
+}
+