unique_delayed_job 0.0.1

data/README

@@ -0,0 +1,30 @@
+= unique_delayed_job
+
+== Overview
+
+You must have delayed_job installed as a gem or plugin to use this class.
+
+Class for creating delayed jobs that can be de-duped with existing delayed jobs
+already in the delayed jobs table. You just specify some additional columns on
+your delayed_jobs table and set them to have uniqueness constraints. Then
+specify these column values when you create a UniqueDelayedJob and if a
+duplicate key is raised on insert, then the insert will just be ignored. There
+are factory methods for creating a delayed job in the following ways:
+* with a delayed job handler class (one that responds to perform())
+* with an object, method and method arguments
+* with a code block
+
+== Examples
+
+# use a custom handler
+job = Delayed::UniqueDelayedJob.use_handler(MyHandlerClass.new( ...), :user_id => 123)
+job.enqueue  # use default priority and run_at
+
+# use a method call (similar to using send_later on the object)
+record = MyActiveRecord.find(1)
+job = Delayed::UniqueDelayedJob.call_method(record, :a_method, [arg1, arg2], :user_id => 123)
+job.enqueue(1) # use priority of 1
+
+# use a code block
+job = Delayed::UniqueDelayedJob.run_block(:user_id => 123) { run_some_code }
+job.enqueue(2, 1.hour.from_now) # priority 1, run at 1 hour from now

data/lib/unique_delayed_job.rb

@@ -0,0 +1,116 @@
+module Delayed
+
+  # allows for specifying additional columns on the delayed_jobs table to help
+  # prevent duplicate delayed jobs from being entered into the queue...but still
+  # keep an easy interface to enqueuing delayed jobs
+  #-----------------------------------------------------------------------------
+  class UniqueDelayedJob
+
+    # factory method to create a new UniqueDelayedJob from a delayed job handler
+    # object (see delayed job documentation for requirements)
+    #
+    # arguments:
+    #    - handler: the delayed jobs handler object you're using
+    #    - columns: hash of column names and values to insert into the delayed
+    #               jobs table in addition to the handler
+    #---------------------------------------------------------------------------
+    def self.use_handler(handler, columns = {})
+      job = self.new
+      job.handler = handler
+
+      job
+    end
+
+    # factory method to create a new UniqueDelayedJob by specifying a method ton
+    # call. will use delayed jobs' PerformableMethod class to enqueue the job
+    #
+    # arguments:
+    #    - object: the object (or class or module) on which to call the method
+    #    - method: the method to call (specify a symbol or string)
+    #    - args_arr: an array of arguments to pass in the method call)
+    #    - columns: hash of column names and values to insert into the delayed
+    #               jobs table in addition to the handler
+    #---------------------------------------------------------------------------
+    def self.call_method(object, method, args_arr, columns = {})
+      job = self.new
+      job.handler = Delayed::PerformableMethod.new(object, method, args_arr)
+
+      job
+    end
+
+
+    # factory method to create a UniqueDelayedJob by specifying a block to
+    # execute asynchronously
+    # arguments:
+    #    - columns: hash of column names and values to insert into the delayed
+    #               jobs table in addition to the handler
+    # NOTE: a block is expected
+    #---------------------------------------------------------------------------
+    def self.run_block(columns = {}, &block)
+      raise "missing a block in call to run_block" if !block_given?
+      job = self.new
+      job.handler = Delayed::EvaledJob.new(&block)
+
+      job
+    end
+
+
+    # specify some additional columns to set in the delayed jobs table for this
+    # row. be sure that you've migrated to add these columns to the delayed jobs
+    # table. it is up to you to specify uniqueness constraints on any of the
+    # columns you'd like to use to prevent duplicate entries in the delayed jobs
+    # table. (it's also fine for some of these columns to not have unique
+    # constraints, though this class will not prevent duplicate values for those
+    # and they'll be for your use for other purposes.)
+    #---------------------------------------------------------------------------
+    def add_delayed_jobs_columns(new_columns)
+      columns.merge! new_columns
+    end
+
+    # put the job on the delayed jobs queue. if there already is a row in the
+    # delayed jobs table with the same value in any of the unique columns
+    # (enforced in the db), then the row will not be inserted
+    #
+    # arguments:
+    #    priority: 
+    #    run_at: 
+    #---------------------------------------------------------------------------
+    def enqueue(priority = nil, run_at = nil)
+      cols_to_insert = columns
+      cols_to_insert.merge! :priority => priority if priority
+      cols_to_insert.merge! :run_at => run_at if run_at
+      cols_to_insert.merge! :handler => handler
+
+      # try to catch if this raises an exception because of a duplicate key
+      # error this should work for mysql and postgresql which both have the
+      # word 'duplicate' followed (not necessarily immediately) by 'key'.
+      # ignoring case cause case differs between the two cases
+      # if doesn't look like a dupe key error, then reraise the exception
+      begin
+        Delayed::Job.create(cols_to_insert)
+      rescue => e
+        if /(duplicate).*(key)/i !~ e.message
+          raise e
+        end
+      end
+
+    end
+
+    attr_accessor :columns
+
+    protected
+
+    attr_accessor :handler
+
+
+    # constructor used by the factory methods
+    #---------------------------------------------------------------------------
+    def initialize(handler, columns = {})
+      @handler = nil
+      @call_method = { :method => nil, args => nil }
+      @columns = {}
+    end
+
+  end
+
+end

data/unique_delayed_job.gemspec

@@ -0,0 +1,49 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{unique_delayed_job}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Brian Percival"]
+  s.date = %q{2009-11-18}
+  s.description = %q{Class for creating delayed jobs that can be de-duped with existing delayed jobs
+already in the delayed jobs table. You just specify some additional columns on
+your delayed_jobs table and set them to have uniqueness constraints. Then
+specify these column values when you create a UniqueDelayedJob and if a
+duplicate key is raised on insert, then the insert will just be ignored. There
+are factory methods for creating a delayed job in the following ways:
+* with a delayed job handler class (one that responds to perform())
+* with an object, method and method arguments
+* with a code block
+
+NOTE: you must have delayed_job installed as a gem or plugin
+}
+  s.email = %q{percivalatumamibuddotcom}
+  s.extra_rdoc_files = [
+    "README"
+  ]
+  s.files = [
+    "lib/unique_delayed_job.rb",
+     "unique_delayed_job.gemspec"
+  ]
+  s.homepage = %q{http://github.com/bmpercy/unique_delayed_job}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Class for inserting delayed jobs without duplication}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: unique_delayed_job
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Brian Percival
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-18 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: |
+  Class for creating delayed jobs that can be de-duped with existing delayed jobs
+  already in the delayed jobs table. You just specify some additional columns on
+  your delayed_jobs table and set them to have uniqueness constraints. Then
+  specify these column values when you create a UniqueDelayedJob and if a
+  duplicate key is raised on insert, then the insert will just be ignored. There
+  are factory methods for creating a delayed job in the following ways:
+  * with a delayed job handler class (one that responds to perform())
+  * with an object, method and method arguments
+  * with a code block
+  
+  NOTE: you must have delayed_job installed as a gem or plugin
+
+email: percivalatumamibuddotcom
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- lib/unique_delayed_job.rb
+- unique_delayed_job.gemspec
+- README
+has_rdoc: true
+homepage: http://github.com/bmpercy/unique_delayed_job
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Class for inserting delayed jobs without duplication
+test_files: []
+