eventmachine 0.12.6-java

data/tasks/cpp.rake

@@ -0,0 +1,77 @@
+# EventMachine C++ Rakefile Stab Case
+# TODO : track header files as a build dependency...
+# TODO : cross platform support
+# TODO : configure style functionality
+namespace :cpp do
+
+  require 'rake/clean'
+
+  # *nix only atm...
+  module Cpp
+    class <<self
+      def cpp; "g++"; end
+      def archive; "ar"; end
+      def compile file, output, includes=nil, flags=nil
+        sh %{#{cpp} #{file} #{includes} #{flags} -c -o #{output}}
+      end
+      def link file, output, libs=nil, flags=nil
+        sh %{#{cpp} #{file} #{libs} #{flags} -o #{output}}
+      end
+      def static output, files
+        sh %{#{archive} cr #{output} #{files}}
+      end
+    end
+  end
+
+  module EmConfig
+    Path = ENV['EVENTMACHINE_SOURCE'] || 'ext'
+    Sources = FileList["#{Path}/*.cpp"]
+    Sources.delete_if { |s| /ruby/ =~ s }
+    Compiled = Sources.sub(%r{^#{Path}/(.*)\.cpp}, "#{Path}/\\1.o")
+
+    Flags = "-O2 -pipe -fno-common -DOS_UNIX -DWITHOUT_SSL"
+    Includes = ""
+    Libs = ''
+  end
+  CLEAN.include(EmConfig::Compiled)
+
+  rule %r{^#{EmConfig::Path}/.*\.o$} => [proc { |targ| 
+    targ.sub(%r{^#{EmConfig::Path}/(.*)\.o$}, "#{EmConfig::Path}/\\1.cpp")
+    }] do |t|
+    Cpp.compile t.source, t.name, EmConfig::Includes, EmConfig::Flags
+  end
+
+  file "#{EmConfig::Path}/libeventmachine.a" => EmConfig::Compiled do |t|
+    Cpp.static t.name, EmConfig::Compiled
+  end
+  CLEAN.include("#{EmConfig::Path}/libeventmachine.a")
+
+  module AppConfig
+    Appname = 'echo_em'
+    Sources = FileList['*.cpp']
+    Compiled = Sources.sub(%r{^(.*)\.cpp}, '\\1.o')
+
+    Flags = ["", EmConfig::Flags].join(' ')
+    Includes = ["-I. -I#{EmConfig::Path}", EmConfig::Includes].join(' ')
+    Libs = ["-L#{EmConfig::Path} -leventmachine", EmConfig::Libs].join(' ')
+  end
+  CLEAN.include(AppConfig::Compiled)
+  CLEAN.include(AppConfig::Appname)
+
+  rule %r{^.*\.o$} => [proc { |targ| 
+    targ.sub(%r{^(.*)\.o$}, '\\1.cpp')
+    }] do |t|
+    Cpp.compile t.source, t.name, AppConfig::Includes, AppConfig::Flags
+  end
+
+  file AppConfig::Appname => ["#{EmConfig::Path}/libeventmachine.a", AppConfig::Compiled] do |t|
+    Cpp.link AppConfig::Compiled, t.name, AppConfig::Libs, AppConfig::Flags
+  end
+
+  task :build => AppConfig::Appname
+
+  task :run => AppConfig::Appname do
+    sh "./#{AppConfig::Appname}"
+  end
+
+end

data/tasks/project.rake

@@ -0,0 +1,78 @@
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/clean'
+
+# monkey bitchin' for windows stuffs...
+module FileUtils
+  # If any of these methods ever clobber, try removing them.
+  # Hopefully they'll do something semantically similar.
+  abort "Err: #{__FILE__}:#{__LINE__} monkey patch windows? clobbers!" unless instance_methods.grep(/windows\?/).empty?
+  abort "Err: #{__FILE__}:#{__LINE__} monkey patch sudo clobbers!" unless instance_methods.grep(/sudo/).empty?
+  abort "Err: #{__FILE__}:#{__LINE__} monkey patch gem_cmd clobbers!" unless instance_methods.grep(/gem_cmd/).empty?
+  def windows?; RUBY_PLATFORM =~ /mswin|mingw/; end
+  def sudo(cmd)
+    if windows? || (require 'etc'; Etc.getpwuid.uid == 0)
+      sh cmd
+    else
+      sh "sudo #{cmd}"
+    end
+  end
+  def gem_cmd(action, name, *args)
+    rb = Gem.ruby rescue nil
+    rb ||= (require 'rbconfig'; File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name']))
+    sudo "#{rb} -r rubygems -e 'require %{rubygems/gem_runner}; Gem::GemRunner.new.run(%w{#{action} #{name} #{args.join(' ')}})'"
+  end
+end
+
+
+# Setup our packaging tasks, we're just jacking the builtins.
+Rake::GemPackageTask.new(Spec) do |pkg|
+  pkg.need_tar, pkg.need_tar_gz, pkg.need_zip = true, true, true if Package
+  pkg.gem_spec = Spec
+end
+Rake::Task[:clean].enhance [:clobber_package]
+
+# Only generate rdoc if the spec says so, again, jack the builtins.
+if Spec.has_rdoc
+  Rake::RDocTask.new do |rd|
+    rd.title = Spec.name
+    rd.rdoc_dir = 'rdoc'
+    rd.main = "docs/README" if test ?e, "docs/README"
+    rd.rdoc_files.include("lib/**/*.rb", *Spec.extra_rdoc_files)
+  end
+  Rake::Task[:clean].enhance [:clobber_rdoc]
+
+  desc 'Generate and open documentation'
+  task :docs => :rdoc do
+    case RUBY_PLATFORM
+    when /darwin/       ; sh 'open rdoc/index.html'
+    when /mswin|mingw/  ; sh 'start rdoc\index.html'
+    else 
+      sh 'firefox rdoc/index.html'
+    end
+  end
+end
+
+if Spec.default_executable
+  desc "Run #{Spec.default_executable}"
+  task :run do ruby File.join(Spec.bindir, Spec.default_executable) end
+end
+
+require 'rubygems'
+
+desc 'Install gem (and sudo if required)'
+task :install => :package do 
+  gem_cmd(:install, "pkg/#{Spec.name}-#{Spec.version}.gem")
+end
+
+desc 'Uninstall gem (and sudo if required)'
+task :uninstall do
+  gem_cmd(:uninstall, "#{Spec.name}", "-v=#{Spec.version}")
+end
+
+# Find an scm's store directory, if we do, make a task to commit to it only
+# after running all the tests (successfully).
+if scm = %w(git svn bzr hg).find { |d| File.directory? ".#{d}" }
+  desc "Run tests then commit to #{scm}"
+  task :commit => :test do sh "#{scm} commit" end
+end

data/tasks/tests.rake

@@ -0,0 +1,193 @@
+# This is used by several rake tasks, that parameterize the
+# behavior so we can use the same tests to test both the
+# extension and non-extension versions.
+def run_tests t, libr = :cascade, test_files="test_*.rb"
+  require 'test/unit/testsuite'
+  require 'test/unit/ui/console/testrunner'
+  require 'tests/testem'
+  
+  base_dir = File.expand_path(File.dirname(__FILE__) + '/../') + '/'
+  
+  runner = Test::Unit::UI::Console::TestRunner
+  
+  $eventmachine_library = libr
+  EmTestRunner.run(test_files)
+  
+  suite = Test::Unit::TestSuite.new($name)
+
+  ObjectSpace.each_object(Class) do |testcase|
+    suite << testcase.suite if testcase < Test::Unit::TestCase
+  end
+
+  runner.run(suite)
+end
+
+desc "Run tests for #{Spec.name}."
+task :test do |t|
+  # run_tests t
+  # Rake +/ friends leave threads, etc, less stable test runs.
+  ruby "-Ilib -Iext -Iext/fastfilereader -Ijava tests/testem.rb #{'-v' if ENV['VERBOSE']}"
+end
+
+namespace :test do
+  desc "Run tests for #{Spec.name}."
+  task :partial do |t|
+    lib = RUBY_PLATFORM =~ /java/ ? :java : :extension
+    run_tests t, lib, [
+      "test_basic.rb",
+      "test_epoll.rb",
+      "test_errors.rb",
+      "test_error_handler.rb",
+      "test_eventables.rb",
+      "test_exc.rb",
+      "test_futures.rb",
+      "test_hc.rb",
+      "test_httpclient2.rb",
+      "test_httpclient.rb",
+      "test_kb.rb",
+      "test_ltp2.rb",
+      "test_ltp.rb",
+      "test_next_tick.rb",
+      "test_processes.rb",
+      "test_pure.rb",
+      "test_running.rb",
+      "test_sasl.rb",
+      "test_send_file.rb",
+      "test_servers.rb",
+      "test_smtpclient.rb",
+      "test_smtpserver.rb",
+      "test_spawn.rb",
+      "test_timers.rb",
+      "test_ud.rb",
+    ].map { |tf| "tests/#{tf}" }
+  end
+  
+  desc "Run java tests for #$name."
+  task :testjava do |t|
+    run_tests t, :java
+  end
+
+  desc "Run pure-ruby tests for #$name."
+  task :testpr do |t|
+    run_tests t, :pure_ruby
+  end
+
+  desc "Run extension tests for #$name."
+  task :testext do |t|
+    run_tests t, :extension
+  end
+
+  desc "PROVISIONAL: run tests for user-defined events"
+  task :ud do |t|
+    run_tests t, :extension, "test_ud.rb"
+  end
+
+  desc "PROVISIONAL: run tests for line/text protocol handler"
+  task :ltp do |t|
+    run_tests t, :extension, "test_ltp*.rb"
+  end
+
+  desc "PROVISIONAL: run tests for header/content protocol handler"
+  task :hc do |t|
+    run_tests t, :extension, "test_hc.rb"
+  end
+
+  desc "PROVISIONAL: run tests for exceptions"
+  task :exc do |t|
+    run_tests t, :extension, "test_exc.rb"
+  end
+
+  desc "Test protocol handlers"
+  task :protocols => [ :hc, :ltp ]
+
+
+  desc "Test HTTP client"
+  task :httpclient do |t|
+    run_tests t, :extension, "test_httpclient.rb"
+  end
+
+  desc "Test HTTP client2"
+  task :httpclient2 do |t|
+    run_tests t, :extension, "test_httpclient2.rb"
+  end
+
+  desc "Test futures"
+  task :futures do |t|
+    run_tests t, :extension, "test_future*.rb"
+  end
+
+  desc "Test Timers"
+  task :timers do |t|
+    run_tests t, :extension, "test_timer*.rb"
+  end
+
+  desc "Test Next Tick"
+  task :next_tick do |t|
+    run_tests t, :extension, "test_next_tick*.rb"
+  end
+
+  desc "Test Epoll"
+  task :epoll do |t|
+    run_tests t, :extension, "test_epoll*.rb"
+  end
+
+  desc "Test Servers"
+  task :servers do |t|
+    run_tests t, :extension, "test_servers*.rb"
+  end
+
+  desc "Test Basic"
+  task :basic do |t|
+    run_tests t, :extension, "test_basic*.rb"
+  end
+
+  desc "Test Send File"
+  task :send_file do |t|
+    run_tests t, :extension, "test_send_file*.rb"
+  end
+
+  desc "Test Running"
+  task :running do |t|
+    run_tests t, :extension, "test_running*.rb"
+  end
+
+  desc "Test Keyboard Events"
+  task :keyboard do |t|
+    run_tests t, :extension, "test_kb*.rb"
+  end
+
+  desc "Test Spawn"
+  task :spawn do |t|
+    run_tests t, :extension, "test_spawn*.rb"
+  end
+
+  desc "Test SMTP"
+  task :smtp do |t|
+    run_tests t, :extension, "test_smtp*.rb"
+  end
+
+  desc "Test Errors"
+  task :errors do |t|
+    run_tests t, :extension, "test_errors*.rb"
+  end
+
+  desc "Test Pure Ruby"
+  task :pure do |t|
+    run_tests t, :extension, "test_pure*.rb"
+  end
+
+  desc "Test Processes"
+  task :processes do |t|
+    run_tests t, :extension, "test_process*.rb"
+  end
+
+  desc "Test SASL"
+  task :sasl do |t|
+    run_tests t, :java, "test_sasl*.rb"
+  end
+  
+  desc "Test Attach"
+  task :attach do |t|
+    run_tests t, :extension, "test_attach*.rb"
+  end
+end

data/tests/test_attach.rb

@@ -0,0 +1,83 @@
+# $Id$
+#
+#----------------------------------------------------------------------------
+#
+# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
+# Gmail: blackhedd
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version; or 2) Ruby's License.
+#
+# See the file COPYING for complete licensing information.
+#
+#---------------------------------------------------------------------------
+#
+
+$:.unshift "../lib"
+require 'eventmachine'
+require 'socket'
+require 'test/unit'
+
+
+class TestAttach < Test::Unit::TestCase
+
+  Host = "127.0.0.1"
+  Port = 9550
+
+  class EchoServer < EM::Connection
+    def receive_data data
+      send_data data
+    end
+  end
+
+  class EchoClient < EM::Connection
+    def initialize
+      $sock.write("abc\n")
+    end
+
+    def notify_readable
+      $read = $sock.readline
+      $fd = detach
+    end
+
+    def unbind
+      EM.next_tick do
+        $sock.write("def\n")
+        EM.add_timer(0.5){ EM.stop }
+      end
+    end
+  end
+
+  def test_attach
+    EM.run{
+      EM.start_server Host, Port, EchoServer
+      $sock = TCPSocket.new Host, Port
+      EM.attach $sock, EchoClient
+    }
+
+    assert_equal $read, "abc\n"
+    assert_equal $fd, $sock.fileno
+    assert_equal false, $sock.closed?
+    assert_equal $sock.readline, "def\n"
+  end
+
+
+  module PipeWatch
+    def notify_readable
+      $read = $r.readline
+      EM.stop
+    end
+  end
+
+  def test_attach_pipe
+    EM.run{
+      $r, $w = IO.pipe
+      EM.attach $r, PipeWatch
+      $w.write("ghi\n")
+    }
+
+    assert_equal $read, "ghi\n"
+  end
+end

data/tests/test_basic.rb

@@ -0,0 +1,231 @@
+# $Id$
+#
+# Author:: Francis Cianfrocca (gmail: blackhedd)
+# Homepage::  http://rubyeventmachine.com
+# Date:: 8 April 2006
+# 
+# See EventMachine and EventMachine::Connection for documentation and
+# usage examples.
+#
+#----------------------------------------------------------------------------
+#
+# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
+# Gmail: blackhedd
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
+#
+#---------------------------------------------------------------------------
+#
+#
+# 
+
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../lib")
+require 'eventmachine'
+require 'test/unit'
+
+class TestBasic < Test::Unit::TestCase
+
+  def setup
+    assert(!EM.reactor_running?)
+  end
+
+  def teardown
+    assert(!EM.reactor_running?)
+  end
+
+  #-------------------------------------
+
+  def test_libtype
+    lt = EventMachine.library_type
+		em_lib = (ENV["EVENTMACHINE_LIBRARY"] || $eventmachine_library || :xxx).to_sym
+		
+		# Running from test runner, under jruby.
+		if RUBY_PLATFORM == 'java'
+			unless em_lib == :pure_ruby
+				assert_equal( :java, lt )
+				return
+			end
+		end
+		
+    case em_lib
+    when :pure_ruby
+      assert_equal( :pure_ruby, lt )
+    when :extension
+      assert_equal( :extension, lt )
+    when :java
+      assert_equal( :java, lt )
+    else
+			# Running from jruby as a standalone test.
+			if RUBY_PLATFORM == 'java'
+				assert_equal( :java, lt )
+			else
+      	assert_equal( :extension, lt )
+			end
+    end
+  end
+
+  #-------------------------------------
+
+
+  def test_em
+    EventMachine.run {
+      EventMachine.add_timer 0 do
+        EventMachine.stop
+      end
+    }
+  end
+
+  #-------------------------------------
+
+  def test_timer
+    n = 0
+    EventMachine.run {
+      EventMachine.add_periodic_timer(0.1) {
+        n += 1
+        EventMachine.stop if n == 2
+      }
+    }
+  end
+
+  #-------------------------------------
+
+  # This test once threw an already-running exception.
+  module Trivial
+    def post_init
+      EventMachine.stop
+    end
+  end
+
+  def test_server
+    EventMachine.run {
+      EventMachine.start_server "localhost", 9000, Trivial
+      EventMachine.connect "localhost", 9000
+    }
+    assert( true ) # make sure it halts
+  end
+
+  #--------------------------------------
+
+  # EventMachine#run_block starts the reactor loop, runs the supplied block, and then STOPS
+  # the loop automatically. Contrast with EventMachine#run, which keeps running the reactor
+  # even after the supplied block completes.
+  def test_run_block
+    assert !EM.reactor_running?
+      a = nil
+      EM.run_block { a = "Worked" }
+      assert a
+      assert !EM.reactor_running?
+  end
+
+
+  #--------------------------------------
+
+  # TODO! This is an unfinished edge case.
+  # EM mishandles uncaught Ruby exceptions that fire from within #unbind handlers.
+  # A uncaught Ruby exception results in a call to EM::release_machine (which is in an ensure
+  # block in EM::run). But if EM is processing an unbind request, the release_machine call
+  # will cause a segmentation fault.
+  #
+
+  TestHost = "127.0.0.1"
+  TestPort = 9070
+
+  class UnbindError < EM::Connection
+	  def initialize *args
+		  super
+	  end
+	  def connection_completed
+		  close_connection_after_writing
+	  end
+	  def unbind
+		  raise "Blooey"
+	  end
+  end
+
+  def xxx_test_unbind_error
+	  assert_raises( RuntimeError ) {
+		  EM.run {
+			  EM.start_server TestHost, TestPort
+			  EM.connect TestHost, TestPort, UnbindError
+		  }
+	  }
+  end
+
+  #------------------------------------
+  #
+  # TODO. This is an unfinished bug fix.
+  # This case was originally reported by Dan Aquino. If you throw a Ruby exception
+  # in a post_init handler, it gets rethrown as a confusing reactor exception.
+  # The problem is in eventmachine.rb, which calls post_init within the private
+  # initialize method of the EM::Connection class. This happens in both the EM::connect
+  # method and in the code that responds to connection-accepted events.
+  # What happens is that we instantiate the new connection object, which calls
+  # initialize, and then after initialize returns, we stick the new connection object
+  # into EM's @conns hashtable.
+  # But the problem is that Connection::initialize calls #post_init before it returns,
+  # and this may be user-written code that may throw an uncaught Ruby exception.
+  # If that happens, the reactor will abort, and it will then try to run down open
+  # connections. Because @conns never got a chance to properly reflect the new connection
+  # (because initialize never returned), we throw a ConnectionNotBound error
+  # (eventmachine.rb line 1080).
+  # When the bug is fixed, activate this test case.
+  #
+
+  class PostInitError < EM::Connection
+	  def post_init
+		  aaa bbb # should produce a Ruby exception
+	  end
+  end
+  # This test causes issues, the machine becomes unreleasable after 
+  # release_machine suffers an exception in event_callback.
+  def xxx_test_post_init_error
+	  assert_raises( EventMachine::ConnectionNotBound ) {
+		  EM.run {
+		  	EM::Timer.new(1) {EM.stop}
+			EM.start_server TestHost, TestPort
+			EM.connect TestHost, TestPort, PostInitError
+		  }
+	  }
+	  EM.run {
+	    EM.stop
+	  }
+	  assert !EM.reactor_running?
+  end
+  
+  module BrsTestSrv
+    def receive_data data
+      $received << data
+    end
+    def unbind
+      EM.stop
+    end
+  end
+  module BrsTestCli
+    def post_init
+      send_data $sent
+      close_connection_after_writing
+    end
+  end
+  
+  # From ticket #50
+  def test_byte_range_send
+    $received = ''
+    $sent = (0..255).to_a.pack('C*')
+    EM::run {
+      
+      EM::start_server TestHost, TestPort, BrsTestSrv
+      
+      EM::connect TestHost, TestPort, BrsTestCli
+      
+      EM::add_timer(0.5) { assert(false, 'test timed out'); EM.stop; Kernel.warn "test timed out!" }
+    }
+    assert_equal($sent, $received)
+  end
+
+end
+