pax_global_header00006660000000000000000000000064131123261300014502gustar00rootroot0000000000000052 comment=42a68ed79917e14244a25a0a77fef0924bef3e97 delayed_job_active_record-4.1.2/000077500000000000000000000000001311232613000166405ustar00rootroot00000000000000delayed_job_active_record-4.1.2/.gitignore000066400000000000000000000001201311232613000206210ustar00rootroot00000000000000*.swp .bundle .rvmrc Gemfile.lock bin coverage pkg/* gemfiles/**/*.gemfile.lock delayed_job_active_record-4.1.2/.rspec000066400000000000000000000000241311232613000177510ustar00rootroot00000000000000--color --fail-fast delayed_job_active_record-4.1.2/.rubocop.yml000066400000000000000000000024751311232613000211220ustar00rootroot00000000000000AllCops: RunRailsCops: true ################# # [i] Overrides # ################# CollectionMethods: # Mapping from undesired method to desired_method # e.g. to use `detect` over `find`: # # CollectionMethods: # PreferredMethods: # find: detect PreferredMethods: collect: 'map' collect!: 'map!' reduce: 'inject' find_all: 'select' find: 'detect' # Multi-line method chaining should be done with leading dots. DotPosition: EnforcedStyle: trailing # Align ends correctly. EndAlignment: AlignWith: variable IfUnlessModifier: MaxLineLength: 75 LineLength: Max: 200 SignalException: EnforcedStyle: only_raise SpaceInsideBlockBraces: SpaceBeforeBlockParameters: false SpaceInsideHashLiteralBraces: EnforcedStyle: no_space StringLiterals: EnforcedStyle: double_quotes ################# # Disabled cops # ################# AbcSize: Enabled: false ClassAndModuleChildren: Enabled: false ClassLength: Enabled: false CyclomaticComplexity: Enabled: false Documentation: Enabled: false EachWithObject: Enabled: false FormatString: Enabled: false Lambda: Enabled: false MethodLength: Enabled: false NegatedIf: Enabled: false Semicolon: Enabled: false SingleLineBlockParams: Enabled: false TrailingComma: Enabled: false WordArray: Enabled: false delayed_job_active_record-4.1.2/.travis.yml000066400000000000000000000062311311232613000207530ustar00rootroot00000000000000language: ruby branches: only: - master before_script: - mysql -e 'create database delayed_job_test;' - psql -c 'create database delayed_job_test;' -U postgres script: bundle exec rspec env: global: - JRUBY_OPTS="$JRUBY_OPTS -Xcli.debug=true --debug" gemfile: # Supported - gemfiles/mysql2/4-2.gemfile - gemfiles/mysql2/5-0.gemfile - gemfiles/mysql2/5-1.gemfile - gemfiles/postgresql/4-2.gemfile - gemfiles/postgresql/5-0.gemfile - gemfiles/postgresql/5-1.gemfile - gemfiles/sqlite3/4-2.gemfile - gemfiles/sqlite3/5-0.gemfile - gemfiles/sqlite3/5-1.gemfile rvm: # Supported - 2.2.7 - 2.3.4 - 2.4.1 - jruby-9.1.8.0 jdk: oraclejdk8 matrix: allow_failures: - rvm: jruby-head # Future - rvm: rbx-2 # Parallel dimension - rvm: ruby-head # Future - gemfile: gemfiles/mysql2/master.gemfile # Future - gemfile: gemfiles/postgresql/master.gemfile # Future - gemfile: gemfiles/sqlite3/master.gemfile # Future # The two combinations below are currently broken. We should stop allowing # failure as the issue is resolved. See: # https://github.com/jruby/activerecord-jdbc-adapter/issues/700 - rvm: jruby-9.1.8.0 gemfile: gemfiles/mysql2/5-1.gemfile - rvm: jruby-9.1.8.0 gemfile: gemfiles/postgresql/5-1.gemfile include: # # The future # # Active Record head - gemfile: gemfiles/mysql2/master.gemfile rvm: 2.4.1 - gemfile: gemfiles/postgresql/master.gemfile rvm: 2.4.1 - gemfile: gemfiles/sqlite3/master.gemfile rvm: 2.4.1 # MRI Ruby head - rvm: ruby-head gemfile: gemfiles/mysql2/5-1.gemfile - rvm: ruby-head gemfile: gemfiles/postgresql/5-1.gemfile - rvm: ruby-head gemfile: gemfiles/sqlite3/5-1.gemfile # JRuby head - rvm: jruby-head gemfile: gemfiles/mysql2/5-1.gemfile - rvm: jruby-head gemfile: gemfiles/postgresql/5-1.gemfile - rvm: jruby-head gemfile: gemfiles/sqlite3/5-1.gemfile # # The past # # EOL Active Record - gemfile: gemfiles/mysql2/3-0.gemfile rvm: 2.2.7 - gemfile: gemfiles/mysql2/3-1.gemfile rvm: 2.2.7 - gemfile: gemfiles/mysql2/3-2.gemfile rvm: 2.2.7 - gemfile: gemfiles/mysql2/4-0.gemfile rvm: 2.3.4 - gemfile: gemfiles/mysql2/4-1.gemfile rvm: 2.3.4 - gemfile: gemfiles/postgresql/3-0.gemfile rvm: 2.2.7 - gemfile: gemfiles/postgresql/3-1.gemfile rvm: 2.2.7 - gemfile: gemfiles/postgresql/3-2.gemfile rvm: 2.2.7 - gemfile: gemfiles/postgresql/4-0.gemfile rvm: 2.3.4 - gemfile: gemfiles/postgresql/4-1.gemfile rvm: 2.3.4 - gemfile: gemfiles/sqlite3/3-0.gemfile rvm: 2.2.7 - gemfile: gemfiles/sqlite3/3-1.gemfile rvm: 2.2.7 - gemfile: gemfiles/sqlite3/3-2.gemfile rvm: 2.2.7 - gemfile: gemfiles/sqlite3/4-0.gemfile rvm: 2.3.4 - gemfile: gemfiles/sqlite3/4-1.gemfile rvm: 2.3.4 # # The parallel dimension # # Rubinius - gemfile: gemfiles/mysql2/5-1.gemfile rvm: rbx-2 - gemfile: gemfiles/postgresql/5-1.gemfile rvm: rbx-2 - gemfile: gemfiles/sqlite3/5-1.gemfile rvm: rbx-2 sudo: false delayed_job_active_record-4.1.2/CONTRIBUTING.md000066400000000000000000000012331311232613000210700ustar00rootroot00000000000000## How to contribute If you find what looks like a bug: * Search the [mailing list](http://groups.google.com/group/delayed_job) to see if anyone else had the same issue. * Check the [GitHub issue tracker](http://github.com/collectiveidea/delayed_job_active_record/issues/) to see if anyone else has reported issue. * If you don't see anything, create an issue with information on how to reproduce it. If you want to contribute an enhancement or a fix: * Fork the project on github. * Make your changes with tests. * Commit the changes without making changes to the Rakefile or any other files that aren't related to your enhancement or fix * Send a pull request. delayed_job_active_record-4.1.2/Gemfile000066400000000000000000000012571311232613000201400ustar00rootroot00000000000000source "https://rubygems.org" gem "rake" group :test do platforms :jruby do gem 'activerecord-jdbcmysql-adapter', git: 'https://github.com/jruby/activerecord-jdbc-adapter', branch: 'rails-5' gem 'activerecord-jdbcpostgresql-adapter', git: 'https://github.com/jruby/activerecord-jdbc-adapter', branch: 'rails-5' gem 'activerecord-jdbcsqlite3-adapter', git: 'https://github.com/jruby/activerecord-jdbc-adapter', branch: 'rails-5' end platforms :ruby, :mswin, :mingw do gem 'mysql2', '~> 0.4.5' gem "pg" gem "sqlite3" end gem "coveralls", require: false gem "rspec", ">= 3" gem "rubocop", ">= 0.23" gem "simplecov", require: false end gemspec delayed_job_active_record-4.1.2/LICENSE.md000066400000000000000000000020401311232613000202400ustar00rootroot00000000000000Copyright (c) 2005 Tobias Lütke Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOa AND NONINFRINGEMENT. IN NO EVENT SaALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. delayed_job_active_record-4.1.2/README.md000066400000000000000000000035371311232613000201270ustar00rootroot00000000000000**If you're viewing this at https://github.com/collectiveidea/delayed_job_active_record, you're reading the documentation for the master branch. [View documentation for the latest release (4.1.2).](https://github.com/collectiveidea/delayed_job_active_record/tree/v4.1.2)** # DelayedJob ActiveRecord Backend [![Gem Version](https://img.shields.io/gem/v/delayed_job_active_record.svg)](https://rubygems.org/gems/delayed_job_active_record) [![Build Status](https://img.shields.io/travis/collectiveidea/delayed_job_active_record.svg)](https://travis-ci.org/collectiveidea/delayed_job_active_record) [![Dependency Status](https://img.shields.io/gemnasium/collectiveidea/delayed_job_active_record.svg)](https://gemnasium.com/collectiveidea/delayed_job_active_record) [![Code Climate](https://img.shields.io/codeclimate/github/collectiveidea/delayed_job_active_record.svg)](https://codeclimate.com/github/collectiveidea/delayed_job_active_record) [![Coverage Status](https://img.shields.io/coveralls/collectiveidea/delayed_job_active_record.svg)](https://coveralls.io/r/collectiveidea/delayed_job_active_record) ## Installation Add the gem to your Gemfile: gem 'delayed_job_active_record' Run `bundle install`. If you're using Rails, run the generator to create the migration for the delayed_job table. rails g delayed_job:active_record rake db:migrate ## Problems locking jobs You can try using the legacy locking code. It is usually slower but works better for certain people. Delayed::Backend::ActiveRecord.configuration.reserve_sql_strategy = :default_sql ## Upgrading from 2.x to 3.0.0 If you're upgrading from Delayed Job 2.x, run the upgrade generator to create a migration to add a column to your delayed_jobs table. rails g delayed_job:upgrade rake db:migrate That's it. Use [delayed_job as normal](http://github.com/collectiveidea/delayed_job). delayed_job_active_record-4.1.2/Rakefile000066400000000000000000000013311311232613000203030ustar00rootroot00000000000000require "bundler/gem_helper" Bundler::GemHelper.install_tasks require "rspec/core/rake_task" ADAPTERS = %w(mysql2 postgresql sqlite3) ADAPTERS.each do |adapter| desc "Run RSpec code examples for #{adapter} adapter" RSpec::Core::RakeTask.new(adapter => "#{adapter}:adapter") namespace adapter do task :adapter do ENV["ADAPTER"] = adapter end end end task :coverage do ENV["COVERAGE"] = "true" end task :adapter do ENV["ADAPTER"] = nil end Rake::Task[:spec].enhance do require "simplecov" require "coveralls" Coveralls::SimpleCov::Formatter.new.format(SimpleCov.result) end require "rubocop/rake_task" RuboCop::RakeTask.new task default: ([:coverage] + ADAPTERS + [:adapter] + [:rubocop]) delayed_job_active_record-4.1.2/delayed_job_active_record.gemspec000066400000000000000000000015131311232613000253370ustar00rootroot00000000000000Gem::Specification.new do |spec| spec.add_dependency "activerecord", [">= 3.0", "< 5.2"] spec.add_dependency "delayed_job", [">= 3.0", "< 5"] spec.authors = ["Brian Ryckbost", "Matt Griffin", "Erik Michaels-Ober"] spec.description = "ActiveRecord backend for Delayed::Job, originally authored by Tobias Lütke" spec.email = ["bryckbost@gmail.com", "matt@griffinonline.org", "sferik@gmail.com"] spec.files = %w(CONTRIBUTING.md LICENSE.md README.md delayed_job_active_record.gemspec) + Dir["lib/**/*.rb"] spec.homepage = "http://github.com/collectiveidea/delayed_job_active_record" spec.licenses = ["MIT"] spec.name = "delayed_job_active_record" spec.require_paths = ["lib"] spec.summary = "ActiveRecord backend for DelayedJob" spec.version = "4.1.2" end delayed_job_active_record-4.1.2/gemfiles/000077500000000000000000000000001311232613000204335ustar00rootroot00000000000000delayed_job_active_record-4.1.2/gemfiles/mysql2/000077500000000000000000000000001311232613000216625ustar00rootroot00000000000000delayed_job_active_record-4.1.2/gemfiles/mysql2/3-0.gemfile000066400000000000000000000005661311232613000235220ustar00rootroot00000000000000source 'https://rubygems.org' gem 'rake' group :test do platforms :jruby do gem 'activerecord-jdbcmysql-adapter' end platforms :ruby, :mswin, :mingw do gem 'activerecord-mysql2-adapter' end gem 'coveralls', :require => false gem 'rspec', '>= 2.11' gem 'simplecov', :require => false gem 'activerecord', "~> 3.0.0" end gemspec :path => "../../" delayed_job_active_record-4.1.2/gemfiles/mysql2/3-1.gemfile000066400000000000000000000006241311232613000235160ustar00rootroot00000000000000source 'https://rubygems.org' gem 'rake' group :test do platforms :jruby do gem 'activerecord-jdbcmysql-adapter' end platforms :ruby, :mswin, :mingw do gem 'mysql2', '~> 0.3.10' gem 'activerecord-mysql2-adapter' end gem 'coveralls', :require => false gem 'rspec', '>= 2.11' gem 'simplecov', :require => false gem 'activerecord', "~> 3.1.0" end gemspec :path => "../../" delayed_job_active_record-4.1.2/gemfiles/mysql2/3-2.gemfile000066400000000000000000000006241311232613000235170ustar00rootroot00000000000000source 'https://rubygems.org' gem 'rake' group :test do platforms :jruby do gem 'activerecord-jdbcmysql-adapter' end platforms :ruby, :mswin, :mingw do gem 'mysql2', '~> 0.3.10' gem 'activerecord-mysql2-adapter' end gem 'coveralls', :require => false gem 'rspec', '>= 2.11' gem 'simplecov', :require => false gem 'activerecord', "~> 3.2.0" end gemspec :path => "../../" delayed_job_active_record-4.1.2/gemfiles/mysql2/4-0.gemfile000066400000000000000000000006241311232613000235160ustar00rootroot00000000000000source 'https://rubygems.org' gem 'rake' group :test do platforms :jruby do gem 'activerecord-jdbcmysql-adapter' end platforms :ruby, :mswin, :mingw do gem 'mysql2', '~> 0.3.10' gem 'activerecord-mysql2-adapter' end gem 'coveralls', :require => false gem 'rspec', '>= 2.11' gem 'simplecov', :require => false gem 'activerecord', "~> 4.0.0" end gemspec :path => "../../" delayed_job_active_record-4.1.2/gemfiles/mysql2/4-1.gemfile000066400000000000000000000006241311232613000235170ustar00rootroot00000000000000source 'https://rubygems.org' gem 'rake' group :test do platforms :jruby do gem 'activerecord-jdbcmysql-adapter' end platforms :ruby, :mswin, :mingw do gem 'mysql2', '~> 0.3.13' gem 'activerecord-mysql2-adapter' end gem 'coveralls', :require => false gem 'rspec', '>= 2.11' gem 'simplecov', :require => false gem 'activerecord', "~> 4.1.0" end gemspec :path => "../../" delayed_job_active_record-4.1.2/gemfiles/mysql2/4-2.gemfile000066400000000000000000000005671311232613000235260ustar00rootroot00000000000000source 'https://rubygems.org' gem 'rake' group :test do platforms :jruby do gem 'activerecord-jdbcmysql-adapter' end platforms :ruby, :mswin, :mingw do gem 'mysql2', '>= 0.3.13', '< 0.5' end gem 'coveralls', :require => false gem 'rspec', '>= 2.11' gem 'simplecov', :require => false gem 'activerecord', "~> 4.2.0" end gemspec :path => "../../" delayed_job_active_record-4.1.2/gemfiles/mysql2/5-0.gemfile000066400000000000000000000006571311232613000235250ustar00rootroot00000000000000source 'https://rubygems.org' gem 'rake' group :test do platforms :jruby do gem 'activerecord-jdbcmysql-adapter', git: 'https://github.com/jruby/activerecord-jdbc-adapter', branch: 'rails-5' end platforms :ruby, :mswin, :mingw do gem 'mysql2' end gem 'coveralls', :require => false gem 'rspec', '>= 2.11' gem 'simplecov', :require => false gem 'activerecord', "~> 5.0.0" end gemspec :path => "../../" delayed_job_active_record-4.1.2/gemfiles/mysql2/5-1.gemfile000066400000000000000000000006571311232613000235260ustar00rootroot00000000000000source 'https://rubygems.org' gem 'rake' group :test do platforms :jruby do gem 'activerecord-jdbcmysql-adapter', git: 'https://github.com/jruby/activerecord-jdbc-adapter', branch: 'rails-5' end platforms :ruby, :mswin, :mingw do gem 'mysql2' end gem 'coveralls', :require => false gem 'rspec', '>= 2.11' gem 'simplecov', :require => false gem 'activerecord', "~> 5.1.0" end gemspec :path => "../../" delayed_job_active_record-4.1.2/gemfiles/mysql2/master.gemfile000066400000000000000000000006641311232613000245150ustar00rootroot00000000000000source 'https://rubygems.org' gem 'rake' group :test do platforms :jruby do gem 'activerecord-jdbcmysql-adapter', git: 'https://github.com/jruby/activerecord-jdbc-adapter', branch: 'rails-5' end platforms :ruby, :mswin, :mingw do gem 'mysql2' end gem 'coveralls', :require => false gem 'rspec', '>= 2.11' gem 'simplecov', :require => false gem 'activerecord', github: 'rails' end gemspec :path => '../../' delayed_job_active_record-4.1.2/gemfiles/postgresql/000077500000000000000000000000001311232613000226365ustar00rootroot00000000000000delayed_job_active_record-4.1.2/gemfiles/postgresql/3-0.gemfile000066400000000000000000000005421311232613000244700ustar00rootroot00000000000000source 'https://rubygems.org' gem 'rake' group :test do platforms :jruby do gem 'activerecord-jdbcpostgresql-adapter' end platforms :ruby, :mswin, :mingw do gem 'pg' end gem 'coveralls', :require => false gem 'rspec', '>= 2.11' gem 'simplecov', :require => false gem 'activerecord', "~> 3.0.0" end gemspec :path => "../../" delayed_job_active_record-4.1.2/gemfiles/postgresql/3-1.gemfile000066400000000000000000000005421311232613000244710ustar00rootroot00000000000000source 'https://rubygems.org' gem 'rake' group :test do platforms :jruby do gem 'activerecord-jdbcpostgresql-adapter' end platforms :ruby, :mswin, :mingw do gem 'pg' end gem 'coveralls', :require => false gem 'rspec', '>= 2.11' gem 'simplecov', :require => false gem 'activerecord', "~> 3.1.0" end gemspec :path => "../../" delayed_job_active_record-4.1.2/gemfiles/postgresql/3-2.gemfile000066400000000000000000000005421311232613000244720ustar00rootroot00000000000000source 'https://rubygems.org' gem 'rake' group :test do platforms :jruby do gem 'activerecord-jdbcpostgresql-adapter' end platforms :ruby, :mswin, :mingw do gem 'pg' end gem 'coveralls', :require => false gem 'rspec', '>= 2.11' gem 'simplecov', :require => false gem 'activerecord', "~> 3.2.0" end gemspec :path => "../../" delayed_job_active_record-4.1.2/gemfiles/postgresql/4-0.gemfile000066400000000000000000000005421311232613000244710ustar00rootroot00000000000000source 'https://rubygems.org' gem 'rake' group :test do platforms :jruby do gem 'activerecord-jdbcpostgresql-adapter' end platforms :ruby, :mswin, :mingw do gem 'pg' end gem 'coveralls', :require => false gem 'rspec', '>= 2.11' gem 'simplecov', :require => false gem 'activerecord', "~> 4.0.0" end gemspec :path => "../../" delayed_job_active_record-4.1.2/gemfiles/postgresql/4-1.gemfile000066400000000000000000000005421311232613000244720ustar00rootroot00000000000000source 'https://rubygems.org' gem 'rake' group :test do platforms :jruby do gem 'activerecord-jdbcpostgresql-adapter' end platforms :ruby, :mswin, :mingw do gem 'pg' end gem 'coveralls', :require => false gem 'rspec', '>= 2.11' gem 'simplecov', :require => false gem 'activerecord', "~> 4.1.0" end gemspec :path => "../../" delayed_job_active_record-4.1.2/gemfiles/postgresql/4-2.gemfile000066400000000000000000000005421311232613000244730ustar00rootroot00000000000000source 'https://rubygems.org' gem 'rake' group :test do platforms :jruby do gem 'activerecord-jdbcpostgresql-adapter' end platforms :ruby, :mswin, :mingw do gem 'pg' end gem 'coveralls', :require => false gem 'rspec', '>= 2.11' gem 'simplecov', :require => false gem 'activerecord', "~> 4.2.0" end gemspec :path => "../../" delayed_job_active_record-4.1.2/gemfiles/postgresql/5-0.gemfile000066400000000000000000000006601311232613000244730ustar00rootroot00000000000000source 'https://rubygems.org' gem 'rake' group :test do platforms :jruby do gem 'activerecord-jdbcpostgresql-adapter', git: 'https://github.com/jruby/activerecord-jdbc-adapter', branch: 'rails-5' end platforms :ruby, :mswin, :mingw do gem 'pg' end gem 'coveralls', :require => false gem 'rspec', '>= 2.11' gem 'simplecov', :require => false gem 'activerecord', "~> 5.0.0" end gemspec :path => "../../" delayed_job_active_record-4.1.2/gemfiles/postgresql/5-1.gemfile000066400000000000000000000006601311232613000244740ustar00rootroot00000000000000source 'https://rubygems.org' gem 'rake' group :test do platforms :jruby do gem 'activerecord-jdbcpostgresql-adapter', git: 'https://github.com/jruby/activerecord-jdbc-adapter', branch: 'rails-5' end platforms :ruby, :mswin, :mingw do gem 'pg' end gem 'coveralls', :require => false gem 'rspec', '>= 2.11' gem 'simplecov', :require => false gem 'activerecord', "~> 5.1.0" end gemspec :path => "../../" delayed_job_active_record-4.1.2/gemfiles/postgresql/master.gemfile000066400000000000000000000006651311232613000254720ustar00rootroot00000000000000source 'https://rubygems.org' gem 'rake' group :test do platforms :jruby do gem 'activerecord-jdbcpostgresql-adapter', git: 'https://github.com/jruby/activerecord-jdbc-adapter', branch: 'rails-5' end platforms :ruby, :mswin, :mingw do gem 'pg' end gem 'coveralls', :require => false gem 'rspec', '>= 2.11' gem 'simplecov', :require => false gem 'activerecord', github: 'rails' end gemspec :path => "../../" delayed_job_active_record-4.1.2/gemfiles/sqlite3/000077500000000000000000000000001311232613000220175ustar00rootroot00000000000000delayed_job_active_record-4.1.2/gemfiles/sqlite3/3-0.gemfile000066400000000000000000000005441311232613000236530ustar00rootroot00000000000000source 'https://rubygems.org' gem 'rake' group :test do platforms :jruby do gem 'activerecord-jdbcsqlite3-adapter' end platforms :ruby, :mswin, :mingw do gem 'sqlite3' end gem 'coveralls', :require => false gem 'rspec', '>= 2.11' gem 'simplecov', :require => false gem 'activerecord', "~> 3.0.0" end gemspec :path => "../../" delayed_job_active_record-4.1.2/gemfiles/sqlite3/3-1.gemfile000066400000000000000000000005441311232613000236540ustar00rootroot00000000000000source 'https://rubygems.org' gem 'rake' group :test do platforms :jruby do gem 'activerecord-jdbcsqlite3-adapter' end platforms :ruby, :mswin, :mingw do gem 'sqlite3' end gem 'coveralls', :require => false gem 'rspec', '>= 2.11' gem 'simplecov', :require => false gem 'activerecord', "~> 3.1.0" end gemspec :path => "../../" delayed_job_active_record-4.1.2/gemfiles/sqlite3/3-2.gemfile000066400000000000000000000005441311232613000236550ustar00rootroot00000000000000source 'https://rubygems.org' gem 'rake' group :test do platforms :jruby do gem 'activerecord-jdbcsqlite3-adapter' end platforms :ruby, :mswin, :mingw do gem 'sqlite3' end gem 'coveralls', :require => false gem 'rspec', '>= 2.11' gem 'simplecov', :require => false gem 'activerecord', "~> 3.2.0" end gemspec :path => "../../" delayed_job_active_record-4.1.2/gemfiles/sqlite3/4-0.gemfile000066400000000000000000000005441311232613000236540ustar00rootroot00000000000000source 'https://rubygems.org' gem 'rake' group :test do platforms :jruby do gem 'activerecord-jdbcsqlite3-adapter' end platforms :ruby, :mswin, :mingw do gem 'sqlite3' end gem 'coveralls', :require => false gem 'rspec', '>= 2.11' gem 'simplecov', :require => false gem 'activerecord', "~> 4.0.0" end gemspec :path => "../../" delayed_job_active_record-4.1.2/gemfiles/sqlite3/4-1.gemfile000066400000000000000000000005441311232613000236550ustar00rootroot00000000000000source 'https://rubygems.org' gem 'rake' group :test do platforms :jruby do gem 'activerecord-jdbcsqlite3-adapter' end platforms :ruby, :mswin, :mingw do gem 'sqlite3' end gem 'coveralls', :require => false gem 'rspec', '>= 2.11' gem 'simplecov', :require => false gem 'activerecord', "~> 4.1.0" end gemspec :path => "../../" delayed_job_active_record-4.1.2/gemfiles/sqlite3/4-2.gemfile000066400000000000000000000005441311232613000236560ustar00rootroot00000000000000source 'https://rubygems.org' gem 'rake' group :test do platforms :jruby do gem 'activerecord-jdbcsqlite3-adapter' end platforms :ruby, :mswin, :mingw do gem 'sqlite3' end gem 'coveralls', :require => false gem 'rspec', '>= 2.11' gem 'simplecov', :require => false gem 'activerecord', "~> 4.2.0" end gemspec :path => "../../" delayed_job_active_record-4.1.2/gemfiles/sqlite3/5-0.gemfile000066400000000000000000000006621311232613000236560ustar00rootroot00000000000000source 'https://rubygems.org' gem 'rake' group :test do platforms :jruby do gem 'activerecord-jdbcsqlite3-adapter', git: 'https://github.com/jruby/activerecord-jdbc-adapter', branch: 'rails-5' end platforms :ruby, :mswin, :mingw do gem 'sqlite3' end gem 'coveralls', :require => false gem 'rspec', '>= 2.11' gem 'simplecov', :require => false gem 'activerecord', "~> 5.0.0" end gemspec :path => "../../" delayed_job_active_record-4.1.2/gemfiles/sqlite3/5-1.gemfile000066400000000000000000000006621311232613000236570ustar00rootroot00000000000000source 'https://rubygems.org' gem 'rake' group :test do platforms :jruby do gem 'activerecord-jdbcsqlite3-adapter', git: 'https://github.com/jruby/activerecord-jdbc-adapter', branch: 'rails-5' end platforms :ruby, :mswin, :mingw do gem 'sqlite3' end gem 'coveralls', :require => false gem 'rspec', '>= 2.11' gem 'simplecov', :require => false gem 'activerecord', "~> 5.1.0" end gemspec :path => "../../" delayed_job_active_record-4.1.2/gemfiles/sqlite3/master.gemfile000066400000000000000000000006671311232613000246550ustar00rootroot00000000000000source 'https://rubygems.org' gem 'rake' group :test do platforms :jruby do gem 'activerecord-jdbcsqlite3-adapter', git: 'https://github.com/jruby/activerecord-jdbc-adapter', branch: 'rails-5' end platforms :ruby, :mswin, :mingw do gem 'sqlite3' end gem 'coveralls', :require => false gem 'rspec', '>= 2.11' gem 'simplecov', :require => false gem 'activerecord', github: 'rails' end gemspec :path => "../../" delayed_job_active_record-4.1.2/lib/000077500000000000000000000000001311232613000174065ustar00rootroot00000000000000delayed_job_active_record-4.1.2/lib/delayed/000077500000000000000000000000001311232613000210155ustar00rootroot00000000000000delayed_job_active_record-4.1.2/lib/delayed/backend/000077500000000000000000000000001311232613000224045ustar00rootroot00000000000000delayed_job_active_record-4.1.2/lib/delayed/backend/active_record.rb000066400000000000000000000156661311232613000255600ustar00rootroot00000000000000require "active_record/version" module Delayed module Backend module ActiveRecord class Configuration attr_reader :reserve_sql_strategy def initialize self.reserve_sql_strategy = :optimized_sql end def reserve_sql_strategy=(val) raise ArgumentError, "allowed values are :optimized_sql or :default_sql" unless val == :optimized_sql || val == :default_sql @reserve_sql_strategy = val end end def self.configuration @configuration ||= Configuration.new end def self.configure yield(configuration) end # A job object that is persisted to the database. # Contains the work object as a YAML field. class Job < ::ActiveRecord::Base include Delayed::Backend::Base if ::ActiveRecord::VERSION::MAJOR < 4 || defined?(::ActiveRecord::MassAssignmentSecurity) attr_accessible :priority, :run_at, :queue, :payload_object, :failed_at, :locked_at, :locked_by, :handler end scope :by_priority, lambda { order("priority ASC, run_at ASC") } before_save :set_default_run_at def self.set_delayed_job_table_name delayed_job_table_name = "#{::ActiveRecord::Base.table_name_prefix}delayed_jobs" self.table_name = delayed_job_table_name end set_delayed_job_table_name def self.ready_to_run(worker_name, max_run_time) where("(run_at <= ? AND (locked_at IS NULL OR locked_at < ?) OR locked_by = ?) AND failed_at IS NULL", db_time_now, db_time_now - max_run_time, worker_name) end def self.before_fork ::ActiveRecord::Base.clear_all_connections! end def self.after_fork ::ActiveRecord::Base.establish_connection end # When a worker is exiting, make sure we don't have any locked jobs. def self.clear_locks!(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) # rubocop:disable CyclomaticComplexity # scope to filter to records that are "ready to run" ready_scope = ready_to_run(worker.name, max_run_time) # scope to filter to the single next eligible job 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 reserve_with_scope(ready_scope, worker, db_time_now) end def self.reserve_with_scope(ready_scope, worker, now) case Delayed::Backend::ActiveRecord.configuration.reserve_sql_strategy # Optimizations for faster lookups on some common databases when :optimized_sql reserve_with_scope_using_optimized_sql(ready_scope, worker, now) # Slower but in some cases more unproblematic strategy to lookup records # See https://github.com/collectiveidea/delayed_job_active_record/pull/89 for more details. when :default_sql reserve_with_scope_using_default_sql(ready_scope, worker, now) end end def self.reserve_with_scope_using_optimized_sql(ready_scope, worker, now) case 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 = connection.quote_table_name(table_name) subquery_sql = ready_scope.limit(1).lock(true).select("id").to_sql reserved = 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" # Removing the millisecond precision from now(time object) # MySQL 5.6.4 onwards millisecond precision exists, but the # datetime object created doesn't have precision, so discarded # while updating. But during the where clause, for mysql(>=5.6.4), # it queries with precision as well. So removing the precision now = now.change(usec: 0) # 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 where(locked_at: now, locked_by: worker.name, failed_at: nil).first when "MSSQL", "Teradata" # The MSSQL driver doesn't generate a limit clause when update_all # is called directly subsubquery_sql = ready_scope.limit(1).to_sql # select("id") doesn't generate a subquery, so force a subquery subquery_sql = "SELECT id FROM (#{subsubquery_sql}) AS x" quoted_table_name = connection.quote_table_name(table_name) sql = ["UPDATE #{quoted_table_name} SET locked_at = ?, locked_by = ? WHERE id IN (#{subquery_sql})", now, worker.name] count = connection.execute(sanitize_sql(sql)) return nil if count == 0 # MSSQL JDBC doesn't support OUTPUT INSERTED.* for returning a result set, so query locked row where(locked_at: now, locked_by: worker.name, failed_at: nil).first # Fallback for unknown / other DBMS else reserve_with_scope_using_default_sql(ready_scope, worker, now) end end def self.reserve_with_scope_using_default_sql(ready_scope, worker, now) # 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 # Get the current time (GMT or local depending on DB) # Note: This does not ping the DB to get the time, so all your clients # must have syncronized clocks. def self.db_time_now if Time.zone Time.zone.now elsif ::ActiveRecord::Base.default_timezone == :utc Time.now.utc else Time.now end end def reload(*args) reset super end end end end end delayed_job_active_record-4.1.2/lib/delayed_job_active_record.rb000066400000000000000000000002001311232613000250550ustar00rootroot00000000000000require "active_record" require "delayed_job" require "delayed/backend/active_record" Delayed::Worker.backend = :active_record delayed_job_active_record-4.1.2/lib/generators/000077500000000000000000000000001311232613000215575ustar00rootroot00000000000000delayed_job_active_record-4.1.2/lib/generators/delayed_job/000077500000000000000000000000001311232613000240205ustar00rootroot00000000000000delayed_job_active_record-4.1.2/lib/generators/delayed_job/active_record_generator.rb000066400000000000000000000016441311232613000312310ustar00rootroot00000000000000require "generators/delayed_job/delayed_job_generator" require "generators/delayed_job/next_migration_version" require "rails/generators/migration" require "rails/generators/active_record" # Extend the DelayedJobGenerator so that it creates an AR migration module DelayedJob class ActiveRecordGenerator < ::DelayedJobGenerator include Rails::Generators::Migration extend NextMigrationVersion source_paths << File.join(File.dirname(__FILE__), "templates") def create_migration_file migration_template "migration.rb", "db/migrate/create_delayed_jobs.rb", migration_version: migration_version end def self.next_migration_number(dirname) ActiveRecord::Generators::Base.next_migration_number dirname end private def migration_version if ActiveRecord::VERSION::MAJOR >= 5 "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]" end end end end delayed_job_active_record-4.1.2/lib/generators/delayed_job/next_migration_version.rb000066400000000000000000000007431311232613000311450ustar00rootroot00000000000000module DelayedJob module NextMigrationVersion # while methods have moved around this has been the implementation # since ActiveRecord 3.0 def next_migration_number(dirname) next_migration_number = current_migration_number(dirname) + 1 if ActiveRecord::Base.timestamped_migrations [Time.now.utc.strftime("%Y%m%d%H%M%S"), format("%.14d", next_migration_number)].max else format("%.3d", next_migration_number) end end end end delayed_job_active_record-4.1.2/lib/generators/delayed_job/templates/000077500000000000000000000000001311232613000260165ustar00rootroot00000000000000delayed_job_active_record-4.1.2/lib/generators/delayed_job/templates/migration.rb000066400000000000000000000024551311232613000303420ustar00rootroot00000000000000class CreateDelayedJobs < ActiveRecord::Migration<%= migration_version %> def self.up create_table :delayed_jobs, force: true do |table| table.integer :priority, default: 0, null: false # Allows some jobs to jump to the front of the queue table.integer :attempts, default: 0, null: false # Provides for retries, but still fail eventually. table.text :handler, null: false # YAML-encoded string of the object that will do work table.text :last_error # reason for last failure (See Note below) table.datetime :run_at # When to run. Could be Time.zone.now for immediately, or sometime in the future. table.datetime :locked_at # Set when a client is working on this object table.datetime :failed_at # Set when all retries have failed (actually, by default, the record is deleted instead) table.string :locked_by # Who is working on this object (if locked) table.string :queue # The name of the queue this job is in table.timestamps null: true end add_index :delayed_jobs, [:priority, :run_at], name: "delayed_jobs_priority" end def self.down drop_table :delayed_jobs end end delayed_job_active_record-4.1.2/lib/generators/delayed_job/templates/upgrade_migration.rb000066400000000000000000000003231311232613000320410ustar00rootroot00000000000000class AddQueueToDelayedJobs < ActiveRecord::Migration<%= migration_version %> def self.up add_column :delayed_jobs, :queue, :string end def self.down remove_column :delayed_jobs, :queue end end delayed_job_active_record-4.1.2/lib/generators/delayed_job/upgrade_generator.rb000066400000000000000000000007661311232613000300530ustar00rootroot00000000000000require "generators/delayed_job/delayed_job_generator" require "generators/delayed_job/next_migration_version" require "rails/generators/migration" require "rails/generators/active_record" # Extend the DelayedJobGenerator so that it creates an AR migration module DelayedJob class UpgradeGenerator < ActiveRecordGenerator def create_migration_file migration_template "upgrade_migration.rb", "db/migrate/add_queue_to_delayed_jobs.rb", migration_version: migration_version end end end delayed_job_active_record-4.1.2/spec/000077500000000000000000000000001311232613000175725ustar00rootroot00000000000000delayed_job_active_record-4.1.2/spec/database.yml000066400000000000000000000004721311232613000220640ustar00rootroot00000000000000mysql: adapter: mysql database: delayed_job_test username: root encoding: utf8 mysql2: adapter: mysql2 database: delayed_job_test username: root encoding: utf8 postgresql: adapter: postgresql database: delayed_job_test username: postgres sqlite3: adapter: sqlite3 database: ":memory:" delayed_job_active_record-4.1.2/spec/delayed/000077500000000000000000000000001311232613000212015ustar00rootroot00000000000000delayed_job_active_record-4.1.2/spec/delayed/backend/000077500000000000000000000000001311232613000225705ustar00rootroot00000000000000delayed_job_active_record-4.1.2/spec/delayed/backend/active_record_spec.rb000066400000000000000000000124011311232613000267360ustar00rootroot00000000000000require "helper" require "delayed/backend/active_record" describe Delayed::Backend::ActiveRecord::Job do it_behaves_like "a delayed_job backend" describe "configuration" do describe "reserve_sql_strategy" do it "allows :optimized_sql" do Delayed::Backend::ActiveRecord.configuration.reserve_sql_strategy = :optimized_sql expect(Delayed::Backend::ActiveRecord.configuration.reserve_sql_strategy).to eq(:optimized_sql) end it "allows :default_sql" do Delayed::Backend::ActiveRecord.configuration.reserve_sql_strategy = :default_sql expect(Delayed::Backend::ActiveRecord.configuration.reserve_sql_strategy).to eq(:default_sql) end it "raises an argument error on invalid entry" do expect { Delayed::Backend::ActiveRecord.configuration.reserve_sql_strategy = :invald }.to raise_error(ArgumentError) end end end describe "reserve_with_scope" do let(:worker) { double(name: "worker01", read_ahead: 1) } let(:scope) { double(limit: limit, where: double(update_all: nil)) } let(:limit) { double(job: job, update_all: nil) } let(:job) { double(id: 1) } before do allow(Delayed::Backend::ActiveRecord::Job.connection).to receive(:adapter_name).at_least(:once).and_return(dbms) Delayed::Backend::ActiveRecord.configuration.reserve_sql_strategy = reserve_sql_strategy end context "with reserve_sql_strategy option set to :optimized_sql (default)" do let(:reserve_sql_strategy) { :optimized_sql } context "for mysql adapters" do let(:dbms) { "MySQL" } it "uses the optimized sql version" do expect(Delayed::Backend::ActiveRecord::Job).to_not receive(:reserve_with_scope_using_default_sql) Delayed::Backend::ActiveRecord::Job.reserve_with_scope(scope, worker, Time.now) end end context "for a dbms without a specific implementation" do let(:dbms) { "OtherDB" } it "uses the plain sql version" do expect(Delayed::Backend::ActiveRecord::Job).to receive(:reserve_with_scope_using_default_sql).once Delayed::Backend::ActiveRecord::Job.reserve_with_scope(scope, worker, Time.now) end end end context "with reserve_sql_strategy option set to :default_sql" do let(:dbms) { "MySQL" } let(:reserve_sql_strategy) { :default_sql } it "uses the plain sql version" do expect(Delayed::Backend::ActiveRecord::Job).to receive(:reserve_with_scope_using_default_sql).once Delayed::Backend::ActiveRecord::Job.reserve_with_scope(scope, worker, Time.now) end end end context "db_time_now" do after do Time.zone = nil ActiveRecord::Base.default_timezone = :local end it "returns time in current time zone if set" do Time.zone = "Eastern Time (US & Canada)" expect(%(EST EDT)).to include(Delayed::Job.db_time_now.zone) end it "returns UTC time if that is the AR default" do Time.zone = nil ActiveRecord::Base.default_timezone = :utc expect(Delayed::Backend::ActiveRecord::Job.db_time_now.zone).to eq "UTC" end it "returns local time if that is the AR default" do Time.zone = "Central Time (US & Canada)" ActiveRecord::Base.default_timezone = :local expect(%w(CST CDT)).to include(Delayed::Backend::ActiveRecord::Job.db_time_now.zone) end end describe "after_fork" do it "calls reconnect on the connection" do expect(ActiveRecord::Base).to receive(:establish_connection) Delayed::Backend::ActiveRecord::Job.after_fork end end describe "enqueue" do it "allows enqueue hook to modify job at DB level" do later = described_class.db_time_now + 20.minutes job = Delayed::Backend::ActiveRecord::Job.enqueue payload_object: EnqueueJobMod.new expect(Delayed::Backend::ActiveRecord::Job.find(job.id).run_at).to be_within(1).of(later) end end if ::ActiveRecord::VERSION::MAJOR < 4 || defined?(::ActiveRecord::MassAssignmentSecurity) context "ActiveRecord::Base.send(:attr_accessible, nil)" do before do Delayed::Backend::ActiveRecord::Job.send(:attr_accessible, nil) end after do Delayed::Backend::ActiveRecord::Job.send(:attr_accessible, *Delayed::Backend::ActiveRecord::Job.new.attributes.keys) end it "is still accessible" do job = Delayed::Backend::ActiveRecord::Job.enqueue payload_object: EnqueueJobMod.new expect(Delayed::Backend::ActiveRecord::Job.find(job.id).handler).to_not be_blank end end end context "ActiveRecord::Base.table_name_prefix" do it "when prefix is not set, use 'delayed_jobs' as table name" do ::ActiveRecord::Base.table_name_prefix = nil Delayed::Backend::ActiveRecord::Job.set_delayed_job_table_name expect(Delayed::Backend::ActiveRecord::Job.table_name).to eq "delayed_jobs" end it "when prefix is set, prepend it before default table name" do ::ActiveRecord::Base.table_name_prefix = "custom_" Delayed::Backend::ActiveRecord::Job.set_delayed_job_table_name expect(Delayed::Backend::ActiveRecord::Job.table_name).to eq "custom_delayed_jobs" ::ActiveRecord::Base.table_name_prefix = nil Delayed::Backend::ActiveRecord::Job.set_delayed_job_table_name end end end delayed_job_active_record-4.1.2/spec/delayed/serialization/000077500000000000000000000000001311232613000240565ustar00rootroot00000000000000delayed_job_active_record-4.1.2/spec/delayed/serialization/active_record_spec.rb000066400000000000000000000005231311232613000302260ustar00rootroot00000000000000require "helper" describe ActiveRecord do it "loads classes with non-default primary key" do expect do YAML.load(Story.create.to_yaml) end.not_to raise_error end it "loads classes even if not in default scope" do expect do YAML.load(Story.create(scoped: false).to_yaml) end.not_to raise_error end end delayed_job_active_record-4.1.2/spec/helper.rb000066400000000000000000000041021311232613000213730ustar00rootroot00000000000000require "simplecov" require "coveralls" SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new([ SimpleCov::Formatter::HTMLFormatter, Coveralls::SimpleCov::Formatter ]) SimpleCov.start do add_filter "/spec/" minimum_coverage(73.33) end require "logger" require "rspec" begin require "protected_attributes" rescue LoadError # rubocop:disable HandleExceptions end require "delayed_job_active_record" require "delayed/backend/shared_spec" Delayed::Worker.logger = Logger.new("/tmp/dj.log") ENV["RAILS_ENV"] = "test" db_adapter, gemfile = ENV["ADAPTER"], ENV["BUNDLE_GEMFILE"] db_adapter ||= gemfile && gemfile[%r{gemfiles/(.*?)/}] && $1 # rubocop:disable PerlBackrefs db_adapter ||= "sqlite3" config = YAML.load(File.read("spec/database.yml")) ActiveRecord::Base.establish_connection config[db_adapter] ActiveRecord::Base.logger = Delayed::Worker.logger ActiveRecord::Migration.verbose = false migration_template = File.open("lib/generators/delayed_job/templates/migration.rb") # need to eval the template with the migration_version intact migration_context = Class.new do def get_binding binding end private def migration_version if ActiveRecord::VERSION::MAJOR >= 5 "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]" end end end migration_ruby = ERB.new(migration_template.read).result(migration_context.new.get_binding) eval(migration_ruby) ActiveRecord::Schema.define do CreateDelayedJobs.up create_table :stories, primary_key: :story_id, force: true do |table| table.string :text table.boolean :scoped, default: true end end # Purely useful for test cases... class Story < ActiveRecord::Base if ::ActiveRecord::VERSION::MAJOR < 4 && ActiveRecord::VERSION::MINOR < 2 set_primary_key :story_id else self.primary_key = :story_id end def tell text end def whatever(n, _) tell * n end default_scope { where(scoped: true) } handle_asynchronously :whatever end # Add this directory so the ActiveSupport autoloading works ActiveSupport::Dependencies.autoload_paths << File.dirname(__FILE__)