Merge lp:~eday/scalestack/style-updates into lp:~registry/scalestack/old-trunk

[Eric Day]

Minor style issues to make things a bit more consistent. I'll be going through the other modules as well making the same kinds of tweaks.

[lp:~eday/scalestack/style-updates]

60. By Eric Day on 2010-06-16

Reworked event interface to push more logic into the providers, updated coding style around those changes, and tweaked a few documentation settings.

=== modified file 'Makefile.am'
--- Makefile.am	2010-06-03 04:51:37 +0000
+++ Makefile.am	2010-06-16 19:32:28 +0000
@@ -112,9 +112,9 @@
 docs: all
 	@echo "/**" > docs/mainpage.h
 	@echo "@mainpage README" >> docs/mainpage.h
-	@echo "<pre>" >> docs/mainpage.h
-	@cat ${top_srcdir}/README >> docs/mainpage.h
-	@echo "</pre>" >> docs/mainpage.h
+	@echo "<pre>@htmlonly" >> docs/mainpage.h
+	@cat ${top_srcdir}/README | sed 's/\(http[^ ]*\)/<a href="\1">\1<\/a>/' >> docs/mainpage.h
+	@echo "@endhtmlonly</pre>" >> docs/mainpage.h
 	@echo "*/" >> docs/mainpage.h
 	${DOXYGEN} ${top_srcdir}/docs/doxyfile
 	@rm docs/mainpage.h

=== modified file 'README'
--- README	2010-06-03 04:51:37 +0000
+++ README	2010-06-16 19:32:28 +0000
@@ -104,38 +104,38 @@
 
 Exceptions to this guide include:
 
-* Comments should follow Doxygen style formatting. See existing code
+- Comments should follow Doxygen style formatting. See existing code
   for examples.
 
-* Opening curly braces should appear on their own line.
+- Opening curly braces should appear on their own line.
 
-* C++ exceptions are allowed if they derive from std::exception. Most
+- C++ exceptions are allowed if they derive from std::exception. Most
   exception throwing is hidden behind log_fatal messages, which throw
   scalestack::common::exception and contains custom messages. Use of
   this through module.log_fatal() in modules is preferred.
 
-* All namespaces, classes, methods, and data members must be all
+- All namespaces, classes, methods, and data members must be all
   lowercase and use '_' to separate words (like the C++ STL).
 
-* Private method names should start with an underscore.
+- Private method names should start with an underscore.
 
-* Data members should always be private and start with an underscore.
+- Data members should always be private and start with an underscore.
   The leading underscores help to easily differentiate the class
   members from local method variables. Some data members may be under
   the protected section so derived classes can also access them.
 
-* Header files should be ordered by system and then Scale Stack
+- Header files should be ordered by system and then Scale Stack
   headers, with a empty line in between. Each set should be ordered
   alphabetically as well. The "config.h" include must be the first
   include for every non-header file, and should NEVER appear in any
   header files.
 
-* You should only use 'using namespace ...;' in source files, never in
+- You should only use 'using namespace ...;' in source files, never in
   header files. In source files, only specify 'using namespace std;'
   and 'using namespace scalestack;'. Beyond that, please write out
   the full namespace for objects.
 
-* In general, do the most consistent thing given the existing code
+- In general, do the most consistent thing given the existing code
   base. If something is not immediately obvious, is ambiguous, or
   if you feel is wrong, please bring it up on the mailing list or in
   IRC so we can clarify it and improve this document. :)

=== modified file 'bin/scalestack.cc'
--- bin/scalestack.cc	2010-06-03 04:51:37 +0000
+++ bin/scalestack.cc	2010-06-16 19:32:28 +0000
@@ -18,6 +18,8 @@
 
 #include <scalestack/kernel/core.h>
 
+using namespace std;
+
 int main(int argc, const char* argv[])
 {
   scalestack::kernel::core core;
@@ -33,9 +35,9 @@
     core.set_signal_handlers();
     core.run();
   }
-  catch (std::exception& e)
+  catch (exception& e)
   {
-    std::cout << e.what() << std::endl;
+    cout << e.what() << endl;
     return 1;
   }
 

=== modified file 'scalestack/common/delete_pointer.h'
--- scalestack/common/delete_pointer.h	2010-06-03 04:51:37 +0000
+++ scalestack/common/delete_pointer.h	2010-06-16 19:32:28 +0000
@@ -10,7 +10,7 @@
 
 /**
  * @file
- * @brief Delete Pointer Function Object Declaration
+ * @brief Delete Pointer Function Object
  */
 
 #ifndef SCALESTACK_COMMON_DELETE_POINTER_H
@@ -29,6 +29,9 @@
 {
 public:
 
+  /**
+   * Delete the pointer passed in as an argument.
+   */
   template<typename T>
   void operator()(const T* pointer) const
   {

=== modified file 'scalestack/common/exception.h'
--- scalestack/common/exception.h	2010-06-03 04:51:37 +0000
+++ scalestack/common/exception.h	2010-06-16 19:32:28 +0000
@@ -26,7 +26,8 @@
 {
 
 /**
- * This class allows exceptions to be thrown with custom error mesages.
+ * This class allows exceptions to be thrown with custom error mesages
+ * without the possiblity of throwing any exceptions itself.
  */
 class SCALESTACK_API exception: public std::exception
 {

=== modified file 'scalestack/common/macros.h.in'
--- scalestack/common/macros.h.in	2010-06-03 04:51:37 +0000
+++ scalestack/common/macros.h.in	2010-06-16 19:32:28 +0000
@@ -70,6 +70,10 @@
  */
 #define SCALESTACK_MAX_MESSAGE_SIZE 1024
 
+/**
+ * Macro to use around strings that should be translated in preparation for
+ * using gettext.
+ */
 #define _(string) string
 
 #endif /* SCALESTACK_COMMON_MACROS_H */

=== modified file 'scalestack/common/notification.cc'
--- scalestack/common/notification.cc	2010-06-03 04:51:37 +0000
+++ scalestack/common/notification.cc	2010-06-16 19:32:28 +0000
@@ -66,7 +66,7 @@
 {
   char message[SCALESTACK_MAX_MESSAGE_SIZE];
   snprintf(message, SCALESTACK_MAX_MESSAGE_SIZE,
-           "%s: %s", prefix, strerror(errno));
+           "%s: %s:%d", prefix, strerror(errno), errno);
   throw exception("notification", message);
 }
 

=== modified file 'scalestack/common/notification.h'
--- scalestack/common/notification.h	2010-06-03 04:51:37 +0000
+++ scalestack/common/notification.h	2010-06-16 19:32:28 +0000
@@ -24,7 +24,8 @@
 {
 
 /**
- * This class provides a way for different threads to notify each other.
+ * This class provides a way for different threads to notify each other. This
+ * uses a pipe rather than conditional thread mechanisms to be more portable.
  */
 class SCALESTACK_API notification
 {

=== modified file 'scalestack/common/test.h'
--- scalestack/common/test.h	2010-06-03 04:51:37 +0000
+++ scalestack/common/test.h	2010-06-16 19:32:28 +0000
@@ -28,8 +28,15 @@
 using namespace std;
 using namespace scalestack;
 
+/**
+ * Default event service to use.
+ */
 #define TEST_EVENT_SERVICE "event::libevent"
 
+/**
+ * Begin a test suite block, there should only be one of these per source
+ * file.
+ */
 #define TEST_SUITE_BEGIN \
 int main(int _test_argc, char* _test_argv[]) \
 { \
@@ -39,33 +46,51 @@
   if (TEST_LOG_THRESHOLD > 0) \
     cout << endl << __FILE__ << endl;
 
+/**
+ * Finish the test suite block.
+ */
 #define TEST_SUITE_END \
   return 0; \
 }
 
+/**
+ * Begin a test block without defining a kernel core object.
+ */
 #define TEST_BEGIN_NO_CORE(name) \
 if (TEST_LOG_THRESHOLD > 0) \
   cout << "---------- TESTING " << #name << endl; \
 {
 
+/**
+ * Begin a test block with a default kernel core object named 'core'.
+ */
 #define TEST_BEGIN(name) \
   TEST_BEGIN_NO_CORE(name) \
   kernel::core core; \
-  core.set_log_threshold(TEST_LOG_THRESHOLD); \
+  core.set_threshold(TEST_LOG_THRESHOLD); \
   core.add_module_option_value("path", "", "scalestack/.libs");
 
-
+/**
+ * End a test block.
+ */
 #define TEST_END \
 } \
 if (TEST_LOG_THRESHOLD > 0) \
   cout << "---------- PASSED" << endl << endl;
 
+/**
+ * Begin an exception test block. This tests to make sure an exception
+ * is thrown.
+ */
 #define TEST_EXCEPTION_BEGIN \
 { \
   bool _test_exception = false; \
   try \
   {
 
+/**
+ * End an exception test block.
+ */
 #define TEST_EXCEPTION_END \
   } \
   catch (exception&) \
@@ -75,6 +100,9 @@
   assert(_test_exception); \
 }
 
+/**
+ * Test a single line of code to make sure it throws an exception.
+ */
 #define TEST_EXCEPTION(code) \
 do \
   TEST_EXCEPTION_BEGIN \

=== modified file 'scalestack/event/handler.h'
--- scalestack/event/handler.h	2010-06-03 04:51:37 +0000
+++ scalestack/event/handler.h	2010-06-16 19:32:28 +0000
@@ -19,7 +19,7 @@
 #include <ctime>
 
 #include <scalestack/common/macros.h>
-#include <scalestack/event/service.h>
+#include <scalestack/event/handler_service.h>
 
 namespace scalestack
 {
@@ -34,18 +34,16 @@
  */
 class SCALESTACK_API handler
 {
-  friend class handler_provider;
-
 public:
 
-  handler(service& creator);
+  handler(handler_service& handler_service);
 
   virtual ~handler();
 
   /**
-   * Get the service this handler belongs to.
+   * Get the handler service this handler belongs to.
    */
-  service& get_service(void);
+  handler_service& get_handler_service(void);
 
   /**
    * This method is run after the event service has added it.
@@ -116,7 +114,7 @@
 
 protected:
 
-  service& _service;
+  handler_service& _handler_service;
   kernel::module& _module;
 
 private:
@@ -134,6 +132,8 @@
   handler& operator=(const handler&);
 
   handler_provider* _handler_provider;
+
+  friend class handler_provider;
 };
 
 /**
@@ -156,13 +156,13 @@
 
   /**
    * Set the handler for this handler_provider. This is used while
-   * initializing the event handler in the service class. This is required
-   * in order to reuse both handler and handler_provider instances, which
-   * will be implemented by unrelated classes.
+   * initializing the event handler in the handler service class. This is
+   * required in order to reuse both handler and handler_provider instances,
+   * which will be implemented by unrelated classes.
    *
-   * @param[in] bound_handler Handler to bind to this provider.
+   * @param[in] handler Handler to bind to this provider.
    */
-  void set_handler(handler* bound_handler);
+  void set_handler(handler* handler);
 
   /**
    * See handler::start().
@@ -245,9 +245,9 @@
  * Public handler methods.
  */
 
-inline handler::handler(service& creator):
-  _service(creator),
-  _module(creator.get_module()),
+inline handler::handler(handler_service& handler_service):
+  _handler_service(handler_service),
+  _module(handler_service.get_module()),
   _handler_provider(NULL)
 {
 }
@@ -256,9 +256,9 @@
 {
 }
 
-inline service& handler::get_service(void)
+inline handler_service& handler::get_handler_service(void)
 {
-  return _service;
+  return _handler_service;
 }
 
 inline void handler::start(void)
@@ -334,9 +334,9 @@
   return _handler;
 }
 
-inline void handler_provider::set_handler(handler* bound_handler)
+inline void handler_provider::set_handler(handler* handler)
 {
-  _handler = bound_handler;
+  _handler = handler;
   _handler->_handler_provider = this;
 }
 

=== renamed file 'scalestack/event/service.h' => 'scalestack/event/handler_service.h'
--- scalestack/event/service.h	2010-06-03 20:51:05 +0000
+++ scalestack/event/handler_service.h	2010-06-16 19:32:28 +0000
@@ -10,17 +10,16 @@
 
 /**
  * @file
- * @brief Event Service Declarations
+ * @brief Event Handler Service and Handler Service Provider Declarations
  */
 
-#ifndef SCALESTACK_EVENT_SERVICE_H
-#define SCALESTACK_EVENT_SERVICE_H
-
-#include <pthread.h>
-#include <set>
+#ifndef SCALESTACK_EVENT_HANDLER_SERVICE_H
+#define SCALESTACK_EVENT_HANDLER_SERVICE_H
 
 #include <scalestack/common/macros.h>
-#include <scalestack/common/notification.h>
+#include <scalestack/event/service.h>
+#include <scalestack/kernel/core.h>
+#include <scalestack/kernel/module.h>
 #include <scalestack/kernel/service.h>
 
 namespace scalestack
@@ -29,46 +28,44 @@
 {
 
 class handler;
-class service_provider;
+class handler_service_provider;
 
 /**
  * This is a base class that other classes using handler classes must
  * implement. This provides a way to add and remove event handlers from the
  * event service provider.
  */
-class SCALESTACK_API service: public kernel::service
+class SCALESTACK_API handler_service: public kernel::service
 {
-  friend class service_provider;
-
 public:
 
   /**
-   * Constructor for event service provider.
+   * Constructor for event handler service.
    *
-   * @param[in] creator Module that the service is associated with.
+   * @param[in] module Module that the handler service is associated with.
    */
-  service(kernel::module& creator);
+  handler_service(kernel::module& module);
 
-  virtual ~service();
+  virtual ~handler_service();
 
   /**
-   * Add an event handler to one of the event service threads.
+   * Add an event handler to the handler service.
    *
-   * @param[in] new_handler Event handler to add.
+   * @param[in] handler Event handler to add.
    */
-  void add_handler(handler* new_handler);
+  void add_handler(handler* handler);
 
   /**
    * Remove an event handler. This is called by the event service when the
    * handler is no longer in use.
    *
-   * @param[in] old_handler Event handler to remove.
+   * @param[in] handler Event handler to remove.
    */
-  virtual void remove_handler(handler* old_handler) = 0;
+  virtual void remove_handler(handler* handler) = 0;
 
   /**
-   * Shutdown the service by removing all associated handlers. This can
-   * block and should most likely only be used during shutdown in derived
+   * Shutdown the handler service by removing all associated handlers. This
+   * can block and should most likely only be used during shutdown in derived
    * class destructors.
    */
   void shutdown(void);
@@ -79,30 +76,107 @@
    * Don't allow copying of objects.
    */
   SCALESTACK_LOCAL
-  service(const service&);
-
-  /**
-   * Don't allow assignment of objects.
-   */
-  SCALESTACK_LOCAL
-  service& operator=(const service&);
-
-  /**
-   * Remove a handler from the service and call remove_handler().
-   *
-   * @param[in] old_handler Event handler to remove.
-   */
-  void _remove_handler(handler* old_handler);
-
-  bool _shutdown;
-  size_t _handler_count;
-  service_provider& _service_provider;
-  pthread_mutex_t _handler_mutex;
-  common::notification _shutdown_notification;
-  std::set<handler*> _handlers;
-};
+  handler_service(const handler_service&);
+
+  /**
+   * Don't allow assignment of objects.
+   */
+  SCALESTACK_LOCAL
+  handler_service& operator=(const handler_service&);
+
+  handler_service_provider& _handler_service_provider;
+};
+
+/**
+ * This is a base class that event service provider modules must
+ * implement. This is used to provide functionality for handler services.
+ */
+class SCALESTACK_API handler_service_provider: public kernel::service
+{
+public:
+
+  handler_service_provider(kernel::module& module,
+                           handler_service& handler_service);
+
+  virtual ~handler_service_provider();
+
+  /**
+   * See handler_service::add_handler().
+   */
+  virtual void add_handler(handler* handler) = 0;
+
+  /**
+   * See handler_service::remove_handler().
+   */
+  virtual void remove_handler(handler* handler);
+
+  /**
+   * See handler_service::add_handler().
+   */
+  virtual void shutdown(void) = 0;
+
+private:
+
+  /**
+   * Don't allow copying of objects.
+   */
+  SCALESTACK_LOCAL
+  handler_service_provider(const handler_service_provider&);
+
+  /**
+   * Don't allow assignment of objects.
+   */
+  SCALESTACK_LOCAL
+  handler_service_provider& operator=(const handler_service_provider&);
+
+  handler_service& _handler_service;
+};
+
+/*
+ * Public handler_service methods.
+ */
+
+inline handler_service::handler_service(kernel::module& module):
+  kernel::service(module),
+  _handler_service_provider(static_cast<event::service&>(module.get_core().get_service("event"))._add_handler_service(*this))
+{
+}
+
+inline handler_service::~handler_service()
+{
+  static_cast<event::service&>(_module.get_core().get_service("event"))._remove_handler_service(_handler_service_provider);
+}
+
+inline void handler_service::add_handler(handler* handler)
+{
+  _handler_service_provider.add_handler(handler);
+}
+
+inline void handler_service::shutdown(void)
+{
+  _handler_service_provider.shutdown();
+}
+
+/*
+ * Public handler_service_provider methods.
+ */
+
+inline handler_service_provider::handler_service_provider(kernel::module& module, handler_service& handler_service):
+  kernel::service(module),
+  _handler_service(handler_service)
+{
+}
+
+inline handler_service_provider::~handler_service_provider()
+{
+}
+
+inline void handler_service_provider::remove_handler(handler* handler)
+{
+  _handler_service.remove_handler(handler);
+}
 
 } /* namespace event */
 } /* namespace scalestack */
 
-#endif /* SCALESTACK_EVENT_SERVICE_H */
+#endif /* SCALESTACK_EVENT_HANDLER_SERVICE_H */

=== modified file 'scalestack/event/libevent/handler_provider.cc'
--- scalestack/event/libevent/handler_provider.cc	2010-06-03 04:51:37 +0000
+++ scalestack/event/libevent/handler_provider.cc	2010-06-16 19:32:28 +0000
@@ -36,18 +36,19 @@
  * Public functions.
  */
 
-extern "C" void handler_provider_callback(int file_descriptor, short events,
-                                        void* context)
+extern "C" void handler_provider_callback(int file_descriptor,
+                                          short events,
+                                          void* context)
 {
-  handler_provider* new_handler_provider = static_cast<handler_provider*>(context);
-  new_handler_provider->_callback(file_descriptor, events);
+  handler_provider* handler_provider = static_cast<libevent::handler_provider*>(context);
+  handler_provider->_callback(file_descriptor, events);
 }
 
 /*
  * Public methods.
  */
 
-handler_provider::handler_provider(kernel::module& module):
+handler_provider::handler_provider(kernel::module& module, handler_service_provider& handler_service_provider):
   _in_check_queue(false),
   _need_start(false),
   _need_update(false),
@@ -65,12 +66,18 @@
   _expire_time(0),
   _set_expire_time(0),
   _module(module),
+  _handler_service_provider(handler_service_provider),
   _thread(NULL),
   _event(),
   _timer()
 {
 }
 
+handler_service_provider& handler_provider::get_handler_service_provider(void)
+{
+  return _handler_service_provider;
+}
+
 handler_provider::~handler_provider()
 {
   set_thread(NULL);

=== modified file 'scalestack/event/libevent/handler_provider.h'
--- scalestack/event/libevent/handler_provider.h	2010-06-03 04:51:37 +0000
+++ scalestack/event/libevent/handler_provider.h	2010-06-16 19:32:28 +0000
@@ -40,29 +40,34 @@
 /**
  * Function passed to libevent to invoke handler_provider::_callback().
  */
-extern "C" void handler_provider_callback(int file_descriptor, short events,
+extern "C" void handler_provider_callback(int file_descriptor,
+                                          short events,
                                           void* context);
 
 /**
- * This is the Handler_provider implementation using libevent.
+ * This is the event handler provider implementation for libevent.
  */
 class SCALESTACK_API handler_provider: public event::handler_provider
 {
-  friend void handler_provider_callback(int file_descriptor, short events,
-                                        void* context);
-
 public:
 
   /**
    * Constructor for handler provider.
    *
    * @param[in] module Module that the handler is associated with.
+   * @param[in] handler_service_provider Owner of this handler provider.
    */
-  handler_provider(kernel::module& module);
+  handler_provider(kernel::module& module,
+                   handler_service_provider& handler_service_provider);
 
   ~handler_provider();
 
   /**
+   * Get the handler service provider this handler provider belongs to.
+   */
+  handler_service_provider& get_handler_service_provider(void);
+
+  /**
    * Set the thread this handler provider belongs to.
    *
    * @param[in] thread Thread to set.
@@ -167,9 +172,14 @@
   time_t _expire_time;
   time_t _set_expire_time;
   kernel::module& _module;
+  handler_service_provider& _handler_service_provider;
   thread* _thread;
   struct event _event;
   struct timeval _timer;
+
+  friend void handler_provider_callback(int file_descriptor,
+                                        short events,
+                                        void* context);
 };
 
 } /* namespace libevent */

=== renamed file 'scalestack/event/service.cc' => 'scalestack/event/libevent/handler_service_provider.cc'
--- scalestack/event/service.cc	2010-06-03 04:51:37 +0000
+++ scalestack/event/libevent/handler_service_provider.cc	2010-06-16 19:32:28 +0000
@@ -10,7 +10,7 @@
 
 /**
  * @file
- * @brief Event Service Definitions
+ * @brief libevent Event Handler Service Provider Definitions
  */
 
 #include "config.h"
@@ -21,8 +21,8 @@
 #include <functional>
 
 #include <scalestack/event/handler.h>
-#include <scalestack/event/service.h>
-#include <scalestack/event/service_provider.h>
+#include <scalestack/event/libevent/handler_service_provider.h>
+#include <scalestack/event/libevent/service.h>
 #include <scalestack/kernel/core.h>
 #include <scalestack/kernel/module.h>
 
@@ -32,94 +32,160 @@
 {
 namespace event
 {
+namespace libevent
+{
 
 /*
  * Public methods.
  */
 
-service::service(kernel::module& creator):
-  kernel::service(creator),
+handler_service_provider::handler_service_provider(kernel::module& module, event::handler_service& handler_service):
+  event::handler_service_provider(module, handler_service),
   _shutdown(false),
   _handler_count(),
-  _service_provider(static_cast<service_provider&>(creator.get_core().get_service("event"))),
+  _service(static_cast<libevent::service&>(module.get_core().get_service("event"))),
   _handler_mutex(),
   _shutdown_notification(),
   _handlers()
 {
   int return_code = pthread_mutex_init(&_handler_mutex, NULL);
   if (return_code != 0)
-    _module.log_fatal(_("Failed pthread_mutex_init: %s"), strerror(return_code));
+  {
+    _module.log_fatal(_("Failed pthread_mutex_init: %s:%d"),
+                      strerror(return_code), return_code);
+  }
 }
 
-service::~service()
+handler_service_provider::~handler_service_provider()
 {
   int return_code = pthread_mutex_destroy(&_handler_mutex);
   if (return_code != 0)
-    _module.log_error(_("Failed pthread_mutex_destroy: %s"), strerror(return_code));
+  {
+    _module.log_error(_("Failed pthread_mutex_destroy: %s:%d"),
+                      strerror(return_code), return_code);
+  }
 }
 
-void service::add_handler(handler* new_handler)
+void handler_service_provider::add_handler(handler* handler)
 {
-  _service_provider.add_handler(new_handler);
+  _service.add_handler(handler, *this);
 
-  pthread_mutex_lock(&_handler_mutex);
+  int return_code = pthread_mutex_lock(&_handler_mutex);
+  if (return_code != 0)
+  {
+    _module.log_fatal(_("Failed pthread_mutex_lock: %s:%d"),
+                      strerror(return_code), return_code);
+  }
 
   try
   {
-    _handlers.insert(new_handler);
+    _handlers.insert(handler);
     ++_handler_count;
   }
   catch (exception&)
   {
-    pthread_mutex_unlock(&_handler_mutex);
+    return_code = pthread_mutex_unlock(&_handler_mutex);
+    if (return_code != 0)
+    {
+      _module.log_error(_("Failed pthread_mutex_unlock: %s:%d"),
+                        strerror(return_code), return_code);
+    }
+
     throw;
   }
 
-  pthread_mutex_unlock(&_handler_mutex);
-
-  if (_shutdown)
-    new_handler->remove();
-}
-
-void service::shutdown(void)
+  return_code = pthread_mutex_unlock(&_handler_mutex);
+  if (return_code != 0)
+  {
+    _module.log_fatal(_("Failed pthread_mutex_unlock: %s:%d"),
+                      strerror(return_code), return_code);
+  }
+
+  if (_shutdown)
+    handler->remove();
+}
+
+void handler_service_provider::remove_handler(handler* handler)
+{
+  int return_code = pthread_mutex_lock(&_handler_mutex);
+  if (return_code != 0)
+  {
+    _module.log_fatal(_("Failed pthread_mutex_lock: %s:%d"),
+                      strerror(return_code), return_code);
+  }
+
+  _handlers.erase(handler);
+
+  return_code = pthread_mutex_unlock(&_handler_mutex);
+  if (return_code != 0)
+  {
+    _module.log_fatal(_("Failed pthread_mutex_unlock: %s:%d"),
+                      strerror(return_code), return_code);
+  }
+
+  event::handler_service_provider::remove_handler(handler);
+
+  /* TODO Replace this lock/decrement with an atomic op at some point. */
+  return_code = pthread_mutex_lock(&_handler_mutex);
+  if (return_code != 0)
+  {
+    _module.log_fatal(_("Failed pthread_mutex_lock: %s:%d"),
+                      strerror(return_code), return_code);
+  }
+
+  --_handler_count;
+
+  if (_shutdown)
+    _shutdown_notification.send();
+
+  return_code = pthread_mutex_unlock(&_handler_mutex);
+  if (return_code != 0)
+  {
+    _module.log_fatal(_("Failed pthread_mutex_unlock: %s:%d"),
+                      strerror(return_code), return_code);
+  }
+}
+
+void handler_service_provider::shutdown(void)
 {
   _shutdown = true;
 
-  pthread_mutex_lock(&_handler_mutex);
+  int return_code = pthread_mutex_lock(&_handler_mutex);
+  if (return_code != 0)
+  {
+    _module.log_fatal(_("Failed pthread_mutex_lock: %s:%d"),
+                      strerror(return_code), return_code);
+  }
+
   for_each(_handlers.begin(), _handlers.end(), mem_fun(&handler::remove));
 
   while (_handler_count > 0)
   {
-    pthread_mutex_unlock(&_handler_mutex);
+    return_code = pthread_mutex_unlock(&_handler_mutex);
+    if (return_code != 0)
+    {
+      _module.log_fatal(_("Failed pthread_mutex_unlock: %s:%d"),
+                        strerror(return_code), return_code);
+    }
+
     _shutdown_notification.wait();
-    pthread_mutex_lock(&_handler_mutex);
-  }
-
-  pthread_mutex_unlock(&_handler_mutex);
-}
-
-/*
- * Private methods.
- */
-
-void service::_remove_handler(handler* old_handler)
-{
-  pthread_mutex_lock(&_handler_mutex);
-  _handlers.erase(old_handler);
-  pthread_mutex_unlock(&_handler_mutex);
-
-  remove_handler(old_handler);
-
-  /* TODO Replace this lock/decrement with an atomic op at some point. */
-  pthread_mutex_lock(&_handler_mutex);
-
-  --_handler_count;
-
-  if (_shutdown)
-    _shutdown_notification.send();
-
-  pthread_mutex_unlock(&_handler_mutex);
-}
-
+
+    return_code = pthread_mutex_lock(&_handler_mutex);
+    if (return_code != 0)
+    {
+      _module.log_fatal(_("Failed pthread_mutex_lock: %s:%d"),
+                        strerror(return_code), return_code);
+    }
+  }
+
+  return_code = pthread_mutex_unlock(&_handler_mutex);
+  if (return_code != 0)
+  {
+    _module.log_fatal(_("Failed pthread_mutex_unlock: %s:%d"),
+                      strerror(return_code), return_code);
+  }
+}
+
+} /* namespace libevent */
 } /* namespace event */
 } /* namespace scalestack */

=== renamed file 'scalestack/event/service_provider.h' => 'scalestack/event/libevent/handler_service_provider.h'
--- scalestack/event/service_provider.h	2010-06-03 04:51:37 +0000
+++ scalestack/event/libevent/handler_service_provider.h	2010-06-16 19:32:28 +0000
@@ -10,44 +10,53 @@
 
 /**
  * @file
- * @brief Event Service Provider Declarations
+ * @brief libevent Event Handler Service Provider Declarations
  */
 
-#ifndef SCALESTACK_EVENT_SERVICE_PROVIDER_H
-#define SCALESTACK_EVENT_SERVICE_PROVIDER_H
+#ifndef SCALESTACK_EVENT_LIBEVENT_HANDLER_SERVICE_PROVIDER_H
+#define SCALESTACK_EVENT_LIBEVENT_HANDLER_SERVICE_PROVIDER_H
+
+#include <pthread.h>
+#include <set>
 
 #include <scalestack/common/macros.h>
-#include <scalestack/event/handler.h>
-#include <scalestack/event/service.h>
-#include <scalestack/kernel/service.h>
+#include <scalestack/event/handler_service.h>
 
 namespace scalestack
 {
 namespace event
 {
+namespace libevent
+{
 
-class handler;
+class service;
 
 /**
- * This is a base class that event service provider modules must implement.
+ * This is the handler service provider implementation.
  */
-class SCALESTACK_API service_provider: public kernel::service
+class SCALESTACK_API handler_service_provider: public event::handler_service_provider
 {
 public:
 
-  service_provider(kernel::module& creator);
-
-  virtual ~service_provider();
-
-  /**
-   * See service::add_handler().
-   */
-  virtual void add_handler(handler* new_handler) = 0;
-
-  /**
-   * See service::remove_handler().
-   */
-  void remove_handler(handler* old_handler);
+  handler_service_provider(kernel::module& module,
+                           event::handler_service& handler_service);
+
+  virtual ~handler_service_provider();
+
+  /**
+   * See event::handler_service::add_handler().
+   */
+  void add_handler(handler* handler);
+
+  /**
+   * See event::handler_service::remove_handler().
+   */
+  void remove_handler(handler* handler);
+
+  /**
+   * See event::handler_service::shutdown().
+   */
+  void shutdown(void);
 
 private:
 
@@ -55,34 +64,26 @@
    * Don't allow copying of objects.
    */
   SCALESTACK_LOCAL
-  service_provider(const service_provider&);
+  handler_service_provider(const handler_service_provider&);
 
   /**
    * Don't allow assignment of objects.
    */
   SCALESTACK_LOCAL
-  service_provider& operator=(const service_provider&);
+  handler_service_provider& operator=(const handler_service_provider&);
+
+  typedef std::set<handler*> handlers;
+
+  bool _shutdown;
+  size_t _handler_count;
+  libevent::service& _service;
+  pthread_mutex_t _handler_mutex;
+  common::notification _shutdown_notification;
+  handlers _handlers;
 };
 
-/*
- * Public methods.
- */
-
-inline service_provider::service_provider(kernel::module& creator):
-  kernel::service(creator)
-{
-}
-
-inline service_provider::~service_provider()
-{
-}
-
-inline void service_provider::remove_handler(handler* old_handler)
-{
-  old_handler->get_service()._remove_handler(old_handler);
-}
-
+} /* namespace libevent */
 } /* namespace event */
 } /* namespace scalestack */
 
-#endif /* SCALESTACK_EVENT_SERVICE_PROVIDER_H */
+#endif /* SCALESTACK_EVENT_LIBEVENT_HANDLER_SERVICE_PROVIDER_H */

=== modified file 'scalestack/event/libevent/libevent.cc'
--- scalestack/event/libevent/libevent.cc	2010-06-03 04:51:37 +0000
+++ scalestack/event/libevent/libevent.cc	2010-06-16 19:32:28 +0000
@@ -16,8 +16,9 @@
 #include "config.h"
 
 #include <exception>
+#include <memory>
 
-#include <scalestack/event/libevent/service_provider.h>
+#include <scalestack/event/libevent/service.h>
 #include <scalestack/kernel/core.h>
 #include <scalestack/kernel/module.h>
 
@@ -26,22 +27,21 @@
 
 static void options(kernel::module& module)
 {
-  module.add_option("threads", "Number of event threads to use.", "THREADS", "1");
-  module.add_option("thread_stack_size", "Size of the stack for threads.", "STACKSIZE", "0");
+  module.add_option("threads",
+                    "Number of event threads to use.",
+                    "THREADS",
+                    "1");
+  module.add_option("thread_stack_size",
+                    "Size of the stack for threads (0 means default).",
+                    "STACKSIZE",
+                    "0");
 }
 
 static void start(kernel::module& module)
 {
-  event::libevent::service_provider* service_provider = new event::libevent::service_provider(module);
-  try
-  {
-    module.get_core().add_service("event", service_provider);
-  }
-  catch (exception&)
-  {
-    delete service_provider;
-    throw;
-  }
+  auto_ptr<event::libevent::service> service(new event::libevent::service(module));
+  module.get_core().add_service("event", service.get());
+  service.release();
 }
 
 static void stop(kernel::module& module)

=== modified file 'scalestack/event/libevent/plugin.ini'
--- scalestack/event/libevent/plugin.ini	2010-06-03 04:51:37 +0000
+++ scalestack/event/libevent/plugin.ini	2010-06-16 19:32:28 +0000
@@ -4,8 +4,8 @@
 version=0.1
 author=Eric Day <[e-mail]>
 license=BSD
-sources=libevent.cc handler_provider.cc service_provider.cc thread.cc
-headers=handler_provider.h service_provider.h thread.h
+sources=libevent.cc handler_provider.cc handler_service_provider.cc service.cc thread.cc
+headers=handler_provider.h handler_service_provider.h service.h thread.h
 dependencies=event
 ldflags=${LTLIBEVENT}
 build_conditional="x$ac_cv_func_event_base_new" = "xyes"

=== renamed file 'scalestack/event/libevent/service_provider.cc' => 'scalestack/event/libevent/service.cc'
--- scalestack/event/libevent/service_provider.cc	2010-06-03 04:51:37 +0000
+++ scalestack/event/libevent/service.cc	2010-06-16 19:32:28 +0000
@@ -18,10 +18,11 @@
 #include <algorithm>
 #include <exception>
 #include <functional>
+#include <memory>
 
-#include <scalestack/event/service.h>
 #include <scalestack/event/libevent/handler_provider.h>
-#include <scalestack/event/libevent/service_provider.h>
+#include <scalestack/event/libevent/handler_service_provider.h>
+#include <scalestack/event/libevent/service.h>
 #include <scalestack/event/libevent/thread.h>
 #include <scalestack/kernel/module.h>
 #include <scalestack/kernel/option.h>
@@ -39,8 +40,8 @@
  * Public methods.
  */
 
-service_provider::service_provider(kernel::module& module):
-  event::service_provider(module),
+service::service(kernel::module& module):
+  event::service(module),
   _current_thread(),
   _threads()
 {
@@ -50,18 +51,18 @@
 
   for (size_t thread_index = 0; thread_index < thread_count; thread_index++)
   {
-    thread* new_thread = NULL;
+    thread* thread = NULL;
     try
     {
-      new_thread = new thread(*this, thread_index);
-      _threads.push_back(new_thread);
+      thread = new libevent::thread(*this, thread_index);
+      _threads.push_back(thread);
     }
     catch (exception&)
     {
-      if (new_thread != NULL)
+      if (thread != NULL)
       {
-        new_thread->stop();
-        delete new_thread;
+        thread->stop();
+        delete thread;
       }
 
       _remove_threads();
@@ -70,32 +71,28 @@
   }
 }
 
-service_provider::~service_provider()
+service::~service()
 {
   _remove_threads();
 }
 
-void service_provider::add_handler(event::handler* handler)
+void service::add_handler(event::handler* handler,
+                          handler_service_provider& handler_service_provider)
 {
-  handler_provider* new_handler_provider = new handler_provider(_module);
-  try
-  {
-    new_handler_provider->set_handler(handler);
-
-    /* Choose assigned thread by round-robin. */
-    _current_thread++;
-    new_handler_provider->set_thread(_threads[_current_thread % _threads.size()]);
-  }
-  catch (exception&)
-  {
-    delete new_handler_provider;
-    throw;
-  }
+  auto_ptr<handler_provider> handler_provider(new libevent::handler_provider(_module, handler_service_provider));
+
+  handler_provider->set_handler(handler);
+
+  /* Choose assigned thread by round-robin. */
+  _current_thread++;
+  handler_provider->set_thread(_threads[_current_thread % _threads.size()]);
+
+  handler_provider.release();
 }
 
-void service_provider::remove_handler_provider(handler_provider* handler_provider)
+void service::remove_handler(handler_provider* handler_provider)
 {
-  remove_handler(handler_provider->get_handler());
+  handler_provider->get_handler_service_provider().remove_handler(handler_provider->get_handler());
   delete handler_provider;
 }
 
@@ -103,11 +100,11 @@
  * Private methods.
  */
 
-void service_provider::_remove_threads(void)
+void service::_remove_threads(void)
 {
   for_each(_threads.begin(), _threads.end(), mem_fun(&thread::stop));
 
-  for (vector<thread*>::iterator thread = _threads.begin();
+  for (threads::iterator thread = _threads.begin();
        thread != _threads.end();
        ++thread)
   {
@@ -115,6 +112,16 @@
   }
 }
 
+event::handler_service_provider& service::_add_handler_service(event::handler_service& handler_service)
+{
+  return *(new handler_service_provider(_module, handler_service));
+}
+
+void service::_remove_handler_service(event::handler_service_provider& handler_service_provider)
+{
+  delete &handler_service_provider;
+}
+
 } /* namespace libevent */
 } /* namespace event */
 } /* namespace scalestack */

=== renamed file 'scalestack/event/libevent/service_provider.h' => 'scalestack/event/libevent/service.h'
--- scalestack/event/libevent/service_provider.h	2010-06-03 04:51:37 +0000
+++ scalestack/event/libevent/service.h	2010-06-16 19:32:28 +0000
@@ -10,28 +10,31 @@
 
 /**
  * @file
- * @brief libevent Event Service Provider Declarations
+ * @brief libevent Event Service Declarations
  */
 
-#ifndef SCALESTACK_EVENT_LIBEVENT_SERVICE_PROVIDER_H
-#define SCALESTACK_EVENT_LIBEVENT_SERVICE_PROVIDER_H
+#ifndef SCALESTACK_EVENT_LIBEVENT_SERVICE_H
+#define SCALESTACK_EVENT_LIBEVENT_SERVICE_H
 
 #include <vector>
 
 #include <scalestack/common/macros.h>
-#include <scalestack/event/service_provider.h>
+#include <scalestack/event/service.h>
 
 namespace scalestack
 {
 namespace event
 {
+
+class handler;
+
 namespace libevent
 {
 
 class handler_provider;
 class thread;
 
-class SCALESTACK_API service_provider: public event::service_provider
+class SCALESTACK_API service: public event::service
 {
 public:
 
@@ -40,21 +43,26 @@
    *
    * @param[in] module Module that the service is associated with.
    */
-  service_provider(kernel::module& module);
+  service(kernel::module& module);
 
-  ~service_provider();
+  ~service();
 
   /**
-   * See event::service::add_handler().
+   * Add a handler to one of the threads in the service pool.
+   *
+   * @param[in] handler Handler to add.
+   * @param[in] handler_service_provider Handler service the handler
+   *  belongs to.
    */
-  void add_handler(event::handler* handler);
+  void add_handler(event::handler* handler,
+                   handler_service_provider& handler_service_provider);
 
   /**
-   * Remove handler provider that was previously added in add_handler().
+   * Remove handler that was previously added in add_handler().
    *
    * @param[in] handler_provider Handler provider to remove.
    */
-  void remove_handler_provider(handler_provider* handler_provider);
+  void remove_handler(handler_provider* handler_provider);
 
 private:
 
@@ -62,25 +70,37 @@
    * Don't allow copying of objects.
    */
   SCALESTACK_LOCAL
-  service_provider(const service_provider&);
+  service(const service&);
 
   /**
    * Don't allow assignment of objects.
    */
   SCALESTACK_LOCAL
-  service_provider& operator=(const service_provider&);
+  service& operator=(const service&);
 
   /**
    * Remove all threads that were created in the constructor.
    */
   void _remove_threads(void);
 
+  /**
+   * See event::service::_add_handler_service().
+   */
+  event::handler_service_provider& _add_handler_service(event::handler_service& handler_service);
+
+  /**
+   * See event::service::_remove_handler_service().
+   */
+  void _remove_handler_service(event::handler_service_provider& handler_service_provider);
+
+  typedef std::vector<thread*> threads;
+
   size_t _current_thread;
-  std::vector<thread*> _threads;
+  threads _threads;
 };
 
 } /* namespace libevent */
 } /* namespace event */
 } /* namespace scalestack */
 
-#endif /* SCALESTACK_EVENT_LIBEVENT_SERVICE_PROVIDER_H */
+#endif /* SCALESTACK_EVENT_LIBEVENT_SERVICE_H */

=== modified file 'scalestack/event/libevent/thread.cc'
--- scalestack/event/libevent/thread.cc	2010-06-03 04:51:37 +0000
+++ scalestack/event/libevent/thread.cc	2010-06-16 19:32:28 +0000
@@ -17,12 +17,13 @@
 
 #include <algorithm>
 #include <cerrno>
+#include <cstring>
 #include <fcntl.h>
 #include <functional>
 #include <unistd.h>
 
 #include <scalestack/event/libevent/handler_provider.h>
-#include <scalestack/event/libevent/service_provider.h>
+#include <scalestack/event/libevent/service.h>
 #include <scalestack/event/libevent/thread.h>
 #include <scalestack/kernel/core.h>
 #include <scalestack/kernel/module.h>
@@ -43,28 +44,28 @@
 
 extern "C" void* thread_run(void* context)
 {
-  thread* new_thread = static_cast<thread*>(context);
-  new_thread->_run();
+  thread* thread = static_cast<libevent::thread*>(context);
+  thread->_run();
   return NULL;
 }
 
 extern "C" void thread_handle_notification(int file_descriptor, short events,
                                            void* context)
 {
-  thread* current_thread = static_cast<thread*>(context);
-  current_thread->_handle_notification(file_descriptor, events);
+  thread* thread = static_cast<libevent::thread*>(context);
+  thread->_handle_notification(file_descriptor, events);
 }
 
 /*
  * Public methods.
  */
 
-thread::thread(service_provider& service_provider, size_t thread_index):
+thread::thread(service& service, size_t thread_index):
   _shutdown(false),
   _handler_providers_index(),
   _thread_index(thread_index),
-  _module(service_provider.get_module()),
-  _service_provider(service_provider),
+  _module(service.get_module()),
+  _service(service),
   _base(),
   _notification_pipe(),
   _thread_id(),
@@ -75,7 +76,7 @@
   _handler_providers()
 {
   if (gettimeofday(&_now, 0) == -1)
-    _module.log_fatal("Failed gettimeofday: %d", errno);
+    _module.log_fatal("Failed gettimeofday: %s:%d", strerror(errno), errno);
 
   _base = event_base_new();
   if (_base == NULL)
@@ -135,13 +136,23 @@
 
 void thread::check_handler_provider(handler_provider* handler_provider)
 {
-  pthread_mutex_lock(&_handler_providers_mutex);
+  int return_code = pthread_mutex_lock(&_handler_providers_mutex);
+  if (return_code != 0)
+  {
+    _module.log_fatal("Failed pthread_mutex_lock: %s:%d",
+                      strerror(return_code), return_code);
+  }
 
   /* Double check queue flag inside lock to avoid race conditions. */
   if (handler_provider->add_to_check_queue())
     _handler_providers[_handler_providers_index].push_back(handler_provider);
 
-  pthread_mutex_unlock(&_handler_providers_mutex);
+  return_code = pthread_mutex_unlock(&_handler_providers_mutex);
+  if (return_code != 0)
+  {
+    _module.log_fatal("Failed pthread_mutex_unlock: %s:%d",
+                      strerror(return_code), return_code);
+  }
 
   _send_notification();
 }
@@ -177,7 +188,7 @@
 {
   int return_code = pipe(_notification_pipe);
   if (return_code == -1)
-    _module.log_fatal("Failed pipe: %d", errno);
+    _module.log_fatal("Failed pipe: %s:%d", strerror(errno), errno);
 
   for (int index = 0; index < 2; index++)
   {
@@ -185,14 +196,14 @@
     if (return_code == -1)
     {
       _remove_notification_pipe();
-      _module.log_fatal("Failed fcntl: %d", errno);
+      _module.log_fatal("Failed fcntl: %s:%d", strerror(errno), errno);
     }
 
     return_code = fcntl(_notification_pipe[index], F_SETFL, return_code | O_NONBLOCK);
     if (return_code == -1)
     {
       _remove_notification_pipe();
-      _module.log_fatal("Failed fcntl: %d", errno);
+      _module.log_fatal("Failed fcntl: %s:%d", strerror(errno), errno);
     }
   }
 
@@ -223,7 +234,10 @@
 void thread::_send_notification(void)
 {
   if (write(_notification_pipe[1], "\0", 1) == -1)
-    _module.log_error("Could not write to notification pipe: %d", errno);
+  {
+    _module.log_error("Could not write to notification pipe: %s:%d",
+                      strerror(errno), errno);
+  }
 }
 
 void thread::_handle_notification(int file_descriptor, short events)
@@ -234,7 +248,10 @@
   {
     char buffer[1024];
     if (read(file_descriptor, buffer, sizeof(buffer)) == -1)
-      _module.log_error("Could not read from notification pipe: %d", errno);
+    {
+      _module.log_error("Could not read from notification pipe: %s:%d",
+                        strerror(errno), errno);
+    }
   }
 
   if (event_del(&_notification_event) == -1)
@@ -254,21 +271,34 @@
   }
 
   if (gettimeofday(&_now, 0) == -1)
-    _module.log_error("Failed gettimeofday: %d", errno);
+    _module.log_error("Failed gettimeofday: %s:%d", strerror(errno), errno);
 
   /* Just switch the index, keep lock time to a minimum. */
   uint8_t index = _handler_providers_index;
-  pthread_mutex_lock(&_handler_providers_mutex);
+
+  int return_code = pthread_mutex_lock(&_handler_providers_mutex);
+  if (return_code != 0)
+  {
+    _module.log_fatal("Failed pthread_mutex_lock: %s:%d",
+                      strerror(return_code), return_code);
+  }
+
   _handler_providers_index = static_cast<uint8_t>(1 - _handler_providers_index);
-  pthread_mutex_unlock(&_handler_providers_mutex);
-
-  vector<handler_provider*>::iterator handler_provider;
+
+  return_code = pthread_mutex_unlock(&_handler_providers_mutex);
+  if (return_code != 0)
+  {
+    _module.log_fatal("Failed pthread_mutex_unlock: %s:%d",
+                      strerror(return_code), return_code);
+  }
+
+  handler_providers::iterator handler_provider;
   for (handler_provider = _handler_providers[index].begin();
        handler_provider != _handler_providers[index].end();
        ++handler_provider)
   {
     if ((*handler_provider)->need_remove())
-      _service_provider.remove_handler_provider(*handler_provider);
+      _service.remove_handler(*handler_provider);
     else
       (*handler_provider)->check();
   }
@@ -280,14 +310,20 @@
 {
   int return_code = pthread_mutex_init(&_handler_providers_mutex, NULL);
   if (return_code != 0)
-    _module.log_fatal("Failed pthread_mutex_init: %d", return_code);
+  {
+    _module.log_fatal("Failed pthread_mutex_init: %s:%d",
+                      strerror(return_code), return_code);
+  }
 }
 
 void thread::_remove_mutexes(void)
 {
   int return_code = pthread_mutex_destroy(&_handler_providers_mutex);
   if (return_code != 0)
-    _module.log_error("Failed pthread_mutex_destroy: %d", return_code);
+  {
+    _module.log_error("Failed pthread_mutex_destroy: %s:%d",
+                      strerror(return_code), return_code);
+  }
 }
 
 void thread::_add_thread(void)
@@ -296,7 +332,10 @@
 
   int return_code = pthread_attr_init(&thread_attribute);
   if (return_code != 0)
-    _module.log_fatal("Failed pthread_attr_init: %d", return_code);
+  {
+    _module.log_fatal("Failed pthread_attr_init: %s:%d",
+                      strerror(return_code), return_code);
+  }
 
   size_t stack_size = _module.get_option("thread_stack_size").get_size_value();
   if (stack_size != 0)
@@ -305,7 +344,8 @@
     if (return_code != 0)
     {
       (void) pthread_attr_destroy(&thread_attribute);
-      _module.log_fatal("Failed pthread_attr_setstacksize: %d", return_code);
+      _module.log_fatal("Failed pthread_attr_setstacksize: %s:%d",
+                      strerror(return_code), return_code);
     }
   }
 
@@ -313,26 +353,34 @@
   if (return_code != 0)
   {
     (void) pthread_attr_destroy(&thread_attribute);
-    _module.log_fatal("Failed pthread_attr_setscope: %d", return_code);
+    _module.log_fatal("Failed pthread_attr_setscope: %s:%d",
+                      strerror(return_code), return_code);
   }
 
   return_code = pthread_create(&_thread_id, &thread_attribute, thread_run, this);
   if (return_code != 0)
   {
     (void) pthread_attr_destroy(&thread_attribute);
-    _module.log_fatal("Failed pthread_create: %d", return_code);
+    _module.log_fatal("Failed pthread_create: %s:%d",
+                      strerror(return_code), return_code);
   }
 
   return_code = pthread_attr_destroy(&thread_attribute);
   if (return_code != 0)
-    _module.log_error("Failed pthread_attr_destroy: %d", return_code);
+  {
+    _module.log_error("Failed pthread_attr_destroy: %s:%d",
+                      strerror(return_code), return_code);
+  }
 }
 
 void thread::_remove_thread(void)
 {
   int return_code = pthread_join(_thread_id, NULL);
   if (return_code != 0)
-    _module.log_error("Failed pthread_join: %d", return_code);
+  {
+    _module.log_error("Failed pthread_join: %s:%d",
+                      strerror(return_code), return_code);
+  }
 }
 
 } /* namespace libevent */

=== modified file 'scalestack/event/libevent/thread.h'
--- scalestack/event/libevent/thread.h	2010-06-03 04:51:37 +0000
+++ scalestack/event/libevent/thread.h	2010-06-16 19:32:28 +0000
@@ -38,7 +38,7 @@
 {
 
 class handler_provider;
-class service_provider;
+class service;
 
 /**
  * Function passed to pthread_create() to invoke thread::_run().
@@ -48,15 +48,12 @@
 /**
  * Function used by notification event to invoke thread::_handle_notification().
  */
-extern "C" void thread_handle_notification(int file_descriptor, short events,
+extern "C" void thread_handle_notification(int file_descriptor,
+                                           short events,
                                            void* context);
 
 class thread
 {
-  friend void* thread_run(void*);
-  friend void thread_handle_notification(int file_descriptor, short events,
-                                         void* context);
-
 public:
 
   /**
@@ -64,10 +61,10 @@
    * starting this call, the _run() method can be called at any time, even
    * before the constructor completes.
    *
-   * @param[in] service_provider Service provider creating this thread.
+   * @param[in] service Service that is creating this thread.
    * @param[in] thread_index The 0-based index for this thread.
    */
-  thread(service_provider& service_provider, size_t thread_index);
+  thread(service& service, size_t thread_index);
 
   ~thread();
 
@@ -164,11 +161,13 @@
   SCALESTACK_LOCAL
   void _remove_thread(void);
 
+  typedef std::vector<handler_provider*> handler_providers;
+
   bool _shutdown;
   uint8_t _handler_providers_index;
   size_t _thread_index;
   kernel::module& _module;
-  service_provider& _service_provider;
+  service& _service;
   struct event_base* _base;
   int _notification_pipe[2];
   pthread_t _thread_id;
@@ -176,7 +175,12 @@
   struct timeval _notification_timeout;
   struct timeval _now;
   pthread_mutex_t _handler_providers_mutex;
-  std::vector<handler_provider*> _handler_providers[2];
+  handler_providers _handler_providers[2];
+
+  friend void* thread_run(void*);
+  friend void thread_handle_notification(int file_descriptor,
+                                         short events,
+                                         void* context);
 };
 
 } /* namespace libevent */

=== modified file 'scalestack/event/plugin.ini'
--- scalestack/event/plugin.ini	2010-06-03 04:51:37 +0000
+++ scalestack/event/plugin.ini	2010-06-16 19:32:28 +0000
@@ -4,5 +4,5 @@
 version=0.1
 author=Eric Day <[e-mail]>
 license=BSD
-sources=event.cc service.cc
-install_headers=handler.h service.h service_provider.h
+sources=event.cc
+install_headers=handler.h handler_service.h service.h

=== added file 'scalestack/event/service.h'
--- scalestack/event/service.h	1970-01-01 00:00:00 +0000
+++ scalestack/event/service.h	2010-06-16 19:32:28 +0000
@@ -0,0 +1,95 @@
+/*
+ * Scale Stack
+ *
+ * Copyright (C) 2010 Eric Day ([e-mail])
+ * All rights reserved.
+ *
+ * Use and distribution licensed under the BSD license. See the
+ * COPYING file in the root project directory for full text.
+ */
+
+/**
+ * @file
+ * @brief Event Service Declarations
+ */
+
+#ifndef SCALESTACK_EVENT_SERVICE_H
+#define SCALESTACK_EVENT_SERVICE_H
+
+#include <scalestack/common/macros.h>
+#include <scalestack/kernel/service.h>
+
+namespace scalestack
+{
+namespace event
+{
+
+class handler_service;
+class handler_service_provider;
+
+/**
+ * This is a base class that event providers must implement in order to
+ * provide an event service.
+ */
+class SCALESTACK_API service: public kernel::service
+{
+public:
+
+  /**
+   * Constructor for event service.
+   *
+   * @param[in] module Module that the service is associated with.
+   */
+  service(kernel::module& module);
+
+  virtual ~service();
+
+private:
+
+  /**
+   * Don't allow copying of objects.
+   */
+  SCALESTACK_LOCAL
+  service(const service&);
+
+  /**
+   * Don't allow assignment of objects.
+   */
+  SCALESTACK_LOCAL
+  service& operator=(const service&);
+
+  /**
+   * Add a handler service to the event service.
+   *
+   * @param[in] handler_service Handler service to add.
+   * @return Handler service provider to use with the handler service.
+   */
+  virtual handler_service_provider& _add_handler_service(handler_service& handler_service) = 0;
+
+  /**
+   * Remove a handler service provider from an event service.
+   *
+   * @param[in] handler_service_provider Handler service provider to remove.
+   */
+  virtual void _remove_handler_service(handler_service_provider& handler_service_provider) = 0;
+
+  friend class handler_service;
+};
+
+/*
+ * Public handler_service methods.
+ */
+
+inline service::service(kernel::module& module):
+  kernel::service(module)
+{
+}
+
+inline service::~service()
+{
+}
+
+} /* namespace event */
+} /* namespace scalestack */
+
+#endif /* SCALESTACK_EVENT_SERVICE_H */

=== modified file 'scalestack/event/test/handler.cc'
--- scalestack/event/test/handler.cc	2010-06-03 04:51:37 +0000
+++ scalestack/event/test/handler.cc	2010-06-16 19:32:28 +0000
@@ -28,8 +28,8 @@
  * Public methods.
  */
 
-handler::handler(service& creator):
-  event::handler(creator)
+handler::handler(handler_service& handler_service):
+  event::handler(handler_service)
 {
 }
 

=== modified file 'scalestack/event/test/handler.h'
--- scalestack/event/test/handler.h	2010-06-03 04:51:37 +0000
+++ scalestack/event/test/handler.h	2010-06-16 19:32:28 +0000
@@ -30,7 +30,7 @@
 {
 public:
 
-  handler(service& creator);
+  handler(handler_service& handler_service);
 
   ~handler();
 

=== modified file 'scalestack/event/test/handler_provider.cc'
--- scalestack/event/test/handler_provider.cc	2010-06-03 04:51:37 +0000
+++ scalestack/event/test/handler_provider.cc	2010-06-16 19:32:28 +0000
@@ -16,7 +16,7 @@
 #include "config.h"
 
 #include <scalestack/event/test/handler_provider.h>
-#include <scalestack/event/test/service_provider.h>
+#include <scalestack/event/test/handler_service_provider.h>
 
 namespace scalestack
 {
@@ -29,8 +29,8 @@
  * Public methods.
  */
 
-handler_provider::handler_provider(service_provider& creator):
-  _service_provider(creator)
+handler_provider::handler_provider(handler_service_provider& handler_service_provider):
+  _handler_service_provider(handler_service_provider)
 {
 }
 
@@ -40,7 +40,7 @@
 
 void handler_provider::remove(void)
 {
-  _service_provider.queue_to_remove(this);
+  _handler_service_provider.queue_to_remove(this);
 }
 
 void handler_provider::set_timer(time_t)

=== modified file 'scalestack/event/test/handler_provider.h'
--- scalestack/event/test/handler_provider.h	2010-06-03 04:51:37 +0000
+++ scalestack/event/test/handler_provider.h	2010-06-16 19:32:28 +0000
@@ -26,13 +26,13 @@
 namespace test
 {
 
-class service_provider;
+class handler_service_provider;
 
 class SCALESTACK_API handler_provider: public event::handler_provider
 {
 public:
 
-  handler_provider(service_provider& creator);
+  handler_provider(handler_service_provider& handler_service_provider);
 
   ~handler_provider();
 
@@ -62,7 +62,7 @@
   SCALESTACK_LOCAL
   handler_provider& operator=(const handler_provider&);
 
-  service_provider& _service_provider;
+  handler_service_provider& _handler_service_provider;
 };
 
 } /* namespace test */

=== renamed file 'scalestack/event/test/service.cc' => 'scalestack/event/test/handler_service.cc'
--- scalestack/event/test/service.cc	2010-06-03 04:51:37 +0000
+++ scalestack/event/test/handler_service.cc	2010-06-16 19:32:28 +0000
@@ -16,7 +16,7 @@
 #include "config.h"
 
 #include <scalestack/event/test/handler.h>
-#include <scalestack/event/test/service.h>
+#include <scalestack/event/test/handler_service.h>
 
 namespace scalestack
 {
@@ -29,19 +29,19 @@
  * Public methods.
  */
 
-service::service(kernel::module& creator):
-  event::service(creator)
+handler_service::handler_service(kernel::module& module):
+  event::handler_service(module)
 {
 }
 
-service::~service()
+handler_service::~handler_service()
 {
   shutdown();
 }
 
-void service::remove_handler(event::handler* old_handler)
+void handler_service::remove_handler(event::handler* handler)
 {
-  delete old_handler;
+  delete handler;
 }
 
 } /* namespace test */

=== renamed file 'scalestack/event/test/service.h' => 'scalestack/event/test/handler_service.h'
--- scalestack/event/test/service.h	2010-06-03 04:51:37 +0000
+++ scalestack/event/test/handler_service.h	2010-06-16 19:32:28 +0000
@@ -13,11 +13,11 @@
  * @brief Event Test Service Declarations
  */
 
-#ifndef SCALESTACK_EVENT_TEST_SERVICE_H
-#define SCALESTACK_EVENT_TEST_SERVICE_H
+#ifndef SCALESTACK_EVENT_TEST_HANDLER_SERVICE_H
+#define SCALESTACK_EVENT_TEST_HANDLER_SERVICE_H
 
 #include <scalestack/common/macros.h>
-#include <scalestack/event/service.h>
+#include <scalestack/event/handler_service.h>
 
 namespace scalestack
 {
@@ -26,18 +26,18 @@
 namespace test
 {
 
-class SCALESTACK_API service: public event::service
+class SCALESTACK_API handler_service: public event::handler_service
 {
 public:
 
-  service(kernel::module& creator);
+  handler_service(kernel::module& module);
 
-  ~service();
+  ~handler_service();
 
   /**
-   * See event::service::remove_handler().
+   * See event::handler_service::remove_handler().
    */
-  void remove_handler(event::handler* old_handler);
+  void remove_handler(event::handler* handler);
 
 private:
 
@@ -45,17 +45,17 @@
    * Don't allow copying of objects.
    */
   SCALESTACK_LOCAL
-  service(const service&);
+  handler_service(const handler_service&);
 
   /**
    * Don't allow assignment of objects.
    */
   SCALESTACK_LOCAL
-  service& operator=(const service&);
+  handler_service& operator=(const handler_service&);
 };
 
 } /* namespace test */
 } /* namespace event */
 } /* namespace scalestack */
 
-#endif /* SCALESTACK_EVENT_TEST_SERVICE_H */
+#endif /* SCALESTACK_EVENT_TEST_HANDLER_SERVICE_H */

=== renamed file 'scalestack/event/test/service_provider.cc' => 'scalestack/event/test/handler_service_provider.cc'
--- scalestack/event/test/service_provider.cc	2010-06-03 04:51:37 +0000
+++ scalestack/event/test/handler_service_provider.cc	2010-06-16 19:32:28 +0000
@@ -16,7 +16,7 @@
 #include "config.h"
 
 #include <scalestack/event/test/handler_provider.h>
-#include <scalestack/event/test/service_provider.h>
+#include <scalestack/event/test/handler_service_provider.h>
 
 namespace scalestack
 {
@@ -29,32 +29,32 @@
  * Public methods.
  */
 
-service_provider::service_provider(kernel::module& creator):
-  event::service_provider(creator),
-  _old_handler_provider()
-{
-}
-
-service_provider::~service_provider()
-{
-}
-
-void service_provider::add_handler(event::handler* new_handler)
-{
-  handler_provider* new_handler_provider = new handler_provider(*this);
-  new_handler_provider->set_handler(new_handler);
-  new_handler_provider->start();
-}
-
-void service_provider::queue_to_remove(handler_provider* old_handler_provider)
-{
-  _old_handler_provider = old_handler_provider;
-}
-
-void service_provider::check_remove_queue(void)
-{
-  remove_handler(_old_handler_provider->get_handler());
-  delete _old_handler_provider;
+handler_service_provider::handler_service_provider(kernel::module& module, event::handler_service& handler_service):
+  event::handler_service_provider(module, handler_service),
+  _handler_provider()
+{
+}
+
+handler_service_provider::~handler_service_provider()
+{
+}
+
+void handler_service_provider::add_handler(event::handler* handler)
+{
+  handler_provider* handler_provider = new test::handler_provider(*this);
+  handler_provider->set_handler(handler);
+  handler_provider->start();
+}
+
+void handler_service_provider::shutdown(void)
+{
+  remove_handler(_handler_provider->get_handler());
+  delete _handler_provider;
+}
+
+void handler_service_provider::queue_to_remove(handler_provider* handler_provider)
+{
+  _handler_provider = handler_provider;
 }
 
 } /* namespace test */

=== renamed file 'scalestack/event/test/service_provider.h' => 'scalestack/event/test/handler_service_provider.h'
--- scalestack/event/test/service_provider.h	2010-06-03 04:51:37 +0000
+++ scalestack/event/test/handler_service_provider.h	2010-06-16 19:32:28 +0000
@@ -13,11 +13,11 @@
  * @brief Event Test Service Provider Declarations
  */
 
-#ifndef SCALESTACK_EVENT_TEST_SERVICE_PROVIDER_H
-#define SCALESTACK_EVENT_TEST_SERVICE_PROVIDER_H
+#ifndef SCALESTACK_EVENT_TEST_HANDLER_SERVICE_PROVIDER_H
+#define SCALESTACK_EVENT_TEST_HANDLER_SERVICE_PROVIDER_H
 
 #include <scalestack/common/macros.h>
-#include <scalestack/event/service_provider.h>
+#include <scalestack/event/handler_service.h>
 
 namespace scalestack
 {
@@ -28,28 +28,29 @@
 
 class handler_provider;
 
-class SCALESTACK_API service_provider: public event::service_provider
+class SCALESTACK_API handler_service_provider: public event::handler_service_provider
 {
 public:
 
-  service_provider(kernel::module& creator);
-
-  ~service_provider();
-
-  /**
-   * See event::service::add_handler().
-   */
-  void add_handler(event::handler* new_handler);
+  handler_service_provider(kernel::module& module,
+                           event::handler_service& handler_service);
+
+  ~handler_service_provider();
+
+  /**
+   * See event::handler_service::add_handler().
+   */
+  void add_handler(event::handler* handler);
+
+  /**
+   * See event::handler_service::shutdown().
+   */
+  void shutdown(void);
 
   /**
    * Queue a handler provider to be removed.
    */
-  void queue_to_remove(handler_provider* old_handler_provider);
-
-  /**
-   * Remove handler providers in remove queue.
-   */
-  void check_remove_queue(void);
+  void queue_to_remove(handler_provider* handler_provider);
 
 private:
 
@@ -57,19 +58,19 @@
    * Don't allow copying of objects.
    */
   SCALESTACK_LOCAL
-  service_provider(const service_provider&);
+  handler_service_provider(const handler_service_provider&);
 
   /**
    * Don't allow assignment of objects.
    */
   SCALESTACK_LOCAL
-  service_provider& operator=(const service_provider&);
+  handler_service_provider& operator=(const handler_service_provider&);
 
-  handler_provider* _old_handler_provider;
+  handler_provider* _handler_provider;
 };
 
 } /* namespace test */
 } /* namespace event */
 } /* namespace scalestack */
 
-#endif /* SCALESTACK_EVENT_TEST_SERVICE_PROVIDER_H */
+#endif /* SCALESTACK_EVENT_TEST_HANDLER_SERVICE_PROVIDER_H */

=== modified file 'scalestack/event/test/plugin.ini'
--- scalestack/event/test/plugin.ini	2010-06-03 04:51:37 +0000
+++ scalestack/event/test/plugin.ini	2010-06-16 19:32:28 +0000
@@ -5,7 +5,7 @@
 author=Eric Day <[e-mail]>
 license=BSD
 install=no
-sources=handler.cc handler_provider.cc run.cc service.cc service_provider.cc test.cc
-headers=handler.h handler_provider.h service.h service_provider.h
+sources=handler.cc handler_provider.cc handler_service.cc handler_service_provider.cc service.cc test.cc
+headers=handler.h handler_provider.h handler_service.h handler_service_provider.h service.h
 dependencies=event
 tests=run

=== modified file 'scalestack/event/test/run.cc'
--- scalestack/event/test/run.cc	2010-06-03 04:51:37 +0000
+++ scalestack/event/test/run.cc	2010-06-16 19:32:28 +0000
@@ -18,7 +18,6 @@
 TEST_SUITE_BEGIN
 
 TEST_BEGIN(test_event)
-  core.get_or_add_module("event");
   core.get_or_add_module("event::test");
   core.run();
 TEST_END

=== added file 'scalestack/event/test/service.cc'
--- scalestack/event/test/service.cc	1970-01-01 00:00:00 +0000
+++ scalestack/event/test/service.cc	2010-06-16 19:32:28 +0000
@@ -0,0 +1,57 @@
+/*
+ * Scale Stack
+ *
+ * Copyright (C) 2010 Eric Day ([e-mail])
+ * All rights reserved.
+ *
+ * Use and distribution licensed under the BSD license. See the
+ * COPYING file in the root project directory for full text.
+ */
+
+/**
+ * @file
+ * @brief Event Test Service Definitions
+ */
+
+#include "config.h"
+
+#include <scalestack/event/test/handler_service_provider.h>
+#include <scalestack/event/test/service.h>
+
+namespace scalestack
+{
+namespace event
+{
+namespace test
+{
+
+/*
+ * Public methods.
+ */
+
+service::service(kernel::module& module):
+  event::service(module)
+{
+}
+
+service::~service()
+{
+}
+
+/*
+ * Private methods.
+ */
+
+event::handler_service_provider& service::_add_handler_service(event::handler_service& handler_service)
+{
+  return *(new handler_service_provider(_module, handler_service));
+}
+
+void service::_remove_handler_service(event::handler_service_provider& handler_service_provider)
+{
+  delete &handler_service_provider;
+}
+
+} /* namespace test */
+} /* namespace event */
+} /* namespace scalestack */

=== added file 'scalestack/event/test/service.h'
--- scalestack/event/test/service.h	1970-01-01 00:00:00 +0000
+++ scalestack/event/test/service.h	2010-06-16 19:32:28 +0000
@@ -0,0 +1,66 @@
+/*
+ * Scale Stack
+ *
+ * Copyright (C) 2010 Eric Day ([e-mail])
+ * All rights reserved.
+ *
+ * Use and distribution licensed under the BSD license. See the
+ * COPYING file in the root project directory for full text.
+ */
+
+/**
+ * @file
+ * @brief Event Test Service Declarations
+ */
+
+#ifndef SCALESTACK_EVENT_TEST_SERVICE_H
+#define SCALESTACK_EVENT_TEST_SERVICE_H
+
+#include <scalestack/common/macros.h>
+#include <scalestack/event/service.h>
+
+namespace scalestack
+{
+namespace event
+{
+namespace test
+{
+
+class SCALESTACK_API service: public event::service
+{
+public:
+
+  service(kernel::module& module);
+
+  virtual ~service();
+
+private:
+
+  /**
+   * Don't allow copying of objects.
+   */
+  SCALESTACK_LOCAL
+  service(const service&);
+
+  /**
+   * Don't allow assignment of objects.
+   */
+  SCALESTACK_LOCAL
+  service& operator=(const service&);
+
+  /**
+   * See event::service::_add_handler_service().
+   */
+  event::handler_service_provider& _add_handler_service(event::handler_service& handler_service);
+
+  /**
+   * See event::service::_remove_handler_service().
+   */
+  void _remove_handler_service(event::handler_service_provider& handler_service_provider);
+};
+
+} /* namespace test */
+} /* namespace event */
+} /* namespace scalestack */
+
+#endif /* SCALESTACK_EVENT_TEST_SERVICE_H */

=== modified file 'scalestack/event/test/test.cc'
--- scalestack/event/test/test.cc	2010-06-03 04:51:37 +0000
+++ scalestack/event/test/test.cc	2010-06-16 19:32:28 +0000
@@ -16,40 +16,36 @@
 #include "config.h"
 
 #include <scalestack/event/test/handler.h>
+#include <scalestack/event/test/handler_service.h>
 #include <scalestack/event/test/service.h>
-#include <scalestack/event/test/service_provider.h>
 #include <scalestack/kernel/core.h>
 #include <scalestack/kernel/module.h>
 
 using namespace std;
 using namespace scalestack;
 
-static void start(kernel::module& current)
-{
-  event::test::service_provider* test_service_provider = new event::test::service_provider(current);
-  current.get_core().add_service("event", test_service_provider);
-
-  event::test::service* test_service = new event::test::service(current);
-  current.get_core().add_service("event::test", test_service);
-}
-
-static void stop(kernel::module& current)
-{
-  delete current.get_core().remove_service("event::test");
-  delete current.get_core().remove_service("event");
-}
-
-static void run(kernel::module& current)
-{
-  event::test::service& test_service = static_cast<event::test::service&>(current.get_core().get_service("event::test"));
-
-  test_service.add_handler(new event::test::handler(test_service));
-
-  event::test::service_provider& test_service_provider = static_cast<event::test::service_provider&>(current.get_core().get_service("event"));
-
-  test_service_provider.check_remove_queue();
-
-  current.get_core().shutdown();
+static void start(kernel::module& module)
+{
+  event::test::service* test_service = new event::test::service(module);
+  module.get_core().add_service("event", test_service);
+
+  event::test::handler_service* test_handler_service = new event::test::handler_service(module);
+  module.get_core().add_service("event::test", test_handler_service);
+}
+
+static void stop(kernel::module& module)
+{
+  delete module.get_core().remove_service("event::test");
+  delete module.get_core().remove_service("event");
+}
+
+static void run(kernel::module& module)
+{
+  event::test::handler_service& test_handler_service = static_cast<event::test::handler_service&>(module.get_core().get_service("event::test"));
+
+  test_handler_service.add_handler(new event::test::handler(test_handler_service));
+
+  module.get_core().shutdown();
 }
 
 SCALESTACK_KERNEL_MODULE(NULL, start, stop, run, NULL);

=== modified file 'scalestack/kernel/core.cc'
--- scalestack/kernel/core.cc	2010-06-03 04:51:37 +0000
+++ scalestack/kernel/core.cc	2010-06-16 19:32:28 +0000
@@ -38,14 +38,13 @@
 namespace kernel
 {
 
-/*
+/**
  * This is provided for convenience for applications that only use a single
  * Core instance per process. This needs to be 'extern "C"' and not just
  * static to make SunCC happy.
  */
-
-static scalestack::kernel::core* global_kernel_core = NULL;
 extern "C" void global_signal_handler(int signal_number);
+static core* global_kernel_core = NULL;
 extern "C" void global_signal_handler(int signal_number)
 {
   global_kernel_core->handle_signal(signal_number);
@@ -96,11 +95,11 @@
   {
     log_error(_("Services still exist"));
 
-    for (map<string, service*>::const_iterator leftover = _services.begin();
-         leftover != _services.end();
-         ++leftover)
+    for (services::const_iterator service = _services.begin();
+         service != _services.end();
+         ++service)
     {
-      log_error("  %s", leftover->first.c_str());
+      log_error("  %s", service->first.c_str());
     }
   }
 
@@ -109,18 +108,20 @@
   {
     log_error(_("Logs still exist"));
 
-    for (map<string, log*>::const_iterator leftover = _logs.begin();
-         leftover != _logs.end();
-         ++leftover)
+    for (logs::const_iterator log = _logs.begin();
+         log != _logs.end();
+         ++log)
     {
-      log_error("  %s", leftover->first.c_str());
+      log_error("  %s", log->first.c_str());
     }
   }
 
   log_info(_("Destructed core object"));
 
   delete remove_log("console");
-  global_kernel_core = NULL;
+
+  if (global_kernel_core == this)
+    global_kernel_core = NULL;
 }
 
 void core::parse_arguments(int argument_count, const char** arguments)
@@ -142,7 +143,7 @@
 
     /* Check for verbose flags. */
     if (argument.find_first_not_of("v") == string::npos)
-      _log_threshold += argument.size();
+      _threshold += argument.size();
   }
 
   for (int current = 0; current < argument_count; current++)
@@ -231,7 +232,7 @@
     }
 
     /* Module name and value given, add an alias for the module name. */
-    map<string, string>::iterator alias;
+    aliases::iterator alias;
     for (alias = _aliases.begin(); alias != _aliases.end(); ++alias)
     {
       if (!strcasecmp(alias->first.c_str(), module_name.c_str()))
@@ -251,11 +252,6 @@
   get_or_add_module(module_name)._set_option_value(option_name, value);
 }
 
-void core::set_log_threshold(size_t log_threshold)
-{
-  _log_threshold = log_threshold;
-}
-
 void core::set_signal_handlers(void)
 {
   if (global_kernel_core != NULL)
@@ -272,28 +268,28 @@
   if (sigemptyset(&signal_action.sa_mask) == -1 ||
       sigaction(SIGPIPE, &signal_action, 0) == -1)
   {
-    log_fatal(_("Could not set SIGPIPE handler: %s"), strerror(errno));
+    log_fatal(_("Could not set SIGPIPE handler: %s:%d"), strerror(errno), errno);
   }
 
   signal_action.sa_handler = global_signal_handler;
 
   if (sigaction(SIGHUP, &signal_action, 0) == -1)
-    log_fatal(_("Could not set SIGHUP handler: %s"), strerror(errno));
+    log_fatal(_("Could not set SIGHUP handler: %s:%d"), strerror(errno), errno);
 
   if (sigaction(SIGINT, &signal_action, 0) == -1)
-    log_fatal(_("Could not set SIGINT handler: %s"), strerror(errno));
+    log_fatal(_("Could not set SIGINT handler: %s:%d"), strerror(errno), errno);
 
   if (sigaction(SIGQUIT, &signal_action, 0) == -1)
-    log_fatal(_("Could not set SIGQUIT handler: %s"), strerror(errno));
+    log_fatal(_("Could not set SIGQUIT handler: %s:%d"), strerror(errno), errno);
 
   if (sigaction(SIGTERM, &signal_action, 0) == -1)
-    log_fatal(_("Could not set SIGTERM handler: %s"), strerror(errno));
+    log_fatal(_("Could not set SIGTERM handler: %s:%d"), strerror(errno), errno);
 
   if (sigaction(SIGUSR1, &signal_action, 0) == -1)
-    log_fatal(_("Could not set SIGUSR1 handler: %s"), strerror(errno));
+    log_fatal(_("Could not set SIGUSR1 handler: %s:%d"), strerror(errno), errno);
 
   if (sigaction(SIGUSR2, &signal_action, 0) == -1)
-    log_fatal(_("Could not set SIGUSR2 handler: %s"), strerror(errno));
+    log_fatal(_("Could not set SIGUSR2 handler: %s:%d"), strerror(errno), errno);
 }
 
 void core::handle_signal(int signal_number)
@@ -312,33 +308,33 @@
 {
   const string& alias = _get_alias(name);
 
-  module* current = _get_module(alias);
-  if (current != NULL)
-    return *current;
+  module* module = _get_module(alias);
+  if (module != NULL)
+    return *module;
 
-  current = new module(*this, alias, _log_threshold);
+  module = new kernel::module(*this, alias, _threshold);
   try
   {
-    _add_modules.push_back(current);
+    _add_modules.push_back(module);
   }
   catch (exception&)
   {
-    delete current;
+    delete module;
     throw;
   }
 
-  return *current;
+  return *module;
 }
 
 module& core::get_module(const std::string& name) const
 {
   const string& alias = _get_alias(name);
 
-  module* current = _get_module(alias);
-  if (current == NULL)
+  module* module = _get_module(alias);
+  if (module == NULL)
     log_fatal(_("Could not find module: %s"), alias.c_str());
 
-  return *current;
+  return *module;
 }
 
 size_t core::get_module_count(void) const
@@ -367,10 +363,10 @@
   return *(_module_iterator++);
 }
 
-void core::add_service(const std::string& name, service* new_service)
+void core::add_service(const std::string& name, service* service)
 {
-  pair<map<string, service*>::iterator, bool> result;
-  result = _services.insert(pair<string, service*>(name, new_service));
+  pair<services::iterator, bool> result;
+  result = _services.insert(pair<string, kernel::service*>(name, service));
   if (result.second == false)
     log_fatal(_("Service already exists: %s"), name.c_str());
 
@@ -379,19 +375,19 @@
 
 service* core::remove_service(const std::string& name)
 {
-  map<string, service*>::iterator result = _services.find(name);
+  services::iterator result = _services.find(name);
   if (result == _services.end())
     log_fatal(_("Could not find service: %s"), name.c_str());
 
-  service* removed = result->second;
+  service* service = result->second;
   _services.erase(result);
   log_info(_("Removed service: %s"), name.c_str());
-  return removed;
+  return service;
 }
 
 service& core::get_service(const std::string& name) const
 {
-  map<string, service*>::const_iterator result = _services.find(name);
+  services::const_iterator result = _services.find(name);
   if (result == _services.end())
     log_fatal(_("Could not find service: %s"), name.c_str());
 
@@ -403,10 +399,10 @@
   return _services.size();
 }
 
-void core::add_log(const std::string& name, log* new_log)
+void core::add_log(const std::string& name, log* log)
 {
-  pair<map<string, log*>::iterator, bool> result;
-  result = _logs.insert(pair<string, log*>(name, new_log));
+  pair<logs::iterator, bool> result;
+  result = _logs.insert(pair<string, kernel::log*>(name, log));
   if (result.second == false)
     log_fatal(_("Log already exists: %s"), name.c_str());
 
@@ -415,19 +411,19 @@
 
 log* core::remove_log(const std::string& name)
 {
-  map<string, log*>::iterator result = _logs.find(name);
+  logs::iterator result = _logs.find(name);
   if (result == _logs.end())
     log_fatal(_("Could not find log: %s"), name.c_str());
 
-  log* removed = result->second;
+  log* log = result->second;
   _logs.erase(result);
   log_info(_("Removed log: %s"), name.c_str());
-  return removed;
+  return log;
 }
 
 log& core::get_log(const std::string& name) const
 {
-  map<string, log*>::const_iterator result = _logs.find(name);
+  logs::const_iterator result = _logs.find(name);
   if (result == _logs.end())
     log_fatal(_("Could not find log: %s"), name.c_str());
 
@@ -496,7 +492,7 @@
 
 const string& core::_get_alias(const std::string& name) const
 {
-  for (map<string, string>::const_iterator alias = _aliases.begin();
+  for (aliases::const_iterator alias = _aliases.begin();
        alias != _aliases.end();
        ++alias)
   {
@@ -514,20 +510,20 @@
    * bind2nd, and that has the reference-to-reference problem with some
    * implementations when used with methods that take a reference.
    */
-  for (vector<module*>::const_iterator current = _modules.begin();
-       current != _modules.end();
-       ++current)
+  for (modules::const_iterator module = _modules.begin();
+       module != _modules.end();
+       ++module)
   {
-    if (!strcasecmp((*current)->get_name().c_str(), name.c_str()))
-      return *current;
+    if (!strcasecmp((*module)->get_name().c_str(), name.c_str()))
+      return *module;
   }
 
-  for (vector<module*>::const_iterator current = _add_modules.begin();
-       current != _add_modules.end();
-       ++current)
+  for (modules::const_iterator module = _add_modules.begin();
+       module != _add_modules.end();
+       ++module)
   {
-    if (!strcasecmp((*current)->get_name().c_str(), name.c_str()))
-      return *current;
+    if (!strcasecmp((*module)->get_name().c_str(), name.c_str()))
+      return *module;
   }
 
   return NULL;
@@ -555,11 +551,11 @@
   char message[SCALESTACK_MAX_MESSAGE_SIZE];
   vsnprintf(message, SCALESTACK_MAX_MESSAGE_SIZE, format, arguments);
 
-  for (map<string, log*>::const_iterator current = _logs.begin();
-       current != _logs.end();
-       ++current)
+  for (logs::const_iterator log = _logs.begin();
+       log != _logs.end();
+       ++log)
   {
-    current->second->write_log(log_level, context, message);
+    log->second->write_log(log_level, context, message);
   }
 
   if (log_level == log::LEVEL_FATAL)
@@ -569,7 +565,7 @@
 void core::_print_help(void)
 {
   cout << endl << PACKAGE_STRING << endl << _("\n\
-Kernel\n\
+kernel\n\
   v - Increase verbosity level.\n\
   h, help - Display this help message.\n\
   p, path=PATH - Add path to module search list.\n\
@@ -579,28 +575,28 @@
   for_each(_modules.begin(), _modules.end(), mem_fun(&module::_print_help));
 
   cout << _("\n\
-Modules can be loaded by simply giving the module name as an\n\
-option. For example, if you run 'scalestack echo', this will load\n\
-the echo module and any dependencies.\n\
+Modules can be loaded by simply giving the module name as an option. For\n\
+example, if you run 'scalestack echo::server::tcp', this will load the TCP\n\
+echo server module and any dependencies.\n\
 \n\
 Module aliases may be specified using the format:\n\
 \n\
   module_alias=module_name\n\
 \n\
-For example, if you run 'scalestack event_service=event_libevent', the\n\
-module 'event_libevent' will be loaded if any other modules depend\n\
-on 'event_service'. This allows a generic service name to be listed\n\
-as a dependency when there are multiple modules that could provide\n\
-that service.\n\
+For example, if you run 'scalestack event::service=event::libevent', the\n\
+module 'event::libevent' will be loaded if any other modules depend on\n\
+'event::service'. This allows a generic service name to be listed as a\n\
+dependency when there are multiple modules that can provide that service.\n\
 \n\
-module options are specified using the format\n\
+Module options are specified using the format\n\
 \n\
   module_name.option[=value]\n\
 \n\
-For example, if you run 'scalestack echo_server.ports=4321', the\n\
-echo_server module will be loaded and will be run on port '4321'. For\n\
-boolean options, you can specify 'false', 'f', 'no', 'n', or '0' to\n\
-mean false using any case. Everything else will be treated as true.\n\
+For example, if you run 'scalestack echo::server::tcp.ports=4321', the\n\
+echo::server::tcp module will be loaded and will be run on port '4321'. For\n\
+boolean options, you can specify 'false', 'f', 'no', 'n', or '0' to mean\n\
+false using any mix of upper and lower case. Everything else will be treated\n\
+as true.\n\
 \n");
 }
 

=== modified file 'scalestack/kernel/core.h'
--- scalestack/kernel/core.h	2010-06-03 04:51:37 +0000
+++ scalestack/kernel/core.h	2010-06-16 19:32:28 +0000
@@ -55,6 +55,9 @@
    */
   ~core();
 
+  /* This is here to make the base method public. */
+  using log_message::set_threshold;
+
   /**
    * Parse arguments, most likely from the main() function arguments.
    *
@@ -80,14 +83,6 @@
                                const std::string& value);
 
   /**
-   * Set the log threshold for kernel logs. This is also set by passing 'v'
-   * or 'verbose' arguments into parse_arguments().
-   *
-   * @param[in] log_threshold The new log threshold to set.
-   */
-  void set_log_threshold(size_t log_threshold);
-
-  /**
    * Set common signal handlers. Calling applications can either use this for
    * convenience or handle their own signals. SIGPIPE is set to be ignored,
    * and the following signals are set to call the given handler function:
@@ -159,9 +154,9 @@
    * already exists, this will fail and return false.
    *
    * @param[in] name Name of the service to add.
-   * @param[in] new_service The service object to add.
+   * @param[in] service The service object to add.
    */
-  void add_service(const std::string& name, service* new_service);
+  void add_service(const std::string& name, service* service);
 
   /**
    * Remove a service object for the given name.
@@ -189,9 +184,9 @@
    * exists, this will fail and return false.
    *
    * @param[in] name Name of the log to add.
-   * @param[in] new_log The log object to add.
+   * @param[in] log The log object to add.
    */
-  void add_log(const std::string& name, log* new_log);
+  void add_log(const std::string& name, log* log);
 
   /**
    * Remove a log object for the given name.
@@ -302,17 +297,23 @@
   SCALESTACK_LOCAL
   void _print_help(void);
 
+  typedef std::vector<std::string> paths;
+  typedef std::vector<module*> modules;
+  typedef std::map<std::string, std::string> aliases;
+  typedef std::map<std::string, service*> services;
+  typedef std::map<std::string, log*> logs;
+
   bool _need_help;
   bool _shutdown_request;
   bool _iterator_on_modules;
   common::notification _run_notification;
-  std::vector<std::string> _paths;
-  std::vector<module*> _modules;
-  std::vector<module*> _add_modules;
-  std::vector<module*>::iterator _module_iterator;
-  std::map<std::string, std::string> _aliases;
-  std::map<std::string, service*> _services;
-  std::map<std::string, log*> _logs;
+  paths _paths;
+  modules _modules;
+  modules _add_modules;
+  modules::iterator _module_iterator;
+  aliases _aliases;
+  services _services;
+  logs _logs;
 };
 
 } /* namespace kernel */

=== modified file 'scalestack/kernel/log.h'
--- scalestack/kernel/log.h	2010-06-03 04:51:37 +0000
+++ scalestack/kernel/log.h	2010-06-16 19:32:28 +0000
@@ -53,14 +53,14 @@
    * @param[in] context Context string for this message.
    * @param[in] message Message to log.
    */
-  virtual void write_log(level log_level,
+  virtual void write_log(log::level log_level,
                          const char* context,
                          const char* message) = 0;
 
   /**
    * Get the string representation for a givel log level.
    */
-  const char* get_level_string(level log_level);
+  const char* get_level_string(log::level log_level);
 
 private:
 
@@ -87,7 +87,7 @@
 {
 }
 
-inline const char* log::get_level_string(level log_level)
+inline const char* log::get_level_string(log::level log_level)
 {
   switch (log_level)
   {

=== modified file 'scalestack/kernel/log_console.h'
--- scalestack/kernel/log_console.h	2010-06-03 04:51:37 +0000
+++ scalestack/kernel/log_console.h	2010-06-16 19:32:28 +0000
@@ -40,7 +40,9 @@
    * @param[in] context Context string for this message.
    * @param[in] message Message to log.
    */
-  void write_log(level log_level, const char* context, const char* message);
+  void write_log(log::level log_level,
+                 const char* context,
+                 const char* message);
 
 private:
 

=== modified file 'scalestack/kernel/log_message.h'
--- scalestack/kernel/log_message.h	2010-06-03 04:51:37 +0000
+++ scalestack/kernel/log_message.h	2010-06-16 19:32:28 +0000
@@ -33,11 +33,18 @@
 {
 public:
 
-  log_message(size_t log_threshold);
+  log_message(size_t threshold);
 
   virtual ~log_message();
 
   /**
+   * Set the threshold for logging messages.
+   *
+   * @param[in] threshold The new log threshold to set.
+   */
+  void set_threshold(size_t threshold);
+
+  /**
    * Log a fatal message with the formatted string if log threshold is met.
    *
    * @param[in] format Message format string.
@@ -74,7 +81,7 @@
 
 protected:
 
-  size_t _log_threshold;
+  size_t _threshold;
 
 private:
 
@@ -114,8 +121,8 @@
  * Public methods.
  */
 
-inline log_message::log_message(size_t log_threshold):
-  _log_threshold(log_threshold)
+inline log_message::log_message(size_t threshold):
+  _threshold(threshold)
 {
 }
 
@@ -123,6 +130,11 @@
 {
 }
 
+inline void log_message::set_threshold(size_t threshold)
+{
+  _threshold = threshold;
+}
+
 inline void log_message::log_fatal(const char* format, ...) const
 {
   std::va_list arguments;
@@ -135,7 +147,7 @@
    */
   try
   {
-    if (_log_threshold >= 1)
+    if (_threshold >= 1)
       _log_message(log::LEVEL_FATAL, format, arguments);
     else
       _set_fatal_message(format, arguments);
@@ -151,7 +163,7 @@
 
 inline void log_message::log_error(const char* format, ...) const
 {
-  if (_log_threshold >= 1)
+  if (_threshold >= 1)
   {
     std::va_list arguments;
     va_start(arguments, format);
@@ -162,7 +174,7 @@
 
 inline void log_message::log_notice(const char* format, ...) const
 {
-  if (_log_threshold >= 1)
+  if (_threshold >= 1)
   {
     std::va_list arguments;
     va_start(arguments, format);
@@ -173,7 +185,7 @@
 
 inline void log_message::log_info(const char* format, ...) const
 {
-  if (_log_threshold >= 2)
+  if (_threshold >= 2)
   {
     std::va_list arguments;
     va_start(arguments, format);
@@ -184,7 +196,7 @@
 
 inline void log_message::log_debug(const char* format, ...) const
 {
-  if (_log_threshold >= 3)
+  if (_threshold >= 3)
   {
     std::va_list arguments;
     va_start(arguments, format);

=== modified file 'scalestack/kernel/module.cc'
--- scalestack/kernel/module.cc	2010-06-03 04:51:37 +0000
+++ scalestack/kernel/module.cc	2010-06-16 19:32:28 +0000
@@ -143,25 +143,25 @@
                            const std::string& value_name,
                            const std::string& default_value)
 {
-  option& current = _get_or_add_option(name);
-  if (current.is_valid())
+  option& option = _get_or_add_option(name);
+  if (option.is_valid())
     log_fatal(_("Duplicate option added: %s"), name.c_str());
 
-  current._set_help(help);
-  current._set_value_name(value_name);
-  current._set_default_value(default_value);
-  current._set_value(default_value, false);
-  current._set_valid(true);
-  return current;
+  option._set_help(help);
+  option._set_value_name(value_name);
+  option._set_default_value(default_value);
+  option._set_value(default_value, false);
+  option._set_valid(true);
+  return option;
 }
 
 option& module::get_option(const std::string& name) const
 {
-  option* current = _get_option(name);
-  if (current == NULL)
+  option* option = _get_option(name);
+  if (option == NULL)
     log_fatal(_("Could not find option: %s"), name.c_str());
 
-  return *current;
+  return *option;
 }
 
 size_t module::get_option_count(void) const
@@ -187,13 +187,13 @@
  * Private methods.
  */
 
-module::module(core& creator, const std::string& name, size_t log_threshold):
-  log_message(log_threshold),
+module::module(core& core, const std::string& name, size_t threshold):
+  log_message(threshold),
   _is_loading(false),
   _is_started(false),
   _need_run(true),
   _need_reconfigure(true),
-  _core(creator),
+  _core(core),
   _handle(),
   _definition(),
   _name(name),
@@ -263,7 +263,7 @@
       filename.push_back(static_cast<char>(tolower(*c)));
   }
 
-  vector<string>::const_iterator path;
+  core::paths::const_iterator path;
   for (path = _core._paths.begin(); path != _core._paths.end(); ++path)
   {
     _pathname = *(path) + "/lib" + filename + "_module." + SCALESTACK_MODULE_EXT;
@@ -274,8 +274,8 @@
     if (stat_return == 0)
       break;
     else if (stat_return == -1 && errno != ENOENT)
-      log_fatal(_("Could not stat() pathname: %s (%s)"),
-                _pathname.c_str(), strerror(errno));
+      log_fatal(_("Could not stat() pathname: %s (%s:%d)"),
+                _pathname.c_str(), strerror(errno), errno);
   }
 
   if (path == _core._paths.end())
@@ -405,12 +405,12 @@
    * bind2nd, and that has the reference-to-reference problem with some
    * implementations when used with methods that take a reference.
    */
-  for (vector<option*>::const_iterator current = _options.begin();
-       current != _options.end();
-       ++current)
+  for (options::const_iterator option = _options.begin();
+       option != _options.end();
+       ++option)
   {
-    if (!strcasecmp((*current)->get_name().c_str(), name.c_str()))
-      return *current;
+    if (!strcasecmp((*option)->get_name().c_str(), name.c_str()))
+      return *option;
   }
 
   return NULL;
@@ -418,37 +418,37 @@
 
 option& module::_get_or_add_option(const std::string& name)
 {
-  option* current = _get_option(name);
-  if (current != NULL)
-    return *current;
+  option* option = _get_option(name);
+  if (option != NULL)
+    return *option;
 
-  current = new option(*this, name);
+  option = new kernel::option(*this, name);
   try
   {
-    _options.push_back(current);
+    _options.push_back(option);
   }
   catch (exception&)
   {
-    delete current;
+    delete option;
     throw;
   }
 
-  return *current;
+  return *option;
 }
 
 void module::_set_option_value(const std::string& name, const std::string& value)
 {
-  option& current = _get_or_add_option(name);
-  current._set_value(value, true);
+  option& option = _get_or_add_option(name);
+  option._set_value(value, true);
 }
 
 void module::_check_options(void) const
 {
-  vector<option*>::const_iterator current = find_if(_options.begin(),
-                                                    _options.end(),
-                                                    not1(mem_fun(&option::is_valid)));
-  if (current != _options.end())
-    log_fatal(_("Invalid option: %s"), (*current)->get_name().c_str());
+  options::const_iterator option = find_if(_options.begin(),
+                                           _options.end(),
+                                           not1(mem_fun(&option::is_valid)));
+  if (option != _options.end())
+    log_fatal(_("Invalid option: %s"), (*option)->get_name().c_str());
 }
 
 void module::_set_fatal_message(const char* format, std::va_list arguments) const

=== modified file 'scalestack/kernel/module.h'
--- scalestack/kernel/module.h	2010-06-03 04:51:37 +0000
+++ scalestack/kernel/module.h	2010-06-16 19:32:28 +0000
@@ -37,8 +37,6 @@
  */
 class SCALESTACK_API module: public log_message
 {
-  friend class core;
-
 public:
 
   /**
@@ -64,6 +62,9 @@
 
   ~module();
 
+  /* This is here to make the base method public. */
+  using log_message::set_threshold;
+
   /**
    * Get the Core object that this module belongs to.
    */
@@ -202,12 +203,12 @@
    * Construct a module instance. This is private because only Core, which
    * is listed as a friend, can construct modules.
    *
-   * @param[in] creator Core that created this module.
+   * @param[in] core Core that created this module.
    * @param[in] name Name of module to create.
-   * @param[in] log_threshold Logging threshold.
+   * @param[in] threshold Logging threshold.
    */
   SCALESTACK_LOCAL
-  module(core& creator, const std::string& name, size_t log_threshold);
+  module(core& core, const std::string& name, size_t threshold);
 
   /**
    * Don't allow copying of objects.
@@ -344,6 +345,9 @@
   SCALESTACK_LOCAL
   void _print_help(void);
 
+  typedef std::vector<module*> modules;
+  typedef std::vector<option*> options;
+
   bool _is_loading;
   bool _is_started;
   bool _need_run;
@@ -358,12 +362,14 @@
   std::string _title;
   std::string _license;
   std::string _dependencies;
-  std::vector<module*> _parents;
-  std::vector<module*>::iterator _parent_iterator;
-  std::vector<module*> _children;
-  std::vector<module*>::iterator _child_iterator;
-  std::vector<option*> _options;
-  std::vector<option*>::iterator _option_iterator;
+  modules _parents;
+  modules::iterator _parent_iterator;
+  modules _children;
+  modules::iterator _child_iterator;
+  options _options;
+  options::iterator _option_iterator;
+
+  friend class core;
 };
 
 } /* namespace kernel */

=== modified file 'scalestack/kernel/option.cc'
--- scalestack/kernel/option.cc	2010-06-03 04:51:37 +0000
+++ scalestack/kernel/option.cc	2010-06-16 19:32:28 +0000
@@ -137,10 +137,10 @@
  * Private methods.
  */
 
-option::option(module& creator, const std::string& name):
+option::option(module& module, const std::string& name):
   _is_valid(false),
   _is_set(false),
-  _module(creator),
+  _module(module),
   _name(name),
   _help(),
   _value_name(),

=== modified file 'scalestack/kernel/option.h'
--- scalestack/kernel/option.h	2010-06-03 20:51:05 +0000
+++ scalestack/kernel/option.h	2010-06-16 19:32:28 +0000
@@ -35,8 +35,6 @@
  */
 class SCALESTACK_API option
 {
-  friend class module;
-
 public:
 
   ~option();
@@ -109,11 +107,11 @@
   /**
    * Construct an option instance.
    *
-   * @param[in] creator Module that created this module.
+   * @param[in] module Module that created this option.
    * @param[in] name Name of option to create.
    */
   SCALESTACK_LOCAL
-  option(module& creator, const std::string& name);
+  option(module& module, const std::string& name);
 
   /**
    * Don't allow copying of objects.
@@ -171,6 +169,8 @@
   std::string _value_name;
   std::string _default_value;
   std::string _value;
+
+  friend class module;
 };
 
 } /* namespace kernel */

=== modified file 'scalestack/kernel/service.h'
--- scalestack/kernel/service.h	2010-06-03 04:51:37 +0000
+++ scalestack/kernel/service.h	2010-06-16 19:32:28 +0000
@@ -34,18 +34,18 @@
 {
 public:
 
-  service(module& creator);
+  service(kernel::module& module);
 
   virtual ~service();
 
   /**
    * Get the module associated with this service.
    */
-  module& get_module(void);
+  kernel::module& get_module(void);
 
 protected:
 
-  module& _module;
+  kernel::module& _module;
 
 private:
 
@@ -64,7 +64,7 @@
  * Public methods.
  */
 
-inline service::service(module& creator):
+inline service::service(kernel::module& creator):
   _module(creator)
 {
 }
@@ -73,7 +73,7 @@
 {
 }
 
-inline module& service::get_module(void)
+inline kernel::module& service::get_module(void)
 {
   return _module;
 }

=== modified file 'scalestack/kernel/test/module.cc'
--- scalestack/kernel/test/module.cc	2010-06-03 04:51:37 +0000
+++ scalestack/kernel/test/module.cc	2010-06-16 19:32:28 +0000
@@ -57,7 +57,10 @@
 
 TEST_BEGIN(get_option)
   kernel::module& module = core.get_or_add_module("module");
-  kernel::option& option = module.add_option("option", "Help", "VALUE_NAME", "default_value");
+  kernel::option& option = module.add_option("option",
+                                             "Help",
+                                             "VALUE_NAME",
+                                             "default_value");
   assert(&module.get_option("option") == &option);
   TEST_EXCEPTION(module.get_option("Bad_option"));
 TEST_END
@@ -76,11 +79,17 @@
   assert(module.begin_option() == NULL);
   assert(module.next_option() == NULL);
 
-  kernel::option& option = module.add_option("option", "Help", "VALUE_NAME", "default_value");
+  kernel::option& option = module.add_option("option",
+                                             "Help",
+                                             "VALUE_NAME",
+                                             "default_value");
   assert(module.begin_option() == &option);
   assert(module.next_option() == NULL);
 
-  kernel::option& option2 = module.add_option("option2", "Help", "VALUE_NAME", "default_value");
+  kernel::option& option2 = module.add_option("option2",
+                                              "Help",
+                                              "VALUE_NAME",
+                                              "default_value");
   assert(module.begin_option() == &option);
   assert(module.next_option() == &option2);
   assert(module.next_option() == NULL);

=== modified file 'scalestack/kernel/test/option.cc'
--- scalestack/kernel/test/option.cc	2010-06-03 04:51:37 +0000
+++ scalestack/kernel/test/option.cc	2010-06-16 19:32:28 +0000
@@ -48,7 +48,10 @@
 
 TEST_BEGIN(constructor_value)
   kernel::module& module = core.get_or_add_module("module");
-  kernel::option& option = module.add_option("option", "Help", "VALUE_NAME", "default_value");
+  kernel::option& option = module.add_option("option",
+                                             "Help",
+                                             "VALUE_NAME",
+                                             "default_value");
   assert(&option.get_module() == &module);
   assert(option.get_name() == "option");
   assert(option.get_help() == "Help");

=== modified file 'scalestack/network/datagram.cc'
--- scalestack/network/datagram.cc	2010-06-03 04:51:37 +0000
+++ scalestack/network/datagram.cc	2010-06-16 19:32:28 +0000
@@ -35,8 +35,8 @@
  * Public methods.
  */
 
-datagram_provider::datagram_provider(event::service& creator):
-  event::handler(creator),
+datagram_provider::datagram_provider(event::handler_service& handler_service):
+  event::handler(handler_service),
   _file_descriptor(-1),
   _peer_size(),
   _receive_buffer_size(),

=== modified file 'scalestack/network/datagram.h'
--- scalestack/network/datagram.h	2010-06-03 20:51:05 +0000
+++ scalestack/network/datagram.h	2010-06-16 19:32:28 +0000
@@ -47,7 +47,7 @@
 
 public:
 
-  datagram(datagram_service& creator);
+  datagram(datagram_service& datagram_service);
 
   virtual ~datagram();
 
@@ -178,7 +178,7 @@
 {
 public:
 
-  datagram_provider(event::service& service);
+  datagram_provider(event::handler_service& handler_service);
 
   virtual ~datagram_provider();
 
@@ -333,9 +333,9 @@
  * Public datagram methods.
  */
 
-inline datagram::datagram(datagram_service& creator):
-  _module(creator.get_module()),
-  _service(creator),
+inline datagram::datagram(datagram_service& datagram_service):
+  _module(datagram_service.get_module()),
+  _service(datagram_service),
   _datagram_provider(NULL)
 {
 }

=== modified file 'scalestack/network/datagram_service.h'
--- scalestack/network/datagram_service.h	2010-06-03 04:51:37 +0000
+++ scalestack/network/datagram_service.h	2010-06-16 19:32:28 +0000
@@ -17,7 +17,7 @@
 #define SCALESTACK_NETWORK_DATAGRAM_SERVICE_H
 
 #include <scalestack/common/macros.h>
-#include <scalestack/event/service.h>
+#include <scalestack/event/handler_service.h>
 
 namespace scalestack
 {
@@ -26,11 +26,11 @@
 
 class datagram;
 
-class SCALESTACK_API datagram_service: public event::service
+class SCALESTACK_API datagram_service: public event::handler_service
 {
 public:
 
-  datagram_service(kernel::module& creator);
+  datagram_service(kernel::module& module);
 
   virtual ~datagram_service();
 
@@ -67,8 +67,8 @@
  * Public methods.
  */
 
-inline datagram_service::datagram_service(kernel::module& creator):
-  event::service(creator)
+inline datagram_service::datagram_service(kernel::module& module):
+  event::handler_service(module)
 {
 }
 

=== modified file 'scalestack/network/ip/tcp/listener_service.cc'
--- scalestack/network/ip/tcp/listener_service.cc	2010-06-03 04:51:37 +0000
+++ scalestack/network/ip/tcp/listener_service.cc	2010-06-16 19:32:28 +0000
@@ -56,9 +56,9 @@
  * Public methods.
  */
 
-listener_service::listener_service(kernel::module& creator,
-                                   connection_service& associated_connection_service):
-  event::service(creator),
+listener_service::listener_service(kernel::module& module,
+                                   connection_service& connection_service):
+  event::handler_service(module),
   network::ip::common()
 {
   vector<pair<string,string> > hosts = _module.get_option("hosts").get_host_list_value();
@@ -76,11 +76,11 @@
              port != ports.end();
              ++port)
         {
-          _add_listeners(associated_connection_service, host->first, *port);
+          _add_listeners(connection_service, host->first, *port);
         }
       }
       else
-        _add_listeners(associated_connection_service, host->first, host->second);
+        _add_listeners(connection_service, host->first, host->second);
     }
   }
   catch (exception&)
@@ -99,7 +99,7 @@
  * Private methods.
  */
 
-void listener_service::_add_listeners(connection_service& associated_connection_service,
+void listener_service::_add_listeners(connection_service& connection_service,
                                       std::string host,
                                       std::string port)
 {
@@ -130,7 +130,7 @@
   {
     try
     {
-      new listener(*this, associated_connection_service, addrinfo);
+      new listener(*this, connection_service, addrinfo);
       added = true;
     }
     catch (exception&)

=== modified file 'scalestack/network/ip/tcp/listener_service.h'
--- scalestack/network/ip/tcp/listener_service.h	2010-06-03 04:51:37 +0000
+++ scalestack/network/ip/tcp/listener_service.h	2010-06-16 19:32:28 +0000
@@ -18,7 +18,7 @@
 
 #include <string>
 
-#include <scalestack/event/service.h>
+#include <scalestack/event/handler_service.h>
 #include <scalestack/network/ip/common.h>
 
 namespace scalestack
@@ -42,13 +42,13 @@
 SCALESTACK_API
 void listener_options(kernel::module& creator, const char* port);
 
-class SCALESTACK_API listener_service: public event::service,
+class SCALESTACK_API listener_service: public event::handler_service,
                                        public network::ip::common
 {
 public:
 
-  listener_service(kernel::module& creator,
-                   connection_service& associated_connection_service);
+  listener_service(kernel::module& module,
+                   connection_service& connection_service);
 
   ~listener_service();
 

=== modified file 'scalestack/network/listener.cc'
--- scalestack/network/listener.cc	2010-06-03 04:51:37 +0000
+++ scalestack/network/listener.cc	2010-06-16 19:32:28 +0000
@@ -37,11 +37,11 @@
  * Public methods.
  */
 
-listener::listener(event::service& creator,
-                   stream_service& associated_stream_service):
-  event::handler(creator),
+listener::listener(event::handler_service& handler_service,
+                   stream_service& stream_service):
+  event::handler(handler_service),
   _file_descriptor(-1),
-  _stream_service(associated_stream_service)
+  _stream_service(stream_service)
 {
   _module.log_info(_("Listener constructed"));
 }
@@ -96,7 +96,7 @@
 
   try
   {
-    _service.add_handler(this);
+    _handler_service.add_handler(this);
     set_file_descriptor(_file_descriptor);
     watch_read();
   }

=== modified file 'scalestack/network/listener.h'
--- scalestack/network/listener.h	2010-06-03 20:51:05 +0000
+++ scalestack/network/listener.h	2010-06-16 19:32:28 +0000
@@ -35,11 +35,12 @@
   /**
    * Constructor, setup associated services.
    *
-   * @param[in] creator Service this listener is associated with.
-   * @param[in] associated_stream_service Service this listener should add
-   *  streams to when it accepts new streams.
+   * @param[in] handler_service Service this listener is associated with.
+   * @param[in] stream_service Service this listener should add streams to
+   *  when it accepts new streams.
    */
-  listener(event::service& creator, stream_service& associated_stream_service);
+  listener(event::handler_service& handler_service,
+           stream_service& stream_service);
 
   virtual ~listener();
 

=== modified file 'scalestack/network/local/stream/listener_service.cc'
--- scalestack/network/local/stream/listener_service.cc	2010-06-03 04:51:37 +0000
+++ scalestack/network/local/stream/listener_service.cc	2010-06-16 19:32:28 +0000
@@ -55,12 +55,12 @@
  * Public methods.
  */
 
-listener_service::listener_service(kernel::module& creator,
-                                   connection_service& associated_connection_service):
-  event::service(creator),
+listener_service::listener_service(kernel::module& module,
+                                   connection_service& connection_service):
+  event::handler_service(module),
   network::local::common()
 {
-  vector<string> local_sockets = creator.get_option("local_sockets").get_list_value();
+  vector<string> local_sockets = module.get_option("local_sockets").get_list_value();
 
   try
   {
@@ -70,7 +70,7 @@
     {
       if (*local_socket != "")
       {
-        _add_listener(associated_connection_service, *local_socket);
+        _add_listener(connection_service, *local_socket);
       }
     }
   }

=== modified file 'scalestack/network/local/stream/listener_service.h'
--- scalestack/network/local/stream/listener_service.h	2010-06-03 04:51:37 +0000
+++ scalestack/network/local/stream/listener_service.h	2010-06-16 19:32:28 +0000
@@ -18,7 +18,7 @@
 
 #include <string>
 
-#include <scalestack/event/service.h>
+#include <scalestack/event/handler_service.h>
 #include <scalestack/network/local/common.h>
 
 namespace scalestack
@@ -36,13 +36,13 @@
 /**
  * Add common options for Connection listen sockets.
  *
- * @param[in] creator Module that the service is associated with.
+ * @param[in] module Module that the service is associated with.
  * @param[in] port Default port to use.
  */
 SCALESTACK_API
-void listener_options(kernel::module& creator, const char* port);
+void listener_options(kernel::module& module, const char* port);
 
-class SCALESTACK_API listener_service: public event::service,
+class SCALESTACK_API listener_service: public event::handler_service,
                                        public network::local::common
 {
 public:

=== modified file 'scalestack/network/stream.cc'
--- scalestack/network/stream.cc	2010-06-03 04:51:37 +0000
+++ scalestack/network/stream.cc	2010-06-16 19:32:28 +0000
@@ -35,8 +35,8 @@
  * Public methods.
  */
 
-stream_provider::stream_provider(event::service& creator):
-  event::handler(creator),
+stream_provider::stream_provider(event::handler_service& handler_service):
+  event::handler(handler_service),
   _address_list(NULL),
   _current_address(NULL),
   _connecting(false),

=== modified file 'scalestack/network/stream.h'
--- scalestack/network/stream.h	2010-06-03 04:51:37 +0000
+++ scalestack/network/stream.h	2010-06-16 19:32:28 +0000
@@ -47,7 +47,7 @@
 
 public:
 
-  stream(stream_service& creator);
+  stream(stream_service& stream_service);
 
   virtual ~stream();
 
@@ -179,7 +179,7 @@
 {
 public:
 
-  stream_provider(event::service& creator);
+  stream_provider(event::handler_service& handler_service);
 
   virtual ~stream_provider();
 
@@ -358,9 +358,9 @@
  * Public stream methods.
  */
 
-inline stream::stream(stream_service& creator):
-  _module(creator.get_module()),
-  _service(creator),
+inline stream::stream(stream_service& stream_service):
+  _module(stream_service.get_module()),
+  _service(stream_service),
   _stream_provider(NULL)
 {
 }

=== modified file 'scalestack/network/stream_service.h'
--- scalestack/network/stream_service.h	2010-06-03 20:51:05 +0000
+++ scalestack/network/stream_service.h	2010-06-16 19:32:28 +0000
@@ -20,7 +20,7 @@
 #include <sys/types.h>
 
 #include <scalestack/common/macros.h>
-#include <scalestack/event/service.h>
+#include <scalestack/event/handler_service.h>
 
 namespace scalestack
 {
@@ -29,11 +29,11 @@
 
 class stream;
 
-class SCALESTACK_API stream_service: public event::service
+class SCALESTACK_API stream_service: public event::handler_service
 {
 public:
 
-  stream_service(kernel::module& creator);
+  stream_service(kernel::module& module);
 
   virtual ~stream_service();
 
@@ -82,8 +82,8 @@
  * Public methods.
  */
 
-inline stream_service::stream_service(kernel::module& creator):
-  event::service(creator)
+inline stream_service::stream_service(kernel::module& module):
+  event::handler_service(module)
 {
 }