eventmachine 1.0.6-java → 1.0.7-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4722f24a61f13ac737b777597b71542a5ea1b0bd
-  data.tar.gz: 2bc74d2fe5b8de6e467faeae30916f4cb1a71ddf
+  metadata.gz: b93017d412c61150a4d664be575d7ce87907d5ed
+  data.tar.gz: bd2358d58e8b21db9cdcd962651a674fb9eb607e
 SHA512:
-  metadata.gz: f2d16977dff27530edcd046a5503f7597a5f5859576592dc0b8e2f826f9cac227309b0f2fadf87c65348520257ea7f78a34f4f2c892f72876c31181df7b3487b
-  data.tar.gz: bdb3a2a7bcf18f803f8e002637b1809a2691e84025bb19ab3e319d82d13e21f39ab35ce1c96a865848e26ba586cc8dbd9be8e880a1bdbdd924498b7df73fdeff
+  metadata.gz: f1f260562d40ed19f4a483080840de34afc7df80d5c31c184e6c52ebf8000596f63d076590a94cc9164922e3d201b24639850f16eae109d2f6af80b72b6eccea
+  data.tar.gz: b521218d7da6dadc59f531932f0e7e03983f326a3bda6ce8728b4b0a052f0a92117de3745a57f539d4fba782b23beebf55f2b30672ccff930ba5db4475f24996

data/.travis.yml

@@ -6,6 +6,7 @@ language: ruby
 sudo: false
 rvm:
   - 1.8.7
+  - 1.9.2
   - 1.9.3
   - 2.0.0
   - 2.1

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 1.0.7 (February 10, 2015)
+* fix delay in kqueue/epoll reactor shutdown when timers exist [#587]
+* fix memory leak introduced in v1.0.5 [#586]
+* expose EM.set_simultaneous_accept_count [#420]
+* fix busy loop when EM.run and EM.next_tick are invoked from exception handler [#452]
+
 ## 1.0.6 (February 3, 2015)
 * add support for Rubinius Process::Status [#568]
 * small bugfixes for SmtpServer [#449]

data/ext/cmain.cpp

@@ -653,7 +653,6 @@ extern "C" int evma_get_max_timer_count()
 	return EventMachine_t::GetMaxTimerCount();
 }
 
-
 /************************
 evma_set_max_timer_count
 ************************/
@@ -671,6 +670,21 @@ extern "C" void evma_set_max_timer_count (int ct)
 	EventMachine_t::SetMaxTimerCount (ct);
 }
 
+/******************
+evma_get/set_simultaneous_accept_count
+******************/
+
+extern "C" void evma_set_simultaneous_accept_count (int count)
+{
+	EventMachine_t::SetSimultaneousAcceptCount(count);
+}
+
+extern "C" int evma_get_simultaneous_accept_count()
+{
+	return EventMachine_t::GetSimultaneousAcceptCount();
+}
+
+
 /******************
 evma_setuid_string
 ******************/

data/ext/ed.cpp

@@ -1431,8 +1431,9 @@ void AcceptorDescriptor::Read()
 
 	struct sockaddr_in pin;
 	socklen_t addrlen = sizeof (pin);
+	int accept_count = EventMachine_t::GetSimultaneousAcceptCount();
 
-	for (int i=0; i < 10; i++) {
+	for (int i=0; i < accept_count; i++) {
 		int sd = accept (GetSocket(), (struct sockaddr*)&pin, &addrlen);
 		if (sd == INVALID_SOCKET) {
 			// This breaks the loop when we've accepted everything on the kernel queue,

data/ext/em.cpp

@@ -27,6 +27,11 @@ See the file COPYING for complete licensing information.
  */
 static unsigned int MaxOutstandingTimers = 100000;
 
+/* The number of accept() done at once in a single tick when the acceptor
+ * socket becomes readable.
+ */
+static unsigned int SimultaneousAcceptCount = 10;
+
 
 /* Internal helper to convert strings to internet addresses. IPv6-aware.
  * Not reentrant or threadsafe, optimized for speed.
@@ -61,6 +66,17 @@ void EventMachine_t::SetMaxTimerCount (int count)
 	MaxOutstandingTimers = count;
 }
 
+int EventMachine_t::GetSimultaneousAcceptCount()
+{
+	return SimultaneousAcceptCount;
+}
+
+void EventMachine_t::SetSimultaneousAcceptCount (int count)
+{
+	if (count < 1)
+		count = 1;
+	SimultaneousAcceptCount = count;
+}
 
 
 /******************************
@@ -68,12 +84,12 @@ EventMachine_t::EventMachine_t
 ******************************/
 
 EventMachine_t::EventMachine_t (EMCallback event_callback):
+	NumCloseScheduled (0),
 	HeartbeatInterval(2000000),
 	EventCallback (event_callback),
 	NextHeartbeatTime (0),
 	LoopBreakerReader (-1),
 	LoopBreakerWriter (-1),
-	NumCloseScheduled (0),
 	bTerminateSignalReceived (false),
 	bEpoll (false),
 	epfd (-1),
@@ -106,6 +122,7 @@ EventMachine_t::EventMachine_t (EMCallback event_callback):
 	#endif
 
 	_InitializeLoopBreaker();
+	SelectData = new SelectData_t();
 }
 
 
@@ -135,6 +152,8 @@ EventMachine_t::~EventMachine_t()
 		close (epfd);
 	if (kqfd != -1)
 		close (kqfd);
+
+	delete SelectData;
 }
 
 
@@ -192,6 +211,12 @@ void EventMachine_t::ScheduleHalt()
    * The answer is to call evma_stop_machine, which calls here, from a SIGINT handler.
    */
 	bTerminateSignalReceived = true;
+
+	/* Signal the loopbreaker so we break out of long-running select/epoll/kqueue and
+	 * notice the halt boolean is set. Signalling the loopbreaker also uses a single
+	 * signal-safe syscall.
+	 */
+	SignalLoopBreaker();
 }
 
 
@@ -576,12 +601,12 @@ void EventMachine_t::_RunEpollOnce()
 	#ifdef HAVE_RB_WAIT_FOR_SINGLE_FD
 	if ((ret = rb_wait_for_single_fd(epfd, RB_WAITFD_IN|RB_WAITFD_PRI, &tv)) < 1) {
 	#else
-	rb_fdset_t fdreads;
+	fd_set fdreads;
 
-	rb_fd_init(&fdreads);
-	rb_fd_set(epfd, &fdreads);
+	FD_ZERO(&fdreads);
+	FD_SET(epfd, &fdreads);
 
-	if ((ret = rb_thread_fd_select(epfd + 1, &fdreads, NULL, NULL, &tv)) < 1) {
+	if ((ret = rb_thread_select(epfd + 1, &fdreads, NULL, NULL, &tv)) < 1) {
 	#endif
 		if (ret == -1) {
 			assert(errno != EINVAL);
@@ -653,12 +678,12 @@ void EventMachine_t::_RunKqueueOnce()
 	#ifdef HAVE_RB_WAIT_FOR_SINGLE_FD
 	if ((ret = rb_wait_for_single_fd(kqfd, RB_WAITFD_IN|RB_WAITFD_PRI, &tv)) < 1) {
 	#else
-	rb_fdset_t fdreads;
+	fd_set fdreads;
 
-	rb_fd_init(&fdreads);
-	rb_fd_set(kqfd, &fdreads);
+	FD_ZERO(&fdreads);
+	FD_SET(kqfd, &fdreads);
 
-	if ((ret = rb_thread_fd_select(kqfd + 1, &fdreads, NULL, NULL, &tv)) < 1) {
+	if ((ret = rb_thread_select(kqfd + 1, &fdreads, NULL, NULL, &tv)) < 1) {
 	#endif
 		if (ret == -1) {
 			assert(errno != EINVAL);
@@ -851,6 +876,12 @@ SelectData_t::SelectData_t()
 	rb_fd_init (&fderrors);
 }
 
+SelectData_t::~SelectData_t()
+{
+	rb_fd_term (&fdreads);
+	rb_fd_term (&fdwrites);
+	rb_fd_term (&fderrors);
+}
 
 #ifdef BUILD_FOR_RUBY
 /*****************
@@ -861,7 +892,7 @@ _SelectDataSelect
 static VALUE _SelectDataSelect (void *v)
 {
 	SelectData_t *sd = (SelectData_t*)v;
-	sd->nSockets = rb_fd_select (sd->maxsocket+1, &(sd->fdreads), &(sd->fdwrites), &(sd->fderrors), &(sd->tv));
+	sd->nSockets = select (sd->maxsocket+1, rb_fd_ptr(&(sd->fdreads)), rb_fd_ptr(&(sd->fdwrites)), rb_fd_ptr(&(sd->fderrors)), &(sd->tv));
 	return Qnil;
 }
 #endif
@@ -873,9 +904,11 @@ SelectData_t::_Select
 int SelectData_t::_Select()
 {
 	#if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
+	// added in ruby 1.9.3
 	rb_thread_call_without_gvl ((void *(*)(void *))_SelectDataSelect, (void*)this, RUBY_UBF_IO, 0);
 	return nSockets;
 	#elif defined(HAVE_TBR)
+	// added in ruby 1.9.1, deprecated in ruby 2.0.0
 	rb_thread_blocking_region (_SelectDataSelect, (void*)this, RUBY_UBF_IO, 0);
 	return nSockets;
 	#else
@@ -884,7 +917,13 @@ int SelectData_t::_Select()
 }
 #endif
 
-
+void SelectData_t::_Clear()
+{
+	maxsocket = 0;
+	rb_fd_zero (&fdreads);
+	rb_fd_zero (&fdwrites);
+	rb_fd_zero (&fderrors);
+}
 
 /******************************
 EventMachine_t::_RunSelectOnce
@@ -901,23 +940,17 @@ void EventMachine_t::_RunSelectOnce()
 	// however it has the same problem interoperating with Ruby
 	// threads that select does.
 
-	SelectData_t SelectData;
-	/*
-	rb_fdset_t fdreads, fdwrites;
-	rb_fd_init (&fdreads);
-	rb_fd_init (&fdwrites);
-
-	int maxsocket = 0;
-	*/
+	// Get ready for select()
+	SelectData->_Clear();
 
 	// Always read the loop-breaker reader.
 	// Changed 23Aug06, provisionally implemented for Windows with a UDP socket
 	// running on localhost with a randomly-chosen port. (*Puke*)
 	// Windows has a version of the Unix pipe() library function, but it doesn't
 	// give you back descriptors that are selectable.
-	rb_fd_set (LoopBreakerReader, &(SelectData.fdreads));
-	if (SelectData.maxsocket < LoopBreakerReader)
-		SelectData.maxsocket = LoopBreakerReader;
+	rb_fd_set (LoopBreakerReader, &(SelectData->fdreads));
+	if (SelectData->maxsocket < LoopBreakerReader)
+		SelectData->maxsocket = LoopBreakerReader;
 
 	// prepare the sockets for reading and writing
 	size_t i;
@@ -930,28 +963,28 @@ void EventMachine_t::_RunSelectOnce()
 		assert (sd != INVALID_SOCKET);
 
 		if (ed->SelectForRead())
-			rb_fd_set (sd, &(SelectData.fdreads));
+			rb_fd_set (sd, &(SelectData->fdreads));
 		if (ed->SelectForWrite())
-			rb_fd_set (sd, &(SelectData.fdwrites));
+			rb_fd_set (sd, &(SelectData->fdwrites));
 
 		#ifdef OS_WIN32
 		/* 21Sep09: on windows, a non-blocking connect() that fails does not come up as writable.
 		   Instead, it is added to the error set. See http://www.mail-archive.com/openssl-users@openssl.org/msg58500.html
 		*/
 		if (ed->IsConnectPending())
-			rb_fd_set (sd, &(SelectData.fderrors));
+			rb_fd_set (sd, &(SelectData->fderrors));
 		#endif
 
-		if (SelectData.maxsocket < sd)
-			SelectData.maxsocket = sd;
+		if (SelectData->maxsocket < sd)
+			SelectData->maxsocket = sd;
 	}
 
 
 	{ // read and write the sockets
 		//timeval tv = {1, 0}; // Solaris fails if the microseconds member is >= 1000000.
 		//timeval tv = Quantum;
-		SelectData.tv = _TimeTilNextEvent();
-		int s = SelectData._Select();
+		SelectData->tv = _TimeTilNextEvent();
+		int s = SelectData->_Select();
 		//rb_thread_blocking_region(xxx,(void*)&SelectData,RUBY_UBF_IO,0);
 		//int s = EmSelect (SelectData.maxsocket+1, &(SelectData.fdreads), &(SelectData.fdwrites), NULL, &(SelectData.tv));
 		//int s = SelectData.nSockets;
@@ -974,19 +1007,19 @@ void EventMachine_t::_RunSelectOnce()
 					continue;
 				assert (sd != INVALID_SOCKET);
 
-				if (rb_fd_isset (sd, &(SelectData.fdwrites))) {
+				if (rb_fd_isset (sd, &(SelectData->fdwrites))) {
 					// Double-check SelectForWrite() still returns true. If not, one of the callbacks must have
 					// modified some value since we checked SelectForWrite() earlier in this method.
 					if (ed->SelectForWrite())
 						ed->Write();
 				}
-				if (rb_fd_isset (sd, &(SelectData.fdreads)))
+				if (rb_fd_isset (sd, &(SelectData->fdreads)))
 					ed->Read();
-				if (rb_fd_isset (sd, &(SelectData.fderrors)))
+				if (rb_fd_isset (sd, &(SelectData->fderrors)))
 					ed->HandleError();
 			}
 
-			if (rb_fd_isset (LoopBreakerReader, &(SelectData.fdreads)))
+			if (rb_fd_isset (LoopBreakerReader, &(SelectData->fdreads)))
 				_ReadLoopBreaker();
 		}
 		else if (s < 0) {
@@ -1029,6 +1062,7 @@ void EventMachine_t::_CleanBadDescriptors()
 		rb_fd_set(sd, &fds);
 
 		int ret = rb_fd_select(sd + 1, &fds, NULL, NULL, &tv);
+		rb_fd_term(&fds);
 
 		if (ret == -1) {
 			if (errno == EBADF)
@@ -2353,4 +2387,3 @@ int EventMachine_t::SetHeartbeatInterval(float interval)
 	return 0;
 }
 //#endif // OS_UNIX
-

data/ext/em.h

@@ -22,7 +22,12 @@ See the file COPYING for complete licensing information.
 
 #ifdef BUILD_FOR_RUBY
   #include <ruby.h>
-  #define EmSelect rb_thread_fd_select
+  #ifdef HAVE_RB_THREAD_FD_SELECT
+    #define EmSelect rb_thread_fd_select
+  #else
+    // ruby 1.9.1 and below
+    #define EmSelect rb_thread_select
+  #endif
 
   #ifdef HAVE_RB_THREAD_CALL_WITHOUT_GVL
    #include <ruby/thread.h>
@@ -61,10 +66,10 @@ See the file COPYING for complete licensing information.
     #define RSTRING_LENINT(str) RSTRING_LEN(str)
   #endif
 #else
-  #define EmSelect rb_fd_select
+  #define EmSelect select
 #endif
 
-#ifndef rb_fd_max
+#if !defined(HAVE_RB_FDSET_T)
 #define fd_check(n) (((n) < FD_SETSIZE) ? 1 : 0*fprintf(stderr, "fd %d too large for select\n", (n)))
 // These definitions are cribbed from include/ruby/intern.h in Ruby 1.9.3,
 // with this change: any macros that read or write the nth element of an
@@ -90,7 +95,7 @@ typedef fd_set rb_fdset_t;
 
 class EventableDescriptor;
 class InotifyDescriptor;
-
+struct SelectData_t;
 
 /********************
 class EventMachine_t
@@ -102,6 +107,9 @@ class EventMachine_t
 		static int GetMaxTimerCount();
 		static void SetMaxTimerCount (int);
 
+		static int GetSimultaneousAcceptCount();
+		static void SetSimultaneousAcceptCount (int);
+
 	public:
 		EventMachine_t (EMCallback);
 		virtual ~EventMachine_t();
@@ -194,7 +202,7 @@ class EventMachine_t
 	public:
 		void _ReadLoopBreaker();
 		void _ReadInotifyEvents();
-        int NumCloseScheduled;
+		int NumCloseScheduled;
 
 	private:
 		enum {
@@ -238,6 +246,7 @@ class EventMachine_t
 
 	private:
 		bool bTerminateSignalReceived;
+		SelectData_t *SelectData;
 
 		bool bEpoll;
 		int epfd; // Epoll file-descriptor
@@ -262,8 +271,10 @@ struct SelectData_t
 struct SelectData_t
 {
 	SelectData_t();
+	~SelectData_t();
 
 	int _Select();
+	void _Clear();
 
 	int maxsocket;
 	rb_fdset_t fdreads;

data/ext/eventmachine.h

@@ -96,6 +96,8 @@ extern "C" {
 	void evma_set_timer_quantum (int);
 	int evma_get_max_timer_count();
 	void evma_set_max_timer_count (int);
+	int evma_get_simultaneous_accept_count();
+	void evma_set_simultaneous_accept_count (int);
 	void evma_setuid_string (const char *username);
 	void evma_stop_machine();
 	float evma_get_heartbeat_interval();

data/ext/extconf.rb

@@ -75,6 +75,7 @@ add_define "HAVE_INOTIFY" if inotify = have_func('inotify_init', 'sys/inotify.h'
 add_define "HAVE_OLD_INOTIFY" if !inotify && have_macro('__NR_inotify_init', 'sys/syscall.h')
 add_define 'HAVE_WRITEV' if have_func('writev', 'sys/uio.h')
 add_define 'HAVE_RB_THREAD_FD_SELECT' if have_func('rb_thread_fd_select')
+add_define 'HAVE_RB_FDSET_T' if have_type('rb_fdset_t', 'ruby/intern.h')
 
 have_func('rb_wait_for_single_fd')
 have_func('rb_enable_interrupt')

data/ext/rubymain.cpp

@@ -813,6 +813,21 @@ static VALUE t_set_max_timer_count (VALUE self, VALUE ct)
   return Qnil;
 }
 
+/********************
+t_get/set_simultaneous_accept_count
+********************/
+
+static VALUE t_get_simultaneous_accept_count (VALUE self)
+{
+  return INT2FIX (evma_get_simultaneous_accept_count());
+}
+
+static VALUE t_set_simultaneous_accept_count (VALUE self, VALUE ct)
+{
+  evma_set_simultaneous_accept_count (FIX2INT (ct));
+  return Qnil;
+}
+
 /***************
 t_setuid_string
 ***************/
@@ -1290,6 +1305,8 @@ extern "C" void Init_rubyeventmachine()
 	rb_define_module_function (EmModule, "set_timer_quantum", (VALUE(*)(...))t_set_timer_quantum, 1);
 	rb_define_module_function (EmModule, "get_max_timer_count", (VALUE(*)(...))t_get_max_timer_count, 0);
 	rb_define_module_function (EmModule, "set_max_timer_count", (VALUE(*)(...))t_set_max_timer_count, 1);
+	rb_define_module_function (EmModule, "get_simultaneous_accept_count", (VALUE(*)(...))t_get_simultaneous_accept_count, 0);
+	rb_define_module_function (EmModule, "set_simultaneous_accept_count", (VALUE(*)(...))t_set_simultaneous_accept_count, 1);
 	rb_define_module_function (EmModule, "setuid_string", (VALUE(*)(...))t_setuid_string, 1);
 	rb_define_module_function (EmModule, "invoke_popen", (VALUE(*)(...))t_invoke_popen, 1);
 	rb_define_module_function (EmModule, "send_file_data", (VALUE(*)(...))t_send_file_data, 2);

data/lib/em/protocols/httpclient.rb

@@ -181,6 +181,8 @@ module EventMachine
             @content_length = nil # not zero
             @content = ""
             @status = nil
+            @chunked = false
+            @chunk_length = nil
             @read_state = :header
             @connection_close = nil
           when :header

data/lib/em/version.rb

@@ -1,3 +1,3 @@
 module EventMachine
-  VERSION = "1.0.6"
+  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

data/tests/test_completion.rb

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

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_resolver.rb

@@ -30,11 +30,11 @@ class TestResolver < Test::Unit::TestCase
 
   def test_a_pair
     EM.run {
-      d = EM::DNS::Resolver.resolve "google.com"
-      d.errback { assert false }
+      d = EM::DNS::Resolver.resolve "yahoo.com"
+      d.errback { |err| assert false, "failed to resolve yahoo.com: #{err}" }
       d.callback { |r|
         assert_kind_of(Array, r)
-        assert r.size > 1
+        assert r.size > 1, "returned #{r.size} results: #{r.inspect}"
         EM.stop
       }
     }
@@ -56,7 +56,7 @@ class TestResolver < Test::Unit::TestCase
   def test_timer_cleanup
     EM.run {
       d = EM::DNS::Resolver.resolve "google.com"
-      d.errback { assert false }
+      d.errback { |err| assert false, "failed to resolve google.com: #{err}" }
       d.callback { |r|
         # This isn't a great test, but it's hard to get more canonical
         # confirmation that the timer is cancelled

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eventmachine
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 1.0.7
 platform: java
 authors:
 - Francis Cianfrocca
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-02-04 00:00:00.000000000 Z
+date: 2015-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: test-unit