drewda_delayed_job 3.0.3

data/lib/delayed/command.rb

@@ -0,0 +1,108 @@
+begin
+  require 'daemons'
+rescue LoadError
+  raise "You need to add gem 'daemons' to your Gemfile if you wish to use it."
+end
+require 'optparse'
+
+module Delayed
+  class Command
+    attr_accessor :worker_count
+
+    def initialize(args)
+      @options = {
+        :quiet => true,
+        :pid_dir => "#{Rails.root}/tmp/pids"
+      }
+
+      @worker_count = 1
+      @monitor = false
+
+      opts = OptionParser.new do |opts|
+        opts.banner = "Usage: #{File.basename($0)} [options] start|stop|restart|run"
+
+        opts.on('-h', '--help', 'Show this message') do
+          puts opts
+          exit 1
+        end
+        opts.on('-e', '--environment=NAME', 'Specifies the environment to run this delayed jobs under (test/development/production).') do |e|
+          STDERR.puts "The -e/--environment option has been deprecated and has no effect. Use RAILS_ENV and see http://github.com/collectiveidea/delayed_job/issues/#issue/7"
+        end
+        opts.on('--min-priority N', 'Minimum priority of jobs to run.') do |n|
+          @options[:min_priority] = n
+        end
+        opts.on('--max-priority N', 'Maximum priority of jobs to run.') do |n|
+          @options[:max_priority] = n
+        end
+        opts.on('-n', '--number_of_workers=workers', "Number of unique workers to spawn") do |worker_count|
+          @worker_count = worker_count.to_i rescue 1
+        end
+        opts.on('--pid-dir=DIR', 'Specifies an alternate directory in which to store the process ids.') do |dir|
+          @options[:pid_dir] = dir
+        end
+        opts.on('-i', '--identifier=n', 'A numeric identifier for the worker.') do |n|
+          @options[:identifier] = n
+        end
+        opts.on('-m', '--monitor', 'Start monitor process.') do
+          @monitor = true
+        end
+        opts.on('--sleep-delay N', "Amount of time to sleep when no jobs are found") do |n|
+          @options[:sleep_delay] = n.to_i
+        end
+        opts.on('--read-ahead N', "Number of jobs from the queue to consider") do |n|
+          @options[:read_ahead] = n
+        end
+        opts.on('-p', '--prefix NAME', "String to be prefixed to worker process names") do |prefix|
+          @options[:prefix] = prefix
+        end
+        opts.on('--queues=queues', "Specify which queue DJ must look up for jobs") do |queues|
+          @options[:queues] = queues.split(',')
+        end
+        opts.on('--queue=queue', "Specify which queue DJ must look up for jobs") do |queue|
+          @options[:queues] = queue.split(',')
+        end
+      end
+      @args = opts.parse!(args)
+    end
+
+    def daemonize
+      dir = @options[:pid_dir]
+      Dir.mkdir(dir) unless File.exists?(dir)
+
+      if @worker_count > 1 && @options[:identifier]
+        raise ArgumentError, 'Cannot specify both --number-of-workers and --identifier'
+      elsif @worker_count == 1 && @options[:identifier]
+        process_name = "delayed_job.#{@options[:identifier]}"
+        run_process(process_name, dir)
+      else
+        worker_count.times do |worker_index|
+          process_name = worker_count == 1 ? "delayed_job" : "delayed_job.#{worker_index}"
+          run_process(process_name, dir)
+        end
+      end
+    end
+
+    def run_process(process_name, dir)
+      Delayed::Worker.before_fork
+      Daemons.run_proc(process_name, :dir => dir, :dir_mode => :normal, :monitor => @monitor, :ARGV => @args) do |*args|
+        $0 = File.join(@options[:prefix], process_name) if @options[:prefix]
+        run process_name
+      end
+    end
+
+    def run(worker_name = nil)
+      Dir.chdir(Rails.root)
+
+      Delayed::Worker.after_fork
+      Delayed::Worker.logger ||= Logger.new(File.join(Rails.root, 'log', 'delayed_job.log'))
+
+      worker = Delayed::Worker.new(@options)
+      worker.name_prefix = "#{worker_name} "
+      worker.start
+    rescue => e
+      Rails.logger.fatal e
+      STDERR.puts e.message
+      exit 1
+    end
+  end
+end

data/lib/delayed/deserialization_error.rb

@@ -0,0 +1,4 @@
+module Delayed
+  class DeserializationError < StandardError
+  end
+end

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,37 @@
+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)
+
+      if defined?(ActiveRecord) && object.kind_of?(ActiveRecord::Base)
+        raise(ArgumentError, 'Jobs cannot be created for records before they\'ve been persisted') if object.attributes[object.class.primary_key].nil?
+      end
+
+      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,132 @@
+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)
+        @emitter.scalar klass.name, nil, '!ruby/class', false, false, Nodes::Scalar::SINGLE_QUOTED
+      end
+    end
+
+    class ToRuby
+      def visit_Psych_Nodes_Scalar(o)
+        @st[o.anchor] = o.value if o.anchor
+
+        if klass = Psych.load_tags[o.tag]
+          instance = klass.allocate
+
+          if instance.respond_to?(:init_with)
+            coder = Psych::Coder.new(o.tag)
+            coder.scalar = o.value
+            instance.init_with coder
+          end
+
+          return instance
+        end
+
+        return o.value if o.quoted
+        return @ss.tokenize(o.value) unless o.tag
+
+        case o.tag
+        when '!binary', 'tag:yaml.org,2002:binary'
+          o.value.unpack('m').first
+        when '!str', 'tag:yaml.org,2002:str'
+          o.value
+        when "!ruby/object:DateTime"
+          require 'date'
+          @ss.parse_time(o.value).to_datetime
+        when "!ruby/object:Complex"
+          Complex(o.value)
+        when "!ruby/object:Rational"
+          Rational(o.value)
+        when "!ruby/class", "!ruby/module"
+          resolve_class o.value
+        when "tag:yaml.org,2002:float", "!float"
+          Float(@ss.tokenize(o.value))
+        when "!ruby/regexp"
+          o.value =~ /^\/(.*)\/([mixn]*)$/
+          source  = $1
+          options = 0
+          lang    = nil
+          ($2 || '').split('').each do |option|
+            case option
+            when 'x' then options |= Regexp::EXTENDED
+            when 'i' then options |= Regexp::IGNORECASE
+            when 'm' then options |= Regexp::MULTILINE
+            when 'n' then options |= Regexp::NOENCODING
+            else lang = option
+            end
+          end
+          Regexp.new(*[source, options, lang].compact)
+        when "!ruby/range"
+          args = o.value.split(/([.]{2,3})/, 2).map { |s|
+            accept Nodes::Scalar.new(s)
+          }
+          args.push(args.delete_at(1) == '...')
+          Range.new(*args)
+        when /^!ruby\/sym(bol)?:?(.*)?$/
+          o.value.to_sym
+        else
+          @ss.tokenize o.value
+        end
+      end
+
+      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\/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