tresque 0.0.2

data/lib/tresque/resque_spec/resque_spec.rb

@@ -0,0 +1,201 @@
+require 'tresque/resque_spec/ext'
+require 'tresque/resque_spec/helpers'
+require 'tresque/resque_spec/matchers'
+
+module ResqueSpec
+
+  # methods to be made accessible for every spec
+  module BaseMethods
+
+    def run_resque_workers(options = {})
+      quantity = options.fetch(:quantity, 1)
+
+      quantity.times do
+        ResqueSpec.perform_all!
+      end
+    end
+
+  end
+
+
+  include ::Resque::Helpers
+  extend self
+
+  attr_accessor :inline
+  attr_accessor :disable_ext
+
+  def dequeue(queue_name, klass, *args)
+    queue_by_name(queue_name).delete_if do |job|
+      job[:class] == klass.to_s && args.empty? || job[:args] == args
+    end
+  end
+
+  def enqueue(queue_name, klass, *args)
+    perform_or_store(queue_name, :class => klass.to_s, :args => args)
+  end
+
+  def perform_next(queue_name)
+    perform(queue_name, shift_queue(queue_name))
+  end
+
+  def perform_all(queue_name)
+    while job = shift_queue(queue_name)
+      perform(queue_name, job)
+    end
+  end
+
+  def shift_queue(queue_name)
+    # pass scheduled ones
+    array = queue_by_name(queue_name) || []
+    index = nil
+    array.each_with_index do |hash, i|
+      if hash[:time].to_i <= Time.now.to_i
+        index = i
+        break
+      end
+    end
+    return nil unless index
+    array.delete_at(index)
+  end
+
+  def pop(queue_name)
+    return unless payload = shift_queue(queue_name)
+    new_job(queue_name, payload)
+  end
+
+  def queue_by_name(name)
+    queues[name.to_s]
+  end
+
+  def queue_for(klass)
+    queue_by_name(queue_name(klass))
+  end
+
+  def peek(queue_name, start = 0, count = 1)
+    queue_by_name(queue_name).slice(start, count)
+  end
+
+  def queue_name(klass)
+    if klass.is_a?(String)
+      klass = Kernel.const_get(klass) rescue nil
+    end
+
+    name_from_instance_var(klass) or
+      name_from_queue_accessor(klass) or
+        raise ::Resque::NoQueueError.new("Jobs must be placed onto a queue.")
+  end
+
+  def queues
+    @queues ||= Hash.new {|h,k| h[k] = []}
+  end
+
+  def delete_all(queue_name)
+    queue = "queue:#{queue_name}"
+    Resque.redis.del(queue)
+    reset!
+  end
+
+  def perform_all!
+    ::TResque::Registry.queues.each do |queue_name|
+      ResqueSpec.perform_all(queue_name)
+    end
+  end
+
+  # Check if we have queued a delayed worker for `klass` with `*args`
+  # Very slow, checks every `delayed` key
+  def delayed?(klass, *args)
+    klass = klass.to_s unless klass.is_a? String
+    [*Resque.redis.keys("delayed:*")].each do |key|
+      [*Resque.redis.lrange(key, 0, -1)].each do |item|
+        parsed_item = JSON.parse(item)
+        return true if parsed_item['class'] == klass && parsed_item['args'] == [*args]
+      end
+    end
+
+    false
+  end
+
+  # Get back the key of the delayed worker if it exists
+  def delayed_key(klass, *args)
+    klass = klass.to_s unless klass.is_a? String
+    [*Resque.redis.keys("delayed:*")].each do |key|
+      [*Resque.redis.lrange(key, 0, -1)].each do |item|
+        parsed_item = JSON.parse(item)
+        return key if parsed_item['class'] == klass && parsed_item['args'] == [*args]
+      end
+    end
+
+    nil
+  end
+
+  # check if the worker has a lock with the provided args
+  def locked?(klass, *args)
+    klass = klass.to_s unless klass.is_a? String
+
+    key = "lock:#{klass}-#{[*args].join('-')}"
+    Resque.redis.keys(key).present?
+  end
+
+  def clear_locked!
+    [*Resque.redis.keys("lock:*")].each do |key|
+      Resque.redis.del(key)
+    end
+  end
+
+  def clear_all!
+    [*Resque.redis.keys].each do |key|
+      Resque.redis.del(key)
+    end
+  end
+
+  def reset!
+    clear_all!
+    queues.clear
+    self.inline = false
+  end
+
+  private
+
+  def name_from_instance_var(klass)
+    klass.instance_variable_get(:@queue)
+  end
+
+  def name_from_queue_accessor(klass)
+    klass.respond_to?(:queue) and klass.queue
+  end
+
+  def new_job(queue_name, payload)
+    Resque::Job.new(queue_name, payload_with_string_keys(payload))
+  end
+
+  def perform(queue_name, payload)
+    prev = ENV['QUEUE']
+    ENV['QUEUE'] = queue_name
+    new_job(queue_name, payload).perform
+  ensure
+    ENV['QUEUE'] = prev
+  end
+
+  def perform_or_store(queue_name, payload)
+    if inline
+      perform(queue_name, payload)
+    else
+      store(queue_name, payload)
+    end
+  end
+
+  def store(queue_name, payload)
+    queue_by_name(queue_name) << payload
+  end
+
+  def payload_with_string_keys(payload)
+    {
+      'class' => payload[:class],
+      'args' => decode(encode(payload[:args])),
+      'stored_at' => payload[:stored_at]
+    }
+  end
+end
+
+config = RSpec.configuration
+config.include ::ResqueSpec::Helpers

data/lib/tresque/resque_spec/scheduler.rb

@@ -0,0 +1,93 @@
+require_relative 'resque_spec'
+
+module ResqueSpec
+  module SchedulerExt
+    def self.extended(klass)
+      if klass.respond_to? :enqueue_at
+        klass.instance_eval do
+          alias :enqueue_at_without_resque_spec :enqueue_at
+          alias :enqueue_in_without_resque_spec :enqueue_in
+          alias :remove_delayed_without_resque_spec :remove_delayed
+        end
+      end
+      klass.extend(ResqueSpec::SchedulerExtMethods)
+    end
+  end
+
+  module SchedulerExtMethods
+    def enqueue_at(time, klass, *args)
+      return enqueue_at_without_resque_spec(time, klass, *args) if ResqueSpec.disable_ext && respond_to?(:enqueue_at_without_resque_spec)
+
+      ResqueSpec.enqueue_at(time, klass, *args)
+    end
+
+    def enqueue_at_with_queue(queue, time, klass, *args)
+      return enqueue_at_with_queue_without_resque_spec(time, klass, *args) if ResqueSpec.disable_ext && respond_to?(:enqueue_at_with_queue_without_resque_spec)
+
+      ResqueSpec.enqueue_at_with_queue(queue, time, klass, *args)
+    end
+
+    def enqueue_in(time, klass, *args)
+      return enqueue_in_without_resque_spec(time, klass, *args) if ResqueSpec.disable_ext && respond_to?(:enqueue_in_without_resque_spec)
+
+      ResqueSpec.enqueue_in(time, klass, *args)
+    end
+
+    def enqueue_in_with_queue(queue, time, klass, *args)
+      return enqueue_in_with_queue_without_resque_spec(time, klass, *args) if ResqueSpec.disable_ext && respond_to?(:enqueue_in_with_queue_without_resque_spec)
+
+      ResqueSpec.enqueue_in_with_queue(queue, time, klass, *args)
+    end
+
+    def remove_delayed(klass, *args)
+      return remove_delayed_without_resque_spec(klass, *args) if ResqueSpec.disable_ext && respond_to?(:remove_delayed_without_resque_spec)
+
+      ResqueSpec.remove_delayed(klass, *args)
+    end
+  end
+
+  def enqueue_at(time, klass, *args)
+    enqueue_at_with_queue(schedule_queue_name(klass), time, klass, *args)
+  end
+
+  def enqueue_at_with_queue(queue, time, klass, *args)
+    is_time?(time)
+    perform_or_store(queue, :class => klass.to_s, :time  => time, :stored_at => Time.now, :args => args)
+  end
+
+  def enqueue_in(time, klass, *args)
+    enqueue_at(Time.now + time, klass, *args)
+  end
+
+  def enqueue_in_with_queue(queue, time, klass, *args)
+    enqueue_at_with_queue(queue, Time.now + time, klass, *args)
+  end
+
+  def remove_delayed(klass, *args)
+    sched_queue = queue_by_name(schedule_queue_name(klass))
+    count_before_remove = sched_queue.length
+    sched_queue.delete_if do |job|
+      job[:class] == klass.to_s && job[:args] == args
+    end
+    # Return number of removed items to match Resque Scheduler behaviour
+    count_before_remove - sched_queue.length
+  end
+
+  def schedule_for(klass)
+    queue_by_name(schedule_queue_name(klass))
+  end
+
+  private
+
+  def is_time?(time)
+    time.to_i
+  end
+
+  def schedule_queue_name(klass)
+    # "#{queue_name(klass)}_scheduled"
+    # we use the real one
+    queue_name(klass)
+  end
+end
+
+Resque.extend(ResqueSpec::SchedulerExt)

data/lib/tresque/spec.rb

@@ -0,0 +1,2 @@
+require 'tresque/resque_spec/resque_spec'
+require 'tresque/resque_spec/scheduler'

data/lib/tresque/spec/delay.rb

@@ -0,0 +1,27 @@
+module TResque
+  module Spec
+    module Delay
+
+      def delay_object
+        TResque::Delay::InvocationProxy.any_instance
+      end
+
+      def without_delay
+        return yield unless Rails.env.test?
+        
+        q   = ENV['QUEUE']
+        qs  = ENV['QUEUES']
+
+        ENV['QUEUE']  = "v3_default"
+        ENV['QUEUES'] = nil
+
+        yield
+
+      ensure
+        ENV['QUEUE']  = q
+        ENV['QUEUES'] = qs
+      end
+
+    end
+  end
+end

data/lib/tresque/util.rb

@@ -0,0 +1,16 @@
+module TResque
+  module Util
+    extend self
+
+    def normalize(val)
+      val.to_s.gsub(/\W/, "_").downcase
+    end
+    
+    def calculate_namespace_from_class(klass)
+      klass = klass.class unless klass.is_a?(Class)
+      pieces = klass.name.to_s.split("::")
+      return "worker" if pieces.size < 2
+      pieces.first.underscore
+    end
+  end
+end

data/lib/tresque/version.rb

@@ -0,0 +1,3 @@
+module TResque
+  VERSION = "0.0.2"
+end

data/lib/tresque/worker.rb

@@ -0,0 +1,228 @@
+require 'resque-retry'
+require 'digest/sha1'
+
+module TResque
+  module Worker
+    extend ::ActiveSupport::Concern
+
+    mattr_accessor :skip_check_queues
+
+    included do
+      extend ::Resque::Plugins::ExponentialBackoff
+      TResque::Registry.worker(self)
+    end
+
+    module ClassMethods
+      def queue(name=nil)
+        return @requeue_in_queue if !name && @requeue_in_queue
+        return @queue if !name && @queue
+        name ||= :default
+        full_queue("#{app_key}_#{name}")
+      end
+
+      def full_queue(name)
+        @queue = name.to_s
+      end
+
+      def application(app_key)
+        @app_key = Util.normalize(app_key)
+      end
+
+      def app_key
+        return @app_key if @app_key
+        @app_key = Util.calculate_namespace_from_class(self)
+      end
+
+      def enqueue(options = {})
+        options = options.with_indifferent_access
+
+        options[:locale] ||= I18n.locale.to_s
+        options[:tz]     ||= Time.zone.name
+
+        run_at = options.delete(:run_at)
+        if options[:full_queue]
+          queue_name = options[:full_queue]
+        elsif options[:queue] || options[:queue_namespace]
+          namespace = options[:queue_namespace] || self.app_key
+          queue = options[:queue] || "default"
+          queue_name = "#{namespace}_#{queue}"
+        else
+          queue_name = self.queue
+        end
+
+        if queue_name == "t_resque_default"
+          message = "QUEUE_ERROR (#{self.class.name}): #{queue_name} will not be worked!"
+          Rails.logger.error(message)
+          puts message if Rails.env.test?
+        end
+
+        if !TResque::Worker.skip_check_queues && !TResque::Registry.queues.include?(queue_name)
+          message = "QUEUE_ERROR (#{self.class.name}): #{queue_name} will not be worked!"
+          Rails.logger.error(message)
+          puts message if Rails.env.test?
+        end
+
+        options[:full_queue] = queue_name
+        if run_at
+          Resque.enqueue_at_with_queue(queue_name, run_at, self, options)
+        else
+          Resque.enqueue_to(queue_name, self, options)
+        end
+
+        # too many events
+        # QueueBus.publish_log(:worker_enqueued, {
+        #   options: options,
+        #   queue_name:  queue_name,
+        #   worker_name: self.name.to_s,
+        #   run_at: run_at.to_i
+        # }) unless Rails.env.test?
+
+        options
+      end
+
+      def perform(options)
+        Waistband.clear_logs if Waistband.config.logging
+
+        @previous_locale, @previous_zone = I18n.locale, Time.zone
+
+        options = options.with_indifferent_access
+        obj = self.new(options.except(:locale, :tz, :bus_locale, :bus_timezone))
+
+        locale = obj.respond_to?(:calculate_locale, true) ? obj.send(:calculate_locale) : nil
+        locale ||= options[:locale]
+        locale ||= options[:bus_locale]
+        locale ||= I18n.locale if Rails.env.production?  # don't crash in production, use default
+
+        zone = obj.respond_to?(:calculate_timezone, true) ? obj.send(:calculate_timezone) : nil
+        zone ||= options[:tz]
+        zone ||= options[:bus_timezone]
+
+        I18n.locale = locale
+        Time.zone   = zone
+
+        # too many events
+        # QueueBus.publish_log(:worker_perform, {
+        #   options: options,
+        #   worker_name: self.name.to_s,
+        #   locale:  locale,
+        #   time_zone: zone
+        # }) unless Rails.env.test?
+
+        obj.worker_perform
+      rescue Resque::Job::DontPerform
+        # it's cool
+      ensure
+        # write waistband logs
+        Waistband.write_logs(nil) if Waistband.config.logging
+        # reset
+        I18n.locale, Time.zone = @previous_locale, @previous_zone
+      end
+
+      def inputs(*args)
+        args.each do |name|
+          define_method name do
+            enqueued_options[name]
+          end
+        end
+      end
+      alias_method :input, :inputs
+
+      def turn_retry_off
+        @retry_limit = 0
+      end
+
+      def lock_namespace(val)
+        @lock_namespace = val.to_s
+      end
+
+      def worker_lock(*args)
+        raise ("worker_lock: what should i lock on?") if args.size == 0
+        extend ::TResque::WorkerLock
+        @worker_lock_attributes = args.collect(&:to_s)
+      end
+
+      def queue_lock(*args)
+        raise ("queue_lock: what should i lock on?") if args.size == 0
+        extend ::TResque::QueueLock
+        @queue_lock_attributes = args.collect(&:to_s)
+      end
+
+      def get_lock_namespace(options)
+        @lock_namespace ||= self.name
+      end
+
+      def get_queue_lock_attributes(options)
+        @queue_lock_attributes  ||= []
+      end
+
+      def get_worker_lock_attributes(options)
+        @worker_lock_attributes ||= []
+      end
+
+      def queue_lock_key(options)
+        options_lock_key(options, get_queue_lock_attributes(options))
+      end
+
+      def worker_lock_key(options)
+        options_lock_key(options, get_worker_lock_attributes(options))
+      end
+
+      def options_lock_key(options, keys)
+        return nil unless keys  # not actually locking
+
+        keys = ["all"] if keys.size == 0
+        keys = options.keys if keys.size == 1 && keys.first == "all"
+        keys.sort!
+
+        vals = [get_lock_namespace(options)]
+        keys.each do |key|
+          vals << key
+          vals << options[key].to_s
+        end
+        Digest::SHA1.hexdigest(vals.join("-"))
+      end
+
+      # make sure we put it back in the same queue
+      # @failure_hooks_already_ran on https://github.com/defunkt/resque/tree/1-x-stable
+      # to prevent running twice
+      def on_failure_aaa(exception, *args)
+        # note: sorted alphabetically
+        # queue needs to be set for rety to work (know what queue in Requeue.class_to_queue)
+        @requeue_in_queue = args[0]["full_queue"]
+      end
+
+      def on_failure_zzz(exception, *args)
+        # note: sorted alphabetically
+        @requeue_in_queue = nil
+      end
+    end
+
+    attr_reader :enqueued_options
+    def initialize(options = {})
+      @enqueued_options = options.with_indifferent_access
+    end
+
+    def worker_perform
+      to_call = self.enqueued_options[:action] || :work
+      send(to_call)
+    end
+
+    def requeue_delay_seconds
+      1
+    end
+
+    def requeue
+      self.enqueued_options["run_at"] = nil
+      delay = self.requeue_delay_seconds
+      if delay > 0
+        self.enqueued_options["run_at"] = delay.seconds.from_now
+      end
+      self.class.enqueue(self.enqueued_options)
+    end
+
+    def requeue!
+      requeue
+      raise Resque::Job::DontPerform
+    end
+  end
+end