serf 0.2.0.alpha1 → 0.3.0

data/Gemfile

@@ -3,9 +3,12 @@ source 'http://rubygems.org'
 # Example:
 #   gem 'activesupport', '>= 2.3.5'
 
+# Requirements for both clients and servers.
 gem 'activemodel', '~> 3.1.3'
 gem 'activesupport', '~> 3.1.3'
-gem 'eventmachine', '~> 0.12.10'
+gem 'i18n', '~> 0.6.0' # For ActiveSupport
+# Used by Serf::Messages::*
+gem 'uuidtools', '~> 2.1.2'
 
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.
@@ -20,4 +23,7 @@ group :development, :test do
   #gem 'log4r', '~> 1.1.9'
   gem 'msgpack', '~> 0.4.6'
   #gem 'multi_json', '~> 1.0.3'
+
+  # For Server Side of things
+  gem 'eventmachine', '~> 0.12.10'
 end

data/Gemfile.lock

@@ -28,6 +28,7 @@ GEM
     rspec-expectations (2.3.0)
       diff-lcs (~> 1.1.2)
     rspec-mocks (2.3.0)
+    uuidtools (2.1.2)
     yard (0.6.8)
 
 PLATFORMS
@@ -38,8 +39,10 @@ DEPENDENCIES
   activesupport (~> 3.1.3)
   bundler (~> 1.0.0)
   eventmachine (~> 0.12.10)
+  i18n (~> 0.6.0)
   jeweler (~> 1.6.4)
   msgpack (~> 0.4.6)
   rcov
   rspec (~> 2.3.0)
+  uuidtools (~> 2.1.2)
   yard (~> 0.6.0)

data/README.md

@@ -5,23 +5,190 @@ Serf is a library that scaffolds distributed systems that are architected using
 Event-Driven Service Oriented Architecture design in combinations with
 the Command Query Responsibility Separation pattern.
 
-Middleware
+Philosophy
 ==========
 
-Airbrake
---------
+The underlying idea of Serf is to define a standard Ruby code interface
+that standalone gems can follow to create a business verticals services.
+These gems are intended to run as standalone processes in a distributed
+manner.
 
-You can use Airbrake's middleware to catch exceptions.
+Fundamentally, a service creates an abstraction of:
+1. Messages
+2. Handlers
 
-    # example.su
-    require 'rack'
-    require 'airbrake'
+Messages are the representation of data, documents, etc that are
+marshalled from client to service, which represents the business
+level interaction of the service.
+
+Messages may be commands that a service must handle.
+Messages may be events that a service emits.
+Messages may be documents that represent state or business data.
+
+Handlers are the code that is executed over Messages.
+Handlers may process Command Messages.
+Handlers may process observed Events that 3rd party services emit.
+
+Services SHOULD declare a manifest to map messages to handlers, which
+allows Serf to route messages and to determine blocking or non-blocking modes.
+
+Serf App and Channels
+=====================
+
+A Serf App is a Rack-like application that accepts an ENV hash as input.
+This ENV hash is simply the hash representation of a message to be processed.
+The Serf App, as configured by registered manifests, will:
+1. validate the message
+2. route the message to the proper handler
+3. run the handler in blocking or non-blocking mode.
+4. publish the handler's results to results or error channels.
+  a. These channels are normally message queuing channels.
+  b. We only require the channel instance to respond to the 'publish'
+    method and accept a message (or message hash) as the argument.
+5. return the handler's results to the caller if it is blocking mode.
+  a. In non-blocking mode, an MessageAcceptedEvent is returned instead
+    because the message will be run by the EventMachine deferred threadpool
+    by default.
+
+Not implemented as yet:
+1. Create a message queue listener or web endpoint to accept messages
+  and run them through the built Serf App.
+2. Message Queue channels to route responses to pub/sub locations.
+
+Service Libraries
+=================
+
+1. Service Libraries SHOULD implement message classes that include the
+  ::Serf::Message helper module.
+  a. Barring that, they should conform to the idea that messages may be
+    hashes that define at least one attribute: 'kind'.
+2. Serialization of the messages SHOULD BE Json or MessagePack (I hate XML).
+3. Service Libraries SHOULD implement handler classes that include the
+  ::Serf::Handler helper module.
+4. Handler methods MUST receive a message as an options hash, symbolized keys.
+5. Handler methods MUST return zero or more messages.
+6. Handler methods SHOULD handle catch their business logic exceptions and
+  return them as specialized messages that can be forwarded down error channels.
+  Uncaught exceptions that are then caught by Serf are published as
+  generic Serf::CaughtExceptionEvents, and are harder to deal with.
+
+Example
+=======
+
+    # Require our libraries
+    require 'log4r'
+    require 'serf/handler'
+    require 'serf/message'
+    require 'serf/builder'
+
+    # create a simple logger for this example
+    logger = Log4r::Logger.new 'my_logger'
+    logger.outputters = Log4r::FileOutputter.new(
+      'fileOutputter',
+      filename: 'log.txt')
+
+    # my_lib/my_handler.rb
+    class MyHandler
+      include Serf::Handler
+
+      receives(
+        'my_message',
+        with: :submit_my_message)
+
+      def initialize(options={})
+        @logger = options[:logger]
+      end
+
+      def submit_my_message(message={})
+        @logger.info "In Submit Match Result: #{message.inspect.to_s}"
+        # Do work Here...
+        # And return other messages as results of work, or nil for nothing.
+        return nil
+      end
+
+    end
+
+    # my_lib/my_message.rb
+    class MyMessage
+      include Serf::Message
+
+      attr_accessor :data
+
+      validates_presence_of :data
+
+      def initialize(options={})
+        @hi = options[:data] || 'some data here'
+      end
 
-    Airbrake.configure do |config|
-      config.api_key = 'my_api_key'
     end
 
-    use Airbrake::Rack
+    # my_lib/manifest.rb
+    MANIFEST = {
+      'my_message' => {
+        # Optional Definition of an implementation class.
+        #message_class => 'other_name_space/my_other_message_implementation',
+        # Declares which handler
+        handler: 'my_handler',
+        # Default is true to process in background.
+        async: true
+      }
+    }
+
+    # Helper class for this example to receive result or error messages
+    # and pipe it into our logger.
+    class MyChannel
+      def initialize(name, logger)
+        @name = name
+        @logger = logger
+      end
+      def publish(message)
+        @logger.info "#{@name} #{message}"
+        #@logger.info message
+      end
+    end
+
+    # Create a new builder for this serf app.
+    builder = Serf::Builder.new do
+      # Registers different service libary manifests.
+      register MANIFEST
+      # Can define arguments to pass to the 'my_handler' initialize method.
+      config(
+        'my_handler',
+        logger: logger)
+      # Create result and error channels for the handler result messages.
+      error_channel MyChannel.new('errorchannel: ', logger)
+      results_channel MyChannel.new('resultschannel: ', logger)
+      # We pass in a logger to our Serf code: Serfer and Runners.
+      logger logger
+      # Optionally define a not found handler...
+      # Defaults to raising an ArgumentError, 'Not Found'.
+      #not_found lambda {|x| puts x}
+    end
+    app = builder.to_app
+
+    # Start event machine loop.
+    EM.run do
+      # On the next tick
+      EM.next_tick do
+        logger.info "Start Tick #{Thread.current.object_id}"
+        # This will submit a 'my_message' message (as a hash) to the Serf App.
+        results = app.call('kind' => 'my_message')
+        # Because we declared the 'my_message' kind to be handled async, we
+        # should get a MessageAcceptedEvent as the results.
+        logger.info "In Tick Results: #{results.inspect}"
+        begin
+          # Here, we're going to submit a message that we don't handle.
+          # By default, an exception will be raised.
+          app.call('kind' => 'unhandled_message_kind')
+        rescue => e
+          puts "Caught in Tick: #{e.inspect}"
+        end
+        logger.info "End Tick #{Thread.current.object_id}"
+      end
+      EM.add_timer 2 do
+        EM.stop
+      end
+    end
 
 
 Contributing to serf

data/lib/serf/builder.rb

@@ -1,4 +1,7 @@
 require 'serf/serfer'
+require 'serf/runners/direct_runner'
+require 'serf/runners/em_runner'
+require 'serf/util/null_object'
 
 module Serf
 
@@ -25,13 +28,27 @@ module Serf
       return builder
     end
 
-    def initialize(options={}, &block)
-      @use = []
+    def initialize(app=nil, &block)
+      # Configuration about the routes and apps to run.
       @manifest = {}
       @config = {}
-      @not_found = options[:not_found]
-      @serfer_class = options.fetch(:serfer_class) { ::Serf::Serfer }
-      @serfer_options = options[:serfer_options] || {}
+      @not_found = app
+
+      # Implementing classes of our app
+      # NOTE: runner_class and async_runner_class are only used if actual
+      #   runner instances are omitted in the configuration.
+      @serfer_class = ::Serf::Serfer
+      @serfer_options = {}
+      @runner_class = ::Serf::Runners::DirectRunner
+      @async_runner_class = ::Serf::Runners::EmRunner
+
+      # Utility and messaging channels for our Runners
+      # NOTE: these are only used if the builder needs to instantiage runners.
+      @results_channel = ::Serf::Util::NullObject.new
+      @error_channel = ::Serf::Util::NullObject.new
+      @logger = ::Serf::Util::NullObject.new
+
+      # configure based on a given block.
       instance_eval(&block) if block_given?
     end
 
@@ -39,10 +56,6 @@ module Serf
       self.new(default_app, &block).to_app
     end
 
-    def use(middleware, *args, &block)
-      @use << proc { |app| middleware.new(app, *args, &block) }
-    end
-
     def register(manifest)
       @manifest.merge! manifest
     end
@@ -55,18 +68,42 @@ module Serf
       @not_found = app
     end
 
-    def to_app
-      app = generate_routes
-      return @use.reverse.inject(app) { |a,e| e[a] }
+    def serfer_class(serfer_class)
+      @serfer_class = serfer_class
+    end
+
+    def serfer_class(serfer_options)
+      @serfer_options = serfer_options
+    end
+
+    def runner(runner)
+      @runner = runner
+    end
+
+    def async_runner(runner)
+      @async_runner = runner
+    end
+
+    def results_channel(results_channel)
+      @results_channel = results_channel
+    end
+
+    def error_channel(error_channel)
+      @error_channel = error_channel
     end
 
-    private
+    def logger(logger)
+      @logger = logger
+    end
 
-    def generate_routes
+    def to_app
+      # Our async and sync messages & handlers.
       kinds = {}
       handlers = {}
+      async_kinds = {}
       async_handlers = {}
 
+      # Iterate our manifests to build out handlers and message classes
       @manifest.each do |kind, options|
         # Instantiate our handler with any possible configuration.
         handler_str = options.fetch(:handler)
@@ -74,28 +111,62 @@ module Serf
         args, block = @config.fetch(handler_str) { [[], nil] }
         handler = handler_class.new *args, &block
 
-        # Then put it into the proper map of handlers for either
-        # synchronous or asynchronous processing.
-        async = options.fetch(:async) { true }
-        (async ? async_handlers : handlers)[kind] = handler
-
         # Get the implementing message serialization class.
         # For a given message kind, we may have a different (or nil)
         # implementing class. If nil, then we're not going to try to
         # create a message class to validate before passing to handler.
         message_class = options.fetch(:message_class) { kind }
-        kinds[kind] = message_class && message_class.camelize.constantize
+        message_class = message_class && message_class.camelize.constantize
+
+        # Put handlers and kinds into the proper map of handlers for either
+        # synchronous or asynchronous processing.
+        async = options.fetch(:async) { true }
+        if async
+          async_kinds[kind] = message_class if message_class
+          async_handlers[kind] = handler
+        else
+          kinds[kind] = message_class if message_class
+          handlers[kind] = handler
+        end
       end
 
-      # We create the serfer class to handle all the messages.
-      return @serfer_class.new(
-        @serfer_options.merge(
-          kinds: kinds,
-          handlers: handlers,
-          async_handlers: async_handlers,
-          not_found: @not_found))
-    end
+      # Get or make our runner
+      runner = @runner || @runner_class.new(
+        results_channel: @results_channel,
+        error_channel: @error_channel,
+        logger: @logger)
+
+      # By default, we go to the not_found app.
+      app = @not_found
+
+      # If we have synchronous handlers, insert before not_found app.
+      if handlers.size > 0
+        # create the serfer class to run synchronous handlers
+        app = @serfer_class.new(
+          @serfer_options.merge(
+            kinds: kinds,
+            handlers: handlers,
+            runner: runner,
+            not_found: app))
+      end
 
+      # If we have async handlers, insert before current app stack.
+      if async_handlers.size > 0
+        # Get or make our async wrapper
+        async_runner = @async_runner || @async_runner_class.new(
+          runner: runner,
+          logger: @logger)
+        # create the serfer class to run async handlers
+        app = @serfer_class.new(
+          @serfer_options.merge(
+            kinds: async_kinds,
+            handlers: async_handlers,
+            runner: async_runner,
+            not_found: app))
+      end
+
+      return app
+    end
   end
 
 end

data/lib/serf/error.rb

@@ -0,0 +1,11 @@
+module Serf
+
+  ##
+  # Module used to tag caught exceptions in this library's code to
+  # let clients (of the library) know that said exceptions came from
+  # within this code.
+  #
+  module Error
+  end
+
+end

data/lib/serf/handler.rb

@@ -4,6 +4,8 @@ require 'active_support/core_ext/hash/keys'
 require 'active_support/core_ext/object/blank'
 require 'active_support/ordered_options'
 
+require 'serf/error'
+
 module Serf
 
   module Handler
@@ -37,14 +39,17 @@ module Serf
       #
       def call(env={})
         # Just to stringify the environment keys
-        env = env.dup.stringify_keys
+        env = env.symbolize_keys
         # Make sure a kind was set, and that we can handle it.
-        message_kind = env['kind']
+        message_kind = env[:kind]
         raise ArgumentError, 'No "kind" in call env' if message_kind.blank?
         method = self.class.serf_actions[message_kind]
         raise ArgumentError, "#{message_kind} not found" if method.blank?
         # Now execute the method with the environment parameters
         self.send method, env
+      rescue => e
+        e.extend ::Serf::Error
+        raise e
       end
     end
 

data/lib/serf/message.rb

@@ -19,13 +19,14 @@ module Serf
     included do
       class_attribute :kind
       send 'kind=', self.to_s.tableize.singularize
+      self.include_root_in_json = false
     end
 
     module InstanceMethods
 
       def attributes
         {
-          'kind' => kind
+          :kind => kind
         }
       end
 
@@ -39,6 +40,14 @@ module Serf
 
     end
 
+    module ClassMethods
+
+      def parse(*args)
+        self.new *args
+      end
+
+    end
+
   end
 
 end

data/lib/serf/messages/caught_exception_event.rb

@@ -0,0 +1,46 @@
+require 'serf/message'
+require 'serf/util/uuidable'
+
+module Serf
+module Messages
+
+  ##
+  # An event message to signal that the serf code caught an
+  # exception during the processing of some message, which is
+  # represented by the context field.
+  #
+  # Instances of this class are norminally published to an
+  # error channel for out of band processing/notification.
+  #
+  class CaughtExceptionEvent
+    include ::Serf::Message
+    include ::Serf::Util::Uuidable
+
+    attr_accessor :context
+    attr_accessor :error_message
+    attr_accessor :error_backtrace
+
+    def initialize(options={})
+      @context = options[:context]
+      @error_message = options[:error_message]
+      @error_backtrace = options[:error_backtrace]
+      @uuid = options[:uuid]
+    end
+
+    def attributes
+      {
+        'context' => @context,
+        'error_message' => @error_message,
+        'error_backtrace' => @error_backtrace,
+        'uuid' => uuid
+      }.merge!(super)
+    end
+
+    def to_s
+      attributes.to_s
+    end
+
+  end
+
+end
+end

data/lib/serf/messages/message_accepted_event.rb

@@ -0,0 +1,38 @@
+require 'serf/message'
+require 'serf/util/uuidable'
+
+module Serf
+module Messages
+
+  ##
+  # This event signals that the serf process has accepted a message
+  # for processing at a later time. These events are normally sent
+  # in response to calling clients, which is a separate signal
+  # than any errors given.
+  #
+  class MessageAcceptedEvent
+    include ::Serf::Message
+    include ::Serf::Util::Uuidable
+
+    attr_accessor :message
+
+    def initialize(options={})
+      @message = options[:message]
+      @uuid = options[:uuid]
+    end
+
+    def attributes
+      {
+        'message' => @message,
+        'uuid' => uuid
+      }.merge!(super)
+    end
+
+    def to_s
+      attributes.to_s
+    end
+
+  end
+
+end
+end

data/lib/serf/runners/direct_runner.rb

@@ -0,0 +1,74 @@
+require 'serf/messages/caught_exception_event'
+require 'serf/util/null_object'
+
+module Serf
+module Runners
+
+  ##
+  # Direct runner drives the execution of a handler for given messages.
+  # This class deals with error handling and publishing handler results
+  # to proper error or results channels.
+  #
+  class DirectRunner
+
+    def initialize(options={})
+      # Mandatory, we want both results and error channels.
+      @results_channel = options.fetch(:results_channel)
+      @error_channel = options.fetch(:error_channel)
+
+      # For caught exceptions, we're going to publish an error event
+      # over our error channel. This defines our error event message class.
+      @error_event_class = options.fetch(:error_event_class) {
+        ::Serf::Messages::CaughtExceptionEvent
+      }
+
+      # Our default logger
+      @logger = options.fetch(:logger) { ::Serf::Util::NullObject.new }
+    end
+
+    def run(handler, params)
+      with_error_handling(params) do
+        results = handler.call params
+        publish_results results
+        return results
+      end
+    end
+
+    protected
+
+    ##
+    # Loop over the results and publish them to the results channel.
+    # Any error in publishing individual messages will result in
+    # a log event and an error channel event.
+    def publish_results(results)
+      results = Array(results)
+      results.each do |message|
+        with_error_handling(message) do
+          @results_channel.publish message
+        end
+      end
+      return nil
+    end
+
+    ##
+    # A block wrapper to handle errors when executing a block.
+    #
+    def with_error_handling(context=nil)
+      yield
+    rescue => e
+      error_event = @error_event_class.new(
+        context: context,
+        error_message: e.inspect,
+        error_backtrace: e.backtrace.join("\n"))
+
+      # log the error to our logger, and to our error channel.
+      @logger.error error_event
+      @error_channel.publish error_event
+
+      # We're done, so just return this error.
+      return error_event
+    end
+  end
+
+end
+end

data/lib/serf/runners/em_runner.rb

@@ -0,0 +1,51 @@
+require 'eventmachine'
+
+require 'serf/messages/message_accepted_event'
+
+module Serf
+module Runners
+
+  ##
+  # This runner simply wraps another runner to execute in the
+  # EventMachine deferred threadpool.
+  #
+  # NOTE: Because the Serfer class validates messages before
+  #  sending them to runners (and handlers), this class simply
+  #  responds to the calling client with an 'MessageAcceptedEvent'
+  #  to signal that the message will be processed later.
+  #
+  # Errors caught here will simply be logged. This is because
+  # the wrapped runner *MUST* handle its own errors. If an error
+  # should propagate up here, then it was most likely an error
+  # that occurred in a rescue block... we don't want to complicate
+  # any extra publishing to error channels because that may have
+  # been the cause of the error.
+  #
+  class EmRunner
+
+    def initialize(options={})
+      # Manditory: Need a runner because EmRunner is just a wrapper.
+      @runner = options.fetch(:runner)
+
+      @mae_class = options.fetch(:message_accepted_event_class) {
+        ::Serf::Messages::MessageAcceptedEvent
+      }
+      @evm = options.fetch(:event_machine) { ::EventMachine }
+      @logger = options.fetch(:logger) { ::Serf::Util::NullObject.new }
+    end
+
+    def run(handler, params)
+      @evm.defer(proc do
+        begin
+          @runner.run handler, params
+        rescue => e
+          @logger.error "#{e.inspect}\n\n#{e.backtrace.join("\n")}"
+        end
+      end)
+      return @mae_class.new message: params
+    end
+
+  end
+
+end
+end

data/lib/serf/serfer.rb

@@ -1,78 +1,54 @@
-require 'eventmachine'
-
-require 'serf/util/null_object'
+require 'serf/error'
 
 module Serf
 
-  ##
-  # The Serfer is a rack app endpoint that:
   class Serfer
 
     def initialize(options={})
+      # Manditory, needs a runner.
+      @runner = options.fetch(:runner)
+
       # Options for handling the requests
       @kinds = options[:kinds] || {}
       @handlers = options[:handlers] || {}
-      @async_handlers = options[:async_handlers] || {}
-      @not_found = options[:not_found]
-
-      # Other processing aspects
-      @em = options.fetch(:event_machine) { ::EM }
-      @logger = options.fetch(:logger) { ::Serf::Util::NullObject.new }
+      @not_found = options[:not_found] || proc do
+        raise ArgumentError, 'Handler Not Found'
+      end
     end
 
     ##
     # Rack-like call to handle a message
     #
     def call(env)
-      kind = env['kind']
+      # We normalize by symbolizing the env keys
+      params = env.symbolize_keys
 
-      # Do a message_class validation if we have it listed.
-      # And use the message attributes instead of raw env when passing
-      # to message handler.
-      message_class = @kinds[kind]
-      if message_class
-        message = message_class.new env
-        raise message.errors.full_messages.join('. ') unless message.valid?
-        params = message.attributes
-      else
-        params = env.stringify_keys
-      end
-
-      # Run an asynchronous handler if we have it. 
-      handler = @async_handlers[kind]
+      # Pull the kind out of the env.
+      kind = params[:kind]
+      handler = @handlers[kind]
       if handler
-        @em.defer(proc do
-          begin
-            handler.call params
-          rescue => e
-            @logger.error e
+        # Do a message_class validation if we have it listed.
+        # And use the message attributes instead of raw env when passing
+        # to message handler.
+        message_class = @kinds[kind]
+        if message_class
+          message = message_class.parse params
+          unless message.valid?
+            raise ArgumentError, message.errors.full_messages.join('. ')
           end
-        end)
-        return [
-          202,
-          {
-            'Content-Type' => 'text/plain'
-          },
-          ['Accepted']
-        ]
-      end
-
-      # Run a synchronous handler if we have it. 
-      handler = @handlers[kind]
-      return handler.call(params) if handler
-
-      # run a not found
-      return @not_found.call(params) if @not_found
+          params = message.attributes.symbolize_keys
+        end
 
-      # we can't handle this kind.
-      return [
-        404,
-        {
-          'Content-Type' => 'text/plain',
-          'X-Cascade' => 'pass'
-        },
-        ['Not Found']
-      ]
+        # Let's run the handler
+        return @runner.run(handler, params) if handler
+      else
+        # we can't handle this kind.
+        return @not_found.call env
+      end
+    rescue => e
+      e.extend(::Serf::Error)
+      raise e
     end
   end
+
 end

data/lib/serf/util/uuidable.rb

@@ -0,0 +1,18 @@
+require 'uuidtools'
+
+module Serf
+module Util
+
+  ##
+  # Helper module to include UUIDs as message fields.
+  #
+  module Uuidable
+
+    def uuid
+      @uuid ||= UUIDTools::UUID.random_create.to_s
+    end
+
+  end
+
+end
+end

data/lib/serf/version.rb

@@ -2,9 +2,9 @@ module Serf
 
   module Version
     MAJOR = 0
-    MINOR = 2
+    MINOR = 3
     PATCH = 0
-    BUILD = 'alpha1'
+    BUILD = nil
     STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join '.'
   end
 

data/serf.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "serf"
-  s.version = "0.2.0.alpha1"
+  s.version = "0.3.0"
 
-  s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Benjamin Yu"]
-  s.date = "2011-12-12"
+  s.date = "2011-12-23"
   s.description = "Event-Driven SOA with CQRS"
   s.email = "benjaminlyu@gmail.com"
   s.extra_rdoc_files = [
@@ -27,10 +27,16 @@ Gem::Specification.new do |s|
     "Rakefile",
     "lib/serf.rb",
     "lib/serf/builder.rb",
+    "lib/serf/error.rb",
     "lib/serf/handler.rb",
     "lib/serf/message.rb",
+    "lib/serf/messages/caught_exception_event.rb",
+    "lib/serf/messages/message_accepted_event.rb",
+    "lib/serf/runners/direct_runner.rb",
+    "lib/serf/runners/em_runner.rb",
     "lib/serf/serfer.rb",
     "lib/serf/util/null_object.rb",
+    "lib/serf/util/uuidable.rb",
     "lib/serf/version.rb",
     "serf.gemspec",
     "spec/serf_spec.rb",
@@ -48,34 +54,40 @@ Gem::Specification.new do |s|
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<activemodel>, ["~> 3.1.3"])
       s.add_runtime_dependency(%q<activesupport>, ["~> 3.1.3"])
-      s.add_runtime_dependency(%q<eventmachine>, ["~> 0.12.10"])
+      s.add_runtime_dependency(%q<i18n>, ["~> 0.6.0"])
+      s.add_runtime_dependency(%q<uuidtools>, ["~> 2.1.2"])
       s.add_development_dependency(%q<rspec>, ["~> 2.3.0"])
       s.add_development_dependency(%q<yard>, ["~> 0.6.0"])
       s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
       s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
       s.add_development_dependency(%q<rcov>, [">= 0"])
       s.add_development_dependency(%q<msgpack>, ["~> 0.4.6"])
+      s.add_development_dependency(%q<eventmachine>, ["~> 0.12.10"])
     else
       s.add_dependency(%q<activemodel>, ["~> 3.1.3"])
       s.add_dependency(%q<activesupport>, ["~> 3.1.3"])
-      s.add_dependency(%q<eventmachine>, ["~> 0.12.10"])
+      s.add_dependency(%q<i18n>, ["~> 0.6.0"])
+      s.add_dependency(%q<uuidtools>, ["~> 2.1.2"])
       s.add_dependency(%q<rspec>, ["~> 2.3.0"])
       s.add_dependency(%q<yard>, ["~> 0.6.0"])
       s.add_dependency(%q<bundler>, ["~> 1.0.0"])
       s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
       s.add_dependency(%q<rcov>, [">= 0"])
       s.add_dependency(%q<msgpack>, ["~> 0.4.6"])
+      s.add_dependency(%q<eventmachine>, ["~> 0.12.10"])
     end
   else
     s.add_dependency(%q<activemodel>, ["~> 3.1.3"])
     s.add_dependency(%q<activesupport>, ["~> 3.1.3"])
-    s.add_dependency(%q<eventmachine>, ["~> 0.12.10"])
+    s.add_dependency(%q<i18n>, ["~> 0.6.0"])
+    s.add_dependency(%q<uuidtools>, ["~> 2.1.2"])
     s.add_dependency(%q<rspec>, ["~> 2.3.0"])
     s.add_dependency(%q<yard>, ["~> 0.6.0"])
     s.add_dependency(%q<bundler>, ["~> 1.0.0"])
     s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
     s.add_dependency(%q<rcov>, [">= 0"])
     s.add_dependency(%q<msgpack>, ["~> 0.4.6"])
+    s.add_dependency(%q<eventmachine>, ["~> 0.12.10"])
   end
 end
 

metadata

@@ -1,19 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: serf
 version: !ruby/object:Gem::Version
-  version: 0.2.0.alpha1
-  prerelease: 6
+  version: 0.3.0
+  prerelease: 
 platform: ruby
 authors:
 - Benjamin Yu
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-12 00:00:00.000000000Z
+date: 2011-12-23 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
-  requirement: &70254700994980 !ruby/object:Gem::Requirement
+  requirement: &70304875304400 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 3.1.3
   type: :runtime
   prerelease: false
-  version_requirements: *70254700994980
+  version_requirements: *70304875304400
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &70254700994500 !ruby/object:Gem::Requirement
+  requirement: &70304875303800 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,21 +32,32 @@ dependencies:
         version: 3.1.3
   type: :runtime
   prerelease: false
-  version_requirements: *70254700994500
+  version_requirements: *70304875303800
 - !ruby/object:Gem::Dependency
-  name: eventmachine
-  requirement: &70254700994020 !ruby/object:Gem::Requirement
+  name: i18n
+  requirement: &70304875303260 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.12.10
+        version: 0.6.0
   type: :runtime
   prerelease: false
-  version_requirements: *70254700994020
+  version_requirements: *70304875303260
+- !ruby/object:Gem::Dependency
+  name: uuidtools
+  requirement: &70304875302780 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *70304875302780
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70254700993540 !ruby/object:Gem::Requirement
+  requirement: &70304875302300 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +65,10 @@ dependencies:
         version: 2.3.0
   type: :development
   prerelease: false
-  version_requirements: *70254700993540
+  version_requirements: *70304875302300
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &70254700993060 !ruby/object:Gem::Requirement
+  requirement: &70304875301820 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -65,10 +76,10 @@ dependencies:
         version: 0.6.0
   type: :development
   prerelease: false
-  version_requirements: *70254700993060
+  version_requirements: *70304875301820
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &70254700992580 !ruby/object:Gem::Requirement
+  requirement: &70304875301340 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -76,10 +87,10 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *70254700992580
+  version_requirements: *70304875301340
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &70254700992100 !ruby/object:Gem::Requirement
+  requirement: &70304875206820 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -87,10 +98,10 @@ dependencies:
         version: 1.6.4
   type: :development
   prerelease: false
-  version_requirements: *70254700992100
+  version_requirements: *70304875206820
 - !ruby/object:Gem::Dependency
   name: rcov
-  requirement: &70254700991540 !ruby/object:Gem::Requirement
+  requirement: &70304875206340 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -98,10 +109,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70254700991540
+  version_requirements: *70304875206340
 - !ruby/object:Gem::Dependency
   name: msgpack
-  requirement: &70254700991060 !ruby/object:Gem::Requirement
+  requirement: &70304875205860 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -109,7 +120,18 @@ dependencies:
         version: 0.4.6
   type: :development
   prerelease: false
-  version_requirements: *70254700991060
+  version_requirements: *70304875205860
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: &70304875205280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.12.10
+  type: :development
+  prerelease: false
+  version_requirements: *70304875205280
 description: Event-Driven SOA with CQRS
 email: benjaminlyu@gmail.com
 executables: []
@@ -128,10 +150,16 @@ files:
 - Rakefile
 - lib/serf.rb
 - lib/serf/builder.rb
+- lib/serf/error.rb
 - lib/serf/handler.rb
 - lib/serf/message.rb
+- lib/serf/messages/caught_exception_event.rb
+- lib/serf/messages/message_accepted_event.rb
+- lib/serf/runners/direct_runner.rb
+- lib/serf/runners/em_runner.rb
 - lib/serf/serfer.rb
 - lib/serf/util/null_object.rb
+- lib/serf/util/uuidable.rb
 - lib/serf/version.rb
 - serf.gemspec
 - spec/serf_spec.rb
@@ -151,13 +179,13 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1721782691913874176
+      hash: -3406748221232182748
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>'
+  - - ! '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.10