eventmachine 0.12.0 → 0.12.2

data/ext/cmain.cpp

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: cmain.cpp 679 2008-01-19 01:40:06Z blackhedd $
+$Id: cmain.cpp 785 2008-09-15 09:46:23Z francis $
 
 File:     cmain.cpp
 Date:     06Apr06
@@ -103,6 +103,32 @@ extern "C" const char *evma_connect_to_unix_server (const char *server)
 	return EventMachine->ConnectToUnixServer (server);
 }
 
+/**************
+evma_attach_fd
+**************/
+
+extern "C" const char *evma_attach_fd (int file_descriptor, int notify_readable, int notify_writable)
+{
+	if (!EventMachine)
+		throw std::runtime_error ("not initialized");
+	return EventMachine->AttachFD (file_descriptor, (notify_readable ? true : false), (notify_writable ? true : false));
+}
+
+/**************
+evma_detach_fd
+**************/
+
+extern "C" int evma_detach_fd (const char *binding)
+{
+	if (!EventMachine)
+		throw std::runtime_error ("not initialized");
+
+	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
+	if (ed)
+		return EventMachine->DetachFD (ed);
+	else
+		throw std::runtime_error ("invalid binding to detach");
+}
 
 /**********************
 evma_create_tcp_server

data/ext/ed.cpp

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: ed.cpp 687 2008-05-15 14:28:32Z francis $
+$Id: ed.cpp 785 2008-09-15 09:46:23Z francis $
 
 File:     ed.cpp
 Date:     06Apr06
@@ -174,6 +174,8 @@ ConnectionDescriptor::ConnectionDescriptor
 ConnectionDescriptor::ConnectionDescriptor (int sd, EventMachine_t *em):
 	EventableDescriptor (sd, em),
 	bConnectPending (false),
+	bNotifyReadable (false),
+	bNotifyWritable (false),
 	bReadAttemptedAfterClose (false),
 	bWriteAttemptedAfterClose (false),
 	OutboundDataSize (0),
@@ -368,7 +370,7 @@ bool ConnectionDescriptor::SelectForWrite()
    * have outgoing data to send.
    */
 
-  if (bConnectPending)
+  if (bConnectPending || bNotifyWritable)
     return true;
   else {
     return (GetOutboundDataSize() > 0);
@@ -413,6 +415,12 @@ void ConnectionDescriptor::Read()
 		return;
 	}
 
+	if (bNotifyReadable) {
+		if (EventCallback)
+			(*EventCallback)(GetBinding().c_str(), EM_CONNECTION_NOTIFY_READABLE, NULL, 0);
+		return;
+	}
+
 	LastIo = gCurrentLoopTime;
 
 	int total_bytes_read = 0;
@@ -549,6 +557,13 @@ void ConnectionDescriptor::Write()
 			//bCloseNow = true;
 	}
 	else {
+
+		if (bNotifyWritable) {
+			if (EventCallback)
+				(*EventCallback)(GetBinding().c_str(), EM_CONNECTION_NOTIFY_WRITABLE, NULL, 0);
+			return;
+		}
+
 		_WriteOutboundData();
 	}
 }

data/ext/ed.h

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: ed.h 687 2008-05-15 14:28:32Z francis $
+$Id: ed.h 785 2008-09-15 09:46:23Z francis $
 
 File:     ed.h
 Date:     06Apr06
@@ -40,6 +40,7 @@ class EventableDescriptor: public Bindable_t
 		virtual ~EventableDescriptor();
 
 		int GetSocket() {return MySocket;}
+		void SetSocketInvalid() { MySocket = INVALID_SOCKET; }
 		void Close();
 
 		virtual void Read() = 0;
@@ -140,6 +141,9 @@ class ConnectionDescriptor: public EventableDescriptor
 
 		void SetConnectPending (bool f) { bConnectPending = f; }
 
+		void SetNotifyReadable (bool readable) { bNotifyReadable = readable; }
+		void SetNotifyWritable (bool writable) { bNotifyWritable = writable; }
+
 		virtual void Read();
 		virtual void Write();
 		virtual void Heartbeat();
@@ -172,6 +176,10 @@ class ConnectionDescriptor: public EventableDescriptor
 
 	protected:
 		bool bConnectPending;
+
+		bool bNotifyReadable;
+		bool bNotifyWritable;
+
 		bool bReadAttemptedAfterClose;
 		bool bWriteAttemptedAfterClose;
 

data/ext/em.cpp

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: em.cpp 686 2008-05-14 21:21:10Z francis $
+$Id: em.cpp 785 2008-09-15 09:46:23Z francis $
 
 File:     em.cpp
 Date:     06Apr06
@@ -635,12 +635,14 @@ SelectData_t::SelectData_t()
 _SelectDataSelect
 *****************/
 
+#ifdef HAVE_TBR
 static VALUE _SelectDataSelect (void *v)
 {
 	SelectData_t *sd = (SelectData_t*)v;
 	sd->nSockets = select (sd->maxsocket+1, &(sd->fdreads), &(sd->fdwrites), NULL, &(sd->tv));
 	return Qnil;
 }
+#endif
 
 /*********************
 SelectData_t::_Select
@@ -654,7 +656,7 @@ int SelectData_t::_Select()
 	#endif
 
 	#ifndef HAVE_TBR
-	return rb_thread_select (maxsocket+1, &fdreads, &fdwrites, NULL, &tv);
+	return EmSelect (maxsocket+1, &fdreads, &fdwrites, NULL, &tv);
 	#endif
 }
 
@@ -1163,6 +1165,113 @@ const char *EventMachine_t::ConnectToUnixServer (const char *server)
 	#endif
 }
 
+/************************
+EventMachine_t::AttachFD
+************************/
+
+const char *EventMachine_t::AttachFD (int fd, bool notify_readable, bool notify_writable)
+{
+	#ifdef OS_UNIX
+	if (fcntl(fd, F_GETFL, 0) < 0)
+		throw std::runtime_error ("invalid file descriptor");
+	#endif
+
+	#ifdef OS_WIN32
+	// TODO: add better check for invalid file descriptors (see ioctlsocket or getsockopt)
+	if (fd == INVALID_SOCKET)
+		throw std::runtime_error ("invalid file descriptor");
+	#endif
+
+	{// Check for duplicate descriptors
+		for (size_t i = 0; i < Descriptors.size(); i++) {
+			EventableDescriptor *ed = Descriptors[i];
+			assert (ed);
+			if (ed->GetSocket() == fd)
+				throw std::runtime_error ("adding existing descriptor");
+		}
+
+		for (size_t i = 0; i < NewDescriptors.size(); i++) {
+			EventableDescriptor *ed = NewDescriptors[i];
+			assert (ed);
+			if (ed->GetSocket() == fd)
+				throw std::runtime_error ("adding existing new descriptor");
+		}
+	}
+
+	ConnectionDescriptor *cd = new ConnectionDescriptor (fd, this);
+	if (!cd)
+		throw std::runtime_error ("no connection allocated");
+
+	cd->SetConnectPending (true);
+	cd->SetNotifyReadable (notify_readable);
+	cd->SetNotifyWritable (notify_writable);
+
+	Add (cd);
+
+	const char *out = NULL;
+	out = cd->GetBinding().c_str();
+	if (out == NULL)
+		closesocket (fd);
+	return out;
+}
+
+/************************
+EventMachine_t::DetachFD
+************************/
+
+int EventMachine_t::DetachFD (EventableDescriptor *ed)
+{
+	if (!ed)
+		throw std::runtime_error ("detaching bad descriptor");
+
+	#ifdef HAVE_EPOLL
+	if (bEpoll) {
+		if (ed->GetSocket() != INVALID_SOCKET) {
+			assert (bEpoll); // wouldn't be in this method otherwise.
+			assert (epfd != -1);
+			int e = epoll_ctl (epfd, EPOLL_CTL_DEL, ed->GetSocket(), ed->GetEpollEvent());
+			// ENOENT or EBADF are not errors because the socket may be already closed when we get here.
+			if (e && (errno != ENOENT) && (errno != EBADF)) {
+				char buf [200];
+				snprintf (buf, sizeof(buf)-1, "unable to delete epoll event: %s", strerror(errno));
+				throw std::runtime_error (buf);
+			}
+		}
+	}
+	#endif
+
+	#ifdef HAVE_KQUEUE
+	if (bKqueue) {
+		struct kevent k;
+		EV_SET (&k, ed->GetSocket(), EVFILT_READ, EV_DELETE, 0, 0, ed);
+		int t = kevent (kqfd, &k, 1, NULL, 0, NULL);
+		assert (t == 0);
+	}
+	#endif
+
+	{ // remove descriptor from lists
+		int i, j;
+		int nSockets = Descriptors.size();
+		for (i=0, j=0; i < nSockets; i++) {
+			EventableDescriptor *ted = Descriptors[i];
+			assert (ted);
+			if (ted != ed)
+				Descriptors [j++] = ted;
+		}
+		while ((size_t)j < Descriptors.size())
+			Descriptors.pop_back();
+
+		ModifiedDescriptors.erase (ed);
+	}
+
+	int fd = ed->GetSocket();
+
+	// We depend on ~EventableDescriptor not calling close() if the socket is invalid
+	ed->SetSocketInvalid();
+	delete ed;
+
+	return fd;
+}
 
 /************
 name2address

data/ext/em.h

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: em.h 668 2008-01-04 23:00:34Z blackhedd $
+$Id: em.h 785 2008-09-15 09:46:23Z francis $
 
 File:     em.h
 Date:     06Apr06
@@ -69,6 +69,8 @@ class EventMachine_t
 		const char *InstallOneshotTimer (int);
 		const char *ConnectToServer (const char *, int);
 		const char *ConnectToUnixServer (const char *);
+		const char *AttachFD (int, bool, bool);
+
 		const char *CreateTcpServer (const char *, int);
 		const char *OpenDatagramSocket (const char *, int);
 		const char *CreateUnixDomainServer (const char*);
@@ -79,6 +81,7 @@ class EventMachine_t
 
 		void Add (EventableDescriptor*);
 		void Modify (EventableDescriptor*);
+		int DetachFD (EventableDescriptor*);
 		void ArmKqueueWriter (EventableDescriptor*);
 		void ArmKqueueReader (EventableDescriptor*);
 

data/ext/eventmachine.h

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: eventmachine.h 679 2008-01-19 01:40:06Z blackhedd $
+$Id: eventmachine.h 785 2008-09-15 09:46:23Z francis $
 
 File:     eventmachine.h
 Date:     15Apr06
@@ -30,7 +30,10 @@ extern "C" {
 		EM_CONNECTION_UNBOUND = 102,
 		EM_CONNECTION_ACCEPTED = 103,
 		EM_CONNECTION_COMPLETED = 104,
-		EM_LOOPBREAK_SIGNAL = 105
+		EM_LOOPBREAK_SIGNAL = 105,
+		EM_CONNECTION_NOTIFY_READABLE = 106,
+		EM_CONNECTION_NOTIFY_WRITABLE = 107
+
 	};
 
 	void evma_initialize_library (void(*)(const char*, int, const char*, int));
@@ -39,6 +42,10 @@ extern "C" {
 	const char *evma_install_oneshot_timer (int seconds);
 	const char *evma_connect_to_server (const char *server, int port);
 	const char *evma_connect_to_unix_server (const char *server);
+
+	const char *evma_attach_fd (int file_descriptor, int read_mode, int write_mode);
+	int evma_detach_fd (const char *binding);
+
 	void evma_stop_tcp_server (const char *signature);
 	const char *evma_create_tcp_server (const char *address, int port);
 	const char *evma_create_unix_domain_server (const char *filename);

data/ext/rubymain.cpp

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: rubymain.cpp 679 2008-01-19 01:40:06Z blackhedd $
+$Id: rubymain.cpp 785 2008-09-15 09:46:23Z francis $
 
 File:     rubymain.cpp
 Date:     06Apr06
@@ -39,6 +39,8 @@ static VALUE Intern_delete;
 static VALUE Intern_call;
 static VALUE Intern_receive_data;
 
+static VALUE Intern_notify_readable;
+static VALUE Intern_notify_writable;
 
 /****************
 t_event_callback
@@ -53,6 +55,20 @@ static void event_callback (const char *a1, int a2, const char *a3, int a4)
 			rb_raise (rb_eRuntimeError, "no connection");
 		rb_funcall (q, Intern_receive_data, 1, rb_str_new (a3, a4));
 	}
+	else if (a2 == EM_CONNECTION_NOTIFY_READABLE) {
+		VALUE t = rb_ivar_get (EmModule, Intern_at_conns);
+		VALUE q = rb_hash_aref (t, rb_str_new2(a1));
+		if (q == Qnil)
+			rb_raise (rb_eRuntimeError, "no connection");
+		rb_funcall (q, Intern_notify_readable, 0);
+	}
+	else if (a2 == EM_CONNECTION_NOTIFY_WRITABLE) {
+		VALUE t = rb_ivar_get (EmModule, Intern_at_conns);
+		VALUE q = rb_hash_aref (t, rb_str_new2(a1));
+		if (q == Qnil)
+			rb_raise (rb_eRuntimeError, "no connection");
+		rb_funcall (q, Intern_notify_writable, 0);
+	}
 	else if (a2 == EM_LOOPBREAK_SIGNAL) {
 		rb_funcall (EmModule, Intern_run_deferred_callbacks, 0);
 	}
@@ -320,6 +336,27 @@ static VALUE t_connect_unix_server (VALUE self, VALUE serversocket)
 	return rb_str_new2 (f);
 }
 
+/***********
+t_attach_fd
+***********/
+
+static VALUE t_attach_fd (VALUE self, VALUE file_descriptor, VALUE read_mode, VALUE write_mode)
+{
+	const char *f = evma_attach_fd (NUM2INT(file_descriptor), (read_mode == Qtrue) ? 1 : 0, (write_mode == Qtrue) ? 1 : 0);
+	if (!f || !*f)
+		rb_raise (rb_eRuntimeError, "no connection");
+	return rb_str_new2 (f);
+}
+
+/***********
+t_detach_fd
+***********/
+
+static VALUE t_detach_fd (VALUE self,  VALUE signature)
+{
+	return INT2NUM(evma_detach_fd (StringValuePtr(signature)));
+}
+
 /*****************
 t_open_udp_socket
 *****************/
@@ -565,6 +602,9 @@ extern "C" void Init_rubyeventmachine()
 	Intern_call = rb_intern ("call");
 	Intern_receive_data = rb_intern ("receive_data");
 
+	Intern_notify_readable = rb_intern ("notify_readable");
+	Intern_notify_writable = rb_intern ("notify_writable");
+
 	// INCOMPLETE, we need to define class Connections inside module EventMachine
 	// run_machine and run_machine_without_threads are now identical.
 	// Must deprecate the without_threads variant.
@@ -590,6 +630,10 @@ extern "C" void Init_rubyeventmachine()
 	rb_define_module_function (EmModule, "report_connection_error_status", (VALUE(*)(...))t_report_connection_error_status, 1);
 	rb_define_module_function (EmModule, "connect_server", (VALUE(*)(...))t_connect_server, 2);
 	rb_define_module_function (EmModule, "connect_unix_server", (VALUE(*)(...))t_connect_unix_server, 1);
+
+	rb_define_module_function (EmModule, "attach_fd", (VALUE (*)(...))t_attach_fd, 3);
+	rb_define_module_function (EmModule, "detach_fd", (VALUE (*)(...))t_detach_fd, 1);
+
 	rb_define_module_function (EmModule, "open_udp_socket", (VALUE(*)(...))t_open_udp_socket, 2);
 	rb_define_module_function (EmModule, "read_keyboard", (VALUE(*)(...))t_read_keyboard, 0);
 	rb_define_module_function (EmModule, "release_machine", (VALUE(*)(...))t_release_machine, 0);
@@ -626,5 +670,9 @@ extern "C" void Init_rubyeventmachine()
 	rb_define_const (EmModule, "ConnectionAccepted", INT2NUM(103));
 	rb_define_const (EmModule, "ConnectionCompleted", INT2NUM(104));
 	rb_define_const (EmModule, "LoopbreakSignalled", INT2NUM(105));
+
+	rb_define_const (EmModule, "ConnectionNotifyReadable", INT2NUM(106));
+	rb_define_const (EmModule, "ConnectionNotifyWritable", INT2NUM(107));
+
 }
 

data/lib/eventmachine.rb

@@ -1,4 +1,4 @@
-# $Id: eventmachine.rb 688 2008-05-15 23:44:39Z francis $
+# $Id: eventmachine.rb 785 2008-09-15 09:46:23Z francis $
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com
@@ -213,18 +213,32 @@ module EventMachine
 	# will start without release_machine being called and will immediately throw
 	# a C++ runtime error.
 	#
-	def EventMachine::run &block
-		@conns = {}
-		@acceptors = {}
-		@timers = {}
-		begin
-			@reactor_running = true
-			initialize_event_machine
-			block and add_timer 0, block
-			run_machine
-		ensure
-			release_machine
-			@reactor_running = false
+	def EventMachine::run blk=nil, tail=nil, &block
+		@tails ||= []
+		tail and @tails.unshift(tail)
+
+		if reactor_running?
+			(b = blk || block) and b.call # next_tick(b)
+		else
+			@conns = {}
+			@acceptors = {}
+			@timers = {}
+			@wrapped_exception = nil
+			begin
+				@reactor_running = true
+				initialize_event_machine
+				(b = blk || block) and add_timer(0, b)
+				run_machine
+			ensure
+				release_machine
+				@reactor_running = false
+			end
+
+			until @tails.empty?
+				@tails.pop.call
+			end
+
+			raise @wrapped_exception if @wrapped_exception
 		end
 	end
 
@@ -242,6 +256,23 @@ module EventMachine
 	    run(&pr)
     end
 
+    # fork_reactor forks a new process and calls EM#run inside of it, passing your block.
+    #--
+    # This implementation is subject to change, especially if we clean up the relationship
+    # of EM#run to @reactor_running.
+    # Original patch by Aman Gupta.
+    #
+    def EventMachine::fork_reactor &block
+	    Kernel.fork do
+		    if self.reactor_running?
+			    self.stop_event_loop
+			    self.release_machine
+			    self.instance_variable_set( '@reactor_running', false )
+		    end
+		    self.run block
+	    end
+    end
+
 
   # +deprecated+
   #--
@@ -527,6 +558,7 @@ module EventMachine
 
     s = start_unix_server filename
     @acceptors[s] = [klass,args,block]
+    s
   end
 
   # EventMachine#connect initiates a TCP connection to a remote
@@ -646,6 +678,71 @@ module EventMachine
     c
   end
 
+  # EventMachine::attach registers a given file descriptor or IO object with the eventloop
+  #
+  # If the handler provided has the functions notify_readable or notify_writable defined,
+  # EventMachine will not read or write from the socket, and instead fire the corresponding
+  # callback on the handler.
+  #
+  # To detach the file descriptor, use EventMachine::Connection#detach
+  #
+  # === Usage Example
+  #
+  #   module SimpleHttpClient
+  #     def initialize sock
+  #       @sock = sock
+  #     end
+  #
+  #     def notify_readable
+  #       header = @sock.readline
+  #
+  #       if header == "\r\n"
+  #         # detach returns the file descriptor number (fd == @sock.fileno)
+  #         fd = detach
+  #       end
+  #     rescue EOFError
+  #       detach
+  #     end
+  #
+  #     def unbind
+  #       EM.next_tick do
+  #         # socket is detached from the eventloop, but still open
+  #         data = @sock.read
+  #       end
+  #     end
+  #   end
+  #
+  #   EM.run{
+  #     $sock = TCPSocket.new('site.com', 80)
+  #     $sock.write("GET / HTTP/1.0\r\n\r\n")
+  #     EM.attach $sock, SimpleHttpClient, $sock
+  #   }
+  #
+  #--
+  # Thanks to Riham Aldakkak (eSpace Technologies) for the initial patch
+  def  EventMachine::attach io, handler=nil, *args
+    klass = if (handler and handler.is_a?(Class))
+      handler
+    else
+      Class.new( Connection ) {handler and include handler}
+    end
+
+    arity = klass.instance_method(:initialize).arity
+    expected = arity >= 0 ? arity : -(arity + 1)
+    if (arity >= 0 and args.size != expected) or (arity < 0 and args.size < expected)
+      raise ArgumentError, "wrong number of arguments for #{klass}#initialize (#{args.size} for #{expected})"
+    end
+
+    readmode  = klass.public_instance_methods.any?{|m| m.to_sym == :notify_readable }
+    writemode = klass.public_instance_methods.any?{|m| m.to_sym == :notify_writable }
+
+    s = attach_fd io.respond_to?(:fileno) ? io.fileno : io, readmode, writemode
+
+    c = klass.new s, *args
+    @conns[s] = c
+    block_given? and yield c
+    c
+  end
 
     #--
     # EXPERIMENTAL. DO NOT RELY ON THIS METHOD TO BE HERE IN THIS FORM, OR AT ALL.
@@ -1057,12 +1154,26 @@ module EventMachine
 		# No one was using it, and it degraded performance significantly.
 		# It's in original_event_callback, which is dead code.
 		#
+		# Changed 25Jul08: Added a partial solution to the problem of exceptions
+		# raised in user-written event-handlers. If such exceptions are not caught,
+		# we must cause the reactor to stop, and then re-raise the exception.
+		# Otherwise, the reactor doesn't stop and it's left on the call stack.
+		# This is partial because we only added it to #unbind, where it's critical
+		# (to keep unbind handlers from being re-entered when a stopping reactor
+		# runs down open connections). It should go on the other calls to user
+		# code, but the performance impact may be too large.
+		#
 		if opcode == ConnectionData
 			c = @conns[conn_binding] or raise ConnectionNotBound
 			c.receive_data data
 		elsif opcode == ConnectionUnbound
 			if c = @conns.delete( conn_binding )
-				c.unbind
+				begin
+					c.unbind
+				rescue
+					@wrapped_exception = $!
+					stop
+				end
 			elsif c = @acceptors.delete( conn_binding )
 				# no-op
 			else
@@ -1083,6 +1194,12 @@ module EventMachine
 			c.connection_completed
 		elsif opcode == LoopbreakSignalled
 			run_deferred_callbacks
+		elsif opcode == ConnectionNotifyReadable
+			c = @conns[conn_binding] or raise ConnectionNotBound
+			c.notify_readable
+		elsif opcode == ConnectionNotifyWritable
+			c = @conns[conn_binding] or raise ConnectionNotBound
+			c.notify_writable
 		end
 	end
 
@@ -1325,6 +1442,12 @@ class Connection
 		EventMachine::close_connection @signature, after_writing
 	end
 
+	# EventMachine::Connection#detach will remove the given connection from the event loop.
+	# The connection's socket remains open and its file descriptor number is returned
+	def detach
+		EventMachine::detach_fd @signature
+	end
+
 	# EventMachine::Connection#close_connection_after_writing is a variant of close_connection.
 	# All of the descriptive comments given for close_connection also apply to
 	# close_connection_after_writing, <i>with one exception:</i> If the connection has
@@ -1609,13 +1732,14 @@ EM::P = EventMachine::Protocols
 require 'protocols/tcptest'
 require 'protocols/httpclient'
 require 'protocols/line_and_text'
-require 'protocols/header_and_content'
 require 'protocols/linetext2'
+require 'protocols/header_and_content'
 require 'protocols/httpcli2'
 require 'protocols/stomp'
 require 'protocols/smtpclient'
 require 'protocols/smtpserver'
 require 'protocols/saslauth'
+#require 'protocols/postgres' UNCOMMENT THIS LINE WHEN THE POSTGRES CODE IS READY FOR PRIME TIME.
 
 require 'em/processes'