libevent 0.0.1

data/ext/libevent_ext/ruby18_compat.h

@@ -0,0 +1,14 @@
+#ifndef RUBY_19
+#ifndef STRING_PTR
+#define STRING_PTR(v) (RSTRING(v)->ptr)
+#endif
+#ifndef RFLOAT_VALUE
+#define RFLOAT_VALUE(v) (RFLOAT(v)->value)
+#endif
+#ifndef RARRAY_LEN
+#define RARRAY_LEN(v) (RARRAY(v)->len)
+#endif
+#ifndef RARRAY_PTR
+#define RARRAY_PTR(v) (RARRAY(v)->ptr)
+#endif
+#endif

data/ext/libevent_ext/signal.c

@@ -0,0 +1,107 @@
+#include "ext.h"
+
+static VALUE t_allocate(VALUE klass);
+
+static void t_free(Libevent_Signal *signal);
+
+static VALUE t_initialize(VALUE self, VALUE base, VALUE name, VALUE handler);
+
+static VALUE t_destroy(VALUE self);
+
+static void t_handler(evutil_socket_t signal_number, short events, void *context);
+
+void Init_libevent_signal() {
+  cLibevent_Signal = rb_define_class_under(mLibevent, "Signal", rb_cObject);
+  
+  rb_define_alloc_func(cLibevent_Signal, t_allocate);
+
+  rb_define_method(cLibevent_Signal, "initialize", t_initialize, 3);
+  rb_define_method(cLibevent_Signal, "destroy", t_destroy, 0);
+}
+
+/*
+ * Allocate memory
+ */
+static VALUE t_allocate(VALUE klass) {
+  Libevent_Signal *signal;
+
+  signal = ALLOC(Libevent_Signal);
+  return Data_Wrap_Struct(klass, 0, t_free, signal); 
+}
+
+/*
+ * Free memory
+ */
+static void t_free(Libevent_Signal *signal) {
+  if ( signal->ev_event ) {
+    event_free(signal->ev_event);
+  }
+
+  xfree(signal);
+}
+
+/*
+ * Create and add signal to specified event base with handler block
+ *
+ * @note method allocates memory for <b>struct event </b>
+ *   that will be freed when object will be freed by ruby' GC
+ *
+ * @param [Base] base event base instance
+ * @param [String] name a name of signal
+ * @param [Object] handler object that perform signal handling. Any object that responds to :call method
+ *
+ */
+static VALUE t_initialize(VALUE self, VALUE base, VALUE name, VALUE handler) {
+  Libevent_Signal *le_signal;
+  Libevent_Base *le_base;
+  VALUE signal_list;
+  VALUE signal_number;
+
+  Data_Get_Struct(self, Libevent_Signal, le_signal);
+  Data_Get_Struct(base, Libevent_Base, le_base);
+
+  // check name
+  signal_list = rb_funcall( rb_const_get(rb_cObject, rb_intern("Signal")), rb_intern("list"), 0);
+  signal_number = rb_hash_aref(signal_list, name);
+  if ( signal_number == Qnil )
+    rb_raise(rb_eArgError, "unknown signal name given");
+  rb_iv_set(self, "@name", name);
+
+  // check handler
+  if ( !rb_respond_to(handler, rb_intern("call")))
+    rb_raise(rb_eArgError, "handler does not response to call method");
+  rb_iv_set(self, "@handler", handler);
+
+  // create signal event
+  le_signal->ev_event = evsignal_new(le_base->ev_base, FIX2INT(signal_number), t_handler, (void *)handler);
+  if ( !le_signal->ev_event )
+    rb_fatal("Could not create a signal event");
+  if ( event_add(le_signal->ev_event, NULL) < 0 )
+    rb_fatal("Could not add a signal event");
+
+  return self;
+}
+
+/*
+ * Delete signal from event base
+ * @return [true] on success
+ * @return [false] on failure
+ */
+static VALUE t_destroy(VALUE self) {
+  Libevent_Signal *le_signal;
+  int status;
+
+  Data_Get_Struct(self, Libevent_Signal, le_signal);
+  status = event_del(le_signal->ev_event);
+
+  return( status == -1 ? Qfalse : Qtrue);
+}
+
+/*
+ * C callback function that invokes call method on  Ruby object.
+ */
+static void t_handler(evutil_socket_t signal_number, short events, void *context) {
+  VALUE handler = (VALUE)context;
+
+  rb_funcall(handler, rb_intern("call"), 0);
+}

data/lib/libevent.rb

@@ -0,0 +1,9 @@
+require "libevent/version"
+
+require "libevent_ext"
+
+require "libevent/base"
+require "libevent/signal"
+require "libevent/http"
+require "libevent/http_request"
+require "libevent/builder"

data/lib/libevent/base.rb

@@ -0,0 +1,18 @@
+module Libevent
+  class Base
+    # Create new event base
+    def initialize
+      @signals = []
+    end
+
+    attr_reader :signals
+
+    # Create new signal with handler as block and add signal to event base
+    #
+    # @param [String] name of signal
+    def trap_signal(name, &block)
+      @signals << Signal.new(self, name, block)
+    end
+
+  end
+end

data/lib/libevent/builder.rb

@@ -0,0 +1,32 @@
+module Libevent
+  class Builder
+    def initialize(options = {}, &block)
+      @base = Base.new
+      instance_eval(&block) if block_given?
+    end
+
+    attr_reader :base
+
+    # Create new Http instance, bind socket and options yield http object
+    # @param [String] host
+    # @param [Fixnum] port
+    # @return [Http] instance
+    def server(host, port, &block)
+      http = Http.new(@base)
+      http.bind_socket(host, port) or raise RuntimeError, "can't bind socket #{host}:#{port}"
+      yield(http) if block_given?
+      http
+    end
+
+    # Trap signal using event base
+    # @param [String] name a signal name
+    def signal(name, &block)
+      base.trap_signal(name, &block)
+    end
+
+    # Start event base loop
+    def dispatch
+      base.dispatch
+    end
+  end
+end

data/lib/libevent/http.rb

@@ -0,0 +1,23 @@
+module Libevent
+  class Http
+
+    attr_reader :base
+
+    # Create virtual http server
+    # @param [String] domain a domain for virtual server
+    # @return [Http] http instance
+    def vhost(domain)
+      http = self.class.new(self.base)
+      add_virtual_host(domain, http)
+      yield(http) if block_given?
+      http
+    end
+
+    # Set request handler for current http instance
+    # @param block
+    def handler(&block)
+      set_request_handler(block)
+    end
+
+  end
+end

data/lib/libevent/http_request.rb

@@ -0,0 +1,4 @@
+module Libevent
+  class HttpRequest
+  end
+end

data/lib/libevent/signal.rb

@@ -0,0 +1,6 @@
+module Libevent
+  class Signal
+    attr_reader :name
+  end
+end
+

data/lib/libevent/version.rb

@@ -0,0 +1,3 @@
+module Libevent
+  VERSION = "0.0.1"
+end

data/lib/rack/handler/libevent.rb

@@ -0,0 +1,97 @@
+require "libevent"
+require "stringio"
+
+module Rack
+  module Handler
+    class Libevent
+
+      def self.run(app, options)
+        server = new(app, options)
+        server.start
+      end
+
+      def self.valid_options
+        {
+          "timeout=TIMEOUT" => "Set the timeout for an HTTP request"
+        }
+      end
+
+      def initialize(app, options)
+        @app = app
+        
+        options[:Host] or raise ArgumentError, "Host option required"
+        options[:Port] or raise ArgumentError, "Port option required"
+
+        @host = options[:Host]
+        @port = options[:Port].to_i
+
+        @base = ::Libevent::Base.new
+        @http = ::Libevent::Http.new(@base)
+
+        @http.set_timeout(options[:timeout].to_i) if options[:timeout]
+      end
+
+      def start
+        @http.bind_socket(@host, @port) or raise RuntimeError, "Can't bind to #{@host}:#{@port}"
+        @http.set_request_handler(self.method(:process))
+
+        @base.trap_signal("INT")  { self.stop }
+        @base.trap_signal("TERM") { self.stop }
+
+        @base.dispatch
+      end
+
+      def stop
+        @base.exit_loop
+      end
+
+      protected
+
+      def process(request)
+        env = {}
+
+        env['REQUEST_METHOD']    = request.get_command
+        env['SCRIPT_NAME']       = ''
+        env['REQUEST_PATH']      = '/'
+        env['PATH_INFO']         = request.get_uri_path  || '/'
+        env['QUERY_STRING']      = request.get_uri_query || ''
+        env['SERVER_NAME']       = request.get_host || @host
+        env['SERVER_PORT']       = @port.to_s
+        env['SERVER_SOFTWARE']   = "libevent/#{::Libevent::VERSION}"
+        env['SERVER_PROTOCOL']   = 'HTTP/1.1'
+        env['REMOTE_ADDR']       = request.get_remote_host
+        env['HTTP_VERSION']      = request.get_http_version
+        env['rack.version']      = [1, 1]
+        env['rack.url_scheme']   = request.get_uri_scheme || 'http'
+        env['rack.input']        = StringIO.new(request.get_body)
+        env['rack.errors']       = STDERR
+        env['rack.multithread']  = false
+        env['rack.multiprocess'] = false
+        env['rack.run_once']     = false
+
+        request.get_input_headers.each do |key, val|
+          env_key = ""
+          env_key << "HTTP_" unless key =~ /^content(_|-)(type|length)$/i
+          env_key << key
+          env_key.gsub!('-','_')
+          env_key.upcase!
+          env[env_key] = val
+        end
+
+        code, headers, body = @app.call(env)
+
+        begin
+          headers.each do |key, values|
+            values.split("\n").each { |value| request.add_output_header(key, value) }
+          end
+          request.send_reply_start(code, nil)
+          body.each { |chunk| request.send_reply_chunk(chunk) }
+          request.send_reply_end
+        ensure
+          body.close if body.respond_to?(:close)
+        end
+      end
+    end
+
+  end
+end

data/libevent.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "libevent/version"
+
+Gem::Specification.new do |s|
+  s.name        = "libevent"
+  s.version     = Libevent::VERSION
+  s.authors     = ["Andriy Yanko"]
+  s.email       = ["andriy.yanko@gmail.com"]
+  s.homepage    = "https://github.com/ayanko/libevent"
+  s.summary     = %q{C extension for libevent}
+  s.description = %q{C extension for libevent}
+
+  s.rubyforge_project = "libevent"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.extensions = ["ext/libevent_ext/extconf.rb"]
+end

data/samples/rack_request_inspect

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require "libevent"
+require "rack/handler/libevent"
+
+app = lambda { |env| 
+  body = []
+  body << "RACK_ENVIRONMENT:\n"
+  env.sort.each { |pair| body << "%-20s : %s\n" % pair }
+  body << "RACK_INPUT_START"
+  body << env['rack.input'].read
+  body << "RACK_INPUT_END\n"
+
+  headers = {}
+  headers['Content-Type'] = 'text/plain'
+  headers['Content-Length'] = body.inject(0) { |sum, chunk| sum += chunk.size }.to_s
+  headers['Set-Cookie'] = "one=first\nsecond=two"
+
+  [ 200, headers, body ]
+}
+
+Rack::Handler::Libevent.run(app, {
+  :Host    => "0.0.0.0",
+  :Port    => 3000,
+  :timeout => 60,
+})

data/samples/simple.rb

@@ -0,0 +1,22 @@
+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
+

data/samples/virtual_hosts

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require "libevent"
+
+# curl -v -H 'Host: blog.local' http://localhost:3001/hello
+# curl -v -H 'Host: blog.local' http://localhost:3001/api
+# curl -v -H 'Host: wiki.local' http://localhost:3001
+# curl -v -H 'Host: any.local' http://localhost:3001
+
+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 4000" ]
+    end
+  end
+
+  signal("INT") do
+    base.exit_loop
+  end
+
+  signal("HUP") do
+    Kernel.puts "HUP received ..."
+  end
+
+  dispatch
+
+end