eventmachine 0.8.0 → 0.8.1

data/README

@@ -1,4 +1,4 @@
-$Id: README 317 2007-05-22 21:55:43Z blackhedd $
+$Id: README 479 2007-07-27 08:51:26Z blackhedd $
 
 = RUBY/EventMachine
 
@@ -47,9 +47,14 @@ the "C10K problem" by Dan Kegel and others.
 
 EventMachine consists of an extension library written in C++ (which can be
 accessed from languages other than Ruby), and a Ruby module which can be dropped
-into user programs. The current implementation uses the <tt>select(2)</tt> system call
-and may be used on a range of Unix-like systems. A future version of EventMachine
-for Linux will use <tt>epoll(4)</tt> and will thus require a Linux 2.6 kernel.
+into user programs. On most platforms, EventMachine uses the
+<tt>select(2)</tt> system call,
+so it will run on a large range of Unix-like systems and on Microsoft
+Windows with good performance and scalability. On Linux 2.6 kernels, EventMachine
+automatically configures itself to use <tt>epoll(4)</tt> instead of
+<tt>select(2),</tt> so scalability on that platform can be significantly
+improved.
+
 Here's a fully-functional echo server written with EventMachine:
 
       require 'rubygems'
@@ -67,4 +72,3 @@ Here's a fully-functional echo server written with EventMachine:
       }
 
 
-# vim: sts=2 sw=2 ts=4 et ai tw=77

data/ext/cmain.cpp

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: cmain.cpp 377 2007-06-13 01:05:56Z blackhedd $
+$Id: cmain.cpp 476 2007-07-27 03:32:51Z blackhedd $
 
 File:     cmain.cpp
 Date:     06Apr06
@@ -170,6 +170,17 @@ extern "C" void evma_close_connection (const char *binding, int after_writing)
 	ConnectionDescriptor::CloseConnection (binding, (after_writing ? true : false));
 }
 
+/********************
+evma_stop_tcp_server
+********************/
+
+extern "C" void evma_stop_tcp_server (const char *binding)
+{
+	if (!EventMachine)
+		throw std::runtime_error ("not initialized");
+	AcceptorDescriptor::StopAcceptor (binding);
+}
+
 
 /*****************
 evma_stop_machine
@@ -355,6 +366,70 @@ extern "C" int evma_set_rlimit_nofile (int nofiles)
 }
 
 
+/*********************************
+evma_send_file_data_to_connection
+*********************************/
+
+extern "C" int evma_send_file_data_to_connection (const char *binding, const char *filename)
+{
+	/* This is a sugaring over send_data_to_connection that reads a file into a
+	 * locally-allocated buffer, and sends the file data to the remote peer.
+	 * Return the number of bytes written to the caller.
+	 * TODO, needs to impose a limit on the file size. This is intended only for
+	 * small files. (I don't know, maybe 8K or less.) For larger files, use interleaved
+	 * I/O to avoid slowing the rest of the system down.
+	 * TODO: we should return a code rather than barf, in case of file-not-found.
+	 * TODO, does this compile on Windows?
+	 * TODO, given that we want this to work only with small files, how about allocating
+	 * the buffer on the stack rather than the heap?
+	 *
+	 * Modified 25Jul07. This now returns -1 on file-too-large; 0 for success, and a positive
+	 * errno in case of other errors.
+	 *
+	/* Contributed by Kirk Haines.
+	 */
+
+	char data[32*1024];
+	int r;
+
+	if (!EventMachine)
+		throw std::runtime_error("not initialized");
+
+	int Fd = open (filename, O_RDONLY);
+
+	if (Fd < 0)
+		return errno;
+	// From here on, all early returns MUST close Fd.
+
+	struct stat st;
+	if (fstat (Fd, &st)) {
+		int e = errno;
+		close (Fd);
+		return e;
+	}
+
+	int filesize = st.st_size;
+	if (filesize <= 0) {
+		close (Fd);
+		return 0;
+	}
+	else if (filesize > sizeof(data)) {
+		close (Fd);
+		return -1;
+	}
+
+
+	r = read (Fd, data, filesize);
+	if (r != filesize) {
+		int e = errno;
+		close (Fd);
+		return e;
+	}
+	evma_send_data_to_connection (binding, data, r);
+	close (Fd);
+
+	return 0;
+}
 
 
 

data/ext/cplusplus.cpp

@@ -0,0 +1,175 @@
+/*****************************************************************************
+
+$Id: cplusplus.cpp 474 2007-07-27 03:12:30Z blackhedd $
+
+File:     cplusplus.cpp
+Date:     27Jul07
+
+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.
+
+*****************************************************************************/
+
+
+#include "project.h"
+
+
+namespace EM {
+	static map<string, Eventable*> Eventables;
+	static map<string, void(*)()> Timers;
+}
+
+
+/*******
+EM::Run
+*******/
+
+void EM::Run (void (*start_func)())
+{
+	evma__epoll();
+	evma_initialize_library (EM::Callback);
+	if (start_func)
+		AddTimer (0, start_func);
+	evma_run_machine();
+	evma_release_library();
+}
+
+/************
+EM::AddTimer
+************/
+
+void EM::AddTimer (int seconds, void (*func)())
+{
+	if (func) {
+		const char *sig = evma_install_oneshot_timer (seconds);
+		Timers.insert (make_pair (sig, func));
+	}
+}
+
+
+/***************
+EM::StopReactor
+***************/
+
+void EM::StopReactor()
+{
+	evma_stop_machine();
+}
+
+
+/********************
+EM::Acceptor::Accept
+********************/
+
+void EM::Acceptor::Accept (const char *signature)
+{
+	Connection *c = MakeConnection();
+	c->Signature = signature;
+	Eventables.insert (make_pair (c->Signature, c));
+	c->PostInit();
+}
+
+/************************
+EM::Connection::SendData
+************************/
+
+void EM::Connection::SendData (const char *data)
+{
+	if (data)
+		SendData (data, strlen (data));
+}
+
+
+/************************
+EM::Connection::SendData
+************************/
+
+void EM::Connection::SendData (const char *data, int length)
+{
+	evma_send_data_to_connection (Signature.c_str(), data, length);
+}
+
+
+/*********************
+EM::Connection::Close
+*********************/
+
+void EM::Connection::Close (bool afterWriting)
+{
+	evma_close_connection (Signature.c_str(), afterWriting);
+}
+
+
+/***********************
+EM::Connection::Connect
+***********************/
+
+void EM::Connection::Connect (const char *host, int port)
+{
+	Signature = evma_connect_to_server (host, port);
+	Eventables.insert( make_pair (Signature, this));
+}
+
+/*******************
+EM::Acceptor::Start
+*******************/
+
+void EM::Acceptor::Start (const char *host, int port)
+{
+	Signature = evma_create_tcp_server (host, port);
+	Eventables.insert( make_pair (Signature, this));
+}
+
+
+
+/************
+EM::Callback
+************/
+
+void EM::Callback (const char *sig, int ev, const char *data, int length)
+{
+	EM::Eventable *e;
+	void (*f)();
+
+	switch (ev) {
+		case EM_TIMER_FIRED:
+			//(new A())->Start ("192.168.0.8", 9700);
+			//cerr << evma_create_tcp_server ("192.168.0.8", 9700) << " SERVER\n";
+			//(new M())->Connect ("www.bayshorenetworks.com", 80);
+			f = Timers [data];
+			if (f)
+				(*f)();
+			Timers.erase (sig);
+			break;
+
+		case EM_CONNECTION_READ:
+			e = EM::Eventables [sig];
+			e->ReceiveData (data, length);
+			break;
+
+		case EM_CONNECTION_COMPLETED:
+			e = EM::Eventables [sig];
+			e->ConnectionCompleted();
+			break;
+
+		case EM_CONNECTION_ACCEPTED:
+			e = EM::Eventables [sig];
+			e->Accept (data);
+			break;
+
+		case EM_CONNECTION_UNBOUND:
+			e = EM::Eventables [sig];
+			e->Unbind();
+			EM::Eventables.erase (sig);
+			delete e;
+			break;
+	}
+}
+

data/ext/ed.cpp

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: ed.cpp 400 2007-07-11 12:10:33Z blackhedd $
+$Id: ed.cpp 447 2007-07-20 16:42:06Z blackhedd $
 
 File:     ed.cpp
 Date:     06Apr06
@@ -175,6 +175,7 @@ ConnectionDescriptor::ConnectionDescriptor (int sd, EventMachine_t *em):
 	EventableDescriptor (sd, em),
 	bConnectPending (false),
 	bReadAttemptedAfterClose (false),
+	bWriteAttemptedAfterClose (false),
 	OutboundDataSize (0),
 	#ifdef WITH_SSL
 	SslBox (NULL),
@@ -537,10 +538,20 @@ void ConnectionDescriptor::_WriteOutboundData()
 	 * be writable by the time we get around to writing. The kernel might
 	 * have used up its available output buffers between the select call
 	 * and when we get here. So this condition is not an error.
+	 *
+	 * 20Jul07, added the same kind of protection against an invalid socket
+	 * that is at the top of ::Read. Not entirely how this could happen in 
+	 * real life (connection-reset from the remote peer, perhaps?), but I'm
+	 * doing it to address some reports of crashing under heavy loads.
 	 */
 
 	int sd = GetSocket();
-	assert (sd != INVALID_SOCKET);
+	//assert (sd != INVALID_SOCKET);
+	if (sd == INVALID_SOCKET) {
+		assert (!bWriteAttemptedAfterClose);
+		bWriteAttemptedAfterClose = true;
+		return;
+	}
 
 	LastIo = gCurrentLoopTime;
 	char output_buffer [16 * 1024];
@@ -777,6 +788,20 @@ AcceptorDescriptor::~AcceptorDescriptor()
 {
 }
 
+/****************************************
+STATIC: AcceptorDescriptor::StopAcceptor
+****************************************/
+
+void AcceptorDescriptor::StopAcceptor (const char *binding)
+{
+	// TODO: This is something of a hack, or at least it's a static method of the wrong class.
+	AcceptorDescriptor *ad = dynamic_cast <AcceptorDescriptor*> (Bindable_t::GetObject (binding));
+	if (ad)
+		ad->ScheduleClose (false);
+	else
+		throw std::runtime_error ("failed to close nonexistent acceptor");
+}
+
 
 /************************
 AcceptorDescriptor::Read

data/ext/ed.h

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: ed.h 400 2007-07-11 12:10:33Z blackhedd $
+$Id: ed.h 447 2007-07-20 16:42:06Z blackhedd $
 
 File:     ed.h
 Date:     06Apr06
@@ -167,6 +167,7 @@ class ConnectionDescriptor: public EventableDescriptor
 	protected:
 		bool bConnectPending;
 		bool bReadAttemptedAfterClose;
+		bool bWriteAttemptedAfterClose;
 
 		deque<OutboundPage> OutboundPages;
 		int OutboundDataSize;
@@ -255,6 +256,8 @@ class AcceptorDescriptor: public EventableDescriptor
 
 		virtual bool SelectForRead() {return true;}
 		virtual bool SelectForWrite() {return false;}
+
+		static void StopAcceptor (const char *binding);
 };
 
 /********************

data/ext/eventmachine.h

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: eventmachine.h 377 2007-06-13 01:05:56Z blackhedd $
+$Id: eventmachine.h 426 2007-07-17 16:54:08Z blackhedd $
 
 File:     eventmachine.h
 Date:     15Apr06
@@ -39,6 +39,7 @@ 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);
+	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);
 	const char *evma_open_datagram_socket (const char *server, int port);
@@ -50,6 +51,7 @@ extern "C" {
 	int evma_get_comm_inactivity_timeout (const char *binding, /*out*/int *value);
 	int evma_set_comm_inactivity_timeout (const char *binding, /*in,out*/int *value);
 	int evma_get_outbound_data_size (const char *binding);
+	int evma_send_file_data_to_connection (const char *binding, const char *filename);
 
 	void evma_close_connection (const char *binding, int after_writing);
 	void evma_signal_loopbreak();

data/ext/eventmachine_cpp.h

@@ -0,0 +1,94 @@
+/*****************************************************************************
+
+$Id: eventmachine_cpp.h 474 2007-07-27 03:12:30Z blackhedd $
+
+File:     eventmachine_cpp.h
+Date:     27Jul07
+
+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.
+
+*****************************************************************************/
+
+
+#ifndef __EVMA_EventmachineCpp__H_
+#define __EVMA_EventmachineCpp__H_
+
+
+// This material is only for directly integrating EM into C++ programs.
+
+namespace EM {
+
+	void Callback (const char *sig, int event, const char *data, int length);
+	void Run (void(*)(void));
+	void AddTimer (int, void(*)());
+	void StopReactor();
+
+	/***************
+	class Eventable
+	***************/
+
+	class Eventable {
+		public:
+			Eventable() {}
+			virtual ~Eventable() {}
+
+			std::string Signature;
+
+			// Called by the framework
+			virtual void ReceiveData (const char *data, int length) {}
+			virtual void ConnectionCompleted() {}
+			virtual void Accept (const char*) {}
+			virtual void Unbind() {}
+			virtual void PostInit() {}
+
+			void StopReactor() {EM::StopReactor();}
+	};
+
+	/****************
+	class Connection
+	****************/
+
+	class Connection: public Eventable {
+		public:
+			Connection() {}
+			virtual ~Connection() {}
+
+			virtual void Connect (const char*, int);
+
+			void SendData (const char *data);
+			void SendData (const char *data, int length);
+			void Close (bool afterWriting);
+	};
+
+
+	/**************
+	class Acceptor
+	**************/
+
+	class Acceptor: public Eventable {
+		public:
+			Acceptor() {PostInit();}
+			virtual ~Acceptor() {}
+
+			void Start (const char*, int);
+			void Accept (const char*);
+
+			virtual Connection *MakeConnection() {return new Connection();}
+	};
+
+
+};
+
+
+
+
+
+#endif // __EVMA_EventmachineCpp__H_