delayed_job_extras 0.4.3 → 0.9.0

data/lib/delayed_job_extras/action_mailer.rb

@@ -0,0 +1,36 @@
+if defined?(ActionMailer)
+  module ActionMailer
+    class Base
+        
+      def self.inherited(klass)
+        super
+        eval %{
+          class ::#{klass}Worker < DJ::Worker
+
+            attr_accessor :called_method
+            attr_accessor :args
+
+            def initialize(called_method, *args)
+              self.called_method = called_method
+              self.args = args
+            end
+
+            def perform
+              ::#{klass}.send(self.called_method, *self.args)
+            end
+            
+            class << self
+              
+              def method_missing(sym, *args)
+                ::#{klass}Worker.enqueue(sym, *args)
+              end
+              
+            end
+
+          end
+        }
+      end
+      
+    end # Base
+  end # ActionMailer
+end

data/lib/delayed_job_extras/extras.rb

@@ -0,0 +1,107 @@
+module Delayed
+  class Job
+    module Extras
+      
+      PRIORITY_LEVELS = {:immediate => 10000, :high => 1000, :medium => 500, :normal => 0, :low => -100, :who_cares => -1000}
+      
+      def self.included(klass)
+        klass.send(:include, Delayed::Job::Extras::InstanceMethods)
+        klass.extend(Delayed::Job::Extras::ClassMethods)
+        klass.class_eval do
+          class << self
+            def new_with_extras(*args)
+              klass = new_without_extras(*args)
+              klass.__original_args = *args
+              return klass
+            end
+
+            alias_method_chain :new, :extras
+          end
+        end
+      end
+      
+      module InstanceMethods
+        
+        attr_accessor :dj_object
+        attr_accessor :run_at
+        attr_accessor :priority
+        attr_accessor :logger
+        attr_accessor :worker_class_name
+        attr_accessor :__original_args
+        attr_accessor :__re_enqueue_block
+        attr_accessor :re_enqueuable
+
+        def priority
+          case @priority
+          when Symbol
+            Delayed::Job::Extras::PRIORITY_LEVELS[@priority] ||= 0
+          when Fixnum
+            @priority
+          else
+            0
+          end
+        end
+
+        def run_at
+          return @run_at ||= Time.now
+        end
+
+        def logger
+          @logger ||= self.class.logger
+        end
+        
+        def worker_class_name
+          @worker_class_name ||= self.class.to_s.underscore
+        end
+        
+        def enqueue(priority = self.priority, run_at = self.run_at)
+          Delayed::Job.enqueue(self, priority, run_at)
+        end
+        
+        alias_method :save, :enqueue
+        
+        def unique?
+          false
+        end
+        
+      end # InstanceMethods
+      
+      module ClassMethods
+        
+        @@logger = SplitLogger.new
+
+        def logger
+          @@logger
+        end
+
+        def logger=(logger)
+          @@logger = logger
+        end
+        
+        def priority(level = 0)
+          define_method('priority') do
+            if level.is_a?(Symbol)
+              level = Delayed::Job::Extras::PRIORITY_LEVELS[level] ||= 0
+            end
+            return @priority ||= level
+          end
+        end
+        
+        def enqueue(*args)
+          self.new(*args).enqueue
+        end
+        
+        def re_enqueue(&block)
+          define_method('re_enqueuable') do
+            true
+          end
+          define_method('__re_enqueue_block') do
+            block
+          end
+        end
+        
+      end # ClassMethods
+      
+    end # Extras
+  end # Job
+end # Delayed

data/lib/delayed_job_extras/hoptoad.rb

@@ -0,0 +1,28 @@
+begin
+  # If the hoptoad_notifier gem is available
+  # let's use it so we can get some good notifications
+  # when an exception is raised.
+  require 'hoptoad_notifier'
+  
+  DJ::Worker.logger.info "Adding Hoptoad support to Delayed::Job"
+  
+  module Delayed
+    class Job
+      include HoptoadNotifier::Catcher
+      
+      def invoke_job_with_hoptoad
+        begin
+          invoke_job_without_hoptoad
+        rescue Exception => e
+          notify_hoptoad(exception_to_data(e).merge(:dj => self.inspect))
+          raise e
+        end
+      end
+      
+      alias_method_chain :invoke_job, :hoptoad
+      
+    end # Job
+  end # Delayed
+  
+rescue Exception => e
+end

data/lib/delayed_job_extras/is_paranoid.rb

@@ -0,0 +1,19 @@
+begin
+  # If the is_paranoid gem is available
+  # let's use it so we can have a record of the
+  # tasks that have been performed.
+  require 'is_paranoid'
+  
+  DJ::Worker.logger.info "Adding is_paranoid support to Delayed::Job"
+  
+  module Delayed
+    class Job
+      include HoptoadNotifier::Catcher
+      
+      is_paranoid
+      
+    end # Job
+  end # Delayed
+  
+rescue Exception => e
+end

data/lib/delayed_job_extras/job.rb

@@ -1,41 +1,40 @@
 module Delayed
   class Job < ActiveRecord::Base
     
-    if (self.respond_to?(:is_paranoid))
-      is_paranoid
-    else
-      alias_method :count_with_destroyed, :count
-      alias_method :find_with_destroyed, :find
-    end
-    
-    def payload_object=(object)
-      self.worker_class_name = object.worker_class_name if object.respond_to?(:worker_class_name)
-      @payload_object = object
-      self['handler'] = object.to_yaml
-    end
-    
-    def invoke_job_with_dj
-      payload_object.dj_object = self if payload_object.respond_to?(:dj_object)
-      invoke_job_without_dj
+    def invoke_job_with_extras
+      begin
+        self.payload_object.dj_object = self
+        self.touch(:started_at)
+        DJ::Worker.logger.info("Starting #{self.payload_object.class.name}#perform (DJ.id = '#{self.id}')")
+        
+        invoke_job_without_extras
+        
+        DJ::Worker.logger.info("Completed #{self.payload_object.class.name}#perform (DJ.id = '#{self.id}') [SUCCESS]")
+        self.touch(:finished_at)
+      rescue Exception => e
+        DJ::Worker.logger.error("Halted #{self.payload_object.class.name}#perform (DJ.id = '#{self.id}') [FAILURE]")
+        self.update_attributes(:started_at => nil)
+        raise e
+      end
+      enqueue_again
     end
     
-    alias_method_chain :invoke_job, :dj
-    
-    def pending?
-      self.started_at.nil? && self.finished_at.nil?
-    end
+    alias_method_chain :invoke_job, :extras
     
-    def running?
-      !self.started_at.nil? && self.finished_at.nil?
-    end
     
-    def finished?
-      !self.started_at.nil? && !self.finished_at.nil?
+    def enqueue_again
+      if self.payload_object.re_enqueuable
+        new_worker = self.payload_object.class.new(*self.payload_object.__original_args)
+        if self.payload_object.__re_enqueue_block
+          self.payload_object.__re_enqueue_block.call(self.payload_object, new_worker)
+        end
+        new_worker.enqueue
+      end
     end
     
     def validate_with_unique
       validate_without_unique
-      if self['handler'] && self.payload_object && self.payload_object.is_a?(DJ::Worker) && self.new_record?
+      if self.payload_object.respond_to?(:unique?) && self.new_record?
         if self.payload_object.unique?
           if Delayed::Job.count(:all, :conditions => {:worker_class_name => self.worker_class_name, :finished_at => nil}) > 0
             self.errors.add_to_base("Only one #{self.worker_class_name} can be queued at a time!")
@@ -46,33 +45,21 @@ module Delayed
     
     alias_method_chain :validate, :unique
     
-    class << self
-      
-      def stats(start_date = 1.day.ago.beginning_of_day, end_date = Time.now.beginning_of_day)
-        workers = {}
-        Delayed::Job.find_with_destroyed(:all, :select => :worker_class_name, :group => :worker_class_name).each do |dj|
-          dj.worker_class_name = 'UNKNOWN' if dj.worker_class_name.blank?
-          workers[dj.worker_class_name] = {} 
-        end
-        workers.each do |worker, stats|
-          wname = (worker == 'UNKNOWN' ? nil : worker)
-          stats[:total] = Delayed::Job.count_with_destroyed(:conditions => {:worker_class_name => wname})
-          stats[:remaining] = Delayed::Job.count(:conditions => {:worker_class_name => wname})
-          stats[:processed] = stats[:total] - stats[:remaining]
-          stats[:failures] = Delayed::Job.count(:conditions => ['worker_class_name = ? and attempts > 1', wname])
-          if start_date
-            date_stats = {:start_date => start_date, :end_date => end_date}
-            date_stats[:total] = Delayed::Job.count_with_destroyed(:conditions => ['worker_class_name = ? and (created_at > ? and created_at < ?)', wname, start_date, end_date])
-            date_stats[:remaining] = Delayed::Job.count(:conditions => ['worker_class_name = ? and (created_at > ? and created_at < ?)', wname, start_date, end_date])
-            date_stats[:processed] = date_stats[:total] - date_stats[:remaining]
-            date_stats[:failures] = Delayed::Job.count(:conditions => ['worker_class_name = ? and attempts > 1 and (created_at > ? and created_at < ?)', wname, start_date, end_date])
-            stats[:date_range] = date_stats
-          end
-          workers[worker] = stats
-        end
-        workers
-      end
-      
+    def payload_object=(payload)
+      self.worker_class_name = payload.respond_to?(:worker_class_name) ? payload.worker_class_name : 'unknown'
+      self['handler'] = payload.to_yaml
+    end
+    
+    def pending?
+      self.started_at.nil? && self.finished_at.nil?
+    end
+    
+    def running?
+      !self.started_at.nil? && self.finished_at.nil?
+    end
+    
+    def finished?
+      !self.started_at.nil? && !self.finished_at.nil?
     end
     
   end # Job

data/lib/delayed_job_extras/performable_method.rb

@@ -1,41 +1,15 @@
 module Delayed
   class PerformableMethod
+    include Delayed::Job::Extras
     
     attr_accessor :worker_class_name
-    attr_accessor :dj_object
     
-    def initialize_with_worker_class_name(object, method, args)
-      self.worker_class_name = "#{object.class}__#{method}".underscore
-      initialize_without_worker_class_name(object, method, args)
+    def initialize_with_extras(object, method, args)
+      self.worker_class_name = "#{object.class.to_s.underscore}/#{method}"
+      initialize_without_extras(object, method, args)
     end
     
-    alias_method_chain :initialize, :worker_class_name
-    
-    if Object.const_defined?(:HoptoadNotifier)
-      include HoptoadNotifier::Catcher
-      
-      def perform_with_hoptoad
-        dj_id = 'unknown'
-        if self.dj_object
-          dj_id = self.dj_object.id
-          self.dj_object.touch(:started_at)
-        end
-        begin
-          DJ::Worker.logger.info("Starting #{self.class.name}#perform (DJ.id = '#{dj_id}')")
-          val = perform_without_hoptoad
-          DJ::Worker.logger.info("Completed #{self.class.name}#perform (DJ.id = '#{dj_id}') [SUCCESS]")
-          self.dj_object.touch(:finished_at) if self.dj_object
-          return val
-        rescue Exception => e
-          notify_hoptoad(exception_to_data(e).merge(:dj => self.dj_object.inspect))
-          DJ::Worker.logger.error("Halted #{self.class.name}#perform (DJ.id = '#{dj_id}') [FAILURE]")
-          self.dj_object.update_attributes(:started_at => nil) if self.dj_object
-          raise e
-        end
-      end
-    
-      alias_method_chain :perform, :hoptoad
-    end
+    alias_method_chain :initialize, :extras
     
   end # PerformableMethod
 end # Delayed

data/lib/delayed_job_extras/worker.rb

@@ -1,131 +1,6 @@
 module DJ
   class Worker
-    
-    PRIORITY_LEVELS = {:immediate => 10000, :high => 1000, :medium => 500, :normal => 0, :low => -100, :who_cares => -1000}
-    
-    attr_accessor :dj_object
-    attr_accessor :logger
-    attr_accessor :__original_args
-    
-    def initialize(*args)
-      self.__original_args = *args
-      return self
-    end
-    
-    def priority=(x)
-      @priority = x
-    end
-    
-    def priority
-      return @priority ||= 0
-    end
-    
-    def run_at=(x)
-      @run_at = x
-    end
-    
-    def run_at
-      return @run_at ||= Time.now
-    end
-    
-    if Object.const_defined?(:HoptoadNotifier)
-      include HoptoadNotifier::Catcher
-    else
-      def notify_hoptoad(e)
-        logger.error(e)
-      end
-    end
-    
-    def worker_class_name
-      self.class.to_s.underscore
-    end
-    
-    def logger
-      @logger || DJ::Worker.logger
-    end
-    
-    def enqueue(priority = self.priority, run_at = self.run_at)
-      Delayed::Job.enqueue(self, priority, run_at)
-    end
-    
-    def reenqueue
-      job = self.class.new(*self.__original_args)
-      yield job if block_given?
-      self.dj_object.touch(:finished_at) if self.dj_object
-      job.enqueue
-    end
-    
-    def unique?
-      false
-    end
-    
-    def before_perform
-    end
-    
-    def after_success
-    end
-    
-    def after_failure
-    end
-
-    class << self
-      
-      @@logger = SplitLogger.new
-      
-      def logger
-        @@logger
-      end
-      
-      def logger=(logger)
-        @@logger = logger
-      end
-      
-      def priority(level = 0)
-        define_method('priority') do
-          if level.is_a?(Symbol)
-            level = DJ::Worker::PRIORITY_LEVELS[level] ||= 0
-          end
-          return @priority ||= level
-        end
-      end
-      
-      # VideoWorker.encode(1) # => Delayed::Job.enqueue(VideoWorker.new(:encode, 1))
-      def method_missing(sym, *args)
-        self.enqueue(sym, *args)
-      end
-      
-      # VideoWorker.enqueue(1) # => Delayed::Job.enqueue(VideoWorker.new(1))
-      def enqueue(*args)
-        self.new(*args).enqueue
-      end
-      
-      def perform(&block)
-        define_method(:perform) do
-          dj_id = 'unknown'
-          if self.dj_object
-            dj_id = self.dj_object.id
-            self.dj_object.touch(:started_at)
-          end
-          begin
-            self.before_perform
-            self.logger.info("Starting #{self.class.name}#perform (DJ.id = '#{dj_id}')")
-            val = self.instance_eval(&block)
-            self.logger.info("Completed #{self.class.name}#perform (DJ.id = '#{dj_id}') [SUCCESS]")
-            self.dj_object.touch(:finished_at) if self.dj_object
-            self.after_success
-            return val
-          rescue Exception => e
-            # send to hoptoad!
-            notify_hoptoad(exception_to_data(e).merge(:dj => self.dj_object.inspect))
-            self.logger.error("Halted #{self.class.name}#perform (DJ.id = '#{dj_id}') [FAILURE]")
-            self.dj_object.update_attributes(:started_at => nil) if self.dj_object
-            self.after_failure
-            raise e
-          end
-        end
-      end
-
-    end
+    include Delayed::Job::Extras
     
   end # Worker
-end # Delayed
+end # DJ

data/lib/delayed_job_extras.rb

@@ -1,21 +1,12 @@
-begin
-  # If the hoptoad_notifier gem is available
-  # let's use it so we can get some good notifications
-  # when an exception is raised.
-  require 'hoptoad_notifier'
-rescue Exception => e
-end
+require 'split_logger'
 
-begin
-  # If the is_paranoid gem is available
-  # let's use it so we can have a record of the
-  # tasks that have been performed.
-  require 'is_paranoid'
-rescue Exception => e
-end
 
-require 'split_logger'
+path = File.join(File.dirname(__FILE__), 'delayed_job_extras')
+require File.join(path, 'extras')
+require File.join(path, 'job')
+require File.join(path, 'performable_method')
+require File.join(path, 'worker')
+require File.join(path, 'action_mailer')
 
-Dir.glob(File.join(File.dirname(__FILE__), 'delayed_job_extras', '**/*.rb')).each do |f|
-  require File.expand_path(f)
-end
+require File.join(path, 'hoptoad')
+require File.join(path, 'is_paranoid')

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: delayed_job_extras
 version: !ruby/object:Gem::Version 
-  version: 0.4.3
+  version: 0.9.0
 platform: ruby
 authors: 
 - markbates
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-03 00:00:00 -04:00
+date: 2009-10-04 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -32,6 +32,10 @@ extra_rdoc_files:
 - README
 - LICENSE
 files: 
+- lib/delayed_job_extras/action_mailer.rb
+- lib/delayed_job_extras/extras.rb
+- lib/delayed_job_extras/hoptoad.rb
+- lib/delayed_job_extras/is_paranoid.rb
 - lib/delayed_job_extras/job.rb
 - lib/delayed_job_extras/performable_method.rb
 - lib/delayed_job_extras/worker.rb