qe 0.1.3

data/examples/beanstalkd.ru

@@ -0,0 +1,5 @@
+require "bundler"
+Bundler.setup(:default)
+Bundler.require(:default)
+
+run BeanstalkdView::Server

data/examples/migrate.rb

@@ -0,0 +1,16 @@
+require "./workers"
+
+ActiveRecord::Schema.define(:version => 0) do
+  create_table :delayed_jobs, :force => true do |table|
+    table.integer  :priority, :default => 0      # Allows some jobs to jump to the front of the queue
+    table.integer  :attempts, :default => 0      # Provides for retries, but still fail eventually.
+    table.text     :handler                      # YAML-encoded string of the object that will do work
+    table.text     :last_error                   # reason for last failure (See Note below)
+    table.datetime :run_at                       # When to run. Could be Time.zone.now for immediately, or sometime in the future.
+    table.datetime :locked_at                    # Set when a client is working on this object
+    table.datetime :failed_at                    # Set when all retries have failed (actually, by default, the record is deleted instead)
+    table.string   :locked_by                    # Who is working on this object (if locked)
+    table.string   :queue                        # The name of the queue this job is in
+    table.timestamps
+  end
+end

data/examples/redis.conf

@@ -0,0 +1 @@
+loglevel notice

data/examples/resque.ru

@@ -0,0 +1,6 @@
+require "bundler"
+Bundler.setup(:default)
+Bundler.require(:default)
+
+require "resque/server"
+run Resque::Server

data/examples/sample.rb

@@ -0,0 +1,11 @@
+require "./workers"
+
+loop do
+  puts "=> Enqueuing jobs [#{Time.now}]"
+
+  MailerWorker.enqueue(:name => "John Doe", :email => "john@example.org")
+  ClockWorker.enqueue
+
+  sleep 3
+end
+

data/examples/sidekiq.ru

@@ -0,0 +1,10 @@
+require "bundler"
+Bundler.setup(:default)
+Bundler.require(:default)
+
+Sidekiq.configure_client do |config|
+  config.redis = { :size => 1 }
+end
+
+require "sidekiq/web"
+run Sidekiq::Web

data/examples/workers.rb

@@ -0,0 +1,43 @@
+require "bundler"
+Bundler.setup(:default)
+Bundler.require
+
+$:.unshift File.expand_path("../../lib", __FILE__)
+require "qe"
+
+$stdout.sync = true
+
+Qe.adapter = Qe::Sidekiq
+# Qe.adapter = Qe::Beanstalk
+# Qe.adapter = Qe::Resque
+# Qe.adapter = Qe::DelayedJob
+# Qe.adapter = Qe::Qu
+# Qe.adapter = Qe::Testing
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => "jobs.sqlite3")
+
+class ClockWorker
+  include Qe::Worker
+
+  def perform
+    puts "=> Time: #{Time.now}"
+  end
+end
+
+class MailerWorker
+  include Qe::Worker
+  queue :mail
+
+  def before
+    puts "=> Running before"
+  end
+
+  def perform
+    puts "=> Performing"
+    puts "=> Options: #{options.inspect}"
+  end
+
+  def after
+    puts "=> Running after"
+  end
+end

data/lib/qe.rb

@@ -0,0 +1,79 @@
+require "qe/immediate"
+require "qe/version"
+require "qe/worker"
+
+# In this wild world where a new asynchronous job processing
+# library is released every once in a while, Qe tries to keep a unified
+# interface that works with most famous libraries:
+#
+# # Sidekiq
+# # Resque
+# # DelayedJob
+# # Qu
+# # Beanstalk/Backburner
+#
+# See an example:
+#
+# You can choose an adapter:
+#
+#   Qe.adapter = Qe::Sidekiq
+#   Qe.adapter = Qe::Resque
+#   Qe.adapter = Qe::Qu
+#   Qe.adapter = Qe::DelayedJob
+#   Qe.adapter = Qe::Beanstalk
+#
+# Create our worker that will send e-mails through +ActionMailer+.
+#
+#   class MailerWorker
+#     include Qe::Worker
+#
+#     def perform
+#       Mailer.public_send(options[:mail], options).deliver
+#     end
+#   end
+#
+# Define our +Mailer+ class.
+#
+#   class Mailer < ActionMailer::Base
+#     def welcome(options)
+#       @options = options
+#       mail :to => options[:email]
+#     end
+#   end
+#
+# Enqueue a job to be processed asynchronously.
+#
+#   MailerWorker.enqueue({
+#     :mail => :welcome,
+#     :email => "john@example.org",
+#     :name => "John Doe"
+#   })
+#
+# == Testing support
+#
+# Qe comes with testing support. Just require the <tt>qe/testing.rb</tt> file
+# and a fake queuing adapter will be used. All enqueued jobs will be stored
+# at <tt>Qe.jobs</tt>. Note that this method is only available on testing mode.
+#
+#   require "qe/testing"
+#   Qe.adapter = Qe::Testing
+#
+# If you're using RSpec, you can require the <tt>qe/testing/rspec.rb</tt> file
+# instead. This will reset <tt>Qe.jobs</tt> before every spec and will add a
+# +enqueue+ matcher.
+#
+#   require "qe/testing/rspec"
+#
+#   describe "Enqueuing a job" do
+#     it "enqueues job" do
+#       expect {
+#         # do something
+#       }.to enqueue(MailerWorker).with(:email => "john@example.org")
+#     end
+#   end
+#
+module Qe
+  class << self
+    attr_accessor :adapter
+  end
+end

data/lib/qe/beanstalk.rb

@@ -0,0 +1,21 @@
+require "qe"
+require "backburner"
+
+module Qe
+  class Beanstalk
+    class Worker
+      include Backburner::Queue
+
+      def self.perform(*args)
+        Qe::Worker.perform(*args)
+      end
+    end
+
+    def self.enqueue(worker, options = {})
+      Worker.queue worker.queue
+      Backburner.enqueue Worker, worker.name, options
+    end
+  end
+
+  self.adapter = Beanstalk
+end

data/lib/qe/delayed_job.rb

@@ -0,0 +1,18 @@
+require "qe"
+require "delayed_job"
+
+module Qe
+  class DelayedJob
+    class Worker < Struct.new(:worker_name, :options)
+      def perform
+        Qe::Worker.perform(worker_name, options)
+      end
+    end
+
+    def self.enqueue(worker, options = {})
+      Delayed::Job.enqueue Worker.new(worker.name, options), :queue => worker.queue
+    end
+  end
+
+  self.adapter = DelayedJob
+end

data/lib/qe/immediate.rb

@@ -0,0 +1,7 @@
+module Qe
+  class Immediate
+    def self.enqueue(worker, options = {})
+      Qe::Worker.perform(worker.name, options)
+    end
+  end
+end

data/lib/qe/qu.rb

@@ -0,0 +1,21 @@
+require "qe"
+require "qu"
+
+module Qe
+  class Qu
+    class Worker
+      include ::Sidekiq::Worker
+
+      def self.perform(*args)
+        Qe::Worker.perform(*args)
+      end
+    end
+
+    def self.enqueue(worker, options = {})
+      Worker.instance_variable_set("@queue", worker.queue)
+      ::Qu.enqueue Worker, worker.name, options
+    end
+  end
+
+  self.adapter = Qu
+end

data/lib/qe/resque.rb

@@ -0,0 +1,19 @@
+require "qe"
+require "resque"
+
+module Qe
+  class Resque
+    class Worker
+      def self.perform(*args)
+        Qe::Worker.perform(*args)
+      end
+    end
+
+    def self.enqueue(worker, options = {})
+      Worker.instance_variable_set "@queue", worker.queue
+      ::Resque.enqueue Worker, worker.name, options
+    end
+  end
+
+  self.adapter = Resque
+end

data/lib/qe/sidekiq.rb

@@ -0,0 +1,21 @@
+require "qe"
+require "sidekiq"
+
+module Qe
+  class Sidekiq
+    class Worker
+      include ::Sidekiq::Worker
+
+      def perform(*args)
+        Qe::Worker.perform(*args)
+      end
+    end
+
+    def self.enqueue(worker, options = {})
+      Worker.sidekiq_options :queue => worker.queue
+      Worker.perform_async(worker.name, options)
+    end
+  end
+
+  self.adapter = Sidekiq
+end

data/lib/qe/testing.rb

@@ -0,0 +1,11 @@
+module Qe
+  def self.jobs
+    @jobs ||= []
+  end
+
+  class Testing
+    def self.enqueue(worker, options = {})
+      Qe.jobs << {:worker => worker, :options => options}
+    end
+  end
+end

data/lib/qe/testing/rspec.rb

@@ -0,0 +1,59 @@
+require "qe/testing"
+
+module Qe
+  module EnqueueMatcher
+    class Matcher
+      attr_reader :worker, :options
+
+      def initialize(worker)
+        @worker = worker
+      end
+
+      def with(options)
+        @options = options
+        self
+      end
+
+      def matches?(block)
+        block.call
+
+        Qe.jobs.find do |job|
+          condition = job[:worker] == worker
+          condition = condition && job[:options] == options if options
+          condition
+        end != nil
+      end
+
+      def description
+        "enqueue job for #{worker.inspect} worker"
+      end
+
+      def failure_message_for_should
+        build_message "expect #{worker.inspect} to be enqueued"
+      end
+
+      def failure_message_for_should_not
+        build_message "expect #{worker.inspect} not to be enqueued"
+      end
+
+      def build_message(base)
+        base << (options.empty? ? "" : " with #{options.inspect}")
+      end
+    end
+
+    #
+    #   expect {}.to enqueue(MailerWorker).with(options)
+    #
+    def enqueue(worker)
+      Matcher.new(worker)
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include Qe::EnqueueMatcher
+  config.before(:each) do
+    Qe.adapter = Qe::Testing
+    Qe.jobs.clear
+  end
+end

data/lib/qe/version.rb

@@ -0,0 +1,3 @@
+module Qe
+  VERSION = "0.1.3"
+end

data/lib/qe/worker.rb

@@ -0,0 +1,71 @@
+module Qe
+  module Worker
+    def self.included(base)
+      base.class_eval do
+        include InstanceMethods
+        extend ClassMethods
+      end
+    end
+
+    module InstanceMethods
+      def initialize(options)
+        @options = options
+      end
+
+      # Return options that were provided when
+      # adding job to the queue.
+      def options
+        @options
+      end
+
+      # Set before hook.
+      def before
+      end
+
+      # Set after hook.
+      def after
+      end
+
+      # Set the error hook.
+      def error(error)
+        raise error
+      end
+    end
+
+    module ClassMethods
+      # Enqueue job on given worker class.
+      def enqueue(options = {})
+        Qe.adapter.enqueue(self, options)
+      end
+
+      # Set the queue name when receiving on argument.
+      # Return queue name otherwise.
+      def queue(*args)
+        @queue = args.first unless args.empty?
+        (@queue || :default).to_s
+      end
+    end
+
+    # Find a worker by its name.
+    # If worker constant is not found, raises a +NameError+
+    # exception.
+    def self.find(name)
+      name.split("::").reduce(Object) do |const, name|
+        const.const_get(name)
+      end
+    end
+
+    # Perform the specified worker if given options.
+    def self.perform(worker_name, options)
+      find(worker_name).new(options).tap do |job|
+        begin
+          job.before
+          job.perform
+          job.after
+        rescue Exception => error
+          job.error(error)
+        end
+      end
+    end
+  end
+end