qs 0.3.0 → 0.4.0

data/lib/qs/job_handler.rb

@@ -1,39 +1,18 @@
+require 'qs/message_handler'
+
 module Qs
 
   module JobHandler
 
     def self.included(klass)
       klass.class_eval do
-        extend ClassMethods
+        include Qs::MessageHandler
         include InstanceMethods
       end
     end
 
     module InstanceMethods
 
-      def initialize(runner)
-        @qs_runner = runner
-      end
-
-      def init
-        run_callback 'before_init'
-        self.init!
-        run_callback 'after_init'
-      end
-
-      def init!
-      end
-
-      def run
-        run_callback 'before_run'
-        self.run!
-        run_callback 'after_run'
-      end
-
-      def run!
-        raise NotImplementedError
-      end
-
       def inspect
         reference = '0x0%x' % (self.object_id << 1)
         "#<#{self.class}:#{reference} @job=#{job.inspect}>"
@@ -43,45 +22,9 @@ module Qs
 
       # Helpers
 
-      def job;    @qs_runner.job;    end
-      def params; @qs_runner.params; end
-      def logger; @qs_runner.logger; end
-
-      def run_callback(callback)
-        (self.class.send("#{callback}_callbacks") || []).each do |callback|
-          self.instance_eval(&callback)
-        end
-      end
-
-    end
-
-    module ClassMethods
-
-      def timeout(value = nil)
-        @timeout = value.to_f if value
-        @timeout
-      end
-
-      def before_callbacks;      @before_callbacks      ||= []; end
-      def after_callbacks;       @after_callbacks       ||= []; end
-      def before_init_callbacks; @before_init_callbacks ||= []; end
-      def after_init_callbacks;  @after_init_callbacks  ||= []; end
-      def before_run_callbacks;  @before_run_callbacks  ||= []; end
-      def after_run_callbacks;   @after_run_callbacks   ||= []; end
-
-      def before(&block);      self.before_callbacks      << block; end
-      def after(&block);       self.after_callbacks       << block; end
-      def before_init(&block); self.before_init_callbacks << block; end
-      def after_init(&block);  self.after_init_callbacks  << block; end
-      def before_run(&block);  self.before_run_callbacks  << block; end
-      def after_run(&block);   self.after_run_callbacks   << block; end
-
-      def prepend_before(&block);      self.before_callbacks.unshift(block);      end
-      def prepend_after(&block);       self.after_callbacks.unshift(block);       end
-      def prepend_before_init(&block); self.before_init_callbacks.unshift(block); end
-      def prepend_after_init(&block);  self.after_init_callbacks.unshift(block);  end
-      def prepend_before_run(&block);  self.before_run_callbacks.unshift(block);  end
-      def prepend_after_run(&block);   self.after_run_callbacks.unshift(block);   end
+      def job;            @qs_runner.message; end
+      def job_name;       job.name;           end
+      def job_created_at; job.created_at;     end
 
     end
 

data/lib/qs/{test_helpers.rb → job_handler_test_helpers.rb}

@@ -1,11 +1,11 @@
 require 'qs/test_runner'
 
-module Qs
+module Qs::JobHandler
 
   module TestHelpers
 
     def test_runner(handler_class, args = nil)
-      TestRunner.new(handler_class, args)
+      Qs::JobTestRunner.new(handler_class, args)
     end
 
     def test_handler(handler_class, args = nil)

data/lib/qs/message.rb

@@ -0,0 +1,29 @@
+module Qs
+
+  class Message
+
+    attr_reader :payload_type, :params
+
+    def initialize(payload_type, options = nil)
+      options ||= {}
+      @payload_type = payload_type.to_s
+      @params       = options[:params] || {}
+    end
+
+    def route_id
+      @route_id ||= RouteId.new(self.payload_type, self.route_name)
+    end
+
+    def route_name
+      raise NotImplementedError
+    end
+
+    module RouteId
+      def self.new(payload_type, route_name)
+        "#{payload_type}|#{route_name}"
+      end
+    end
+
+  end
+
+end

data/lib/qs/message_handler.rb

@@ -0,0 +1,84 @@
+module Qs
+
+  module MessageHandler
+
+    def self.included(klass)
+      klass.class_eval do
+        extend ClassMethods
+        include InstanceMethods
+      end
+    end
+
+    module InstanceMethods
+
+      def initialize(runner)
+        @qs_runner = runner
+      end
+
+      def init
+        run_callback 'before_init'
+        self.init!
+        run_callback 'after_init'
+      end
+
+      def init!
+      end
+
+      def run
+        run_callback 'before_run'
+        self.run!
+        run_callback 'after_run'
+      end
+
+      def run!
+        raise NotImplementedError
+      end
+
+      private
+
+      # Helpers
+
+      def params; @qs_runner.params; end
+      def logger; @qs_runner.logger; end
+
+      def run_callback(callback)
+        (self.class.send("#{callback}_callbacks") || []).each do |callback|
+          self.instance_eval(&callback)
+        end
+      end
+
+    end
+
+    module ClassMethods
+
+      def timeout(value = nil)
+        @timeout = value.to_f if value
+        @timeout
+      end
+
+      def before_callbacks;      @before_callbacks      ||= []; end
+      def after_callbacks;       @after_callbacks       ||= []; end
+      def before_init_callbacks; @before_init_callbacks ||= []; end
+      def after_init_callbacks;  @after_init_callbacks  ||= []; end
+      def before_run_callbacks;  @before_run_callbacks  ||= []; end
+      def after_run_callbacks;   @after_run_callbacks   ||= []; end
+
+      def before(&block);      self.before_callbacks      << block; end
+      def after(&block);       self.after_callbacks       << block; end
+      def before_init(&block); self.before_init_callbacks << block; end
+      def after_init(&block);  self.after_init_callbacks  << block; end
+      def before_run(&block);  self.before_run_callbacks  << block; end
+      def after_run(&block);   self.after_run_callbacks   << block; end
+
+      def prepend_before(&block);      self.before_callbacks.unshift(block);      end
+      def prepend_after(&block);       self.after_callbacks.unshift(block);       end
+      def prepend_before_init(&block); self.before_init_callbacks.unshift(block); end
+      def prepend_after_init(&block);  self.after_init_callbacks.unshift(block);  end
+      def prepend_before_run(&block);  self.before_run_callbacks.unshift(block);  end
+      def prepend_after_run(&block);   self.after_run_callbacks.unshift(block);   end
+
+    end
+
+  end
+
+end

data/lib/qs/payload.rb

@@ -0,0 +1,98 @@
+require 'qs'
+require 'qs/event'
+require 'qs/job'
+
+module Qs
+
+  module Payload
+
+    METHOD_NAMES = Hash.new{ |h, t| raise(InvalidError.new(t)) }.tap do |h|
+      h[Job::PAYLOAD_TYPE]   = 'job'
+      h[Event::PAYLOAD_TYPE] = 'event'
+    end.freeze
+
+    def self.type_method_name(payload_type)
+      METHOD_NAMES[payload_type]
+    end
+
+    def self.deserialize(encoded_payload)
+      payload_hash = Qs.decode(encoded_payload)
+      self.send(self.type_method_name(payload_hash['type']), payload_hash)
+    end
+
+    def self.serialize(message)
+      Qs.encode(self.send("#{self.type_method_name(message.payload_type)}_hash", message))
+    end
+
+    def self.job(payload_hash)
+      Qs::Job.new(payload_hash['name'], {
+        :params     => payload_hash['params'],
+        :created_at => Timestamp.to_time(payload_hash['created_at'])
+      })
+    end
+
+    def self.job_hash(job)
+      self.message_hash(job, {
+        'name'       => job.name.to_s,
+        'created_at' => Timestamp.new(job.created_at)
+      })
+    end
+
+    def self.event(payload_hash)
+      Qs::Event.new(payload_hash['channel'], payload_hash['name'], {
+        :params       => payload_hash['params'],
+        :publisher    => payload_hash['publisher'],
+        :published_at => Timestamp.to_time(payload_hash['published_at'])
+      })
+    end
+
+    def self.event_hash(event)
+      self.message_hash(event, {
+        'channel'      => event.channel.to_s,
+        'name'         => event.name.to_s,
+        'publisher'    => event.publisher.to_s,
+        'published_at' => Timestamp.new(event.published_at)
+      })
+    end
+
+    # private
+
+    def self.message_hash(message, hash)
+      hash.tap do |h|
+        h['type']   = message.payload_type.to_s
+        h['params'] = StringifyParams.new(message.params)
+      end
+    end
+
+    module StringifyParams
+      def self.new(object)
+        case(object)
+        when Hash
+          object.inject({}){ |h, (k, v)| h.merge(k.to_s => self.new(v)) }
+        when Array
+          object.map{ |item| self.new(item) }
+        else
+          object
+        end
+      end
+    end
+
+    module Timestamp
+      def self.to_time(integer)
+        Time.at(integer)
+      end
+
+      def self.new(time)
+        time.to_i
+      end
+    end
+
+    class InvalidError < ArgumentError
+      def initialize(payload_type)
+        super "unknown payload type #{payload_type.inspect}"
+      end
+    end
+
+  end
+
+end

data/lib/qs/payload_handler.rb

@@ -1,19 +1,20 @@
 require 'benchmark'
 require 'dat-worker-pool'
-require 'qs'
 require 'qs/error_handler'
+require 'qs/event'
 require 'qs/job'
 require 'qs/logger'
+require 'qs/payload'
 
 module Qs
 
   class PayloadHandler
 
-    attr_reader :daemon_data, :redis_item, :logger
+    attr_reader :daemon_data, :queue_item, :logger
 
-    def initialize(daemon_data, redis_item)
+    def initialize(daemon_data, queue_item)
       @daemon_data = daemon_data
-      @redis_item  = redis_item
+      @queue_item  = queue_item
       @logger = Qs::Logger.new(
         @daemon_data.logger,
         @daemon_data.verbose_logging
@@ -22,49 +23,48 @@ module Qs
 
     def run
       log_received
-      benchmark = Benchmark.measure{ run!(@daemon_data, @redis_item) }
-      @redis_item.time_taken = RoundedTime.new(benchmark.real)
-      log_complete(@redis_item)
-      raise_if_debugging!(@redis_item.exception)
+      benchmark = Benchmark.measure{ run!(@daemon_data, @queue_item) }
+      @queue_item.time_taken = RoundedTime.new(benchmark.real)
+      log_complete(@queue_item)
+      raise_if_debugging!(@queue_item.exception)
     end
 
     private
 
-    def run!(daemon_data, redis_item)
-      redis_item.started = true
+    def run!(daemon_data, queue_item)
+      queue_item.started = true
 
-      payload = Qs.deserialize(redis_item.serialized_payload)
-      job = Qs::Job.parse(payload)
-      log_job(job)
-      redis_item.job = job
+      message = Qs::Payload.deserialize(queue_item.encoded_payload)
+      log_message(message)
+      queue_item.message = message
 
-      route = daemon_data.route_for(job.name)
+      route = daemon_data.route_for(message.route_id)
       log_handler_class(route.handler_class)
-      redis_item.handler_class = route.handler_class
+      queue_item.handler_class = route.handler_class
 
-      route.run(job, daemon_data)
-      redis_item.finished = true
+      route.run(message, daemon_data)
+      queue_item.finished = true
     rescue DatWorkerPool::ShutdownError => exception
-      if redis_item.started
+      if queue_item.started
         error = ShutdownError.new(exception.message)
         error.set_backtrace(exception.backtrace)
-        handle_exception(error, daemon_data, redis_item)
+        handle_exception(error, daemon_data, queue_item)
       end
       raise exception
     rescue StandardError => exception
-      handle_exception(exception, daemon_data, redis_item)
+      handle_exception(exception, daemon_data, queue_item)
     end
 
-    def handle_exception(exception, daemon_data, redis_item)
+    def handle_exception(exception, daemon_data, queue_item)
       error_handler = Qs::ErrorHandler.new(exception, {
-        :daemon_data        => daemon_data,
-        :queue_redis_key    => redis_item.queue_redis_key,
-        :serialized_payload => redis_item.serialized_payload,
-        :job                => redis_item.job,
-        :handler_class      => redis_item.handler_class
+        :daemon_data     => daemon_data,
+        :queue_redis_key => queue_item.queue_redis_key,
+        :encoded_payload => queue_item.encoded_payload,
+        :message         => queue_item.message,
+        :handler_class   => queue_item.handler_class
       }).tap(&:run)
-      redis_item.exception = error_handler.exception
-      log_exception(redis_item.exception)
+      queue_item.exception = error_handler.exception
+      log_exception(queue_item.exception)
     end
 
     def raise_if_debugging!(exception)
@@ -72,32 +72,30 @@ module Qs
     end
 
     def log_received
-      log_verbose "===== Running job ====="
+      log_verbose "===== Received message ====="
+    end
+
+    def log_message(message)
+      self.send("log_#{Qs::Payload.type_method_name(message.payload_type)}", message)
+      log_verbose "  Params:    #{message.params.inspect}"
     end
 
     def log_job(job)
-      log_verbose "  Job:     #{job.name.inspect}"
-      log_verbose "  Params:  #{job.params.inspect}"
+      log_verbose "  Job:       #{job.route_name.inspect}"
+    end
+
+    def log_event(event)
+      log_verbose "  Event:     #{event.route_name.inspect}"
+      log_verbose "  Publisher: #{event.publisher.inspect}"
     end
 
     def log_handler_class(handler_class)
-      log_verbose "  Handler: #{handler_class}"
+      log_verbose "  Handler:   #{handler_class}"
     end
 
-    def log_complete(redis_item)
-      log_verbose "===== Completed in #{redis_item.time_taken}ms ====="
-      summary_line_args = {
-        'time'    => redis_item.time_taken,
-        'handler' => redis_item.handler_class
-      }
-      if (job = redis_item.job)
-        summary_line_args['job']    = job.name
-        summary_line_args['params'] = job.params
-      end
-      if (exception = redis_item.exception)
-        summary_line_args['error'] = "#{exception.inspect}"
-      end
-      log_summary SummaryLine.new(summary_line_args)
+    def log_complete(queue_item)
+      log_verbose "===== Completed in #{queue_item.time_taken}ms ====="
+      log_summary build_summary_line(queue_item)
     end
 
     def log_exception(exception)
@@ -114,18 +112,72 @@ module Qs
       self.logger.summary.send(level, "[Qs] #{message}")
     end
 
-    module RoundedTime
-      ROUND_PRECISION = 2
-      ROUND_MODIFIER = 10 ** ROUND_PRECISION
-      def self.new(time_in_seconds)
-        (time_in_seconds * 1000 * ROUND_MODIFIER).to_i / ROUND_MODIFIER.to_f
+    def build_summary_line(queue_item)
+      summary_line_args = {
+        'time'    => queue_item.time_taken,
+        'handler' => queue_item.handler_class
+      }
+      if (exception = queue_item.exception)
+        summary_line_args['error'] = "#{exception.class}: #{exception.message}"
       end
+      if (message = queue_item.message)
+        summary_line_args['params'] = message.params
+        self.send(
+          "#{Qs::Payload.type_method_name(message.payload_type)}_summary_line",
+          message,
+          summary_line_args
+        )
+      else
+        UnknownSummaryLine.new(summary_line_args)
+      end
+    end
+
+    def job_summary_line(job, summary_line_args)
+      JobSummaryLine.new(job, summary_line_args)
+    end
+
+    def event_summary_line(event, summary_line_args)
+      EventSummaryLine.new(event, summary_line_args)
     end
 
     module SummaryLine
+      def self.new(keys, line_attrs)
+        keys.map{ |k| "#{k}=#{line_attrs[k].inspect}" }.join(' ')
+      end
+    end
+
+    module UnknownSummaryLine
+      ORDERED_KEYS = %w(time handler error).freeze
+
       def self.new(line_attrs)
-        attr_keys = %w{time handler job params error}
-        attr_keys.map{ |k| "#{k}=#{line_attrs[k].inspect}" }.join(' ')
+        SummaryLine.new(ORDERED_KEYS, line_attrs)
+      end
+    end
+
+    module JobSummaryLine
+      ORDERED_KEYS = %w(time handler job params error).freeze
+
+      def self.new(job, line_attrs)
+        SummaryLine.new(ORDERED_KEYS, line_attrs.merge('job' => job.route_name))
+      end
+    end
+
+    module EventSummaryLine
+      ORDERED_KEYS = %w(time handler event publisher params error).freeze
+
+      def self.new(event, line_attrs)
+        SummaryLine.new(ORDERED_KEYS, line_attrs.merge({
+          'event'     => event.route_name,
+          'publisher' => event.publisher
+        }))
+      end
+    end
+
+    module RoundedTime
+      ROUND_PRECISION = 2
+      ROUND_MODIFIER = 10 ** ROUND_PRECISION
+      def self.new(time_in_seconds)
+        (time_in_seconds * 1000 * ROUND_MODIFIER).to_i / ROUND_MODIFIER.to_f
       end
     end