eventmachine 0.4.0 → 0.4.2

data/RELEASE_NOTES

@@ -1,7 +1,20 @@
-$Id: RELEASE_NOTES 2283 2006-04-13 10:17:37Z francis $
+$Id: RELEASE_NOTES 2326 2006-04-19 16:16:16Z francis $
 
 RUBY/EventMachine RELEASE NOTES
 
+--------------------------------------------------
+Version: 0.4.2, released 19Apr06
+Changed the Ruby-glue so the extension will play nicer
+in the sandbox with Ruby threads.
+Added an EventMachine::run_without_threads API to
+switch off the thread-awareness for better performance
+in programs that do not spin any Ruby threads.
+
+--------------------------------------------------
+Version: 0.4.1, released 15Apr06
+Reworked the shared-object interface to make it easier to
+use EventMachine from languages other than Ruby.
+
 --------------------------------------------------
 Version: 0.3.2, released 12Apr06
 Added support for a user-supplied block in EventMachine#connect.

data/ext/cmain.cpp

@@ -0,0 +1,146 @@
+/*****************************************************************************
+
+$Id: libmain.cpp 2291 2006-04-14 03:56:18Z francis $
+
+File:     libmain.cpp
+Date:     06Apr06
+
+Copyright (C) 2006 by Francis Cianfrocca. All Rights Reserved.
+Gmail: garbagecat20
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of 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.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+*****************************************************************************/
+
+#include "project.h"
+
+
+static EventMachine_t *EventMachine;
+
+
+/***********************
+evma_initialize_library
+***********************/
+
+extern "C" void evma_initialize_library (void(*cb)(const char*, int, const char*, int))
+{
+	// Probably a bad idea to mess with the signal mask of a process
+	// we're just being linked into.
+	//InstallSignalHandlers();
+	if (EventMachine)
+		throw std::runtime_error ("already initialized");
+	EventMachine = new EventMachine_t (cb);
+}
+
+
+/********************
+evma_release_library
+********************/
+
+extern "C" void evma_release_library()
+{
+  if (!EventMachine)
+    throw std::runtime_error ("not initialized");
+  delete EventMachine;
+  EventMachine = NULL;
+}
+
+
+/****************
+evma_run_machine
+****************/
+
+extern "C" void evma_run_machine()
+{
+	if (!EventMachine)
+		throw std::runtime_error ("not initialized");
+	EventMachine->Run();
+}
+
+
+/**************************
+evma_install_oneshot_timer
+**************************/
+
+extern "C" const char *evma_install_oneshot_timer (int seconds)
+{
+	if (!EventMachine)
+		throw std::runtime_error ("not initialized");
+	return EventMachine->InstallOneshotTimer (seconds);
+}
+
+
+/**********************
+evma_connect_to_server
+**********************/
+
+extern "C" const char *evma_connect_to_server (const char *server, int port)
+{
+	if (!EventMachine)
+		throw std::runtime_error ("not initialized");
+	return EventMachine->ConnectToServer (server, port);
+}
+
+
+/**********************
+evma_create_tcp_server
+**********************/
+
+extern "C" const char *evma_create_tcp_server (const char *address, int port)
+{
+	if (!EventMachine)
+		throw std::runtime_error ("not initialized");
+	return EventMachine->CreateTcpServer (address, port);
+}
+
+
+/****************************
+evma_send_data_to_connection
+****************************/
+
+extern "C" int evma_send_data_to_connection (const char *binding, const char *data, int data_length)
+{
+	if (!EventMachine)
+		throw std::runtime_error ("not initialized");
+	return ConnectionDescriptor::SendDataToConnection (binding, data, data_length);
+}
+
+
+/*********************
+evma_close_connection
+*********************/
+
+extern "C" void evma_close_connection (const char *binding, int after_writing)
+{
+	if (!EventMachine)
+		throw std::runtime_error ("not initialized");
+	ConnectionDescriptor::CloseConnection (binding, (after_writing ? true : false));
+}
+
+
+/*****************
+evma_stop_machine
+*****************/
+
+extern "C" void evma_stop_machine()
+{
+	if (!EventMachine)
+		throw std::runtime_error ("not initialized");
+	EventMachine->ScheduleHalt();
+}
+
+
+
+

data/ext/eventmachine.h

@@ -0,0 +1,49 @@
+/*****************************************************************************
+
+$Id: eventmachine.h 2313 2006-04-15 16:12:57Z francis $
+
+File:     eventmachine.h
+Date:     15Apr06
+
+Copyright (C) 2006 by Francis Cianfrocca. All Rights Reserved.
+Gmail: garbagecat10
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of 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.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+*****************************************************************************/
+
+#ifndef __EVMA_EventMachine__H_
+#define __EVMA_EventMachine__H_
+
+#if __cplusplus
+extern "C" {
+#endif
+
+	void evma_initialize_library (void(*)(const char*, int, const char*, int));
+	void evma_run_machine();
+	void evma_release_library();
+	const char *evma_install_oneshot_timer (int seconds);
+	const char *evma_connect_to_server (const char *server, int port);
+	const char *evma_create_tcp_server (const char *address, int port);
+	int evma_send_data_to_connection (const char *binding, const char *data, int data_length);
+	void evma_close_connection (const char *binding, int after_writing);
+	void evma_stop_machine();
+#if __cplusplus
+}
+#endif
+
+
+#endif // __EventMachine__H_
+

data/ext/extconf.rb

@@ -1,4 +1,4 @@
-# $Id: extconf.rb 2291 2006-04-14 03:56:18Z francis $
+# $Id: extconf.rb 2328 2006-04-19 16:31:45Z francis $
 #
 #----------------------------------------------------------------------------
 #
@@ -28,4 +28,5 @@
 
 require 'mkmf'
 CONFIG['LDSHARED'] = "$(CXX) -shared"
-create_makefile "libeventmachine"
+$LOCAL_LIBS << "-lpthread"
+create_makefile "rubyeventmachine"

data/ext/{libmain.cpp → rubymain.cpp}

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: libmain.cpp 2291 2006-04-14 03:56:18Z francis $
+$Id: libmain.cpp 2309 2006-04-15 15:37:53Z francis $
 
 File:     libmain.cpp
 Date:     06Apr06
@@ -26,149 +26,126 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 #include <ruby.h>
 #include "project.h"
+#include "eventmachine.h"
 
 
-static EventMachine_t *EventMachine;
 
+/*******
+Statics
+*******/
 
-/******************
-initialize_library
-******************/
-
-extern "C" void initialize_library (void(*cb)(const char*, int, const char*, int))
-{
-	InstallSignalHandlers();
-	if (EventMachine)
-		throw std::runtime_error ("already initialized");
-	EventMachine = new EventMachine_t (cb);
-}
-
-
-/***************
-release_library
-***************/
-
-extern "C" void release_library()
-{
-  if (!EventMachine)
-    throw std::runtime_error ("not initialized");
-  delete EventMachine;
-  EventMachine = NULL;
-}
-
-
-/***********
-run_machine
-***********/
-
-extern "C" void run_machine()
-{
-	if (!EventMachine)
-		throw std::runtime_error ("not initialized");
-	EventMachine->Run();
-}
-
-
-/*********************
-install_oneshot_timer
-*********************/
-
-extern "C" const char *install_oneshot_timer (int seconds)
-{
-	if (!EventMachine)
-		throw std::runtime_error ("not initialized");
-	return EventMachine->InstallOneshotTimer (seconds);
-}
-
-
-/*****************
-connect_to_server
-*****************/
-
-extern "C" const char *connect_to_server (const char *server, int port)
-{
-	if (!EventMachine)
-		throw std::runtime_error ("not initialized");
-	return EventMachine->ConnectToServer (server, port);
-}
-
-
-/*****************
-create_tcp_server
-*****************/
-
-extern "C" const char *create_tcp_server (const char *address, int port)
-{
-	if (!EventMachine)
-		throw std::runtime_error ("not initialized");
-	return EventMachine->CreateTcpServer (address, port);
-}
-
+static VALUE EmModule;
+static int SyncSockets [2];
+static bool UseThreads;
 
-/***********************
-send_data_to_connection
-***********************/
+static const char *A1;
+static int A2;
+static const char *A3;
+static int A4;
 
-extern "C" int send_data_to_connection (const char *binding, const char *data, int data_length)
-{
-	if (!EventMachine)
-		throw std::runtime_error ("not initialized");
-  return ConnectionDescriptor::SendDataToConnection (binding, data, data_length);
-}
 
 
 /****************
-close_connection
+t_event_callback
 ****************/
 
-extern "C" void close_connection (const char *binding, int after_writing)
+static void event_callback (const char *a1, int a2, const char *a3, int a4)
 {
-	if (!EventMachine)
-		throw std::runtime_error ("not initialized");
-  ConnectionDescriptor::CloseConnection (binding, (after_writing ? true : false));
+	if (UseThreads) {
+		A1 = a1; A2 = a2; A3 = a3; A4 = a4;
+		write (SyncSockets[1], "+", 1);
+		char g;
+		read (SyncSockets[1], &g, 1);
+	}
+	else {
+		rb_funcall (EmModule, rb_intern ("event_callback"), 3, rb_str_new2(a1), (a2 << 1) | 1, rb_str_new(a3,a4));
+	}
 }
 
 
+/********
+TRunEvma
+********/
 
-
-/*******
-Statics
-*******/
-
-static VALUE EmModule;
-
-/****************
-t_event_callback
-****************/
-
-static void event_callback (const char *a1, int a2, const char *a3, int a4)
+void *TRunEvma (void *v)
 {
-	rb_funcall (EmModule, rb_intern ("event_callback"), 3, rb_str_new2(a1), (a2 << 1) | 1, rb_str_new(a3,a4));
+	evma_run_machine();
+	write (SyncSockets[1], "$", 1);
 }
 
+
 /**************************
 t_initialize_event_machine
 **************************/
 
 static VALUE t_initialize_event_machine (VALUE self)
 {
-	InstallSignalHandlers();
-	if (EventMachine)
-		rb_raise (rb_eRuntimeError, "event-machine already initialized");
-	EventMachine = new EventMachine_t (event_callback);
+	evma_initialize_library (event_callback);
 	return Qnil;
 }
 
 
+
+/*************
+t_run_machine_without_threads
+*************/
+
+static VALUE t_run_machine_without_threads (VALUE self)
+{
+	UseThreads = false;
+	evma_run_machine();
+}
+
+
 /*************
 t_run_machine
 *************/
 
 static VALUE t_run_machine (VALUE self)
 {
-	if (!EventMachine)
-		rb_raise (rb_eRuntimeError, "event-machine not initialized");
-	EventMachine->Run();
+	UseThreads = true;
+
+	int sp = socketpair (AF_LOCAL, SOCK_STREAM, 0, SyncSockets);
+	if (sp)
+		throw std::runtime_error ("no socket pair");
+
+	char buf [100];
+	snprintf (buf, sizeof(buf), "@io________pipe = IO.new( %d, \"r\")", SyncSockets[0]);
+	rb_eval_string (buf);
+
+	pthread_t tid;
+	pthread_create (&tid, NULL, TRunEvma, NULL);
+
+	while (true) {
+		VALUE v = rb_eval_string ("\
+			if s=select([@io________pipe]) and s=s.shift and s=s.shift\n\
+				r = s.read(1)\n\
+				if r == '+'\n\
+					1\n\
+				elsif r == '$'\n\
+					2\n\
+				else\n\
+					0\n\
+				end\n\
+			else\n\
+				0\n\
+			end\n\
+		");
+
+		if (v == 3) {
+			rb_funcall (EmModule, rb_intern ("event_callback"), 3, rb_str_new2(A1), (A2 << 1) | 1, rb_str_new(A3,A4));
+			write (SyncSockets[0], "", 1);
+		}
+		else if (v == 5) {
+			break;
+		}
+
+	}
+
+	pthread_join (tid, NULL);
+	close (SyncSockets[0]);
+	close (SyncSockets[1]);
+
 	return Qnil;
 }
 
@@ -179,9 +156,7 @@ t_add_oneshot_timer
 
 static VALUE t_add_oneshot_timer (VALUE self, VALUE interval)
 {
-	if (!EventMachine)
-		rb_raise (rb_eRuntimeError, "event-machine not initialized");
-	const char *f = EventMachine->InstallOneshotTimer (FIX2INT (interval));
+	const char *f = evma_install_oneshot_timer (FIX2INT (interval));
 	if (!f || !*f)
 		rb_raise (rb_eRuntimeError, "no timer");
 	return rb_str_new2 (f);
@@ -194,9 +169,7 @@ t_start_server
 
 static VALUE t_start_server (VALUE self, VALUE server, VALUE port)
 {
-	if (!EventMachine)
-		rb_raise (rb_eRuntimeError, "event-machine not initialized");
-	const char *f = EventMachine->CreateTcpServer (StringValuePtr(server), FIX2INT(port));
+	const char *f = evma_create_tcp_server (StringValuePtr(server), FIX2INT(port));
 	if (!f || !*f)
 		rb_raise (rb_eRuntimeError, "no acceptor");
 	return rb_str_new2 (f);
@@ -210,9 +183,7 @@ t_send_data
 
 static VALUE t_send_data (VALUE self, VALUE signature, VALUE data, VALUE data_length)
 {
-	if (!EventMachine)
-		rb_raise (rb_eRuntimeError, "event-machine not initialized");
-  	int b = ConnectionDescriptor::SendDataToConnection (StringValuePtr (signature), StringValuePtr (data), FIX2INT (data_length));
+	int b = evma_send_data_to_connection (StringValuePtr (signature), StringValuePtr (data), FIX2INT (data_length));
 	return (b << 1) | 1;
 }
 
@@ -223,9 +194,7 @@ t_close_connection
 
 static VALUE t_close_connection (VALUE self, VALUE signature, VALUE after_writing)
 {
-	if (!EventMachine)
-		rb_raise (rb_eRuntimeError, "event-machine not initialized");
-	ConnectionDescriptor::CloseConnection (StringValuePtr(signature), ((after_writing == Qtrue) ? true : false));
+	evma_close_connection (StringValuePtr (signature), ((after_writing == Qtrue) ? 1 : 0));
 	return Qnil;
 }
 
@@ -237,9 +206,7 @@ t_connect_server
 
 static VALUE t_connect_server (VALUE self, VALUE server, VALUE port)
 {
-	if (!EventMachine)
-		rb_raise (rb_eRuntimeError, "event-machine not initialized");
-	const char *f = EventMachine->ConnectToServer (StringValuePtr(server), FIX2INT(port));
+	const char *f = evma_connect_to_server (StringValuePtr(server), FIX2INT(port));
 	if (!f || !*f)
 		rb_raise (rb_eRuntimeError, "no connection");
 	return rb_str_new2 (f);
@@ -253,13 +220,7 @@ t_release_machine
 
 static VALUE t_release_machine (VALUE self)
 {
-	if (!EventMachine)
-		rb_raise (rb_eRuntimeError, "event-machine not initialized");
-	delete EventMachine;
-	EventMachine = NULL;
-	// ff line is a mistake, removed 11Apr06. EmModule is set permanently
-	// for the process when we create the EventMachine module in Init_libeventmachine.
-	//EmModule = Qnil;
+	evma_release_library();
 	return Qnil;
 }
 
@@ -270,24 +231,23 @@ t_stop
 
 static VALUE t_stop (VALUE self)
 {
-	if (!EventMachine)
-		rb_raise (rb_eRuntimeError, "event-machine not initialized");
-  EventMachine->ScheduleHalt();
-  return Qnil;
+	evma_stop_machine();
+	return Qnil;
 }
 
 
 
-/********************
-Init_libeventmachine
-********************/
+/*********************
+Init_rubyeventmachine
+*********************/
 
-extern "C" void Init_libeventmachine()
+extern "C" void Init_rubyeventmachine()
 {
 	// INCOMPLETE, we need to define class Connectons inside module EventMachine
 	EmModule = rb_define_module ("EventMachine");
 	rb_define_module_function (EmModule, "initialize_event_machine", (VALUE(*)(...))t_initialize_event_machine, 0);
 	rb_define_module_function (EmModule, "run_machine", (VALUE(*)(...))t_run_machine, 0);
+	rb_define_module_function (EmModule, "run_machine_without_threads", (VALUE(*)(...))t_run_machine_without_threads, 0);
 	rb_define_module_function (EmModule, "add_oneshot_timer", (VALUE(*)(...))t_add_oneshot_timer, 1);
 	rb_define_module_function (EmModule, "start_tcp_server", (VALUE(*)(...))t_start_server, 2);
 	rb_define_module_function (EmModule, "send_data", (VALUE(*)(...))t_send_data, 3);

data/lib/eventmachine.rb

@@ -1,4 +1,4 @@
-# $Id: eventmachine.rb 2289 2006-04-14 03:52:22Z francis $
+# $Id: eventmachine.rb 2325 2006-04-19 16:10:00Z francis $
 #
 # Author:: blackhedd (gmail address: garbagecat20).
 # Date:: 8 Apr 2006
@@ -34,7 +34,7 @@
 #
 # 
 
-require 'libeventmachine'
+require 'rubyeventmachine'
 
 # == Introduction
 # EventMachine provides a fast, lightweight framework for implementing
@@ -164,16 +164,20 @@ module EventMachine
   # See the description of stop_event_loop for an extremely simple client example.
   #
 
-  def EventMachine::run &block
+  def EventMachine::run use_threads = true, &block
     @conns = {}
     @acceptors = {}
     @timers = {}
     initialize_event_machine
     block and add_timer 0, block
-    run_machine
+    use_threads ? run_machine : run_machine_without_threads
     release_machine
   end
 
+  def EventMachine::run_without_threads &block
+    EventMachine::run false, &block
+  end
+
   # EventMachine#add_timer adds a one-shot timer to the event loop.
   # Call it with one or two parameters. The first parameters is a delay-time
   # expressed in <i>seconds</i> (not milliseconds). The second parameter, if

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.11
+rubygems_version: 0.8.10
 specification_version: 1
 name: eventmachine
 version: !ruby/object:Gem::Version 
-  version: 0.4.0
-date: 2006-04-14 00:00:00 -04:00
+  version: 0.4.2
+date: 2006-04-19
 summary: Ruby/EventMachine socket engine library
 require_paths: 
   - lib
@@ -13,7 +13,7 @@ email: garbagecat10@gmail.com
 homepage: http://rubyforge.org/projects/eventmachine
 rubyforge_project: 
 description: 
-autorequire: eventmachine
+autorequire: 
 default_executable: 
 bindir: bin
 has_rdoc: true
@@ -25,23 +25,23 @@ required_ruby_version: !ruby/object:Gem::Version::Requirement
         version: 0.0.0
   version: 
 platform: ruby
-signing_key: 
-cert_chain: 
 authors: []
 files: 
   - tests/testem.rb
   - lib/eventmachine.rb
+  - ext/binder.cpp
+  - ext/rubymain.cpp
   - ext/sigs.h
-  - ext/project.h
   - ext/sigs.cpp
-  - ext/binder.cpp
-  - ext/extconf.rb
-  - ext/em.cpp
-  - ext/binder.h
   - ext/ed.h
-  - ext/ed.cpp
   - ext/em.h
-  - ext/libmain.cpp
+  - ext/cmain.cpp
+  - ext/eventmachine.h
+  - ext/ed.cpp
+  - ext/binder.h
+  - ext/em.cpp
+  - ext/extconf.rb
+  - ext/project.h
   - README
   - RELEASE_NOTES
   - COPYING