evdispatch 0.1.0

data/ext/revdispatch/libevdispatch/test/next_test.cc

@@ -0,0 +1,86 @@
+#include "ev_dispatch.h"
+
+using namespace EVD;
+
+
+// catch SIGINT to kill process 
+static void  SIGINT_handler(int sig)
+{
+  exit(sig);
+}
+
+static void run_tests( Dispatch &dispatcher, int count )
+{
+  time_t start_time = time(NULL);
+  int expected_response_count = 0;
+  int response_count = 0;
+
+  dispatcher.request(Request::HTTP, "http://127.0.0.1:4044/bytes/10200/");
+  ++expected_response_count;
+  dispatcher.request(Request::HTTP, "http://127.0.0.1:4044/bytes/10080/");
+  ++expected_response_count;
+  dispatcher.request(Request::HTTP, "http://127.0.0.1:4044/delay/2/");
+  ++expected_response_count;
+  dispatcher.request(Request::HTTP, "http://127.0.0.1:4044/bytes/100900/");
+  ++expected_response_count;
+  dispatcher.request(Request::HTTP, "http://127.0.0.1:4044/delay/1/");
+  ++expected_response_count;
+  dispatcher.request(Request::HTTP, "http://127.0.0.1:4044/delay/1/");
+  ++expected_response_count;
+  dispatcher.request(Request::HTTP, "http://127.0.0.1:4044/delay/3/");
+  ++expected_response_count;
+  dispatcher.request(Request::HTTP, "http://127.0.0.1:4044/bytes/1010/");
+  ++expected_response_count;
+
+  //ev_sleep(0.2);
+
+  Response *rep = NULL;
+  Timer timeout(2,0);
+  double longest_request = 0.0;
+
+  while( expected_response_count > 0 && (rep = dispatcher.get_next_response(timeout)) ){
+    if( longest_request < rep->response_time ){
+      longest_request = rep->response_time;
+    }
+    printf( "recieved response(%d): from '%s', Content-Length: %d bytes, within: %.2f seconds \n", rep->id, rep->name.c_str(), rep->body.length(), rep->response_time );
+    ++response_count;
+    delete rep;
+    --expected_response_count;
+  }
+  
+  if( expected_response_count != 0 ){
+    printf( "Expected: %d responses but recieved: %d\n", expected_response_count, response_count );
+  }
+  printf( "%d responses completed, within %.2f seconds\n", response_count, difftime( time(NULL), start_time ) );
+  printf( "longest request: %.2f\n", longest_request );
+}
+
+int main(int argc, char **argv)
+{
+  Dispatch dispatcher;
+
+  if (signal(SIGINT, SIGINT_handler) == SIG_ERR) {
+    printf("SIGINT install error\n");
+    exit(1);
+  }
+
+  if( !dispatcher.start() ){
+    fprintf( stderr, "Failed to start up dispatcher\n" );
+    return 1;
+  }
+
+  printf( "dispatcher thread running...\n" );
+
+  time_t start_time = time(NULL);
+
+  run_tests( dispatcher, 10 );
+  run_tests( dispatcher, 10 );
+  run_tests( dispatcher, 10 );
+  run_tests( dispatcher, 10 );
+
+  printf( "total time: %.2f seconds\n", difftime( time(NULL), start_time ) );
+
+  dispatcher.stop();
+
+  return 0;
+}

data/ext/revdispatch/libevdispatch/test/next_test.rb

@@ -0,0 +1,8 @@
+test_dir = File.dirname(__FILE__) 
+require test_dir + '/helper'
+puts "starting up ebb";
+Thread.start{ Ebb.start_server(HelperApp.new, :port => TEST_PORT) }
+sleep 0.1 until Ebb.running?
+system("#{test_dir}/next_test")  
+Ebb.stop_server
+sleep 0.1 while Ebb.running?

data/ext/revdispatch/libevdispatch/test/server.rb

@@ -0,0 +1,9 @@
+# shamelessly copied directly from ebb gem
+require File.dirname(__FILE__) + '/helper'
+trap("INT") {
+puts "got int"
+  Ebb.stop_server
+  sleep 0.1 while Ebb.running?
+}
+puts "starting up ebb";
+Ebb.start_server(HelperApp.new, :port => TEST_PORT)

data/ext/revdispatch/revdispatch.cc

@@ -0,0 +1,151 @@
+#include <ruby.h>
+#include "ev_dispatch.h"
+
+/* ruby 1.9 compat */
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(str) RSTRING(str)->ptr
+#endif
+
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(str) RSTRING(str)->len
+#endif
+
+
+/*
+ *
+ * Using ruby dispatch interface:
+ *
+ * require 'rev_dispatch'
+ * 
+ * # create a new dispatch loop
+ * d = Rev::Dispatch::Loop.new
+ *
+ * # start the event loop thread
+ *
+ * # send a dispatch http request and store a handle to the request
+ * google_id = d.request("get", "http://www.google.com/")
+ *
+ * # do some processing and later on check for the response
+ * while d.wait_for_response( google_id, 1, 0 )
+ *   res = d.response_for( google_id )
+ *   break if res
+ * end
+ * res = d.response_for( google_id ) unless res
+ *
+ * puts res.inspect # array of response values
+ *
+ * # sometime later you can stop the event loop
+ * d.stop
+ *
+ *
+ * You only get 1 background event loop, calling start multiple times will have no effect.
+ * You typically don't need or want to stop the event loop after it's active. It will sit in the 
+ * background and happily wait for new requests using a minimal amount of cpu while waiting.
+ * Everything in the background thread is written in C++ and has absolutely no hooks back into ruby.
+ * The results of the work being processed in the background can be retrieved by ruby but that is it.
+ */
+static VALUE rb_Evdispatch;
+static VALUE rb_Loop;
+
+static
+VALUE Loop_start( VALUE self )
+{
+  EVD::Dispatch *d;
+  Data_Get_Struct( self, EVD::Dispatch, d );
+
+  d->start();
+
+  return self;
+}
+
+static
+VALUE Loop_request_http( VALUE self, VALUE url )
+{
+  EVD::Dispatch *d;
+  Data_Get_Struct( self, EVD::Dispatch, d );
+
+  EVD::request_t id = d->request( EVD::Request::HTTP, RSTRING_PTR(url) );
+
+  return rb_int_new(id);
+}
+
+static 
+VALUE Loop_wait_for_response( VALUE self, VALUE id, VALUE timeout_seconds, VALUE timeout_mseconds )
+{
+  EVD::Dispatch *d;
+  EVD::Queue<EVD::Response>::POP_STATE rstate;
+  EVD::request_t rid = FIX2LONG(id);
+
+  Data_Get_Struct( self, EVD::Dispatch, d );
+
+  rstate = d->wait_for_response_by_id( rid, EVD::Timer(FIX2LONG(timeout_seconds), FIX2LONG(timeout_mseconds)) );
+
+  return rb_int_new(rstate);
+}
+
+static 
+VALUE Loop_response_for( VALUE self, VALUE id )
+{
+  EVD::Dispatch *d;
+  Data_Get_Struct( self, EVD::Dispatch, d );
+
+  EVD::Response *res = NULL;
+  EVD::request_t rid = FIX2LONG(id);
+
+  res = d->response_for( rid );
+  if( res ){
+
+    VALUE result = rb_hash_new();
+
+    rb_hash_aset( result, ID2SYM(rb_intern("name")), rb_str_new( res->name.c_str(), res->name.length() ) );
+    rb_hash_aset( result, ID2SYM(rb_intern("body")), rb_str_new( res->body.c_str(), res->body.length() ) );
+    rb_hash_aset( result, ID2SYM(rb_intern("id")), rb_int_new( res->id ) );
+    rb_hash_aset( result, ID2SYM(rb_intern("response_time")), rb_float_new( res->response_time ) );
+
+    delete res;
+
+    return result;
+  }
+  return Qnil;
+}
+
+static 
+VALUE Loop_stop( VALUE self )
+{
+  EVD::Dispatch *d;
+  Data_Get_Struct( self, EVD::Dispatch, d );
+
+  d->stop();
+  return Qnil;
+}
+
+static
+void Loop_free( EVD::Dispatch *d )
+{
+  delete d;
+}
+
+static
+VALUE Loop_alloc(VALUE klass)
+{
+  VALUE object;
+  EVD::Dispatch *d = new EVD::Dispatch();
+
+  object = Data_Wrap_Struct( klass, NULL, Loop_free, d );
+
+  return object;
+}
+
+extern "C" void Init_revdispatch()
+{
+  rb_Evdispatch = rb_define_module( "Evdispatch" );
+  rb_Loop = rb_define_class_under( rb_Evdispatch, "Loop", rb_cObject );
+
+  rb_define_alloc_func( rb_Loop, Loop_alloc );
+  
+  rb_define_method( rb_Loop, "start", (VALUE (*)(...))Loop_start, 0 );
+  rb_define_method( rb_Loop, "request_http", (VALUE (*)(...))Loop_request_http, 1 );
+  rb_define_method( rb_Loop, "response_for", (VALUE (*)(...))Loop_response_for, 1 );
+  rb_define_method( rb_Loop, "wait_for_response", (VALUE (*)(...))Loop_wait_for_response, 3 );
+  rb_define_method( rb_Loop, "stop", (VALUE (*)(...))Loop_stop, 0 );
+}

data/ext/revdispatch/server.rb

@@ -0,0 +1,60 @@
+require 'rubygems'
+require 'ebb'
+
+Ebb.log = File.open('/dev/null','w')
+
+TEST_PORT = 4044
+
+
+class HelperApp
+  def call(env)
+    commands = env['PATH_INFO'].split('/')
+
+    if commands.include?('delay')
+      n = commands.last.to_i
+      raise "delay called with n <= 0" if n < 0
+      sleep n
+      body = "delayed #{n} seconds"
+      status = 200
+
+    elsif commands.include?('bytes')
+      n = commands.last.to_i
+      raise "bytes called with n <= 0" if n <= 0
+      body = "C"*n
+      status = 200
+      
+    elsif commands.include?('test_post_length')
+      input_body = env['rack.input'].read
+      
+      content_length_header = env['HTTP_CONTENT_LENGTH'].to_i
+      
+      if content_length_header == input_body.length
+        body = "Content-Length matches input length"
+        status = 200
+      else
+        body = "Content-Length header is #{content_length_header} but body length is #{input_body.length}"
+        status = 500
+      end
+      
+    else
+      status = 404
+      body = "Undefined url"
+    end
+
+    [status, {'Content-Type' => 'text/json'}, body]
+  end
+end
+
+def start
+  puts "starting up ebb";
+  Thread.start{ Ebb.start_server(HelperApp.new, :port => TEST_PORT) }
+  sleep 0.1 until Ebb.running?
+
+  Signal.trap( "HUP" ){
+    Ebb.stop_server
+    sleep 0.1 while Ebb.running?
+  }
+
+  # keep process alive
+  sleep 0.5 while Ebb.running?
+end

data/ext/revdispatch/test.rb

@@ -0,0 +1,100 @@
+require 'evdispatch'
+
+# to run this through valgrind run the server outside of this script
+# i run this: valgrind --leak-check=full ~/project/ruby-valgrind-env/bin/ruby test.rb r
+unless ARGV[0] == 'r'
+  pid = fork do
+    require 'server'
+    start
+  end
+end
+
+require 'ostruct'
+
+# NOTE: we define this part in ruby to make sure other ruby threads can execute while we wait
+class Evdispatch::Loop
+  def response(id)
+    while wait_for_response( id, 1, 0 )
+      res = response_for( id )
+      break if res
+    end
+    res = response_for( id ) unless res
+    res
+  end
+end
+
+def request_bytes_from( d, base, amount, range )
+  ids = []
+  amount.times do|i|
+    am = rand( range )
+    ids << d.request_http( base + "bytes/#{am}/" )
+  end
+  ids
+end
+
+def request_delay_from( d, base, amount, delay )
+  ids = []
+  amount.times do|i|
+    am = rand( delay )
+    ids << d.request_http( base + "delay/#{delay}/" )
+  end
+  ids
+end
+
+def run_trial
+
+  d = Evdispatch::Loop.new
+
+  # start the event loop thread
+  d.start
+
+
+  timer = Time.now
+  # send a dispatch http request and store a handle to the request
+  google_id = d.request_http("http://www.google.com/")
+
+  # do some processing and later on check for the response
+  response = d.response( google_id )
+  puts "Requested: #{response[0]} in #{Time.now - timer} seconds"
+
+  ebbbase = "http://127.0.0.1:4044/"
+  timer = Time.now
+  ids = request_bytes_from( d, ebbbase, 20, 1000 )
+  ids += request_delay_from( d, ebbbase, 20, 1 )
+
+  # wait for each response
+  puts "expecting #{ids.size} responses..."
+  ids.each do|id|
+    response = d.response( id )
+    #puts response[:name]
+    ObjectSpace.garbage_collect
+  end
+
+  puts "recieved #{ids.size} responses in #{Time.now - timer} seconds"
+
+  # sometime later you can stop the event loop
+  d.stop
+
+end
+
+sleep 1 unless ARGV[0] == 'r'
+
+ObjectSpace.garbage_collect
+
+count = ObjectSpace.each_object { }
+puts "Starting Total objects: #{count}"
+
+begin
+run_trial
+rescue => e
+  puts e.message, e.backtrace
+end
+
+
+Process.kill('HUP', pid) unless ARGV[0] == 'r'
+
+count = ObjectSpace.each_object { }
+puts "Final Total objects: #{count}"
+ObjectSpace.garbage_collect
+count = ObjectSpace.each_object { }
+puts "After garbage collection objects: #{count}"

data/lib/evdispatch/loop.rb

@@ -0,0 +1,16 @@
+require 'revdispatch'
+
+# define this part in ruby to make sure other
+# ruby threads can execute while we waiting for a response
+module Evdispatch
+  class Loop
+    def response(id)
+      while wait_for_response( id, 1, 0 )
+        res = response_for( id )
+        break if res
+      end
+      res = response_for( id ) unless res
+      res
+    end
+  end
+end

data/lib/evdispatch/version.rb

@@ -0,0 +1,9 @@
+module Evdispatch #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/evdispatch.rb

@@ -0,0 +1,8 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+module Evdispatch
+  
+end
+
+require 'evdispatch/loop'

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/evdispatch.rb'}"
+puts "Loading evdispatch gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/script/txt2html

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+begin
+  require 'newgem'
+rescue LoadError
+  puts "\n\nGenerating the website requires the newgem RubyGem"
+  puts "Install: gem install newgem\n\n"
+  exit(1)
+end
+require 'redcloth'
+require 'syntax/convertors/html'
+require 'erb'
+require File.dirname(__FILE__) + '/../lib/evdispatch/version.rb'
+
+version  = Evdispatch::VERSION::STRING
+download = 'http://rubyforge.org/projects/evdispatch'
+
+class Fixnum
+  def ordinal
+    # teens
+    return 'th' if (10..19).include?(self % 100)
+    # others
+    case self % 10
+    when 1: return 'st'
+    when 2: return 'nd'
+    when 3: return 'rd'
+    else    return 'th'
+    end
+  end
+end
+
+class Time
+  def pretty
+    return "#{mday}#{mday.ordinal} #{strftime('%B')} #{year}"
+  end
+end
+
+def convert_syntax(syntax, source)
+  return Syntax::Convertors::HTML.for_syntax(syntax).convert(source).gsub(%r!^<pre>|</pre>$!,'')
+end
+
+if ARGV.length >= 1
+  src, template = ARGV
+  template ||= File.join(File.dirname(__FILE__), '/../website/template.html.erb')
+  
+else
+  puts("Usage: #{File.split($0).last} source.txt [template.html.erb] > output.html")
+  exit!
+end
+
+template = ERB.new(File.open(template).read)
+
+title = nil
+body = nil
+File.open(src) do |fsrc|
+  title_text = fsrc.readline
+  body_text = fsrc.read
+  syntax_items = []
+  body_text.gsub!(%r!<(pre|code)[^>]*?syntax=['"]([^'"]+)[^>]*>(.*?)</\1>!m){
+    ident = syntax_items.length
+    element, syntax, source = $1, $2, $3
+    syntax_items << "<#{element} class='syntax'>#{convert_syntax(syntax, source)}</#{element}>"
+    "syntax-temp-#{ident}"
+  }
+  title = RedCloth.new(title_text).to_html.gsub(%r!<.*?>!,'').strip
+  body = RedCloth.new(body_text).to_html
+  body.gsub!(%r!(?:<pre><code>)?syntax-temp-(\d+)(?:</code></pre>)?!){ syntax_items[$1.to_i] }
+end
+stat = File.stat(src)
+created = stat.ctime
+modified = stat.mtime
+
+$stdout << template.result(binding)