eventmachine 0.12.10-x86-mswin32-60 → 1.0.0.beta.2-x86-mswin32-60

data/eventmachine.gemspec

@@ -1,13 +1,24 @@
 # -*- encoding: utf-8 -*-
+require File.expand_path('../lib/em/version', __FILE__)
 
 Gem::Specification.new do |s|
-  s.name = %q{eventmachine}
-  s.version = "0.12.10"
+  s.date = "2010-11-13"
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Francis Cianfrocca"]
-  s.date = %q{2009-10-24}
-  s.description = %q{EventMachine implements a fast, single-threaded engine for arbitrary network
+  s.name = 'eventmachine'
+  s.version = EventMachine::VERSION
+  s.homepage = 'http://rubyeventmachine.com'
+  s.rubyforge_project = 'eventmachine'
+
+  s.authors = ["Francis Cianfrocca", "Aman Gupta"]
+  s.email   = ["garbagecat10@gmail.com", "aman@tmm1.net"]
+
+  s.files = `git ls-files`.split("\n")
+  s.extensions = ["ext/extconf.rb", "ext/fastfilereader/extconf.rb"]
+
+  s.add_development_dependency 'rake-compiler'
+
+  s.summary = 'Ruby/EventMachine library'
+  s.description = "EventMachine implements a fast, single-threaded engine for arbitrary network
 communications. It's extremely easy to use in Ruby. EventMachine wraps all
 interactions with IP sockets, allowing programs to concentrate on the
 implementation of network protocols. It can be used to create both network
@@ -16,25 +27,7 @@ to specify the IP address and port, and provide a Module that implements the
 communications protocol. Implementations of several standard network protocols
 are provided with the package, primarily to serve as examples. The real goal
 of EventMachine is to enable programs to easily interface with other programs
-using TCP/IP, especially if custom protocols are required.
-}
-  s.email = %q{garbagecat10@gmail.com}
-  s.extensions = ["ext/extconf.rb", "ext/fastfilereader/extconf.rb"]
-  s.files = [".gitignore", "README", "Rakefile", "docs/COPYING", "docs/ChangeLog", "docs/DEFERRABLES", "docs/EPOLL", "docs/GNU", "docs/INSTALL", "docs/KEYBOARD", "docs/LEGAL", "docs/LIGHTWEIGHT_CONCURRENCY", "docs/PURE_RUBY", "docs/RELEASE_NOTES", "docs/SMTP", "docs/SPAWNED_PROCESSES", "docs/TODO", "eventmachine.gemspec", "examples/ex_channel.rb", "examples/ex_queue.rb", "examples/helper.rb", "ext/binder.cpp", "ext/binder.h", "ext/cmain.cpp", "ext/cplusplus.cpp", "ext/ed.cpp", "ext/ed.h", "ext/em.cpp", "ext/em.h", "ext/emwin.cpp", "ext/emwin.h", "ext/epoll.cpp", "ext/epoll.h", "ext/eventmachine.h", "ext/eventmachine_cpp.h", "ext/extconf.rb", "ext/fastfilereader/extconf.rb", "ext/fastfilereader/mapper.cpp", "ext/fastfilereader/mapper.h", "ext/fastfilereader/rubymain.cpp", "ext/files.cpp", "ext/files.h", "ext/kb.cpp", "ext/page.cpp", "ext/page.h", "ext/pipe.cpp", "ext/project.h", "ext/rubymain.cpp", "ext/sigs.cpp", "ext/sigs.h", "ext/ssl.cpp", "ext/ssl.h", "java/.classpath", "java/.project", "java/src/com/rubyeventmachine/EmReactor.java", "java/src/com/rubyeventmachine/EmReactorException.java", "java/src/com/rubyeventmachine/EventableChannel.java", "java/src/com/rubyeventmachine/EventableDatagramChannel.java", "java/src/com/rubyeventmachine/EventableSocketChannel.java", "java/src/com/rubyeventmachine/application/Application.java", "java/src/com/rubyeventmachine/application/Connection.java", "java/src/com/rubyeventmachine/application/ConnectionFactory.java", "java/src/com/rubyeventmachine/application/DefaultConnectionFactory.java", "java/src/com/rubyeventmachine/application/PeriodicTimer.java", "java/src/com/rubyeventmachine/application/Timer.java", "java/src/com/rubyeventmachine/tests/ApplicationTest.java", "java/src/com/rubyeventmachine/tests/ConnectTest.java", "java/src/com/rubyeventmachine/tests/EMTest.java", "java/src/com/rubyeventmachine/tests/TestDatagrams.java", "java/src/com/rubyeventmachine/tests/TestServers.java", "java/src/com/rubyeventmachine/tests/TestTimers.java", "lib/em/buftok.rb", "lib/em/callback.rb", "lib/em/channel.rb", "lib/em/connection.rb", "lib/em/deferrable.rb", "lib/em/file_watch.rb", "lib/em/future.rb", "lib/em/messages.rb", "lib/em/process_watch.rb", "lib/em/processes.rb", "lib/em/protocols.rb", "lib/em/protocols/header_and_content.rb", "lib/em/protocols/httpclient.rb", "lib/em/protocols/httpclient2.rb", "lib/em/protocols/line_and_text.rb", "lib/em/protocols/linetext2.rb", "lib/em/protocols/memcache.rb", "lib/em/protocols/object_protocol.rb", "lib/em/protocols/postgres3.rb", "lib/em/protocols/saslauth.rb", "lib/em/protocols/smtpclient.rb", "lib/em/protocols/smtpserver.rb", "lib/em/protocols/socks4.rb", "lib/em/protocols/stomp.rb", "lib/em/protocols/tcptest.rb", "lib/em/queue.rb", "lib/em/spawnable.rb", "lib/em/streamer.rb", "lib/em/timers.rb", "lib/em/version.rb", "lib/eventmachine.rb", "lib/evma.rb", "lib/evma/callback.rb", "lib/evma/container.rb", "lib/evma/factory.rb", "lib/evma/protocol.rb", "lib/evma/reactor.rb", "lib/jeventmachine.rb", "lib/pr_eventmachine.rb", "setup.rb", "tasks/cpp.rake_example", "tests/client.crt", "tests/client.key", "tests/test_attach.rb", "tests/test_basic.rb", "tests/test_channel.rb", "tests/test_connection_count.rb", "tests/test_defer.rb", "tests/test_epoll.rb", "tests/test_error_handler.rb", "tests/test_errors.rb", "tests/test_exc.rb", "tests/test_file_watch.rb", "tests/test_futures.rb", "tests/test_get_sock_opt.rb", "tests/test_handler_check.rb", "tests/test_hc.rb", "tests/test_httpclient.rb", "tests/test_httpclient2.rb", "tests/test_inactivity_timeout.rb", "tests/test_kb.rb", "tests/test_ltp.rb", "tests/test_ltp2.rb", "tests/test_next_tick.rb", "tests/test_object_protocol.rb", "tests/test_pause.rb", "tests/test_pending_connect_timeout.rb", "tests/test_process_watch.rb", "tests/test_processes.rb", "tests/test_proxy_connection.rb", "tests/test_pure.rb", "tests/test_queue.rb", "tests/test_running.rb", "tests/test_sasl.rb", "tests/test_send_file.rb", "tests/test_servers.rb", "tests/test_smtpclient.rb", "tests/test_smtpserver.rb", "tests/test_spawn.rb", "tests/test_ssl_args.rb", "tests/test_ssl_methods.rb", "tests/test_ssl_verify.rb", "tests/test_timers.rb", "tests/test_ud.rb", "tests/testem.rb", "web/whatis"]
-  s.homepage = %q{http://rubyeventmachine.com}
-  s.rdoc_options = ["--title", "EventMachine", "--main", "README", "--line-numbers", "-x", "lib/em/version", "-x", "lib/emva", "-x", "lib/evma/", "-x", "lib/pr_eventmachine", "-x", "lib/jeventmachine"]
-  s.require_paths = ["lib"]
-  s.rubyforge_project = %q{eventmachine}
-  s.rubygems_version = %q{1.3.5}
-  s.summary = %q{Ruby/EventMachine library}
-
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
+using TCP/IP, especially if custom protocols are required."
 
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-    else
-    end
-  else
-  end
+  s.rdoc_options = ["--title", "EventMachine", "--main", "README", "-x", "lib/em/version", "-x", "lib/jeventmachine"]
 end

data/examples/ex_channel.rb

@@ -1,43 +1,43 @@
-require File.dirname(__FILE__) + '/helper'
-
-EM.run do
-
-  # Create a channel to push data to, this could be stocks...
-  RandChannel = EM::Channel.new
-
-  # The server simply subscribes client connections to the channel on connect,
-  # and unsubscribes them on disconnect.
-  class Server < EM::Connection
-    def self.start(host = '127.0.0.1', port = 8000)
-      EM.start_server(host, port, self)
-    end
-
-    def post_init
-      @sid = RandChannel.subscribe { |m| send_data "#{m.inspect}\n" }
-    end
-
-    def unbind
-      RandChannel.unsubscribe @sid
-    end
-  end
-  Server.start
-
-  # Two client connections, that just print what they receive.
-  2.times do
-    EM.connect('127.0.0.1', 8000) do |c|
-      c.extend EM::P::LineText2
-      def c.receive_line(line)
-        puts "Subscriber: #{signature} got #{line}"
-      end
-      EM.add_timer(2) { c.close_connection }
-    end
-  end
-
-  # This part of the example is more fake, but imagine sleep was in fact a 
-  # long running calculation to achieve the value.
-  40.times do
-    EM.defer lambda { v = sleep(rand * 2); RandChannel << [Time.now, v] }
-  end
-  
-  EM.add_timer(5) { EM.stop }
+require File.dirname(__FILE__) + '/helper'
+
+EM.run do
+
+  # Create a channel to push data to, this could be stocks...
+  RandChannel = EM::Channel.new
+
+  # The server simply subscribes client connections to the channel on connect,
+  # and unsubscribes them on disconnect.
+  class Server < EM::Connection
+    def self.start(host = '127.0.0.1', port = 8000)
+      EM.start_server(host, port, self)
+    end
+
+    def post_init
+      @sid = RandChannel.subscribe { |m| send_data "#{m.inspect}\n" }
+    end
+
+    def unbind
+      RandChannel.unsubscribe @sid
+    end
+  end
+  Server.start
+
+  # Two client connections, that just print what they receive.
+  2.times do
+    EM.connect('127.0.0.1', 8000) do |c|
+      c.extend EM::P::LineText2
+      def c.receive_line(line)
+        puts "Subscriber: #{signature} got #{line}"
+      end
+      EM.add_timer(2) { c.close_connection }
+    end
+  end
+
+  # This part of the example is more fake, but imagine sleep was in fact a 
+  # long running calculation to achieve the value.
+  40.times do
+    EM.defer lambda { v = sleep(rand * 2); RandChannel << [Time.now, v] }
+  end
+  
+  EM.add_timer(5) { EM.stop }
 end

data/examples/ex_queue.rb

@@ -1,2 +1,2 @@
-require File.dirname(__FILE__) + '/helper'
-
+require File.dirname(__FILE__) + '/helper'
+

data/examples/ex_tick_loop_array.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/helper'
+
+EM.run do
+  array = (1..100).to_a
+
+  tickloop = EM.tick_loop do
+    if array.empty?
+      :stop
+    else
+      puts array.shift
+    end
+  end
+
+  tickloop.on_stop { EM.stop }
+end

data/examples/ex_tick_loop_counter.rb

@@ -0,0 +1,32 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TickCounter
+  attr_reader :start_time, :count
+
+  def initialize
+    reset
+    @tick_loop = EM.tick_loop(method(:tick))
+  end
+
+  def reset
+    @count = 0
+    @start_time = EM.current_time
+  end
+
+  def tick
+    @count += 1
+  end
+
+  def rate
+    @count / (EM.current_time - @start_time)
+  end
+end
+
+period = 5
+EM.run do
+  counter = TickCounter.new
+  EM.add_periodic_timer(period) do
+    puts "Ticks per second: #{counter.rate} (mean of last #{period}s)"
+    counter.reset
+  end
+end

data/examples/helper.rb

@@ -1,2 +1,2 @@
-$:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+$:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
 require 'eventmachine'

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

@@ -25,6 +25,7 @@ See the file COPYING for complete licensing information.
 */
 #if defined(BUILD_FOR_RUBY) && defined(OS_WIN32)
 #undef stat
+#undef fstat
 #endif
 
 static EventMachine_t *EventMachine;
@@ -49,11 +50,8 @@ extern "C" void ensure_eventmachine (const char *caller = "unknown caller")
 evma_initialize_library
 ***********************/
 
-extern "C" void evma_initialize_library (void(*cb)(const unsigned long, int, const char*, const unsigned long))
+extern "C" void evma_initialize_library (EMCallback cb)
 {
-	// Probably a bad idea to mess with the signal mask of a process
-	// we're just being linked into.
-	//InstallSignalHandlers();
 	if (EventMachine)
 		#ifdef BUILD_FOR_RUBY
 			rb_raise(rb_eRuntimeError, "eventmachine already initialized: evma_initialize_library");
@@ -148,6 +146,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 +165,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 +340,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 +353,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 +367,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 +379,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;
 }
 
 /********************
@@ -539,17 +550,6 @@ extern "C" void evma_signal_loopbreak()
 
 
 
-/****************
-evma__write_file
-****************/
-
-extern "C" const unsigned long evma__write_file (const char *filename)
-{
-	ensure_eventmachine("evma__write_file");
-	return EventMachine->_OpenFileForWriting (filename);
-}
-
-
 /********************************
 evma_get_comm_inactivity_timeout
 ********************************/
@@ -559,7 +559,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 +574,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 +590,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 +606,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;
@@ -783,12 +783,12 @@ extern "C" int evma_send_file_data_to_connection (const unsigned long binding, c
 evma_start_proxy
 *****************/
 
-extern "C" void evma_start_proxy (const unsigned long from, const unsigned long to, const unsigned long bufsize)
+extern "C" void evma_start_proxy (const unsigned long from, const unsigned long to, const unsigned long bufsize, const unsigned long length)
 {
 	ensure_eventmachine("evma_start_proxy");
 	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (from));
 	if (ed)
-		ed->StartProxy(to, bufsize);
+		ed->StartProxy(to, bufsize, length);
 }
 
 
@@ -825,3 +825,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->GetCurrentLoopTime();
+}

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->GetCurrentLoopTime();
 
 	#ifdef HAVE_EPOLL
 	EpollEvent.events = 0;
 	EpollEvent.data.ptr = this;
 	#endif
+	LastActivity = MyEventMachine->GetCurrentLoopTime();
 }
 
 
@@ -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) {
@@ -118,7 +122,7 @@ EventableDescriptor::~EventableDescriptor()
 EventableDescriptor::SetEventCallback
 *************************************/
 
-void EventableDescriptor::SetEventCallback (void(*cb)(const unsigned long, int, const char*, const unsigned long))
+void EventableDescriptor::SetEventCallback (EMCallback cb)
 {
 	EventCallback = cb;
 }
@@ -133,7 +137,7 @@ void EventableDescriptor::Close()
 	// Close the socket right now. Intended for emergencies.
 	if (MySocket != INVALID_SOCKET) {
 		shutdown (MySocket, 1);
-		closesocket (MySocket);
+		close (MySocket);
 		MySocket = INVALID_SOCKET;
 	}
 }
@@ -187,12 +191,13 @@ bool EventableDescriptor::IsCloseScheduled()
 EventableDescriptor::StartProxy
 *******************************/
 
-void EventableDescriptor::StartProxy(const unsigned long to, const unsigned long bufsize)
+void EventableDescriptor::StartProxy(const unsigned long to, const unsigned long bufsize, const unsigned long length)
 {
 	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (to));
 	if (ed) {
 		StopProxy();
 		ProxyTarget = ed;
+		BytesToProxy = length;
 		ed->SetProxiedFrom(this, bufsize);
 		return;
 	}
@@ -219,6 +224,9 @@ EventableDescriptor::SetProxiedFrom
 
 void EventableDescriptor::SetProxiedFrom(EventableDescriptor *from, const unsigned long bufsize)
 {
+	if (from != NULL && ProxiedFrom != NULL)
+		throw std::runtime_error ("Tried to proxy to a busy target");
+
 	ProxiedFrom = from;
 	MaxOutboundBufSize = bufsize;
 }
@@ -232,10 +240,24 @@ void EventableDescriptor::_GenericInboundDispatch(const char *buf, int size)
 {
 	assert(EventCallback);
 
-	if (ProxyTarget)
-		ProxyTarget->SendOutboundData(buf, size);
-	else
+	if (ProxyTarget) {
+		if (BytesToProxy > 0) {
+			unsigned long proxied = min(BytesToProxy, (unsigned long) size);
+			ProxyTarget->SendOutboundData(buf, proxied);
+			BytesToProxy -= proxied;
+			if (BytesToProxy == 0) {
+				StopProxy();
+				(*EventCallback)(GetBinding(), EM_PROXY_COMPLETED, NULL, 0);
+				if (proxied < size) {
+					(*EventCallback)(GetBinding(), EM_CONNECTION_READ, buf + proxied, size - proxied);
+				}
+			}
+		} else {
+			ProxyTarget->SendOutboundData(buf, size);
+		}
+	} else {
 		(*EventCallback)(GetBinding(), EM_CONNECTION_READ, buf, size);
+	}
 }
 
 
@@ -243,9 +265,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 +275,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 +335,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 +359,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 +496,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
@@ -541,7 +537,11 @@ int ConnectionDescriptor::_SendRawOutboundData (const char *data, int length)
 	// (Well, not so bad, small pages are coalesced in ::Write)
 
 	if (IsCloseScheduled())
-	//if (bCloseNow || bCloseAfterWriting)
+		return 0;
+
+	// 25Mar10: Ignore 0 length packets as they are not meaningful in TCP (as opposed to UDP)
+	// and can cause the assert(nbytes>0) to fail when OutboundPages has a bunch of 0 length pages.
+	if (length == 0)
 		return 0;
 
 	if (!data && (length > 0))
@@ -688,7 +688,7 @@ void ConnectionDescriptor::Read()
 		return;
 	}
 
-	LastIo = gCurrentLoopTime;
+	LastActivity = MyEventMachine->GetCurrentLoopTime();
 
 	int total_bytes_read = 0;
 	char readbuffer [16 * 1024 + 1];
@@ -894,7 +894,7 @@ void ConnectionDescriptor::_WriteOutboundData()
 		return;
 	}
 
-	LastIo = gCurrentLoopTime;
+	LastActivity = MyEventMachine->GetCurrentLoopTime();
 	size_t nbytes = 0;
 
 	#ifdef HAVE_WRITEV
@@ -902,11 +902,19 @@ void ConnectionDescriptor::_WriteOutboundData()
 	// Max of 16 outbound pages at a time
 	if (iovcnt > 16) iovcnt = 16;
 
+	#ifdef CC_SUNWspro
+	struct iovec iov[16];
+	#else
 	struct iovec iov[ iovcnt ];
+	#endif
 
 	for(int i = 0; i < iovcnt; i++){
 		OutboundPage *op = &(OutboundPages[i]);
+		#ifdef CC_SUNWspro
+		iov[i].iov_base = (char *)(op->Buffer + op->Offset);
+		#else
 		iov[i].iov_base = (void *)(op->Buffer + op->Offset);
+		#endif
 		iov[i].iov_len	= op->Length - op->Offset;
 
 		nbytes += iov[i].iov_len;
@@ -953,7 +961,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
@@ -1005,11 +1013,11 @@ void ConnectionDescriptor::_WriteOutboundData()
 }
 
 
-/****************************************
-ConnectionDescriptor::_ReportErrorStatus
-****************************************/
+/***************************************
+ConnectionDescriptor::ReportErrorStatus
+***************************************/
 
-int ConnectionDescriptor::_ReportErrorStatus()
+int ConnectionDescriptor::ReportErrorStatus()
 {
 	int error;
 	socklen_t len;
@@ -1190,12 +1198,12 @@ void ConnectionDescriptor::Heartbeat()
 	 */
 
 	if (bConnectPending) {
-		if ((gCurrentLoopTime - CreatedAt) >= PendingConnectTimeout)
+		if ((MyEventMachine->GetCurrentLoopTime() - CreatedAt) >= PendingConnectTimeout)
 			ScheduleClose (false);
 			//bCloseNow = true;
 	}
 	else {
-		if (InactivityTimeout && ((gCurrentLoopTime - LastIo) >= InactivityTimeout))
+		if (InactivityTimeout && ((MyEventMachine->GetCurrentLoopTime() - LastActivity) >= InactivityTimeout))
 			ScheduleClose (false);
 			//bCloseNow = true;
 	}
@@ -1328,7 +1336,7 @@ void AcceptorDescriptor::Read()
 		//int val = fcntl (sd, F_GETFL, 0);
 		//if (fcntl (sd, F_SETFL, val | O_NONBLOCK) == -1) {
 			shutdown (sd, 1);
-			closesocket (sd);
+			close (sd);
 			continue;
 		}
 
@@ -1405,9 +1413,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));
 
@@ -1461,7 +1467,7 @@ void DatagramDescriptor::Heartbeat()
 {
 	// Close it if its inactivity timer has expired.
 
-	if (InactivityTimeout && ((gCurrentLoopTime - LastIo) >= InactivityTimeout))
+	if (InactivityTimeout && ((MyEventMachine->GetCurrentLoopTime() - LastActivity) >= InactivityTimeout))
 		ScheduleClose (false);
 		//bCloseNow = true;
 }
@@ -1475,7 +1481,7 @@ void DatagramDescriptor::Read()
 {
 	int sd = GetSocket();
 	assert (sd != INVALID_SOCKET);
-	LastIo = gCurrentLoopTime;
+	LastActivity = MyEventMachine->GetCurrentLoopTime();
 
 	// This is an extremely large read buffer.
 	// In many cases you wouldn't expect to get any more than 4K.
@@ -1552,7 +1558,7 @@ void DatagramDescriptor::Write()
 
 	int sd = GetSocket();
 	assert (sd != INVALID_SOCKET);
-	LastIo = gCurrentLoopTime;
+	LastActivity = MyEventMachine->GetCurrentLoopTime();
 
 	assert (OutboundPages.size() > 0);
 
@@ -1618,11 +1624,11 @@ DatagramDescriptor::SendOutboundData
 
 int DatagramDescriptor::SendOutboundData (const char *data, int length)
 {
-	// This is an exact clone of ConnectionDescriptor::SendOutboundData.
-	// That means it needs to move to a common ancestor.
+	// This is almost an exact clone of ConnectionDescriptor::_SendRawOutboundData.
+	// That means most of it could be factored to a common ancestor. Note that
+	// empty datagrams are meaningful, which isn't the case for TCP streams.
 
 	if (IsCloseScheduled())
-	//if (bCloseNow || bCloseAfterWriting)
 		return 0;
 
 	if (!data && (length > 0))
@@ -1706,20 +1712,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
 *********************************/
@@ -1757,9 +1749,9 @@ bool ConnectionDescriptor::GetSockname (struct sockaddr *s)
 ConnectionDescriptor::GetCommInactivityTimeout
 **********************************************/
 
-float ConnectionDescriptor::GetCommInactivityTimeout()
+uint64_t ConnectionDescriptor::GetCommInactivityTimeout()
 {
-	return ((float)InactivityTimeout / 1000000);
+	return InactivityTimeout / 1000;
 }
 
 
@@ -1767,13 +1759,11 @@ float ConnectionDescriptor::GetCommInactivityTimeout()
 ConnectionDescriptor::SetCommInactivityTimeout
 **********************************************/
 
-int ConnectionDescriptor::SetCommInactivityTimeout (float value)
+int ConnectionDescriptor::SetCommInactivityTimeout (uint64_t value)
 {
-	if (value > 0) {
-		InactivityTimeout = (Int64)(value * 1000000);
-		return 1;
-	}
-	return 0;
+	InactivityTimeout = value * 1000;
+	MyEventMachine->QueueHeartbeat(this);
+	return 1;
 }
 
 /*******************************
@@ -1813,19 +1803,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;