qs 0.3.0 → 0.4.0

data/lib/qs/queue.rb

@@ -1,15 +1,17 @@
+require 'qs'
 require 'qs/route'
 
 module Qs
 
   class Queue
 
-    attr_reader :routes
+    attr_reader :routes, :event_route_names
     attr_reader :enqueued_jobs
 
     def initialize(&block)
-      @routes = []
-      @enqueued_jobs = []
+      @routes            = []
+      @event_route_names = []
+      @enqueued_jobs     = []
       self.instance_eval(&block) if !block.nil?
       raise InvalidError, "a queue must have a name" if self.name.nil?
     end
@@ -28,12 +30,30 @@ module Qs
       @job_handler_ns
     end
 
+    def event_handler_ns(value = nil)
+      @event_handler_ns = value if !value.nil?
+      @event_handler_ns
+    end
+
     def job(name, handler_name)
       if self.job_handler_ns && !(handler_name =~ /^::/)
         handler_name = "#{self.job_handler_ns}::#{handler_name}"
       end
 
-      @routes.push(Qs::Route.new(name, handler_name))
+      route_id = Message::RouteId.new(Qs::Job::PAYLOAD_TYPE, name)
+      @routes.push(Qs::Route.new(route_id, handler_name))
+    end
+
+    def event(channel, name, handler_name)
+      if self.event_handler_ns && !(handler_name =~ /^::/)
+        handler_name = "#{self.event_handler_ns}::#{handler_name}"
+      end
+
+      route_name = Qs::Event::RouteName.new(channel, name)
+      route_id   = Qs::Message::RouteId.new(Qs::Event::PAYLOAD_TYPE, route_name)
+
+      @event_route_names.push(route_name)
+      @routes.push(Qs::Route.new(route_id, handler_name))
     end
 
     def enqueue(job_name, params = nil)
@@ -41,6 +61,18 @@ module Qs
     end
     alias :add :enqueue
 
+    def sync_subscriptions
+      Qs.sync_subscriptions(self)
+    end
+
+    def clear_subscriptions
+      Qs.clear_subscriptions(self)
+    end
+
+    def published_events
+      self.enqueued_jobs.map(&:event)
+    end
+
     def reset!
       self.enqueued_jobs.clear
     end
@@ -49,14 +81,15 @@ module Qs
       reference = '0x0%x' % (self.object_id << 1)
       "#<#{self.class}:#{reference} " \
         "@name=#{self.name.inspect} " \
-        "@job_handler_ns=#{self.job_handler_ns.inspect}>"
+        "@job_handler_ns=#{self.job_handler_ns.inspect} " \
+        "@event_handler_ns=#{self.event_handler_ns.inspect}>"
     end
 
     InvalidError = Class.new(RuntimeError)
 
     module RedisKey
       def self.parse_name(key)
-        key.split(':').last
+        key.split(':', 2).last
       end
 
       def self.new(name)

data/lib/qs/queue_item.rb

@@ -0,0 +1,33 @@
+module Qs
+
+  class QueueItem
+
+    attr_reader :queue_redis_key, :encoded_payload
+    attr_accessor :started, :finished
+    attr_accessor :message, :handler_class
+    attr_accessor :exception, :time_taken
+
+    def initialize(queue_redis_key, encoded_payload)
+      @queue_redis_key = queue_redis_key
+      @encoded_payload = encoded_payload
+      @started         = false
+      @finished        = false
+
+      @message       = nil
+      @handler_class = nil
+      @exception     = nil
+      @time_taken    = nil
+    end
+
+    def ==(other)
+      if other.kind_of?(self.class)
+        self.queue_redis_key == other.queue_redis_key &&
+        self.encoded_payload == other.encoded_payload
+      else
+        super
+      end
+    end
+
+  end
+
+end

data/lib/qs/route.rb

@@ -4,10 +4,10 @@ module Qs
 
   class Route
 
-    attr_reader :name, :handler_class_name, :handler_class
+    attr_reader :id, :handler_class_name, :handler_class
 
-    def initialize(name, handler_class_name)
-      @name = name.to_s
+    def initialize(route_id, handler_class_name)
+      @id = route_id.to_s
       @handler_class_name = handler_class_name
       @handler_class = nil
     end
@@ -16,11 +16,11 @@ module Qs
       @handler_class = constantize_handler_class(@handler_class_name)
     end
 
-    def run(job, daemon_data)
+    def run(message, daemon_data)
       QsRunner.new(self.handler_class, {
-        :job    => job,
-        :params => job.params,
-        :logger => daemon_data.logger
+        :message => message,
+        :params  => message.params,
+        :logger  => daemon_data.logger
       }).run
     end
 

data/lib/qs/runner.rb

@@ -5,16 +5,17 @@ module Qs
   class Runner
 
     attr_reader :handler_class, :handler
-    attr_reader :job, :params, :logger
+    attr_reader :message, :params, :logger
 
     def initialize(handler_class, args = nil)
       @handler_class = handler_class
-      @handler = @handler_class.new(self)
 
       a = args || {}
-      @job    = a[:job]
-      @params = a[:params] || {}
-      @logger = a[:logger] || Qs::NullLogger.new
+      @message = a[:message]
+      @params  = a[:params] || {}
+      @logger  = a[:logger] || Qs::NullLogger.new
+
+      @handler = @handler_class.new(self)
     end
 
     def run

data/lib/qs/test_runner.rb

@@ -1,24 +1,19 @@
 require 'qs'
-require 'qs/job'
+require 'qs/event_handler'
 require 'qs/job_handler'
+require 'qs/payload'
 require 'qs/runner'
 
 module Qs
 
-  InvalidJobHandlerError = Class.new(StandardError)
-
   class TestRunner < Runner
 
     def initialize(handler_class, args = nil)
-      if !handler_class.include?(Qs::JobHandler)
-        raise InvalidJobHandlerError, "#{handler_class.inspect} is not a"\
-                                      " Qs::JobHandler"
-      end
       args = (args || {}).dup
       super(handler_class, {
-        :job    => args.delete(:job),
-        :params => normalize_params(args.delete(:params) || {}),
-        :logger => args.delete(:logger)
+        :message => args.delete(:message),
+        :params  => normalize_params(args.delete(:params) || {}),
+        :logger  => args.delete(:logger)
       })
       args.each{ |key, value| self.handler.send("#{key}=", value) }
 
@@ -31,13 +26,46 @@ module Qs
 
     private
 
-    # Stringify and serialize/deserialize to ensure params are valid and are
+    # Stringify and encode/decode to ensure params are valid and are
     # in the format they would normally be when a handler is built and run.
     def normalize_params(params)
-      params = Job::StringifyParams.new(params)
-      Qs.deserialize(Qs.serialize(params))
+      params = Qs::Payload::StringifyParams.new(params)
+      Qs.decode(Qs.encode(params))
     end
 
   end
 
+  class JobTestRunner < TestRunner
+
+    def initialize(handler_class, args = nil)
+      if !handler_class.include?(Qs::JobHandler)
+        raise InvalidJobHandlerError, "#{handler_class.inspect} is not a"\
+                                      " Qs::JobHandler"
+      end
+
+      args = (args || {}).dup
+      args[:message] = args.delete(:job) if args.key?(:job)
+      super(handler_class, args)
+    end
+
+  end
+
+  class EventTestRunner < TestRunner
+
+    def initialize(handler_class, args = nil)
+      if !handler_class.include?(Qs::EventHandler)
+        raise InvalidEventHandlerError, "#{handler_class.inspect} is not a"\
+                                      " Qs::EventHandler"
+      end
+
+      args = (args || {}).dup
+      args[:message] = args.delete(:event) if args.key?(:event)
+      super(handler_class, args)
+    end
+
+  end
+
+  InvalidJobHandlerError   = Class.new(StandardError)
+  InvalidEventHandlerError = Class.new(StandardError)
+
 end

data/lib/qs/version.rb

@@ -1,3 +1,3 @@
 module Qs
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/qs.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
 
   gem.add_dependency("dat-worker-pool", ["~> 0.5"])
-  gem.add_dependency("hella-redis",     ["~> 0.2"])
+  gem.add_dependency("hella-redis",     ["~> 0.3"])
   gem.add_dependency("ns-options",      ["~> 1.1"])
   gem.add_dependency("SystemTimer",     ["~> 1.2"])
 

data/test/helper.rb

@@ -11,4 +11,4 @@ ROOT_PATH = Pathname.new(File.expand_path('../..', __FILE__))
 
 require 'test/support/factory'
 
-require 'json' # so the default serializer/deserializer procs will work
+require 'json' # so the default encoder/decoder procs will work

data/test/support/app_daemon.rb

@@ -4,7 +4,7 @@ LOGGER = Logger.new(ROOT_PATH.join('log/app_daemon.log').to_s)
 LOGGER.datetime_format = "" # turn off the datetime in the logs
 
 AppQueue = Qs::Queue.new do
-  name 'app_main'
+  name 'qs-app-main'
 
   job_handler_ns 'AppHandlers'
 
@@ -12,12 +12,19 @@ AppQueue = Qs::Queue.new do
   job 'error',   'Error'
   job 'timeout', 'Timeout'
   job 'slow',    'Slow'
+
+  event_handler_ns 'AppHandlers'
+
+  event 'qs-app', 'basic',   'BasicEvent'
+  event 'qs-app', 'error',   'ErrorEvent'
+  event 'qs-app', 'timeout', 'TimeoutEvent'
+  event 'qs-app', 'slow',    'SlowEvent'
 end
 
 class AppDaemon
   include Qs::Daemon
 
-  name 'app'
+  name 'qs-app'
 
   logger LOGGER
   verbose_logging true
@@ -25,25 +32,49 @@ class AppDaemon
   queue AppQueue
 
   error do |exception, context|
-    job_name = context.job.name if context.job
-    case(job_name)
-    when 'error', 'timeout'
-      message = "#{exception.class}: #{exception.message}"
-      Qs.redis.with{ |c| c.set('last_error', message) }
-    when 'slow'
-      Qs.redis.with{ |c| c.set('last_error', exception.class.to_s) }
+    return unless (message = context.message)
+    payload_type = message.payload_type
+    route_name   = message.route_name
+    case(route_name)
+    when 'error', 'timeout', 'qs-app:error', 'qs-app:timeout'
+      error = "#{exception.class}: #{exception.message}"
+      Qs.redis.with{ |c| c.set("qs-app:last_#{payload_type}_error", error) }
+    when 'slow', 'qs-app:slow'
+      error = exception.class.to_s
+      Qs.redis.with{ |c| c.set("qs-app:last_#{payload_type}_error", error) }
     end
   end
 
 end
 
+DISPATCH_LOGGER = Logger.new(ROOT_PATH.join('log/app_dispatcher_daemon.log').to_s)
+DISPATCH_LOGGER.datetime_format = "" # turn off the datetime in the logs
+
+class DispatcherDaemon
+  include Qs::Daemon
+
+  name 'qs-app-dispatcher'
+
+  logger DISPATCH_LOGGER
+  verbose_logging true
+
+  # we build a "custom" dispatcher because we can't rely on Qs being initialized
+  # when this is required
+  queue Qs::DispatcherQueue.new({
+    :queue_class            => Qs.config.dispatcher_queue_class,
+    :queue_name             => 'qs-app-dispatcher',
+    :job_name               => Qs.config.dispatcher.job_name,
+    :job_handler_class_name => Qs.config.dispatcher.job_handler_class_name
+  })
+end
+
 module AppHandlers
 
   class Basic
     include Qs::JobHandler
 
     def run!
-      Qs.redis.with{ |c| c.set(params['key'], params['value']) }
+      Qs.redis.with{ |c| c.set("qs-app:#{params['key']}", params['value']) }
     end
   end
 
@@ -70,7 +101,42 @@ module AppHandlers
 
     def run!
       sleep 5
-      Qs.redis.with{ |c| c.set('slow', 'finished') }
+      Qs.redis.with{ |c| c.set('qs-app:slow', 'finished') }
+    end
+  end
+
+  class BasicEvent
+    include Qs::EventHandler
+
+    def run!
+      Qs.redis.with{ |c| c.set("qs-app:#{params['key']}", params['value']) }
+    end
+  end
+
+  class ErrorEvent
+    include Qs::EventHandler
+
+    def run!
+      raise params['error_message']
+    end
+  end
+
+  class TimeoutEvent
+    include Qs::EventHandler
+
+    timeout 0.2
+
+    def run!
+      sleep 2
+    end
+  end
+
+  class SlowEvent
+    include Qs::EventHandler
+
+    def run!
+      sleep 5
+      Qs.redis.with{ |c| c.set('qs-app:slow:event', 'finished') }
     end
   end
 

data/test/support/factory.rb

@@ -1,4 +1,7 @@
 require 'assert/factory'
+require 'qs/dispatch_job'
+require 'qs/job'
+require 'qs/event'
 
 module Factory
   extend Assert::Factory
@@ -11,4 +14,35 @@ module Factory
     exception
   end
 
+  def self.message(params = nil)
+    self.send([:job, :event].choice, params)
+  end
+
+  def self.job(args = nil)
+    args ||= {}
+    name = args.delete(:name) || Factory.string
+    args[:params]     ||= { Factory.string => Factory.string }
+    args[:created_at] ||= Factory.time
+    Qs::Job.new(name, args)
+  end
+
+  def self.dispatch_job(args = nil)
+    args ||= {}
+    event_channel = args.delete(:event_channel) || Factory.string
+    event_name    = args.delete(:event_name)    || Factory.string
+    args[:event_params] ||= { Factory.string => Factory.string }
+    args[:created_at]   ||= Factory.time
+    Qs::DispatchJob.new(event_channel, event_name, args)
+  end
+
+  def self.event(args = nil)
+    args ||= {}
+    channel = args.delete(:channel) || Factory.string
+    name    = args.delete(:name)    || Factory.string
+    args[:params]       ||= { Factory.string => Factory.string }
+    args[:publisher]    ||= Factory.string
+    args[:published_at] ||= Factory.time
+    Qs::Event.new(channel, name, args)
+  end
+
 end