message 0.0.3 → 0.0.4

data/README.md

@@ -1,6 +1,7 @@
 # Message
 
-https://travis-ci.org/xli/message.svg?branch=master
+[![Build Status](https://travis-ci.org/xli/message.svg?branch=master)](https://travis-ci.org/xli/message)
+
 
 Message provides flexible & reliable background/asynchronous job processing mechanism on top of simple queue interface.
 
@@ -22,7 +23,7 @@ and you can easily swap in other queues later.
 ### Queuing jobs
 
 
-Inspired by delayed_job API, call .async.method(params) on any object and it will be processed in the background.
+Call .async.method(params) on any object and it will be processed in the background.
 
     # without message
     @img.resize(36)
@@ -30,10 +31,22 @@ Inspired by delayed_job API, call .async.method(params) on any object and it wil
     # with message
     @img.async.resize(36)
 
-### Start worker to process jobs
+The above .async call will enqueue the job to a default job queue (Message.worker.default_job)
+
+### Start worker to process default job queue
 
     Message.worker.start
 
+### Named job queue
+
+Queuing jobs into speicific queue named 'image-resize-queue':
+
+    @img.async('image-resize-queue').resize(36)
+
+Start a worker to process queued jobs:
+
+    Message.worker('image-resize-queue').start
+
 ### Change to synchronize mode
 
     Message.worker.sync = true
@@ -48,93 +61,9 @@ For some environment or queue system (e.g. AWS SQS), you will need set an applic
 
     Message.worker.default_job = "app-name-#{Rails.env}-message-default"
 
-## Job interface specification
-
-Job = a queue + message processor
-
-### initialize a job
-
-    job = Message.job('name') { |msg| ... process msg ... }
-
-### enq(msg), alias: <<
-
-Queue up a message for processing:
-
-    job << msg
-
-### process(size=1)
-
-Process a message in queue by processor defined when initializing the job
-
-    job.process
-
-Process multiple messages
-
-    job.process(5)
-
-## Job filters
-
-You can add job filter to add additional functions to enqueue and process job message
-
-    Message.job.filter(filter_name) do |next_filter, job|
-      lambda do |*args, &block|
-        next_filter.call(*args, &block)
-      end
-    end
+### Change backend queue system
 
-Filters will be applied as the order initialized.
-Checkout all filters:
-
-    Message.job.filters
-
-### enq filter
-
-    Message.job.filter(:enq) do |filter, job|
-      lambda do |work|
-        filter.call(work)
-      end
-    end
-
-### process filter
-
-    Message.job.filter(:process) do |filter, job|
-      lambda do |size, &processor|
-        filter.call(size) do |msg|
-          processor.call(msg)
-        end
-      end
-    end
-
-## Queue adapters
-
-Change queue adapter to change different queue implementation. Default is a in memory queue for testing and development environments.
-
-### Change adapter
+By change queue adapter:
 
     Message.queue.adapter = :sqs
 
-### Add a new adapter
-
-    Message.queue.adapters[:sqs] = Message::SqsQueue
-
-## Queue interface specification
-
-To hook up a new queue into Message.
-
-### name
-
-Queue name.
-
-### enq(msg), alias: <<
-
-Enqueue message, non-blocking.
-
-### deq(size, &block)
-
-Dequeue message, non-blocking.
-It is up to Queue implementation when to delete the message in queue when deq got called with a block.
-
-### size
-
-(Approximate) queue size.
-

data/lib/message/filters/benchmarking.rb

@@ -0,0 +1,20 @@
+require 'benchmark'
+module Message
+  class Filters
+    class Benchmarking
+      def call(filter, job, action)
+        lambda do |msg|
+          return filter.call(msg) unless action == :process
+
+          ret = nil
+          Message.logger.info { "#{job.name}: processing one message"}
+          s = Benchmark.realtime do
+            ret = filter.call(msg)
+          end
+          Message.logger.info { "#{job.name}: processed in #{(1000 * s).to_i}ms" }
+          ret
+        end
+      end
+    end
+  end
+end

data/lib/message/filters/error_handling.rb

@@ -0,0 +1,21 @@
+module Message
+  class Filters
+    class ErrorHandling
+      attr_accessor :callback
+
+      def call(filter, job, action)
+        lambda do |msg|
+          begin
+            filter.call(msg)
+          rescue => e
+            job_name = job.name rescue 'unknown job(find job name failed)'
+            Message.logger.error {"#{action} #{job_name} message failed, #{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"}
+            if self.callback
+              self.callback.call(e, msg, job, action)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/message/filters/retry_on_error.rb

@@ -0,0 +1,28 @@
+module Message
+  class Filters
+    class RetryOnError
+      attr_accessor :tries, :on, :sleep
+      def initialize
+        @tries = 3
+        @on = StandardError
+        @sleep = 0.001
+      end
+
+      def call(filter, _, _)
+        lambda do |arg|
+          @try = 0
+          begin
+            filter.call(arg)
+          rescue self.on => e
+            @try += 1
+            if @try < self.tries
+              Kernel.sleep self.sleep.to_f
+              retry
+            end
+            raise
+          end
+        end
+      end
+    end
+  end
+end

data/lib/message/filters.rb

@@ -1,66 +1,37 @@
-require 'benchmark'
+require 'message/filters/error_handling'
+require 'message/filters/benchmarking'
+require 'message/filters/retry_on_error'
 
 module Message
   class Filters
-    attr_reader :config
+    include Enumerable
+
+    attr_accessor :error_handling, :benchmarking, :retry_on_error
 
     def initialize
-      @data = Hash.new{|h,k|h[k]=[]}
-      @config = {
-        :error_handling_callback => lambda {|type, job, msg, e| }
-      }
-      defaults.each do |t, m|
-        self[t] << [m, method(m)]
-      end
+      @data = []
+      @error_handling = ErrorHandling.new
+      @benchmarking = Benchmarking.new
+      @retry_on_error = RetryOnError.new
+      load(defaults)
     end
 
-    def [](type)
-      @data[type]
+    def <<(filter)
+      @data << filter
     end
 
-    def defaults
-      [
-        [:process, :error_handling],
-        [:enq, :error_handling],
-        [:process, :benchmarking]
-      ]
-    end
-
-    def error_handling(filter, job)
-      lambda do |arg, &processor|
-        type = processor ? :process : :enq
-        log_error(type, job, (type == :enq ? arg : nil)) do
-          if processor
-            filter.call(arg) do |msg|
-              log_error(type, job, msg) { processor.call(msg) }
-            end
-          else
-            filter.call(arg)
-          end
-        end
+    def load(data)
+      data.each do |m|
+        @data << [m, send(m)]
       end
     end
 
-    def benchmarking(filter, job)
-      lambda do |size, &processor|
-        filter.call(size) do |msg|
-          ret = nil
-          Message.logger.info { "#{job.name}: processing one message"}
-          s = Benchmark.realtime do
-            ret = processor.call(msg)
-          end
-          Message.logger.info { "#{job.name}: processed in #{(1000 * s).to_i}ms" }
-          ret
-        end
-      end
+    def defaults
+      [:error_handling, :benchmarking, :retry_on_error]
     end
 
-    private
-    def log_error(type, job, msg, &block)
-      block.call
-    rescue => e
-      Message.logger.error {"#{type} #{job.name} message failed, #{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"}
-      config[:error_handling_callback].call(type, job, msg, e)
+    def each(&block)
+      @data.each(&block)
     end
   end
 end

data/lib/message/job.rb

@@ -7,8 +7,8 @@ module Message
         @filters ||= Filters.new
       end
 
-      def filter(type, name, &block)
-        filters[type] << [name, block]
+      def filter(name, &block)
+        filters << [name, block]
       end
 
       def reset
@@ -30,18 +30,23 @@ module Message
     end
 
     def enq(msg)
-      chain(:enq, @queue.method(:enq)).call(msg)
+      chain(:enq, lambda {|msg| @queue.enq(msg)}).call(msg)
     end
     alias :<< :enq
 
     def process(size=1)
-      chain(:process, @queue.method(:deq)).call(size, &@processor)
+      deq = lambda do |size|
+        @queue.deq(size) do |msg|
+          chain(:process, @processor).call(msg)
+        end
+      end
+      chain(:deq, deq).call(size)
     end
 
     private
-    def chain(type, base)
-      Job.filters[type].reverse.inject(base) do |m, f|
-        f[1].call(m, self)
+    def chain(action, base)
+      Job.filters.to_a.reverse.inject(base) do |m, f|
+        f[1].call(m, self, action)
       end
     end
   end

data/lib/message/q.rb

@@ -1,5 +1,8 @@
 require 'message/in_memory_queue'
 module Message
+  class AdapterNotFoundError < StandardError
+  end
+
   module Q
     module_function
     def init(name)
@@ -15,6 +18,10 @@ module Message
     end
 
     def adapter=(name)
+      name = name.to_sym
+      unless adapters.has_key?(name)
+        raise AdapterNotFoundError, "Could not find adapter named #{name.inspect}"
+      end
       @adapter = name
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: message
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-09 00:00:00.000000000 Z
+date: 2014-09-13 00:00:00.000000000 Z
 dependencies: []
 description: ! 'Message provides flexible & reliable background/asynchronous job processing
   mechanism on top of simple queue interface.
@@ -31,6 +31,9 @@ extensions: []
 extra_rdoc_files: []
 files:
 - README.md
+- lib/message/filters/benchmarking.rb
+- lib/message/filters/error_handling.rb
+- lib/message/filters/retry_on_error.rb
 - lib/message/filters.rb
 - lib/message/in_memory_queue.rb
 - lib/message/job.rb