topprospect-delayed_job 2.0.5

data/lib/delayed/backend/data_mapper.rb

@@ -0,0 +1,121 @@
+require 'dm-core'
+require 'dm-observer'
+require 'dm-aggregates'
+
+DataMapper::Resource.class_eval do
+  yaml_as "tag:ruby.yaml.org,2002:DataMapper"
+
+  def self.yaml_new(klass, tag, val)
+    klass.find(val['id'])
+  end
+
+  def to_yaml_properties
+    ['@id']
+  end
+end
+
+module Delayed
+  module Backend
+    module DataMapper
+      class Job
+        include ::DataMapper::Resource
+        include Delayed::Backend::Base
+        
+        storage_names[:default] = 'delayed_jobs'
+        
+        property :id,          Serial
+        property :priority,    Integer, :default => 0, :index => :run_at_priority
+        property :attempts,    Integer, :default => 0
+        property :handler,     Text, :lazy => false
+        property :run_at,      Time, :index => :run_at_priority
+        property :locked_at,   Time, :index => true
+        property :locked_by,   String
+        property :failed_at,   Time
+        property :last_error,  Text
+                
+        def self.db_time_now
+          Time.now
+        end
+                
+        def self.find_available(worker_name, limit = 5, max_run_time = Worker.max_run_time)
+          
+          simple_conditions = { :run_at.lte => db_time_now, :limit => limit, :failed_at => nil, :order => [:priority.asc, :run_at.asc]  }
+
+          # respect priorities
+          simple_conditions[:priority.gte] = Worker.min_priority if Worker.min_priority
+          simple_conditions[:priority.lte] = Worker.max_priority if Worker.max_priority
+          
+          # lockable 
+          lockable = (
+            # not locked or past the max time
+            ( all(:locked_at => nil ) | all(:locked_at.lt => db_time_now - max_run_time)) |
+
+            # OR locked by our worker
+            all(:locked_by => worker_name))
+            
+          # plus some other boring junk 
+          (lockable).all( simple_conditions )
+        end
+        
+        # When a worker is exiting, make sure we don't have any locked jobs.
+        def self.clear_locks!(worker_name)
+          all(:locked_by => worker_name).update(:locked_at => nil, :locked_by => nil)
+        end
+        
+        # Lock this job for this worker.
+        # Returns true if we have the lock, false otherwise.
+        def lock_exclusively!(max_run_time, worker = worker_name)
+
+          now = self.class.db_time_now
+          overtime = now - max_run_time
+          
+          # FIXME - this is a bit gross
+          # DM doesn't give us the number of rows affected by a collection update
+          # so we have to circumvent some niceness in DM::Collection here
+          collection = locked_by != worker ?
+            (self.class.all(:id => id, :run_at.lte => now) & ( self.class.all(:locked_at => nil) | self.class.all(:locked_at.lt => overtime) ) ) :
+            self.class.all(:id => id, :locked_by => worker)
+          
+          attributes = collection.model.new(:locked_at => now, :locked_by => worker).dirty_attributes
+          affected_rows = self.repository.update(attributes, collection)
+            
+          if affected_rows == 1
+            self.locked_at = now
+            self.locked_by = worker
+            return true
+          else
+            return false
+          end
+        end
+        
+        # these are common to the other backends, so we provide an implementation
+        def self.delete_all
+          Delayed::Job.auto_migrate!
+        end
+        
+        def self.find id
+          get id
+        end
+        
+        def update_attributes(attributes)
+          attributes.each do |k,v|
+            self[k] = v
+          end
+          self.save
+        end
+        
+        
+      end
+      
+      class JobObserver
+        include ::DataMapper::Observer
+
+        observe Job
+
+        before :save do
+          self.run_at ||= self.class.db_time_now
+        end  
+      end
+    end
+  end
+end

data/lib/delayed/backend/mongo_mapper.rb

@@ -0,0 +1,106 @@
+require 'mongo_mapper'
+
+MongoMapper::Document.class_eval do
+  yaml_as "tag:ruby.yaml.org,2002:MongoMapper"
+  
+  def self.yaml_new(klass, tag, val)
+    klass.find(val['_id'])
+  end
+
+  def to_yaml_properties
+    ['@_id']
+  end
+end
+
+module Delayed
+  module Backend
+    module MongoMapper
+      class Job
+        include ::MongoMapper::Document
+        include Delayed::Backend::Base
+        set_collection_name 'delayed_jobs'
+        
+        key :priority,    Integer, :default => 0
+        key :attempts,    Integer, :default => 0
+        key :handler,     String
+        key :run_at,      Time
+        key :locked_at,   Time
+        key :locked_by,   String, :index => true
+        key :failed_at,   Time
+        key :last_error,  String
+        timestamps!
+        
+        before_save :set_default_run_at
+
+        ensure_index [[:priority, 1], [:run_at, 1]]
+        
+        def self.before_fork
+          ::MongoMapper.connection.close
+        end
+        
+        def self.after_fork
+          ::MongoMapper.connect(RAILS_ENV)
+        end
+        
+        def self.db_time_now
+          Time.now.utc
+        end
+        
+        def self.find_available(worker_name, limit = 5, max_run_time = Worker.max_run_time)
+          right_now = db_time_now
+
+          conditions = {
+            :run_at => {"$lte" => right_now},
+            :limit => -limit, # In mongo, positive limits are 'soft' and negative are 'hard'
+            :failed_at => nil,
+            :sort => [['priority', 1], ['run_at', 1]]
+          }
+
+          where = "this.locked_at == null || this.locked_at < #{make_date(right_now - max_run_time)}"
+          
+          (conditions[:priority] ||= {})['$gte'] = Worker.min_priority.to_i if Worker.min_priority
+          (conditions[:priority] ||= {})['$lte'] = Worker.max_priority.to_i if Worker.max_priority
+
+          results = all(conditions.merge(:locked_by => worker_name))
+          results += all(conditions.merge('$where' => where)) if results.size < limit
+          results
+        end
+        
+        # When a worker is exiting, make sure we don't have any locked jobs.
+        def self.clear_locks!(worker_name)
+          collection.update({:locked_by => worker_name}, {"$set" => {:locked_at => nil, :locked_by => nil}}, :multi => true)
+        end
+        
+        # Lock this job for this worker.
+        # Returns true if we have the lock, false otherwise.
+        def lock_exclusively!(max_run_time, worker = worker_name)
+          right_now = self.class.db_time_now
+          overtime = right_now - max_run_time.to_i
+          
+          query = "this.locked_at == null || this.locked_at < #{make_date(overtime)} || this.locked_by == #{worker.to_json}"
+          conditions = {:_id => id, :run_at => {"$lte" => right_now}, "$where" => query}
+
+          collection.update(conditions, {"$set" => {:locked_at => right_now, :locked_by => worker}})
+          affected_rows = collection.find({:_id => id, :locked_by => worker}).count
+          if affected_rows == 1
+            self.locked_at = right_now
+            self.locked_by = worker
+            return true
+          else
+            return false
+          end
+        end
+        
+      private
+      
+        def self.make_date(date_or_seconds)
+          "new Date(#{date_or_seconds.to_f * 1000})"
+        end
+
+        def make_date(date)
+          self.class.make_date(date)
+        end
+      end
+    end
+  end
+end

data/lib/delayed/command.rb

@@ -0,0 +1,107 @@
+require 'rubygems'
+require 'daemons'
+require 'optparse'
+
+module Delayed
+  class Command
+    attr_accessor :worker_count
+    
+    def initialize(args)
+      @files_to_reopen = []
+      @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
+        
+
+      end
+      @args = opts.parse!(args)
+    end
+  
+    def daemonize
+      Delayed::Worker.backend.before_fork
+
+      ObjectSpace.each_object(File) do |file|
+        @files_to_reopen << file unless file.closed?
+      end
+      
+      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)
+      Daemons.run_proc(process_name, :dir => dir, :dir_mode => :normal, :monitor => @monitor, :ARGV => @args) do |*args|
+        run process_name
+      end
+    end
+    
+    def run(worker_name = nil)
+      Dir.chdir(Rails.root)
+      
+      # Re-open file handles
+      @files_to_reopen.each do |file|
+        begin
+          file.reopen file.path, "a+"
+          file.sync = true
+        rescue ::Exception
+        end
+      end
+      
+      Delayed::Worker.logger = Logger.new(File.join(Rails.root, 'log', 'delayed_job.log'))
+      Delayed::Worker.backend.after_fork
+      
+      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/message_sending.rb

@@ -0,0 +1,45 @@
+require 'active_support/basic_object'
+
+module Delayed
+  class DelayProxy < ActiveSupport::BasicObject
+    def initialize(target, options)
+      @target = target
+      @options = options
+    end
+
+    def method_missing(method, *args)
+      Job.create({
+        :payload_object => PerformableMethod.new(@target, method.to_sym, args),
+        :priority       => ::Delayed::Worker.default_priority
+      }.merge(@options))
+    end
+  end
+
+  module MessageSending
+    def delay(options = {})
+      DelayProxy.new(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, options = {})
+        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|
+          delay(options).__send__(without_method, *args)
+        end
+        alias_method_chain method, :delay
+      end
+    end
+  end                               
+end

data/lib/delayed/performable_method.rb

@@ -0,0 +1,27 @@
+module Delayed
+  class PerformableMethod < Struct.new(:object, :method, :args)
+    def initialize(object, method, args)
+      raise NoMethodError, "undefined method `#{method}' for #{object.inspect}" unless object.respond_to?(method, true)
+
+      self.object = object
+      self.args   = args
+      self.method = method.to_sym
+    end
+    
+    def display_name
+      "#{object.class}##{method}"
+    end
+    
+    def perform
+      object.send(method, *args) if object
+    end
+    
+    def method_missing(symbol, *args)
+      object.respond_to?(symbol) ? object.send(symbol, *args) : super
+    end
+       
+    def respond_to?(symbol, include_private=false)
+      object.respond_to?(symbol, include_private) || super
+    end    
+  end
+end

data/lib/delayed/railtie.rb

@@ -0,0 +1,14 @@
+require 'delayed_job'
+require 'rails'
+
+module Delayed
+  class Railtie < Rails::Railtie
+    initializer :after_initialize do
+      Delayed::Worker.guess_backend
+    end
+
+    rake_tasks do
+      load 'delayed/tasks.rb'
+    end
+  end
+end

data/lib/delayed/recipes.rb

@@ -0,0 +1,31 @@
+# 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"
+
+Capistrano::Configuration.instance.load do
+  namespace :delayed_job do
+    def rails_env
+      fetch(:rails_env, false) ? "RAILS_ENV=#{fetch(:rails_env)}" : ''
+    end
+    
+    desc "Stop the delayed_job process"
+    task :stop, :roles => :app do
+      run "cd #{current_path};#{rails_env} script/delayed_job stop"
+    end
+
+    desc "Start the delayed_job process"
+    task :start, :roles => :app do
+      run "cd #{current_path};#{rails_env} script/delayed_job start"
+    end
+
+    desc "Restart the delayed_job process"
+    task :restart, :roles => :app do
+      run "cd #{current_path};#{rails_env} script/delayed_job restart"
+    end
+  end
+end

data/lib/delayed/tasks.rb

@@ -0,0 +1,20 @@
+# Re-definitions are appended to existing tasks
+task :environment
+task :merb_env
+
+namespace :jobs do
+  desc "Clear the delayed_job queue."
+  task :clear => [:merb_env, :environment] do
+    Delayed::Job.delete_all
+  end
+
+  desc "Start a delayed_job worker with an optional log name"
+  task :work, [:logname] => [:merb_env, :environment] do |_, args|
+
+    Delayed::Worker.new(:min_priority => ENV['MIN_PRIORITY'],
+                        :max_priority => ENV['MAX_PRIORITY'],
+                        :queue => ENV['QUEUE'],
+                        :logname => args.logname
+    ).start
+  end
+end

data/lib/delayed/tasks.rb.orig

@@ -0,0 +1,26 @@
+# Re-definitions are appended to existing tasks
+task :environment
+task :merb_env
+
+namespace :jobs do
+  desc "Clear the delayed_job queue."
+  task :clear => [:merb_env, :environment] do
+    Delayed::Job.delete_all
+  end
+
+<<<<<<< HEAD
+  desc "Start a delayed_job worker with an optional log name"
+  task :work, [:logname] => [:merb_env, :environment] do |_, args|
+
+    Delayed::Worker.new(:min_priority => ENV['MIN_PRIORITY'],
+                        :max_priority => ENV['MAX_PRIORITY'],
+                        :queue => ENV['QUEUE'],
+                        :logname => args.logname
+    ).start
+=======
+  desc "Start a delayed_job worker."
+  task :work => [:merb_env, :environment] do
+    Delayed::Worker.new(:min_priority => ENV['MIN_PRIORITY'], :max_priority => ENV['MAX_PRIORITY'], :queue => ENV['QUEUE']).start
+>>>>>>> 75b6e0c... added queues from the original topprospect patch, added tests for queues
+  end
+end