sensu-em 2.4.1 → 2.5.0.beta

data/lib/em/protocols/smtpserver.rb

@@ -227,18 +227,26 @@ module EventMachine
           process_unknown
         end
       end
-
+      
       # TODO - implement this properly, the implementation is a stub!
-      def process_vrfy
+      def process_help
         send_data "250 Ok, but unimplemented\r\n"
       end
+      
+      # RFC2821, 3.5.3 Meaning of VRFY or EXPN Success Response:
+      #   A server MUST NOT return a 250 code in response to a VRFY or EXPN
+      #   command unless it has actually verified the address.  In particular,
+      #   a server MUST NOT return 250 if all it has done is to verify that the
+      #   syntax given is valid.  In that case, 502 (Command not implemented)
+      #   or 500 (Syntax error, command unrecognized) SHOULD be returned.
+      #
       # TODO - implement this properly, the implementation is a stub!
-      def process_help
-        send_data "250 Ok, but unimplemented\r\n"
+      def process_vrfy
+        send_data "502 Command not implemented\r\n"
       end
       # TODO - implement this properly, the implementation is a stub!
       def process_expn
-        send_data "250 Ok, but unimplemented\r\n"
+        send_data "502 Command not implemented\r\n"
       end
 
       #--
@@ -358,12 +366,23 @@ module EventMachine
       def process_auth_line(line)
         plain = line.unpack("m").first
         _,user,psw = plain.split("\000")
-        if receive_plain_auth user,psw
+        
+        succeeded = proc {
           send_data "235 authentication ok\r\n"
           @state << :auth
-        else
+        }
+        failed = proc {
           send_data "535 invalid authentication\r\n"
+        }
+        auth = receive_plain_auth user,psw
+        
+        if auth.respond_to?(:callback)
+          auth.callback(&succeeded)
+          auth.errback(&failed)
+        else
+          (auth ? succeeded : failed).call
         end
+        
         @state.delete :auth_incomplete
       end
 
@@ -409,8 +428,12 @@ module EventMachine
       #--
       # STARTTLS may not be issued before EHLO, or unless the user has chosen
       # to support it.
-      # TODO, must support user-supplied certificates.
       #
+      # If :starttls_options is present and :starttls is set in the parms
+      # pass the options in :starttls_options to start_tls. Do this if you want to use
+      # your own certificate
+      # e.g. {:cert_chain_file => "/etc/ssl/cert.pem", :private_key_file => "/etc/ssl/private/cert.key"}
+
       def process_starttls
         if @@parms[:starttls]
           if @state.include?(:starttls)
@@ -419,7 +442,7 @@ module EventMachine
             send_data "503 EHLO required before STARTTLS\r\n"
           else
             send_data "220 Start TLS negotiation\r\n"
-            start_tls
+            start_tls(@@parms[:starttls_options] || {})
             @state << :starttls
           end
         else

data/lib/em/pure_ruby.rb

@@ -393,7 +393,7 @@ module EventMachine
       100.times {
         @loopbreak_port = rand(10000) + 40000
         begin
-          @loopbreak_reader.bind "localhost", @loopbreak_port
+          @loopbreak_reader.bind "127.0.0.1", @loopbreak_port
           bound = true
           break
         rescue
@@ -410,7 +410,7 @@ module EventMachine
 
     def signal_loopbreak
       #@loopbreak_writer.write '+' if @loopbreak_writer
-      @loopbreak_writer.send('+',0,"localhost",@loopbreak_port) if @loopbreak_writer
+      @loopbreak_writer.send('+',0,"127.0.0.1",@loopbreak_port) if @loopbreak_writer
     end
 
     def set_timer_quantum interval_in_seconds

data/lib/em/tick_loop.rb

@@ -7,25 +7,25 @@ module EventMachine
   # A TickLoop is useful when one needs to distribute amounts of work
   # throughout ticks in order to maintain response times. It is also useful for
   # simple repeated checks and metrics.
-  # 
-  #   # Here we run through an array one item per tick until it is empty, 
-  #   # printing each element.
-  #   # When the array is empty, we return :stop from the callback, and the
-  #   # loop will terminate.
-  #   # When the loop terminates, the on_stop callbacks will be called.
-  #   EM.run do
-  #     array = (1..100).to_a
-  #   
-  #     tickloop = EM.tick_loop do
-  #       if array.empty?
-  #         :stop
-  #       else
-  #         puts array.shift
-  #       end
-  #     end
-  #   
-  #     tickloop.on_stop { EM.stop }
-  #   end
+  # @example
+  #    # Here we run through an array one item per tick until it is empty, 
+  #    # printing each element.
+  #    # When the array is empty, we return :stop from the callback, and the
+  #    # loop will terminate.
+  #    # When the loop terminates, the on_stop callbacks will be called.  
+  #    EM.run do
+  #      array = (1..100).to_a
+  #      
+  #      tickloop = EM.tick_loop do
+  #        if array.empty?
+  #          :stop
+  #        else
+  #          puts array.shift
+  #        end
+  #      end
+  #      
+  #      tickloop.on_stop { EM.stop }
+  #    end
   #
   class TickLoop
 

data/lib/em/version.rb

@@ -1,3 +1,3 @@
 module EventMachine
-  VERSION = "1.0.3"
+  VERSION = "1.0.7"
 end

data/lib/eventmachine.rb

@@ -966,13 +966,16 @@ module EventMachine
       callback = @next_tick_mutex.synchronize { @next_tick_queue.shift }
       begin
         callback.call
+      rescue
+        exception_raised = true
+        raise
       ensure
         # This is a little nasty. The problem is, if an exception occurs during
         # the callback, then we need to send a signal to the reactor to actually
         # do some work during the next_tick. The only mechanism we have from the
         # ruby side is next_tick itself, although ideally, we'd just drop a byte
         # on the loopback descriptor.
-        EM.next_tick {} if $!
+        EM.next_tick {} if exception_raised
       end
     end
   end
@@ -1042,7 +1045,12 @@ module EventMachine
       thread = Thread.new do
         Thread.current.abort_on_exception = true
         while true
-          op, cback = *@threadqueue.pop
+          begin
+            op, cback = *@threadqueue.pop
+          rescue ThreadError
+            $stderr.puts $!.message
+            break # Ruby 2.0 may fail at Queue.pop
+          end
           result = op.call
           @resultqueue << [result, cback]
           EventMachine.signal_loopbreak
@@ -1528,9 +1536,9 @@ module EventMachine
       raise ArgumentError, "must provide module or subclass of #{klass.name}" unless klass >= handler
       handler
     elsif handler
-      begin
+      if defined?(handler::EM_CONNECTION_CLASS)
         handler::EM_CONNECTION_CLASS
-      rescue NameError
+      else
         handler::const_set(:EM_CONNECTION_CLASS, Class.new(klass) {include handler})
       end
     else

data/lib/jeventmachine.rb

@@ -3,7 +3,7 @@
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com
 # Date:: 8 Apr 2006
-# 
+#
 # See EventMachine and EventMachine::Connection for documentation and
 # usage examples.
 #
@@ -11,17 +11,17 @@
 #
 # 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.
 #
 #---------------------------------------------------------------------------
 #
-# 
+#
 
 # This module provides "glue" for the Java version of the EventMachine reactor core.
 # For C++ EventMachines, the analogous functionality is found in ext/rubymain.cpp,
@@ -269,8 +269,21 @@ module EventMachine
     @em.getConnectionCount
   end
 
+  def self.pause_connection(sig)
+    @em.pauseConnection(sig)
+  end
+  def self.resume_connection(sig)
+    @em.resumeConnection(sig)
+  end
+  def self.connection_paused?(sig)
+    @em.isConnectionPaused(sig)
+  end
+  def self._get_outbound_data_size(sig)
+    @em.getOutboundDataSize(sig)
+  end
+
   def self.set_tls_parms(sig, privkeyfile, certchainfile, verify_peer, use_tls, cipher_list)
-    keystore = KeyStoreBuilder.create privkeyfile, certchainfile unless (privkeyfile.empty? or certchainfile.empty?) 
+    keystore = KeyStoreBuilder.create privkeyfile, certchainfile unless (privkeyfile.empty? or certchainfile.empty?)
     @em.setTlsParms(sig, keystore, (!!verify_peer))
   end
   def self.send_file_data(sig, filename)
@@ -280,6 +293,9 @@ module EventMachine
     def associate_callback_target sig
       # No-op for the time being
     end
+    def get_outbound_data_size
+      EM._get_outbound_data_size @signature
+    end
   end
 end
 
@@ -305,7 +321,7 @@ module KeyStoreBuilder
 
   def self.create(privkeyfile, certchainfile)
     self.init
-    
+
     key_reader = FileReader.new privkeyfile
     key_pair = PEMReader.new(key_reader).read_object
 

data/rakelib/package.rake

@@ -65,7 +65,7 @@ end
   require "\#{$1}/#{File.basename(t.name, '.rb')}"
       eoruby
     end
-    at_exit{ FileUtils.rm t.name if File.exists?(t.name) }
+    at_exit{ FileUtils.rm t.name if File.exist?(t.name) }
   end
 end
 

data/tests/em_test_helper.rb

@@ -45,6 +45,10 @@ class Test::Unit::TestCase
     def jruby?
       defined? JRUBY_VERSION
     end
+
+    def rbx?
+      defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
+    end
   end
 
   include PlatformHelper

data/tests/test_attach.rb

@@ -67,6 +67,7 @@ class TestAttach < Test::Unit::TestCase
   end
 
   def test_attach_server
+    omit_if(jruby?)
     $before = TCPServer.new("127.0.0.1", @port)
     sig     = nil
     EM.run {

data/tests/test_basic.rb

@@ -179,18 +179,15 @@ class TestBasic < Test::Unit::TestCase
     assert x
   end
 
-  if EM.respond_to? :set_heartbeat_interval
-    def test_set_heartbeat_interval
-      interval = 0.5
-      EM.run {
-        EM.set_heartbeat_interval interval
-        $interval = EM.get_heartbeat_interval
-        EM.stop
-      }
-      assert_equal(interval, $interval)
-    end
-  else
-    warn "EM.set_heartbeat_interval not implemented, skipping a test in #{__FILE__}"
+  def test_set_heartbeat_interval
+    omit_if(jruby?)
+    interval = 0.5
+    EM.run {
+      EM.set_heartbeat_interval interval
+      $interval = EM.get_heartbeat_interval
+      EM.stop
+    }
+    assert_equal(interval, $interval)
   end
   
   module PostInitRaiser
@@ -226,6 +223,7 @@ class TestBasic < Test::Unit::TestCase
   end
   
   def test_schedule_close
+    omit_if(jruby?)
     localhost, port = '127.0.0.1', 9000
     timer_ran = false
     num_close_scheduled = nil
@@ -247,22 +245,22 @@ class TestBasic < Test::Unit::TestCase
   end
 
   def test_fork_safe
-    return unless cpid = fork { exit! } rescue false
+    omit_if(jruby?)
+    omit_if(rbx?, 'Omitting test on Rubinius because it hangs for unknown reasons')
 
     read, write = IO.pipe
     EM.run do
-      cpid = fork do
+      fork do
         write.puts "forked"
         EM.run do
           EM.next_tick do
             write.puts "EM ran"
-            exit!
+            EM.stop
           end
         end
       end
       EM.stop
     end
-    Process.waitall
     assert_equal "forked\n", read.readline
     assert_equal "EM ran\n", read.readline
   ensure

data/tests/test_completion.rb

@@ -1,3 +1,4 @@
+require 'em_test_helper'
 require 'em/completion'
 
 class TestCompletion < Test::Unit::TestCase

data/tests/test_connection_count.rb

@@ -43,6 +43,7 @@ class TestConnectionCount < Test::Unit::TestCase
   end
 
   def test_num_close_scheduled
+    omit_if(jruby?)
     EM.run {
       assert_equal(0, EM.num_close_scheduled)
       EM.connect("127.0.0.1", 9999, DoubleCloseClient) # nothing listening on 9999

data/tests/test_connection_write.rb

@@ -0,0 +1,35 @@
+require 'em_test_helper'
+
+class TestConnectionWrite < Test::Unit::TestCase
+
+  # This test takes advantage of the fact that EM::_RunSelectOnce iterates over the connections twice:
+  #   - once to determine which ones to call Write() on
+  #   - and once to call Write() on each of them.
+  #
+  # But state may change in the meantime before Write() is finally called.
+  # And that is what we try to exploit to get Write() to be called when bWatchOnly is true, and bNotifyWritable is false,
+  # to cause an assertion failure.
+
+  module SimpleClient
+    def notify_writable
+      $conn2.notify_writable = false  # Being naughty in callback
+      # If this doesn't crash anything, the test passed!
+    end
+  end
+
+  def test_with_naughty_callback
+    EM.run do
+      r1, w1 = IO.pipe
+      r2, w2 = IO.pipe
+
+      # Adding EM.watches
+      $conn1 = EM.watch(r1, SimpleClient)
+      $conn2 = EM.watch(r2, SimpleClient)
+
+      $conn1.notify_writable = true
+      $conn2.notify_writable = true
+
+      EM.stop
+    end
+  end
+end

data/tests/test_epoll.rb

@@ -25,19 +25,16 @@ class TestEpoll < Test::Unit::TestCase
   end
 
 
-  if windows? || jruby?
-    warn "EM.set_descriptor_table_size not implemented, skipping test in #{__FILE__}"
-  else
-    # We can set the rlimit/nofile of a process but we can only set it
-    # higher if we're running as root.
-    # On most systems, the default value is 1024.
-    def test_rlimit
-      unless EM.set_descriptor_table_size >= 1024
-        a = EM.set_descriptor_table_size
-        assert( a <= 1024 )
-        a = EM.set_descriptor_table_size( 1024 )
-        assert( a == 1024 )
-      end
+  # We can set the rlimit/nofile of a process but we can only set it
+  # higher if we're running as root.
+  # On most systems, the default value is 1024.
+  def test_rlimit
+    omit_if(windows? || jruby?)
+    unless EM.set_descriptor_table_size >= 1024
+      a = EM.set_descriptor_table_size
+      assert( a <= 1024 )
+      a = EM.set_descriptor_table_size( 1024 )
+      assert( a == 1024 )
     end
   end
 
@@ -97,7 +94,7 @@ class TestEpoll < Test::Unit::TestCase
     assert_equal( "abcdefghij", $out )
   end
 
-  # XXX this test fails randomly..
+  # XXX this test fails randomly...
   def _test_unix_domain
     fn = "/tmp/xxx.chain"
     EM.epoll

data/tests/test_httpclient.rb

@@ -187,4 +187,47 @@ class TestHttpClient < Test::Unit::TestCase
     assert ok
   end
 
+  #-----------------------------------------
+
+  # Test a server that returns chunked encoding
+  #
+  class ChunkedEncodingContent < EventMachine::Connection
+    def initialize *args
+      super
+    end
+    def receive_data data
+      send_data ["HTTP/1.1 200 OK",
+                "Server: nginx/0.7.67", 
+                "Date: Sat, 23 Oct 2010 16:41:32 GMT",
+                "Content-Type: application/json",
+                "Transfer-Encoding: chunked",
+                "Connection: keep-alive",
+                "", 
+                "1800",
+                "chunk1" * 1024,
+                "5a",
+                "chunk2" * 15,
+                "0",
+                ""].join("\r\n")
+      close_connection_after_writing
+    end
+  end
+
+  def test_http_chunked_encoding_content
+    ok = false
+    EventMachine.run {
+      EventMachine.start_server "127.0.0.1", 9701, ChunkedEncodingContent
+      c = EventMachine::Protocols::HttpClient.send :request, :host => "127.0.0.1", :port => 9701
+      c.callback {|result|
+        if result[:content] == "chunk1" * 1024 + "chunk2" * 15
+          ok = true
+        end
+        EventMachine.stop
+      }
+    }
+    assert ok
+  end
+
 end
+
+

data/tests/test_iterator.rb

@@ -18,7 +18,7 @@ class TestIterator < Test::Unit::TestCase
       }, proc {EM.stop})
     }
     assert_equal(10, items.keys.size)
-    assert_equal((list).to_a, items.values.flatten)
+    assert_equal(list.to_a.sort, items.values.flatten.sort)
   end
 
   def test_concurrency_bigger_than_list_size
@@ -33,7 +33,7 @@ class TestIterator < Test::Unit::TestCase
       }, proc {EM.stop})
     }
     assert_equal(1, items.keys.size)
-    assert_equal((list).to_a, items.values.flatten)
+    assert_equal(list.to_a.sort, items.values.flatten.sort)
   end
 
 
@@ -56,7 +56,7 @@ class TestIterator < Test::Unit::TestCase
       }
     }
     assert_equal(9, items.keys.size)
-    assert_equal((list).to_a, items.values.flatten)
+    assert_equal(list.to_a.sort, items.values.flatten.sort)
   end
 
   def test_map
@@ -65,7 +65,7 @@ class TestIterator < Test::Unit::TestCase
       EM::Iterator.new(list).map(proc{ |num,iter|
         EM.add_timer(0.01){ iter.return(num) }
       }, proc{ |results|
-        assert_equal((list).to_a.size, results.size)
+        assert_equal(list.to_a.size, results.size)
        EM.stop
       })
     }
@@ -80,7 +80,7 @@ class TestIterator < Test::Unit::TestCase
           iter.return(hash)
         }
       }, proc{ |results|
-        assert_equal(results.keys, list)
+        assert_equal(results.keys.sort, list.sort)
         EM.stop
       })
     }
@@ -94,4 +94,4 @@ class TestIterator < Test::Unit::TestCase
       EM.stop
     }
   end
-end
+end

data/tests/test_kb.rb

@@ -2,33 +2,27 @@ require 'em_test_helper'
 
 class TestKeyboardEvents < Test::Unit::TestCase
 
-  if !jruby?
-    module KbHandler
-      include EM::Protocols::LineText2
-      def receive_line d
-        EM::stop if d == "STOP"
-      end
+  module KbHandler
+    include EM::Protocols::LineText2
+    def receive_line d
+      EM::stop if d == "STOP"
     end
+  end
 
-    # This test doesn't actually do anything useful but is here to
-    # illustrate the usage. If you removed the timer and ran this test
-    # by itself on a console, and then typed into the console, it would
-    # work.
-    # I don't know how to get the test harness to simulate actual keystrokes.
-    # When someone figures that out, then we can make this a real test.
-    #
-    def test_kb
-      EM.run {
-        EM.open_keyboard KbHandler
-        EM::Timer.new(1) { EM.stop }
-      } if $stdout.tty? # don't run the test unless it stands a chance of validity.
-    end
-  else
-    warn "EM.open_keyboard not implemented, skipping tests in #{__FILE__}"
-
-    # Because some rubies will complain if a TestCase class has no tests
-    def test_em_open_keyboard_unsupported
-      assert true
+  # This test doesn't actually do anything useful but is here to
+  # illustrate the usage. If you removed the timer and ran this test
+  # by itself on a console, and then typed into the console, it would
+  # work.
+  # I don't know how to get the test harness to simulate actual keystrokes.
+  # When someone figures that out, then we can make this a real test.
+  #
+  def test_kb
+    omit_if(jruby?)
+    omit_if(!$stdout.tty?) # don't run the test unless it stands a chance of validity.
+    EM.run do
+      EM.open_keyboard KbHandler
+      EM::Timer.new(1) { EM.stop }
     end
   end
+
 end

data/tests/test_many_fds.rb

@@ -0,0 +1,22 @@
+require 'em_test_helper'
+require 'socket'
+
+class TestManyFDs < Test::Unit::TestCase
+  def setup
+    @port = next_port
+  end
+
+  def test_connection_class_cache
+    mod = Module.new
+    a = nil
+    Process.setrlimit(Process::RLIMIT_NOFILE,4096);
+    EM.run {
+      EM.start_server '127.0.0.1', @port, mod
+      1100.times do
+        a = EM.connect '127.0.0.1', @port, mod
+        assert_kind_of EM::Connection, a
+      end
+      EM.stop
+    }
+  end
+end

data/tests/test_pause.rb

@@ -82,14 +82,19 @@ class TestPause < Test::Unit::TestCase
         end
       end
 
+      buf = 'a' * 1024
+
       EM.run do
         EM.start_server "127.0.0.1", @port, test_server
         cli = EM.connect "127.0.0.1", @port
-        cli.send_data 'a'*(17*1024)
+        128.times do
+          cli.send_data buf
+        end
       end
 
       assert_equal 1, incoming.size
-      assert_equal 16*1024, incoming[0].bytesize
+      assert incoming[0].bytesize > buf.bytesize
+      assert incoming[0].bytesize < buf.bytesize * 128
     end
   else
     warn "EM.pause_connection not implemented, skipping tests in #{__FILE__}"

data/tests/test_pool.rb

@@ -1,3 +1,5 @@
+require 'em_test_helper'
+
 class TestPool < Test::Unit::TestCase
   def pool
     @pool ||= EM::Pool.new

data/tests/test_process_watch.rb

@@ -27,6 +27,8 @@ if EM.kqueue?
     end
 
     def test_events
+      omit_if(rbx?)
+      omit_if(jruby?)
       EM.run{
         # watch ourselves for a fork notification
         EM.watch_process(Process.pid, ParentProcessWatcher)