serf 0.9.0 → 0.10.0

data/lib/serf/routing/endpoint.rb

@@ -1,49 +0,0 @@
-require 'serf/util/options_extraction'
-
-module Serf
-module Routing
-
-  ##
-  # An endpoint is the description of how to build a Unit of Work
-  # for a given matched message. It builds an instance that
-  # responds to the `call` method that will actually execute the work.
-  # Units of work is built on every received message with the request,
-  # given arguments, options (merged with serf infrastructure options)
-  # and given block.
-  #
-  class Endpoint
-    include Serf::Util::OptionsExtraction
-
-    def initialize(connect, handler_factory, *args, &block)
-      # If we want to connect serf options, then we try to extract
-      # any possible options from the args list. If a hash exists at the
-      # end of the args list, then we'll merge into it. Otherwise a new hash
-      # will be added on.
-      extract_options! args if @connect = connect
-
-      @handler_factory= handler_factory
-      @args = args
-      @block = block
-    end
-
-    ##
-    # Builds a Unit of Work object.
-    #
-    def build(env, serf_options={})
-      # If we are connecting serf options, then we need to pass these
-      # options on to the builder.
-      if @connect
-        @handler_factory.build(
-          env.dup,
-          *@args,
-          options.merge(serf_options),
-          &@block)
-      else
-        @handler_factory.build env.dup, *@args, &@block
-      end
-    end
-
-  end
-
-end
-end

data/lib/serf/routing/registry.rb

@@ -1,66 +0,0 @@
-require 'serf/util/regexp_matcher'
-
-module Serf
-module Routing
-
-  ##
-  # EndpointRegistry returns list of Endpoints to execute that match
-  # criteria based on the Endpoints' associated 'matcher' object
-  # with the input of the ENV Hash (passed to match).
-  #
-  class Registry
-
-    def initialize(options={})
-      @endpoints = {}
-      @matchers = []
-      @regexp_matcher_factory = options.fetch(:regexp_matcher_factory) {
-        ::Serf::Util::RegexpMatcher
-      }
-    end
-
-    ##
-    # Connects a matcher (String or an Object implementing ===) to endpoints.
-    #
-    def add(matcher, endpoints)
-      # Maybe we have an non-String matcher. Handle the Regexp case.
-      # We only keep track of matchers if it isn't a string because
-      # string matchers are just pulled out of endpoints by key lookup.
-      matcher = @regexp_matcher_factory.build matcher if matcher.kind_of? Regexp
-      @matchers << matcher unless matcher.is_a? String
-
-      # We add the (matcher+endpoint) into our endpoints
-      @endpoints[matcher] ||= []
-      @endpoints[matcher].concat endpoints
-    end
-
-    ##
-    # @param [Hash] env The input message environment to match for endpoints.
-    # @return [Array] List of endpoints that matched.
-    #
-    def match(env={})
-      kind = env[:kind]
-      endpoints = []
-      endpoints.concat @endpoints.fetch(kind) { [] }
-      @matchers.each do |matcher|
-        endpoints.concat @endpoints[matcher] if matcher === env
-      end
-      return endpoints
-    end
-
-    ##
-    # @return [Integer] Number of matchers this EndpointsMap tracks.
-    #
-    def size
-      return @endpoints.size
-    end
-
-    ##
-    # Default factory method.
-    #
-    def self.build(options={})
-      self.new options
-    end
-  end
-
-end
-end

data/lib/serf/runners/direct.rb

@@ -1,52 +0,0 @@
-require 'serf/runners/helper'
-require 'serf/util/error_handling'
-
-module Serf
-module Runners
-
-  ##
-  # Direct runner drives the execution of a handler for given messages.
-  # This class deals with error handling and pushing handler results
-  # to proper error or results channels.
-  #
-  # NOTES:
-  # * Results returned from handlers are pushed to response channel.
-  # * Errors raised by handlers are pushed to error channel, not response.
-  #
-  class Direct
-    include Serf::Util::ErrorHandling
-    include Serf::Runners::Helper
-
-    def initialize(*args)
-      extract_options! args
-      opts! :response_channel
-    end
-
-    def call(handlers, context)
-      results = []
-      handlers.each do |handler|
-        ok, run_result = with_error_handling(context) do
-          handler.call
-        end
-        run_result = run_result.is_a?(Hash) ? [run_result] : Array(run_result)
-
-        # We only post to the response channel if we didn't catch and error.
-        # But we add both error and success results to the 'results' to
-        # pass back to the caller of the runner. This may be a background
-        # runner, which then the results are ignored. But it may have been
-        # the Serfer, which means all results should go back to the user
-        # as this was a foreground (synchronous) execution.
-        results.concat run_result
-        push_results run_result if ok
-      end
-      return results
-    end
-
-    def self.build(options={})
-      self.new options
-    end
-
-  end
-
-end
-end

data/lib/serf/runners/event_machine.rb

@@ -1,69 +0,0 @@
-require 'eventmachine'
-
-require 'serf/runners/direct'
-require 'serf/util/error_handling'
-
-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 pushing to error channels because that may have
-  # been the cause of the error.
-  #
-  class EventMachine
-    include Serf::Util::ErrorHandling
-
-    def initialize(*args)
-      extract_options! args
-
-      # Manditory: Need a runner because this class is just a wrapper.
-      @runner = opts! :runner
-
-      @evm = opts :event_machine, ::EventMachine
-      @logger = opts :logger, ::Serf::Util::NullObject.new
-    end
-
-    def call(handlers, context)
-      # This queues up each handler to be run separately.
-      handlers.each do |handler|
-        @evm.defer(proc do
-          begin
-            with_error_handling(context) do
-              @runner.call [handler], context
-            end
-          rescue => e
-            @logger.fatal(
-              "EventMachineThread: #{e.inspect}\n\n#{e.backtrace.join("\n")}")
-          end
-        end)
-      end
-      return {
-        kind: 'serf/messages/message_accepted_event',
-        message: context
-      }
-    end
-
-    def self.build(options={})
-      options[:runner] = options.fetch(:runner) {
-        factory = options[:runner_factory] || ::Serf::Runners::Direct
-        factory.build options
-      }
-      self.new options
-    end
-
-  end
-
-end
-end

data/lib/serf/runners/girl_friday.rb

@@ -1,69 +0,0 @@
-require 'girl_friday'
-
-require 'serf/runners/helper'
-require 'serf/util/error_handling'
-
-module Serf
-module Runners
-
-  ##
-  #
-  class GirlFriday
-    include Serf::Util::ErrorHandling
-    include Serf::Runners::Helper
-
-    def initialize(*args)
-      extract_options! args
-
-      # Mandatory response channel.
-      opts! :response_channel
-
-      # Create our worker queue that will accept tasks (handler and context).
-      # The worker is just a block that passes on the task to the
-      # actual worker method.
-      @queue = ::GirlFriday::WorkQueue.new(
-          opts(:queue_name, :serf_runner),
-          :size => opts(:queue_size, 1)) do |task|
-        perform task
-      end
-    end
-
-    def call(handlers, context)
-      # Push each handler into the queue along with a copy of the context.
-      handlers.each do |handler|
-        @queue.push(
-          handler: handler,
-          context: context.dup)
-      end
-
-      # We got here, we succeeded pushing all the works.
-      # Now we return our accepted event.
-      return {
-        kind: 'serf/messages/message_accepted_event',
-        message: context
-      }
-    end
-
-    ##
-    # Builder method
-    #
-    def self.build(*args)
-      self.new *args
-    end
-
-    ##
-    # Actually drives the execution of individual handlers passed to job
-    # queue.
-    #
-    def perform(task)
-      ok, run_result = with_error_handling(task[:context]) do
-        task[:handler].call
-      end
-      run_result = run_result.is_a?(Hash) ? [run_result] : Array(run_result)
-      push_results run_result if ok
-    end
-
-  end
-
-end
-end

data/lib/serf/runners/helper.rb

@@ -1,23 +0,0 @@
-module Serf
-module Runners
-
-  module Helper
-
-    ##
-    # Loop over the results and push them to the response channel.
-    # Any error in pushing individual messages will result in
-    # a log event and an error channel event.
-    def push_results(results)
-      response_channel = opts! :response_channel
-      results.each do |message|
-        with_error_handling(message) do
-          response_channel.push message
-        end
-      end
-      return nil
-    end
-
-  end
-
-end
-end

data/lib/serf/util/mash_factory.rb

@@ -1,18 +0,0 @@
-require 'hashie'
-
-module Serf
-module Util
-
-  ##
-  # A Request Factory that just coerces a REQUEST ENV hash message
-  # into a Hashie::Mash object for convenience key/value access.
-  #
-  module MashFactory
-
-    def self.build(message)
-      Hashie::Mash.new message
-    end
-  end
-
-end
-end