delayed_job_unique_key 0.0.1

data/lib/delayed/lifecycle.rb

@@ -0,0 +1,84 @@
+module Delayed
+  class InvalidCallback < Exception; end
+  
+  class Lifecycle
+    EVENTS = {
+      :enqueue => [:job], 
+      :execute => [:worker], 
+      :loop => [:worker], 
+      :perform => [:worker, :job], 
+      :error => [:worker, :job], 
+      :failure => [:worker, :job], 
+      :invoke_job => [:job]
+    }
+    
+    def initialize
+      @callbacks = EVENTS.keys.inject({}) { |hash, e| hash[e] = Callback.new; hash }
+    end
+    
+    def before(event, &block)
+      add(:before, event, &block)
+    end
+    
+    def after(event, &block)
+      add(:after, event, &block)
+    end
+    
+    def around(event, &block)
+      add(:around, event, &block)
+    end
+    
+    def run_callbacks(event, *args, &block)
+      missing_callback(event) unless @callbacks.has_key?(event)
+      
+      unless EVENTS[event].size == args.size
+        raise ArgumentError, "Callback #{event} expects #{EVENTS[event].size} parameter(s): #{EVENTS[event].join(', ')}"
+      end
+      
+      @callbacks[event].execute(*args, &block)
+    end
+    
+    private
+    
+      def add(type, event, &block)
+        missing_callback(event) unless @callbacks.has_key?(event)
+
+        @callbacks[event].add(type, &block)
+      end
+      
+      def missing_callback(event)
+        raise InvalidCallback, "Unknown callback event: #{event}"
+      end
+  end
+  
+  class Callback
+    def initialize
+      @before = []
+      @after = []
+      
+      # Identity proc. Avoids special cases when there is no existing around chain.
+      @around = lambda { |*args, &block| block.call(*args) }
+    end
+    
+    def execute(*args, &block)      
+      @before.each { |c| c.call(*args) }
+      result = @around.call(*args, &block)
+      @after.each { |c| c.call(*args) }
+      result
+    end
+    
+    def add(type, &callback)      
+      case type
+      when :before
+        @before << callback
+      when :after
+        @after << callback
+      when :around
+        chain = @around # use a local variable so that the current chain is closed over in the following lambda
+        @around = lambda { |*a, &block| chain.call(*a) { |*b| callback.call(*b, &block) } }
+      else
+        raise InvalidCallback, "Invalid callback type: #{type}"
+      end
+    end
+  end
+end

data/lib/delayed/message_sending.rb

@@ -0,0 +1,54 @@
+require 'active_support/basic_object'
+require 'active_support/core_ext/module/aliasing'
+
+module Delayed
+  class DelayProxy < ActiveSupport::BasicObject
+    def initialize(payload_class, target, options)
+      @payload_class = payload_class
+      @target = target
+      @options = options
+    end
+
+    def method_missing(method, *args)
+      Job.enqueue({:payload_object => @payload_class.new(@target, method.to_sym, args)}.merge(@options))
+    end
+  end
+
+  module MessageSending
+    def delay(options = {})
+      DelayProxy.new(PerformableMethod, self, options)
+    end
+    alias __delay__ delay
+
+    def send_later(method, *args)
+      warn "[DEPRECATION] `object.send_later(:method)` is deprecated. Use `object.delay.method"
+      __delay__.__send__(method, *args)
+    end
+
+    def send_at(time, method, *args)
+      warn "[DEPRECATION] `object.send_at(time, :method)` is deprecated. Use `object.delay(:run_at => time).method"
+      __delay__(:run_at => time).__send__(method, *args)
+    end
+
+    module ClassMethods
+      def handle_asynchronously(method, opts = {})
+        aliased_method, punctuation = method.to_s.sub(/([?!=])$/, ''), $1
+        with_method, without_method = "#{aliased_method}_with_delay#{punctuation}", "#{aliased_method}_without_delay#{punctuation}"
+        define_method(with_method) do |*args|
+          curr_opts = opts.clone
+          curr_opts.each_key do |key|
+            if (val = curr_opts[key]).is_a?(Proc)
+              curr_opts[key] = if val.arity == 1
+                val.call(self)
+              else
+                val.call
+              end
+            end
+          end
+          delay(curr_opts).__send__(without_method, *args)
+        end
+        alias_method_chain method, :delay
+      end
+    end
+  end
+end

data/lib/delayed/performable_mailer.rb

@@ -0,0 +1,21 @@
+require 'mail'
+
+module Delayed
+  class PerformableMailer < PerformableMethod
+    def perform
+      object.send(method_name, *args).deliver
+    end
+  end
+
+  module DelayMail
+    def delay(options = {})
+      DelayProxy.new(PerformableMailer, self, options)
+    end
+  end
+end
+
+Mail::Message.class_eval do
+  def delay(*args)
+    raise RuntimeError, "Use MyMailer.delay.mailer_action(args) to delay sending of emails."
+  end
+end

data/lib/delayed/performable_method.rb

@@ -0,0 +1,33 @@
+require 'active_support/core_ext/module/delegation'
+
+module Delayed
+  class PerformableMethod
+    attr_accessor :object, :method_name, :args
+
+    delegate :method, :to => :object
+
+    def initialize(object, method_name, args)
+      raise NoMethodError, "undefined method `#{method_name}' for #{object.inspect}" unless object.respond_to?(method_name, true)
+
+      self.object       = object
+      self.args         = args
+      self.method_name  = method_name.to_sym
+    end
+
+    def display_name
+      "#{object.class}##{method_name}"
+    end
+
+    def perform
+      object.send(method_name, *args) if object
+    end
+
+    def method_missing(symbol, *args)
+      object.send(symbol, *args)
+    end
+
+    def respond_to?(symbol, include_private=false)
+      super || object.respond_to?(symbol, include_private)
+    end
+  end
+end

data/lib/delayed/plugin.rb

@@ -0,0 +1,15 @@
+require 'active_support/core_ext/class/attribute'
+
+module Delayed
+  class Plugin
+    class_attribute :callback_block
+
+    def self.callbacks(&block)
+      self.callback_block = block
+    end
+
+    def initialize
+      self.class.callback_block.call(Delayed::Worker.lifecycle) if self.class.callback_block
+    end
+  end
+end

data/lib/delayed/plugins/clear_locks.rb

@@ -0,0 +1,15 @@
+module Delayed
+  module Plugins
+    class ClearLocks < Plugin
+      callbacks do |lifecycle|
+        lifecycle.around(:execute) do |worker, &block|
+          begin
+            block.call(worker)
+          ensure            
+            Delayed::Job.clear_locks!(worker.name)
+          end
+        end 
+      end
+    end
+  end
+end

data/lib/delayed/psych_ext.rb

@@ -0,0 +1,75 @@
+if defined?(ActiveRecord)
+  class ActiveRecord::Base
+    # serialize to YAML
+    def encode_with(coder)
+      coder["attributes"] = @attributes
+      coder.tag = ['!ruby/ActiveRecord', self.class.name].join(':')
+    end
+  end
+end
+
+class Delayed::PerformableMethod
+  # serialize to YAML
+  def encode_with(coder)
+    coder.map = {
+      "object" => object,
+      "method_name" => method_name,
+      "args" => args
+    }
+  end
+end
+
+module Psych
+  module Visitors
+    class YAMLTree
+      def visit_Class(klass)
+        tag = ['!ruby/class', klass.name].join(':')
+        register(klass, @emitter.start_mapping(nil, tag, false, Nodes::Mapping::BLOCK))
+        @emitter.end_mapping
+      end
+    end
+
+    class ToRuby
+      def visit_Psych_Nodes_Mapping_with_class(object)
+        return revive(Psych.load_tags[object.tag], object) if Psych.load_tags[object.tag]
+
+        case object.tag
+        when /^!ruby\/class:?(.*)?$/
+          resolve_class $1
+        when /^!ruby\/ActiveRecord:(.+)$/
+          klass = resolve_class($1)
+          payload = Hash[*object.children.map { |c| accept c }]
+          id = payload["attributes"][klass.primary_key]
+          begin
+            if ActiveRecord::VERSION::MAJOR == 3
+              klass.unscoped.find(id)
+            else # Rails 2
+              klass.with_exclusive_scope { klass.find(id) }
+            end
+          rescue ActiveRecord::RecordNotFound
+            raise Delayed::DeserializationError
+          end
+        when /^!ruby\/Mongoid:(.+)$/
+          klass = resolve_class($1)
+          payload = Hash[*object.children.map { |c| accept c }]
+          begin
+            klass.find(payload["attributes"]["_id"])
+          rescue Mongoid::Errors::DocumentNotFound
+            raise Delayed::DeserializationError
+          end
+        else
+          visit_Psych_Nodes_Mapping_without_class(object)
+        end
+      end
+      alias_method_chain :visit_Psych_Nodes_Mapping, :class
+
+      def resolve_class_with_constantize(klass_name)
+        klass_name.constantize
+      rescue
+        resolve_class_without_constantize(klass_name)
+      end
+      alias_method_chain :resolve_class, :constantize
+    end
+  end
+end
+

data/lib/delayed/railtie.rb

@@ -0,0 +1,16 @@
+require 'delayed_job'
+require 'rails'
+
+module Delayed
+  class Railtie < Rails::Railtie
+    initializer :after_initialize do
+      ActiveSupport.on_load(:action_mailer) do
+        ActionMailer::Base.send(:extend, Delayed::DelayMail)
+      end
+    end
+
+    rake_tasks do
+      load 'delayed/tasks.rb'
+    end
+  end
+end

data/lib/delayed/recipes.rb

@@ -0,0 +1,50 @@
+# Capistrano Recipes for managing delayed_job
+#
+# Add these callbacks to have the delayed_job process restart when the server
+# is restarted:
+#
+#   after "deploy:stop",    "delayed_job:stop"
+#   after "deploy:start",   "delayed_job:start"
+#   after "deploy:restart", "delayed_job:restart"
+#
+# If you want to use command line options, for example to start multiple workers,
+# define a Capistrano variable delayed_job_args:
+#
+#   set :delayed_job_args, "-n 2"
+#
+# If you've got delayed_job workers running on a servers, you can also specify
+# which servers have delayed_job running and should be restarted after deploy.
+#
+#   set :delayed_job_server_role, :worker
+#
+
+Capistrano::Configuration.instance.load do
+  namespace :delayed_job do
+    def rails_env
+      fetch(:rails_env, false) ? "RAILS_ENV=#{fetch(:rails_env)}" : ''
+    end
+    
+    def args
+      fetch(:delayed_job_args, "")
+    end
+    
+    def roles
+      fetch(:delayed_job_server_role, :app)
+    end
+    
+    desc "Stop the delayed_job process"
+    task :stop, :roles => lambda { roles } do
+      run "cd #{current_path};#{rails_env} script/delayed_job stop"
+    end
+
+    desc "Start the delayed_job process"
+    task :start, :roles => lambda { roles } do
+      run "cd #{current_path};#{rails_env} script/delayed_job start #{args}"
+    end
+
+    desc "Restart the delayed_job process"
+    task :restart, :roles => lambda { roles } do
+      run "cd #{current_path};#{rails_env} script/delayed_job restart #{args}"
+    end
+  end
+end

data/lib/delayed/serialization/active_record.rb

@@ -0,0 +1,19 @@
+if defined?(ActiveRecord)
+  class ActiveRecord::Base
+    yaml_as "tag:ruby.yaml.org,2002:ActiveRecord"
+
+    def self.yaml_new(klass, tag, val)
+      if ActiveRecord::VERSION::MAJOR == 3
+        klass.unscoped.find(val['attributes'][klass.primary_key])
+      else # Rails 2
+        klass.with_exclusive_scope { klass.find(val['attributes'][klass.primary_key]) }
+      end
+    rescue ActiveRecord::RecordNotFound
+      raise Delayed::DeserializationError
+    end
+
+    def to_yaml_properties
+      ['@attributes']
+    end
+  end
+end

data/lib/delayed/syck_ext.rb

@@ -0,0 +1,34 @@
+class Module
+  yaml_as "tag:ruby.yaml.org,2002:module"
+
+  def self.yaml_new(klass, tag, val)
+    klass
+  end
+
+  def to_yaml(options = {})
+    YAML.quick_emit(nil, options) do |out|
+      out.scalar(taguri, name, :plain)
+    end
+  end
+
+  def yaml_tag_read_class(name)
+    # Constantize the object so that ActiveSupport can attempt
+    # its auto loading magic. Will raise LoadError if not successful.
+    name.constantize
+    name
+  end
+end
+
+class Class
+  yaml_as "tag:ruby.yaml.org,2002:class"
+  remove_method :to_yaml if respond_to?(:to_yaml) && method(:to_yaml).owner == Class # use Module's to_yaml
+end
+
+class Struct
+  def self.yaml_tag_read_class(name)
+    # Constantize the object so that ActiveSupport can attempt
+    # its auto loading magic. Will raise LoadError if not successful.
+    name.constantize
+    "Struct::#{ name }"
+  end
+end

data/lib/delayed/tasks.rb

@@ -0,0 +1,11 @@
+namespace :jobs do
+  desc "Clear the delayed_job queue."
+  task :clear => :environment do
+    Delayed::Job.delete_all
+  end
+
+  desc "Start a delayed_job worker."
+  task :work => :environment do
+    Delayed::Worker.new(:min_priority => ENV['MIN_PRIORITY'], :max_priority => ENV['MAX_PRIORITY'], :queues => (ENV['QUEUES'] || ENV['QUEUE'] || '').split(','), :quiet => false).start
+  end
+end

data/lib/delayed/worker.rb

@@ -0,0 +1,222 @@
+require 'timeout'
+require 'active_support/core_ext/numeric/time'
+require 'active_support/core_ext/class/attribute_accessors'
+require 'active_support/core_ext/kernel'
+require 'active_support/core_ext/enumerable'
+require 'logger'
+
+module Delayed
+  class Worker
+    cattr_accessor :min_priority, :max_priority, :max_attempts, :max_run_time, :default_priority, :sleep_delay, :logger, :delay_jobs, :queues
+    self.sleep_delay = 5
+    self.max_attempts = 25
+    self.max_run_time = 4.hours
+    self.default_priority = 0
+    self.delay_jobs = true
+    self.queues = []
+
+    # Add or remove plugins in this list before the worker is instantiated
+    cattr_accessor :plugins
+    self.plugins = [Delayed::Plugins::ClearLocks]
+
+    # By default failed jobs are destroyed after too many attempts. If you want to keep them around
+    # (perhaps to inspect the reason for the failure), set this to false.
+    cattr_accessor :destroy_failed_jobs
+    self.destroy_failed_jobs = true
+
+    self.logger = if defined?(Rails)
+      Rails.logger
+    elsif defined?(RAILS_DEFAULT_LOGGER)
+      RAILS_DEFAULT_LOGGER
+    end
+
+    # name_prefix is ignored if name is set directly
+    attr_accessor :name_prefix
+
+    cattr_reader :backend
+
+    def self.backend=(backend)
+      if backend.is_a? Symbol
+        require "delayed/serialization/#{backend}" if YAML.parser.class.name =~ /syck/i
+        require "delayed/backend/#{backend}"
+        backend = "Delayed::Backend::#{backend.to_s.classify}::Job".constantize
+      end
+      @@backend = backend
+      silence_warnings { ::Delayed.const_set(:Job, backend) }
+    end
+
+    def self.guess_backend
+      warn "[DEPRECATION] guess_backend is deprecated. Please remove it from your code."
+    end
+
+    def self.before_fork
+      unless @files_to_reopen
+        @files_to_reopen = []
+        ObjectSpace.each_object(File) do |file|
+          @files_to_reopen << file unless file.closed?
+        end
+      end
+
+      backend.before_fork
+    end
+
+    def self.after_fork
+      # Re-open file handles
+      @files_to_reopen.each do |file|
+        begin
+          file.reopen file.path, "a+"
+          file.sync = true
+        rescue ::Exception
+        end
+      end
+
+      backend.after_fork
+    end
+
+    def self.lifecycle
+      @lifecycle ||= Delayed::Lifecycle.new
+    end
+
+    def initialize(options={})
+      @quiet = options.has_key?(:quiet) ? options[:quiet] : true
+      self.class.min_priority = options[:min_priority] if options.has_key?(:min_priority)
+      self.class.max_priority = options[:max_priority] if options.has_key?(:max_priority)
+      self.class.sleep_delay = options[:sleep_delay] if options.has_key?(:sleep_delay)
+      self.class.queues = options[:queues] if options.has_key?(:queues)
+
+      self.plugins.each { |klass| klass.new }
+    end
+
+    # Every worker has a unique name which by default is the pid of the process. There are some
+    # advantages to overriding this with something which survives worker retarts:  Workers can#
+    # safely resume working on tasks which are locked by themselves. The worker will assume that
+    # it crashed before.
+    def name
+      return @name unless @name.nil?
+      "#{@name_prefix}host:#{Socket.gethostname} pid:#{Process.pid}" rescue "#{@name_prefix}pid:#{Process.pid}"
+    end
+
+    # Sets the name of the worker.
+    # Setting the name to nil will reset the default worker name
+    def name=(val)
+      @name = val
+    end
+
+    def start
+      trap('TERM') { say 'Exiting...'; stop }
+      trap('INT')  { say 'Exiting...'; stop }
+
+      say "Starting job worker"
+
+      self.class.lifecycle.run_callbacks(:execute, self) do
+        loop do
+          self.class.lifecycle.run_callbacks(:loop, self) do
+            result = nil
+
+            realtime = Benchmark.realtime do
+              result = work_off
+            end
+
+            count = result.sum
+
+            break if @exit
+
+            if count.zero?
+              sleep(self.class.sleep_delay)
+            else
+              say "#{count} jobs processed at %.4f j/s, %d failed ..." % [count / realtime, result.last]
+            end
+          end
+
+          break if @exit
+        end
+      end
+    end
+
+    def stop
+      @exit = true
+    end
+
+    # Do num jobs and return stats on success/failure.
+    # Exit early if interrupted.
+    def work_off(num = 100)
+      success, failure = 0, 0
+
+      num.times do
+        case reserve_and_run_one_job
+        when true
+            success += 1
+        when false
+            failure += 1
+        else
+          break  # leave if no work could be done
+        end
+        break if $exit # leave if we're exiting
+      end
+
+      return [success, failure]
+    end
+
+    def run(job)
+      runtime =  Benchmark.realtime do
+        Timeout.timeout(self.class.max_run_time.to_i) { job.invoke_job }
+        job.destroy
+      end
+      say "#{job.name} completed after %.4f" % runtime
+      return true  # did work
+    rescue DeserializationError => error
+      job.last_error = "{#{error.message}\n#{error.backtrace.join("\n")}"
+      failed(job)
+    rescue Exception => error
+      self.class.lifecycle.run_callbacks(:error, self, job){ handle_failed_job(job, error) }
+      return false  # work failed
+    end
+
+    # Reschedule the job in the future (when a job fails).
+    # Uses an exponential scale depending on the number of failed attempts.
+    def reschedule(job, time = nil)
+      if (job.attempts += 1) < max_attempts(job)
+        time ||= job.reschedule_at
+        job.run_at = time
+        job.unlock
+        job.save!
+      else
+        say "PERMANENTLY removing #{job.name} because of #{job.attempts} consecutive failures.", Logger::INFO
+        failed(job)
+      end
+    end
+
+    def failed(job)
+      self.class.lifecycle.run_callbacks(:failure, self, job) do
+        job.hook(:failure)
+        self.class.destroy_failed_jobs ? job.destroy : job.fail!
+      end
+    end
+
+    def say(text, level = Logger::INFO)
+      text = "[Worker(#{name})] #{text}"
+      puts text unless @quiet
+      logger.add level, "#{Time.now.strftime('%FT%T%z')}: #{text}" if logger
+    end
+
+    def max_attempts(job)
+      job.max_attempts || self.class.max_attempts
+    end
+
+  protected
+
+    def handle_failed_job(job, error)
+      job.last_error = "{#{error.message}\n#{error.backtrace.join("\n")}"
+      say "#{job.name} failed with #{error.class.name}: #{error.message} - #{job.attempts} failed attempts", Logger::ERROR
+      reschedule(job)
+    end
+
+    # Run the next job we can get an exclusive lock on.
+    # If no jobs are left we return nil
+    def reserve_and_run_one_job
+      job = Delayed::Job.reserve(self)
+      self.class.lifecycle.run_callbacks(:perform, self, job){ result = run(job) } if job
+    end
+  end
+
+end

data/lib/delayed/yaml_ext.rb

@@ -0,0 +1,10 @@
+# These extensions allow properly serializing and autoloading of
+# Classes, Modules and Structs
+
+require 'yaml'
+if YAML.parser.class.name =~ /syck/i
+  require File.expand_path('../syck_ext', __FILE__)
+  require File.expand_path('../serialization/active_record', __FILE__)
+else
+  require File.expand_path('../psych_ext', __FILE__)
+end

data/lib/delayed_job.rb

@@ -0,0 +1,22 @@
+require 'active_support'
+
+require File.dirname(__FILE__) + '/delayed/message_sending'
+require File.dirname(__FILE__) + '/delayed/performable_method'
+
+# PerformableMailer is compatible with ActionMailer 3 (and possibly 3.1)
+if defined?(ActionMailer)
+  require 'action_mailer/version'
+  require File.dirname(__FILE__) + '/delayed/performable_mailer' if 3 == ActionMailer::VERSION::MAJOR
+end
+
+require File.dirname(__FILE__) + '/delayed/yaml_ext'
+require File.dirname(__FILE__) + '/delayed/lifecycle'
+require File.dirname(__FILE__) + '/delayed/plugin'
+require File.dirname(__FILE__) + '/delayed/plugins/clear_locks'
+require File.dirname(__FILE__) + '/delayed/backend/base'
+require File.dirname(__FILE__) + '/delayed/worker'
+require File.dirname(__FILE__) + '/delayed/deserialization_error'
+require File.dirname(__FILE__) + '/delayed/railtie' if defined?(Rails::Railtie)
+
+Object.send(:include, Delayed::MessageSending)
+Module.send(:include, Delayed::MessageSending::ClassMethods)