delayed_job_active_record 0.4.3 → 0.4.4

data/delayed_job_active_record.gemspec

@@ -15,5 +15,5 @@ Gem::Specification.new do |spec|
   spec.require_paths  = ['lib']
   spec.summary        = 'ActiveRecord backend for DelayedJob'
   spec.test_files     = Dir.glob("spec/**/*")
-  spec.version        = '0.4.3'
+  spec.version        = '0.4.4'
 end

data/lib/delayed/backend/active_record.rb

@@ -37,50 +37,43 @@ module Delayed
 
         # When a worker is exiting, make sure we don't have any locked jobs.
         def self.clear_locks!(worker_name)
-          update_all("locked_by = null, locked_at = null", ["locked_by = ?", worker_name])
+          where(:locked_by => worker_name).update_all(:locked_by => nil, :locked_at => nil)
         end
 
         def self.reserve(worker, max_run_time = Worker.max_run_time)
           # scope to filter to records that are "ready to run"
-          readyScope = self.ready_to_run(worker.name, max_run_time)
+          ready_scope = self.ready_to_run(worker.name, max_run_time)
 
           # scope to filter to the single next eligible job
-          nextScope = readyScope.scoped
-          nextScope = nextScope.scoped(:conditions => ['priority >= ?', Worker.min_priority]) if Worker.min_priority
-          nextScope = nextScope.scoped(:conditions => ['priority <= ?', Worker.max_priority]) if Worker.max_priority
-          nextScope = nextScope.scoped(:conditions => ["queue IN (?)", Worker.queues]) if Worker.queues.any?
-          nextScope = nextScope.scoped.by_priority.limit(1)
+          ready_scope = ready_scope.where('priority >= ?', Worker.min_priority) if Worker.min_priority
+          ready_scope = ready_scope.where('priority <= ?', Worker.max_priority) if Worker.max_priority
+          ready_scope = ready_scope.where(:queue => Worker.queues) if Worker.queues.any?
+          ready_scope = ready_scope.by_priority
 
           now = self.db_time_now
-          job = nextScope.first
-          return unless job
-          job.with_lock do
-            job.locked_at = now
-            job.locked_by = worker.name
-            job.save!
-          end
-          job
-        end
 
-        # Lock this job for this worker.
-        # Returns true if we have the lock, false otherwise.
-        def lock_exclusively!(max_run_time, worker)
-          now = self.class.db_time_now
-          affected_rows = if locked_by != worker
-            # We don't own this job so we will update the locked_by name and the locked_at
-            self.class.update_all(["locked_at = ?, locked_by = ?", now, worker], ["id = ? and (locked_at is null or locked_at < ?) and (run_at <= ?)", id, (now - max_run_time.to_i), now])
-          else
-            # We already own this job, this may happen if the job queue crashes.
-            # Simply resume and update the locked_at
-            self.class.update_all(["locked_at = ?", now], ["id = ? and locked_by = ?", id, worker])
-          end
-          if affected_rows == 1
-            self.locked_at = now
-            self.locked_by = worker
-            self.changed_attributes.clear
-            return true
+          # Optimizations for faster lookups on some common databases
+          case self.connection.adapter_name
+          when "PostgreSQL"
+            # Custom SQL required for PostgreSQL because postgres does not support UPDATE...LIMIT
+            # This locks the single record 'FOR UPDATE' in the subquery (http://www.postgresql.org/docs/9.0/static/sql-select.html#SQL-FOR-UPDATE-SHARE)
+            # Note: active_record would attempt to generate UPDATE...LIMIT like sql for postgres if we use a .limit() filter, but it would not use
+            # 'FOR UPDATE' and we would have many locking conflicts
+            quoted_table_name = self.connection.quote_table_name(self.table_name)
+            subquery_sql      = ready_scope.limit(1).lock(true).select('id').to_sql
+            reserved          = self.find_by_sql(["UPDATE #{quoted_table_name} SET locked_at = ?, locked_by = ? WHERE id IN (#{subquery_sql}) RETURNING *", now, worker.name])
+            reserved[0]
+          when "MySQL", "Mysql2"
+            # This works on MySQL and possibly some other DBs that support UPDATE...LIMIT. It uses separate queries to lock and return the job
+            count = ready_scope.limit(1).update_all(:locked_at => now, :locked_by => worker.name)
+            return nil if count == 0
+            self.where(:locked_at => now, :locked_by => worker.name).first
           else
-            return false
+            # This is our old fashion, tried and true, but slower lookup
+            ready_scope.limit(worker.read_ahead).detect do |job|
+              count = ready_scope.where(:id => job.id).update_all(:locked_at => now, :locked_by => worker.name)
+              count == 1 && job.reload
+            end
           end
         end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: delayed_job_active_record
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.4.4
   prerelease: 
 platform: ruby
 authors:
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-02 00:00:00.000000000 Z
+date: 2013-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -91,7 +91,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4151912302057659194
+      hash: 1565525879185101901
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -100,7 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4151912302057659194
+      hash: 1565525879185101901
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.25