talentbox-delayed_job_sequel 0.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 TalentBox SA
+
+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.

data/README.md

@@ -0,0 +1,33 @@
+# DelayedJob Sequel Backend
+
+## Installation
+
+Add the gem to your Gemfile:
+
+    gem 'delayed_job_sequel'
+
+Run `bundle install`.
+
+If you're using Rails, run the generator to create the migration for the delayed_job table.
+
+    rails g delayed_job:sequel
+    rake db:migrate
+
+## Build Status
+
+[![Build Status](http://travis-ci.org/TalentBox/delayed_job_sequel.png)](https://travis-ci.org/TalentBox/delayed_job_sequel)
+
+## 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/TalentBox/delayed_job_sequel/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.

data/lib/delayed/backend/sequel.rb

@@ -0,0 +1,131 @@
+require 'sequel'
+module Delayed
+  module Backend
+    module Sequel
+      # A job object that is persisted to the database.
+      # Contains the work object as a YAML field.
+      class Job < ::Sequel::Model(:delayed_jobs)
+        include Delayed::Backend::Base
+        plugin :timestamps
+
+        def before_save
+          super
+          set_default_run_at
+        end
+
+        def_dataset_method :ready_to_run do |worker_name, max_run_time|
+          db_time_now = model.db_time_now
+          lock_upper_bound = db_time_now - max_run_time
+          filter do
+            ( (run_at <= db_time_now) &
+              ({:locked_at => nil} | (locked_at < lock_upper_bound)) |
+              {:locked_by => worker_name}
+            ) & {:failed_at => nil}
+          end
+        end
+
+        def_dataset_method :by_priority do
+          order(:priority.asc, :run_at.asc)
+        end
+
+        def self.before_fork
+          ::Sequel::Model.db.disconnect
+        end
+
+        # When a worker is exiting, make sure we don't have any locked jobs.
+        def self.clear_locks!(worker_name)
+          filter(:locked_by => worker_name).update(:locked_by => nil, :locked_at => nil)
+        end
+
+        # Find a few candidate jobs to run (in case some immediately get locked by others).
+        def self.find_available(worker_name, limit = 5, max_run_time = Worker.max_run_time)
+          set = ready_to_run(worker_name, max_run_time)
+          set = set.filter("priority >= ?", Worker.min_priority) if Worker.min_priority
+          set = set.filter("priority <= ?", Worker.max_priority) if Worker.max_priority
+          set = set.filter(:queue => Worker.queues) if Worker.queues.any?
+
+          silence_log do
+            set.by_priority.limit(limit).all
+          end
+        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
+            lock_upper_bound = now - max_run_time.to_i
+            closure_pk = pk
+            self.class.filter{
+              {:id => closure_pk} &
+              ({:locked_at => nil} | (locked_at < lock_upper_bound)) &
+              (run_at <= now)
+            }.update(:locked_at => now, :locked_by => worker)
+          else
+            # We already own this job, this may happen if the job queue crashes.
+            # Simply resume and update the locked_at
+            self.class.filter(:id => id, :locked_by => worker).update(:locked_at => now)
+          end
+          if affected_rows == 1
+            self.locked_at = now
+            self.locked_by = worker
+            return true
+          else
+            return false
+          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 ::Sequel.database_timezone == :utc
+            Time.now.utc
+          else
+            Time.now
+          end
+        end
+
+        def self.delete_all
+          delete
+        end
+
+        def reload(*args)
+          reset
+          super
+        end
+
+        def save!
+          save :raise_on_failure => true
+        end
+
+        def update_attributes(attrs)
+          update attrs
+        end
+
+        def self.create!(attrs)
+          new(attrs).save :raise_on_failure => true
+        end
+
+        def self.silence_log(&block)
+          if db.respond_to?(:logger) && db.logger.respond_to?(:silence)
+            db.logger.silence &block
+          else
+            yield
+          end
+        end
+  
+        # The default behaviour for sequel on #==/#eql? is to check if all 
+        # values are matching.
+        # This differs from ActiveRecord which checks class and id only.
+        # To pass the specs we're reverting to what AR does here.
+        def eql?(obj)
+          (obj.class == model) && (obj.pk == pk)
+        end
+      end
+    end
+  end
+end

data/lib/delayed/serialization/sequel.rb

@@ -0,0 +1,50 @@
+require "sequel/model"
+
+module Delayed
+  module Serialization
+    module Sequel
+      def self.configure(klass)
+        klass.class_eval do
+          def self.inherited(child)
+            super
+            if YAML.parser.class.name =~ /syck/i
+              child.yaml_as "tag:ruby.yaml.org,2002:#{child.name}"
+            else
+              child.yaml_as ['!ruby/Sequel', child.name].join(':')
+            end
+          end
+        end
+      end
+
+      if YAML.parser.class.name =~ /syck/i
+        module ClassMethods
+          def yaml_new(klass, tag, val)
+            klass[val['values'][klass.primary_key]] ||
+            raise(Delayed::DeserializationError, "Sequel Record not found, class: #{klass} , primary key: #{val['values'][klass.primary_key]}")
+          end
+        end
+      end
+
+      module InstanceMethods
+        if YAML.parser.class.name =~ /syck/i
+          def to_yaml_properties
+            ['@values']
+          end
+        else
+          def encode_with(coder)
+            coder["values"] = @values
+            coder.tag = ['!ruby/Sequel', self.class.name].join(':')
+          end
+
+          def init_with(coder)
+            @values = coder["values"]
+            reload
+          rescue Sequel::Error
+            raise Delayed::DeserializationError, "Sequel Record not found, class: #{self.class.name} , primary key: #{pk}"
+          end
+        end
+      end
+    end
+  end
+end
+Sequel::Model.plugin Delayed::Serialization::Sequel

data/lib/delayed_job_sequel.rb

@@ -0,0 +1,5 @@
+require 'sequel'
+require 'delayed_job'
+require 'delayed/backend/sequel'
+
+Delayed::Worker.backend = :sequel

data/lib/generators/delayed_job/sequel_generator.rb

@@ -0,0 +1,17 @@
+require 'generators/delayed_job/delayed_job_generator'
+require 'rails/generators/migration'
+require 'rails/generators/active_record/migration'
+
+# Extend the DelayedJobGenerator so that it creates an AR migration
+module DelayedJob
+  class ActiveRecordGenerator < ::DelayedJobGenerator
+    include Rails::Generators::Migration
+    extend ActiveRecord::Generators::Migration
+
+    self.source_paths << File.join(File.dirname(__FILE__), 'templates')
+
+    def create_migration_file
+      migration_template 'migration.rb', 'db/migrate/create_delayed_jobs.rb'
+    end
+  end
+end

data/lib/generators/delayed_job/templates/migration.rb

@@ -0,0 +1,22 @@
+class CreateDelayedJobs < ActiveRecord::Migration
+  def self.up
+    create_table :delayed_jobs, :force => true do |table|
+      table.integer  :priority, :default => 0      # Allows some jobs to jump to the front of the queue
+      table.integer  :attempts, :default => 0      # Provides for retries, but still fail eventually.
+      table.text     :handler                      # 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
+    end
+
+    add_index :delayed_jobs, [:priority, :run_at], :name => 'delayed_jobs_priority'
+  end
+
+  def self.down
+    drop_table :delayed_jobs
+  end
+end

data/spec/database.yml

@@ -0,0 +1,4 @@
+sqlite:
+  adapter: sqlite
+  database: ":memory:"
+

data/spec/delayed/backend/sequel_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+require "delayed/backend/sequel"
+
+describe Delayed::Backend::Sequel::Job do
+  after do
+    Time.zone = nil
+  end
+
+  it_should_behave_like "a delayed_job backend"
+
+  context "db_time_now" do
+    it "should return time in current time zone if set" do
+      Time.zone = "Eastern Time (US & Canada)"
+      %w(EST EDT).should include(Delayed::Job.db_time_now.zone)
+    end
+
+    it "should return UTC time if that is the Sequel.database_timezone default" do
+      Time.zone = nil
+      Sequel.database_timezone = :utc
+      Delayed::Backend::Sequel::Job.db_time_now.zone.should == "UTC"
+    end
+
+    it "should return local time if that is the AR default" do
+      Time.zone = "Central Time (US & Canada)"
+      Sequel.database_timezone = :local
+      %w(CST CDT).should include(Delayed::Backend::Sequel::Job.db_time_now.zone)
+    end
+  end
+
+  describe "before_fork" do
+    it "should call disconnect on the connection" do
+      Sequel::Model.db.should_receive(:disconnect)
+      Delayed::Backend::Sequel::Job.before_fork
+    end
+  end
+
+  describe "enqueue" do
+    it "should allow enqueue hook to modify job at DB level" do
+      later = described_class.db_time_now + 20.minutes
+      job = Delayed::Backend::Sequel::Job.enqueue :payload_object => EnqueueJobMod.new
+      Delayed::Backend::Sequel::Job[job.id].run_at.should be_within(1).of(later)
+    end
+  end
+end

data/spec/delayed/serialization/sequel_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Sequel::Model do
+  it 'should load classes with non-default primary key' do
+    lambda {
+      YAML.load(Story.create.to_yaml)
+    }.should_not raise_error
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,58 @@
+$:.unshift(File.dirname(__FILE__) + "/../lib")
+
+require "rubygems"
+require "bundler/setup"
+require "rspec"
+require "logger"
+require "sqlite3"
+require "sequel"
+
+config = YAML.load(File.read("spec/database.yml"))
+DB = Sequel.connect config["sqlite"]
+
+Sequel.extension :migration
+Class.new(Sequel::Migration) do
+  def up
+    create_table :delayed_jobs do
+      primary_key :id
+      Integer :priority, :default => 0
+      Integer :attempts, :default => 0
+      String  :handler, :text => true
+      String  :last_error, :text => true
+      column  :run_at,    :datetime#"timestamp(0)"
+      column  :locked_at, :datetime#"timestamp(0)"
+      column  :failed_at, :datetime#"timestamp(0)"
+      String  :locked_by
+      String  :queue
+      Time    :created_at
+      Time    :updated_at
+      index   [:priority, :run_at]
+    end
+
+    create_table :stories do
+      primary_key :story_id
+      String      :text
+      TrueClass   :scoped, :default => true
+    end
+  end
+end.apply(DB, :up)
+
+require "delayed_job_sequel"
+require "delayed/backend/shared_spec"
+
+Delayed::Worker.logger = Logger.new("/tmp/dj.log")
+ENV["RAILS_ENV"] = "test"
+DB.logger = Delayed::Worker.logger
+
+# Purely useful for test cases...
+class Story < Sequel::Model
+  def tell; text; end
+  def whatever(n, _); tell*n; end
+  def update_attributes(*args)
+    update *args
+  end
+  handle_asynchronously :whatever
+end
+
+# Add this directory so the ActiveSupport autoloading works
+# ActiveSupport::Dependencies.autoload_paths << File.dirname(__FILE__)

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: talentbox-delayed_job_sequel
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Jonathan Tron
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: &2161185360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.28'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2161185360
+- !ruby/object:Gem::Dependency
+  name: delayed_job
+  requirement: &2160614300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *2160614300
+- !ruby/object:Gem::Dependency
+  name: tzinfo
+  requirement: &2160611720 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2160611720
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2160609540 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: *2160609540
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &2161543600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: *2161543600
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &2161541640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2161541640
+description: Sequel backend for DelayedJob, originally authored by Tobias Luetke
+email:
+- jonathan@tron.name
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- lib/delayed/backend/sequel.rb
+- lib/delayed/serialization/sequel.rb
+- lib/delayed_job_sequel.rb
+- lib/generators/delayed_job/sequel_generator.rb
+- lib/generators/delayed_job/templates/migration.rb
+- spec/database.yml
+- spec/delayed/backend/sequel_spec.rb
+- spec/delayed/serialization/sequel_spec.rb
+- spec/spec_helper.rb
+- LICENSE
+- README.md
+homepage: http://github.com/TalentBox/delayed_job_sequel
+licenses: []
+post_install_message: 
+rdoc_options:
+- --main
+- README.md
+- --inline-source
+- --line-numbers
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -179484122693818536
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -179484122693818536
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Sequel backend for DelayedJob
+test_files:
+- spec/database.yml
+- spec/delayed/backend/sequel_spec.rb
+- spec/delayed/serialization/sequel_spec.rb
+- spec/spec_helper.rb