smparkes-eventmachine 0.12.10.2 → 0.12.10.3

data/.gitignore

@@ -13,4 +13,5 @@ Makefile
 *.pdb
 *.dSYM
 java/src/.project
-/*eventmachine*.gem
+/*eventmachine*.gem
+*.rbc

data/eventmachine.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{smparkes-eventmachine}
-  s.version = "0.12.10.2"
+  s.version = "0.12.10.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Francis Cianfrocca"]

data/ext/binder.cpp

@@ -31,7 +31,6 @@ STATIC Bindable_t::CreateBinding
 
 unsigned long Bindable_t::CreateBinding()
 {
-	// XXX use atomic_t to prevent thread-safety issues
 	static unsigned long num = 0;
 	while(BindingBag[++num]);
 	return num;

data/ext/cmain.cpp

@@ -148,6 +148,7 @@ extern "C" int evma_detach_fd (const unsigned long binding)
 		#else
 			throw std::runtime_error ("invalid binding to detach");
 		#endif
+			return -1;
 }
 
 /************************
@@ -166,6 +167,7 @@ extern "C" int evma_get_file_descriptor (const unsigned long binding)
 		#else
 			throw std::runtime_error ("invalid binding to get_fd");
 		#endif
+			return -1;
 }
 
 /***********************
@@ -340,7 +342,10 @@ evma_send_data_to_connection
 extern "C" int evma_send_data_to_connection (const unsigned long binding, const char *data, int data_length)
 {
 	ensure_eventmachine("evma_send_data_to_connection");
-	return ConnectionDescriptor::SendDataToConnection (binding, data, data_length);
+	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
+	if (ed)
+		return ed->SendOutboundData(data, data_length);
+	return -1;
 }
 
 /******************
@@ -350,7 +355,10 @@ evma_send_datagram
 extern "C" int evma_send_datagram (const unsigned long binding, const char *data, int data_length, const char *address, int port)
 {
 	ensure_eventmachine("evma_send_datagram");
-	return DatagramDescriptor::SendDatagram (binding, data, data_length, address, port);
+	DatagramDescriptor *dd = dynamic_cast <DatagramDescriptor*> (Bindable_t::GetObject (binding));
+	if (dd)
+		return dd->SendOutboundDatagram(data, data_length, address, port);
+	return -1;
 }
 
 
@@ -361,7 +369,9 @@ evma_close_connection
 extern "C" void evma_close_connection (const unsigned long binding, int after_writing)
 {
 	ensure_eventmachine("evma_close_connection");
-	ConnectionDescriptor::CloseConnection (binding, (after_writing ? true : false));
+	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
+	if (ed)
+		ed->ScheduleClose (after_writing ? true : false);
 }
 
 /***********************************
@@ -371,7 +381,10 @@ evma_report_connection_error_status
 extern "C" int evma_report_connection_error_status (const unsigned long binding)
 {
 	ensure_eventmachine("evma_report_connection_error_status");
-	return ConnectionDescriptor::ReportErrorStatus (binding);
+	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
+	if (ed)
+		return ed->ReportErrorStatus();
+	return -1;
 }
 
 /********************
@@ -559,7 +572,7 @@ extern "C" float evma_get_comm_inactivity_timeout (const unsigned long binding)
 	ensure_eventmachine("evma_get_comm_inactivity_timeout");
 	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
 	if (ed) {
-		return ed->GetCommInactivityTimeout();
+		return ((float)ed->GetCommInactivityTimeout() / 1000);
 	}
 	else
 		return 0.0; //Perhaps this should be an exception. Access to an unknown binding.
@@ -574,7 +587,7 @@ extern "C" int evma_set_comm_inactivity_timeout (const unsigned long binding, fl
 	ensure_eventmachine("evma_set_comm_inactivity_timeout");
 	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
 	if (ed) {
-		return ed->SetCommInactivityTimeout (value);
+		return ed->SetCommInactivityTimeout ((uint64_t)(value * 1000));
 	}
 	else
 		return 0; //Perhaps this should be an exception. Access to an unknown binding.
@@ -590,7 +603,7 @@ extern "C" float evma_get_pending_connect_timeout (const unsigned long binding)
 	ensure_eventmachine("evma_get_pending_connect_timeout");
 	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
 	if (ed) {
-		return ed->GetPendingConnectTimeout();
+		return ((float)ed->GetPendingConnectTimeout() / 1000);
 	}
 	else
 		return 0.0;
@@ -606,7 +619,7 @@ extern "C" int evma_set_pending_connect_timeout (const unsigned long binding, fl
 	ensure_eventmachine("evma_set_pending_connect_timeout");
 	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
 	if (ed) {
-		return ed->SetPendingConnectTimeout (value);
+		return ed->SetPendingConnectTimeout ((uint64_t)(value * 1000));
 	}
 	else
 		return 0;
@@ -825,3 +838,14 @@ extern "C" int evma_set_heartbeat_interval(float interval)
 	ensure_eventmachine("evma_set_heartbeat_interval");
 	return EventMachine->SetHeartbeatInterval(interval);
 }
+
+
+/**************************
+evma_get_current_loop_time
+***************************/
+
+extern "C" uint64_t evma_get_current_loop_time()
+{
+	ensure_eventmachine("evma_get_current_loop_time");
+	return EventMachine->GetCurrentTime();
+}

data/ext/ed.cpp

@@ -61,7 +61,8 @@ EventableDescriptor::EventableDescriptor (int sd, EventMachine_t *em):
 	ProxiedFrom(NULL),
 	MaxOutboundBufSize(0),
 	MyEventMachine (em),
-	PendingConnectTimeout(20000000)
+	PendingConnectTimeout(20000000),
+	InactivityTimeout (0)
 {
 	/* There are three ways to close a socket, all of which should
 	 * automatically signal to the event machine that this object
@@ -88,12 +89,13 @@ EventableDescriptor::EventableDescriptor (int sd, EventMachine_t *em):
 		throw std::runtime_error ("bad eventable descriptor");
 	if (MyEventMachine == NULL)
 		throw std::runtime_error ("bad em in eventable descriptor");
-	CreatedAt = gCurrentLoopTime;
+	CreatedAt = MyEventMachine->GetCurrentTime();
 
 	#ifdef HAVE_EPOLL
 	EpollEvent.events = 0;
 	EpollEvent.data.ptr = this;
 	#endif
+	LastActivity = MyEventMachine->GetCurrentTime();
 }
 
 
@@ -103,6 +105,8 @@ EventableDescriptor::~EventableDescriptor
 
 EventableDescriptor::~EventableDescriptor()
 {
+	if (NextHeartbeat)
+		MyEventMachine->ClearHeartbeat(NextHeartbeat);
 	if (EventCallback && bCallbackUnbind)
 		(*EventCallback)(GetBinding(), EM_CONNECTION_UNBOUND, NULL, UnbindReasonCode);
 	if (ProxiedFrom) {
@@ -243,9 +247,9 @@ void EventableDescriptor::_GenericInboundDispatch(const char *buf, int size)
 EventableDescriptor::GetPendingConnectTimeout
 *********************************************/
 
-float EventableDescriptor::GetPendingConnectTimeout()
+uint64_t EventableDescriptor::GetPendingConnectTimeout()
 {
-	return ((float)PendingConnectTimeout / 1000000);
+	return PendingConnectTimeout / 1000;
 }
 
 
@@ -253,16 +257,43 @@ float EventableDescriptor::GetPendingConnectTimeout()
 EventableDescriptor::SetPendingConnectTimeout
 *********************************************/
 
-int EventableDescriptor::SetPendingConnectTimeout (float value)
+int EventableDescriptor::SetPendingConnectTimeout (uint64_t value)
 {
 	if (value > 0) {
-		PendingConnectTimeout = (Int64)(value * 1000000);
+		PendingConnectTimeout = value * 1000;
+		MyEventMachine->QueueHeartbeat(this);
 		return 1;
 	}
 	return 0;
 }
 
 
+/*************************************
+EventableDescriptor::GetNextHeartbeat
+*************************************/
+
+uint64_t EventableDescriptor::GetNextHeartbeat()
+{
+	if (NextHeartbeat)
+		MyEventMachine->ClearHeartbeat(NextHeartbeat);
+
+	NextHeartbeat = 0;
+
+	if (!ShouldDelete()) {
+		uint64_t time_til_next = GetCommInactivityTimeout() * 1000;
+		if (IsConnectPending()) {
+			if (time_til_next == 0 || PendingConnectTimeout < time_til_next)
+				time_til_next = PendingConnectTimeout;
+		}
+		if (time_til_next == 0)
+			return 0;
+		NextHeartbeat = time_til_next + MyEventMachine->GetRealTime();
+	}
+
+	return NextHeartbeat;
+}
+
+
 /******************************************
 ConnectionDescriptor::ConnectionDescriptor
 ******************************************/
@@ -286,9 +317,7 @@ ConnectionDescriptor::ConnectionDescriptor (int sd, EventMachine_t *em):
 	#ifdef HAVE_KQUEUE
 	bGotExtraKqueueEvent(false),
 	#endif
-	bIsServer (false),
-	LastIo (gCurrentLoopTime),
-	InactivityTimeout (0)
+	bIsServer (false)
 {
 	// 22Jan09: Moved ArmKqueueWriter into SetConnectPending() to fix assertion failure in _WriteOutboundData()
 	//  5May09: Moved EPOLLOUT into SetConnectPending() so it doesn't happen for attached read pipes
@@ -312,57 +341,6 @@ ConnectionDescriptor::~ConnectionDescriptor()
 }
 
 
-/**************************************************
-STATIC: ConnectionDescriptor::SendDataToConnection
-**************************************************/
-
-int ConnectionDescriptor::SendDataToConnection (const unsigned long binding, const char *data, int data_length)
-{
-	// TODO: This is something of a hack, or at least it's a static method of the wrong class.
-	// TODO: Poor polymorphism here. We should be calling one virtual method
-	// instead of hacking out the runtime information of the target object.
-	ConnectionDescriptor *cd = dynamic_cast <ConnectionDescriptor*> (Bindable_t::GetObject (binding));
-	if (cd)
-		return cd->SendOutboundData (data, data_length);
-	DatagramDescriptor *ds = dynamic_cast <DatagramDescriptor*> (Bindable_t::GetObject (binding));
-	if (ds)
-		return ds->SendOutboundData (data, data_length);
-	#ifdef OS_UNIX
-	PipeDescriptor *ps = dynamic_cast <PipeDescriptor*> (Bindable_t::GetObject (binding));
-	if (ps)
-		return ps->SendOutboundData (data, data_length);
-	#endif
-	return -1;
-}
-
-
-/*********************************************
-STATIC: ConnectionDescriptor::CloseConnection
-*********************************************/
-
-void ConnectionDescriptor::CloseConnection (const unsigned long binding, bool after_writing)
-{
-	// TODO: This is something of a hack, or at least it's a static method of the wrong class.
-	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
-	if (ed)
-		ed->ScheduleClose (after_writing);
-}
-
-/***********************************************
-STATIC: ConnectionDescriptor::ReportErrorStatus
-***********************************************/
-
-int ConnectionDescriptor::ReportErrorStatus (const unsigned long binding)
-{
-	// TODO: This is something of a hack, or at least it's a static method of the wrong class.
-	// TODO: Poor polymorphism here. We should be calling one virtual method
-	// instead of hacking out the runtime information of the target object.
-	ConnectionDescriptor *cd = dynamic_cast <ConnectionDescriptor*> (Bindable_t::GetObject (binding));
-	if (cd)
-		return cd->_ReportErrorStatus();
-	return -1;
-}
-
 /***********************************
 ConnectionDescriptor::_UpdateEvents
 ************************************/
@@ -500,7 +478,7 @@ int ConnectionDescriptor::SendOutboundData (const char *data, int length)
 	if (bWatchOnly)
 		throw std::runtime_error ("cannot send data on a 'watch only' connection");
 
-	if (ProxiedFrom && MaxOutboundBufSize && GetOutboundDataSize() + length > MaxOutboundBufSize)
+	if (ProxiedFrom && MaxOutboundBufSize && (unsigned int)(GetOutboundDataSize() + length) > MaxOutboundBufSize)
 		ProxiedFrom->Pause();
 
 	#ifdef WITH_SSL
@@ -688,7 +666,7 @@ void ConnectionDescriptor::Read()
 		return;
 	}
 
-	LastIo = gCurrentLoopTime;
+	LastActivity = MyEventMachine->GetCurrentTime();
 
 	int total_bytes_read = 0;
 	char readbuffer [16 * 1024 + 1];
@@ -894,7 +872,7 @@ void ConnectionDescriptor::_WriteOutboundData()
 		return;
 	}
 
-	LastIo = gCurrentLoopTime;
+	LastActivity = MyEventMachine->GetCurrentTime();
 	size_t nbytes = 0;
 
 	#ifdef HAVE_WRITEV
@@ -961,7 +939,7 @@ void ConnectionDescriptor::_WriteOutboundData()
 	assert (bytes_written >= 0);
 	OutboundDataSize -= bytes_written;
 
-	if (ProxiedFrom && MaxOutboundBufSize && GetOutboundDataSize() < MaxOutboundBufSize && ProxiedFrom->IsPaused())
+	if (ProxiedFrom && MaxOutboundBufSize && (unsigned int)GetOutboundDataSize() < MaxOutboundBufSize && ProxiedFrom->IsPaused())
 		ProxiedFrom->Resume();
 
 	#ifdef HAVE_WRITEV
@@ -1013,11 +991,11 @@ void ConnectionDescriptor::_WriteOutboundData()
 }
 
 
-/****************************************
-ConnectionDescriptor::_ReportErrorStatus
-****************************************/
+/***************************************
+ConnectionDescriptor::ReportErrorStatus
+***************************************/
 
-int ConnectionDescriptor::_ReportErrorStatus()
+int ConnectionDescriptor::ReportErrorStatus()
 {
 	int error;
 	socklen_t len;
@@ -1198,12 +1176,12 @@ void ConnectionDescriptor::Heartbeat()
 	 */
 
 	if (bConnectPending) {
-		if ((gCurrentLoopTime - CreatedAt) >= PendingConnectTimeout)
+		if ((MyEventMachine->GetCurrentTime() - CreatedAt) >= PendingConnectTimeout)
 			ScheduleClose (false);
 			//bCloseNow = true;
 	}
 	else {
-		if (InactivityTimeout && ((gCurrentLoopTime - LastIo) >= InactivityTimeout))
+		if (InactivityTimeout && ((MyEventMachine->GetCurrentTime() - LastActivity) >= InactivityTimeout))
 			ScheduleClose (false);
 			//bCloseNow = true;
 	}
@@ -1413,9 +1391,7 @@ DatagramDescriptor::DatagramDescriptor
 
 DatagramDescriptor::DatagramDescriptor (int sd, EventMachine_t *parent_em):
 	EventableDescriptor (sd, parent_em),
-	OutboundDataSize (0),
-	LastIo (gCurrentLoopTime),
-	InactivityTimeout (0)
+	OutboundDataSize (0)
 {
 	memset (&ReturnAddress, 0, sizeof(ReturnAddress));
 
@@ -1469,7 +1445,7 @@ void DatagramDescriptor::Heartbeat()
 {
 	// Close it if its inactivity timer has expired.
 
-	if (InactivityTimeout && ((gCurrentLoopTime - LastIo) >= InactivityTimeout))
+	if (InactivityTimeout && ((MyEventMachine->GetCurrentTime() - LastActivity) >= InactivityTimeout))
 		ScheduleClose (false);
 		//bCloseNow = true;
 }
@@ -1483,7 +1459,7 @@ void DatagramDescriptor::Read()
 {
 	int sd = GetSocket();
 	assert (sd != INVALID_SOCKET);
-	LastIo = gCurrentLoopTime;
+	LastActivity = MyEventMachine->GetCurrentTime();
 
 	// This is an extremely large read buffer.
 	// In many cases you wouldn't expect to get any more than 4K.
@@ -1560,7 +1536,7 @@ void DatagramDescriptor::Write()
 
 	int sd = GetSocket();
 	assert (sd != INVALID_SOCKET);
-	LastIo = gCurrentLoopTime;
+	LastActivity = MyEventMachine->GetCurrentTime();
 
 	assert (OutboundPages.size() > 0);
 
@@ -1714,20 +1690,6 @@ int DatagramDescriptor::SendOutboundDatagram (const char *data, int length, cons
 }
 
 
-/****************************************
-STATIC: DatagramDescriptor::SendDatagram
-****************************************/
-
-int DatagramDescriptor::SendDatagram (const unsigned long binding, const char *data, int length, const char *address, int port)
-{
-	DatagramDescriptor *dd = dynamic_cast <DatagramDescriptor*> (Bindable_t::GetObject (binding));
-	if (dd)
-		return dd->SendOutboundDatagram (data, length, address, port);
-	else
-		return -1;
-}
-
-
 /*********************************
 ConnectionDescriptor::GetPeername
 *********************************/
@@ -1765,9 +1727,9 @@ bool ConnectionDescriptor::GetSockname (struct sockaddr *s)
 ConnectionDescriptor::GetCommInactivityTimeout
 **********************************************/
 
-float ConnectionDescriptor::GetCommInactivityTimeout()
+uint64_t ConnectionDescriptor::GetCommInactivityTimeout()
 {
-	return ((float)InactivityTimeout / 1000000);
+	return InactivityTimeout / 1000;
 }
 
 
@@ -1775,10 +1737,11 @@ float ConnectionDescriptor::GetCommInactivityTimeout()
 ConnectionDescriptor::SetCommInactivityTimeout
 **********************************************/
 
-int ConnectionDescriptor::SetCommInactivityTimeout (float value)
+int ConnectionDescriptor::SetCommInactivityTimeout (uint64_t value)
 {
 	if (value > 0) {
-		InactivityTimeout = (Int64)(value * 1000000);
+		InactivityTimeout = value * 1000;
+		MyEventMachine->QueueHeartbeat(this);
 		return 1;
 	}
 	return 0;
@@ -1821,19 +1784,20 @@ bool DatagramDescriptor::GetSockname (struct sockaddr *s)
 DatagramDescriptor::GetCommInactivityTimeout
 ********************************************/
 
-float DatagramDescriptor::GetCommInactivityTimeout()
+uint64_t DatagramDescriptor::GetCommInactivityTimeout()
 {
-	return ((float)InactivityTimeout / 1000000);
+	return InactivityTimeout / 1000;
 }
 
 /********************************************
 DatagramDescriptor::SetCommInactivityTimeout
 ********************************************/
 
-int DatagramDescriptor::SetCommInactivityTimeout (float value)
+int DatagramDescriptor::SetCommInactivityTimeout (uint64_t value)
 {
 	if (value > 0) {
-		InactivityTimeout = (Int64)(value * 1000000);
+		InactivityTimeout = value * 1000;
+		MyEventMachine->QueueHeartbeat(this);
 		return 1;
 	}
 	return 0;